GameSentenceMiner 2.18.2__py3-none-any.whl → 2.18.4__py3-none-any.whl

GameSentenceMiner/util/db.py

@@ -93,6 +93,7 @@ class SQLiteDBTable:
     _types: List[type] = []
     _pk: str = 'id'
     _auto_increment: bool = True
+    _column_order_cache: Optional[List[str]] = None  # Cache for actual column order
 
     def __init_subclass__(cls, **kwargs):
         super().__init_subclass__(**kwargs)
@@ -104,6 +105,7 @@ class SQLiteDBTable:
     @classmethod
     def set_db(cls, db: SQLiteDB):
         cls._db = db
+        cls._column_order_cache = None  # Reset cache when database changes
         # Ensure table exists
         if not db.table_exists(cls._table):
             fields_def = ', '.join([f"{field} TEXT" for field in cls._fields])
@@ -115,6 +117,7 @@ class SQLiteDBTable:
         for field in cls._fields:
             if field not in existing_columns:
                 db.execute(f"ALTER TABLE {cls._table} ADD COLUMN {field} TEXT", commit=True)
+                cls._column_order_cache = None  # Reset cache when schema changes
 
     @classmethod
     def all(cls: Type[T]) -> List[T]:
@@ -137,49 +140,80 @@ class SQLiteDBTable:
         if not row:
             return None
         obj = cls()
-        fields = [cls._pk] + cls._fields
-        for i, field in enumerate(fields):
-            if i == 0 and field == cls._pk:
-                if cls._types[i] is int:
-                    setattr(obj, field, int(row[i])
-                            if row[i] is not None else None)
-                elif cls._types[i] is str:
-                    setattr(obj, field, str(row[i])
-                            if row[i] is not None else None)
-                continue
-            if cls._types[i] is str:
-                if not row[i]:
-                    setattr(obj, field, "")
-                elif (row[i].startswith('[') or row[i].startswith('{')):
-                    try:
-                        setattr(obj, field, json.loads(row[i]))
-                    except json.JSONDecodeError:
-                        setattr(obj, field, row[i])
-                else:
-                    setattr(obj, field, str(row[i])
-                            if row[i] is not None else None)
-            elif cls._types[i] is list:
-                try:
-                    setattr(obj, field, json.loads(row[i]) if row[i] else [])
-                except json.JSONDecodeError:
-                    setattr(obj, field, [])
-            elif cls._types[i] is int:
-                setattr(obj, field, int(row[i])
-                        if row[i] is not None else None)
-            elif cls._types[i] is float:
-                setattr(obj, field, float(row[i])
-                        if row[i] is not None else None)
-            elif cls._types[i] is bool:
-                setattr(obj, field, bool(row[i])
-                        if row[i] is not None else None)
-            elif cls._types[i] is dict:
+        
+        try:
+            # Get actual column order from database schema
+            actual_columns = cls.get_actual_column_order()
+            expected_fields = [cls._pk] + cls._fields
+            
+            # Create a mapping from actual column positions to expected field positions
+            column_mapping = {}
+            for i, actual_col in enumerate(actual_columns):
+                if actual_col in expected_fields:
+                    expected_index = expected_fields.index(actual_col)
+                    column_mapping[i] = expected_index
+            
+            # Process each column in the row based on the mapping
+            for actual_pos, row_value in enumerate(row):
+                if actual_pos not in column_mapping:
+                    continue  # Skip unknown columns
+                    
+                expected_pos = column_mapping[actual_pos]
+                field = expected_fields[expected_pos]
+                field_type = cls._types[expected_pos]
+                
+                cls._set_field_value(obj, field, field_type, row_value, expected_pos == 0 and field == cls._pk)
+                
+        except Exception as e:
+            # Fallback to original behavior if schema-based mapping fails
+            logger.warning(f"Column mapping failed for {cls._table}, falling back to positional mapping: {e}")
+            expected_fields = [cls._pk] + cls._fields
+            for i, field in enumerate(expected_fields):
+                if i >= len(row):
+                    break  # Safety check
+                field_type = cls._types[i]
+                cls._set_field_value(obj, field, field_type, row[i], i == 0 and field == cls._pk)
+                    
+        return obj
+    
+    @classmethod
+    def _set_field_value(cls, obj, field: str, field_type: type, row_value, is_pk: bool = False):
+        """Helper method to set field value with proper type conversion."""
+        if is_pk:
+            if field_type is int:
+                setattr(obj, field, int(row_value) if row_value is not None else None)
+            elif field_type is str:
+                setattr(obj, field, str(row_value) if row_value is not None else None)
+            return
+            
+        if field_type is str:
+            if not row_value:
+                setattr(obj, field, "")
+            elif isinstance(row_value, str) and (row_value.startswith('[') or row_value.startswith('{')):
                 try:
