GameSentenceMiner 2.10.12__py3-none-any.whl → 2.10.14__py3-none-any.whl

GameSentenceMiner/obs.py

@@ -135,7 +135,7 @@ def get_obs_websocket_config_values():
         full_config.save()
         reload_config()
 
-async def connect_to_obs(retry_count=0):
+async def connect_to_obs(retry=5):
     global client, obs_connection_manager, event_client, connecting
     if not get_config().obs.enabled:
         return
@@ -166,11 +166,18 @@ async def connect_to_obs(retry_count=0):
             update_current_game()
             break  # Exit the loop once connected
         except Exception as e:
+            if retry <= 0:
+                gsm_status.obs_connected = False
+                logger.error(f"Failed to connect to OBS WebSocket: {e}")
+                client = None
+                event_client = None
+                connecting = False
+                break
             await asyncio.sleep(1)
-            retry_count += 1
+            retry -= 1
     connecting = False
 
-def connect_to_obs_sync(retry_count=0):
+def connect_to_obs_sync(retry=2):
     global client, obs_connection_manager, event_client
     if not get_config().obs.enabled or client:
         return
@@ -198,8 +205,15 @@ def connect_to_obs_sync(retry_count=0):
             update_current_game()
             break  # Exit the loop once connected
         except Exception as e:
+            if retry <= 0:
+                gsm_status.obs_connected = False
+                logger.error(f"Failed to connect to OBS WebSocket: {e}")
+                client = None
+                event_client = None
+                connecting = False
+                break
             time.sleep(1)
-            retry_count += 1
+            retry -= 1
 
 
 def disconnect_from_obs():

GameSentenceMiner/ocr/owocr_area_selector.py

@@ -34,7 +34,7 @@ COORD_SYSTEM_PERCENTAGE = "percentage"
 
 
 class ScreenSelector:
-    def __init__(self, result, window_name):
+    def __init__(self, result, window_name, use_window_as_config):
         if not selector_available or not gw:
             raise RuntimeError("tkinter or pygetwindow is not available.")
         if not window_name:
@@ -60,6 +60,8 @@ class ScreenSelector:
         # ---
 
         self.root = None
+        self.scene = ''
+        self.use_window_as_config = use_window_as_config
         self.result = result
         self.rectangles = []  # Internal storage is ALWAYS absolute pixels for drawing
         self.drawn_rect_ids = []
@@ -94,11 +96,14 @@ class ScreenSelector:
         ocr_config_dir = app_dir / "ocr_config"
         ocr_config_dir.mkdir(parents=True, exist_ok=True)
         try:
-            scene = sanitize_filename(obs.get_current_scene() or "default_scene")
+            if self.use_window_as_config:
+                self.scene = sanitize_filename(self.window_name)
+            else:
+                self.scene = sanitize_filename(obs.get_current_scene() or "")
         except Exception as e:
             print(f"Error getting OBS scene: {e}. Using default config name.")
-            scene = "default_scene"
-        return ocr_config_dir / f"{scene}.json"
+            self.scene = ""
+        return ocr_config_dir / f"{self.scene}.json"
 
     def load_existing_rectangles(self):
         """Loads rectangles from config, converting from percentage to absolute pixels for use."""
@@ -170,7 +175,7 @@ class ScreenSelector:
             })
 
         save_data = {
-            "scene": obs.get_current_scene() or "default_scene",
+            "scene": self.scene or "",
             "window": self.window_name,
             "coordinate_system": COORD_SYSTEM_PERCENTAGE,  # Always save as percentage
             "window_geometry": win_geom,  # Save the geometry used for conversion
@@ -397,9 +402,9 @@ class ScreenSelector:
         self.root = None
 
 
-def run_screen_selector(result_dict, window_name):
+def run_screen_selector(result_dict, window_name, use_window_as_config):
     try:
-        selector = ScreenSelector(result_dict, window_name)
+        selector = ScreenSelector(result_dict, window_name, use_window_as_config)
         selector.start()
     except Exception as e:
         print(f"Error in selector process: {e}", file=sys.stderr)
@@ -408,7 +413,7 @@ def run_screen_selector(result_dict, window_name):
         result_dict['error'] = str(e)
 
 
-def get_screen_selection(window_name):
+def get_screen_selection(window_name, use_window_as_config=False):
     if not selector_available or not gw: return None
     if not window_name:
         print("Error: A target window name must be provided.", file=sys.stderr)
@@ -416,7 +421,7 @@ def get_screen_selection(window_name):
 
     with Manager() as manager:
         result_data = manager.dict()
-        process = Process(target=run_screen_selector, args=(result_data, window_name))
+        process = Process(target=run_screen_selector, args=(result_data, window_name, use_window_as_config))
         print(f"Starting ScreenSelector process...")
         process.start()
         process.join()
@@ -434,11 +439,15 @@ def get_screen_selection(window_name):
 
 if __name__ == "__main__":
     set_dpi_awareness()
-    target_window_title = "Windowed Projector (Preview)"  # Default
+    target_window_title = "YouTube - JP"
+    use_window_as_config = False
     if len(sys.argv) > 1:
         target_window_title = sys.argv[1]
+    if len(sys.argv) > 2:
+        use_window_as_config = True
+        target_window_title = sys.argv[1]
 
-    selection_result = get_screen_selection(target_window_title)
+    selection_result = get_screen_selection(target_window_title, use_window_as_config)
 
     if selection_result is None:
         print("\n--- Screen selection failed. ---")

GameSentenceMiner/ocr/owocr_helper.py

@@ -47,13 +47,16 @@ console_handler.setFormatter(formatter)
 logger.addHandler(console_handler)
 
 
-def get_ocr_config(window=None) -> OCRConfig:
+def get_ocr_config(window=None, use_window_for_config=False) -> OCRConfig:
     """Loads and updates screen capture areas from the corresponding JSON file."""
     app_dir = Path.home() / "AppData" / "Roaming" / "GameSentenceMiner"
     ocr_config_dir = app_dir / "ocr_config"
     os.makedirs(ocr_config_dir, exist_ok=True)
-    obs.connect_to_obs_sync()
-    scene = sanitize_filename(obs.get_current_scene())
+    obs.connect_to_obs_sync(retry=0)
+    if use_window_for_config and window:
+        scene = sanitize_filename(window)
+    else:
+        scene = sanitize_filename(obs.get_current_scene())
     config_path = ocr_config_dir / f"{scene}.json"
     if not config_path.exists():
         ocr_config = OCRConfig(scene=scene, window=window, rectangles=[], coordinate_system="percentage")
@@ -401,7 +404,7 @@ def set_force_stable_hotkey():
 
 if __name__ == "__main__":
     try:
-        global ocr1, ocr2, twopassocr, language, ss_clipboard, ss, ocr_config, furigana_filter_sensitivity, area_select_ocr_hotkey, window, optimize_second_scan
+        global ocr1, ocr2, twopassocr, language, ss_clipboard, ss, ocr_config, furigana_filter_sensitivity, area_select_ocr_hotkey, window, optimize_second_scan, use_window_for_config
         import sys
 
         import argparse
@@ -423,6 +426,8 @@ if __name__ == "__main__":
                             help="Hotkey for area selection OCR (default: ctrl+shift+o)")
         parser.add_argument("--optimize_second_scan", action="store_true",
                             help="Optimize second scan by cropping based on first scan results")
