rbx-proofreader 1.1.1__py3-none-any.whl → 1.2.0__py3-none-any.whl

proofreader/core/config.py

@@ -6,6 +6,7 @@ from pathlib import Path
 # Resolves to the 'proofreader' root directory
 BASE_DIR = Path(__file__).resolve().parent.parent.parent
 BASE_URL = "https://github.com/lucacrose/proofreader"
+VERSION_TAG = "v1.2.0"
 
 # --- ASSETS & MODELS ---
 ASSETS_PATH = BASE_DIR / "assets"
@@ -16,6 +17,7 @@ THUMBNAILS_DIR = ASSETS_PATH / "thumbnails"
 TRAIN_THUMBNAILS_DIR = ASSETS_PATH / "train_data"
 CLASS_MAP_PATH = ASSETS_PATH / "class_mapping.json"
 CLIP_BEST_PATH = ASSETS_PATH / "weights" / "clip.pt"
+CLIP_VIT_BASE_PATCH32_PATH = ASSETS_PATH / "clip-vit-base-patch32"
 
 # --- TRAINING & EMULATOR ---
 TRAIN_DIR = BASE_DIR / "proofreader" / "train"
@@ -79,7 +81,7 @@ AUGMENTER_CONFIG = {
         "height_max": 1600,                # Maximum height in pixels (after aspect ratio calculation)
         "total_images": 1024,              # Total number of images to generate
         "max_workers": 16,                 # Maximum number of parallel workers for generation
-        "train_split_fraction": 0.8,       # Fraction of images used for training vs validation
+        "train_split_fraction": 0.9,       # Fraction of images used for training vs validation
         "empty_trade_chance": 0.09,        # Chance a trade has no items or robux (negative sample)
     }
 }

proofreader/core/detector.py

@@ -1,6 +1,10 @@
 from typing import List
 from ultralytics.models import YOLO
 from .schema import Box
+from typing import Union
+import numpy as np
+
+ImageSource = Union[str, np.ndarray]
 
 class TradeDetector:
     def __init__(self, model_path: str):
@@ -11,11 +15,13 @@ class TradeDetector:
             1: "item_thumb",
             2: "item_name",
             3: "robux_line",
-            4: "robux_value"
+            4: "robux_value",
+            5: "outgoing_header",
+            6: "incoming_header"
         }
 
-    def detect(self, image_source: str, conf_threshold: float) -> List[Box]:
-        results = self.model.predict(image_source, conf=conf_threshold, verbose=False)[0]
+    def detect(self, image: ImageSource, conf_threshold: float) -> List[Box]:
+        results = self.model.predict(image, verbose=False, conf=conf_threshold)[0]
 
         detected_boxes = []
 

proofreader/core/matcher.py

@@ -6,14 +6,18 @@ import json
 import cv2
 from PIL import Image
 from torchvision import transforms
-from transformers import CLIPVisionModelWithProjection
+from transformers import CLIPVisionModelWithProjection, logging as hf_logging
 from typing import List
 from .schema import TradeLayout, ResolvedItem
 
+hf_logging.disable_progress_bar()
+hf_logging.set_verbosity_error()
+
 class CLIPItemEmbedder(nn.Module):
-    def __init__(self, num_classes, model_id="openai/clip-vit-base-patch32"):
+    def __init__(self, num_classes, model_path):
         super().__init__()
-        self.vision_encoder = CLIPVisionModelWithProjection.from_pretrained(model_id)
+
+        self.vision_encoder = CLIPVisionModelWithProjection.from_pretrained(model_path, token=False, low_cpu_mem_usage=True)
         self.item_prototypes = nn.Embedding(num_classes, 512)
         self.logit_scale = nn.Parameter(torch.ones([]) * 2.659)
 
@@ -22,7 +26,7 @@ class CLIPItemEmbedder(nn.Module):
         return F.normalize(outputs.image_embeds, p=2, dim=-1)
 
 class VisualMatcher:
-    def __init__(self, weights_path: str, mapping_path: str, item_db: List[dict], device: str = "cuda"):
+    def __init__(self, model_path: str, weights_path: str, mapping_path: str, item_db: List[dict], device: str = "cuda"):
         self.device = device
 
         with open(mapping_path, "r") as f:
@@ -33,7 +37,7 @@ class VisualMatcher:
         self.name_to_id = {str(i["name"]).lower().strip(): i["id"] for i in item_db}
 
         num_classes = len(self.class_to_idx)
