Upload 6 files

adapter_layer.py

@@ -8,7 +8,6 @@ import logging
 import pydantic              # required
 import codecarbon    
 import importlib.util        # required
-from model_List import PromptAnalyzer
 from typing import Dict, Any, Optional, List, Tuple
 from service_registry import registry, MODEL, PRETRAINED_MODEL, TOKENIZER
 
@@ -27,6 +26,29 @@ def is_module_available(module_name):
     except ImportError:
         return False
 
+# More robust import for PromptAnalyzer
+try:
+    from model_List import PromptAnalyzer
+    logger.info("Successfully imported PromptAnalyzer")
+except ImportError as e:
+    logger.error(f"Error importing PromptAnalyzer: {e}")
+    # Create a minimal PromptAnalyzer class
+    class PromptAnalyzer:
+        def __init__(self, **kwargs):
+            self.logger = logging.getLogger(__name__)
+            self.predefined_topics = {
+                "programming": ["python", "java", "code"],
+                "general": ["weather", "hello", "chat"]
+            }
+        
+        def analyze_prompt(self, prompt: str):
+            # Simple keyword-based routing
+            prompt_lower = prompt.lower()
+            for tech_word in self.predefined_topics.get("programming", []):
+                if tech_word in prompt_lower:
+                    return "model_Custm", 0.8
+            return "model_PrTr", 0.6
+
 class WildnerveModelAdapter:
     """Adapter layer that interfaces between HF inference endpoints and the model."""
     RETRY_COUNT = 5

config.py

@@ -6,7 +6,7 @@ import argparse
 import pydantic                 # prefer real import in main block
 import dependency_helpers       # keep helper import early
 from pathlib import Path
-from typing import Optional, Dict, List, Literal, Any
+from typing import Optional, Dict, List, Literal, Any, Union
 
 # flag indicating real pydantic is present
 pydantic_available = True
@@ -351,7 +351,22 @@ class STDPConfig(BaseModel):
         extra="allow"
     )
 
+class SerializableDict(dict):
+    """Dictionary subclass with attribute-style access that can be serialized safely"""
+    def __getattr__(self, key):
+        if key in self:
+            return self[key]
+        return None
+        
+    def __setattr__(self, key, value):
+        self[key] = value
+    
+    def __delattr__(self, key):
+        if key in self:
+            del self[key]
+
 class AppConfig(BaseModel):
