mindroot 9.3.0__py3-none-any.whl → 9.6.0__py3-none-any.whl

mindroot/coreplugins/jwt_auth/mod.py

@@ -1,6 +1,6 @@
 from lib.providers.hooks import hook
 from lib.route_decorators import public_route, public_routes
-from starlette.routing import Mount
+from starlette.routing import Mount, Route
 import json
 print("---  Hello from JWT mod ---")
 
@@ -8,19 +8,42 @@ print("---  Hello from JWT mod ---")
 async def startup(app, context):
     print('Running startup hook')
     print('Registering public routes:')
-    for route in app.routes: 
-        print(route)
-        if isinstance(route, Mount):
-            for sub_route in route.routes:
-                if hasattr(sub_route, 'endpoint') and hasattr(sub_route.endpoint, '__public_route__'):
-                    print(f"Found public route: {route.path}{sub_route.path}")
-                    public_routes.add(f"{route.path}{sub_route.path}")
-                else:
-                    print(f"Skipping private route: {route.path}{sub_route}")
-        elif hasattr(route, 'endpoint') and hasattr(route.endpoint, '__public_route__'):
-            print(f"Found public route: {route.path}")
-            public_routes.add(route.path)
-        else:
-            print(f"Skipping private route: {route}")
-
-
+    
+    def register_route(route_path, route_obj):
+        """Helper function to register a route if it's marked as public"""
+        if hasattr(route_obj, 'endpoint') and hasattr(route_obj.endpoint, '__public_route__'):
+            print(f"Found public route: {route_path}")
+            public_routes.add(route_path)
+            return True
+        return False
+    
+    def process_routes(routes, path_prefix=""):
+        """Recursively process routes and sub-routes"""
+        for route in routes:
+            if isinstance(route, Mount):
+                # Handle mounted sub-applications
+                mount_path = path_prefix + route.path.rstrip('/')
+                print(f"Processing mount: {mount_path}")
+                
+                # Process sub-routes within the mount
+                if hasattr(route, 'routes'):
+                    for sub_route in route.routes:
+                        if isinstance(sub_route, Route):
+                            full_path = mount_path + sub_route.path
+                            if not register_route(full_path, sub_route):
+                                print(f"Skipping private route: {full_path}")
+                        else:
+                            print(f"Skipping non-route in mount: {sub_route}")
+                            
+            elif isinstance(route, Route):
+                # Handle direct routes
+                full_path = path_prefix + route.path
+                if not register_route(full_path, route):
+                    print(f"Skipping private route: {full_path}")
+            else:
+                print(f"Skipping unknown route type: {route}")
+    
+    # Process all routes
+    process_routes(app.routes)
+    
+    print(f"Final public routes registered: {public_routes}")

mindroot/coreplugins/l8n/__init__.py

@@ -0,0 +1,6 @@
+# Import all commands and services from mod.py
+
+from .mod import *
+from .middleware import middleware
+
+

mindroot/coreplugins/l8n/debug_loader.py

@@ -0,0 +1,85 @@
+#!/usr/bin/env python3
+"""
+Debug script to simulate the plugin loader behavior.
+"""
+
+import sys
+import os
+import importlib
+from pathlib import Path
+
+# Add the mindroot path
+sys.path.insert(0, '/files/mindroot/src/mindroot')
+
+try:
+    print("Simulating plugin loader behavior...")
+    
+    # Simulate what the loader does
+    plugin_name = 'l8n'
+    category = 'core'
+    
+    # Get plugin path (simulating get_plugin_path)
+    plugin_dir = '/files/mindroot/src/mindroot/coreplugins/l8n'
+    print(f"Plugin directory: {plugin_dir}")
+    
+    # Check for middleware.py
+    middleware_path = os.path.join(plugin_dir, 'middleware.py')
+    print(f"Middleware path: {middleware_path}")
+    print(f"Middleware exists: {os.path.exists(middleware_path)}")
+    
+    if os.path.exists(middleware_path):
+        # Simulate get_plugin_import_path
+        plugin_import_path = f'coreplugins.{plugin_name}'
+        print(f"Plugin import path: {plugin_import_path}")
+        
+        # Try to import the module (this is what the loader does)
+        print("\nAttempting to import module...")
+        try:
+            module = importlib.import_module(plugin_import_path)
+            print(f"✅ Module imported: {module}")
+        except ImportError as e:
+            print(f"First import failed: {e}")
+            try:
+                module = importlib.import_module(f"{plugin_import_path}.mod")
+                print(f"✅ Module imported via .mod: {module}")
+            except ImportError as e2:
+                print(f"❌ Both imports failed: {e2}")
+                raise
+        
+        # Check if module has middleware
+        print(f"\nModule has middleware: {hasattr(module, 'middleware')}")
+        
+        if hasattr(module, 'middleware'):
+            middleware_func = module.middleware
+            print(f"Middleware type: {type(middleware_func)}")
+            print(f"Middleware callable: {callable(middleware_func)}")
+            
+            # This is what causes the error - let's check what we're actually getting
+            print(f"Middleware repr: {repr(middleware_func)}")
+            
+            # Check if it's actually a function
+            import inspect
+            print(f"Is function: {inspect.isfunction(middleware_func)}")
+            print(f"Is coroutine function: {inspect.iscoroutinefunction(middleware_func)}")
+            
+            if inspect.isfunction(middleware_func):
+                print(f"Function signature: {inspect.signature(middleware_func)}")
+            
+            # Try to simulate what FastAPI does
+            print("\nSimulating FastAPI middleware registration...")
+            try:
+                # This is essentially what BaseHTTPMiddleware does
+                if callable(middleware_func):
+                    print("✅ Middleware function is callable")
+                else:
+                    print("❌ Middleware function is not callable")
+            except Exception as e:
+                print(f"❌ Error checking callable: {e}")
+        else:
+            print("❌ Module does not have middleware attribute")
+            print(f"Module attributes: {dir(module)}")
+    
+except Exception as e:
+    print(f"❌ Error during simulation: {e}")
+    import traceback
+    traceback.print_exc()