-        self.model = CLIPItemEmbedder(num_classes).to(self.device)
+        self.model = CLIPItemEmbedder(num_classes, model_path=model_path).to(self.device)
         self.model.load_state_dict(torch.load(weights_path, map_location=self.device))
         self.model.eval()
 

proofreader/core/resolver.py

@@ -5,71 +5,84 @@ class SpatialResolver:
     def __init__(self):
         pass
 
-    def get_center(self, box: Box):
-        x1, y1, x2, y2 = box.coords
-        return (x1 + x2) / 2, (y1 + y2) / 2
-    
-    def is_contained(self, child: Box, parent: Box, margin: int = 20) -> bool:
+    def get_iou(self, box1: Box, box2: Box) -> float:
+        b1x1, b1y1, b1x2, b1y2 = box1.coords
+        b2x1, b2y1, b2x2, b2y2 = box2.coords
+        
+        ix1, iy1 = max(b1x1, b2x1), max(b1y1, b2y1)
+        ix2, iy2 = min(b1x2, b2x2), min(b1y2, b2y2)
+        
+        inter_area = max(0, ix2 - ix1) * max(0, iy2 - iy1)
+        area1 = (b1x2 - b1x1) * (b1y2 - b1y1)
+        area2 = (b2x2 - b2x1) * (b2y2 - b2y1)
+        union_area = area1 + area2 - inter_area
+        
+        return inter_area / union_area if union_area > 0 else 0
+
+    def get_ioa(self, child: Box, parent: Box) -> float:
         cx1, cy1, cx2, cy2 = child.coords
         px1, py1, px2, py2 = parent.coords
         
-        return (cx1 >= px1 - margin and 
-                cy1 >= py1 - margin and 
-                cx2 <= px2 + margin and 
-                cy2 <= py2 + margin)
+        ix1, iy1 = max(cx1, px1), max(cy1, py1)
+        ix2, iy2 = min(cx2, px2), min(cy2, py2)
+        
+        inter_area = max(0, ix2 - ix1) * max(0, iy2 - iy1)
+        child_area = (cx2 - cx1) * (cy2 - cy1)
+        return inter_area / child_area if child_area > 0 else 0
 
     def resolve(self, all_boxes: List[Box]) -> TradeLayout:
         layout = TradeLayout()
 
-        cards = [b for b in all_boxes if b.label == "item_card"]
-        robux_lines = [b for b in all_boxes if b.label == "robux_line"]
+        raw_cards = sorted([b for b in all_boxes if b.label == "item_card"], 
+                           key=lambda x: x.confidence, reverse=True)
+        
+        unique_cards = []
+        for card in raw_cards:
+            if any(self.get_iou(card, accepted) > 0.5 for accepted in unique_cards):
+                continue
+            unique_cards.append(card)
         
+        robux_lines = [b for b in all_boxes if b.label == "robux_line"]
         names = [b for b in all_boxes if b.label == "item_name"]
         thumbs = [b for b in all_boxes if b.label == "item_thumb"]
         values = [b for b in all_boxes if b.label == "robux_value"]
+        header_received = next((b for b in all_boxes if b.label == "received_header"), None)
 
-        parents = cards + robux_lines
-        if not parents:
-            return layout
-
-        y_centers = sorted([self.get_center(p)[1] for p in parents])
-        
-        if len(y_centers) > 1:
-            max_gap = -1
-            gap_index = 0
-
-            for i in range(len(y_centers) - 1):
-                gap = y_centers[i + 1] - y_centers[i]
-                if gap > max_gap:
-                    max_gap = gap
-                    gap_index = i + 1
-            
-            first_bottom_parent = next(p for p in parents if self.get_center(p)[1] == y_centers[gap_index])
-            split_y = first_bottom_parent.coords[1] - 10
+        if header_received:
+            split_y = header_received.coords[1]
         else:
-            split_y = y_centers[0] + 100
+            parents = sorted(unique_cards + robux_lines, key=lambda b: (b.coords[1] + b.coords[3])/2)
+            if len(parents) > 1:
+                y_centers = [(b.coords[1] + b.coords[3])/2 for b in parents]
+                max_gap = 0
+                split_y = y_centers[0] + 50 
+                for i in range(len(y_centers) - 1):
+                    gap = y_centers[i+1] - y_centers[i]
+                    if gap > max_gap:
+                        max_gap = gap
+                        split_y = (y_centers[i] + y_centers[i+1]) / 2
+            else:
+                split_y = 500
+        
+        unique_cards.sort(key=lambda b: b.coords[1])
 
