mindroot 9.2.0__py3-none-any.whl → 9.5.0__py3-none-any.whl

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

mindroot/coreplugins/l8n/mod.py

@@ -0,0 +1,277 @@
+import os
+import re
+import json
+from pathlib import Path
+
+# Try to import from lib first (for same instance), fallback to mindroot.lib
+try:
+    from lib.providers.commands import command, command_manager
+    print("l8n: Using lib.providers.commands (same instance)")
+except ImportError:
+    from mindroot.lib.providers.commands import command, command_manager
+    print("l8n: Using mindroot.lib.providers.commands (fallback)")
+
+from .utils import extract_plugin_root, get_localized_file_path, load_plugin_translations, get_plugin_translations_path
+from mindroot.lib.utils.debug import debug_box
+
+debug_box("l8n: Top of mod.py")
+
+from .l8n_constants import *
+
+def save_plugin_translations(plugin_path: str, translations: dict):
+    """Save translations for a specific plugin to disk."""
+    translations_file = get_plugin_translations_path(plugin_path)
+    
+    try:
+        # Ensure directory exists
+        translations_file.parent.mkdir(parents=True, exist_ok=True)
+        with open(translations_file, 'w', encoding='utf-8') as f:
+            json.dump(translations, f, indent=2, ensure_ascii=False)
+        return True
+    except Exception as e:
+        print(f"Warning: Could not save translations to {translations_file}: {e}")
+        return False
+
+
+debug_box("l8n: defining command")
+
+# Debug: Check if command_manager has functions
+debug_box(f"l8n: command_manager has {len(command_manager.functions)} functions before registration")
+debug_box(f"l8n: command_manager instance ID: {id(command_manager)}")
+
+@command()
+async def write_localized_file(original_path: str, content: str, context=None):
+    """
+    Write a localized version of a file with static placeholders.
+    
+    This command creates a localized version of a template or source file
+    with __TRANSLATE_key__ placeholders that will be replaced with actual
+    translations when the file is loaded.
+    
+    PLACEHOLDER FORMAT RULES:
+    - Always use the exact format: __TRANSLATE_key_name__
+    - Must start with __TRANSLATE_ and end with __
+    - Use lowercase letters, numbers, and underscores only for the key name
+    - Use descriptive, hierarchical key names like section_element or buttons_save
+    - NO spaces, hyphens, or special characters in key names
+    
+    Args:
+        original_path: Absolute path to the original file
+        content: File content with __TRANSLATE_key__ placeholders
+        context: Command context (optional)
+    
+    Examples:
+        await write_localized_file(
+            "/files/mindroot/src/mindroot/coreplugins/chat/templates/chat.jinja2",
+            "<h1>__TRANSLATE_chat_title__</h1><button>__TRANSLATE_buttons_send__</button>"
+        )
+        
+        await write_localized_file(
+            "/some/path/src/my_plugin/templates/dashboard.jinja2",
+            "<div>__TRANSLATE_dashboard_welcome__</div>"
+        )
+    """
+    try:
+        localized_path = get_localized_file_path(original_path)
+        
+        # Create directory if it doesn't exist
+        localized_path.parent.mkdir(parents=True, exist_ok=True)
+        
+        # Write the content
+        with open(localized_path, 'w', encoding='utf-8') as f:
+            f.write(content)
+        
+        return f"Localized file written to: {localized_path}"
+    
+    except Exception as e:
+        return f"Error writing localized file: {str(e)}"
+
+@command()
+async def append_localized_file(original_path: str, content: str, context=None):
+    """
+    Append content to an existing localized file.
+    
+    Use this for large files that need to be built incrementally.
+    Follow the same placeholder format rules as write_localized_file.
+    
+    Args:
+        original_path: Absolute path to the original file
+        content: Content to append with __TRANSLATE_key__ placeholders
+        context: Command context (optional)
+    
+    Example:
+        # First write the beginning
+        await write_localized_file(
+            "/path/to/large_template.jinja2",
+            "<html><head><title>__TRANSLATE_page_title__</title></head>"
+        )
+        
+        # Then append more sections
+        await append_localized_file(
+            "/path/to/large_template.jinja2",
+            "<body><h1>__TRANSLATE_main_heading__</h1></body></html>"
+        )
+    """
+    try:
+        localized_path = get_localized_file_path(original_path)
+        
+        # Create directory if it doesn't exist
+        localized_path.parent.mkdir(parents=True, exist_ok=True)
+        
+        # Append the content
+        with open(localized_path, 'a', encoding='utf-8') as f:
+            f.write(content)
+        
+        return f"Content appended to: {localized_path}"
+    
+    except Exception as e:
+        return f"Error appending to localized file: {str(e)}"
+
+@command()
+async def set_translations(original_path: str, language: str, translations: dict, context=None):
+    """
+    Set translations for a specific language and plugin.
+    
+    This command stores the translation mappings that will be used to replace
+    __TRANSLATE_key__ placeholders in localized files. Translations are stored
+    per plugin based on the provided file path.
+    
+    Args:
+        original_path: Absolute path to a file in the plugin (used to identify the plugin)
+        language: Language code (e.g., 'en', 'es', 'fr', 'de')
+        translations: Dictionary mapping translation keys to translated text
+        context: Command context (optional)
+    
+    Examples:
+        await set_translations(
+            "/files/mindroot/src/mindroot/coreplugins/chat/templates/chat.jinja2",
+            'es', 
+            {
+                'chat_title': 'Interfaz de Chat',
+                'buttons_send': 'Enviar Mensaje',
+                'nav_home': 'Inicio',
+                'error_connection_failed': 'Error de conexión'
+            }
+        )
+        
+        await set_translations(
+            "/some/path/src/my_plugin/templates/dashboard.jinja2",
+            'fr', 
+            {
+                'dashboard_welcome': 'Bienvenue au Tableau de Bord',
+                'buttons_save': 'Enregistrer',
+                'nav_home': 'Accueil'
+            }
+        )
+    """
+    try:
+        if not isinstance(translations, dict):
+            return "Error: translations must be a dictionary"
+        
+        # Get the plugin-specific translations path
+        plugin_key = str(get_plugin_translations_path(original_path))
+        
+        # Load existing translations for this plugin
+        plugin_translations = load_plugin_translations(original_path)
+        
+        # Validate translation keys (should match placeholder format)
+        invalid_keys = []
+        for key in translations.keys():
+            if not re.match(r'^[a-z0-9_]+$', key):
+                invalid_keys.append(key)
+        
+        if invalid_keys:
+            return f"Error: Invalid translation keys (use lowercase, numbers, underscores only): {invalid_keys}"
+        
+        # Update translations for this language
+        if language not in plugin_translations:
+            plugin_translations[language] = {}
+        
+        plugin_translations[language].update(translations)
+        
+        # Save translations to disk
+        if save_plugin_translations(original_path, plugin_translations):
+            # Update cache
+            TRANSLATIONS[plugin_key] = plugin_translations
+            return f"Set {len(translations)} translations for language '{language}' in {Path(plugin_key).parent.name} plugin"
+        else:
+            return f"Error: Could not save translations"
+    
+    except Exception as e:
+        return f"Error setting translations: {str(e)}"
+
+@command()
+async def get_translations(original_path: str = None, language: str = None, context=None):
+    """
+    Get translations for a specific plugin and language.
+    
+    Args:
+        original_path: Absolute path to a file in the plugin (optional)
+                      If not provided, returns all cached translations
+        language: Language code to get translations for (optional)
+        context: Command context (optional)
+    
+    Returns:
+        Dictionary of translations
+    
+    Examples:
+        # Get all translations for a plugin
+        translations = await get_translations(
+            "/files/mindroot/src/mindroot/coreplugins/chat/templates/chat.jinja2"
+        )
+        
+        # Get Spanish translations for a plugin
+        spanish = await get_translations(
+            "/files/mindroot/src/mindroot/coreplugins/chat/templates/chat.jinja2",
+            'es'
+        )
+        
+        # Get all cached translations
+        all_cached = await get_translations()
+    """
+    try:
+        if original_path:
+            # Load translations for specific plugin
+            plugin_translations = load_plugin_translations(original_path)
+            
+            # Update cache
+            plugin_key = str(get_plugin_translations_path(original_path))
+            TRANSLATIONS[plugin_key] = plugin_translations
+            
+            if language:
+                return plugin_translations.get(language, {})
+            else:
+                return plugin_translations
+        else:
+            # Return all cached translations
+            return TRANSLATIONS
+        
+    except Exception as e:
+        return f"Error getting translations: {str(e)}"
+
+@command()
+async def list_localized_files(context=None):
+    """
+    List all localized files that have been created.
+    
+    Returns:
+        List of paths to localized files
+    """
+    try:
+        localized_files = []
+        
+        if LOCALIZED_FILES_DIR.exists():
+            for file_path in LOCALIZED_FILES_DIR.rglob("*.i18n.*"):
+                localized_files.append(str(file_path.relative_to(LOCALIZED_FILES_DIR)))
+        
+        return {
+            "count": len(localized_files),
+            "files": sorted(localized_files)
+        }
+    
+    except Exception as e:
+        return f"Error listing localized files: {str(e)}"
+
+debug_box(f"l8n: command_manager has {len(command_manager.functions)} functions after registration")
+
+debug_box("l8n: End of mod.py")