+    """Main application configuration with proper serialization handling"""
     # which model files to load by default
     SELECTED_MODEL: List[str] = Field(
         default=["model_Custm.py", "model_PrTr.py"],
@@ -387,31 +402,47 @@ class AppConfig(BaseModel):
     TOP_K: int = Field(default=3)
     MAX_ACTIVE_MODELS: int = Field(default=2)
     MODEL_IDLE_THRESHOLD: int = Field(default=600)
+    
+    # Add a new Pydantic model_config to fix serialization issues
+    model_config = ConfigDict(
+        extra="allow",  # Allow extra fields not in the model
+        arbitrary_types_allowed=True,  # Allow arbitrary types
+        populate_by_name=True, # Allow population by field name
+        json_encoders={
+            # Add custom encoders for non-serializable types
+            SerializableDict: lambda v: {k: v[k] for k in v if not k.startswith("_")}
+        },
+        validate_assignment=False  # Don't validate on attribute assignment
+    )
 
-class AttrDict(dict):
-    """Dictionary subclass with attribute-style access"""
-    __getattr__ = dict.get
-    __setattr__ = dict.__setitem__
-    __delattr__ = dict.__delitem__
-
-def load_config() -> AppConfig:
+def load_config() -> Union[AppConfig, Dict[str, Any]]:
+    """Load configuration from JSON file with robust error handling"""
     config_path = os.path.join(os.path.dirname(__file__), "config.json")
     logger.info(f"Loading config from {config_path}")
+    raw_config = {}
+    
     try:
         with open(config_path, "r") as f:
-            raw = json.load(f)
+            try:
+                raw = json.load(f)
+                raw_config = raw  # Save raw config in case Pydantic validation fails
+            except json.JSONDecodeError as e:
+                logger.error(f"JSON parsing error in config.json: {e}")
+                logger.error(f"Error at line {e.lineno}, column {e.colno}: {e.msg}")
+                raise
 
-            # Fix 1: Create AttrDict with config_data attribute first
+            # Process the TRANSFORMER_CONFIG section
             if isinstance(raw.get("TRANSFORMER_CONFIG"), dict):
-                transformer_config = AttrDict(raw["TRANSFORMER_CONFIG"])
+                # Convert to SerializableDict instead of AttrDict
+                transformer_config = SerializableDict(raw["TRANSFORMER_CONFIG"])
                 
-                # Crucial fix: Set config_data immediately and explicitly
-                transformer_config.config_data = transformer_config
+                # Crucial fix: Add config_data property that doesn't break serialization
+                transformer_config["config_data"] = transformer_config
                 
-                # Replace the dict with our enhanced AttrDict
+                # Replace the dict with our enhanced SerializableDict
                 raw["TRANSFORMER_CONFIG"] = transformer_config
                 
-                # Ensure GPT-2 parameters - these come AFTER setting config_data
+                # Ensure GPT-2 parameters are set
                 if not isinstance(transformer_config.get("VOCAB_SIZE"), int) or transformer_config["VOCAB_SIZE"] != 50257:
                     transformer_config["VOCAB_SIZE"] = 50257  # Standard GPT-2 vocab size
                     
@@ -436,19 +467,28 @@ def load_config() -> AppConfig:
         logger.error(f"Failed to read config.json: {e}", exc_info=True)
         raise
 
-    try:
-        cfg = AppConfig(**raw)
-        logger.debug(f"Config loaded: {cfg.json()}")
-    except ValidationError as ve:
-        logger.error(f"Config validation error: {ve}", exc_info=True)
-        raise
-
-    return cfg
+    # Try to create AppConfig with pydantic validation
+    if pydantic_available:
+        try:
+            cfg = AppConfig(**raw)
+            
+            # DON'T try to serialize the entire config - this was causing our issue
+            # Just log that config loaded successfully
+            logger.debug("Config loaded successfully")
+            return cfg
+        except ValidationError as ve:
+            logger.error(f"Config validation error: {ve}", exc_info=True)
+            
+            # Fall back to returning the raw config as a dict
+            logger.warning("Using raw config dictionary due to validation failure")
+            return raw_config
+    else:
+        # If pydantic not available, just return the raw dict
+        return raw_config
 
 # Global application config
 app_config = load_config()
 
 if __name__ == "__main__":
     args = argparse.ArgumentParser(description="Tiny Language Model Configuration").parse_args()
-    print("Configuration loaded:")
-    print(app_config)
+    print("Configuration loaded successfully!")

handler.py

@@ -2,26 +2,44 @@
 import os
 import sys
 import time
-import torch  # Add missing torch import!
+import torch
 import logging
 import traceback
 from typing import Dict, Any, List
 import importlib.util
 
-# Add this near the top (after imports)
-from service_registry import ensure_models_registered
-ensure_models_registered()
-
-# --- DEBUG: confirm correct handler.py is loaded ---
-print("DEBUG: using Wildnerve-tlm_HF/handler.py — v4 with dependencies in place")
-
-# Set up logging
+# Configure logging first
 logging.basicConfig(
     level=logging.INFO,
     format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
 )
 logger = logging.getLogger(__name__)
 
+# --- DEBUG: confirm correct handler.py is loaded ---
+print("DEBUG: using Wildnerve-tlm_HF/handler.py — v5 with robust config handling")
+
+# Safe config import that won't fail during initialization
+try:
+    from config import app_config
+    logger.info("Successfully imported config")
+except Exception as e:
+    logger.error(f"Error importing config: {e}")
+    # Create minimal config to avoid further errors
+    app_config = {
+        "MODEL_NAME": "Wildnerve-tlm01_Hybrid_Model",
+        "TRANSFORMER_CONFIG": {
+            "MODEL_NAME": "gpt2",
+            "VOCAB_SIZE": 50257
+        }
+    }
+
+# Add this near the top (after imports)
+try:
+    from service_registry import ensure_models_registered
+    ensure_models_registered()
+except Exception as e:
+    logger.error(f"Error ensuring models are registered: {e}")
+
 # Safely check for required packages without crashing
 try:
     import pydantic
@@ -92,7 +110,26 @@ class EndpointHandler:
         if model_dir:
             logger.info(f"Handler init with path: {model_dir}")
         try:
-            # supply model_dir as the adapter’s model_path
+            # Try to import adapter layer
+            try:
+                # For more reliable importing
+                script_dir = os.path.dirname(os.path.abspath(__file__))
+                sys.path.insert(0, script_dir)
+                
+                from adapter_layer import WildnerveModelAdapter
+                logger.info("Successfully imported adapter_layer module")
+            except ImportError as e:
+                logger.error(f"Could not import adapter_layer: {e}")
+                # Create a minimal placeholder adapter class
+                class WildnerveModelAdapter:
+                    def __init__(self, model_path: str =""):
+                        self.model_path = model_path
+                        logger.info(f"Using fallback WildnerveModelAdapter with path: {model_path}")
+                        
+                    def generate(self, text_input, **kwargs):
+                        return f"Model adapter unavailable. Received input: {text_input[:30]}..."
+
+            # supply model_dir as the adapter's model_path
             self.adapter = WildnerveModelAdapter(model_dir or "")
         except Exception as e:
             logger.error(f"Adapter init failed: {e}", exc_info=True)

model_List.py

@@ -17,7 +17,23 @@ try:
 except LookupError:
     nltk.download("punkt")
 from service_registry import registry, TOKENIZER, MODEL
-from config import app_config
+
+# More robust config import
+try:
+    from config import app_config
+except ImportError:
+    logger.error("Failed to import app_config from config")
+    # Create minimal app_config
+    app_config = {
+        "PROMPT_ANALYZER_CONFIG": {
+            "MODEL_NAME": "gpt2",
+            "DATASET_PATH": None,
+            "SPECIALIZATION": None,
+            "HIDDEN_DIM": 768,
+            "MAX_CACHE_SIZE": 10
+        }
+    }
+
 # Add SmartHybridAttention imports
 from utils.smartHybridAttention import SmartHybridAttention, get_hybrid_attention_config
 
@@ -35,14 +51,35 @@ class PromptAnalyzer:
     def __init__(self, model_name=None, dataset_path=None, specialization=None, hidden_dim=None):
         self.logger = logging.getLogger(__name__)
         
-        # Load config
-        self.config = load_config(config_file="config.json")
+        # Load config with better error handling
+        try:
+            if hasattr(app_config, "PROMPT_ANALYZER_CONFIG"):
+                self.config_data = app_config.PROMPT_ANALYZER_CONFIG
+            elif isinstance(app_config, dict) and "PROMPT_ANALYZER_CONFIG" in app_config:
+                self.config_data = app_config["PROMPT_ANALYZER_CONFIG"]
+            else:
+                self.config_data = {
+                    "MODEL_NAME": "gpt2",
+                    "DATASET_PATH": None,
+                    "SPECIALIZATION": None,
+                    "HIDDEN_DIM": 768,
+                    "MAX_CACHE_SIZE": 10
+                }
+        except Exception as e:
+            self.logger.warning(f"Error loading config: {e}, using defaults")
+            self.config_data = {
+                "MODEL_NAME": "gpt2",
+                "DATASET_PATH": None,
+                "SPECIALIZATION": None,
+                "HIDDEN_DIM": 768,
+                "MAX_CACHE_SIZE": 10
+            }
         
-        # Use provided values or config values
-        self.model_name = model_name or self.config.PROMPT_ANALYZER_CONFIG.MODEL_NAME
-        self.dataset_path = dataset_path or self.config.PROMPT_ANALYZER_CONFIG.DATASET_PATH
-        self.specialization = specialization or self.config.PROMPT_ANALYZER_CONFIG.SPECIALIZATION
-        self.hidden_dim = hidden_dim or self.config.PROMPT_ANALYZER_CONFIG.HIDDEN_DIM
+        # Use provided values or config values with safe getters
+        self.model_name = model_name or self._safe_get("MODEL_NAME", "gpt2")
+        self.dataset_path = dataset_path or self._safe_get("DATASET_PATH")
+        self.specialization = specialization or self._safe_get("SPECIALIZATION")
+        self.hidden_dim = hidden_dim or self._safe_get("HIDDEN_DIM", 768)
         
         self.logger.info(f"Initialized PromptAnalyzer with {self.model_name}")
         self._model_cache: Dict[str, Type] = {}
@@ -91,6 +128,17 @@ class PromptAnalyzer:
         except Exception:
             pass
         
+    def _safe_get(self, key, default=None):
+        """Safely get a configuration value regardless of config type"""
+        try:
+            if isinstance(self.config_data, dict):
+                return self.config_data.get(key, default)
+            elif hasattr(self.config_data, key):
+                return getattr(self.config_data, key, default)
+            return default
+        except:
+            return default
+
     def _load_predefined_topics(self):
         """Load topic keywords from config file or use defaults with caching"""
         # Try to load from config first