-        for card in cards:
+        for card in unique_cards:
             item = ResolvedItem(container_box=card)
-            item.name_box = next((n for n in names if self.is_contained(n, card)), None)
-            item.thumb_box = next((t for t in thumbs if self.is_contained(t, card)), None)
 
-            if self.get_center(card)[1] < split_y:
+            item.name_box = next((n for n in names if self.get_ioa(n, card) > 0.7), None)
+            item.thumb_box = next((t for t in thumbs if self.get_ioa(t, card) > 0.7), None)
+
+            if (card.coords[1] + card.coords[3]) / 2 < split_y:
                 layout.outgoing.items.append(item)
             else:
                 layout.incoming.items.append(item)
-
+        
         for line in robux_lines:
-            val_box = next((v for v in values if self.is_contained(v, line)), None)
-            
+            val_box = next((v for v in values if self.get_ioa(v, line) > 0.5), None)
             if val_box:
-                robux_obj = robux_obj = ResolvedRobux(
-                    container_box=line,
-                    value_box=val_box
-                )
-
-                if self.get_center(line)[1] < split_y:
-                    layout.outgoing.robux = robux_obj 
+                robux_obj = ResolvedRobux(container_box=line, value_box=val_box)
+                if (line.coords[1] + line.coords[3]) / 2 < split_y:
+                    layout.outgoing.robux = robux_obj
                 else:
                     layout.incoming.robux = robux_obj
 

proofreader/main.py

@@ -1,17 +1,22 @@
-import os
+import io
 import cv2
 import torch
 import json
 import requests
+from typing import Union
+from pathlib import Path
+import numpy as np
 from tqdm import tqdm
 from transformers import CLIPProcessor, CLIPModel
 from .core.detector import TradeDetector
 from .core.resolver import SpatialResolver
 from .core.ocr import OCRReader
 from .core.matcher import VisualMatcher
-from .core.config import DB_PATH, MODEL_PATH, DEVICE, CLASS_MAP_PATH, CLIP_BEST_PATH, BASE_URL, CERTAIN_VISUAL_CONF
+from .core.config import DB_PATH, MODEL_PATH, DEVICE, CLASS_MAP_PATH, CLIP_BEST_PATH, BASE_URL, CERTAIN_VISUAL_CONF, VERSION_TAG, CLIP_VIT_BASE_PATCH32_PATH
 from .core.schema import ResolvedItem
 
+ImageInput = Union[str, Path, np.ndarray, bytes, io.BytesIO]
+
 class TradeEngine:
     def __init__(self):
         self._ensure_assets()
@@ -27,9 +32,6 @@ class TradeEngine:
 
         self.device = DEVICE
 
-        self.clip_model = CLIPModel.from_pretrained("openai/clip-vit-base-patch32").to(self.device)
-        self.clip_processor = CLIPProcessor.from_pretrained("openai/clip-vit-base-patch32", use_fast=True)
-
         with open(DB_PATH, "r") as f:
             item_db = json.load(f)
         
@@ -39,24 +41,40 @@ class TradeEngine:
 
         self.matcher = VisualMatcher(
             item_db=item_db,
+            model_path=CLIP_VIT_BASE_PATCH32_PATH,
             weights_path=CLIP_BEST_PATH,
             mapping_path=CLASS_MAP_PATH,
             device=self.device
-        ) 
+        )
+
+    def _download_clip_locally(self):
+        model_name = "openai/clip-vit-base-patch32"
+        model = CLIPModel.from_pretrained(model_name)
+        processor = CLIPProcessor.from_pretrained(model_name)
+
+        model_path = str(CLIP_VIT_BASE_PATCH32_PATH.resolve().as_posix())
+
+        model.save_pretrained(model_path)
+        processor.save_pretrained(model_path)
+        print(f"✅ CLIP saved locally at {CLIP_VIT_BASE_PATCH32_PATH}")
 
     def _ensure_assets(self):
         assets = {
-            DB_PATH: f"{BASE_URL}/releases/download/v1.1.0/item_database.json",
-            MODEL_PATH: f"{BASE_URL}/releases/download/v1.1.0/yolo.pt",
-            CLIP_BEST_PATH: f"{BASE_URL}/releases/download/v1.1.0/clip.pt",
-            CLASS_MAP_PATH: f"{BASE_URL}/releases/download/v1.1.0/class_mapping.json"
+            DB_PATH: f"{BASE_URL}/releases/download/{VERSION_TAG}/item_database.json",
+            MODEL_PATH: f"{BASE_URL}/releases/download/{VERSION_TAG}/yolo.pt",
+            CLIP_BEST_PATH: f"{BASE_URL}/releases/download/{VERSION_TAG}/clip.pt",
+            CLASS_MAP_PATH: f"{BASE_URL}/releases/download/{VERSION_TAG}/class_mapping.json"
         }
 
         for path, url in assets.items():
             if not path.exists():
