GameSentenceMiner 2.21.25__tar.gz → 2.21.29__tar.gz

{gamesentenceminer-2.21.25 → gamesentenceminer-2.21.29}/GameSentenceMiner/ocr/ss_picker_qt.py

@@ -1,4 +1,3 @@
-import io
 import logging
 from PIL import Image
 import mss
@@ -7,15 +6,71 @@ from PyQt6.QtWidgets import QApplication, QWidget
 from PyQt6.QtCore import Qt, QRect
 from PyQt6.QtGui import QPainter, QPen, QColor, QPixmap, QImage
 import sys
+import ctypes
+import ctypes.wintypes
 
 # Import Window State Manager
 from GameSentenceMiner.ui import window_state_manager, WindowId
 
 logger = logging.getLogger("GSM_OCR")
 
+
+def get_monitor_dpi_scale():
+    """
+    Get DPI scaling information for all monitors.
+    Returns a dict mapping monitor index to scale factor.
+    """
+    try:
+        # Get DPI awareness
+        user32 = ctypes.windll.user32
+        user32.SetProcessDPIAware()
+        
+        # Enumerate all monitors and their DPI
+        monitors_dpi = {}
+        
+        def callback(hMonitor, hdcMonitor, lprcMonitor, dwData):
+            try:
+                # Get DPI for this monitor
+                shcore = ctypes.windll.shcore
+                dpiX = ctypes.c_uint()
+                dpiY = ctypes.c_uint()
+                
+                # MDT_EFFECTIVE_DPI = 0
+                shcore.GetDpiForMonitor(hMonitor, 0, ctypes.byref(dpiX), ctypes.byref(dpiY))
+                
+                # Standard DPI is 96, so scale factor is dpi/96
+                scale = dpiX.value / 96.0
+                
+                # Store by monitor count
+                idx = len(monitors_dpi)
+                monitors_dpi[idx] = scale
+                logger.debug(f"Monitor {idx}: DPI={dpiX.value}, Scale={scale:.2f}")
+            except Exception as e:
+                logger.warning(f"Failed to get DPI for monitor: {e}")
+                monitors_dpi[len(monitors_dpi)] = 1.0
+            return True
+        
+        # Define callback type
+        MonitorEnumProc = ctypes.WINFUNCTYPE(
+            ctypes.c_bool,
+            ctypes.wintypes.HMONITOR,
+            ctypes.wintypes.HDC,
+            ctypes.POINTER(ctypes.wintypes.RECT),
+            ctypes.wintypes.LPARAM
+        )
+        
+        # Enumerate monitors
+        user32.EnumDisplayMonitors(None, None, MonitorEnumProc(callback), 0)
+        
+        return monitors_dpi
+    except Exception as e:
+        logger.warning(f"Failed to get monitor DPI scaling: {e}. Using 1.0")
+        return {}
+
 # Global instance
 _screen_cropper_instance = None
 
+
 class ScreenCropperWidget(QWidget):
     def __init__(self, parent=None):
         super().__init__(parent)
@@ -32,6 +87,11 @@ class ScreenCropperWidget(QWidget):
         self.result = None
         self.pixmap = None
         
+        # DPI scaling factors
+        self.dpi_scale_x = 1.0
+        self.dpi_scale_y = 1.0
+        self.physical_to_logical_scale = 1.0
+        
         # Drawing state
         self.start_pos = None
         self.current_pos = None
@@ -39,9 +99,18 @@ class ScreenCropperWidget(QWidget):
 
         self.setCursor(Qt.CursorShape.CrossCursor)
 
-    def prepare_capture(self, captured_image, monitor_geometry, main_monitor, on_complete=None, transparent_mode=False):
+    def prepare_capture(self, captured_image, monitor_geometry, main_monitor, 
+                       on_complete=None, transparent_mode=False, dpi_scale=1.0):
         """
         Resets the widget state for a new capture session.
+        
+        Args:
+            captured_image: PIL Image captured at physical pixel resolution
+            monitor_geometry: Physical pixel coordinates from mss
+            main_monitor: Main monitor info from mss
+            on_complete: Callback function
+            transparent_mode: Whether to use transparent overlay mode
+            dpi_scale: DPI scale factor for coordinate conversion
         """
         self.captured_image = captured_image
         self.monitor_geometry = monitor_geometry
@@ -49,27 +118,46 @@ class ScreenCropperWidget(QWidget):
         self.on_complete = on_complete
         self.transparent_mode = transparent_mode
         self.result = None
+        self.physical_to_logical_scale = dpi_scale
         
         # Reset drawing state
         self.start_pos = None
         self.current_pos = None
         self.is_drawing = False
         
