Upload 2 files

adapter_layer.py

@@ -6,12 +6,36 @@ import traceback
 from typing import Dict, Any, Optional, List
 import importlib.util
 
+# Import dependency helpers
+try:
+    from dependency_helpers import safely_import, is_module_available, with_fallback
+except ImportError:
+    # Inline implementation if module isn't available
+    def safely_import(module_name):
+        try:
+            return importlib.import_module(module_name)
+        except ImportError:
+            return None
+    
+    def is_module_available(module_name):
+        try:
+            importlib.util.find_spec(module_name)
+            return True
+        except ImportError:
+            return False
+    
+    def with_fallback(primary_func, fallback_func, *args, **kwargs):
+        try:
+            return primary_func(*args, **kwargs)
+        except Exception:
+            return fallback_func(*args, **kwargs)
+
 logger = logging.getLogger(__name__)
 
 class WildnerveModelAdapter:
     """
     Adapter layer that interfaces between HF inference endpoints and the model.
-    Uses full tokenizer implementation with multiple fallbacks.
+    Compatible with the original architecture while providing robust fallbacks.
     """
     
     def __init__(self, model_path: str):
@@ -26,62 +50,95 @@ class WildnerveModelAdapter:
             
         logger.info(f"Model adapter initialized with path: {model_path}")
         
-        # Initialize tokenizer using the proper TokenizerWrapper
+        # Initialize tokenizer - try to use the original TokenizerWrapper
         self._initialize_tokenizer()
     
     def _initialize_tokenizer(self):
-        """Initialize tokenizer with multiple fallbacks"""
-        # Try to use the full TokenizerWrapper from tokenizer.py
+        """Initialize tokenizer while respecting the original architecture"""
+        # First try loading config - use original implementation if available
         try:
-            # First check if TokenizerWrapper is already available
-            tokenizer_spec = importlib.util.find_spec('tokenizer')
-            if (tokenizer_spec):
-                logger.info("Found tokenizer.py module, importing TokenizerWrapper")
-                from tokenizer import TokenizerWrapper, get_tokenizer
+            # Check if we have a config module
+            has_config = is_module_available('config')
+            
+            # Try to import from service_registry if available
+            has_registry = is_module_available('service_registry')
+            
+            # Use the appropriate approach based on available modules
+            if has_registry:
+                # Use original registry approach
+                from service_registry import registry, TOKENIZER
                 
-                # Try using the get_tokenizer function
-                self.tokenizer = get_tokenizer()
-                if self.tokenizer:
-                    logger.info("Successfully initialized TokenizerWrapper")
+                if registry.has(TOKENIZER):
+                    self.tokenizer = registry.get(TOKENIZER)
+                    logger.info("Retrieved tokenizer from registry")
                     return
             
-            # Next try to import it from our model path
-            tokenizer_path = os.path.join(self.model_path, "tokenizer.py")
-            if os.path.exists(tokenizer_path):
-                spec = importlib.util.spec_from_file_location("tokenizer_module", tokenizer_path)
-                tokenizer_module = importlib.util.module_from_spec(spec)
-                spec.loader.exec_module(tokenizer_module)
+            # Try loading from the original tokenizer.py
+            tokenizer_module = None
+            
+            # First check if it's directly importable
+            if is_module_available('tokenizer'):
+                tokenizer_module = safely_import('tokenizer')
+                logger.info("Imported tokenizer module from Python path")
                 
-                if hasattr(tokenizer_module, 'TokenizerWrapper'):
+            # Next try to load it from model_path
+            if tokenizer_module is None:
+                tokenizer_path = os.path.join(self.model_path, "tokenizer.py")
+                if os.path.exists(tokenizer_path):
+                    spec = importlib.util.spec_from_file_location("tokenizer_module", tokenizer_path)
+                    tokenizer_module = importlib.util.module_from_spec(spec)
+                    spec.loader.exec_module(tokenizer_module)
+                    logger.info("Loaded tokenizer module from model path")
+            
+            # Create tokenizer if module was loaded
+            if tokenizer_module is not None and hasattr(tokenizer_module, 'TokenizerWrapper'):
+                # Handle potential missing config_app
+                if hasattr(tokenizer_module, 'get_tokenizer'):
+                    self.tokenizer = tokenizer_module.get_tokenizer()
+                else:
+                    # Try direct instantiation
                     self.tokenizer = tokenizer_module.TokenizerWrapper()
-                    logger.info("Loaded TokenizerWrapper from tokenizer.py")
-                    return
+                
+                logger.info("Created TokenizerWrapper instance")
+                
+                # Register in registry if available
+                if has_registry:
+                    from service_registry import registry, TOKENIZER
+                    registry.register(TOKENIZER, self.tokenizer)
+                    
+                return
+                
         except Exception as e:
-            logger.warning(f"Failed to load TokenizerWrapper: {e}")
+            logger.warning(f"Error initializing original tokenizer: {e}")
         