-                print(f"📦 {path.name} missing. Downloading from latest release...")
+                print(f"📦 {path.name} missing. Downloading from {VERSION_TAG} release...")
                 self._download_file(url, path)
 
+        if not CLIP_VIT_BASE_PATCH32_PATH.exists():
+            print(f"📦 Local CLIP assets missing. Downloading to {CLIP_VIT_BASE_PATCH32_PATH}...")
+            self._download_clip_locally()
+
     def _download_file(self, url, dest_path):
         response = requests.get(url, stream=True)
         total_size = int(response.headers.get('content-length', 0))
@@ -110,15 +128,34 @@ class TradeEngine:
             item.id = ocr_id_direct
             item.name = self.matcher.id_to_name.get(str(ocr_id_direct))
 
-    def process_image(self, image_path: str, conf_threshold: float) -> dict:
-        if not os.path.exists(image_path):
-            raise FileNotFoundError(f"Image not found: {image_path}")
+    def _load_image(self, image: ImageInput) -> np.ndarray:
+        if isinstance(image, np.ndarray):
+            return image
+        
+        if isinstance(image, io.BytesIO):
+            image = image.getvalue()
+        
+        if isinstance(image, bytes):
+            nparr = np.frombuffer(image, np.uint8)
+            img = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
+            if img is None:
+                raise ValueError("Failed to decode image from bytes")
+            return img
+        
+        image_str = str(image)
+        img = cv2.imread(image_str)
+        if img is None:
+            raise ValueError(f"Failed to load image: {image_str}")
+        
+        return img
+
+    def process_image(self, image: ImageInput, conf_threshold: float) -> dict:
+        image_np = self._load_image(image)
         
-        boxes = self.detector.detect(image_path, conf_threshold)
+        boxes = self.detector.detect(image_np, conf_threshold)
         layout = self.resolver.resolve(boxes)
-        image = cv2.imread(image_path)
 
-        self.matcher.match_item_visuals(image, layout)
+        self.matcher.match_item_visuals(image_np, layout)
 
         for side in [layout.outgoing, layout.incoming]:
             for item in side.items:
@@ -128,7 +165,7 @@ class TradeEngine:
                     item._finalized = True
 
         self.reader.process_layout(
-            image,
+            image_np,
             layout,
             skip_if=lambda item: getattr(item, "_finalized", False)
         )

proofreader/train/emulator/generator.py

