feat: Initial commit of Clutch-IQ project

database/L2/processors/round_processor.py

@@ -0,0 +1,97 @@
+"""
+Round Processor - Dispatches round data processing based on data_source_type
+
+Responsibilities:
+- Act as the unified entry point for round data processing
+- Determine data source type (leetify vs classic)
+- Dispatch to appropriate specialized processors
+- Coordinate economy, event, and spatial processors
+"""
+
+import sqlite3
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class RoundProcessor:
+    @staticmethod
+    def process(match_data, conn: sqlite3.Connection) -> bool:
+        """
+        Process round data by dispatching to specialized processors
+        
+        Args:
+            match_data: MatchData object containing parsed JSON
+            conn: L2 database connection
+            
+        Returns:
+            bool: True if successful
+        """
+        try:
+            # Import specialized processors
+            from . import economy_processor
+            from . import event_processor
+            from . import spatial_processor
+            
+            if match_data.data_source_type == 'leetify':
+                logger.debug(f"Processing leetify data for match {match_data.match_id}")
+                # Process leetify rounds
+                success = economy_processor.EconomyProcessor.process_leetify(match_data, conn)
+                if not success:
+                    logger.warning(f"Failed to process leetify economy for match {match_data.match_id}")
+                
+                # Process leetify events
+                success = event_processor.EventProcessor.process_leetify_events(match_data, conn)
+                if not success:
+                    logger.warning(f"Failed to process leetify events for match {match_data.match_id}")
+                    
+            elif match_data.data_source_type == 'classic':
+                logger.debug(f"Processing classic data for match {match_data.match_id}")
+                # Process classic rounds (basic round info)
+                success = _process_classic_rounds(match_data, conn)
+                if not success:
+                    logger.warning(f"Failed to process classic rounds for match {match_data.match_id}")
+                
+                # Process classic economy (NEW)
+                success = economy_processor.EconomyProcessor.process_classic(match_data, conn)
+                if not success:
+                    logger.warning(f"Failed to process classic economy for match {match_data.match_id}")
+                
+                # Process classic events (kills, bombs)
+                success = event_processor.EventProcessor.process_classic_events(match_data, conn)
+                if not success:
+                    logger.warning(f"Failed to process classic events for match {match_data.match_id}")
+                
+                # Process spatial data (xyz coordinates)
+                success = spatial_processor.SpatialProcessor.process(match_data, conn)
+                if not success:
+                    logger.warning(f"Failed to process spatial data for match {match_data.match_id}")
+                    
+            else:
+                logger.info(f"No round data to process for match {match_data.match_id} (data_source_type={match_data.data_source_type})")
+            
+            return True
+            
+        except Exception as e:
+            logger.error(f"Error in round processor for match {match_data.match_id}: {e}")
+            import traceback
+            traceback.print_exc()
+            return False
+
+
+def _process_classic_rounds(match_data, conn: sqlite3.Connection) -> bool:
+    """
+    Process basic round information for classic data source
+    
+    Classic round data contains:
+    - current_score (ct/t scores, type, pasttime, final_round_time)
+    - But lacks economy data
+    """
+    try:
+        # This is handled by event_processor for classic
+        # Classic rounds are extracted from round_list structure
+        # which is processed in event_processor.process_classic_events
+        return True
+    except Exception as e:
+        logger.error(f"Error processing classic rounds: {e}")
+        return False