GameSentenceMiner 2.13.15__py3-none-any.whl → 2.14.0rc1__py3-none-any.whl

GameSentenceMiner/util/get_overlay_coords.py

@@ -0,0 +1,324 @@
+import asyncio
+import io
+import base64
+import math
+import os
+import time
+from PIL import Image
+from typing import Dict, Any, List, Tuple
+
+# Local application imports
+from GameSentenceMiner.util.configuration import get_config
+from GameSentenceMiner.util.electron_config import get_ocr_language
+from GameSentenceMiner.obs import get_screenshot_PIL, logger
+from GameSentenceMiner.web.texthooking_page import send_word_coordinates_to_overlay
+
+# Conditionally import OCR engines
+try:
+    from GameSentenceMiner.owocr.owocr.ocr import GoogleLens, OneOCR, get_regex
+except ImportError:
+    GoogleLens, OneOCR, get_regex = None, None, None
+
+# Conditionally import screenshot library
+try:
+    import mss
+except ImportError:
+    mss = None
+
+class OverlayProcessor:
+    """
+    Handles the entire overlay process from screen capture to text extraction.
+
+    This class encapsulates the logic for taking screenshots, identifying text
+    regions, performing OCR, and processing the results into a structured format
+    with pixel coordinates.
+    """
+
+    def __init__(self):
+        """Initializes the OCR engines and configuration."""
+        self.config = get_config()
+        self.oneocr = None
+        self.lens = None
+        self.regex = None
+
+        if self.config.overlay.websocket_port and all([GoogleLens, OneOCR, get_regex]):
+            logger.info("Initializing OCR engines...")
+            self.oneocr = OneOCR(lang=get_ocr_language())
+            self.lens = GoogleLens(lang=get_ocr_language())
+            self.ocr_language = get_ocr_language()
+            self.regex = get_regex(self.ocr_language)
+            logger.info("OCR engines initialized.")
+        else:
+            logger.warning("OCR dependencies not found or websocket port not configured. OCR functionality will be disabled.")
+            
+        if not mss:
+            logger.warning("MSS library not found. Screenshot functionality may be limited.")
+            
+    async def find_box_and_send_to_overlay(self, sentence_to_check: str = None):
+        """
+        Sends the detected text boxes to the overlay via WebSocket.
+        """
+        boxes = await self.find_box_for_sentence(sentence_to_check)
+        logger.info(f"Sending {len(boxes)} boxes to overlay.")
+        await send_word_coordinates_to_overlay(boxes)
+
+    async def find_box_for_sentence(self, sentence_to_check: str = None) -> List[Dict[str, Any]]:
+        """
+        Public method to perform OCR and find text boxes for a given sentence.
+        
+        This is a wrapper around the main work-horse method, providing
+        error handling.
+        """
+        try:
+            return await self._do_work(sentence_to_check)
+        except Exception as e:
+            logger.error(f"Error during OCR processing: {e}", exc_info=True)
+            return []
+
+    def _get_full_screenshot(self) -> Tuple[Image.Image | None, int, int]:
+        """Captures a screenshot of the configured monitor."""
+        if not mss:
+            raise RuntimeError("MSS screenshot library is not installed.")
+        
+        with mss.mss() as sct:
+            monitors = sct.monitors
+            # Index 0 is the 'all monitors' virtual screen, so we skip it.
+            monitor_list = monitors[1:] if len(monitors) > 1 else [monitors[0]]
+            
+            monitor_index = self.config.overlay.monitor_to_capture
+            if monitor_index >= len(monitor_list):
+                logger.error(f"Monitor index {monitor_index} is out of bounds. Found {len(monitor_list)} monitors.")
+                return None, 0, 0
+                
+            monitor = monitor_list[monitor_index]
+            sct_img = sct.grab(monitor)
+            img = Image.frombytes('RGB', sct_img.size, sct_img.bgra, 'raw', 'BGRX')
+            
+            return img, monitor['width'], monitor['height']
+
+    def _create_composite_image(
+        self, 
+        full_screenshot: Image.Image,
+        crop_coords_list: List[Tuple[int, int, int, int]],
+        monitor_width: int,
+        monitor_height: int
+    ) -> Image.Image:
+        """
+        Creates a new image by pasting cropped text regions onto a transparent background.
+        This isolates text for more accurate secondary OCR.
+        """
+        if not crop_coords_list:
+            return full_screenshot
+
+        # Create a transparent canvas
+        composite_img = Image.new("RGBA", (monitor_width, monitor_height), (0, 0, 0, 0))
+
+        for crop_coords in crop_coords_list:
+            cropped_image = full_screenshot.crop(crop_coords)
+            # Paste the cropped image onto the canvas at its original location
+            paste_x = math.floor(crop_coords[0])
+            paste_y = math.floor(crop_coords[1])
+            composite_img.paste(cropped_image, (paste_x, paste_y))
+        
+        return composite_img
+
+    async def _do_work(self, sentence_to_check: str = None) -> Tuple[List[Dict[str, Any]], int]:
+        """The main OCR workflow."""
+        if not self.oneocr or not self.lens:
+            raise RuntimeError("OCR engines are not initialized. Cannot perform OCR.")
+
+        # 1. Get screenshot
+        full_screenshot, monitor_width, monitor_height = self._get_full_screenshot()
+        if not full_screenshot:
+            logger.warning("Failed to get a screenshot.")
+            return []
+
+        # 2. Use OneOCR to find general text areas (fast)
+        _, _, _, crop_coords_list = self.oneocr(
+            full_screenshot,
+            return_coords=True,
+            multiple_crop_coords=True,
+            return_one_box=False,
+            furigana_filter_sensitivity=0
+        )
+
+        # 3. Create a composite image with only the detected text regions
+        composite_image = self._create_composite_image(
+            full_screenshot, 
+            crop_coords_list, 
+            monitor_width, 
+            monitor_height
+        )
+        
+        # 4. Use Google Lens on the cleaner composite image for higher accuracy
+        res, text, coords = self.lens(
+            composite_image,
+            return_coords=True,
+            furigana_filter_sensitivity=0
+        )
+        
+        if not res or not coords:
+            return []
+        
+        # 5. Process the high-accuracy results into the desired format
+        extracted_data = self._extract_text_with_pixel_boxes(
+            api_response=coords,
+            original_width=monitor_width,
+            original_height=monitor_height,
+            crop_x=0,
+            crop_y=0,
+            crop_width=composite_image.width,
+            crop_height=composite_image.height
+        )
+        
+        return extracted_data
+
+    def _extract_text_with_pixel_boxes(
+        self,
+        api_response: Dict[str, Any],
+        original_width: int,
+        original_height: int,
+        crop_x: int,
+        crop_y: int,
+        crop_width: int,
+        crop_height: int
+    ) -> List[Dict[str, Any]]:
+        """
+        Parses Google Lens API response and converts normalized coordinates
+        to absolute pixel coordinates.
+        """
+        results = []
+        try:
+            paragraphs = api_response["objects_response"]["text"]["text_layout"]["paragraphs"]
+        except (KeyError, TypeError):
+            return []  # Return empty if the expected structure isn't present
+
+        for para in paragraphs:
+            for line in para.get("lines", []):
+                line_text_parts = []
+                word_list = []
+
+                for word in line.get("words", []):
+                    word_text = word.get("plain_text", "")
+                    line_text_parts.append(word_text)
+                    
+                    word_box = self._convert_box_to_pixels_v2(
+                        word["geometry"]["bounding_box"],
+                        crop_x, crop_y, crop_width, crop_height
+                    )
+                    
+                    word_list.append({
+                        "text": word_text,
+                        "bounding_rect": word_box
+                    })
+                
+                if not line_text_parts:
+                    continue
+                
+                full_line_text = "".join(line_text_parts)
+                line_box = self._convert_box_to_pixels_v2(
+                    line["geometry"]["bounding_box"],
+                    crop_x, crop_y, crop_width, crop_height
+                )
+
+                results.append({
+                    "text": full_line_text,
+                    "bounding_rect": line_box,
+                    "words": word_list
+                })
+        return results
+
+    def _convert_box_to_pixels_v2(
+        self,
+        bbox_data: Dict[str, float],
+        crop_x: int,
+        crop_y: int,
+        crop_width: int,
+        crop_height: int
+    ) -> Dict[str, float]:
+        """
+        Simplified conversion: scales normalized bbox to pixel coordinates within
+        the cropped region, then offsets by the crop position. Ignores rotation.
+        """
+        cx, cy = bbox_data['center_x'], bbox_data['center_y']
+        w, h = bbox_data['width'], bbox_data['height']
+
+        # Scale normalized coordinates to pixel coordinates relative to the crop area
+        box_width_px = w * crop_width
+        box_height_px = h * crop_height
+        
+        # Calculate center within the cropped area and then add the crop offset
+        center_x_px = (cx * crop_width) + crop_x
+        center_y_px = (cy * crop_height) + crop_y
+
+        # Calculate corners (unrotated)
+        half_w_px, half_h_px = box_width_px / 2, box_height_px / 2
+        return {
+            "x1": center_x_px - half_w_px, "y1": center_y_px - half_h_px,
+            "x2": center_x_px + half_w_px, "y2": center_y_px - half_h_px,
+            "x3": center_x_px + half_w_px, "y3": center_y_px + half_h_px,
+            "x4": center_x_px - half_w_px, "y4": center_y_px + half_h_px,
+        }
+
+async def main_test_screenshot():
+    """
+    A test function to demonstrate screenshot and image composition.
+    This is preserved from your original __main__ block.
+    """
+    processor = OverlayProcessor()
+    
+    # Use the class method to get the screenshot
+    img, monitor_width, monitor_height = processor._get_full_screenshot()
+    if not img:
+        logger.error("Could not get screenshot for test.")
+        return
+        
+    img.show()
+    
+    # Create a transparent image with the same size as the monitor
+    new_img = Image.new("RGBA", (monitor_width, monitor_height), (0, 0, 0, 0))
+    
+    # Calculate coordinates to center the captured image (if it's not full-screen)
+    left = (monitor_width - img.width) // 2
+    top = (monitor_height - img.height) // 2
+    
+    print(f"Image size: {img.size}, Monitor size: {monitor_width}x{monitor_height}")
+    print(f"Pasting at: Left={left}, Top={top}")
+    
+    new_img.paste(img, (left, top))
+    new_img.show()
+
+async def main_run_ocr():
+    """
+    Main function to demonstrate running the full OCR process.
+    """
+    processor = OverlayProcessor()
+    results, _ = await processor.find_box_for_sentence()
+    if results:
+        import json
+        print("OCR process completed successfully.")
+        # print(json.dumps(results, indent=2, ensure_ascii=False))
+        # Find first result with some text
+        for result in results:
+            if result.get("text"):
+                print(f"Found line: '{result['text']}'")
+                print(f"  - Line BBox: {result['bounding_rect']}")
+                if result.get("words"):
+                    print(f"  - First word: '{result['words'][0]['text']}' BBox: {result['words'][0]['bounding_rect']}")
+                break
+    else:
+        print("OCR process did not find any text.")
+
+
+if __name__ == '__main__':
+    try:
+        # To run the screenshot test:
+        # asyncio.run(main_test_screenshot())
+        
+        # To run the full OCR process:
+        asyncio.run(main_run_ocr())
+
+    except KeyboardInterrupt:
+        logger.info("Script terminated by user.")
+    except Exception as e:
+        logger.error(f"An error occurred in the main execution block: {e}", exc_info=True)