+        # Calculate logical coordinates for Qt widget
+        # mss gives us physical pixels, Qt uses logical pixels
+        logical_left = int(self.monitor_geometry['left'] / dpi_scale)
+        logical_top = int(self.monitor_geometry['top'] / dpi_scale)
+        logical_width = int(self.monitor_geometry['width'] / dpi_scale)
+        logical_height = int(self.monitor_geometry['height'] / dpi_scale)
+        
         if not self.transparent_mode and self.captured_image:
-            # Convert PIL Image to QPixmap
+            # Keep the image at full physical resolution for best quality
+            # Qt will handle the scaling automatically via devicePixelRatio
             img_data = self.captured_image.tobytes('raw', 'RGB')
-            qimage = QImage(img_data, self.captured_image.width, self.captured_image.height, 
-                           self.captured_image.width * 3, QImage.Format.Format_RGB888)
+            qimage = QImage(
+                img_data, 
+                self.captured_image.width, 
+                self.captured_image.height, 
+                self.captured_image.width * 3, 
+                QImage.Format.Format_RGB888
+            )
             self.pixmap = QPixmap.fromImage(qimage)
+            # Set device pixel ratio so Qt knows this is a high-DPI image
+            self.pixmap.setDevicePixelRatio(dpi_scale)
+            logger.debug(f"Pixmap size: {self.pixmap.width()}x{self.pixmap.height()}, DPR: {dpi_scale}")
         else:
             self.pixmap = None
             
         self.setAttribute(Qt.WidgetAttribute.WA_TranslucentBackground, self.transparent_mode)
         
-        # Enforce geometry to match the monitor/screenshot area
-        # We do this every time because mss coordinates are absolute
-        self.move(self.monitor_geometry['left'], self.monitor_geometry['top'])
-        self.resize(self.monitor_geometry['width'], self.monitor_geometry['height'])
+        # Set widget geometry using logical coordinates
+        self.move(logical_left, logical_top)
+        self.resize(logical_width, logical_height)
+        
+        logger.info(f"Widget positioned at logical ({logical_left}, {logical_top}) "
+                   f"size {logical_width}x{logical_height}, DPI scale: {dpi_scale:.2f}")
         
         self.show()
         self.activateWindow()
@@ -104,12 +192,11 @@ class ScreenCropperWidget(QWidget):
         else:
             # Original mode with screenshot background
             if self.pixmap:
-                painter.drawPixmap(0, 0, self.pixmap)
+                # Scale the drawing to account for device pixel ratio
+                # The pixmap has devicePixelRatio set, so it will draw at the correct size
+                painter.drawPixmap(0, 0, self.width(), self.height(), self.pixmap)
             
-            # Draw semi-transparent overlay
-            painter.fillRect(self.rect(), QColor(0, 0, 0, 128))
-            
-            # If we're drawing a selection, clear that area and draw border
+            # If we're drawing a selection, only overlay outside the selection
             if self.start_pos and self.current_pos:
                 x1 = min(self.start_pos.x(), self.current_pos.x())
                 y1 = min(self.start_pos.y(), self.current_pos.y())
@@ -118,19 +205,29 @@ class ScreenCropperWidget(QWidget):
                 
                 selection_rect = QRect(x1, y1, x2 - x1, y2 - y1)
                 
-                # Clear the overlay in selection area
-                painter.setCompositionMode(QPainter.CompositionMode.CompositionMode_Clear)
-                painter.fillRect(selection_rect, Qt.GlobalColor.transparent)
-                painter.setCompositionMode(QPainter.CompositionMode.CompositionMode_SourceOver)
+                # Draw overlay everywhere except selection area
+                overlay_color = QColor(0, 0, 0, 128)
                 
-                # Draw the screenshot in selection area (without overlay)
-                if self.pixmap:
-                    painter.drawPixmap(selection_rect, self.pixmap, selection_rect)
+                # Top rectangle
+                if y1 > 0:
+                    painter.fillRect(0, 0, self.width(), y1, overlay_color)
+                # Bottom rectangle
+                if y2 < self.height():
+                    painter.fillRect(0, y2, self.width(), self.height() - y2, overlay_color)
+                # Left rectangle
+                if x1 > 0:
+                    painter.fillRect(0, y1, x1, y2 - y1, overlay_color)
+                # Right rectangle
+                if x2 < self.width():
+                    painter.fillRect(x2, y1, self.width() - x2, y2 - y1, overlay_color)
                 
                 # Draw red border
                 pen = QPen(QColor(255, 0, 0), 3)
                 painter.setPen(pen)
                 painter.drawRect(selection_rect)
