Upload 3 files

adapter_layer.py

@@ -193,6 +193,12 @@ class WildnerveModelAdapter:
         # All attempts failed
         raise ImportError("No model registered in service registry")
 
+        # When storing models/objects, make sure we don't create circular references
+        if registry.has(MODEL):
+            self.model = registry.get(MODEL)
+            # Don't add back-references to registry or other objects that might 
+            # include this adapter, to avoid circular references
+
     def _build_init_kwargs(self):
         return {
             "vocab_size": 30522,

config.py

@@ -364,6 +364,24 @@ class SerializableDict(dict):
     def __delattr__(self, key):
         if key in self:
             del self[key]
+            
+    # Add special methods to handle JSON serialization
+    def __getstate__(self):
+        """Return state for pickling - exclude config_data if it's self"""
+        state = dict(self)
+        if 'config_data' in state and id(state['config_data']) == id(self):
+            state['config_data'] = '__self__'  # Replace self-reference with marker
+        return state
+    
+    def __repr__(self):
+        """Safe representation that handles circular references"""
+        items = []
+        for k, v in self.items():
+            if k == "config_data" and v is self:
+                items.append(f"{k}=<self>")
+            else:
+                items.append(f"{k}={v!r}")
+        return f"{self.__class__.__name__}({', '.join(items)})"
 
 class AppConfig(BaseModel):
     """Main application configuration with proper serialization handling"""
@@ -433,11 +451,16 @@ def load_config() -> Union[AppConfig, Dict[str, Any]]:
 
             # Process the TRANSFORMER_CONFIG section
             if isinstance(raw.get("TRANSFORMER_CONFIG"), dict):
-                # Convert to SerializableDict instead of AttrDict
+                # Create SerializableDict with safe self-reference handling
                 transformer_config = SerializableDict(raw["TRANSFORMER_CONFIG"])
                 
-                # Crucial fix: Add config_data property that doesn't break serialization
-                transformer_config["config_data"] = transformer_config
+                # Store reference to self using a descriptor instead of direct reference
+                class ConfigDataDescriptor:
+                    def __get__(self, obj, objtype=None):
+                        return obj
+                
+                # Add descriptor to class
+                type(transformer_config).config_data = ConfigDataDescriptor()
                 
                 # Replace the dict with our enhanced SerializableDict
                 raw["TRANSFORMER_CONFIG"] = transformer_config
@@ -472,10 +495,10 @@ def load_config() -> Union[AppConfig, Dict[str, Any]]:
         try:
             cfg = AppConfig(**raw)
             
-            # DON'T try to serialize the entire config - this was causing our issue
-            # Just log that config loaded successfully
+            # Just log success message
             logger.debug("Config loaded successfully")
             return cfg
+            
         except ValidationError as ve:
             logger.error(f"Config validation error: {ve}", exc_info=True)
             

model_List.py

@@ -238,7 +238,12 @@ class PromptAnalyzer:
             self.attention = None
 
     def _track_model_performance(self, model_type: str, start_time: float) -> None:
-        """Track model loading and performance metrics"""
+        """Track model loading and performance metrics.
+        
+        Args:
+            model_type: Type of model being tracked
+            start_time: Start time of operation
+        """
         end_time = time.time()
         if model_type not in self._performance_metrics:
             self._performance_metrics[model_type] = {
@@ -247,6 +252,7 @@ class PromptAnalyzer:
                 'avg_response_time': 0.0
             }
         
+        # Ensure we're not creating circular references that might impact serialization
         metrics = self._performance_metrics[model_type]
         metrics['load_time'] = end_time - start_time
         metrics['usage_count'] += 1