GameSentenceMiner/util/model.py

@@ -109,12 +109,18 @@ class SceneListResponse:
 #     videoActive: bool
 #     videoShowing: bool
 
+@dataclass_json
+@dataclass
+class AnkiField:
+    value: str
+    order: int
+
 @dataclass_json
 @dataclass
 class AnkiCard:
     noteId: int
     tags: list[str]
-    fields: dict[str, dict[str, str]]
+    fields: dict[str, AnkiField]
     cards: list[int]
     alternatives = {
         "word_field": ["Front", "Word", "TargetWord", "Expression"],
@@ -125,7 +131,7 @@ class AnkiCard:
 
     def get_field(self, field_name: str) -> str:
         if self.has_field(field_name):
-            return self.fields[field_name]['value']
+            return self.fields[field_name].value
         else:
             raise ValueError(f"Field '{field_name}' not found in AnkiCard. Please make sure your Anki Field Settings in GSM Match your fields in your Anki Note!")
 

GameSentenceMiner/util/text_log.py

@@ -129,7 +129,7 @@ def lines_match(texthooker_sentence, anki_sentence):
         logger.debug(f"One contains the other: {texthooker_sentence} in {anki_sentence} - Similarity: {similarity}")
     elif anki_sentence in texthooker_sentence:
         logger.debug(f"One contains the other: {anki_sentence} in {texthooker_sentence} - Similarity: {similarity}")
-    return (anki_sentence in texthooker_sentence) or (texthooker_sentence in anki_sentence and similarity > 80)
+    return (anki_sentence in texthooker_sentence) or (texthooker_sentence in anki_sentence) or (similarity >= 80)
 
 
 def get_text_event(last_note) -> GameLine:

GameSentenceMiner/web/texthooking_page.py

@@ -523,7 +523,7 @@ if get_config().advanced.plaintext_websocket_port:
     plaintext_websocket_server_thread.start()
 
 overlay_server_thread = WebsocketServerThread(
-    read=False, get_ws_port_func=lambda: get_config().get_field_value('wip', 'overlay_websocket_port'))
+    read=False, get_ws_port_func=lambda: get_config().get_field_value('overlay', 'websocket_port'))
 overlay_server_thread.start()
 
 websocket_server_threads = [

{gamesentenceminer-2.13.15.dist-info → gamesentenceminer-2.14.0rc1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GameSentenceMiner
-Version: 2.13.15
+Version: 2.14.0rc1
 Summary: A tool for mining sentences from games. Update: Overlay?
 Author-email: Beangate <bpwhelan95@gmail.com>
 License: MIT License
@@ -39,4 +39,8 @@ Requires-Dist: obsws-python~=1.7.2
 Requires-Dist: matplotlib
 Requires-Dist: sounddevice
 Requires-Dist: google-genai
+Requires-Dist: owocr
+Requires-Dist: betterproto==2.0.0b7
+Requires-Dist: oneocr
+Requires-Dist: openai
 Dynamic: license-file

{gamesentenceminer-2.13.15.dist-info → gamesentenceminer-2.14.0rc1.dist-info}/RECORD

@@ -1,12 +1,12 @@
 GameSentenceMiner/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-GameSentenceMiner/anki.py,sha256=zBvKvu-LBaUmG1bUNLq9QXmVoPidqZCxJn4UPw6pUug,21041
-GameSentenceMiner/config_gui.py,sha256=nrOGhYuvHxvJ0mmlXsK5ANtaie_ztMNOWf-iwxLEkeM,125738
-GameSentenceMiner/gametext.py,sha256=h6IOGesK79X8IlvqqMmSzRkSVtkPAXDMHrkQsBwEV1E,10879
-GameSentenceMiner/gsm.py,sha256=daUAD_kr5nEG0WjPxMDq2PVSLXfx4dQ73OvTUWX9AlQ,28298
+GameSentenceMiner/anki.py,sha256=mNUU0AYwsDezVug-ZXDpR71R9GGUBsmc9Gu8ftfnpf4,23078
+GameSentenceMiner/config_gui.py,sha256=dFN-2mD9JTcRhjFIjaj4bFcEmMAdjudYk_A5x9rp3_U,134126
+GameSentenceMiner/gametext.py,sha256=2MHOLuuXAxrhs0tkwh9JW_BYHQ7YMf-lHfO2Kl3ACDs,10244
+GameSentenceMiner/gsm.py,sha256=GdqegZnKrTMVRvp43bK7oNlWj5OxLx2PNdVWyHL9Gc4,28282
 GameSentenceMiner/obs.py,sha256=smlP_BFuuMkASVDEPG3DjxJ6p617kZXuNTeQ0edtH64,18703
 GameSentenceMiner/vad.py,sha256=zFReBMvNEEaQ_YEozCTCaMdV-o40FwtlxYRb17cYZio,19125
 GameSentenceMiner/ai/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-GameSentenceMiner/ai/ai_prompting.py,sha256=iHkEx2pQJ-tEyejOgYy4G0DcZc8qvBugVL6-CQpPSME,26089
+GameSentenceMiner/ai/ai_prompting.py,sha256=gNNDkoXVjWU8-is1CVI08ir2Jo_DpGvCWkV8TLl74Gg,23375
 GameSentenceMiner/assets/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 GameSentenceMiner/assets/icon.png,sha256=9GRL8uXUAgkUSlvbm9Pv9o2poFVRGdW6s2ub_DeUD9M,937624
 GameSentenceMiner/assets/icon128.png,sha256=l90j7biwdz5ahwOd5wZ-406ryEV9Pan93dquJQ3e1CI,18395
@@ -15,9 +15,9 @@ GameSentenceMiner/assets/icon32.png,sha256=Kww0hU_qke9_22wBuO_Nq0Dv2SfnOLwMhCyGg
 GameSentenceMiner/assets/icon512.png,sha256=HxUj2GHjyQsk8NV433256UxU9phPhtjCY-YB_7W4sqs,192487
 GameSentenceMiner/assets/icon64.png,sha256=N8xgdZXvhqVQP9QUK3wX5iqxX9LxHljD7c-Bmgim6tM,9301
 GameSentenceMiner/assets/pickaxe.png,sha256=VfIGyXyIZdzEnVcc4PmG3wszPMO1W4KCT7Q_nFK6eSE,1403829
-GameSentenceMiner/locales/en_us.json,sha256=9aFJw4vls269_ufnVx03uRLXG8-E-hdG9hJ9RVzM01I,25653
-GameSentenceMiner/locales/ja_jp.json,sha256=zx5R_DLsdUw9Szg7RrOkRprMcnumM5Bnl4QhsfOj-qM,27190
-GameSentenceMiner/locales/zh_cn.json,sha256=fwP5GQh0WkftdpXuyyt9IiaEIPK_ZXtEa_3kmoeQMAk,24198
+GameSentenceMiner/locales/en_us.json,sha256=MYcOLgjOIpzWwC0WCPvsbIvGQ9qRIhLCZ1DlHcGQfko,25942
+GameSentenceMiner/locales/ja_jp.json,sha256=2I-aSs6KIbjJ7uNRA-dx_5oRP9JLTWWUIrMMZOkenlE,27520
+GameSentenceMiner/locales/zh_cn.json,sha256=tx9Szm6KEMn_YaYDWS1ph4pGALYR3iguVru2Dfj7S3o,24047
 GameSentenceMiner/ocr/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 GameSentenceMiner/ocr/gsm_ocr_config.py,sha256=1cuFYT2LN_A2WjCqm2FsiHqM93EG2zIbB4ZWxps829Y,5791
 GameSentenceMiner/ocr/ocrconfig.py,sha256=_tY8mjnzHMJrLS8E5pHqYXZjMuLoGKYgJwdhYgN-ny4,6466
@@ -28,21 +28,23 @@ GameSentenceMiner/owocr/owocr/__init__.py,sha256=87hfN5u_PbL_onLfMACbc0F5j4KyIK9
 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=beArOJgVPhK7aeEwC5qAdbXzGRkNIpGNiM8rAnQ6cbg,68508
+GameSentenceMiner/owocr/owocr/ocr.py,sha256=OeGPD6NgwKXkmgVTQfo3gulNLXwnBP7zltyKPZKPB1I,68365
 GameSentenceMiner/owocr/owocr/run.py,sha256=TSSZnHO_sPoTtUCsDol-v4TWPPzz_Nbf24TeBUea5I4,68498
 GameSentenceMiner/owocr/owocr/screen_coordinate_picker.py,sha256=Na6XStbQBtpQUSdbN3QhEswtKuU1JjReFk_K8t5ezQE,3395
+GameSentenceMiner/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+GameSentenceMiner/tools/audio_offset_selector.py,sha256=8Stk3BP-XVIuzRv9nl9Eqd2D-1yD3JrgU-CamBywJmY,8542
+GameSentenceMiner/tools/ss_selector.py,sha256=cbjMxiKOCuOfbRvLR_PCRlykBrGtm1LXd6u5czPqkmc,4793
+GameSentenceMiner/tools/window_transparency.py,sha256=GtbxbmZg0-UYPXhfHff-7IKZyY2DKe4B9GdyovfmpeM,8166
 GameSentenceMiner/util/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-GameSentenceMiner/util/audio_offset_selector.py,sha256=8Stk3BP-XVIuzRv9nl9Eqd2D-1yD3JrgU-CamBywJmY,8542
-GameSentenceMiner/util/configuration.py,sha256=p0ZnrPa0UTFzj59y__pNy0aWOxjlHz1fURZI33qWu74,37184
+GameSentenceMiner/util/configuration.py,sha256=SODstU9nrRRAmbPrubYHJuGzzuKXURNUEQQPrfa9_1o,39739
+GameSentenceMiner/util/db.py,sha256=2bO0rD4i8A1hhsRBER-wgZy9IK17ibRbI8DHxdKvYsI,16598
 GameSentenceMiner/util/electron_config.py,sha256=9CA27nzEFlxezzDqOPHxeD4BdJ093AnSJ9DJTcwWPsM,8762
-GameSentenceMiner/util/ffmpeg.py,sha256=HI2H_prbiZtLtLQgYOj1QNu0Ik_8Du_7gtoHftaz1g4,23520
+GameSentenceMiner/util/ffmpeg.py,sha256=iqsdp3TbBv6KMACJxkUF3e5VWak3jHPZdIEMrUdKFtE,23073
+GameSentenceMiner/util/get_overlay_coords.py,sha256=zBDFSWVdBLYZQcwdICQe9stg1mG0UHnJHupkuZGlJY8,12042
 GameSentenceMiner/util/gsm_utils.py,sha256=Piwv88Q9av2LBeN7M6QDi0Mp0_R2lNbkcI6ekK5hd2o,11851
-GameSentenceMiner/util/model.py,sha256=hmA_seopP2bK40v9T4ulua9TrAeWtbkdCv-sTBPBQDk,6660
+GameSentenceMiner/util/model.py,sha256=R-_RYTYLSDNgBoVTPuPBcIHeOznIqi_vBzQ7VQ20WYk,6727
 GameSentenceMiner/util/notification.py,sha256=-qk3kTKEERzmMxx5XMh084HCyFmbfqz0XjY1hTKhCeQ,4202
-GameSentenceMiner/util/package.py,sha256=u1ym5z869lw5EHvIviC9h9uH97bzUXSXXA8KIn8rUvk,1157
-GameSentenceMiner/util/ss_selector.py,sha256=cbjMxiKOCuOfbRvLR_PCRlykBrGtm1LXd6u5czPqkmc,4793
-GameSentenceMiner/util/text_log.py,sha256=TnrwoB830wzLEnur57uZoWg-agi5vxPYFnd2GipWaFE,6729
-GameSentenceMiner/util/window_transparency.py,sha256=GtbxbmZg0-UYPXhfHff-7IKZyY2DKe4B9GdyovfmpeM,8166
+GameSentenceMiner/util/text_log.py,sha256=zB9--7J_Wwck74IOEI4aWhmCYouqjSE6Sm0sCznF63Q,6731
 GameSentenceMiner/util/communication/__init__.py,sha256=xh__yn2MhzXi9eLi89PeZWlJPn-cbBSjskhi1BRraXg,643
 GameSentenceMiner/util/communication/send.py,sha256=Wki9qIY2CgYnuHbmnyKVIYkcKAN_oYS4up93XMikBaI,222
 GameSentenceMiner/util/communication/websocket.py,sha256=TbphRGmxVrgEupS7tNdifsmQfWDfIp0Hio2cSiUKgsk,3317
@@ -52,7 +54,7 @@ GameSentenceMiner/util/downloader/download_tools.py,sha256=zR-aEHiFVkyo-9oPoSx6n
 GameSentenceMiner/util/downloader/oneocr_dl.py,sha256=l3s9Z-x1b57GX048o5h-MVv0UTZo4H-Q-zb-JREkMLI,10439
 GameSentenceMiner/web/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 GameSentenceMiner/web/service.py,sha256=YZchmScTn7AX_GkwV1ULEK6qjdOnJcpc3qfMwDf7cUE,5363
-GameSentenceMiner/web/texthooking_page.py,sha256=qCNtWtWZAiC91uPrHD2LUWdHOufVuzDhTyTH8Z4oXXk,17927
+GameSentenceMiner/web/texthooking_page.py,sha256=EBdP6v_CCEr-7MCRAkBSBf5Y59E4JBkneifQ1Pgq76I,17923
 GameSentenceMiner/web/static/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 GameSentenceMiner/web/static/apple-touch-icon.png,sha256=OcMI8af_68DA_tweOsQ5LytTyMwm7-hPW07IfrOVgEs,46132
 GameSentenceMiner/web/static/favicon-96x96.png,sha256=lOePzjiKl1JY2J1kT_PMdyEnrlJmi5GWbmXJunM12B4,16502
@@ -66,10 +68,10 @@ GameSentenceMiner/web/templates/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm
 GameSentenceMiner/web/templates/index.html,sha256=Gv3CJvNnhAzIVV_QxhNq4OD-pXDt1vKCu9k6WdHSXuA,215343
 GameSentenceMiner/web/templates/text_replacements.html,sha256=tV5c8mCaWSt_vKuUpbdbLAzXZ3ATZeDvQ9PnnAfqY0M,8598
 GameSentenceMiner/web/templates/utility.html,sha256=3flZinKNqUJ7pvrZk6xu__v67z44rXnaK7UTZ303R-8,16946
-GameSentenceMiner/wip/get_overlay_coords.py,sha256=IK3ZLKOygHmk02bUGl7GDQF7LV_FEDmSMWRniWGPvBk,20435
-gamesentenceminer-2.13.15.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-gamesentenceminer-2.13.15.dist-info/METADATA,sha256=ovhoy-qvPB2qkIRV9pqrj3DkRg9nZbAPikRNBABW9os,1464
-gamesentenceminer-2.13.15.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-gamesentenceminer-2.13.15.dist-info/entry_points.txt,sha256=2APEP25DbfjSxGeHtwBstMH8mulVhLkqF_b9bqzU6vQ,65
-gamesentenceminer-2.13.15.dist-info/top_level.txt,sha256=V1hUY6xVSyUEohb0uDoN4UIE6rUZ_JYx8yMyPGX4PgQ,18
-gamesentenceminer-2.13.15.dist-info/RECORD,,
+GameSentenceMiner/wip/__init___.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+gamesentenceminer-2.14.0rc1.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+gamesentenceminer-2.14.0rc1.dist-info/METADATA,sha256=Dtctsp_KYbHfrXer_6_pAzok5waimQ_OKsBPzCzQKZ8,1567
+gamesentenceminer-2.14.0rc1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+gamesentenceminer-2.14.0rc1.dist-info/entry_points.txt,sha256=2APEP25DbfjSxGeHtwBstMH8mulVhLkqF_b9bqzU6vQ,65
+gamesentenceminer-2.14.0rc1.dist-info/top_level.txt,sha256=V1hUY6xVSyUEohb0uDoN4UIE6rUZ_JYx8yMyPGX4PgQ,18
+gamesentenceminer-2.14.0rc1.dist-info/RECORD,,

GameSentenceMiner/util/package.py

@@ -1,37 +0,0 @@
-from importlib import metadata
-
-import requests
-
-from GameSentenceMiner.util.configuration import logger
-
-PACKAGE_NAME = "GameSentenceMiner"
-
-def get_current_version():
-    try:
-        version = metadata.version(PACKAGE_NAME)
-        return version
-    except metadata.PackageNotFoundError:
-        return None
-
-def get_latest_version():
-    try:
-        response = requests.get(f"https://pypi.org/pypi/{PACKAGE_NAME}/json")
-        latest_version = response.json()["info"]["version"]
-        return latest_version
-    except Exception as e:
-        logger.error(f"Error fetching latest version: {e}")
-        return None
-
-def check_for_updates(force=False):
-    try:
-        installed_version = get_current_version()
-        latest_version = get_latest_version()
-
-        if installed_version != latest_version or force:
-            logger.info(f"Update available: {installed_version} -> {latest_version}")
-            return True, latest_version
-        else:
-            logger.info("You are already using the latest version.")
-            return False, latest_version
-    except Exception as e:
-        logger.error(f"Error checking for updates: {e}")