mindroot/coreplugins/l8n/debug_middleware.py

@@ -0,0 +1,74 @@
+#!/usr/bin/env python3
+"""
+Debug script to test middleware import and functionality.
+"""
+
+import sys
+from pathlib import Path
+
+# Add the mindroot path
+sys.path.insert(0, '/files/mindroot/src/mindroot')
+
+try:
+    print("Testing middleware import...")
+    import coreplugins.l8n.middleware as mw
+    print(f"✅ Middleware imported successfully")
+    print(f"✅ Has middleware function: {hasattr(mw, 'middleware')}")
+    print(f"✅ Middleware type: {type(mw.middleware)}")
+    
+    # Test if the function is callable
+    import inspect
+    print(f"✅ Function signature: {inspect.signature(mw.middleware)}")
+    print(f"✅ Is coroutine function: {inspect.iscoroutinefunction(mw.middleware)}")
+    
+    # Test basic functionality
+    print("\nTesting basic middleware functionality...")
+    
+    # Mock request and call_next
+    class MockRequest:
+        def __init__(self):
+            self.url = type('obj', (object,), {'path': '/test'})
+            self.query_params = {}
+            self.cookies = {}
+            self.headers = {}
+            self.state = type('obj', (object,), {})
+    
+    class MockResponse:
+        def __init__(self):
+            self.cookies_set = {}
+        def set_cookie(self, **kwargs):
+            self.cookies_set.update(kwargs)
+    
+    async def mock_call_next(request):
+        return MockResponse()
+    
+    # Test the middleware
+    import asyncio
+    
+    async def test_middleware():
+        request = MockRequest()
+        try:
+            response = await mw.middleware(request, mock_call_next)
+            print(f"✅ Middleware executed successfully")
+            print(f"✅ Request language set: {hasattr(request.state, 'language')}")
+            if hasattr(request.state, 'language'):
+                print(f"✅ Language: {request.state.language}")
+            return True
+        except Exception as e:
+            print(f"❌ Middleware execution failed: {e}")
+            import traceback
+            traceback.print_exc()
+            return False
+    
+    # Run the test
+    result = asyncio.run(test_middleware())
+    
+    if result:
+        print("\n🎉 All middleware tests passed!")
+    else:
+        print("\n💥 Middleware tests failed!")
+        
+except Exception as e:
+    print(f"❌ Error during testing: {e}")
+    import traceback
+    traceback.print_exc()

mindroot/coreplugins/l8n/l8n_constants.py

@@ -0,0 +1,19 @@
+from pathlib import Path
+import os
+
+L8N_AVAILABLE = True
+
+# Base directory for l8n plugin
+L8N_DIR = Path(os.environ.get('MR_SOURCE_DIR', '/files/mindroot/src/mindroot/coreplugins/l8n'))
+
+# Base directory for localized files
+LOCALIZED_FILES_DIR = L8N_DIR / "localized_files"
+
+# Base directory for translations
+TRANSLATIONS_DIR = L8N_DIR / "translations"
+
+# Global cache for translations
+# Structure: {plugin_path: {language: {key: translation}}}
+TRANSLATIONS = {}
+
+

mindroot/coreplugins/l8n/language_detection.py

