linux fixes

models.py

@@ -0,0 +1,98 @@
+"""
+Models Module
+
+Provides model registry and interfaces for the trading system.
+This module acts as a bridge between the core system and the NN models.
+"""
+
+import logging
+from typing import Dict, Any, Optional, List
+from NN.models.model_interfaces import ModelInterface, CNNModelInterface, RLAgentInterface, ExtremaTrainerInterface
+
+logger = logging.getLogger(__name__)
+
+class ModelRegistry:
+    """Registry for managing trading models"""
+    
+    def __init__(self):
+        self.models: Dict[str, ModelInterface] = {}
+        self.model_performance: Dict[str, Dict[str, Any]] = {}
+    
+    def register_model(self, name: str, model: ModelInterface):
+        """Register a model in the registry"""
+        self.models[name] = model
+        self.model_performance[name] = {
+            'correct': 0,
+            'total': 0,
+            'accuracy': 0.0,
+            'last_used': None
+        }
+        logger.info(f"Registered model: {name}")
+    
+    def get_model(self, name: str) -> Optional[ModelInterface]:
+        """Get a model by name"""
+        return self.models.get(name)
+    
+    def get_all_models(self) -> Dict[str, ModelInterface]:
+        """Get all registered models"""
+        return self.models.copy()
+    
+    def update_performance(self, name: str, correct: bool):
+        """Update model performance metrics"""
+        if name in self.model_performance:
+            self.model_performance[name]['total'] += 1
+            if correct:
+                self.model_performance[name]['correct'] += 1
+            self.model_performance[name]['accuracy'] = (
+                self.model_performance[name]['correct'] / 
+                self.model_performance[name]['total']
+            )
+    
+    def get_best_model(self, model_type: str = None) -> Optional[str]:
+        """Get the best performing model"""
+        if not self.model_performance:
+            return None
+        
+        best_model = None
+        best_accuracy = -1.0
+        
+        for name, perf in self.model_performance.items():
+            if model_type and not name.lower().startswith(model_type.lower()):
+                continue
+            if perf['accuracy'] > best_accuracy:
+                best_accuracy = perf['accuracy']
+                best_model = name
+        
+        return best_model
+
+# Global model registry instance
+_model_registry = ModelRegistry()
+
+def get_model_registry() -> ModelRegistry:
+    """Get the global model registry instance"""
+    return _model_registry
+
+def register_model(name: str, model: ModelInterface):
+    """Register a model in the global registry"""
+    _model_registry.register_model(name, model)
+
+def get_model(name: str) -> Optional[ModelInterface]:
+    """Get a model from the global registry"""
+    return _model_registry.get_model(name)
+
+def get_all_models() -> Dict[str, ModelInterface]:
+    """Get all models from the global registry"""
+    return _model_registry.get_all_models()
+
+# Export the interfaces
+__all__ = [
+    'ModelRegistry',
+    'get_model_registry',
+    'register_model',
+    'get_model',
+    'get_all_models',
+    'ModelInterface',
+    'CNNModelInterface',
+    'RLAgentInterface',
+    'ExtremaTrainerInterface'
+]