comic-ocr-reader 0.0.5__tar.gz → 1.0.3__tar.gz

{comic_ocr_reader-0.0.5 → comic_ocr_reader-1.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: comic_ocr_reader
-Version: 0.0.5
+Version: 1.0.3
 Summary: A Python package made for processing Japanese manga into a format usable with web-based on-screen dictionaries like Yomitan.
 Project-URL: Homepage, https://github.com/HagantaRG/comic-ocr
 Author-email: HRG <rhaganta@gmail.com>
@@ -27,11 +27,11 @@ pip install comic-ocr-reader
 ```
 Once that it is installed (it may take some time, there are large dependencies in there) you should then run:
 ```
-comic-ocr-reader
+comic_ocr_reader
 ```
 Or if that doesn't work:
 ```
-python3 -m comic-ocr-reader
+python3 -m comic_ocr_reader
 ```
 ## Usage
 1. Prepare a folder containing the images you would like to process. As of v.0.0.1 the images in this folder must be named the page number you would like that image to be.

{comic_ocr_reader-0.0.5 → comic_ocr_reader-1.0.3}/README.md

@@ -8,11 +8,11 @@ pip install comic-ocr-reader
 ```
 Once that it is installed (it may take some time, there are large dependencies in there) you should then run:
 ```
-comic-ocr-reader
+comic_ocr_reader
 ```
 Or if that doesn't work:
 ```
-python3 -m comic-ocr-reader
+python3 -m comic_ocr_reader
 ```
 ## Usage
 1. Prepare a folder containing the images you would like to process. As of v.0.0.1 the images in this folder must be named the page number you would like that image to be.

{comic_ocr_reader-0.0.5 → comic_ocr_reader-1.0.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "comic_ocr_reader"
-version = "0.0.5"
+version = "1.0.3"
 authors = [
   { name="HRG", email="rhaganta@gmail.com" },
 ]

{comic_ocr_reader-0.0.5 → comic_ocr_reader-1.0.3}/src/comic_ocr_reader/__main__.py

@@ -9,6 +9,7 @@ from manga_ocr import MangaOcr
 
 from comic_ocr_reader.html_utils import Page, make_html_file
 from comic_ocr_reader.functions import process_page
+from comic_ocr_reader.functions.model_init import ensure_models_initialised
 
 VALID_EXTENSIONS: Final[list[str]] = [
         "jpg",
@@ -19,6 +20,14 @@ VALID_EXTENSIONS: Final[list[str]] = [
 ]
 logger.disable("manga_ocr")
 
+
+def print_main_menu() -> None:
+    print(
+        'Hello! Please type in "help" to see a list of commands. '
+        'Otherwise, please type in a valid command.'
+    )
+
+
 def main(
         folder_path: str,
         manga_name: str = ...
@@ -45,12 +54,19 @@ def main(
         print("One of the image files in the folder you have entered has a non-integer name. (e.g. 123abc.jpeg instead of 123.jpeg)\n"
               "All image files within the folder *must* have an integer name for ordering purposes.")
         return False
+
+    print("=== Initialisation ===")
+    ensure_models_initialised()
+
+    print("=== OCR setup ===")
     detector = Reader(
         lang_list=['ja'],
         recognizer=False,
         gpu=True
     )
     recogniser = MangaOcr()
+
+    print("=== OCR processing ===")
     for file in tqdm(images):
         page_num += 1
         process_page(
@@ -67,38 +83,41 @@ def main(
         f.flush()
     return True
 
-if __name__ == "__main__":
+
+def run() -> None:
     while True:
         try:
-            user_input: str = input(
-                f"Hello! Please type in \"help\" to see a list of commands. Otherwise, please type in a valid command.\n"
-            )
-            user_input = user_input.strip()
+            print_main_menu()
+            user_input: str = input().strip().lower()
             match user_input:
                 case "help":
                     print(
                         """
         The valid commands are:
-        - folder 
+        - folder
             Allows you to specify a folder containing the image files for the manga you want to process.
             Also optionally allows you to give the manga a name. Otherwise the folder name will be used.
-            Supported file formats for images in folder: .jpg, .jpeg, .png, .bmp, .tiff 
-        And of course, 
-        - help 
-        Which you are currently using.
+            Supported file formats for images in folder: .jpg, .jpeg, .png, .bmp, .tiff
+        And of course,
+        - help
+            Which you are currently using.
                         """
                     )
                 case "folder":
                     target_folder: str = input("Please input a target folder.\n")
                     if os.path.isdir(target_folder):
                         if main(target_folder):
-                            print("Success! Please press Ctrl+C to exit.")
+                            print("Success! Returning to the main menu.")
                         else:
-                            print("Something went wrong.")
+                            print("Something went wrong. Returning to the main menu.")
                     else:
-                        print("Please input a valid folder.")
+                        print("Please input a valid folder. Returning to the main menu.")
                 case _:
-                    print("That was not a valid command.")
+                    print("That was not a valid command. Returning to the main menu.")
         except KeyboardInterrupt:
             print("\nGoodbye!")
-            exit(0)
+            return
+
+
+if __name__ == "__main__":
+    run()

comic_ocr_reader-1.0.3/src/comic_ocr_reader/functions/model_init.py

@@ -0,0 +1,92 @@
+from __future__ import annotations
+
+import hashlib
+from pathlib import Path
+from typing import Callable, Optional
+
+from easyocr import Reader
+from easyocr.config import MODULE_PATH as EASYOCR_MODULE_PATH, detection_models as EASYOCR_DETECTION_MODELS
+from manga_ocr import MangaOcr
+
+EASYOCR_DETECTOR_NAME = "craft"
+EASYOCR_DETECTOR_MODEL = Path(EASYOCR_MODULE_PATH) / "model" / EASYOCR_DETECTION_MODELS[EASYOCR_DETECTOR_NAME]["filename"]
+
+MANGA_OCR_REPO = (
+    Path.home()
+    / ".cache"
+    / "huggingface"
+    / "hub"
+    / "models--kha-white--manga-ocr-base"
+)
+MANGA_OCR_REQUIRED_FILES = (
+    "config.json",
+    "preprocessor_config.json",
+    "pytorch_model.bin",
+    "special_tokens_map.json",
+    "tokenizer_config.json",
+    "vocab.txt",
+)
+
+
+def _file_md5(path: Path) -> str:
+    digest = hashlib.md5()
+    with path.open("rb") as file_handle:
+        for chunk in iter(lambda: file_handle.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def easyocr_detector_is_initialised(model_path: Path = EASYOCR_DETECTOR_MODEL) -> bool:
+    expected_md5 = EASYOCR_DETECTION_MODELS[EASYOCR_DETECTOR_NAME]["md5sum"]
+    return model_path.is_file() and _file_md5(model_path) == expected_md5
+
+
+def manga_ocr_is_initialised(repo_path: Path = MANGA_OCR_REPO) -> bool:
+    refs_main = repo_path / "refs" / "main"
+    if not refs_main.is_file():
+        return False
+
+    snapshot_hash = refs_main.read_text(encoding="utf-8").strip()
+    if not snapshot_hash:
+        return False
+
+    snapshot_dir = repo_path / "snapshots" / snapshot_hash
+    if not snapshot_dir.is_dir():
+        return False
+
+    return all((snapshot_dir / filename).is_file() for filename in MANGA_OCR_REQUIRED_FILES)
+
+
+def models_are_initialised(
+    easyocr_model_path: Path = EASYOCR_DETECTOR_MODEL,
+    manga_repo_path: Path = MANGA_OCR_REPO,
+) -> bool:
+    return easyocr_detector_is_initialised(easyocr_model_path) and manga_ocr_is_initialised(manga_repo_path)
+
+
+def _download_easyocr_detector() -> None:
+    Reader(lang_list=["ja"], recognizer=False, gpu=True, detect_network=EASYOCR_DETECTOR_NAME)
+
+
+def _download_manga_ocr() -> None:
+    MangaOcr()
+
+
+def ensure_models_initialised(
+    easyocr_model_path: Path = EASYOCR_DETECTOR_MODEL,
+    manga_repo_path: Path = MANGA_OCR_REPO,
+    easyocr_factory: Optional[Callable[[], None]] = None,
+    manga_factory: Optional[Callable[[], None]] = None,
+) -> bool:
+    if models_are_initialised(easyocr_model_path, manga_repo_path):
+        print("Not required! You have already initialised.")
+        return False
+
+    if not easyocr_detector_is_initialised(easyocr_model_path):
+        (easyocr_factory or _download_easyocr_detector)()
+
+    if not manga_ocr_is_initialised(manga_repo_path):
+        (manga_factory or _download_manga_ocr)()
+
+    print("Initialisation complete.")
+    return True

comic_ocr_reader-1.0.3/tests/test_main_flow.py

@@ -0,0 +1,46 @@
+import builtins
+import contextlib
+import io
+import unittest
+from pathlib import Path
+from unittest.mock import mock_open, patch
+
+from comic_ocr_reader import __main__ as cli
+
+
+class MainFlowTests(unittest.TestCase):
+    def test_main_runs_initialisation_before_ocr_processing(self):
+        folder = r"C:\fake\folder"
+        output = io.StringIO()
+
+        with patch.object(cli, "ensure_models_initialised") as init_mock:
+            with patch.object(cli, "Reader") as reader_mock:
+                with patch.object(cli, "MangaOcr") as manga_mock:
+                    with patch.object(cli, "process_page") as process_page_mock:
+                        with patch.object(cli, "make_html_file", return_value="<html></html>"):
+                            with patch.object(cli, "tqdm", side_effect=lambda items: items):
+                                with patch.object(cli.os.path, "isdir", return_value=True):
+                                    with patch.object(cli.os, "listdir", return_value=["1.jpg"]):
+                                        with patch.object(Path, "is_file", return_value=True):
+                                            with patch.object(builtins, "open", mock_open()):
+                                                reader_mock.return_value = object()
+                                                manga_mock.return_value = object()
+                                                with contextlib.redirect_stdout(output):
+                                                    result = cli.main(folder)
+
+        self.assertTrue(result)
+        init_mock.assert_called_once()
+        reader_mock.assert_called_once()
+        manga_mock.assert_called_once()
+        process_page_mock.assert_called_once()
+
+        rendered = output.getvalue()
+        self.assertIn("=== Initialisation ===", rendered)
+        self.assertIn("=== OCR setup ===", rendered)
+        self.assertIn("=== OCR processing ===", rendered)
+        self.assertLess(rendered.index("=== Initialisation ==="), rendered.index("=== OCR setup ==="))
+        self.assertLess(rendered.index("=== OCR setup ==="), rendered.index("=== OCR processing ==="))
+
+
+if __name__ == "__main__":
+    unittest.main()

comic_ocr_reader-1.0.3/tests/test_model_init.py

@@ -0,0 +1,48 @@
+import contextlib
+import io
+import unittest
+from unittest.mock import patch
+
+from comic_ocr_reader.functions import model_init
+
+
+class ModelInitTests(unittest.TestCase):
+    def test_ensure_models_initialised_prints_noop_message_when_ready(self):
+        with patch.object(model_init, "models_are_initialised", return_value=True):
+            with patch.object(model_init, "_download_easyocr_detector") as easyocr_factory:
+                with patch.object(model_init, "_download_manga_ocr") as manga_factory:
+                    buffer = io.StringIO()
+                    with contextlib.redirect_stdout(buffer):
+                        result = model_init.ensure_models_initialised()
+
+        self.assertFalse(result)
+        self.assertEqual(buffer.getvalue(), "Not required! You have already initialised.\n")
+        easyocr_factory.assert_not_called()
+        manga_factory.assert_not_called()
+
+    def test_ensure_models_initialised_calls_missing_factories(self):
+        with patch.object(model_init, "models_are_initialised", return_value=False):
+            with patch.object(model_init, "easyocr_detector_is_initialised", return_value=False):
+                with patch.object(model_init, "manga_ocr_is_initialised", return_value=False):
+                    calls = []
+
+                    def easyocr_factory():
+                        calls.append("easyocr")
+
+                    def manga_factory():
+                        calls.append("manga")
+
+                    buffer = io.StringIO()
+                    with contextlib.redirect_stdout(buffer):
+                        result = model_init.ensure_models_initialised(
+                            easyocr_factory=easyocr_factory,
+                            manga_factory=manga_factory,
+                        )
+
+        self.assertTrue(result)
+        self.assertEqual(calls, ["easyocr", "manga"])
+        self.assertEqual(buffer.getvalue(), "Initialisation complete.\n")
+
+
+if __name__ == "__main__":
+    unittest.main()