@@ -0,0 +1,183 @@
+import os
+from typing import Optional
+
+def get_current_language_from_request() -> str:
+    """
+    Get the current language from various request sources.
+    
+    This function checks multiple sources in order of priority:
+    1. Environment variable MINDROOT_LANGUAGE
+    2. FastAPI request context (if available)
+    3. HTTP Accept-Language header
+    4. URL parameters (?lang=es)
+    5. Cookie values
+    6. User preferences from database/session
+    
+    Returns:
+        Language code (e.g., 'en', 'es', 'fr')
+    """
+    # 1. Check environment variable first (for testing/override)
+    env_lang = os.environ.get('MINDROOT_LANGUAGE')
+    if env_lang:
+        return env_lang
+    
+    # 2. Try to get language from FastAPI request context
+    try:
+        from contextvars import ContextVar
+        import contextvars
+        
+        # Try to find request context
+        request_lang = _get_language_from_fastapi_context()
+        if request_lang:
+            return request_lang
+    except (ImportError, Exception):
+        pass
+    
+    # 3. Fallback to default language
+    return 'en'
+
+def _get_language_from_fastapi_context() -> Optional[str]:
+    """
+    Extract language from FastAPI request context.
+    
+    This function attempts to access the current FastAPI request
+    and extract language information from various sources.
+    
+    Returns:
+        Language code if found, None otherwise
+    """
+    try:
+        # Try to get the current request from FastAPI context
+        from starlette.requests import Request
+        import contextvars
+        
+        # This is a placeholder - in a real implementation, we would need
+        # to access the actual request context that MindRoot uses
+        # For now, we'll implement the detection logic structure
+        
+        # Check if there's a way to get the current request
+        # This would need to be integrated with MindRoot's request handling
+        
+        return None  # Placeholder
+        
+    except (ImportError, Exception):
+        return None
+
+def _parse_accept_language_header(accept_language: str) -> str:
+    """
+    Parse the Accept-Language header and return the preferred language.
+    
+    Args:
+        accept_language: Accept-Language header value
+        
+    Returns:
+        Preferred language code
+        
+    Example:
+        'en-US,en;q=0.9,es;q=0.8,fr;q=0.7' -> 'en'
+    """
+    if not accept_language:
+        return 'en'
+    
+    # Parse the Accept-Language header
+    languages = []
+    for lang_range in accept_language.split(','):
+        lang_range = lang_range.strip()
+        if ';q=' in lang_range:
+            lang, quality = lang_range.split(';q=', 1)
+            try:
+                quality = float(quality)
+            except ValueError:
+                quality = 1.0
+        else:
+            lang = lang_range
+            quality = 1.0
+        
+        # Extract just the language code (e.g., 'en' from 'en-US')
+        lang_code = lang.split('-')[0].lower()
+        languages.append((lang_code, quality))
+    
+    # Sort by quality (highest first)
+    languages.sort(key=lambda x: x[1], reverse=True)
+    
+    # Return the highest quality language
+    if languages:
+        return languages[0][0]
+    
+    return 'en'
+
+def set_language_for_request(language: str):
+    """
+    Set the language for the current request context.
+    
+    This function would be called by middleware or route handlers
+    to set the language for the current request.
+    
+    Args:
+        language: Language code to set
+    """
+    # Set environment variable as a simple implementation
+    os.environ['MINDROOT_LANGUAGE'] = language
+    
+    # In a real implementation, this would set the language
+    # in the request context or thread-local storage
+
+def get_supported_languages() -> list:
+    """
+    Get the list of supported languages.
+    
+    Returns:
+        List of supported language codes
+    """
+    # This could be configured via environment variables or config files
+    supported = os.environ.get('MINDROOT_SUPPORTED_LANGUAGES', 'en,es,fr,de,it,pt,ru,zh,ja,ko')
+    return [lang.strip() for lang in supported.split(',')]
+
+def is_language_supported(language: str) -> bool:
+    """
+    Check if a language is supported.
+    
+    Args:
+        language: Language code to check
+        
+    Returns:
+        True if language is supported, False otherwise
+    """
+    return language in get_supported_languages()
+
+def get_fallback_language(language: str) -> str:
+    """
+    Get a fallback language if the requested language is not supported.
+    
+    Args:
+        language: Requested language code
+        
+    Returns:
+        Fallback language code
+    """
+    if is_language_supported(language):
+        return language
+    
+    # Language family fallbacks
+    fallbacks = {
+        'en-us': 'en',
+        'en-gb': 'en',
+        'es-es': 'es',
+        'es-mx': 'es',
+        'fr-fr': 'fr',
+        'fr-ca': 'fr',
+        'de-de': 'de',
+        'de-at': 'de',
+        'pt-br': 'pt',
+        'pt-pt': 'pt',
+        'zh-cn': 'zh',
+        'zh-tw': 'zh',
+    }
+    
+    # Try fallback
+    fallback = fallbacks.get(language.lower())
+    if fallback and is_language_supported(fallback):
+        return fallback
+    
+    # Default to English
+    return 'en'