@@ -25,6 +25,104 @@ from proofreader.core.config import (
 
 GENERATOR_CONFIG = AUGMENTER_CONFIG["generator"]
 
+def clean_and_save_labels(page, width, height):
+    label_data = []
+
+    chat_bar = page.query_selector("#chat-main")
+    chat_box = chat_bar.bounding_box() if chat_bar and chat_bar.is_visible() else None
+
+    def get_intersection_area(boxA, boxB):
+        xA = max(boxA['x'], boxB['x'])
+        yA = max(boxA['y'], boxB['y'])
+        xB = min(boxA['x'] + boxA['width'], boxB['x'] + boxB['width'])
+        yB = min(boxA['y'] + boxA['height'], boxB['y'] + boxB['height'])
+        interWidth = max(0, xB - xA)
+        interHeight = max(0, yB - yA)
+        return interWidth * interHeight
+
+    def get_valid_yolo_data(box, class_id, pad=0, visibility_threshold=0.5):
+        if not box:
+            return None
+        
+        x1_raw, y1_raw = box['x'] - pad, box['y'] - pad
+        x2_raw, y2_raw = box['x'] + box['width'] + pad, box['y'] + box['height'] + pad
+        
+        padded_w = x2_raw - x1_raw
+        padded_h = y2_raw - y1_raw
+        original_area = max(1, padded_w * padded_h)
+
+        x1, y1 = max(0, x1_raw), max(0, y1_raw)
+        x2, y2 = min(width, x2_raw), min(height, y2_raw)
+
+        nw, nh = x2 - x1, y2 - y1
+        if nw <= 2 or nh <= 2:
+            return None
+
+        canvas_visible_area = nw * nh
+
+        overlap_with_chat = 0
+        if chat_box:
+            current_box = {'x': x1, 'y': y1, 'width': nw, 'height': nh}
+            overlap_with_chat = get_intersection_area(current_box, chat_box)
+        
+        actual_visible_area = canvas_visible_area - overlap_with_chat
+
+        visibility_ratio = actual_visible_area / original_area
+
+        if visibility_ratio < visibility_threshold:
+            return None
+        
+        return [
+            class_id,
+            (x1 + nw/2) / width,
+            (y1 + nh/2) / height,
+            nw / width,
+            nh / height
+        ]
+    
+    items = page.query_selector_all("div[trade-item-card]")
+    for item in items:
+        if not item.is_visible(): continue
+
+        card_box = item.bounding_box()
+
+        card_res = get_valid_yolo_data(card_box, 0, pad=4, visibility_threshold=0.4) 
+        
+        if card_res:
+            label_data.append(card_res)
+
+            thumb = item.query_selector(".item-card-thumb-container")
+            name = item.query_selector(".item-card-name")
+            
+            t_box = thumb.bounding_box() if thumb and thumb.is_visible() else None
+            n_box = name.bounding_box() if name and name.is_visible() else None
+
+            t_res = get_valid_yolo_data(t_box, 1, pad=4, visibility_threshold=0.5)
+            n_res = get_valid_yolo_data(n_box, 2, pad=4, visibility_threshold=0.5)
+
+            if t_res: label_data.append(t_res)
+            if n_res: label_data.append(n_res)
+    
+    for section in page.query_selector_all(".robux-line"):
+        if section.is_visible() and "Robux Offered" in section.inner_text():
+            res_3 = get_valid_yolo_data(section.bounding_box(), 3, pad=6, visibility_threshold=0.4)
+            if res_3: 
+                label_data.append(res_3)
+                val_el = section.query_selector(".robux-line-value")
+                if val_el and val_el.is_visible():
+                    res_4 = get_valid_yolo_data(val_el.bounding_box(), 4, pad=4, visibility_threshold=0.5)
+                    if res_4: label_data.append(res_4)
+    
+    for header in page.query_selector_all("h3.trade-list-detail-offer-header"):
+        if not header.is_visible(): continue
+        text = header.inner_text().lower()
+        cid = 5 if "gave" in text else 6 if "received" in text else None
+        if cid:
+            res_h = get_valid_yolo_data(header.bounding_box(), cid, pad=4, visibility_threshold=0.4)
+            if res_h: label_data.append(res_h)
+
+    return label_data
+
 def process_batch(batch_ids, db, backgrounds_count, progress_counter):
     try:
         with sync_playwright() as p:
@@ -95,50 +193,7 @@ def generate_single_image(page, task_id, db, backgrounds_count, augmenter_js):
         }
     """)
 
-    def get_padded_yolo(element, class_id, pad_px=2):
-        box = element.bounding_box()
-        if not box: return None
-        x1, y1 = max(0, box['x'] - pad_px), max(0, box['y'] - pad_px)
-        x2, y2 = min(width, box['x'] + box['width'] + pad_px), min(height, box['y'] + box['height'] + pad_px)
-        nw, nh = x2 - x1, y2 - y1
-        return [class_id, (x1 + nw/2)/width, (y1 + nh/2)/height, nw/width, nh/height]
-
-    def is_fully_visible(box, width, height, pad=4):
-        return (box['x'] - pad >= 0 and 
-                box['y'] - pad >= 0 and 
-                (box['x'] + box['width'] + pad) <= width and 
-                (box['y'] + box['height'] + pad) <= height)
-
-    label_data = []
-
-    items = page.query_selector_all("div[trade-item-card]")
-    for item in items:
-        box = item.bounding_box()
-        if box and is_fully_visible(box, width, height):
-            card_box = get_padded_yolo(item, 0, pad_px=4)
-            if card_box: label_data.append(card_box)
-
-            thumb = item.query_selector(".item-card-thumb-container") 
-            if thumb:
-                thumb_box = get_padded_yolo(thumb, 1, pad_px=4)
-                if thumb_box: label_data.append(thumb_box)
-
-            name = item.query_selector(".item-card-name")
-            if name:
-                name_box = get_padded_yolo(name, 2, pad_px=4)
-                if name_box: label_data.append(name_box)
-
-    robux_sections = page.query_selector_all(".robux-line:not(.total-value)")
-    for section in robux_sections:
-        box = section.bounding_box()
-        if box and is_fully_visible(box, width, height, 8) and section.is_visible():
-            line_box = get_padded_yolo(section, 3, pad_px=8)
-            if line_box: label_data.append(line_box)
-
-            value_element = section.query_selector(".robux-line-value") 
-            if value_element:
-                value_box = get_padded_yolo(value_element, 4, pad_px=4)
-                if value_box: label_data.append(value_box)
+    label_data = clean_and_save_labels(page, width, height)
     
     img_buffer = page.screenshot(type="jpeg", quality=100)
     nparr = np.frombuffer(img_buffer, np.uint8)
@@ -195,7 +250,7 @@ def generate_single_image(page, task_id, db, backgrounds_count, augmenter_js):
         for label in label_data:
             f.write(f"{label[0]} {label[1]:.6f} {label[2]:.6f} {label[3]:.6f} {label[4]:.6f}\n")
 
-def run_mass_generation(total_images=65536, max_workers=24):
+def run_mass_generation(total_images=16384, max_workers=24):
     with open(DB_PATH, "r") as f:
         db = json.load(f)
     

proofreader/train/yolo_trainer.py

@@ -2,7 +2,7 @@ from ultralytics import YOLO
 from ..core.config import TRAINING_CONFIG, DATA_YAML_PATH
 
 def train_yolo(device):
-    model = YOLO("yolo11n.pt")
+    model = YOLO("yolo26n.pt")
 
     model.train(
         data = DATA_YAML_PATH,
@@ -10,7 +10,7 @@ def train_yolo(device):
         imgsz = TRAINING_CONFIG["img_size"],
         device = device,
         plots = True,
-        multi_scale = True,
+        multi_scale = 0.5,
 
         batch = TRAINING_CONFIG["batch_size"],
         patience = TRAINING_CONFIG["patience"],
@@ -32,9 +32,9 @@ def finish_training(file_path, device):
 
     model.train(
         data = DATA_YAML_PATH,
-        epochs = 32,
-        close_mosaic = 32,
-        patience = 20,
+        epochs = 28,
+        close_mosaic = 28,
+        patience = 6,
         imgsz = TRAINING_CONFIG["img_size"],
         batch = TRAINING_CONFIG["batch_size"],
         device = device

{rbx_proofreader-1.1.1.dist-info → rbx_proofreader-1.2.0.dist-info}/METADATA

@@ -1,10 +1,12 @@
 Metadata-Version: 2.4
 Name: rbx-proofreader
-Version: 1.1.1
+Version: 1.2.0
 Summary: Visual trade detection and OCR engine
+Author: Luca Rose
 License: MIT
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
@@ -32,9 +34,9 @@ A high-speed vision pipeline for reading Roblox trade screenshots.
 [![License](https://img.shields.io/badge/license-MIT-blue)](LICENSE)
 [![Build Status](https://github.com/lucacrose/proofreader/actions/workflows/build.yml/badge.svg)](https://github.com/lucacrose/proofreader/actions)
 [![GPU](https://img.shields.io/badge/GPU-CUDA-blueviolet)](https://developer.nvidia.com/cuda-zone)
-[![YOLOv11](https://img.shields.io/badge/model-YOLOv11-blueviolet)](https://github.com/ultralytics/ultralytics)
+[![YOLO26](https://img.shields.io/badge/model-YOLO26-blueviolet)](https://github.com/ultralytics/ultralytics)
 
-Proofreader transforms unstructured screenshots of Roblox trades ("proofs", hence "proofreader") into structured Python dictionaries. By combining **YOLOv11** for object detection, **CLIP** for visual similarity, and **EasyOCR**, it achieves high accuracy across diverse UI themes, resolutions, and extensions.
+Proofreader transforms unstructured screenshots of Roblox trades ("proofs", hence "proofreader") into structured Python dictionaries. By combining **YOLO26** for object detection, **CLIP** for visual similarity, and **EasyOCR**, it achieves high accuracy across diverse UI themes, resolutions, and extensions.
 
 ## Why Proofreader?
 
@@ -47,20 +49,20 @@ Roblox trade screenshots are commonly used as proof in marketplaces, moderation
 
 ## ⚡ Performance
 
-Tested on an **RTX 5070** using $n=500$ real-world "worst-case" user screenshots (compressed, cropped, and varied UI).
+Tested on an **RTX 5070** using $n=1300$ real-world "worst-case" user screenshots (compressed, cropped, and varied UI).
 
 | Metric                  | Result (E2E)                |
 |:------------------------|:----------------------------|
-| Exact Match Accuracy    | 97.2% (95% CI: 95.4–98.5%)  |
-| Median latency          | 36.8 ms                     |
-| 95th percentile latency | 73.4 ms                     |
+| Exact Match Accuracy    | 98.4% (95% CI: 97.5–99.0%)  |
+| Median latency          | 28.0 ms                     |
+| 95th percentile latency | 47.4 ms                     |
 
 > [!NOTE]
-> End-to-End **(E2E)** latency includes image loading, YOLO detection, spatial organization, CLIP similarity matching, and OCR fallback.
+> Latencies above are reported End-to-End (**E2E**), including image loading, YOLO detection, spatial organization, CLIP matching, and OCR fallback. If passing images directly as NumPy arrays, median latency is 20.5 ms (35.0 ms P95).
 
 ## ✨ Key Features
 
-- **Sub-40ms Latency:** Optimized with "Fast-Path" logic that skips OCR for high-confidence visual matches, ensuring near-instant processing.
+- **Sub-30ms Latency:** Optimized with "Fast-Path" logic that skips OCR for high-confidence visual matches, ensuring near-instant processing.
 
 - **Multi-modal decision engine:** Weighs visual embeddings against OCR text to resolve identities across 2,500+ distinct item classes.
 
@@ -77,7 +79,7 @@ pip install rbx-proofreader
 ```
 
 > [!IMPORTANT]
-> **Hardware Acceleration:** Proofreader automatically detects NVIDIA GPUs. For sub-40ms performance, ensure you have the CUDA-enabled version of PyTorch installed. If a CPU-only environment is detected on a GPU-capable machine, the engine will provide the exact `pip` command to fix your environment.
+> **Hardware Acceleration:** Proofreader automatically detects NVIDIA GPUs. For sub-30ms performance, ensure you have the CUDA-enabled version of PyTorch installed. If a CPU-only environment is detected on a GPU-capable machine, the engine will provide the exact `pip` command to fix your environment.
 
 ### Usage
 
@@ -97,7 +99,7 @@ print(f"Robux In: {data['incoming']['robux_value']}")
 ## 🧩 How it Works
 The model handles the inconsistencies of user-generated screenshots (varied crops, UI themes, and extensions) through a multi-stage process:
 
-1. **Detection:** YOLOv11 localizes item cards, thumbnails, and robux containers.
+1. **Detection:** YOLO26 localizes item cards, thumbnails, and robux containers.
 
 2. **Spatial Organization:** Assigns child elements (names/values) to parents and determines trade side.
 
@@ -146,7 +148,7 @@ python scripts/train_models.py
 
 ## 🛠️ Tech Stack
 
-- **Vision:** YOLOv11 (Detection), CLIP (Embeddings), OpenCV (Processing)
+- **Vision:** YOLO26 (Detection), CLIP (Embeddings), OpenCV (Processing)
 - **OCR:** EasyOCR
 - **Logic:** RapidFuzz (Fuzzy String Matching)
 - **Core:** Python 3.12, PyTorch, NumPy

rbx_proofreader-1.2.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+proofreader/__init__.py,sha256=YVsRxmHmC2nvCrxvNmZX230B1s5k36RFM51kElXSxB4,285
+proofreader/main.py,sha256=fR1wXfGtxDUWjMRi5bMElXR8BkXnbGNJ0QXg71mJwso,6491
+proofreader/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+proofreader/core/config.py,sha256=xNp4K9zcukkW7eBDwr2XG6SkOCBwc6-q1iK3UNgEFSE,5996
+proofreader/core/detector.py,sha256=usY7ORLF1utfdq8tRYdrojshFxfagsdNI3Ek3M4AoFY,1131
+proofreader/core/matcher.py,sha256=av5cB4JDjO4euoMxH5dcjnJCMpBytiFZQXOWNZvhFhw,3745
+proofreader/core/ocr.py,sha256=FFhIS1TVrqSXUPGOll5RNbHX18q7de4xFUP1ewrnhSc,3652
+proofreader/core/resolver.py,sha256=gFFIwah1n9y2y1ojnUF_AOB52hf-4NbKKXUyxNxWyao,3593
+proofreader/core/schema.py,sha256=ga_7cYCBO13yFvLAtyAgDw7CFEb9c8Ui85SJDu2pcsA,2512
+proofreader/train/clip_trainer.py,sha256=6hiVrJ6WX6m13E3FE8kouIxXjQo3GPrU_8X266oeXqs,6416
+proofreader/train/yolo_trainer.py,sha256=ppVoQPpueMH4jfXCpyngo2ts9UEqS9I2WyecBIQe0Ac,984
+proofreader/train/emulator/generator.py,sha256=vmqDcgrht43m8T0mRfXeT3GbYTQlEbOKaEX6oz_9viw,11488
+rbx_proofreader-1.2.0.dist-info/licenses/LICENSE,sha256=eHSaONn9P_ZcYiY9QCi_XzVARIoQu7l2AI5BtFGA_BY,1069
+rbx_proofreader-1.2.0.dist-info/METADATA,sha256=UXY6DSMfY8zo9WK6F0uFHnVzaGlmI8WADn78lk41-DU,6730
+rbx_proofreader-1.2.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+rbx_proofreader-1.2.0.dist-info/top_level.txt,sha256=U3s8IVdLtGeGD3JgMmCHUgAsFhZXSSamp3vIojAFTxU,12
+rbx_proofreader-1.2.0.dist-info/RECORD,,

rbx_proofreader-1.1.1.dist-info/RECORD

@@ -1,17 +0,0 @@
-proofreader/__init__.py,sha256=YVsRxmHmC2nvCrxvNmZX230B1s5k36RFM51kElXSxB4,285
-proofreader/main.py,sha256=01G_-ppevuNNafi-QCc6UB_Y2NuIW6sDoZwvjjdm1B0,5220
-proofreader/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-proofreader/core/config.py,sha256=8L6MTBn3Z3Xa0bjPYt5q-OI-mm0-wMqeDSS0beAQ1fk,5906
-proofreader/core/detector.py,sha256=em2Kx0v96Zofi4kK5ipWlqMX9czq9YobHuEGuZkAQEc,987
-proofreader/core/matcher.py,sha256=4URgBb6EgBaCNFpafjnQrIot9KeIwoYUUNraaC9nlIk,3603
-proofreader/core/ocr.py,sha256=FFhIS1TVrqSXUPGOll5RNbHX18q7de4xFUP1ewrnhSc,3652
-proofreader/core/resolver.py,sha256=DTbf5qyQaJrBbw1QWQQJ_BZf_dg003p_xH8RMpI6sn8,2685
-proofreader/core/schema.py,sha256=ga_7cYCBO13yFvLAtyAgDw7CFEb9c8Ui85SJDu2pcsA,2512
-proofreader/train/clip_trainer.py,sha256=6hiVrJ6WX6m13E3FE8kouIxXjQo3GPrU_8X266oeXqs,6416
-proofreader/train/yolo_trainer.py,sha256=nOHPrYmBuefsUyiGEYqboNU6i3pykBXE0U4HYwNaqg8,986
-proofreader/train/emulator/generator.py,sha256=_l7qFLSoQxPYUKLDrqVIS-0sUs5FkjBK7ENWmZ-q2ls,9681
-rbx_proofreader-1.1.1.dist-info/licenses/LICENSE,sha256=eHSaONn9P_ZcYiY9QCi_XzVARIoQu7l2AI5BtFGA_BY,1069
-rbx_proofreader-1.1.1.dist-info/METADATA,sha256=CNi-FAGJvwoEL6LPmpL8m39canCcXsg_idlPTQFVeFA,6568
-rbx_proofreader-1.1.1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-rbx_proofreader-1.1.1.dist-info/top_level.txt,sha256=U3s8IVdLtGeGD3JgMmCHUgAsFhZXSSamp3vIojAFTxU,12
-rbx_proofreader-1.1.1.dist-info/RECORD,,