-                    setattr(obj, field, json.loads(row[i]) if row[i] else {})
+                    setattr(obj, field, json.loads(row_value))
                 except json.JSONDecodeError:
-                    setattr(obj, field, {})
+                    setattr(obj, field, row_value)
             else:
-                setattr(obj, field, row[i])
-        return obj
+                setattr(obj, field, str(row_value) if row_value is not None else None)
+        elif field_type is list:
+            try:
+                setattr(obj, field, json.loads(row_value) if row_value else [])
+            except json.JSONDecodeError:
+                setattr(obj, field, [])
+        elif field_type is int:
+            setattr(obj, field, int(row_value) if row_value is not None else None)
+        elif field_type is float:
+            setattr(obj, field, float(row_value) if row_value is not None else None)
+        elif field_type is bool:
+            setattr(obj, field, bool(row_value) if row_value is not None else None)
+        elif field_type is dict:
+            try:
+                setattr(obj, field, json.loads(row_value) if row_value else {})
+            except json.JSONDecodeError:
+                setattr(obj, field, {})
+        else:
+            setattr(obj, field, row_value)
 
     def save(self, retry=1):
         try:
@@ -245,9 +279,9 @@ class SQLiteDBTable:
             
     def add_column(self, column_name: str, new_column_type: str = "TEXT"):
         try:
-            index = self._fields.index(column_name) + 1
             self._db.execute(
                 f"ALTER TABLE {self._table} ADD COLUMN {column_name} {new_column_type}", commit=True)
+            self.__class__._column_order_cache = None  # Reset cache when schema changes
             logger.info(f"Added column {column_name} to {self._table}")
         except sqlite3.OperationalError as e:
             if "duplicate column name" in str(e):
@@ -286,11 +320,13 @@ class SQLiteDBTable:
     def rename_column(cls, old_column: str, new_column: str):
         cls._db.execute(
             f"ALTER TABLE {cls._table} RENAME COLUMN {old_column} TO {new_column}", commit=True)
+        cls._column_order_cache = None  # Reset cache when schema changes
         
     @classmethod
     def drop_column(cls, column_name: str):
         cls._db.execute(
             f"ALTER TABLE {cls._table} DROP COLUMN {column_name}", commit=True)
+        cls._column_order_cache = None  # Reset cache when schema changes
         
     @classmethod
     def get_column_type(cls, column_name: str) -> Optional[str]:
@@ -315,6 +351,36 @@ class SQLiteDBTable:
             f"UPDATE {cls._table} SET {new_column} = CAST({old_column} AS {new_type})", commit=True)
         cls._db.execute(
             f"ALTER TABLE {cls._table} DROP COLUMN {old_column}", commit=True)
+        cls._column_order_cache = None  # Reset cache when schema changes
+        
+    @classmethod
+    def get_actual_column_order(cls) -> List[str]:
+        """Get the actual column order from the database schema."""
+        if cls._column_order_cache is not None:
+            return cls._column_order_cache
+            
+        # Use direct database access to avoid recursion through from_row()
+        with cls._db._lock:
+            import sqlite3
+            with sqlite3.connect(cls._db.db_path, check_same_thread=False) as conn:
+                cursor = conn.cursor()
+                cursor.execute(f"PRAGMA table_info({cls._table})")
+                columns_info = cursor.fetchall()
+                
+        # Each row is (cid, name, type, notnull, dflt_value, pk)
+        # Sort by column id (cid) to get the actual order
+        sorted_columns = sorted(columns_info, key=lambda x: x[0])
+        column_order = [col[1] for col in sorted_columns]
+        
+        # Cache the result
+        cls._column_order_cache = column_order
+        return column_order
+        
+    @classmethod
+    def get_expected_column_list(cls) -> str:
+        """Get comma-separated list of columns in expected order for explicit SELECT queries."""
+        expected_fields = [cls._pk] + cls._fields
+        return ', '.join(expected_fields)
 
 
 class AIModelsTable(SQLiteDBTable):

