GameSentenceMiner 2.14.9__py3-none-any.whl → 2.14.10__py3-none-any.whl

GameSentenceMiner/util/downloader/oneocr_dl.py

@@ -0,0 +1,250 @@
+import os
+import time
+import zipfile
+import shutil
+from os.path import expanduser
+
+import requests
+import re
+import tempfile
+
+# Placeholder functions/constants for removed proprietary ones
+# In a real application, you would replace these with appropriate logic
+# or standard library equivalents.
+
+def checkdir(d):
+    """Checks if a directory exists and contains the expected files."""
+    flist = ["oneocr.dll", "oneocr.onemodel", "onnxruntime.dll"]
+    return os.path.isdir(d) and all((os.path.isfile(os.path.join(d, _)) for _ in flist))
+
+def selectdir():
+    """Attempts to find the SnippingTool directory, prioritizing cache."""
+    cachedir = "cache/SnippingTool"
+    packageFamilyName = "Microsoft.ScreenSketch_8wekyb3d8bbwe"
+
+    if checkdir(cachedir):
+        return cachedir
+    # This part needs NativeUtils.GetPackagePathByPackageFamily, which is proprietary.
+    # We'll skip this part for simplification as requested.
+    # path = NativeUtils.GetPackagePathByPackageFamily(packageFamilyName)
+    # if not path:
+    #     return None
+    # path = os.path.join(path, "SnippingTool")
+    # if not checkdir(path):
+    #     return None
+    # return path
+    return None # Return None if not found in cache
+
+def getproxy():
+    """Placeholder for proxy retrieval."""
+    # Replace with actual proxy retrieval logic or return None
+    return None
+
+def stringfyerror(e):
+    """Placeholder for error stringification."""
+    return str(e)
+
+def dynamiclink(path):
+    """Placeholder for dynamic link resolution."""
+    # This would likely map a resource path to a local file path.
+    # For simplification, we'll just use the provided path string.
+    return path # Assuming path is a URL here based on usage
+
+# Simplified download logic extracted from the question class
+class Downloader:
+    def __init__(self):
+        self.oneocr_dir = expanduser("~/.config/oneocr")
+        self.packageFamilyName = "Microsoft.ScreenSketch_8wekyb3d8bbwe"
+        self.flist = ["oneocr.dll", "oneocr.onemodel", "onnxruntime.dll"]
+
+    def download_and_extract(self):
+        """
+        Main function to attempt download and extraction.
+        Tries official source first, then a fallback URL.
+        """
+        if checkdir(self.oneocr_dir):
+            print("Files already exist in cache.")
+            return True
+
+        try:
+            print("Attempting to download from official source...")
+            # raise Exception("")
+            self.downloadofficial()
+            print("Download and extraction from official source successful.")
+            return True
+        except Exception as e:
+            print(f"Download from official source failed: {stringfyerror(e)}")
+            print("Attempting to download from fallback URL...")
+            try:
+                fallback_url = "https://gsm.beangate.us/oneocr.zip"
+                self.downloadx(fallback_url)
+                print("Download and extraction from fallback URL successful.")
+                return True
+            except Exception as e_fallback:
+                print(f"Download from fallback URL failed: {stringfyerror(e_fallback)}")
+                print("All download attempts failed.")
+                return False
+
+
+    def downloadofficial(self):
+        """Downloads the latest SnippingTool MSIX bundle from a store API."""
+        headers = {
+            "accept": "*/*",
+            # Changed accept-language to prioritize US English
+            "accept-language": "en-US,en;q=0.9",
+            "cache-control": "no-cache",
+            "origin": "https://store.rg-adguard.net",
+            "pragma": "no-cache",
+            "priority": "u=1, i",
+            "referer": "https://store.rg-adguard.net/",
+            "sec-ch-ua": '"Chromium";v="134", "Not:A-Brand";v="24", "Google Chrome";v="134"',
+            "sec-ch-ua-mobile": "?0",
+            "sec-ch-ua-platform": '"Windows"',
+            "sec-fetch-dest": "empty",
+            "sec-fetch-mode": "cors",
+            "sec-fetch-site": "same-origin",
+            "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36",
+        }
+
+        data = dict(type="PackageFamilyName", url=self.packageFamilyName)
+
+        response = requests.post(
+            "https://store.rg-adguard.net/api/GetFiles",
+            headers=headers,
+            data=data,
+            proxies=getproxy(),
+        )
+        response.raise_for_status() # Raise an exception for bad status codes
+
+        saves = []
+        for link, package in re.findall('<a href="(.*?)".*?>(.*?)</a>', response.text):
+            if not package.startswith("Microsoft.ScreenSketch"):
+                continue
+            if not package.endswith(".msixbundle"):
+                continue
+            version = re.search(r"\d+\.\d+\.\d+\.\d+", package)
+            if not version:
+                continue
+            version = tuple(int(_) for _ in version.group().split("."))
+            saves.append((version, link, package))
+
+        if not saves:
+            raise Exception("Could not find suitable download link from official source.")
+
+        saves.sort(key=lambda _: _[0])
+        url = saves[-1][1]
+        package_name = saves[-1][2]
+
+        print(f"Downloading {package_name} from {url}")
+        req = requests.get(url, stream=True, proxies=getproxy())
+        req.raise_for_status()
+
+        total_size_in_bytes = int(req.headers.get('content-length', 0))
+        block_size = 1024 * 32 # 32 Kibibytes
+        temp_msixbundle_path = os.path.join(tempfile.gettempdir(), package_name)
+
+        with open(temp_msixbundle_path, "wb") as ff:
+            downloaded_size = 0
+            for chunk in req.iter_content(chunk_size=block_size):
+                ff.write(chunk)
+                downloaded_size += len(chunk)
+                # Basic progress reporting (can be removed)
+                if total_size_in_bytes:
+                    progress = (downloaded_size / total_size_in_bytes) * 100
+                    print(f"Downloaded {downloaded_size}/{total_size_in_bytes} bytes ({progress:.2f}%)", end='\r')
+        print("\nDownload complete. Extracting...")
+
+        namemsix = None
+        with zipfile.ZipFile(temp_msixbundle_path) as ff:
+            for name in ff.namelist():
+                if name.startswith("SnippingTool") and name.endswith("_x64.msix"):
+                    namemsix = name
+                    break
+            if not namemsix:
+                raise Exception("Could not find MSIX file within MSIXBUNDLE.")
+            temp_msix_path = os.path.join(tempfile.gettempdir(), namemsix)
+            ff.extract(namemsix, tempfile.gettempdir())
+
+        print(f"Extracted {namemsix}. Extracting components...")
+        if os.path.exists(self.oneocr_dir):
+             shutil.rmtree(self.oneocr_dir)
+        os.makedirs(self.oneocr_dir, exist_ok=True)
+
+        with zipfile.ZipFile(temp_msix_path) as ff:
+            collect = []
+            for name in ff.namelist():
+                # Extract only the files within the "SnippingTool/" directory
+                if name.startswith("SnippingTool/") and any(name.endswith(f) for f in self.flist):
+                     # Construct target path relative to cachedir
+                    target_path = os.path.join(self.oneocr_dir, os.path.relpath(name, "SnippingTool/"))
+                    # Ensure parent directories exist
+                    os.makedirs(os.path.dirname(target_path), exist_ok=True)
+                    # Extract the file
+                    with ff.open(name) as source, open(target_path, "wb") as target:
+                        shutil.copyfileobj(source, target)
+                    collect.append(name)
+            if not collect:
+                 raise Exception("Could not find required files within MSIX.")
+
+
+        if not checkdir(self.oneocr_dir):
+            raise Exception("Extraction failed: Required files not found in cache directory.")
+
+        # Clean up temporary files
+        os.remove(temp_msixbundle_path)
+        os.remove(temp_msix_path)
+
+
+    def downloadx(self, url: str):
+        """Downloads a zip file from a URL and extracts it."""
+        print(f"Downloading from fallback URL")
+        # Added accept-language to the fallback download as well for consistency
+        headers = {
+             "accept-language": "en-US,en;q=0.9",
+             # Add other relevant headers if necessary for the fallback URL
+             "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36",
+             "accept": "*/*",
+        }
+        req = requests.get(url, verify=False, proxies=getproxy(), stream=True, headers=headers)
+        req.raise_for_status()
+
+        total_size_in_bytes = int(req.headers.get('content-length', 0))
+        block_size = 1024 * 32 # 32 Kibibytes
+        temp_zip_path = os.path.join(tempfile.gettempdir(), url.split("/")[-1])
+
+        with open(temp_zip_path, "wb") as ff:
+            downloaded_size = 0
+            for chunk in req.iter_content(chunk_size=block_size):
+                ff.write(chunk)
+                downloaded_size += len(chunk)
+                 # Basic progress reporting (can be removed)
+                if total_size_in_bytes:
+                    progress = (downloaded_size / total_size_in_bytes) * 100
+                    print(f"Downloaded {downloaded_size}/{total_size_in_bytes} bytes ({progress:.2f}%)", end='\r')
+        print("\nDownload complete. Extracting...")
+
+        if os.path.exists(self.oneocr_dir):
+             shutil.rmtree(self.oneocr_dir)
+        os.makedirs(self.oneocr_dir, exist_ok=True)
+
+        with zipfile.ZipFile(temp_zip_path) as zipf:
+            zipf.extractall(self.oneocr_dir)
+
+        if not checkdir(self.oneocr_dir):
+            raise Exception("Extraction failed: Required files not found in cache directory.")
+
+        # Clean up temporary files
+        os.remove(temp_zip_path)
+
+# Example usage:
+if __name__ == "__main__":
+    downloader = Downloader()
+    downloader.download_and_extract()
+    # if downloader.download_and_extract():
+    #     print("SnippingTool files are ready.")
+    #     print("Press Ctrl+C or X on window to exit.")
+    #     # input()
+    # else:
+    #     # print("Failed to download and extract SnippingTool files. You may need to follow instructions at https://github.com/AuroraWright/oneocr")
+    #     print("Press Ctrl+C or X on window to exit.")
+    #     input()