+        parser.add_argument("--use_window_for_config", action="store_true",
+                            help="Use the specified window for loading OCR configuration")
 
         args = parser.parse_args()
 
@@ -440,11 +445,12 @@ if __name__ == "__main__":
             "alt", "<alt>") if args.manual_ocr_hotkey else None
         clipboard_output = args.clipboard_output
         optimize_second_scan = args.optimize_second_scan
+        use_window_for_config = args.use_window_for_config
 
         window = None
         logger.info(f"Received arguments: {vars(args)}")
         # set_force_stable_hotkey()
-        ocr_config: OCRConfig = get_ocr_config(window=window_name)
+        ocr_config: OCRConfig = get_ocr_config(window=window_name, use_window_for_config=use_window_for_config)
         if ocr_config:
             if ocr_config.window:
                 start_time = time.time()

GameSentenceMiner/owocr/owocr/ocr.py

@@ -18,6 +18,8 @@ from google.generativeai import GenerationConfig
 from loguru import logger
 import requests
 
+# from GameSentenceMiner.util.configuration import get_temporary_directory
+
 try:
     from manga_ocr import MangaOcr as MOCR
 except ImportError:
@@ -77,7 +79,6 @@ try:
     from GameSentenceMiner.owocr.owocr.lens_betterproto import *
     import random
 except ImportError:
-    print('Google Lens not available, please install betterproto package!')
     pass
 
 try:
@@ -100,11 +101,13 @@ def post_process(text):
 
 
 def input_to_pil_image(img):
+    is_path = False
     if isinstance(img, Image.Image):
         pil_image = img
     elif isinstance(img, (bytes, bytearray)):
         pil_image = Image.open(io.BytesIO(img))
     elif isinstance(img, Path):
+        is_path = True
         try:
             pil_image = Image.open(img)
             pil_image.load()
@@ -112,7 +115,7 @@ def input_to_pil_image(img):
             return None
     else:
         raise ValueError(f'img must be a path, PIL.Image or bytes object, instead got: {img}')
-    return pil_image
+    return pil_image, is_path
 
 
 def pil_image_to_bytes(img, img_format='png', png_compression=6, jpeg_quality=80, optimize=False):
@@ -163,7 +166,7 @@ class MangaOcr:
     key = 'm'
     available = False
 
-    def __init__(self, config={'pretrained_model_name_or_path':'kha-white/manga-ocr-base','force_cpu': False}):
+    def __init__(self, config={'pretrained_model_name_or_path':'kha-white/manga-ocr-base','force_cpu': False}, lang='ja'):
         if 'manga_ocr' not in sys.modules:
             logger.warning('manga-ocr not available, Manga OCR will not work!')
         else:
@@ -177,7 +180,7 @@ class MangaOcr:
             logger.info('Manga OCR ready')
 
     def __call__(self, img, furigana_filter_sensitivity=0):
-        img = input_to_pil_image(img)
+        img, is_path = input_to_pil_image(img)
         if not img:
             return (False, 'Invalid image provided')
 
@@ -192,7 +195,7 @@ class GoogleVision:
     key = 'g'
     available = False
 
-    def __init__(self):
+    def __init__(self, lang='ja'):
         if 'google.cloud' not in sys.modules:
             logger.warning('google-cloud-vision not available, Google Vision will not work!')
         else:
@@ -207,7 +210,7 @@ class GoogleVision:
                 logger.warning('Error parsing Google credentials, Google Vision will not work!')
 
     def __call__(self, img, furigana_filter_sensitivity=0):
-        img = input_to_pil_image(img)
+        img, is_path = input_to_pil_image(img)
         if not img:
             return (False, 'Invalid image provided')
 
@@ -235,7 +238,7 @@ class GoogleLens:
     key = 'l'
     available = False
 
-    def __init__(self):
+    def __init__(self, lang='ja'):
         self.kana_kanji_regex = re.compile(r'[\u3041-\u3096\u30A1-\u30FA\u4E00-\u9FFF]')
         if 'betterproto' not in sys.modules:
             logger.warning('betterproto not available, Google Lens will not work!')
@@ -244,7 +247,7 @@ class GoogleLens:
             logger.info('Google Lens ready')
 
     def __call__(self, img, furigana_filter_sensitivity=0):
-        img = input_to_pil_image(img)
+        img, is_path = input_to_pil_image(img)
         if not img:
             return (False, 'Invalid image provided')
 
@@ -369,9 +372,7 @@ class GoogleLens:
             aspect_ratio = img.width / img.height
             new_w = int(sqrt(3000000 * aspect_ratio))
             new_h = int(new_w / aspect_ratio)
-            img_resized = img.resize((new_w, new_h), Image.Resampling.LANCZOS)
-            # img.close()
-            img = img_resized
+            img = img.resize((new_w, new_h), Image.Resampling.LANCZOS)
 
         return (pil_image_to_bytes(img), img.width, img.height)
 
@@ -381,7 +382,7 @@ class GoogleLensWeb:
     key = 'k'
     available = False
 
-    def __init__(self):
+    def __init__(self, lang='ja'):
         if 'pyjson5' not in sys.modules:
             logger.warning('pyjson5 not available, Google Lens (web) will not work!')
         else:
@@ -390,7 +391,7 @@ class GoogleLensWeb:
             logger.info('Google Lens (web) ready')
 
     def __call__(self, img, furigana_filter_sensitivity=0):
-        img = input_to_pil_image(img)
+        img, is_path = input_to_pil_image(img)
         if not img:
             return (False, 'Invalid image provided')
 
@@ -465,9 +466,7 @@ class GoogleLensWeb:
             aspect_ratio = img.width / img.height
             new_w = int(sqrt(3000000 * aspect_ratio))
             new_h = int(new_w / aspect_ratio)
-            img_resized = img.resize((new_w, new_h), Image.Resampling.LANCZOS)
-            # img.close()
-            img = img_resized
+            img = img.resize((new_w, new_h), Image.Resampling.LANCZOS)
 
         return pil_image_to_bytes(img)
 
@@ -477,13 +476,13 @@ class Bing:
     key = 'b'
     available = False
 
-    def __init__(self):
+    def __init__(self, lang='ja'):
         self.requests_session = requests.Session()
         self.available = True
         logger.info('Bing ready')
 
     def __call__(self, img, furigana_filter_sensitivity=0):
-        img = input_to_pil_image(img)
+        img, is_path = input_to_pil_image(img)
         if not img:
             return (False, 'Invalid image provided')
 
@@ -544,7 +543,7 @@ class Bing:
             'imageInfo': {'imageInsightsToken': image_insights_token, 'source': 'Url'},
             'knowledgeRequest': {'invokedSkills': ['OCR'], 'index': 1}
         }