-        # Try to load from transformers if available
+        # If we reach here, try the HuggingFace transformers approach
         try:
-            from transformers import AutoTokenizer, BertTokenizer
+            from transformers import AutoTokenizer
+            
+            models_to_try = [
+                "bert-base-uncased",  # Standard BERT model
+                "distilbert-base-uncased",  # Smaller, faster alternative
+                "gpt2"  # Another commonly available model
+            ]
             
-            # Try multiple model names, starting with our own
-            for model_name in ["Wildnerve-tlm01_Hybrid_Model", "bert-base-uncased", "gpt2"]:
+            for model_name in models_to_try:
                 try:
                     self.tokenizer = AutoTokenizer.from_pretrained(model_name)
-                    logger.info(f"Loaded {model_name} tokenizer via AutoTokenizer")
+                    logger.info(f"Using transformers AutoTokenizer with {model_name}")
+                    
+                    # Register if registry is available
+                    if 'registry' in locals() and 'TOKENIZER' in locals():
+                        registry.register(TOKENIZER, self.tokenizer)
+                        
                     return
                 except Exception as e:
-                    logger.warning(f"Failed to load {model_name} tokenizer: {e}")
+                    logger.warning(f"Failed to load {model_name}: {e}")
             
-            # Direct attempt with BertTokenizer
-            self.tokenizer = BertTokenizer.from_pretrained("bert-base-uncased")
-            logger.info("Loaded bert-base-uncased via BertTokenizer")
-            return
-                
-        except Exception as e:
-            logger.warning(f"Failed to load transformers tokenizers: {e}")
+        except ImportError:
+            logger.warning("transformers package not available")
         
-        # If all else fails, use our SimpleTokenizer
-        logger.warning("All tokenizer loading attempts failed, using SimpleTokenizer")
+        # Last resort: use our SimpleTokenizer implementation
+        logger.warning("Using SimpleTokenizer as final fallback")
         self.tokenizer = SimpleTokenizer()
     
     def load_fallback_model(self):
@@ -90,12 +147,63 @@ class WildnerveModelAdapter:
             return self.fallback_model
             
         try:
+            # First try to import original model if available
+            model_module = None
+            models_to_try = ["model_Combn", "model_Custm", "model_PrTr"]
+            
+            for model_name in models_to_try:
+                try:
+                    if is_module_available(model_name):
+                        model_module = safely_import(model_name)
+                        if model_module:
+                            logger.info(f"Imported {model_name} module")
+                            break
+                except Exception as e:
+                    logger.warning(f"Failed to import {model_name}: {e}")
+            
+            # If we found a valid model module, try to instantiate it
+            if model_module:
+                model_classes = [
+                    "Wildnerve_tlm01_Hybrid_Model", 
+                    "Wildnerve_tlm01"
+                ]
+                
+                for class_name in model_classes:
+                    if hasattr(model_module, class_name):
+                        try:
+                            # Try to instantiate with minimal parameters
+                            model_class = getattr(model_module, class_name)
+                            instance = model_class(
+                                vocab_size=30522,
+                                specialization="general",
+                                dataset_path=None,
+                                model_name="bert-base-uncased",
+                                embedding_dim=768,
+                                num_heads=12,
+                                hidden_dim=768,
+                                num_layers=6,
+                                output_size=768,
+                                dropout=0.1,
+                                max_seq_length=512,
+                                pooling_mode="mean",
+                                tokenizer=self.tokenizer
+                            )
+                            logger.info(f"Created {class_name} instance from {model_module.__name__}")
+                            self.fallback_model = instance
+                            return self.fallback_model
+                        except Exception as e:
+                            logger.warning(f"Failed to instantiate {class_name}: {e}")
+            
+            # If we couldn't use the original model, use our fallback
             self.fallback_model = SimpleFallbackModel(self.tokenizer)
-            logger.info("Created fallback model")
+            logger.info("Created SimpleFallbackModel")
             return self.fallback_model
+            
         except Exception as e:
-            logger.error(f"Failed to create fallback model: {e}")
-            return None
+            logger.error(f"Failed to create any fallback model: {e}")
+            # As an absolute last resort, create a minimal model on the fly
+            self.fallback_model = SimpleFallbackModel(self.tokenizer)
+            return self.fallback_model
     
     def generate(self, prompt: str, **kwargs) -> str:
         """Generate a response to the prompt"""
@@ -112,7 +220,38 @@ class WildnerveModelAdapter:
             # Try to use the fallback model if it exists or can be created
             model = self.load_fallback_model()
             if model is not None:
-                return model.generate(prompt, **kwargs)
+                # Try different generation methods the model might have
+                if hasattr(model, "generate_streaming"):
+                    try:
+                        # For streaming we need to collect all tokens
+                        tokens = []
+                        for token in model.generate_streaming(prompt, **kwargs):
+                            tokens.append(token)
+                        return "".join(tokens)
+                    except Exception as e:
+                        logger.warning(f"Streaming generation failed: {e}")
+                
+                # Try standard generate methods
+                gen_methods = ["generate_with_decoding", "generate"]
+                for method_name in gen_methods:
+                    if hasattr(model, method_name):
+                        try:
+                            # Tokenize the input if needed
+                            if hasattr(self.tokenizer, "__call__"):
+                                input_ids = self.tokenizer(prompt, return_tensors="pt").input_ids
+                                # Get the result
+                                method = getattr(model, method_name)
+                                result = method(input_ids, **kwargs)
+                                if isinstance(result, str) and result:
+                                    return result
+                        except Exception as e:
+                            logger.warning(f"{method_name} failed: {e}")
+                
+                # If we get here, try a final simple generate method
+                try:
+                    return model.generate(prompt, **kwargs)
+                except Exception as e:
+                    logger.warning(f"Direct generation failed: {e}")
                 
             # If fallback model failed, use a simple hardcoded response based on prompt
             logger.warning("Using hardcoded response as fallback")
@@ -153,7 +292,8 @@ Please try again later when these issues have been resolved."""
             return f"Error generating response: {str(e)}"
 
 
-# Fallback tokenizer implementation
+# Minimal implementations below - these are only used if absolutely necessary
+
 class SimpleTokenizer:
     """
     A minimal tokenizer implementation for fallback purposes.

dependency_helpers.py

@@ -0,0 +1,118 @@
+"""
+Helper utilities for handling dependencies in a graceful manner.
+This module provides functions to check for and load dependencies without crashing.
+"""
+import importlib
+import logging
+import sys
+import os
+from typing import Optional, Any, Dict, Callable, List
+
+logger = logging.getLogger(__name__)
+
+def safely_import(module_name: str) -> Optional[Any]:
+    """
+    Safely import a module without crashing if it's not available.
+    
+    Args:
+        module_name: Name of the module to import
+        
+    Returns:
+        The imported module or None if import failed
+    """
+    try:
+        return importlib.import_module(module_name)
+    except ImportError as e:
+        logger.warning(f"Failed to import {module_name}: {e}")
+        return None
+
+def is_module_available(module_name: str) -> bool:
+    """
+    Check if a module is available without importing it.
+    
+    Args:
+        module_name: Name of the module to check
+        
+    Returns:
+        True if module is available, False otherwise
+    """
+    try:
+        importlib.util.find_spec(module_name)
+        return True
+    except ImportError:
+        return False
+
+def check_dependencies(dependencies: List[str]) -> Dict[str, bool]:
+    """
+    Check multiple dependencies at once.
+    
+    Args:
+        dependencies: List of module names to check
+        
+    Returns:
+        Dictionary mapping module names to availability (True/False)
+    """
+    return {dep: is_module_available(dep) for dep in dependencies}
+
+def get_object_if_available(module_name: str, object_name: str) -> Optional[Any]:
+    """
+    Get an object from a module if the module is available.
+    
+    Args:
+        module_name: Name of the module containing the object
+        object_name: Name of the object to get
+        
+    Returns:
+        The requested object or None if not available
+    """
+    module = safely_import(module_name)
+    if module and hasattr(module, object_name):
+        return getattr(module, object_name)
+    return None
+
+def with_fallback(primary_func: Callable, fallback_func: Callable, *args, **kwargs) -> Any:
+    """
+    Call primary_func with the given args/kwargs, falling back to fallback_func if it fails.
+    
+    Args:
+        primary_func: Function to try first
+        fallback_func: Function to use if primary_func fails
+        args: Positional arguments to pass to both functions
+        kwargs: Keyword arguments to pass to both functions
+        
+    Returns:
+        Result from either primary_func or fallback_func
+    """
+    try:
+        return primary_func(*args, **kwargs)
+    except Exception as e:
+        logger.warning(f"Primary function {primary_func.__name__} failed: {e}")
+        return fallback_func(*args, **kwargs)
+
+def install_package(package_name: str) -> bool:
+    """
+    Attempt to install a package using pip.
+    Note: This is generally not recommended in production code but can be useful for development.
+    
+    Args:
+        package_name: Name of the package to install
+        
+    Returns:
+        True if installation was successful, False otherwise
+    """
+    try:
+        import subprocess
+        logger.info(f"Attempting to install {package_name}")
+        subprocess.check_call([sys.executable, "-m", "pip", "install", package_name])
+        return True
+    except Exception as e:
+        logger.warning(f"Failed to install {package_name}: {e}")
+        return False
+
+# Check critical dependencies used in the project
+CRITICAL_DEPENDENCIES = ["torch", "transformers", "sentencepiece", "pydantic", "nltk"]
+DEPENDENCY_STATUS = check_dependencies(CRITICAL_DEPENDENCIES)
+
+def get_dependency_status() -> Dict[str, bool]:
+    """Get the status of critical dependencies."""
+    return DEPENDENCY_STATUS