GameSentenceMiner/util/electron_config.py

@@ -0,0 +1,259 @@
+import json
+import os
+from dataclasses import dataclass, field
+from typing import List, Optional
+from dataclasses_json import dataclass_json
+
+from GameSentenceMiner.util.configuration import get_app_directory, logger
+
+
+# @dataclass_json
+# @dataclass
+# class SteamGame:
+#     id: str = ''
+#     name: str = ''
+#     processName: str = ''
+#     script: str = ''
+
+@dataclass_json
+@dataclass
+class YuzuConfig:
+    emuPath: str = "C:\\Emulation\\Emulators\\yuzu-windows-msvc\\yuzu.exe"
+    romsPath: str = "C:\\Emulation\\Yuzu\\Games"
+    launchGameOnStart: str = ""
+    lastGameLaunched: str = ""
+
+@dataclass_json
+@dataclass
+class VNConfig:
+    vns: List[str] = field(default_factory=list)
+    textractorPath: str = ""
+    launchVNOnStart: str = ""
+    lastVNLaunched: str = ""
+
+# @dataclass_json
+# @dataclass
+# class SteamConfig:
+#     steamPath: str = ""
+#     steamGames: List[SteamGame] = field(default_factory=list)
+#     launchSteamOnStart: int = 0
+#     lastGameLaunched: int = 0
+
+@dataclass_json
+@dataclass
+class OCRConfig:
+    twoPassOCR: bool = True
+    optimize_second_scan: bool = True
+    ocr1: str = "oneOCR"
+    ocr2: str = "glens"
+    window_name: str = ""
+    language: str = "ja"
+    ocr_screenshots: bool = False
+    furigana_filter_sensitivity: int = 0
+    manualOcrHotkey: str = "Ctrl+Shift+G"
+    areaSelectOcrHotkey: str = "Ctrl+Shift+O"
+    sendToClipboard: bool = True
+    scanRate: float = 0.5
+    requiresOpenWindow: bool = False
+    useWindowForConfig: bool = False
+    lastWindowSelected: str = ""
+    keep_newline: bool = False
+    useObsAsOCRSource: bool = True
+
+    def has_changed(self, other: 'OCRConfig') -> bool:
+        return self.to_dict() != other.to_dict()
+
+@dataclass_json
+@dataclass
+class StoreConfig:
+    yuzu: YuzuConfig = field(default_factory=YuzuConfig)
+    agentScriptsPath: str = "E:\\Japanese Stuff\\agent-v0.1.4-win32-x64\\data\\scripts"
+    textractorPath: str = "E:\\Japanese Stuff\\Textractor\\Textractor.exe"
+    startConsoleMinimized: bool = False
+    autoUpdateElectron: bool = True
+    autoUpdateGSMApp: bool = False
+    pythonPath: str = ""
+    VN: VNConfig = field(default_factory=VNConfig)
+    # steam: SteamConfig = field(default_factory=SteamConfig)
+    agentPath: str = ""
+    OCR: OCRConfig = field(default_factory=OCRConfig)
+
+class Store:
+    def __init__(self, config_path=os.path.join(get_app_directory(), "electron", "config.json"), defaults: Optional[StoreConfig] = None):
+        self.data: StoreConfig = StoreConfig()
+        self.config_path = config_path
+        self.defaults = defaults if defaults is not None else StoreConfig()
+        self._load_config()
+
+    def _load_config(self):
+        if os.path.exists(self.config_path):
+            while True:
+                try:
+                    with open(self.config_path, 'r', encoding='utf-8') as f:
+                        data = json.load(f)
+                        self.data = StoreConfig.from_dict(data)
+                    break
+                except (json.JSONDecodeError, IOError) as e:
+                    logger.debug(f"File being written to: {e}. Retrying...")
+        else:
+            self.data = self.defaults
+            self._save_config()
+
+    def _save_config(self):
+        with open(self.config_path, 'w', encoding='utf-8') as f:
+            json.dump(self.data.to_dict(), f, indent=4)
+
+    def reload_config(self):
+        self._load_config()
+
+    def get(self, key, default=None):
+        keys = key.split('.')
+        value = self.data
+        for k in keys:
+            if hasattr(value, '__dataclass_fields__') and k in value.__dataclass_fields__:
+                value = getattr(value, k)
+            else:
+                return default
+        return value
+
+    def set(self, key, value):
+        keys = key.split('.')
+        current = self.data
+        for i, k in enumerate(keys):
+            if i == len(keys) - 1:
+                setattr(current, k, value)
+            else:
+                if not hasattr(current, '__dataclass_fields__') or k not in current.__dataclass_fields__:
+                    return  # Key doesn't exist in the dataclass structure
+                if not hasattr(getattr(current, k), '__dataclass_fields__'):
+                    setattr(current, k, object()) # Create a new object if it's not a dataclass instance yet
+                current = getattr(current, k)
+        self._save_config()
+
+    def delete(self, key):
+        keys = key.split('.')
+        if not keys:
+            return False
+        current = self.data
+        for i, k in enumerate(keys[:-1]):
+            if not hasattr(current, '__dataclass_fields__') or k not in current.__dataclass_fields__:
+                return False
+            current = getattr(current, k)
+        if hasattr(current, keys[-1]):
+            delattr(current, keys[-1])
+            self._save_config()
+            return True
+        return False
+
+    def print_store(self):
+        """Prints the entire contents of the store in a readable JSON format."""
+        print(json.dumps(self.data.to_dict(), indent=4))
+
+# Initialize the store
+electron_store = Store(config_path=os.path.join(get_app_directory(), "electron", "config.json"), defaults=StoreConfig())
+
+
+# def has_section_changed(section_class: type) -> bool:
+#     global electron_store
+#     # Get the attribute name from the class (e.g. OCRConfig -> OCR)
+#     section_name = None
+#     for attr, value in StoreConfig.__dataclass_fields__.items():
+#         if value.type == section_class:
+#             section_name = attr
+#             break
+#     if not section_name:
+#         return False
+#     if not os.path.exists(electron_store.config_path):
+#         return False
+#     with open(electron_store.config_path, 'r', encoding='utf-8') as f:
+#         data = json.load(f)
+#         current = StoreConfig.from_dict(data)
+#         current_section = getattr(current, section_name)
+#         old_section = getattr(electron_store, section_name)
+#         if hasattr(current_section, 'to_dict') and hasattr(old_section, 'to_dict'):
+#             return current_section.to_dict() != old_section.to_dict()
+#         electron_store = Store(config_path=electron_store.config_path)
+#         return True
+
+# Helper Methods
+def get_electron_store() -> Store:
+    global electron_store
+    return electron_store
+
+def get_ocr_two_pass_ocr():
+    return electron_store.data.OCR.twoPassOCR
+
+def get_ocr_optimize_second_scan():
+    return electron_store.data.OCR.optimize_second_scan
+
+def get_ocr_ocr1():
+    return electron_store.data.OCR.ocr1
+
+def get_ocr_ocr2():
+    return electron_store.data.OCR.ocr2
+
+def get_ocr_window_name():
+    return electron_store.data.OCR.window_name or ""
+
+def get_ocr_language():
+    return electron_store.data.OCR.language or "ja"
+
+def get_ocr_ocr_screenshots():
+    return electron_store.data.OCR.ocr_screenshots
+
+def get_ocr_furigana_filter_sensitivity():
+    return electron_store.data.OCR.furigana_filter_sensitivity
+
+def get_ocr_manual_ocr_hotkey():
+    return electron_store.data.OCR.manualOcrHotkey
+
+def get_ocr_area_select_ocr_hotkey():
+    return electron_store.data.OCR.areaSelectOcrHotkey
+
+def get_ocr_send_to_clipboard():
+    return electron_store.data.OCR.sendToClipboard
+
+def get_ocr_scan_rate():
+    return electron_store.data.OCR.scanRate
+
+def get_ocr_requires_open_window():
+    return electron_store.data.OCR.requiresOpenWindow
+
+def get_ocr_use_window_for_config():
+    return electron_store.data.OCR.useWindowForConfig
+
+def get_ocr_last_window_selected():
+    return electron_store.data.OCR.lastWindowSelected
+
+def get_ocr_keep_newline():
+    return electron_store.data.OCR.keep_newline
+
+def get_ocr_use_obs_as_source():
+    return electron_store.data.OCR.useObsAsOCRSource
+
+def get_furigana_filter_sensitivity() -> int:
+    return electron_store.data.OCR.furigana_filter_sensitivity
+    
+def has_ocr_config_changed() -> bool:
+    global electron_store
+    if not os.path.exists(electron_store.config_path):
+        return False, {}
+    with open(electron_store.config_path, 'r', encoding='utf-8') as f:
+        data = json.load(f)
+        current = StoreConfig.from_dict(data)
+        current_section = current.OCR
+        old_section = electron_store.data.OCR
+    if not (hasattr(current_section, 'to_dict') and hasattr(old_section, 'to_dict')):
+        return False, {}
+    current_dict = current_section.to_dict()
+    old_dict = old_section.to_dict()
+    if current_dict != old_dict:
+        changes = {k: (old_dict[k], current_dict[k]) for k in current_dict if old_dict.get(k) != current_dict.get(k)}
+        # logger.info(f"OCR Config changes detected: {changes}")
+        return True, changes
+    return False, {}
+
+def reload_electron_config():
+    global electron_store
+    electron_store.reload_config()
+    return electron_store