mindroot/coreplugins/l8n/middleware.py

@@ -0,0 +1,151 @@
+from fastapi import Request
+
+try:
+    from .language_detection import (
+        _parse_accept_language_header,
+        get_fallback_language,
+        set_language_for_request
+    )
+except ImportError:
+    # For standalone testing
+    from language_detection import (
+        _parse_accept_language_header,
+        get_fallback_language,
+        set_language_for_request
+    )
+import os
+
+# Global variable to store the current request language
+# This will be set by the middleware for each request
+_current_request_language = None
+
+def get_request_language() -> str:
+    """
+    Get the language that was detected for the current request.
+    
+    This function is called by the monkey patch system to get the
+    language for template translation.
+    
+    Returns:
+        Language code for the current request
+    """
+    global _current_request_language
+    print(f"L8n: Current request language is '{_current_request_language}'")
+    # If we have a request-specific language, use it
+    if _current_request_language:
+        return _current_request_language
+    
+    # Fallback to environment variable or default
+    print("L8n: No request language set, falling back to environment variable or default")
+    return os.environ.get('MINDROOT_LANGUAGE', 'en')
+
+def detect_language_from_request(request: Request) -> str:
+    """
+    Detect the preferred language from a FastAPI request.
+    
+    Checks multiple sources in order of priority:
+    1. URL parameter (?lang=es)
+    2. Cookie value (mindroot_language)
+    3. Accept-Language header
+    4. Environment variable
+    5. Default to 'en'
+    
+    Args:
+        request: FastAPI Request object
+        
+    Returns:
+        Detected language code
+    """
+    # 1. Check URL parameter first (highest priority)
+    print(f"L8n: Checking URL parameters for language: {request.query_params}")
+    url_lang = request.query_params.get('lang')
+    if url_lang:
+
+        return get_fallback_language(url_lang.lower())
+    
+    # 2. Check cookie value
+    print(f"L8n: Checking cookies for language: {request.cookies}")
+    cookie_lang = request.cookies.get('mindroot_language')
+    if cookie_lang:
+        print(f"L8n: Found language in cookie: {cookie_lang}")
+        return get_fallback_language(cookie_lang.lower())
+    
+    # 3. Check Accept-Language header
+    print(f"L8n: Accept-Language header: {request.headers.get('accept-language')}")
+    accept_language = request.headers.get('accept-language')
+    if accept_language:
+        print(f"L8n: Parsing Accept-Language header: {accept_language}")
+        parsed_lang = _parse_accept_language_header(accept_language)
+        if parsed_lang:
+            print(f"L8n: Parsed language from header: {parsed_lang}")
+            return get_fallback_language(parsed_lang)
+    
+    # 4. Check environment variable
+    env_lang = os.environ.get('MINDROOT_LANGUAGE')
+    if env_lang:
+        return get_fallback_language(env_lang.lower())
+    
+    # 5. Default to English
+    return 'en'
+
+async def middleware(request: Request, call_next):
+    """
+    L8n middleware for language detection and setting.
+    
+    This middleware runs early in the request pipeline to:
+    1. Detect the preferred language for the request
+    2. Store it globally for use by the template system
+    3. Set it in the request state for other components
+    
+    Args:
+        request: FastAPI Request object
+        call_next: Next middleware/handler in the chain
+        
+    Returns:
+        Response from the next handler
+    """
+    global _current_request_language
+    try:
+        print("L8n middleware: Starting language detection")
+        # Detect the language for this request
+        detected_language = detect_language_from_request(request)
+
+        print(f"L8n: Detected language '{detected_language}' for {request.url.path}")
+        # Store it globally for the template system
+        _current_request_language = detected_language
+        
+        # Also store it in request state for other components
+        request.state.language = detected_language
+        
+        # Set it using the language detection system
+        set_language_for_request(detected_language)
+        
+        # Debug logging (can be removed in production)
+        print(f"L8n: Detected language '{detected_language}' for {request.url.path}")
+        
+        # Process the request
+        response = await call_next(request)
+        
+        # Optionally set a cookie to remember the language preference
+        # Only set if it was explicitly requested via URL parameter
+        if request.query_params.get('lang'):
+            response.set_cookie(
+                key="mindroot_language",
+                value=detected_language,
+                max_age=30 * 24 * 60 * 60,  # 30 days
+                httponly=True,
+                samesite="lax"
+            )
+        
+        return response
+        
+    except Exception as e:
+        print(f"L8n middleware error: {e}")
+        # If there's an error, continue with default language
+        _current_request_language = 'en'
+        request.state.language = 'en'
+        return await call_next(request)
+    
+    finally:
+        # Clean up the global variable after the request
+        _current_request_language = None