The final result I am happy with

Author: wpdevelopment11

.gitignore

@@ -0,0 +1,2 @@
+*.pyc
+__pycache__

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 wpdevelopment11
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,119 @@
+## Description
+
+Find the fenced code blocks in the Markdown file that don't have the language specified.
+Detect the language from the block contents and insert the language name after the starting fence.
+Print the resulting code blocks or edit the files in-place.
+
+Under the hood it uses [Magika](https://github.com/google/magika) (recommended) or [Guesslang](https://github.com/yoeo/guesslang) deep learning models to detect the language.
+
+Tested on Windows and Linux.
+
+## Install
+
+```bash
+git clone https://github.com/wpdevelopment11/codeblocks
+cd codeblocks
+python3 -m venv .venv
+source .venv/bin/activate
+
+# Install one of them:
+pip install magika==0.6.1 # Recommended
+# Or
+pip install guesslang # May not work,
+                      # depending on your Python version
+                      # and OS combination.
+```
+
+> **Note:** <a id="guesslang"></a>
+> [Guesslang](https://github.com/yoeo/guesslang) is not maintained. I got it working on Windows with Python 3.10.
+>
+> First `pip install tensorflow==2.13`.
+>
+> Next, copy [guesslang directory](https://github.com/yoeo/guesslang/tree/master/guesslang) to the top-level directory of your project.
+> Start the Python shell with `python` and run `import guesslang` to check if it's installed properly.
+
+## Usage
+
+```bash
+python3 codeblocks.py [--edit] path ...
+```
+
+* `--edit`
+
+  Edit files by inserting the language.
+  By default, files are not modified,
+  instead code blocks for which the language can be detected are printed to the terminal.
+
+* `path`
+
+  Paths to process.
+  Can be Markdown files or directories, or any combination of them.
+  Directories are processed recursively.
+
+### Insert the language names in all Markdown files in directory
+
+This command will edit your files, make a backup.
+
+```bash
+python3 codeblocks.py --edit /path/to/dir
+```
+
+### Insert the language names in specified file(s) only
+
+```bash
+python3 codeblocks.py --edit /path/to/file.md
+```
+
+### Print code blocks with the detected language, without modifying files
+
+```bash
+python3 codeblocks.py /path/to/file.md
+```
+
+## Run tests
+
+```bash
+python3 -m unittest discover test
+```
+
+## Limitations
+
+* Line that consists of three or more backticks is always detected as a fenced code block.
+Normal Markdown parsers consider them as such only if up to three spaces of indentation are used outside of a list item,
+and up to seven spaces otherwise.
+
+## Motivation
+
+The language names in the fenced code blocks are commonly used for syntax highlighting.
+
+Some people forget to or don't know how to specify the language.
+This leads to a code that is not highlighted and hard to read.
+This script is intended to solve that issue.
+
+Example:
+
+* Before:
+
+  ````
+  ```
+  def print_table():
+      for num in range(10):
+          sqr = num * num
+          print(f"{num}^2\t= {sqr}")
+
+  print_table()
+  ```
+  ````
+
+* After:
+
+  ````python
+  ```python
+  def print_table():
+      for num in range(10):
+          sqr = num * num
+          print(f"{num}^2\t= {sqr}")
+
+  print_table()
+  ```
+  ````

codeblocks.py

@@ -1,28 +1,30 @@
-import glob
-import sys
-import os.path
-
 from enum import Enum
+from itertools import chain
 from tempfile import NamedTemporaryFile
-from shutil import copy
-from os import unlink
+
+import argparse
+import glob
+import os
+import os.path
+import re
+import shutil
+import sys
 
 class Codeblock(Enum):
     IN = 1
     IN_WITH_LANG = 2
     OUT = 3
 
+INTLINE_PATTERN = re.compile("```+[^`]+`")
 DEFAULT_LANG = "txt"
-EDIT_FILES = True
 
 try:
     from magika import Magika
     magika = Magika()
     def guess_language(code):
         codebytes = code.encode(encoding="utf-8")
         lang = magika.identify_bytes(codebytes).prediction.output.label
-        if lang == "unknown": return DEFAULT_LANG
-        return lang
+        return lang if lang != "unknown" else DEFAULT_LANG
 except ImportError:
     try:
         from guesslang import Guess
@@ -34,61 +36,86 @@ def guess_language(code):
         print("Magika or Guesslang is required to run this script. Install one of them to proceed!")
         sys.exit(1)
 
-if len(sys.argv) != 2:
-    print("Usage: python codeblocks.py dir")
-    sys.exit(1)
+def add_language(files, edit_files):
+    def is_made_of_char(str, char):
+        return len(str) == str.count(char)
+    # newline="" is important. See below.
+    temp = NamedTemporaryFile("w+", encoding="utf-8", newline="", delete=False)
+    for file in files:
+        blockstate = Codeblock.OUT
+        code = []
+        # The argument newline="" is important here and in the NamedTemporaryFile() call above.
+        # We don't want to change line endings in a file which we're editing.
+        with open(file, encoding="utf-8", newline="") as f:
+            for linenum, line in enumerate(f, 1):
+                stripped = line.strip()
+                if stripped.startswith("```") and not INTLINE_PATTERN.match(stripped) \
+                and (blockstate == Codeblock.OUT or is_made_of_char(stripped, "`") and len(stripped) >= backticks_num):
+                    if  blockstate == Codeblock.IN_WITH_LANG:
+                        blockstate = Codeblock.OUT
+                        if edit_files: temp.write(line)
+                    elif blockstate == Codeblock.IN:
+                        blockstate = Codeblock.OUT
+                        code_str = "\n".join(line.removeprefix(indent).rstrip() for line in code) + "\n"
+                        lang = guess_language(code_str) if code_str else ""
+                        if edit_files:
+                            # When editing files, txt is not very useful edit.
+                            if lang == "txt": lang = ""
+                            fence_start = "`" * backticks_num
+                            temp.write(fence.replace(fence_start, fence_start + lang))
+                            temp.writelines(code)
+                            temp.write(line)
+                        elif lang:
+                            print(f"{file}:{linenum - len(code) - 1}")
+                            print(("`" * backticks_num) + lang + "\n" + code_str + stripped)
+                            print()
+                        code = []
+                    elif is_made_of_char(stripped, "`"):
+                        backticks_num = len(stripped)
+                        blockstate = Codeblock.IN
+                        count = len(line) - len(line.lstrip())
+                        indent = line[:count]
+                        fence = line
+                    else:
+                        backticks_num = stripped.count("`")
+                        blockstate = Codeblock.IN_WITH_LANG
+                        if edit_files: temp.write(line)
+                elif blockstate == Codeblock.IN:
+                    code.append(line)
+                elif edit_files:
+                    temp.write(line)
+            if edit_files:
+                if code:
+                    # non-terminated fence
+                    temp.write(fence)
+                    temp.writelines(code)
+                temp.flush()
+                shutil.copy(temp.name, file)
+                temp.seek(0)
+                temp.truncate(0)
+    temp.close()
+    os.unlink(temp.name)
 
-files = glob.iglob("**/*.md", root_dir=sys.argv[1], recursive=True)
-# newline="" is important. See below.
-temp = NamedTemporaryFile("w+", encoding="utf-8", newline="", delete=False)
+def main():
+    parser = argparse.ArgumentParser(description="Detect and insert the language in the Markdown code blocks.")
+    parser.add_argument("--edit", action="store_true", help="Edit files by inserting the language")
+    parser.add_argument("path", nargs="+", help="Paths to process")
+    args = parser.parse_args()
 
-for file in files:
-    fullpath = os.path.join(sys.argv[1], file)
-    blockstate = Codeblock.OUT
-    code = []
-    fence = ""
-    # The argument newline="" is important here and in the NamedTemporaryFile() call above.
-    # We don't want to change line endings in a file which we're editing.
-    for linenum, line in enumerate(open(fullpath, encoding="utf-8", newline=""), 1):
-        if line.strip().startswith("```"):
-            if  blockstate == Codeblock.IN_WITH_LANG:
-                blockstate = Codeblock.OUT
-                if EDIT_FILES: temp.write(line)
-            elif blockstate == Codeblock.IN:
-                blockstate = Codeblock.OUT
-                indent = len(fence) - len(fence.lstrip())
-                code_str = "\n".join(line[indent:].strip() for line in code) + "\n"
-                lang = guess_language(code_str) if code_str else ""
-                if EDIT_FILES:
-                    # When editing files, txt is not very useful edit.
-                    if lang == "txt": lang = ""
-                    temp.write(fence.replace("```", f"```{lang}"))
-                    temp.writelines(code)
-                    temp.write(line)
-                elif lang:
-                    print(f"{fullpath}:{linenum - len(code) - 1}")
-                    print(f"```{lang}\n" + code_str + "```")
-                    print()
-                code = []
-            elif line.strip() == "```":
-                blockstate = Codeblock.IN
-                fence = line
-            else:
-                blockstate = Codeblock.IN_WITH_LANG
-                if EDIT_FILES: temp.write(line)
-        elif blockstate == Codeblock.IN:
-            code.append(line)
-        elif EDIT_FILES:
-            temp.write(line)
-    if EDIT_FILES:
-        if code:
-            # non-terminated fence
-            temp.write(fence)
-            temp.writelines(code)
-        temp.flush()
-        copy(temp.name, fullpath)
-        temp.seek(0)
-        temp.truncate(0)
+    files = []
+    iters = []
+
+    for path in args.path:
+        if os.path.isfile(path):
+            files.append(path)
+        elif os.path.isdir(path):
+            iters.append(glob.iglob(os.path.join(path, "**", "*.md"), recursive=True))
+        else:
+            print(f"Path doesn't exist: \"{path}\"")
+            sys.exit(1)
+
+    iters.append(iter(files))
+    add_language(chain.from_iterable(iters), args.edit)
 
-temp.close()
-unlink(temp.name)
+if __name__ == "__main__":
+    main()

test/files/block_termination.md

@@ -0,0 +1,15 @@
+```
+
+```blah
+
+import os
+
+def foo():
+    for i in range(10):
+        print(i)
+
+def foobar():
+    pass
+
+foo()
+```

test/files/block_termination_result.md

@@ -0,0 +1,15 @@
+```python
+
+```blah
+
+import os
+
+def foo():
+    for i in range(10):
+        print(i)
+
+def foobar():
+    pass
+
+foo()
+```

test/files/inline_code.md

@@ -0,0 +1,14 @@
+```console.log("I like JavaScript");```
+
+```
+import os
+
+def foo():
+    for i in range(10):
+        print(i)
+
+def foobar():
+    pass
+
+foo()
+```

test/files/inline_code_result.md

@@ -0,0 +1,14 @@
+```console.log("I like JavaScript");```
+
+```python
+import os
+
+def foo():
+    for i in range(10):
+        print(i)
+
+def foobar():
+    pass
+
+foo()
+```