-        files = {   
+        files = {
             'knowledgeRequest': (None, json.dumps(api_data_json), 'application/json')
         }
 
@@ -577,7 +576,7 @@ class Bing:
                 for region in regions:
                     for line in region.get('lines', []):
                         res += line['text'] + '\n'
-        
+
         x = (True, res)
 
         # img.close()
@@ -592,9 +591,7 @@ class Bing:
             resize_factor = max(max_pixel_size / img.width, max_pixel_size / img.height)
             new_w = int(img.width * resize_factor)
             new_h = int(img.height * resize_factor)
-            img_resized = img.resize((new_w, new_h), Image.Resampling.LANCZOS)
-            # img.close()
-            img = img_resized
+            img = img.resize((new_w, new_h), Image.Resampling.LANCZOS)
 
         img_bytes, _ = limit_image_size(img, max_byte_size)
 
@@ -609,7 +606,7 @@ class AppleVision:
     key = 'a'
     available = False
 
-    def __init__(self):
+    def __init__(self, lang='ja'):
         if sys.platform != 'darwin':
             logger.warning('Apple Vision is not supported on non-macOS platforms!')
         elif int(platform.mac_ver()[0].split('.')[0]) < 13:
@@ -619,7 +616,7 @@ class AppleVision:
             logger.info('Apple Vision ready')
 
     def __call__(self, img, furigana_filter_sensitivity=0):
-        img = input_to_pil_image(img)
+        img, is_path = input_to_pil_image(img)
         if not img:
             return (False, 'Invalid image provided')
 
@@ -657,7 +654,7 @@ class AppleLiveText:
     key = 'd'
     available = False
 
-    def __init__(self):
+    def __init__(self, lang='ja'):
         if sys.platform != 'darwin':
             logger.warning('Apple Live Text is not supported on non-macOS platforms!')
         elif int(platform.mac_ver()[0].split('.')[0]) < 13:
@@ -698,7 +695,7 @@ class AppleLiveText:
             logger.info('Apple Live Text ready')
 
     def __call__(self, img, furigana_filter_sensitivity=0):
-        img = input_to_pil_image(img)
+        img, is_path = input_to_pil_image(img)
         if not img:
             return (False, 'Invalid image provided')
 
@@ -737,7 +734,7 @@ class WinRTOCR:
     key = 'w'
     available = False
 
-    def __init__(self, config={}):
+    def __init__(self, config={}, lang='ja'):
         if sys.platform == 'win32':
             if int(platform.release()) < 10:
                 logger.warning('WinRT OCR is not supported on Windows older than 10!')
@@ -755,7 +752,7 @@ class WinRTOCR:
                 logger.warning('Error reading URL from config, WinRT OCR will not work!')
 
     def __call__(self, img, furigana_filter_sensitivity=0):
-        img = input_to_pil_image(img)
+        img, is_path = input_to_pil_image(img)
         if not img:
             return (False, 'Invalid image provided')
 
@@ -790,7 +787,26 @@ class OneOCR:
     key = 'z'
     available = False
 
-    def __init__(self, config={}):
+    def __init__(self, config={}, lang='ja'):
+        if lang == "ja":
+            self.regex = re.compile(r'[\u3041-\u3096\u30A1-\u30FA\u4E00-\u9FFF]')
+        elif lang == "zh":
+            self.regex = re.compile(r'[\u4E00-\u9FFF]')
+        elif lang == "ko":
+            self.regex = re.compile(r'[\uAC00-\uD7AF]')
+        elif lang == "ar":
+            self.regex = re.compile(r'[\u0600-\u06FF\u0750-\u077F\u08A0-\u08FF\uFB50-\uFDFF\uFE70-\uFEFF]')
+        elif lang == "ru":
+            self.regex = re.compile(r'[\u0400-\u04FF\u0500-\u052F\u2DE0-\u2DFF\uA640-\uA69F\u1C80-\u1C8F]')
+        elif lang == "el":
+            self.regex = re.compile(r'[\u0370-\u03FF\u1F00-\u1FFF]')
+        elif lang == "he":
+            self.regex = re.compile(r'[\u0590-\u05FF\uFB1D-\uFB4F]')
+        elif lang == "th":
+            self.regex = re.compile(r'[\u0E00-\u0E7F]')
+        else:
+            self.regex = re.compile(
+            r'[a-zA-Z\u00C0-\u00FF\u0100-\u017F\u0180-\u024F\u0250-\u02AF\u1D00-\u1D7F\u1D80-\u1DBF\u1E00-\u1EFF\u2C60-\u2C7F\uA720-\uA7FF\uAB30-\uAB6F]')
         if sys.platform == 'win32':
             if int(platform.release()) < 10:
                 logger.warning('OneOCR is not supported on Windows older than 10!')
@@ -813,14 +829,13 @@ class OneOCR:
                 logger.warning('Error reading URL from config, OneOCR will not work!')
 
     def __call__(self, img, furigana_filter_sensitivity=0):
-        img = input_to_pil_image(img)
+        img, is_path = input_to_pil_image(img)
         if img.width < 51 or img.height < 51:
             new_width = max(img.width, 51)
             new_height = max(img.height, 51)
             new_img = Image.new("RGBA", (new_width, new_height), (0, 0, 0, 0))
             new_img.paste(img, ((new_width - img.width) // 2, (new_height - img.height) // 2))
             img = new_img
-
         if not img:
             return (False, 'Invalid image provided')
         crop_coords = None
@@ -828,8 +843,9 @@ class OneOCR:
             try:
                 ocr_resp = self.model.recognize_pil(img)
                 # print(json.dumps(ocr_resp))
-                x_coords = [line['bounding_rect'][f'x{i}'] for line in ocr_resp['lines'] for i in range(1, 5)]
-                y_coords = [line['bounding_rect'][f'y{i}'] for line in ocr_resp['lines'] for i in range(1, 5)]
+                filtered_lines = [line for line in ocr_resp['lines'] if self.regex.search(line['text'])]
+                x_coords = [line['bounding_rect'][f'x{i}'] for line in filtered_lines for i in range(1, 5)]
+                y_coords = [line['bounding_rect'][f'y{i}'] for line in filtered_lines for i in range(1, 5)]
                 if x_coords and y_coords:
                     crop_coords = (min(x_coords) - 5, min(y_coords) - 5, max(x_coords) + 5, max(y_coords) + 5)
 
@@ -902,7 +918,6 @@ class OneOCR:
             if res.status_code != 200:
                 return (False, 'Unknown error!')
 
-
             res = res.json()['text']
 
         x = (True, res, crop_coords)
@@ -919,7 +934,7 @@ class AzureImageAnalysis:
     key = 'v'
     available = False
 
-    def __init__(self, config={}):
+    def __init__(self, config={}, lang='ja'):
         if 'azure.ai.vision.imageanalysis' not in sys.modules:
             logger.warning('azure-ai-vision-imageanalysis not available, Azure Image Analysis will not work!')
         else:
@@ -932,7 +947,7 @@ class AzureImageAnalysis:
                 logger.warning('Error parsing Azure credentials, Azure Image Analysis will not work!')
 
     def __call__(self, img, furigana_filter_sensitivity=0):
-        img = input_to_pil_image(img)
+        img, is_path = input_to_pil_image(img)
         if not img:
             return (False, 'Invalid image provided')
 
@@ -961,9 +976,7 @@ class AzureImageAnalysis:
             resize_factor = max(50 / img.width, 50 / img.height)
             new_w = int(img.width * resize_factor)
             new_h = int(img.height * resize_factor)
-            img_resized = img.resize((new_w, new_h), Image.Resampling.LANCZOS)
-            # img.close()
-            img = img_resized
+            img = img.resize((new_w, new_h), Image.Resampling.LANCZOS)
 
         return pil_image_to_bytes(img)
 
@@ -973,7 +986,7 @@ class EasyOCR:
     key = 'e'
     available = False
 
-    def __init__(self, config={'gpu': True}):
+    def __init__(self, config={'gpu': True}, lang='ja'):
         if 'easyocr' not in sys.modules:
             logger.warning('easyocr not available, EasyOCR will not work!')
         else:
@@ -984,7 +997,7 @@ class EasyOCR:
             logger.info('EasyOCR ready')
 
     def __call__(self, img, furigana_filter_sensitivity=0):
-        img = input_to_pil_image(img)
+        img, is_path = input_to_pil_image(img)
         if not img:
             return (False, 'Invalid image provided')
 
@@ -1007,7 +1020,7 @@ class RapidOCR:
     key = 'r'
     available = False
 
-    def __init__(self):
+    def __init__(self, lang='ja'):
         if 'rapidocr_onnxruntime' not in sys.modules:
             logger.warning('rapidocr_onnxruntime not available, RapidOCR will not work!')
         else:
@@ -1030,7 +1043,7 @@ class RapidOCR:
             logger.info('RapidOCR ready')
 
     def __call__(self, img, furigana_filter_sensitivity=0):
-        img = input_to_pil_image(img)
+        img, is_path = input_to_pil_image(img)
         if not img:
             return (False, 'Invalid image provided')
 
@@ -1054,7 +1067,7 @@ class OCRSpace:
     key = 'o'
     available = False
 
-    def __init__(self, config={}):
+    def __init__(self, config={}, lang='ja'):
         try:
             self.api_key = config['api_key']
             self.max_byte_size = config.get('file_size_limit', 1000000)
@@ -1064,7 +1077,7 @@ class OCRSpace:
             logger.warning('Error reading API key from config, OCRSpace will not work!')
 
     def __call__(self, img, furigana_filter_sensitivity=0):
-        img = input_to_pil_image(img)
+        img, is_path = input_to_pil_image(img)
         if not img:
             return (False, 'Invalid image provided')
 
@@ -1101,7 +1114,7 @@ class OCRSpace:
         # img.close()
         return x
 
-    def _preprocess(self, img):       
+    def _preprocess(self, img):
         return limit_image_size(img, self.max_byte_size)
 
 
@@ -1111,7 +1124,7 @@ class GeminiOCR:
     key = 'm'
     available = False
 
-    def __init__(self, config={'api_key': None}):
+    def __init__(self, config={'api_key': None}, lang='ja'):
         # if "google-generativeai" not in sys.modules:
         #     logger.warning('google-generativeai not available, GeminiOCR will not work!')
         # else:
@@ -1138,7 +1151,7 @@ class GeminiOCR:
             return (False, 'GeminiOCR is not available due to missing API key or configuration error.')
 
         try:
-            img = input_to_pil_image(img)
+            img, is_path = input_to_pil_image(img)
             import google.generativeai as genai
             img_bytes = self._preprocess(img)
             if not img_bytes:
@@ -1180,7 +1193,7 @@ class GroqOCR:
     key = 'j'
     available = False
 
-    def __init__(self, config={'api_key': None}):
+    def __init__(self, config={'api_key': None}, lang='ja'):
         try:
             import groq
             self.api_key = config['api_key']
@@ -1200,7 +1213,7 @@ class GroqOCR:
             return (False, 'GroqOCR is not available due to missing API key or configuration error.')
 
         try:
-            img = input_to_pil_image(img)
+            img, is_path = input_to_pil_image(img)
 
             img_base64 = self._preprocess(img)
             if not img_base64:
@@ -1252,7 +1265,7 @@ class GroqOCR:
 #     key = 'q'
 #     available = False
 #
-#     def __init__(self, config={}):
+#     def __init__(self, config={}, lang='ja'):
 #         try:
 #             import torch
 #             from transformers import Qwen2VLForConditionalGeneration, AutoProcessor
@@ -1314,7 +1327,7 @@ class GroqOCR:
 #     key = '-'
 #     available = False
 #
-#     def __init__(self):
+#     def __init__(self, lang='ja'):
 #         self.requests_session = requests.Session()
 #         self.available = True
 #         # logger.info('Local OCR ready') # Uncomment if you have a logger defined

GameSentenceMiner/owocr/owocr/run.py

@@ -373,7 +373,7 @@ class TextFiltering:
                           "fi"]:  # Many European languages use extended Latin
                 block_filtered = self.latin_extended_regex.findall(block)
             else:
-                block_filtered = self.english_regex.findall(block)
+                block_filtered = self.latin_extended_regex.findall(block)
 
             if block_filtered:
                 orig_text_filtered.append(''.join(block_filtered))
@@ -414,8 +414,9 @@ class TextFiltering:
         return text, orig_text_filtered
 
 
-class ScreenshotClass:
-    def __init__(self, screen_capture_area, screen_capture_window, screen_capture_exclusions, screen_capture_only_active_windows, screen_capture_areas):
+class ScreenshotThread(threading.Thread):
+    def __init__(self, screen_capture_area, screen_capture_window, screen_capture_exclusions, screen_capture_only_active_windows, screen_capture_areas, screen_capture_on_combo):
+        super().__init__(daemon=True)
         self.macos_window_tracker_instance = None
         self.windows_window_tracker_instance = None
         self.screencapture_window_active = True
@@ -424,6 +425,7 @@ class ScreenshotClass:
         self.screen_capture_exclusions = screen_capture_exclusions
         self.screen_capture_window = screen_capture_window
         self.areas = []
+        self.use_periodic_queue = not screen_capture_on_combo
         if screen_capture_area == '':
             self.screencapture_mode = 0
         elif screen_capture_area.startswith('screen_'):
@@ -441,10 +443,10 @@ class ScreenshotClass:
             self.screencapture_mode = 2
 
         if self.screencapture_mode != 2:
-            self.sct = mss.mss()
+            sct = mss.mss()
 
             if self.screencapture_mode == 1:
-                mon = self.sct.monitors
+                mon = sct.monitors
                 if len(mon) <= screen_capture_monitor:
                     raise ValueError('Invalid monitor number in screen_capture_area')
                 coord_left = mon[screen_capture_monitor]['left']
@@ -535,12 +537,6 @@ class ScreenshotClass:
             else:
                 raise ValueError('Window capture is only currently supported on Windows and macOS')
 
-    def __del__(self):
-        if self.macos_window_tracker_instance:
-            self.macos_window_tracker_instance.join()
-        elif self.windows_window_tracker_instance:
-            self.windows_window_tracker_instance.join()
-
     def get_windows_window_handle(self, window_title):
         def callback(hwnd, window_title_part):
             window_title = win32gui.GetWindowText(hwnd)
@@ -647,114 +643,121 @@ class ScreenshotClass:
         if not found:
             on_window_closed(False)
 
-    def __call__(self):
-        if self.screencapture_mode == 2 or self.screen_capture_window:
-            if sys.platform == 'darwin':
-                with objc.autorelease_pool():
-                    if self.old_macos_screenshot_api:
-                        cg_image = CGWindowListCreateImageFromArray(CGRectNull, [self.window_id], kCGWindowImageBoundsIgnoreFraming)
-                    else:
-                        self.capture_macos_window_screenshot(self.window_id)
-                        try:
-                            cg_image = self.screencapturekit_queue.get(timeout=0.5)
-                        except queue.Empty:
-                            cg_image = None
-                    if not cg_image:
+    def write_result(self, result):
+        if self.use_periodic_queue:
+            periodic_screenshot_queue.put(result)
+        else:
+            image_queue.put((result, True))
+
+    def run(self):
+        if self.screencapture_mode != 2:
+            sct = mss.mss()
+        while not terminated:
+            if not screenshot_event.wait(timeout=0.1):
+                continue
+            if self.screencapture_mode == 2 or self.screen_capture_window:
+                if sys.platform == 'darwin':
+                    with objc.autorelease_pool():
+                        if self.old_macos_screenshot_api:
+                            cg_image = CGWindowListCreateImageFromArray(CGRectNull, [self.window_id],
+                                                                        kCGWindowImageBoundsIgnoreFraming)
+                        else:
+                            self.capture_macos_window_screenshot(self.window_id)
+                            try:
+                                cg_image = self.screencapturekit_queue.get(timeout=0.5)
+                            except queue.Empty:
+                                cg_image = None
+                        if not cg_image:
+                            return 0
+                        width = CGImageGetWidth(cg_image)
+                        height = CGImageGetHeight(cg_image)
+                        raw_data = CGDataProviderCopyData(CGImageGetDataProvider(cg_image))
+                        bpr = CGImageGetBytesPerRow(cg_image)
+                    img = Image.frombuffer('RGBA', (width, height), raw_data, 'raw', 'BGRA', bpr, 1)
+                else:
+                    try:
+                        coord_left, coord_top, right, bottom = win32gui.GetWindowRect(self.window_handle)
+                        coord_width = right - coord_left
+                        coord_height = bottom - coord_top
+
+                        hwnd_dc = win32gui.GetWindowDC(self.window_handle)
+                        mfc_dc = win32ui.CreateDCFromHandle(hwnd_dc)
+                        save_dc = mfc_dc.CreateCompatibleDC()
+
+                        save_bitmap = win32ui.CreateBitmap()
+                        save_bitmap.CreateCompatibleBitmap(mfc_dc, coord_width, coord_height)
+                        save_dc.SelectObject(save_bitmap)
+
+                        result = ctypes.windll.user32.PrintWindow(self.window_handle, save_dc.GetSafeHdc(), 2)
+
+                        bmpinfo = save_bitmap.GetInfo()
+                        bmpstr = save_bitmap.GetBitmapBits(True)
+                    except pywintypes.error:
                         return 0
-                    width = CGImageGetWidth(cg_image)
-                    height = CGImageGetHeight(cg_image)
-                    raw_data = CGDataProviderCopyData(CGImageGetDataProvider(cg_image))
-                    bpr = CGImageGetBytesPerRow(cg_image)
-                img = Image.frombuffer('RGBA', (width, height), raw_data, 'raw', 'BGRA', bpr, 1)
+                    img = Image.frombuffer('RGB', (bmpinfo['bmWidth'], bmpinfo['bmHeight']), bmpstr, 'raw', 'BGRX', 0,
+                                           1)
+                    try:
+                        win32gui.DeleteObject(save_bitmap.GetHandle())
+                    except:
+                        pass
+                    try:
+                        save_dc.DeleteDC()
+                    except:
+                        pass
+                    try:
+                        mfc_dc.DeleteDC()
+                    except:
+                        pass
+                    try:
+                        win32gui.ReleaseDC(self.window_handle, hwnd_dc)
+                    except:
+                        pass
             else:
-                try:
-                    coord_left, coord_top, right, bottom = win32gui.GetWindowRect(self.window_handle)
-                    coord_width = right - coord_left
-                    coord_height = bottom - coord_top
+                sct_img = sct.grab(self.sct_params)
+                img = Image.frombytes('RGB', sct_img.size, sct_img.bgra, 'raw', 'BGRX')
 
-                    hwnd_dc = win32gui.GetWindowDC(self.window_handle)
-                    mfc_dc = win32ui.CreateDCFromHandle(hwnd_dc)
-                    save_dc = mfc_dc.CreateCompatibleDC()
+            import random  # Ensure this is imported at the top of the file if not already
+            rand_int = random.randint(1, 20)  # Executes only once out of 10 times
 
-                    save_bitmap = win32ui.CreateBitmap()
-                    save_bitmap.CreateCompatibleBitmap(mfc_dc, coord_width, coord_height)
-                    save_dc.SelectObject(save_bitmap)
+            if rand_int == 1:  # Executes only once out of 10 times
+                img.save(os.path.join(get_temporary_directory(), 'before_crop.png'), 'PNG')
 
-                    result = ctypes.windll.user32.PrintWindow(self.window_handle, save_dc.GetSafeHdc(), 2)
+            if self.screen_capture_exclusions:
+                img = img.convert("RGBA")
+                draw = ImageDraw.Draw(img)
+                for exclusion in self.screen_capture_exclusions:
+                    left, top, width, height = exclusion
+                    draw.rectangle((left, top, left + width, top + height), fill=(0, 0, 0, 0))
 
-                    bmpinfo = save_bitmap.GetInfo()
-                    bmpstr = save_bitmap.GetBitmapBits(True)
-                except pywintypes.error:
-                    return 0
-                img = Image.frombuffer('RGB', (bmpinfo['bmWidth'], bmpinfo['bmHeight']), bmpstr, 'raw', 'BGRX', 0, 1)
-                try:
-                    win32gui.DeleteObject(save_bitmap.GetHandle())
-                except:
-                    pass
-                try:
-                    save_dc.DeleteDC()
-                except:
-                    pass
-                try:
-                    mfc_dc.DeleteDC()
-                except:
-                    pass
-                try:
-                    win32gui.ReleaseDC(self.window_handle, hwnd_dc)
-                except:
-                    pass
-        else:
-            sct_img = self.sct.grab(self.sct_params)
-            img = Image.frombytes('RGB', sct_img.size, sct_img.bgra, 'raw', 'BGRX')
-
-        import random  # Ensure this is imported at the top of the file if not already
-        rand_int = random.randint(1, 20)  # Executes only once out of 10 times
-
-        if rand_int == 1:  # Executes only once out of 10 times
-            img.save(os.path.join(get_temporary_directory(), 'before_crop.png'), 'PNG')
-
-        if self.screen_capture_exclusions:
-            img = img.convert("RGBA")
-            draw = ImageDraw.Draw(img)
-            for exclusion in self.screen_capture_exclusions:
-                left, top, width, height = exclusion
-                draw.rectangle((left, top, left + width, top + height), fill=(0, 0, 0, 0))
-
-        cropped_sections = []
-        start = time.time()
-        for area in self.areas:
-            cropped_sections.append(img.crop((area[0], area[1], area[0] + area[2], area[1] + area[3])))
-
-        # if len(cropped_sections) > 1:
-        #     combined_width = sum(section.width for section in cropped_sections)
-        #     combined_height = max(section.height for section in cropped_sections)
-        #     combined_img = Image.new("RGBA", (combined_width, combined_height))
-        #
-        #     x_offset = 0
-        #     for section in cropped_sections:
-        #         combined_img.paste(section, (x_offset, 0))
-        #         x_offset += section.width
-        #
-        #     img = combined_img
-        if len(cropped_sections) > 1:
-            combined_width = max(section.width for section in cropped_sections)
-            combined_height = sum(section.height for section in cropped_sections) + (len(cropped_sections) - 1) * 10  # Add space for gaps
-            combined_img = Image.new("RGBA", (combined_width, combined_height))
-
-            y_offset = 0
-            for section in cropped_sections:
-                combined_img.paste(section, (0, y_offset))
-                y_offset += section.height + 50  # Add gap between sections
-
-            img = combined_img
-        elif cropped_sections:
-            img = cropped_sections[0]
-
-        if rand_int == 1:
-            img.save(os.path.join(get_temporary_directory(), 'after_crop.png'), 'PNG')
-
-        return img
+            cropped_sections = []
+            for area in self.areas:
+                cropped_sections.append(img.crop((area[0], area[1], area[0] + area[2], area[1] + area[3])))
+
+            if len(cropped_sections) > 1:
+                combined_width = max(section.width for section in cropped_sections)
+                combined_height = sum(section.height for section in cropped_sections) + (
+                            len(cropped_sections) - 1) * 10  # Add space for gaps
+                combined_img = Image.new("RGBA", (combined_width, combined_height))
+
+                y_offset = 0
+                for section in cropped_sections:
+                    combined_img.paste(section, (0, y_offset))
+                    y_offset += section.height + 50  # Add gap between sections
 
+                img = combined_img
+            elif cropped_sections:
+                img = cropped_sections[0]
+
+            if rand_int == 1:
+                img.save(os.path.join(get_temporary_directory(), 'after_crop.png'), 'PNG')
+
+            self.write_result(img)
+            screenshot_event.clear()
+
+        if self.macos_window_tracker_instance:
+            self.macos_window_tracker_instance.join()
+        elif self.windows_window_tracker_instance:
+            self.windows_window_tracker_instance.join()
 
 class AutopauseTimer:
     def __init__(self, timeout):
@@ -823,21 +826,28 @@ def user_input_thread_run():
         global terminated
         logger.info('Terminated!')
         terminated = True
+    import sys
 
     if sys.platform == 'win32':
         import msvcrt
         while not terminated:
-            user_input_bytes = msvcrt.getch()
-            try:
-                user_input = user_input_bytes.decode()
+            user_input = None
+            if msvcrt.kbhit():  # Check if a key is pressed
+                user_input_bytes = msvcrt.getch()
+                try:
+                    user_input = user_input_bytes.decode()
+                except UnicodeDecodeError:
+                    pass
+            if not user_input:  # If no input from msvcrt, check stdin
+                import sys
+                user_input = sys.stdin.read(1)
+
                 if user_input.lower() in 'tq':
                     _terminate_handler()
                 elif user_input.lower() == 'p':
                     pause_handler(False)
                 else:
                     engine_change_handler(user_input, False)
-            except UnicodeDecodeError:
-                pass
     else:
         import tty, termios
         fd = sys.stdin.fileno()
@@ -871,8 +881,7 @@ def on_window_closed(alive):
 
 def on_screenshot_combo():
     if not paused:
-        img = take_screenshot()
-        image_queue.put((img, True))
+        screenshot_event.set()
 
 
 def on_window_minimized(minimized):
@@ -1084,7 +1093,7 @@ def run(read_from=None,
             if config.get_engine(engine_class.name) == None:
                 engine_instance = engine_class()
             else:
-                engine_instance = engine_class(config.get_engine(engine_class.name))
+                engine_instance = engine_class(config.get_engine(engine_class.name), lang=lang)
 
             if engine_instance.available:
                 engine_instances.append(engine_instance)
@@ -1104,6 +1113,7 @@ def run(read_from=None,
     global auto_pause_handler
     global notifier
     global websocket_server_thread
+    global screenshot_thread
     global image_queue
     global ocr_1
     global ocr_2
@@ -1128,6 +1138,7 @@ def run(read_from=None,
     auto_pause = config.get_general('auto_pause')
     clipboard_thread = None
     websocket_server_thread = None
+    screenshot_thread = None
     directory_watcher_thread = None
     unix_socket_server = None
     key_combo_listener = None
@@ -1160,13 +1171,18 @@ def run(read_from=None,
 
     if 'screencapture' in (read_from, read_from_secondary):
         global take_screenshot
+        global screenshot_event
         last_screenshot_time = 0
         last_result = ([], engine_index)
         if screen_capture_combo != '':
             screen_capture_on_combo = True
             key_combos[screen_capture_combo] = on_screenshot_combo
-        take_screenshot = ScreenshotClass(screen_capture_area, screen_capture_window, screen_capture_exclusions, screen_capture_only_active_windows, screen_capture_areas)
-        # global_take_screenshot = ScreenshotClass(screen_capture_area, screen_capture_window, screen_capture_exclusions, screen_capture_only_active_windows, rectangle)
+        else:
+            global periodic_screenshot_queue
+            periodic_screenshot_queue = queue.Queue()
+        screenshot_event = threading.Event()
+        screenshot_thread = ScreenshotThread(screen_capture_area, screen_capture_window, screen_capture_exclusions, screen_capture_only_active_windows, screen_capture_areas, screen_capture_on_combo)
+        screenshot_thread.start()
         filtering = TextFiltering()
         read_from_readable.append('screen capture')
     if 'websocket' in (read_from, read_from_secondary):
@@ -1233,8 +1249,9 @@ def run(read_from=None,
                 pass
 
         if (not img) and process_screenshots:
-            if (not paused) and take_screenshot.screencapture_window_active and take_screenshot.screencapture_window_visible and (time.time() - last_screenshot_time) > screen_capture_delay_secs:
-                img = take_screenshot()
+            if (not paused) and screenshot_thread.screencapture_window_active and screenshot_thread.screencapture_window_visible and (time.time() - last_screenshot_time) > screen_capture_delay_secs:
+                screenshot_event.set()
+                img = periodic_screenshot_queue.get()
                 filter_img = True
                 notify = False
                 last_screenshot_time = time.time()
@@ -1270,5 +1287,7 @@ def run(read_from=None,
     if unix_socket_server:
         unix_socket_server.shutdown()
         unix_socket_server_thread.join()
+    if screenshot_thread:
+        screenshot_thread.join()
     if key_combo_listener:
         key_combo_listener.stop()

{gamesentenceminer-2.10.12.dist-info → gamesentenceminer-2.10.14.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GameSentenceMiner
-Version: 2.10.12
+Version: 2.10.14
 Summary: A tool for mining sentences from games. Update: Full UI Re-design
 Author-email: Beangate <bpwhelan95@gmail.com>
 License: MIT License

{gamesentenceminer-2.10.12.dist-info → gamesentenceminer-2.10.14.dist-info}/RECORD

@@ -3,7 +3,7 @@ GameSentenceMiner/anki.py,sha256=kWw3PV_Jj5-lHcttCB3lRXejHlaAbiJ2Ag_NAGX-RI8,166
 GameSentenceMiner/config_gui.py,sha256=Xa_a-sdQzht3kzR-Z9gkLy4qnaPyP1bdVadYTHp5lUQ,91018
 GameSentenceMiner/gametext.py,sha256=6VkjmBeiuZfPk8T6PHFdIAElBH2Y_oLVYvmcafqN7RM,6747
 GameSentenceMiner/gsm.py,sha256=p4DVa_Jx1EOsgUxAAdC7st7VXLKWnP2BLDGT78ToO8w,24864
-GameSentenceMiner/obs.py,sha256=ZV9Vk39hrsJLT-AlIxa3qgncKxXaL3Myl33vVJEDEoA,14670
+GameSentenceMiner/obs.py,sha256=o_I6213VZvXqYkZDdUBgUg2KWi9SbnNZZjjUnKnQkK4,15190
 GameSentenceMiner/vad.py,sha256=G0NkaWFJaIfKQAV7LOFxyKoih7pPNYHDuy4SzeFVCkI,16389
 GameSentenceMiner/ai/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 GameSentenceMiner/ai/ai_prompting.py,sha256=0jBAnngNwmc3dqJiVWe_QRy4Syr-muV-ML2rq0FiUtU,10215
@@ -18,15 +18,15 @@ GameSentenceMiner/assets/pickaxe.png,sha256=VfIGyXyIZdzEnVcc4PmG3wszPMO1W4KCT7Q_
 GameSentenceMiner/ocr/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 GameSentenceMiner/ocr/gsm_ocr_config.py,sha256=jtTzAWtMAx8GuA1XIJ_BmyNn3aYaO3u_c5Q7m5D4gS8,4056
 GameSentenceMiner/ocr/ocrconfig.py,sha256=_tY8mjnzHMJrLS8E5pHqYXZjMuLoGKYgJwdhYgN-ny4,6466
-GameSentenceMiner/ocr/owocr_area_selector.py,sha256=boAqarX17jvFscu-7s6C9rqesjQ54s-kfuW0bjCru-M,19834
-GameSentenceMiner/ocr/owocr_helper.py,sha256=VDcuBfyZ1B7TN6yImJVuNxqWY7pr95R2cRM9jgD5Rk8,21670
+GameSentenceMiner/ocr/owocr_area_selector.py,sha256=lHMVZuEE_-_wICfDr6jDJNSJIyZd2PnF7dIajknaHCU,20255
+GameSentenceMiner/ocr/owocr_helper.py,sha256=Iidu2T6z-eewFC40t3jUlLukankVsQB_HUEhr1L7HCU,22097
 GameSentenceMiner/ocr/ss_picker.py,sha256=0IhxUdaKruFpZyBL-8SpxWg7bPrlGpy3lhTcMMZ5rwo,5224
 GameSentenceMiner/owocr/owocr/__init__.py,sha256=87hfN5u_PbL_onLfMACbc0F5j4KyIK9lKnRCj6oZgR0,49
 GameSentenceMiner/owocr/owocr/__main__.py,sha256=XQaqZY99EKoCpU-gWQjNbTs7Kg17HvBVE7JY8LqIE0o,157
 GameSentenceMiner/owocr/owocr/config.py,sha256=qM7kISHdUhuygGXOxmgU6Ef2nwBShrZtdqu4InDCViE,8103
 GameSentenceMiner/owocr/owocr/lens_betterproto.py,sha256=oNoISsPilVVRBBPVDtb4-roJtAhp8ZAuFTci3TGXtMc,39141
-GameSentenceMiner/owocr/owocr/ocr.py,sha256=Mri_zB_COk7x9GmolyhYCINJ-lQlD45GuJ4m4M0IBFM,55328
-GameSentenceMiner/owocr/owocr/run.py,sha256=mZIGDm3fGYrYbSNuFOk7Sbslfgi36YN0YqfC1xYh_eY,55286
+GameSentenceMiner/owocr/owocr/ocr.py,sha256=siEqZLXhvFX-l311a19nCs-a0PxY9iwpaOoSV5lzVj4,56562
+GameSentenceMiner/owocr/owocr/run.py,sha256=goOZSO3a7z8GxjYAcWjHsPxdzM60Nt3vxjcUzy1fnZg,56242
 GameSentenceMiner/owocr/owocr/screen_coordinate_picker.py,sha256=Na6XStbQBtpQUSdbN3QhEswtKuU1JjReFk_K8t5ezQE,3395
 GameSentenceMiner/util/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 GameSentenceMiner/util/audio_offset_selector.py,sha256=8Stk3BP-XVIuzRv9nl9Eqd2D-1yD3JrgU-CamBywJmY,8542
@@ -62,9 +62,9 @@ GameSentenceMiner/web/templates/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm
 GameSentenceMiner/web/templates/index.html,sha256=n0J-dV8eksj8JXUuaCTIh0fIxIjfgm2EvxGBdQ6gWoM,214113
 GameSentenceMiner/web/templates/text_replacements.html,sha256=tV5c8mCaWSt_vKuUpbdbLAzXZ3ATZeDvQ9PnnAfqY0M,8598
 GameSentenceMiner/web/templates/utility.html,sha256=3flZinKNqUJ7pvrZk6xu__v67z44rXnaK7UTZ303R-8,16946
-gamesentenceminer-2.10.12.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-gamesentenceminer-2.10.12.dist-info/METADATA,sha256=YzGn0pkP-I00xGsRHt-5GK8x9pCKpoKR5lHBYL_z8Ho,7355
-gamesentenceminer-2.10.12.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-gamesentenceminer-2.10.12.dist-info/entry_points.txt,sha256=2APEP25DbfjSxGeHtwBstMH8mulVhLkqF_b9bqzU6vQ,65
-gamesentenceminer-2.10.12.dist-info/top_level.txt,sha256=V1hUY6xVSyUEohb0uDoN4UIE6rUZ_JYx8yMyPGX4PgQ,18
-gamesentenceminer-2.10.12.dist-info/RECORD,,
+gamesentenceminer-2.10.14.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+gamesentenceminer-2.10.14.dist-info/METADATA,sha256=vnV_Sx7Xcs1DLFjkW4iKpwPNPf_ZFt83yVj7FSYtxAU,7355
+gamesentenceminer-2.10.14.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+gamesentenceminer-2.10.14.dist-info/entry_points.txt,sha256=2APEP25DbfjSxGeHtwBstMH8mulVhLkqF_b9bqzU6vQ,65
+gamesentenceminer-2.10.14.dist-info/top_level.txt,sha256=V1hUY6xVSyUEohb0uDoN4UIE6rUZ_JYx8yMyPGX4PgQ,18
+gamesentenceminer-2.10.14.dist-info/RECORD,,