+            else:
+                # No selection, draw overlay over everything
+                painter.fillRect(self.rect(), QColor(0, 0, 0, 128))
     
     def mousePressEvent(self, event):
         if event.button() == Qt.MouseButton.LeftButton:
@@ -157,27 +254,41 @@ class ScreenCropperWidget(QWidget):
             if (x2 - x1) > 0 and (y2 - y1) > 0:
                 if self.transparent_mode:
                     # In transparent mode, take a fresh screenshot of the selected area
+                    # Convert widget logical coordinates to physical screen coordinates
                     try:
                         with mss.mss() as sct:
-                            # Convert widget coordinates to screen coordinates
+                            # Widget coordinates are in logical pixels, need to convert to physical
+                            physical_x1 = int(x1 * self.physical_to_logical_scale)
+                            physical_y1 = int(y1 * self.physical_to_logical_scale)
+                            physical_x2 = int(x2 * self.physical_to_logical_scale)
+                            physical_y2 = int(y2 * self.physical_to_logical_scale)
+                            
                             monitor_region = {
-                                "left": self.monitor_geometry['left'] + x1,
-                                "top": self.monitor_geometry['top'] + y1,
-                                "width": x2 - x1,
-                                "height": y2 - y1
+                                "left": self.monitor_geometry['left'] + physical_x1,
+                                "top": self.monitor_geometry['top'] + physical_y1,
+                                "width": physical_x2 - physical_x1,
+                                "height": physical_y2 - physical_y1
                             }
                             sct_grab = sct.grab(monitor_region)
                             # Convert to PIL Image
                             self.result = Image.frombytes('RGB', sct_grab.size, sct_grab.bgra, 'raw', 'BGRX')
-                            logger.info(f"Fresh screenshot captured: ({monitor_region['left']}, {monitor_region['top']}) size {monitor_region['width']}x{monitor_region['height']}")
+                            logger.info(f"Fresh screenshot captured: ({monitor_region['left']}, {monitor_region['top']}) "
+                                      f"size {monitor_region['width']}x{monitor_region['height']} (physical pixels)")
                     except Exception as e:
                         logger.error(f"Error capturing fresh screenshot: {e}")
                         self.result = None
                 else:
                     # Original mode: crop from the already-captured image
+                    # Widget coordinates are in logical pixels, need to convert to physical for cropping
                     if self.captured_image:
-                        self.result = self.captured_image.crop((x1, y1, x2, y2))
-                        logger.info(f"Selection made: ({x1}, {y1}) to ({x2}, {y2})")
+                        physical_x1 = int(x1 * self.physical_to_logical_scale)
+                        physical_y1 = int(y1 * self.physical_to_logical_scale)
+                        physical_x2 = int(x2 * self.physical_to_logical_scale)
+                        physical_y2 = int(y2 * self.physical_to_logical_scale)
+                        
+                        self.result = self.captured_image.crop((physical_x1, physical_y1, physical_x2, physical_y2))
+                        logger.info(f"Selection made: logical ({x1}, {y1}) to ({x2}, {y2}), "
+                                  f"physical ({physical_x1}, {physical_y1}) to ({physical_x2}, {physical_y2})")
                 
                 # Hide instead of close to preserve instance
                 self._finish()
@@ -194,12 +305,19 @@ class ScreenCropperWidget(QWidget):
             self._finish()
         elif event.key() == Qt.Key.Key_Return or event.key() == Qt.Key.Key_Enter:
             # Grab main monitor area
+            # Convert main monitor coords from physical to logical for cropping
             if self.captured_image:
+                # Main monitor coordinates are in physical pixels
+                main_left = self.main_monitor['left'] - self.monitor_geometry['left']
+                main_top = self.main_monitor['top'] - self.monitor_geometry['top']
+                main_right = main_left + self.main_monitor['width']
+                main_bottom = main_top + self.main_monitor['height']
+                
                 self.result = self.captured_image.crop((
-                    self.main_monitor['left'],
-                    self.main_monitor['top'],
-                    self.main_monitor['left'] + self.main_monitor['width'],
-                    self.main_monitor['top'] + self.main_monitor['height']
+                    main_left,
+                    main_top,
+                    main_right,
+                    main_bottom
                 ))
             logger.info("Main monitor area selected")
             self._finish()
@@ -225,9 +343,13 @@ def show_screen_cropper(on_complete=None, transparent_mode=False):
     """
     Displays a Qt-based screen cropper that allows the user to select a region.
     Reuses the existing widget instance.
+    Properly handles Windows DPI scaling.
     """
     global _screen_cropper_instance
 
