GameSentenceMiner 2.18.3__tar.gz → 2.18.5__tar.gz

{gamesentenceminer-2.18.3 → gamesentenceminer-2.18.5}/GameSentenceMiner/obs.py

@@ -132,11 +132,14 @@ class OBSConnectionManager(threading.Thread):
         
     def check_replay_buffer_enabled(self):
         if not self.should_check_output:
-            return True, ""
-        output = get_replay_buffer_output()
-        if not output:
-            return False, "Replay Buffer output not found in OBS. Please enable Replay Buffer In OBS Settings -> Output -> Replay Buffer. I recommend 300 seconds (5 minutes) or higher."
-        return True, ""
+            return 300, ""
+        buffer_seconds = get_replay_buffer_max_time_seconds()
+        if not buffer_seconds:
+            replay_output = get_replay_buffer_output()
+            if not replay_output:
+                return 0, "Replay Buffer output not found in OBS. Please enable Replay Buffer In OBS Settings -> Output -> Replay Buffer. I recommend 300 seconds (5 minutes) or higher."
+            return 300, ""
+        return buffer_seconds, ""
 
     def _manage_replay_buffer_and_utils(self):
         errors = []
@@ -150,11 +153,13 @@ class OBSConnectionManager(threading.Thread):
             errors.append("Automatic Replay Buffer management is disabled in GSM settings.")
             return errors
 
-        replay_buffer_enabled, error_message = self.check_replay_buffer_enabled()
+        buffer_seconds, error_message = self.check_replay_buffer_enabled()
 
-        if not replay_buffer_enabled:
+        if not buffer_seconds:
             errors.append(error_message)
             return errors
+        
+        self.NO_OUTPUT_SHUTDOWN_SECONDS = max(300, buffer_seconds * 1.10)  # At least 5 minutes or 10% more than buffer
 
         current_status = get_replay_buffer_status()
 
@@ -167,10 +172,10 @@ class OBSConnectionManager(threading.Thread):
             self.no_output_timestamp = None
             return errors
         
-        img = get_screenshot_PIL(compression=100, img_format='jpg', width=1280, height=720)
-        has_changed = self.has_image_changed(img) if img else True
+        img = get_screenshot_PIL(compression=75, img_format='jpg', width=1280, height=720)
+        is_empty = self.is_image_empty(img) if img else True
 
-        if not has_changed:
+        if not is_empty:
             self.no_output_timestamp = None
             if not current_status:
                 start_replay_buffer()
@@ -184,20 +189,18 @@ class OBSConnectionManager(threading.Thread):
                     self.last_replay_buffer_status = False
                     self.no_output_timestamp = None
 
-    def has_image_changed(self, img):
-        if self.previous_image is None:
-            self.previous_image = np.array(img)
-            return True
+    def is_image_empty(self, img):
         try:
-            img1_np = np.array(img) if not isinstance(img, np.ndarray) else img
-            img2_np = self.previous_image
-            self.previous_image = img1_np
+            extrema = img.getextrema()
+            if isinstance(extrema[0], tuple):
+                is_empty = all(e[0] == e[1] for e in extrema)
+            else:
+                is_empty = extrema[0] == extrema[1]
+            return is_empty
         except Exception:
-            logger.warning("Failed to convert images to numpy arrays for comparison.")
+            logger.warning("Failed to check image extrema for emptiness.")
             return False
 
-        return (img1_np.shape == img2_np.shape) and np.array_equal(img1_np, img2_np)
-
     def run(self):
         time.sleep(5)  # Initial delay to allow OBS to start
         while self.running:
@@ -566,7 +569,7 @@ def get_replay_buffer_max_time_seconds():
                 logger.warning(f"get_output_settings for replay_buffer failed: {response.status}")
                 return 0
     except Exception as e:
-        logger.error(f"Exception while fetching replay buffer settings: {e}")
+        # logger.error(f"Exception while fetching replay buffer settings: {e}")
         return 0
     
 def enable_replay_buffer():
@@ -805,7 +808,24 @@ def set_fit_to_screen_for_scene_items(scene_name: str):
     except obs.error.OBSSDKError as e:
         logger.error(f"An OBS error occurred: {e}")
     except Exception as e:
-        logger.error(f"An unexpected error occurred: {e}")
+        logger.error(f"An unexpected error occurred: {e}")    
+
+def get_current_source_input_settings():
+    with connection_pool.get_client() as client:
+        client: obs.ReqClient
+        current_scene = get_current_scene()
+        if not current_scene:
+            return None
+        scene_items_response = client.get_scene_item_list(name=current_scene)
+        items = scene_items_response.scene_items if scene_items_response and scene_items_response.scene_items else []
+        if not items:
+            return None
+        first_item = items[0]
+        source_name = first_item.get('sourceName')
+        if not source_name:
+            return None
+        input_settings_response = client.get_input_settings(name=source_name)
+        return input_settings_response.input_settings if input_settings_response else None
 
 
 def main():
@@ -867,17 +887,23 @@ if __name__ == '__main__':
     logging.basicConfig(level=logging.INFO)
     connect_to_obs_sync()
     
-    save_replay_buffer()
+    # outputs = get_output_list()
+    # print(outputs)
+    
+    # output = get_replay_buffer_output()
+    # print(output)
+    
+    # save_replay_buffer()
     # img = get_screenshot_PIL(source_name='Display Capture 2', compression=100, img_format='jpg', width=2560, height=1440)
     # img.show()
-    # output_list = get_output_list()
-    # print(output_list)
+    # source = get_current_source_input_settings()
+    # print(source)
     
     # response = enable_replay_buffer()
     # print(response)
     
     # response = get_replay_buffer_max_time_seconds()
-    # # response is dataclass with attributes, print attributes
+    # response is dataclass with attributes, print attributes
     # print(response)
     
     # response = enable_replay_buffer()

{gamesentenceminer-2.18.3 → gamesentenceminer-2.18.5}/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-2.18.3 → gamesentenceminer-2.18.5}/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.3 → gamesentenceminer-2.18.5}/GameSentenceMiner.egg-info/PKG-INFO

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

{gamesentenceminer-2.18.3 → gamesentenceminer-2.18.5}/PKG-INFO

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

{gamesentenceminer-2.18.3 → gamesentenceminer-2.18.5}/pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "GameSentenceMiner"
-version = "2.18.3"
+version = "2.18.5"
 description = "A tool for mining sentences from games. Update: Overlay?"
 readme = "README.md"
 requires-python = ">=3.10"