GameSentenceMiner 2.19.2.dev0__py3-none-any.whl → 2.19.4__py3-none-any.whl

GameSentenceMiner/anki.py

@@ -559,10 +559,10 @@ def update_new_card():
     else:
         logger.info("New card(s) detected! Added to Processing Queue!")
         gsm_state.last_mined_line = game_line
-        queue_card_for_processing(last_card, lines)
+        queue_card_for_processing(last_card, lines, game_line)
         
-def queue_card_for_processing(last_card, lines):
-    card_queue.append((last_card, datetime.now(), lines))
+def queue_card_for_processing(last_card, lines, last_mined_line):
+    card_queue.append((last_card, datetime.now(), lines, last_mined_line))
     texthooking_page.reset_checked_lines()
     try:
         obs.save_replay_buffer()

GameSentenceMiner/gsm.py

@@ -32,7 +32,7 @@ try:
 
     import keyboard
     import ttkbootstrap as ttk
-    from PIL import Image, ImageDraw
+    from PIL import Image
     from pystray import Icon, Menu, MenuItem
     from watchdog.events import FileSystemEventHandler
     from watchdog.observers import Observer
@@ -187,7 +187,7 @@ class VideoToAudioHandler(FileSystemEventHandler):
             return
         try:
             if anki.card_queue and len(anki.card_queue) > 0:
-                last_note, anki_card_creation_time, selected_lines = anki.card_queue.pop(
+                last_note, anki_card_creation_time, selected_lines, mined_line = anki.card_queue.pop(
                     0)
             else:
                 logger.info(
@@ -211,11 +211,11 @@ class VideoToAudioHandler(FileSystemEventHandler):
             full_text = ''
             if selected_lines:
                 start_line = selected_lines[0]
-                mined_line = get_mined_line(last_note, selected_lines)
+                # mined_line = get_mined_line(last_note, selected_lines)
                 line_cutoff = selected_lines[-1].get_next_time()
                 full_text = remove_html_and_cloze_tags(note['fields'][get_config().anki.sentence_field])
             else:
-                mined_line = get_text_event(last_note)
+                # mined_line = get_text_event(last_note)
                 if mined_line:
                     start_line = mined_line
                     if mined_line.next:

GameSentenceMiner/obs.py

@@ -64,7 +64,8 @@ class OBSConnectionPool:
             except Exception as e:
                 if str(e) == self.last_error_shown[i]:
                     continue
-                logger.error(f"Failed to create client {i} in pool: {e}")
+                if self.connected_once:
+                    logger.error(f"Failed to create client {i} in pool during initial connection: {e}")
                 self.last_error_shown[i] = str(e)
         return True
 

GameSentenceMiner/ocr/owocr_helper.py

@@ -344,15 +344,75 @@ def reset_callback_vars():
 
 #     def get_ocr_ocr2(self):
 #         return self.ocr2
+last_meiki_crop_coords = None
+last_meiki_crop_time = None
+last_meiki_success = None
 
-def text_callback(text, orig_text, time, img=None, came_from_ss=False, filtering=None, crop_coords=None):
-    global twopassocr, ocr2, previous_text, last_oneocr_time, text_stable_start_time, previous_orig_text, previous_img, force_stable, previous_ocr1_result, previous_text_list, last_sent_result
+
+def text_callback(text, orig_text, time, img=None, came_from_ss=False, filtering=None, crop_coords=None, meiki_boxes=None):
+    global twopassocr, ocr2, previous_text, last_oneocr_time, text_stable_start_time, previous_orig_text, previous_img, force_stable, previous_ocr1_result, previous_text_list, last_sent_result, last_meiki_crop_coords, last_meiki_success, last_meiki_crop_time
     orig_text_string = ''.join([item for item in orig_text if item is not None]) if orig_text else ""
     if came_from_ss:
         save_result_image(img)
         asyncio.run(send_result(text, time))
         return
-    
+        
+    if meiki_boxes:
+        # If we don't have a previous meiki crop coords, store this one and wait for the next run
+        try:
+            if last_meiki_crop_coords is None:
+                last_meiki_crop_coords = crop_coords
+                last_meiki_crop_time = time
+                previous_img = img
+                return
+
+            # Ensure both coords exist
+            if not crop_coords or not last_meiki_crop_coords:
+                last_meiki_crop_coords = crop_coords
+                last_meiki_crop_time = time
+                return
+
+            # Compare coordinates within tolerance (pixels)
+            tol = 5
+            try:
+                close = all(abs(int(crop_coords[i]) - int(last_meiki_crop_coords[i])) <= tol for i in range(4))
+            except Exception:
+                # Fallback: if values not int-convertible, set not close
+                close = False
+                
+            if close:
+                if all(last_meiki_success and abs(int(crop_coords[i]) - int(last_meiki_success[i])) <= tol for i in range(4)):
+                    # Reset last_meiki_crop_coords and time so we require another matching pair for a future queue
+                    last_meiki_crop_coords = None
+                    last_meiki_crop_time = None
+                    return
+                # Stable crop: queue second OCR immediately
+                try:
+                    stable_time = last_meiki_crop_time
+                    previous_img_local = previous_img
+                    pre_crop_image = previous_img_local
+                    ocr2_image = get_ocr2_image(crop_coords, og_image=previous_img_local, ocr2_engine=get_ocr_ocr2())
+                    # Use the earlier timestamp for when the stable crop started if available
+                    # ocr2_image.show()
+                    second_ocr_queue.put((text, stable_time, ocr2_image, filtering, pre_crop_image))
+                    run.set_last_image(img)
+                    last_meiki_success = crop_coords
+                except Exception as e:
+                    logger.info(f"Failed to queue second OCR task: {e}", exc_info=True)
+                # Reset last_meiki_crop_coords and time so we require another matching pair for a future queue
+                last_meiki_crop_coords = None
+                last_meiki_crop_time = None
+                return
+            else:
+                # Not stable: replace last and wait for the next run
+                last_meiki_crop_coords = crop_coords
+                last_meiki_success = None
+                previous_img = img
+                return
+        except Exception as e:
+            logger.debug(f"Error handling meiki crop coords stability check: {e}")
+            last_meiki_crop_coords = crop_coords
+            
     if not text:
         run.set_last_image(img)
 

GameSentenceMiner/owocr/owocr/ocr.py

@@ -1539,6 +1539,579 @@ class localLLMOCR:
                 return (True, "")
         except Exception as e:
             return (False, f'Local LLM OCR request failed: {e}')
+        
+import os
+import onnxruntime as ort
+import numpy as np
+import cv2
+from huggingface_hub import hf_hub_download
+from PIL import Image
+import requests
+from io import BytesIO
+
+# --- HELPER FUNCTION FOR VISUALIZATION (Optional but useful) ---
+def draw_detections(image: np.ndarray, detections: list, model_name: str) -> np.ndarray:
+    """
+    Draws bounding boxes from the detection results onto an image.
+
+    Args:
+        image (np.ndarray): The original image (in BGR format).
+        detections (list): A list of detection dictionaries, e.g., [{"box": [x1, y1, x2, y2], "score": 0.95}, ...].
+        model_name (str): The name of the model ('tiny' or 'small') to determine box color.
+
+    Returns:
+        np.ndarray: The image with bounding boxes drawn on it.
+    """
+    output_image = image.copy()
+    color = (0, 255, 0) if model_name == "small" else (0, 0, 255) # Green for small, Blue for tiny
+    
+    for detection in detections:
+        box = detection['box']
+        score = detection['score']
+        
+        # Ensure coordinates are integers for drawing
+        x_min, y_min, x_max, y_max = map(int, box)
+        
+        # Draw the rectangle
+        cv2.rectangle(output_image, (x_min, y_min), (x_max, y_max), color, 2)
+        
+        # Optionally, add the score text
+        label = f"{score:.2f}"
+        cv2.putText(output_image, label, (x_min, y_min - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, color, 2)
+        
+    return output_image
+
+
+class MeikiTextDetector:
+    """
+    A class to perform text detection using the meiki.text.detect.v0 models.
+    
+    This class handles downloading the ONNX models from the Hugging Face Hub,
+    loading them into an ONNX Runtime session, and providing a simple interface
+    for inference.
+    """
+    name = 'meiki_text_detector'
+    readable_name = 'Meiki Text Detector'
+    available = False
+    key = ']'
+
+    def __init__(self, model_name: str = 'tiny'):
+        """
+        Initializes the detector by downloading and loading the specified ONNX model.
+
+        Args:
+            model_name (str): The model to use, either "tiny" or "small". 
+                              Defaults to "small".
+        """
+        if model_name not in ['tiny', 'small']:
+            raise ValueError("model_name must be either 'tiny' or 'small'")
+        
+        ort.preload_dlls(cuda=True, directory=None)
+
+        self.model_name = model_name
+        self.session = None
+        
+        # --- Model-specific parameters ---
+        if self.model_name == "tiny":
+            self.model_size = 320
+            self.is_color = False
+            self.onnx_filename = "meiki.text.detect.tiny.v0.onnx"
+        else: # "small"
+            self.model_size = 640
+            self.is_color = True
+            self.onnx_filename = "meiki.text.detect.small.v0.onnx"
+
+        try:
+            print(f"Initializing MeikiTextDetector with '{self.model_name}' model...")
+            MODEL_REPO = "rtr46/meiki.text.detect.v0"
+            
+            # Download the model file from the Hub and get its local path
+            model_path = hf_hub_download(repo_id=MODEL_REPO, filename=self.onnx_filename)
+            
+            # Load the ONNX model into an inference session
+            # providers = ['CUDAExecutionProvider']
+            providers = ['CPUExecutionProvider']
+            self.session = ort.InferenceSession(model_path, providers=providers)
+            
+            self.available = True
+            print("Model loaded successfully. MeikiTextDetector is ready.")
+            
+        except Exception as e:
+            print(f"Error initializing MeikiTextDetector: {e}")
+            self.available = False
+
+    def _resize_and_pad(self, image: np.ndarray):
+        """ 
+        Resizes and pads an image to the model's expected square size,
+        preserving the aspect ratio.
+        """
+        if self.is_color:
+            h, w, _ = image.shape
+        else:
+            h, w = image.shape
+
+        size = self.model_size
+        ratio = min(size / w, size / h)
+        new_w, new_h = int(w * ratio), int(h * ratio)
+        
+        resized_image = cv2.resize(image, (new_w, new_h), interpolation=cv2.INTER_LINEAR)
+        
+        if self.is_color:
+            padded_image = np.zeros((size, size, 3), dtype=np.uint8)
+        else:
+            padded_image = np.zeros((size, size), dtype=np.uint8)
+            
+        pad_w, pad_h = (size - new_w) // 2, (size - new_h) // 2
+        padded_image[pad_h:pad_h + new_h, pad_w:pad_w + new_w] = resized_image
+        
+        return padded_image, ratio, pad_w, pad_h
+
+    def __call__(self, img, confidence_threshold: float = 0.4):
+        """
+        Performs text detection on an input image.
+
+        Args:
+            img: The input image. Can be a file path, URL, PIL Image, or a NumPy array (BGR format).
+            confidence_threshold (float): The threshold to filter out low-confidence detections.
+
+        Returns:
+            A list of dictionaries, where each dictionary represents a detected
+            text box and contains 'box' (a list of [x_min, y_min, x_max, y_max])
+            and 'score' (a float). Returns an empty list if no boxes are found.
+        """
+        if confidence_threshold is None:
+            confidence_threshold = 0.4
+        if not self.available:
+            raise RuntimeError("MeikiTextDetector is not available due to an initialization error.")
+
+        # --- Input Handling ---
+        if isinstance(img, str):
+            if img.startswith('http'):
+                response = requests.get(img)
+                pil_image = Image.open(BytesIO(response.content)).convert("RGB")
+            else:
+                pil_image = Image.open(img).convert("RGB")
+            # Convert PIL (RGB) to OpenCV (BGR) format
+            input_image = cv2.cvtColor(np.array(pil_image), cv2.COLOR_RGB2BGR)
+        elif isinstance(img, Image.Image):
+             # Convert PIL (RGB) to OpenCV (BGR) format
+            input_image = cv2.cvtColor(np.array(img.convert("RGB")), cv2.COLOR_RGB2BGR)
+        elif isinstance(img, np.ndarray):
+            input_image = img
+        else:
+            raise TypeError("Unsupported input type for 'img'. Use a file path, URL, PIL Image, or NumPy array.")
+
+
+        # --- Preprocessing ---
+        if self.is_color:
+            image_for_model = input_image
+        else:
+            image_for_model = cv2.cvtColor(input_image, cv2.COLOR_BGR2GRAY)
+            
+        padded_image, ratio, pad_w, pad_h = self._resize_and_pad(image_for_model)
+        img_normalized = padded_image.astype(np.float32) / 255.0
+
+        if self.is_color:
+            img_transposed = np.transpose(img_normalized, (2, 0, 1))
+            input_tensor = np.expand_dims(img_transposed, axis=0)
+        else:
+            input_tensor = np.expand_dims(np.expand_dims(img_normalized, axis=0), axis=0)
+
+        # --- Inference ---
+        sizes_tensor = np.array([[self.model_size, self.model_size]], dtype=np.int64)
+        input_names = [inp.name for inp in self.session.get_inputs()]
+        inputs = {input_names[0]: input_tensor, input_names[1]: sizes_tensor}
+        
+        outputs = self.session.run(None, inputs)
+        
+        # print(outputs)
+
+        # --- Post-processing ---
+        if self.model_name == "tiny":
+            boxes = outputs[0]
+            scores = [1.0] * len(boxes) # Tiny model doesn't output scores
+        else: # "small"
+            _, boxes, scores = outputs
+            boxes, scores = boxes[0], scores[0]
+        
+        detections = []
+        for box, score in zip(boxes, scores):
+            if score < confidence_threshold:
+                continue
+            
+            x_min, y_min, x_max, y_max = box
+            
+            # Rescale box coordinates to the original image size
+            final_x_min = (x_min - pad_w) / ratio
+            final_y_min = (y_min - pad_h) / ratio
+            final_x_max = (x_max - pad_w) / ratio
+            final_y_max = (y_max - pad_h) / ratio
+            
+            detections.append({
+                "box": [final_x_min, final_y_min, final_x_max, final_y_max],
+                "score": float(score)
+            })
+            
+        # print(f"Processed with '{self.model_name}' model. Found {len(detections)} boxes with confidence > {confidence_threshold}.")
+
+        # Compute crop_coords as padded min/max of all detected boxes
+        if detections:
+            x_mins = [b['box'][0] for b in detections]
+            y_mins = [b['box'][1] for b in detections]
+            x_maxs = [b['box'][2] for b in detections]
+            y_maxs = [b['box'][3] for b in detections]
+
+            pad = 5
+            crop_xmin = min(x_mins) - pad
+            crop_ymin = min(y_mins) - pad
+            crop_xmax = max(x_maxs) + pad
+            crop_ymax = max(y_maxs) + pad
+
+            # Clamp to image bounds
+            h, w = input_image.shape[:2]
+            crop_xmin = max(0, int(floor(crop_xmin)))
+            crop_ymin = max(0, int(floor(crop_ymin)))
+            crop_xmax = min(w, int(floor(crop_xmax)))
+            crop_ymax = min(h, int(floor(crop_ymax)))
+
+            crop_coords = [crop_xmin, crop_ymin, crop_xmax, crop_ymax]
+        else:
+            crop_coords = None
+
+        resp = {
+            "boxes": detections,
+            "provider": 'meiki',
+            "crop_coords": crop_coords
+        }
+
+        return True, resp
+
+
+# --- EXAMPLE USAGE ---
+if __name__ == '__main__':
+    import datetime
+    # You can choose 'tiny' or 'small' here
+    meiki = MeikiTextDetector(model_name='small')
+    # Example: run a short warm-up then measure average over N runs
+    image_path = r"C:\Users\Beangate\GSM\GameSentenceMiner\GameSentenceMiner\owocr\owocr\lotsofsmalltext.png"
+    video_path = r"C:\Users\Beangate\GSM\GameSentenceMiner\GameSentenceMiner\owocr\owocr\tanetsumi_CdACfZkwMY.mp4"
+    # Warm-up run (helps with any one-time setup cost)
+    try:
+        _ = meiki(image_path, confidence_threshold=0.4)
+    except Exception as e:
+        print(f"Error running MeikiTextDetector on warm-up: {e}")
+        raise
+
+    # runs = 500
+    times = []
+    detections_list = []
+    # for i in range(runs):
+    #     start_time = datetime.datetime.now()
+    #     res, resp_dict = meiki(image_path, confidence_threshold=0.4)
+    #     detections = resp_dict['boxes']
+    #     dections_list.append(detections)
+    #     end_time = datetime.datetime.now()
+    #     times.append((end_time - start_time).total_seconds())
+    
+    # Process video frame by frame with cv2 (sample at ~10 FPS)
+    cap = cv2.VideoCapture(video_path)
+    try:
+        src_fps = cap.get(cv2.CAP_PROP_FPS) or 30.0
+    except Exception:
+        src_fps = 30.0
+
+    target_fps = 10
+    sample_interval = max(1, int(round(src_fps / target_fps)))
+    runs = 0
+    last_detections = []
+    pil_img = None
+
+    while True:
+        ret, frame = cap.read()
+        if not ret:
+            break
+
+        # Only process sampled frames
+        if runs % sample_interval == 0:
+            # Convert to PIL image
+            try:
+                pil_img = Image.fromarray(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB))
+            except Exception:
+                runs += 1
+                continue
+
+            # Run Meiki detector on the full frame (or you can crop before passing)
+            start_t = time.time()
+            try:
+                ok, resp = meiki(pil_img, confidence_threshold=0.4)
+                if ok:
+                    detections = resp.get('boxes', [])
+                else:
+                    detections = []
+            except Exception as e:
+                # on error, record empty detections but keep going
+                detections = []
+            end_t = time.time()
+
+            times.append(end_t - start_t)
+            detections_list.append(detections)
+            last_detections = detections
+
+        runs += 1
+
+    cap.release()
+
+    # Make sure 'detections' variable exists for later visualization
+    detections = last_detections
+
+    avg_time = sum(times) / len(times) if times else 0.0
+    
+    print(f"Average processing/inference time over {runs} runs: {avg_time:.4f} seconds")
+
+    # --- Stability / similarity analysis across detection runs ---
+    # We consider two boxes the same if their IoU >= iou_threshold.
+    def iou(boxA, boxB):
+        # boxes are [x_min, y_min, x_max, y_max]
+        xA = max(boxA[0], boxB[0])
+        yA = max(boxA[1], boxB[1])
+        xB = min(boxA[2], boxB[2])
+        yB = min(boxA[3], boxB[3])
+
+        interW = max(0.0, xB - xA)
+        interH = max(0.0, yB - yA)
+        interArea = interW * interH
+
+        boxAArea = max(0.0, boxA[2] - boxA[0]) * max(0.0, boxA[3] - boxA[1])
+        boxBArea = max(0.0, boxB[2] - boxB[0]) * max(0.0, boxB[3] - boxB[1])
+
+        union = boxAArea + boxBArea - interArea
+        if union <= 0:
+            return 0.0
+        return interArea / union
+
+    def match_counts(ref_boxes, other_boxes, iou_threshold=0.5):
+        # Greedy matching by IoU
+        if not ref_boxes or not other_boxes:
+            return 0, []
+        ref_idx = list(range(len(ref_boxes)))
+        oth_idx = list(range(len(other_boxes)))
+        matches = []
+        # compute all IoUs
+        iou_matrix = []
+        for i, rb in enumerate(ref_boxes):
+            row = []
+            for j, ob in enumerate(other_boxes):
+                row.append(iou(rb, ob))
+            iou_matrix.append(row)
+
+        iou_matrix = np.array(iou_matrix)
+        while True:
+            if iou_matrix.size == 0:
+                break
+            # find best remaining pair
+            idx = np.unravel_index(np.argmax(iou_matrix), iou_matrix.shape)
+            best_i, best_j = idx[0], idx[1]
+            best_val = iou_matrix[best_i, best_j]
+            if best_val < iou_threshold:
+                break
+            matches.append((ref_idx[best_i], oth_idx[best_j], float(best_val)))
+            # remove matched row and column
+            iou_matrix = np.delete(iou_matrix, best_i, axis=0)
+            iou_matrix = np.delete(iou_matrix, best_j, axis=1)
+            del ref_idx[best_i]
+            del oth_idx[best_j]
+
+        return len(matches), matches
+
+    # canonical reference: first run (if any)
+    stability_scores = []
+    avg_ious = []
+    if len(detections_list) == 0:
+        stability_avg = 0.0
+    else:
+        ref = detections_list[0]
+        # extract boxes list-of-lists
+        print(ref)
+        ref_boxes = [d['box'] for d in ref]
+        for run_idx, run in enumerate(detections_list):
+            other_boxes = [d['box'] for d in run]
+            matched_count, matches = match_counts(ref_boxes, other_boxes, iou_threshold=0.5)
+            denom = max(len(ref_boxes), len(other_boxes), 1)
+            score = matched_count / denom
+            stability_scores.append(score)
+            if matches:
+                avg_ious.append(sum(m for (_, _, m) in matches) / len(matches))
+
+        stability_avg = float(np.mean(stability_scores)) if stability_scores else 0.0
+        stability_std = float(np.std(stability_scores)) if stability_scores else 0.0
+        median_stability = float(np.median(stability_scores)) if stability_scores else 0.0
+        avg_iou_over_matches = float(np.mean(avg_ious)) if avg_ious else 0.0
+
+    # Heuristic for recommended pixel offset to treat boxes as identical
+    # Use median box dimension across all detections and suggest a small fraction
+    all_widths = []
+    all_heights = []
+    for run in detections_list:
+        for d in run:
+            b = d['box']
+            w = abs(b[2] - b[0])
+            h = abs(b[3] - b[1])
+            all_widths.append(w)
+            all_heights.append(h)
+
+    if all_widths and all_heights:
+        med_w = float(np.median(all_widths))
+        med_h = float(np.median(all_heights))
+        # pixel suggestion: 5px absolute, and also ~5% of median min dimension
+        suggestion_px = max(5.0, min(med_w, med_h) * 0.05)
+        suggestion_px_rounded = int(round(suggestion_px))
+    else:
+        med_w = med_h = 0.0
+        suggestion_px_rounded = 5
+
+    # Additional check: if we expand each box by suggestion_px_rounded (on all sides),
+    # would that cause every run to fully match the reference (i.e., every box in
+    # each run matches some reference box and vice-versa using the same IoU threshold)?
+    def expand_box(box, px, img_w=None, img_h=None):
+        # box: [x_min, y_min, x_max, y_max]
+        x0, y0, x1, y1 = box
+        x0 -= px
+        y0 -= px
+        x1 += px
+        y1 += px
+        if img_w is not None and img_h is not None:
+            x0 = max(0, x0)
+            y0 = max(0, y0)
+            x1 = min(img_w, x1)
+            y1 = min(img_h, y1)
+        return [x0, y0, x1, y1]
+
+    def all_boxes_match_after_expansion(ref_boxes, other_boxes, px_expand, iou_threshold=0.5):
+        # Expand both sets and perform greedy matching. True if both sets are fully matched.
+        if not ref_boxes and not other_boxes:
+            return True
+        if not ref_boxes or not other_boxes:
+            return False
+
+        # Expand boxes
+        ref_exp = [expand_box(b, px_expand) for b in ref_boxes]
+        oth_exp = [expand_box(b, px_expand) for b in other_boxes]
+
+        # compute IoU matrix
+        mat = np.zeros((len(ref_exp), len(oth_exp)), dtype=float)
+        for i, rb in enumerate(ref_exp):
+            for j, ob in enumerate(oth_exp):
+                mat[i, j] = iou(rb, ob)
+
+        # greedy match
+        ref_idx = list(range(len(ref_exp)))
+        oth_idx = list(range(len(oth_exp)))
+        matches = 0
+        m = mat.copy()
+        while m.size:
+            idx = np.unravel_index(np.argmax(m), m.shape)
+            best_i, best_j = idx[0], idx[1]
+            best_val = m[best_i, best_j]
+            if best_val < iou_threshold:
+                break
+            matches += 1
+            m = np.delete(m, best_i, axis=0)
+            m = np.delete(m, best_j, axis=1)
+            del ref_idx[best_i]
+            del oth_idx[best_j]
+
+        # Fully matched if matches equals both lengths
+        return (matches == len(ref_exp)) and (matches == len(oth_exp))
+
+    would_treat_all_same = False
+    per_run_expanded_match = []
+    try:
+        if len(detections_list) == 0:
+            would_treat_all_same = False
+        else:
+            ref = detections_list[0]
+            ref_boxes = [d['box'] for d in ref]
+            for run in detections_list:
+                other_boxes = [d['box'] for d in run]
+                matched = all_boxes_match_after_expansion(ref_boxes, other_boxes, suggestion_px_rounded, iou_threshold=0.5)
+                per_run_expanded_match.append(bool(matched))
+            would_treat_all_same = all(per_run_expanded_match) if per_run_expanded_match else False
+    except Exception:
+        would_treat_all_same = False
+
+    # Print results
+    print(f"Average processing time over {runs} runs: {avg_time:.4f} seconds")
+    print("--- Stability summary (reference = first run) ---")
+    if len(detections_list) == 0:
+        print("No detections recorded.")
+    else:
+        print(f"Per-run similarity ratios vs first run: {[round(s,3) for s in stability_scores]}")
+        print(f"Stability average: {stability_avg:.4f}, std: {stability_std:.4f}, median: {median_stability:.4f}")
+        print(f"Average IoU (matched boxes): {avg_iou_over_matches:.4f}")
+        print(f"Median box size (w x h): {med_w:.1f} x {med_h:.1f} px")
+        print(f"Recommended pixel-offset heuristic to treat boxes as identical: {suggestion_px_rounded} px (~5% of median box min-dim).")
+        print(f"Per-run fully-matched after expanding by {suggestion_px_rounded}px: {per_run_expanded_match}")
+        print(f"Would the recommendation treat all runs as identical? {would_treat_all_same}")
+        print("Also consider fixed offsets like 5px or 10px depending on image DPI and scaling.")
+
+
+    # Draw and save the last-run detections for inspection
+    if pil_img:
+        image_path = os.path.join(os.getcwd(), "last_frame_for_detections.png")
+        pil_img.save(image_path)
+    try:
+        src_img = cv2.imread(image_path)
+        if src_img is not None:
+            res_img = draw_detections(image=src_img, detections=detections, model_name=meiki.model_name)
+            out_path = Path(image_path).with_name(f"detection_result_{meiki.model_name}.png")
+            cv2.imwrite(str(out_path), res_img)
+            print(f"Saved detection visualization to: {out_path}")
+        else:
+            print(f"Could not read image for visualization: {image_path}")
+    except Exception as e:
+        print(f"Error drawing/saving detections: {e}")
+
+    # print(f"Average processing time over {runs} runs: {avg_time:.4f} seconds")
+
+    # if detector.available:
+    #     # Example image URL
+    #     # image_url = "https://huggingface.co/rtr46/meiki.text.detect.v0/resolve/main/test_images/manga.jpg"
+    #     # image_url = "https://huggingface.co/rtr46/meiki.text.detect.v0/resolve/main/test_images/sign.jpg"
+        
+    #     print(f"\nProcessing image from URL: {image_url}")
+        
+    #     # The __call__ method handles the URL directly
+    #     detections = detector(image_url, confidence_threshold=0.4)
+
+    #     # Print the results
+    #     print("\nDetections:")
+    #     for det in detections:
+    #         # Formatting the box coordinates to 2 decimal places for cleaner printing
+    #         formatted_box = [f"{coord:.2f}" for coord in det['box']]
+    #         print(f"  - Box: {formatted_box}, Score: {det['score']:.4f}")
+
+    #     # --- Visualization ---
+    #     print("\nVisualizing results... Check for a window named 'Detection Result'.")
+    #     # Load image again for drawing
+    #     response = requests.get(image_url)
+    #     pil_img = Image.open(BytesIO(response.content)).convert("RGB")
+    #     original_image_np = cv2.cvtColor(np.array(pil_img), cv2.COLOR_RGB2BGR)
+
+    #     # Use the helper function to draw the detections
+    #     result_image = draw_detections(original_image_np, detections, detector.model_name)
+
+    #     # Save or display the image
+    #     output_path = "detection_result.jpg"
+    #     cv2.imwrite(output_path, result_image)
+    #     print(f"Result saved to {output_path}")
+
+    #     # To display in a window (press any key to close)
+    #     # cv2.imshow("Detection Result", result_image)
+    #     # cv2.waitKey(0)
+    #     # cv2.destroyAllWindows()
+    # else:
+    #     print("\nDetector could not be initialized. Please check the error messages above.")
+
 
 # class QWENOCR:
 #     name = 'qwenv2'

GameSentenceMiner/owocr/owocr/run.py

@@ -1392,6 +1392,13 @@ def process_and_write_results(img_or_path, write_to=None, last_result=None, filt
     # print(engine_index)
 
     if res:
+        if 'provider' in text:
+            if write_to == 'callback':
+                logger.opt(ansi=True).info(f"{len(text['boxes'])} text boxes recognized using Meiki:")
+                txt_callback('', '', ocr_start_time,
+                             img_or_path, is_second_ocr, filtering, text.get('crop_coords', None), meiki_boxes=text.get('boxes', []))
+                return str(text), str(text)
+        
         if isinstance(text, list):
             for i, line in enumerate(text):
                 text[i] = do_configured_ocr_replacements(line)

GameSentenceMiner/ui/config_gui.py

@@ -845,6 +845,14 @@ class ConfigApp:
 
         title_template = self.i18n.get('app', {}).get('title_with_profile', 'GameSentenceMiner Configuration - {profile_name}')
         self.window.title(title_template.format(profile_name=current_config.name))
+        
+        try:
+            import mss as mss
+            self.monitors = [f"Monitor {i}: width: {monitor['width']}, height: {monitor['height']}" for i, monitor in enumerate(mss.mss().monitors[1:], start=1)]
+            if len(self.monitors) == 0:
+                self.monitors = [1]
+        except ImportError:
+            self.monitors = []
 
         if current_config.name != self.settings.name or self.settings.config_changed(current_config) or force_refresh:
             logger.info("Config changed, reloading settings.")

GameSentenceMiner/util/text_log.py

@@ -146,25 +146,27 @@ def get_matching_line(last_note: AnkiCard, lines=None) -> GameLine:
     
     if not lines:
         raise Exception("No voicelines in GSM. GSM can only do work on text that has been sent to it since it started. If you are not getting any text into GSM, please check your setup/config.")
+    
+    last_line = lines[-1] # Store reference to the latest line
 
     if not last_note:
-        return lines[-1]
+        return last_line
 
     sentence = last_note.get_field(get_config().anki.sentence_field)
     if not sentence:
-        return lines[-1]
+        return last_line
 
     logger.info(f"Replay buffer length: {gsm_state.replay_buffer_length}")
     time_window = datetime.now() - timedelta(seconds=gsm_state.replay_buffer_length) - timedelta(seconds=5)
     for line in reversed(lines):
         if line.time < time_window:
             logger.info("Could not find matching sentence from GSM's history within the replay buffer time window. Using the latest line.")
-            return lines[-1]
+            return last_line
         if lines_match(line.text, remove_html_and_cloze_tags(sentence)):
             return line
 
     logger.info("Could not find matching sentence from GSM's history. Using the latest line.")
-    return lines[-1]
+    return last_line
 
 
 def get_text_event(last_note) -> GameLine:

GameSentenceMiner/web/texthooking_page.py

@@ -235,14 +235,29 @@ def translate_line():
     if event_id is None:
         return jsonify({'error': 'Missing id'}), 400
     
+    prompt = f"""
+    **Professional Game Localization Task**
+
+    **Task Directive:**
+    Translate ONLY the provided line of game dialogue specified below into natural-sounding, context-aware {get_config().general.get_native_language_name()}. The translation must preserve the original tone and intent of the source.
+
+    **Output Requirements:**
+    - Provide only the single, best {get_config().general.get_native_language_name()} translation.
+    - Use expletives if they are natural for the context and enhance the translation's impact, but do not over-exaggerate.
+    - Do not include notes, alternatives, explanations, or any other surrounding text. Absolutely nothing but the translated line.
+
+    **Line to Translate:**
+    """
+
     if not get_config().ai.is_configured():
         return jsonify({'error': 'AI translation is not properly configured. Please check your settings in the "AI" Tab.'}), 400
     line = get_line_by_id(event_id)
     if line is None:
         return jsonify({'error': 'Invalid id'}), 400
     line_to_translate = text if text else line.text
-    translation = get_ai_prompt_result(get_all_lines(), line_to_translate,
-                                       line, get_current_game())
+    translation = get_ai_prompt_result(
+        get_all_lines(), line_to_translate, line, get_current_game(), custom_prompt=prompt
+    )
     line.set_TL(translation)
     return jsonify({'TL': translation}), 200
 

{gamesentenceminer-2.19.2.dev0.dist-info → gamesentenceminer-2.19.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GameSentenceMiner
-Version: 2.19.2.dev0
+Version: 2.19.4
 Summary: A tool for mining sentences from games. Update: Dependencies, replay buffer based line searching, and bug fixes.
 Author-email: Beangate <bpwhelan95@gmail.com>
 License: MIT License
@@ -12,42 +12,43 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: requests>=2.32.3
-Requires-Dist: watchdog>=5.0.2
-Requires-Dist: DateTime>=5.5
-Requires-Dist: pyperclip>=1.9.0
-Requires-Dist: soundfile>=0.12.1
-Requires-Dist: toml>=0.10.2
-Requires-Dist: psutil>=7.1.0
-Requires-Dist: rapidfuzz>=3.9.7
-Requires-Dist: plyer>=2.1.0
-Requires-Dist: keyboard>=0.13.5
-Requires-Dist: websockets>=15.0.1
-Requires-Dist: ttkbootstrap>=1.10.1
-Requires-Dist: dataclasses_json>=0.6.7
+Requires-Dist: requests~=2.32.5
+Requires-Dist: watchdog~=6.0.0
+Requires-Dist: DateTime~=5.5
+Requires-Dist: pyperclip~=1.9.0
+Requires-Dist: soundfile~=0.13.1
+Requires-Dist: toml~=0.10.2
+Requires-Dist: psutil~=7.1.0
+Requires-Dist: rapidfuzz~=3.10.0
+Requires-Dist: plyer~=2.1.0
+Requires-Dist: keyboard~=0.13.5
+Requires-Dist: websockets~=15.0.1
+Requires-Dist: ttkbootstrap~=1.10.1
+Requires-Dist: dataclasses_json~=0.6.7
 Requires-Dist: betterproto==2.0.0b7
-Requires-Dist: obsws-python>=1.7.2
+Requires-Dist: obsws-python~=1.8.0
 Requires-Dist: numpy==2.2.6
-Requires-Dist: faster-whisper>=1.2.0
-Requires-Dist: silero-vad>=6.0.0
-Requires-Dist: regex>=2025.9.18
-Requires-Dist: opencv-python>=4.12.0.88
-Requires-Dist: scikit-image>=0.25.2
-Requires-Dist: openai>=1.108.0
-Requires-Dist: owocr>=1.9.1
-Requires-Dist: oneocr>=1.0.10
-Requires-Dist: google-genai>=1.38.0
-Requires-Dist: sounddevice>=0.5.2
-Requires-Dist: matplotlib>=3.10.6
-Requires-Dist: groq>=0.31.1
-Requires-Dist: flask>=3.1.2
-Requires-Dist: pystray>=0.19.5
-Requires-Dist: pygetwindow>=0.0.9; sys_platform == "win32"
-Requires-Dist: pywin32>=311; sys_platform == "win32"
-Requires-Dist: win10toast>=0.9; sys_platform == "win32"
-Requires-Dist: stable-ts>=2.19.1
-Requires-Dist: torchcodec>=0.7.0
+Requires-Dist: faster-whisper~=1.2.0
+Requires-Dist: silero-vad~=6.0.0
+Requires-Dist: regex~=2025.10.23
+Requires-Dist: opencv-python~=4.12.0.88
+Requires-Dist: scikit-image~=0.25.2
+Requires-Dist: owocr==1.9.1
+Requires-Dist: oneocr==1.0.10
+Requires-Dist: google-genai~=1.46.0
+Requires-Dist: sounddevice~=0.5.2
+Requires-Dist: matplotlib~=3.10.6
+Requires-Dist: groq~=0.33.0
+Requires-Dist: flask~=3.1.2
+Requires-Dist: pystray~=0.19.5
+Requires-Dist: pygetwindow==0.0.9; sys_platform == "win32"
+Requires-Dist: pywin32==311; sys_platform == "win32"
+Requires-Dist: win10toast==0.9; sys_platform == "win32"
+Requires-Dist: stable-ts~=2.19.1
+Requires-Dist: torchcodec~=0.7.0
 Requires-Dist: torchaudio==2.8.0
+Requires-Dist: pillow~=12.0.0
+Requires-Dist: openai>=2.6.0
 Dynamic: license-file
 
 # GSM - An Immersion toolkit for Games.

{gamesentenceminer-2.19.2.dev0.dist-info → gamesentenceminer-2.19.4.dist-info}/RECORD

@@ -1,8 +1,8 @@
 GameSentenceMiner/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-GameSentenceMiner/anki.py,sha256=9pjjJrQS7IbA6iTtOaJ0Hs2nBddYXTCZBF5lZ5I4dOs,29593
+GameSentenceMiner/anki.py,sha256=jySFPzDYz0vItb12kwZ-rm9WmtxO8Kr41wK1JdwRnU4,29638
 GameSentenceMiner/gametext.py,sha256=4PPm7QSWDmvsyooVjFANkd1Vnoy5ixbGRMHfYfhwGs0,13320
-GameSentenceMiner/gsm.py,sha256=Fqpy210vJIscxEaaX5bI4n-HEyp4EtkGSLkIreEs-Gw,34564
-GameSentenceMiner/obs.py,sha256=vhTFqGxHWEz9g-081gain6iI2poJM_D7v5vI8Kl7rqk,37918
+GameSentenceMiner/gsm.py,sha256=Do-1RRdsC9jqu1artpYN4mQIYT2XGxPPDeYbLKtHMdM,34569
+GameSentenceMiner/obs.py,sha256=MdT3zQJqTe72MAxawxBafK-4a9UoRWdFDJn_V2TsIp4,37988
 GameSentenceMiner/vad.py,sha256=iMSsoUZ7-aNoWKzDKfOHdB3Zk5U2hV7x5hqTny6rj08,21501
 GameSentenceMiner/ai/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 GameSentenceMiner/ai/ai_prompting.py,sha256=mq9Odv_FpohXagU-OoSZbLWttdrEl1M1NiqnodeUpD8,29126
@@ -21,14 +21,14 @@ GameSentenceMiner/ocr/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3h
 GameSentenceMiner/ocr/gsm_ocr_config.py,sha256=Ov04c-nKzh3sADxO-5JyZWVe4DlrHM9edM9tc7-97Jo,5970
 GameSentenceMiner/ocr/ocrconfig.py,sha256=_tY8mjnzHMJrLS8E5pHqYXZjMuLoGKYgJwdhYgN-ny4,6466
 GameSentenceMiner/ocr/owocr_area_selector.py,sha256=4MjItlaZ78Smxa3uxMxbjU0n2z_IBTG-iBpDB9COSL8,29270
-GameSentenceMiner/ocr/owocr_helper.py,sha256=GL16SZa48LwmVQ7xKYRtEgbj8V-7JwOfAHUw-CPwfp4,32370
+GameSentenceMiner/ocr/owocr_helper.py,sha256=MZFKA252lQE1M39tUTtccX3vLaPRJrWfBzWvfxNq3B8,35310
 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=XR6tbcj8ctDXn8NlpXrRZIel60zj2h3R0NKWBtEE5M4,72273
-GameSentenceMiner/owocr/owocr/run.py,sha256=z3EaF_a5m9T_ZrELYoaAzHPqzTO0cd7MQCndcnWXq_4,82035
+GameSentenceMiner/owocr/owocr/ocr.py,sha256=yVrLr8nNgvLRB-pPvkyhw07zkAiWrCf85SvgfQBquEk,95309
+GameSentenceMiner/owocr/owocr/run.py,sha256=y90fHSbbjH4BeMlxH_xjKU3uJzfJgdKo6nUqwNcdUJs,82455
 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
@@ -37,7 +37,7 @@ GameSentenceMiner/tools/ss_selector.py,sha256=ob2oJdiYreDMMau7CvsglpnhZ1CDnJqop3
 GameSentenceMiner/tools/window_transparency.py,sha256=GtbxbmZg0-UYPXhfHff-7IKZyY2DKe4B9GdyovfmpeM,8166
 GameSentenceMiner/ui/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 GameSentenceMiner/ui/anki_confirmation.py,sha256=krrT3q3anTtXNTPHz5ahXSd4genEnEvS07v1JYftBFg,15174
-GameSentenceMiner/ui/config_gui.py,sha256=Vgi6cJbebOwhdu_HQtT5saBM_cWpxTeiQhT9GmFK5FA,157919
+GameSentenceMiner/ui/config_gui.py,sha256=JHXlD6CE7o4YH1M85JSvGqc2-pNfuAyLgkztUn6ho1w,158268
 GameSentenceMiner/ui/furigana_filter_preview.py,sha256=DAT2-j6vSDHr9ufk6PiaLikEsbIp56B_OHIEeYLMwlk,17135
 GameSentenceMiner/ui/screenshot_selector.py,sha256=7QvDhOMpA0ej8x_lYtu6fhmrWbM1GCg-dps3XVWwk1Q,8234
 GameSentenceMiner/util/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -51,7 +51,7 @@ GameSentenceMiner/util/get_overlay_coords.py,sha256=jQ0hcrEh9CfvjlBRJez3Ly-er4Mj
 GameSentenceMiner/util/gsm_utils.py,sha256=mASECTmN10c2yPL4NEfLg0Y0YWwFso1i6r_hhJPR3MY,10974
 GameSentenceMiner/util/model.py,sha256=R-_RYTYLSDNgBoVTPuPBcIHeOznIqi_vBzQ7VQ20WYk,6727
 GameSentenceMiner/util/notification.py,sha256=YBhf_mSo_i3cjBz-pmeTPx3wchKiG9BK2VBdZSa2prQ,4597
-GameSentenceMiner/util/text_log.py,sha256=nb4N6bId1hwVWSnKjbxl0kvTqBhJW2UL-xmwtyKmKrk,6835
+GameSentenceMiner/util/text_log.py,sha256=6eekK0TTuh65YHDw6tjGFQUrCmV1P1ebNzkdxRNXP9k,6903
 GameSentenceMiner/util/communication/__init__.py,sha256=xh__yn2MhzXi9eLi89PeZWlJPn-cbBSjskhi1BRraXg,643
 GameSentenceMiner/util/communication/send.py,sha256=9tEpbodt1nqsA-XqyXZGMHK_80EJPnhMJJxvDF-w3Ug,578
 GameSentenceMiner/util/communication/websocket.py,sha256=RWPN9V6Gddqw1PmR_Ql8z0yjVihGvwSLSPQHXSxRlqM,3357
@@ -68,7 +68,7 @@ GameSentenceMiner/web/events.py,sha256=RJ8tIK8WUn7Fbgny23UJWrZ1SlhYzzT5p55E1uXRw
 GameSentenceMiner/web/gsm_websocket.py,sha256=B0VKpxmsRu0WRh5nFWlpDPBQ6-K2ed7TEIa0O6YWeoo,4166
 GameSentenceMiner/web/service.py,sha256=6cgUmDgtp3ZKzuPFszowjPoq-BDtC1bS3ux6sykeaqo,6662
 GameSentenceMiner/web/stats.py,sha256=LYMhekifcQo-cbfy2--b6vycKcu8RAoTnQA4TefcS6U,29037
-GameSentenceMiner/web/texthooking_page.py,sha256=xX2ZZpvTmXyBOKOkYZxKA3yNZQMbE930EEvUeY-xJpo,14332
+GameSentenceMiner/web/texthooking_page.py,sha256=jnEBnxDj37BEbi1AGsiEk3GNOqBLsd9znIKC1OuO8jM,15068
 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
@@ -135,9 +135,9 @@ GameSentenceMiner/web/templates/components/kanji_grid/thousand_character_classic
 GameSentenceMiner/web/templates/components/kanji_grid/wanikani_levels.json,sha256=8wjnnaYQqmho6t5tMxrIAc03512A2tYhQh5dfsQnfAM,11372
 GameSentenceMiner/web/templates/components/kanji_grid/words_hk_frequency_list.json,sha256=wRkqZNPzz6DT9OTPHpXwfqW96Qb96stCQNNgOL-ZdKk,17535
 GameSentenceMiner/wip/__init___.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-gamesentenceminer-2.19.2.dev0.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-gamesentenceminer-2.19.2.dev0.dist-info/METADATA,sha256=627cISuxTZ_4qlXzOXwkh9nsrWqg2P14C84K0FLOhiY,8126
-gamesentenceminer-2.19.2.dev0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-gamesentenceminer-2.19.2.dev0.dist-info/entry_points.txt,sha256=2APEP25DbfjSxGeHtwBstMH8mulVhLkqF_b9bqzU6vQ,65
-gamesentenceminer-2.19.2.dev0.dist-info/top_level.txt,sha256=V1hUY6xVSyUEohb0uDoN4UIE6rUZ_JYx8yMyPGX4PgQ,18
-gamesentenceminer-2.19.2.dev0.dist-info/RECORD,,
+gamesentenceminer-2.19.4.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+gamesentenceminer-2.19.4.dist-info/METADATA,sha256=W32ddWeKMJrfVVFIC0YQfVQY26BQ_ulWZiooBYOD3NQ,8151
+gamesentenceminer-2.19.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+gamesentenceminer-2.19.4.dist-info/entry_points.txt,sha256=2APEP25DbfjSxGeHtwBstMH8mulVhLkqF_b9bqzU6vQ,65
+gamesentenceminer-2.19.4.dist-info/top_level.txt,sha256=V1hUY6xVSyUEohb0uDoN4UIE6rUZ_JYx8yMyPGX4PgQ,18
+gamesentenceminer-2.19.4.dist-info/RECORD,,