+    # Get DPI scaling information for all monitors
+    monitors_dpi = get_monitor_dpi_scale()
+    
     if not transparent_mode:
         # Original mode: capture screen first
         try:
@@ -235,19 +357,27 @@ def show_screen_cropper(on_complete=None, transparent_mode=False):
             with mss.mss() as sct:
                 all_monitors_bbox = sct.monitors[0]
                 main_monitor = sct.monitors[1]
+                
+                # Determine DPI scale - use primary monitor's scale
+                # mss monitor indices start at 1 for actual monitors
+                dpi_scale = monitors_dpi.get(0, 1.0)  # Monitor 0 in our enum is monitor 1 in mss
+                
                 monitor_geometry = {
                     'left': all_monitors_bbox['left'],
                     'top': all_monitors_bbox['top'],
                     'width': all_monitors_bbox['width'],
                     'height': all_monitors_bbox['height']
                 }
+                
+                # mss captures at physical pixel resolution
                 sct_grab = sct.grab(all_monitors_bbox)
                 
                 # Convert directly from raw bytes to PIL Image (faster than to_png)
                 # MSS returns BGRA format, convert to RGB
                 captured_image = Image.frombytes('RGB', sct_grab.size, sct_grab.bgra, 'raw', 'BGRX')
                 
-                logger.info(f"Screen captured: {monitor_geometry['width']}x{monitor_geometry['height']}")
+                logger.info(f"Screen captured: {monitor_geometry['width']}x{monitor_geometry['height']} "
+                          f"(physical pixels), DPI scale: {dpi_scale:.2f}")
         except Exception as e:
             logger.error(f"Error capturing screen: {e}")
             if on_complete:
@@ -259,6 +389,10 @@ def show_screen_cropper(on_complete=None, transparent_mode=False):
             with mss.mss() as sct:
                 all_monitors_bbox = sct.monitors[0]
                 main_monitor = sct.monitors[1]
+                
+                # Determine DPI scale
+                dpi_scale = monitors_dpi.get(0, 1.0)
+                
                 monitor_geometry = {
                     'left': all_monitors_bbox['left'],
                     'top': all_monitors_bbox['top'],
@@ -266,7 +400,8 @@ def show_screen_cropper(on_complete=None, transparent_mode=False):
                     'height': all_monitors_bbox['height']
                 }
                 captured_image = None
-                logger.info(f"Transparent mode: monitor geometry {monitor_geometry['width']}x{monitor_geometry['height']}")
+                logger.info(f"Transparent mode: monitor geometry {monitor_geometry['width']}x{monitor_geometry['height']} "
+                          f"(physical pixels), DPI scale: {dpi_scale:.2f}")
         except Exception as e:
             logger.error(f"Error getting monitor geometry: {e}")
             if on_complete:
@@ -283,7 +418,14 @@ def show_screen_cropper(on_complete=None, transparent_mode=False):
         _screen_cropper_instance = ScreenCropperWidget()
         
     # Prepare the widget with the new screenshot data
-    _screen_cropper_instance.prepare_capture(captured_image, monitor_geometry, main_monitor, on_complete, transparent_mode)
+    _screen_cropper_instance.prepare_capture(
+        captured_image, 
+        monitor_geometry, 
+        main_monitor, 
+        on_complete, 
+        transparent_mode,
+        dpi_scale
+    )
     
     # Keep the widget alive by entering event loop until it's hidden
     if on_complete:

{gamesentenceminer-2.21.25 → gamesentenceminer-2.21.29}/GameSentenceMiner/web/static/js/goals.js

@@ -188,6 +188,13 @@ const GoalsUtils = {
         return str.charAt(0).toUpperCase() + str.slice(1);
     },
 