GameSentenceMiner/util/get_overlay_coords.py

@@ -188,41 +188,41 @@ class OverlayProcessor:
         For primary monitor, excludes taskbar. For others, returns full monitor area.
         monitor_index: 0 = primary monitor, 1+ = others (as in mss.monitors).
         """
-        set_dpi_awareness()
+        # set_dpi_awareness()
         with mss.mss() as sct:
             monitors = sct.monitors[1:]
-            return monitors[monitor_index] if 0 <= monitor_index < len(monitors) else monitors[0]
-            # if is_windows() and monitor_index == 0:
-            #     from ctypes import wintypes
-            #     import ctypes
-            #     # Get work area for primary monitor (ignores taskbar)
-            #     SPI_GETWORKAREA = 0x0030
-            #     rect = wintypes.RECT()
-            #     res = ctypes.windll.user32.SystemParametersInfoW(
-            #         SPI_GETWORKAREA, 0, ctypes.byref(rect), 0
-            #     )
-            #     if not res:
-            #         raise ctypes.WinError()
+            # return monitors[monitor_index] if 0 <= monitor_index < len(monitors) else monitors[0]
+            if is_windows() and monitor_index == 0:
+                from ctypes import wintypes
+                import ctypes
+                # Get work area for primary monitor (ignores taskbar)
+                SPI_GETWORKAREA = 0x0030
+                rect = wintypes.RECT()
+                res = ctypes.windll.user32.SystemParametersInfoW(
+                    SPI_GETWORKAREA, 0, ctypes.byref(rect), 0
+                )
+                if not res:
+                    raise ctypes.WinError()
                 
-            #     return {
-            #         "left": rect.left,
-            #         "top": rect.top,
-            #         "width": rect.right - rect.left,
-            #         "height": rect.bottom - rect.top,
-            #     }
-            # elif is_windows() and monitor_index > 0:
-            #     # Secondary monitors: just return with a guess of how tall the taskbar is
-            #     taskbar_height_guess = 48  # A common taskbar height, may vary
-            #     mon = monitors[monitor_index]
-            #     return {
-            #         "left": mon["left"],
-            #         "top": mon["top"],
-            #         "width": mon["width"],
-            #         "height": mon["height"] - taskbar_height_guess
-            #     }
-            # else:
-            #     # For non-Windows systems or unspecified monitors, return the monitor area as-is
-            #     return monitors[monitor_index] if 0 <= monitor_index < len(monitors) else monitors[0]
+                return {
+                    "left": rect.left,
+                    "top": rect.top,
+                    "width": rect.right - rect.left,
+                    "height": rect.bottom - rect.top,
+                }
+            elif is_windows() and monitor_index > 0:
+                # Secondary monitors: just return with a guess of how tall the taskbar is
+                taskbar_height_guess = 48  # A common taskbar height, may vary
+                mon = monitors[monitor_index]
+                return {
+                    "left": mon["left"],
+                    "top": mon["top"],
+                    "width": mon["width"],
+                    "height": mon["height"] - taskbar_height_guess
+                }
+            else:
+                # For non-Windows systems or unspecified monitors, return the monitor area as-is
+                return monitors[monitor_index] if 0 <= monitor_index < len(monitors) else monitors[0]
 
 
     def _get_full_screenshot(self) -> Tuple[Image.Image | None, int, int]:

GameSentenceMiner/web/database_api.py

@@ -1182,7 +1182,7 @@ def register_database_api_routes(app):
             })
             
         except Exception as e:
-            logger.error(f"Unexpected error in api_stats: {e}")
+            logger.error(f"Unexpected error in api_stats: {e}", exc_info=True)
             return jsonify({'error': 'Failed to generate statistics'}), 500
 
     @app.route('/api/goals-today', methods=['GET'])

{gamesentenceminer-2.18.2.dist-info → gamesentenceminer-2.18.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GameSentenceMiner
-Version: 2.18.2
+Version: 2.18.4
 Summary: A tool for mining sentences from games. Update: Overlay?
 Author-email: Beangate <bpwhelan95@gmail.com>
 License: MIT License

{gamesentenceminer-2.18.2.dist-info → gamesentenceminer-2.18.4.dist-info}/RECORD

@@ -41,10 +41,10 @@ GameSentenceMiner/ui/config_gui.py,sha256=Nt6uuJrinOrSpDdrw92zdd1GvyQNjOoGvkZQdG
 GameSentenceMiner/ui/screenshot_selector.py,sha256=AKML87MpgYQeSuj1F10GngpNrn9qp06zLLzNRwrQWM8,8900
 GameSentenceMiner/util/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 GameSentenceMiner/util/configuration.py,sha256=fYlU4Qrr6T-k_G2MY2rgoQ9EV_k7XBfbtsO8q7PKTsU,46653
-GameSentenceMiner/util/db.py,sha256=3Fs75pGJyf8-3y3k6Zfpgp8z9tYL9-ZvQUk_FgDc9Vw,28664
+GameSentenceMiner/util/db.py,sha256=1DjGjlwWnPefmQfzvMqqFPW0a0qeO-fIXE1YqKiok18,32000
 GameSentenceMiner/util/electron_config.py,sha256=KfeJToeFFVw0IR5MKa-gBzpzaGrU-lyJbR9z-sDEHYU,8767
 GameSentenceMiner/util/ffmpeg.py,sha256=cAzztfY36Xf2WvsJDjavoiMOvA9ac2GVdCrSB4LzHk4,29007
-GameSentenceMiner/util/get_overlay_coords.py,sha256=iAA49bF_8jJXNR6bEGEVAuXsUwYMW5tcfnCGiLyAzso,22172
+GameSentenceMiner/util/get_overlay_coords.py,sha256=c37zVKPxFqwIi5XjZKjxRCW_Y8W4e1MX7vSLLwcOhs4,22116
 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
@@ -59,7 +59,7 @@ GameSentenceMiner/util/downloader/oneocr_dl.py,sha256=l3s9Z-x1b57GX048o5h-MVv0UT
 GameSentenceMiner/util/win10toast/__init__.py,sha256=6TL2w6rzNmpJEp6_v2cAJP_7ExA3UsKzwdM08pNcVfE,5341
 GameSentenceMiner/util/win10toast/__main__.py,sha256=5MYnBcFj8y_6Dyc1kiPd0_FsUuh4yl1cv5wsleU6V4w,668
 GameSentenceMiner/web/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-GameSentenceMiner/web/database_api.py,sha256=pY1j8b1H5VdkDv5aaZjBnpx4tSNfJhfsuukyty6jbi0,84812
+GameSentenceMiner/web/database_api.py,sha256=Ph30uGAJFSxRkBdrZglXKsuwuKP46RxjzGODMO5aaLc,84827
 GameSentenceMiner/web/events.py,sha256=6Vyz5c9MdpMIa7Zqljqhap2XFQnAVYJ0CdQV64TSZsA,5119
 GameSentenceMiner/web/gsm_websocket.py,sha256=B0VKpxmsRu0WRh5nFWlpDPBQ6-K2ed7TEIa0O6YWeoo,4166
 GameSentenceMiner/web/service.py,sha256=YZchmScTn7AX_GkwV1ULEK6qjdOnJcpc3qfMwDf7cUE,5363
@@ -124,9 +124,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.18.2.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-gamesentenceminer-2.18.2.dist-info/METADATA,sha256=ur53IngoSZHHs1vyMxSPuwZJhbkyBJajZ9exWCn8zQY,7487
-gamesentenceminer-2.18.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-gamesentenceminer-2.18.2.dist-info/entry_points.txt,sha256=2APEP25DbfjSxGeHtwBstMH8mulVhLkqF_b9bqzU6vQ,65
-gamesentenceminer-2.18.2.dist-info/top_level.txt,sha256=V1hUY6xVSyUEohb0uDoN4UIE6rUZ_JYx8yMyPGX4PgQ,18
-gamesentenceminer-2.18.2.dist-info/RECORD,,
+gamesentenceminer-2.18.4.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+gamesentenceminer-2.18.4.dist-info/METADATA,sha256=SXw7P4busY00L4EwV-Avnt2C29HYJGLoePm5WBEgIo8,7487
+gamesentenceminer-2.18.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+gamesentenceminer-2.18.4.dist-info/entry_points.txt,sha256=2APEP25DbfjSxGeHtwBstMH8mulVhLkqF_b9bqzU6vQ,65
+gamesentenceminer-2.18.4.dist-info/top_level.txt,sha256=V1hUY6xVSyUEohb0uDoN4UIE6rUZ_JYx8yMyPGX4PgQ,18
+gamesentenceminer-2.18.4.dist-info/RECORD,,