+    // Parse YYYY-MM-DD date string as local date (not UTC)
+    parseLocalDate(dateStr) {
+        if (!dateStr) return null;
+        const [year, month, day] = dateStr.split('-').map(Number);
+        return new Date(year, month - 1, day); // month is 0-indexed
+    },
+
     // Get goals from database (uses cache if available)
     async getGoalsWithFallback() {
         const data = GoalsDataManager.getCached() || await GoalsDataManager.fetchCurrent();
@@ -395,7 +402,7 @@ const CustomGoalCheckboxManager = {
 
         // Start from the most recent completion date
         let streak = 1;
-        let prevDate = new Date(sortedDates[0]);
+        let prevDate = GoalsUtils.parseLocalDate(sortedDates[0]);
 
         // Count consecutive days backwards from the most recent date
         for (let i = 1; i < sortedDates.length; i++) {
@@ -477,9 +484,7 @@ const CustomGoalsManager = {
 
     // Get active goals (within current date or future)
     async getActive() {
-        const today = new Date();
-        today.setHours(0, 0, 0, 0);
-        const todayStr = today.toISOString().split('T')[0];
+        const todayStr = GoalsUtils.getTodayDateString();
 
         const allGoals = await this.getAll();
         return allGoals.filter(goal => {
@@ -491,9 +496,7 @@ const CustomGoalsManager = {
 
     // Get goals that are currently in progress (today is within date range)
     async getInProgress() {
-        const today = new Date();
-        today.setHours(0, 0, 0, 0);
-        const todayStr = today.toISOString().split('T')[0];
+        const todayStr = GoalsUtils.getTodayDateString();
 
         const allGoals = await this.getAll();
         return allGoals.filter(goal => {
@@ -729,15 +732,15 @@ document.addEventListener('DOMContentLoaded', function () {
 
         const progressBarClass = `completion-${Math.floor(percentage / 25) * 25}`;
 
-        // Format dates for display
-        const startDate = new Date(goal.startDate);
-        const endDate = new Date(goal.endDate);
+        // Format dates for display - parse YYYY-MM-DD as local date
+        const startDate = GoalsUtils.parseLocalDate(goal.startDate);
+        const endDate = GoalsUtils.parseLocalDate(goal.endDate);
         let formattedStartDate = 'N/A';
 
-        if (startDate >= new Date(1980, 0, 1)) {
+        if (startDate && startDate >= new Date(1980, 0, 1)) {
             formattedStartDate = startDate.toLocaleDateString(navigator.language, { month: 'short', day: 'numeric', year: 'numeric' });
         }
-        const formattedEndDate = endDate.toLocaleDateString(navigator.language, { month: 'short', day: 'numeric', year: 'numeric' });
+        const formattedEndDate = endDate ? endDate.toLocaleDateString(navigator.language, { month: 'short', day: 'numeric', year: 'numeric' }) : 'N/A';
 
         return `
             <div class="goal-progress-item custom-goal-item" data-goal-id="${goal.id}">
@@ -1148,9 +1151,9 @@ document.addEventListener('DOMContentLoaded', function () {
             formattedProjection = projectionData.projection.toLocaleString();
         }
 
-        // Format target date
-        const targetDate = new Date(projectionData.end_date);
-        const formattedTargetDate = targetDate.toLocaleDateString(navigator.language);
+        // Format target date - parse YYYY-MM-DD as local date
+        const targetDate = GoalsUtils.parseLocalDate(projectionData.end_date);
+        const formattedTargetDate = targetDate ? targetDate.toLocaleDateString(navigator.language) : 'N/A';
 
         // Calculate projected completion date
         const remaining = Math.max(0, projectionData.target - projectionData.current);
@@ -1231,9 +1234,7 @@ document.addEventListener('DOMContentLoaded', function () {
 
             // Filter for only the 5 core metrics and goals that have started
             const coreMetrics = ['hours', 'characters', 'games', 'cards', 'mature_cards'];
-            const today = new Date();
-            today.setHours(0, 0, 0, 0);
-            const todayStr = today.toISOString().split('T')[0];
+            const todayStr = GoalsUtils.getTodayDateString();
 
             const customGoalsWithProjections = customGoals.filter(goal => {
                 // Must be a core metric
@@ -1387,8 +1388,8 @@ document.addEventListener('DOMContentLoaded', function () {
                 // Helper to calculate days between two dates (inclusive)
                 function getDaysBetween(start, end) {
                     if (!start || !end) return null;
-                    const startDate = new Date(start);
-                    const endDate = new Date(end);
+                    const startDate = GoalsUtils.parseLocalDate(start);
+                    const endDate = GoalsUtils.parseLocalDate(end);
                     if (isNaN(startDate) || isNaN(endDate)) return null;
                     // Add 1 to include both start and end dates
                     return Math.floor((endDate - startDate) / (1000 * 60 * 60 * 24)) + 1;

{gamesentenceminer-2.21.25 → gamesentenceminer-2.21.29}/GameSentenceMiner.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GameSentenceMiner
-Version: 2.21.25
+Version: 2.21.29
 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

{gamesentenceminer-2.21.25 → gamesentenceminer-2.21.29}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GameSentenceMiner
-Version: 2.21.25
+Version: 2.21.29
 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

{gamesentenceminer-2.21.25 → gamesentenceminer-2.21.29}/pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "GameSentenceMiner"
-version = "2.21.25"
+version = "2.21.29"
 description = "A tool for mining sentences from games. Update: Dependencies, replay buffer based line searching, and bug fixes."
 readme = "README.md"
 requires-python = ">=3.10, <3.14"