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

mindroot/coreplugins/l8n/test_middleware.py

@@ -0,0 +1,272 @@
+#!/usr/bin/env python3
+"""
+Test script for the l8n middleware functionality.
+
+This script simulates FastAPI request objects to test the middleware.
+"""
+
+import asyncio
+import os
+from unittest.mock import Mock
+
+# Mock FastAPI Request for testing
+class MockRequest:
+    def __init__(self, path="/", query_params=None, cookies=None, headers=None):
+        self.url = Mock()
+        self.url.path = path
+        self.query_params = query_params or {}
+        self.cookies = cookies or {}
+        self.headers = headers or {}
+        self.state = Mock()
+
+# Mock Response for testing
+class MockResponse:
+    def __init__(self):
+        self.cookies_set = {}
+    
+    def set_cookie(self, key, value, max_age=None, httponly=None, samesite=None):
+        self.cookies_set[key] = {
+            'value': value,
+            'max_age': max_age,
+            'httponly': httponly,
+            'samesite': samesite
+        }
+
+# Import the middleware functions with sys.path manipulation
+import sys
+from pathlib import Path
+sys.path.insert(0, str(Path(__file__).parent))
+
+# Now import with absolute imports
+import middleware
+from language_detection import _parse_accept_language_header, get_fallback_language
+
+# Create aliases for easier use
+middleware_func = middleware.middleware
+detect_language_from_request = middleware.detect_language_from_request
+get_request_language = middleware.get_request_language
+
+async def mock_call_next(request):
+    """Mock the next handler in the middleware chain."""
+    return MockResponse()
+
+async def test_language_detection():
+    """Test language detection from various request sources."""
+    print("Testing Language Detection from Requests...\n")
+    
+    # Test 1: URL parameter
+    print("1. Testing URL parameter detection...")
+    request = MockRequest(
+        path="/chat",
+        query_params={'lang': 'es'}
+    )
+    detected = detect_language_from_request(request)
+    print(f"   URL param 'lang=es' -> {detected}")
+    
+    # Test 2: Cookie value
+    print("\n2. Testing cookie detection...")
+    request = MockRequest(
+        path="/admin",
+        cookies={'mindroot_language': 'fr'}
+    )
+    detected = detect_language_from_request(request)
+    print(f"   Cookie 'mindroot_language=fr' -> {detected}")
+    
+    # Test 3: Accept-Language header
+    print("\n3. Testing Accept-Language header...")
+    test_headers = [
+        'en-US,en;q=0.9,es;q=0.8',
+        'es-ES,es;q=0.9,en;q=0.8',
+        'fr-FR,fr;q=0.9',
+        'de-DE,de;q=0.8,en;q=0.5',
+        'zh-CN,zh;q=0.9,en;q=0.1'
+    ]
+    
+    for header in test_headers:
+        request = MockRequest(
+            path="/test",
+            headers={'accept-language': header}
+        )
+        detected = detect_language_from_request(request)
+        print(f"   '{header}' -> {detected}")
+    
+    # Test 4: Environment variable
+    print("\n4. Testing environment variable...")
+    os.environ['MINDROOT_LANGUAGE'] = 'de'
+    request = MockRequest(path="/test")
+    detected = detect_language_from_request(request)
+    print(f"   MINDROOT_LANGUAGE=de -> {detected}")
+    
+    # Test 5: Priority order (URL param should override everything)
+    print("\n5. Testing priority order...")
+    request = MockRequest(
+        path="/test",
+        query_params={'lang': 'es'},
+        cookies={'mindroot_language': 'fr'},
+        headers={'accept-language': 'de-DE,de;q=0.9'}
+    )
+    detected = detect_language_from_request(request)
+    print(f"   URL=es, Cookie=fr, Header=de -> {detected} (should be es)")
+    
+    # Clean up
+    os.environ.pop('MINDROOT_LANGUAGE', None)
+    
+    print("\n✅ Language detection tests completed!")
+
+async def test_middleware_functionality():
+    """Test the complete middleware functionality."""
+    print("\nTesting Middleware Functionality...\n")
+    
+    # Test 1: Basic middleware flow
+    print("1. Testing basic middleware flow...")
+    request = MockRequest(
+        path="/chat",
+        query_params={'lang': 'es'},
+        headers={'accept-language': 'en-US,en;q=0.9'}
+    )
+    
+    response = await middleware_func(request, mock_call_next)
+    
+    print(f"   Request language set to: {request.state.language}")
+    print(f"   Global language: {get_request_language()}")
+    print(f"   Cookie set: {'mindroot_language' in response.cookies_set}")
+    
+    if 'mindroot_language' in response.cookies_set:
+        cookie_info = response.cookies_set['mindroot_language']
+        print(f"   Cookie value: {cookie_info['value']}")
+        print(f"   Cookie max_age: {cookie_info['max_age']} seconds")
+    
+    # Test 2: Different language sources
+    print("\n2. Testing different language sources...")
+    
+    test_cases = [
+        {
+            'name': 'Accept-Language only',
+            'request': MockRequest(
+                path="/admin",
+                headers={'accept-language': 'fr-FR,fr;q=0.9,en;q=0.8'}
+            ),
+            'expected': 'fr'
+        },
+        {
+            'name': 'Cookie preference',
+            'request': MockRequest(
+                path="/settings",
+                cookies={'mindroot_language': 'de'}
+            ),
+            'expected': 'de'
+        },
+        {
+            'name': 'URL override',
+            'request': MockRequest(
+                path="/dashboard",
+                query_params={'lang': 'es'},
+                cookies={'mindroot_language': 'fr'}
+            ),
+            'expected': 'es'
+        }
+    ]
+    
+    for case in test_cases:
+        print(f"\n   Testing: {case['name']}")
+        response = await middleware_func(case['request'], mock_call_next)
+        actual = case['request'].state.language
+        expected = case['expected']
+        status = "✅" if actual == expected else "❌"
+        print(f"   {status} Expected: {expected}, Got: {actual}")
+    
+    # Test 3: Error handling
+    print("\n3. Testing error handling...")
+    
+    # Create a request that might cause issues
+    request = MockRequest(
+        path="/test",
+        headers={'accept-language': 'invalid-header-format'}
+    )
+    
+    try:
+        response = await middleware_func(request, mock_call_next)
+        print(f"   ✅ Error handled gracefully, language: {request.state.language}")
+    except Exception as e:
+        print(f"   ❌ Unexpected error: {e}")
+    
+    print("\n✅ Middleware functionality tests completed!")
+
+async def test_integration_with_templates():
+    """Test integration with the template system."""
+    print("\nTesting Integration with Template System...\n")
+    
+    # Import template-related functions
+    from test_l8n_standalone import set_translations, replace_placeholders
+    
+    # Set up some translations
+    print("1. Setting up translations...")
+    await set_translations('en', {
+        'page_title': 'Welcome to MindRoot',
+        'nav_home': 'Home',
+        'nav_settings': 'Settings'
+    })
+    
+    await set_translations('es', {
+        'page_title': 'Bienvenido a MindRoot',
+        'nav_home': 'Inicio',
+        'nav_settings': 'Configuración'
+    })
+    
+    await set_translations('fr', {
+        'page_title': 'Bienvenue à MindRoot',
+        'nav_home': 'Accueil',
+        'nav_settings': 'Paramètres'
+    })
+    
+    # Template content
+    template = "<title>__TRANSLATE_page_title__</title><nav><a>__TRANSLATE_nav_home__</a><a>__TRANSLATE_nav_settings__</a></nav>"
+    
+    # Test different language requests
+    print("\n2. Testing template translation with different requests...")
+    
+    test_requests = [
+        ('English (default)', MockRequest(path="/")),
+        ('Spanish (URL param)', MockRequest(path="/", query_params={'lang': 'es'})),
+        ('French (cookie)', MockRequest(path="/", cookies={'mindroot_language': 'fr'})),
+        ('German (header)', MockRequest(path="/", headers={'accept-language': 'de-DE,de;q=0.9,en;q=0.8'}))
+    ]
+    
+    for name, request in test_requests:
+        print(f"\n   Testing: {name}")
+        
+        # Process request through middleware
+        await middleware_func(request, mock_call_next)
+        
+        # Get the detected language
+        detected_lang = get_request_language()
+        print(f"   Detected language: {detected_lang}")
+        
+        # Translate the template
+        translated = replace_placeholders(template, detected_lang)
+        
+        # Extract title for display
+        title_start = translated.find('<title>') + 7
+        title_end = translated.find('</title>')
+        title = translated[title_start:title_end]
+        
+        print(f"   Translated title: {title}")
+    
+    print("\n✅ Template integration tests completed!")
+
+async def main():
+    """Run all middleware tests."""
+    print("=" * 60)
+    print("MindRoot l8n Plugin - Middleware Testing Suite")
+    print("=" * 60)
+    
+    await test_language_detection()
+    await test_middleware_functionality()
+    await test_integration_with_templates()
+    
+    print("\n" + "=" * 60)
+    print("✅ All middleware tests completed successfully!")
+    print("=" * 60)
+
+if __name__ == "__main__":
+    asyncio.run(main())

mindroot/coreplugins/l8n/utils.py

@@ -0,0 +1,232 @@
+# need to import Path
+from pathlib import Path
+from .l8n_constants import *
+import json
+import re
+import logging
+
+# Set up logging for l8n warnings
+logger = logging.getLogger('l8n')
+logger.setLevel(logging.WARNING)
+
+# Create console handler with formatting
+if not logger.handlers:
+    console_handler = logging.StreamHandler()
+    console_handler.setLevel(logging.WARNING)
+    formatter = logging.Formatter('\033[91m[L8N WARNING]\033[0m %(message)s')
+    console_handler.setFormatter(formatter)
+    logger.addHandler(console_handler)
+
+def extract_plugin_root(absolute_path: str) -> str:
+    """
+    Extract the plugin root from an absolute path.
+    
+    For core plugins: everything after 'coreplugins/'
+    For external plugins: everything after 'src/[plugin_name]/'
+    
+    Examples:
+    - /files/mindroot/src/mindroot/coreplugins/chat/templates/chat.jinja2 -> chat/templates/chat.jinja2
+    - /some/path/src/my_plugin/templates/page.jinja2 -> my_plugin/templates/page.jinja2
+    """
+    path = Path(absolute_path)
+    parts = path.parts
+    
+    # Find coreplugins in the path
+    if 'coreplugins' in parts:
+        coreplugins_idx = parts.index('coreplugins')
+        if coreplugins_idx + 1 < len(parts):
+            return '/'.join(parts[coreplugins_idx + 1:])
+    
+    # Find src/[plugin_name] pattern for external plugins
+    for i, part in enumerate(parts):
+        if part == 'src' and i + 1 < len(parts):
+            # Check if this looks like a plugin (has templates, static, etc.)
+            potential_plugin = parts[i + 1]
+            if i + 2 < len(parts):  # Has more path after src/plugin_name
+                return '/'.join(parts[i + 1:])
+    
+    # Fallback: return the filename
+    return path.name
+
+def extract_translation_keys(content: str) -> set:
+    """
+    Extract all __TRANSLATE_key__ placeholders from content.
+    
+    Args:
+        content: Content to scan for translation keys
+        
+    Returns:
+        Set of translation keys found in the content
+    """
+    pattern = r'__TRANSLATE_([a-z0-9_]+)__'
+    matches = re.findall(pattern, content)
+    return set(matches)
+
+def replace_placeholders(content: str, language: str, plugin_path: str = None) -> str:
+    """
+    Replace __TRANSLATE_key__ placeholders with actual translations.
+    
+    This function now validates that ALL required translations are available
+    for the specified language. If any translations are missing, it logs
+    a strong warning and returns None to indicate fallback is needed.
+    
+    Args:
+        content: Template content with placeholders
+        language: Language code for translations
+        plugin_path: Path to the localized file (used to determine which plugin's translations to use)
+    
+    Returns:
+        Content with placeholders replaced by translations, or None if translations are incomplete
+    """
+    if not plugin_path:
+        # No plugin path provided, return content unchanged
+        logger.warning("No plugin path provided for translation replacement.")
+        return content
+    
+    try:
+        # Extract all translation keys from the content
+        required_keys = extract_translation_keys(content)
+        
+        if not required_keys:
+            # No translation keys found, return content as-is
+            return content
+        
+        # Extract plugin name from the localized file path
+        # Path format: .../localized_files/[coreplugins|external_plugins]/[plugin_name]/...
+        path_parts = Path(plugin_path).parts
+        
+        # Find 'localized_files' in the path
+        if 'localized_files' in path_parts:
+            idx = path_parts.index('localized_files')
+            if idx + 2 < len(path_parts):
+                # Get plugin name (should be at idx+2)
+                plugin_type = path_parts[idx + 1]  # 'coreplugins' or 'external_plugins'
+                plugin_name = path_parts[idx + 2]
+                
+                # Load translations for this plugin
+                translations_path = TRANSLATIONS_DIR / plugin_type / plugin_name / "translations.json"
+                plugin_translations = {}
+                if translations_path.exists():
+                    try:
+                        with open(translations_path, 'r', encoding='utf-8') as f:
+                             plugin_translations = json.load(f)
+                    except Exception as e:
+                        logger.warning(f"Could not load translations from {translations_path}: {e}")
+                        return None  # Fallback to original file
+                
+                if language in plugin_translations:
+                    translations = plugin_translations[language]
+                    
+                    # Check if ALL required translations are available
+                    missing_keys = required_keys - set(translations.keys())
+                    
+                    if missing_keys:
+                        # Some translations are missing - log strong warning and return None
+                        missing_list = ', '.join(sorted(missing_keys))
+                        logger.warning(
+                            f"\n" +
+                            f"="*80 + "\n" +
+                            f"MISSING TRANSLATIONS DETECTED!\n" +
+                            f"Plugin: {plugin_name}\n" +
+                            f"Language: {language}\n" +
+                            f"File: {plugin_path}\n" +
+                            f"Missing keys: {missing_list}\n" +
+                            f"Falling back to original file to avoid showing placeholders.\n" +
+                            f"="*80
+                        )
+                        return None  # Signal that fallback is needed
+                    
+                    # All translations are available - proceed with replacement
+                    def replace_match(match):
+                        key = match.group(1)
+                        return translations.get(key, match.group(0))  # This shouldn't happen now
+                    
+                    return re.sub(r'__TRANSLATE_([a-z0-9_]+)__', replace_match, content)
+                else:
+                    # No translations for this language
+                    logger.warning(
+                        f"\n" +
+                        f"="*80 + "\n" +
+                        f"NO TRANSLATIONS FOR LANGUAGE!\n" +
+                        f"Plugin: {plugin_name}\n" +
+                        f"Language: {language}\n" +
+                        f"File: {plugin_path}\n" +
+                        f"Required keys: {', '.join(sorted(required_keys))}\n" +
+                        f"Falling back to original file.\n" +
+                        f"="*80
+                    )
+                    return None  # Signal that fallback is needed
+            else:
+                logger.warning(f"Could not extract plugin info from path: {plugin_path}")
+                return None
+        else:
+            logger.warning(f"Path does not contain 'localized_files': {plugin_path}")
+            return None
+        
+    except Exception as e:
+        logger.warning(f"Error in replace_placeholders: {e}")
+        return None  # Fallback to original file on any error
+       
+def get_localized_file_path(original_path: str) -> Path:
+    """
+    Convert an original file path to its localized version path.
+    
+    Examples:
+    - chat/templates/chat.jinja2 -> localized_files/coreplugins/chat/templates/chat.i18n.jinja2
+    - my_plugin/templates/page.jinja2 -> localized_files/external_plugins/my_plugin/templates/page.i18n.jinja2
+    """
+    plugin_root = extract_plugin_root(original_path)
+    path = Path(plugin_root)
+    
+    # Determine if this is a core plugin or external plugin based on the absolute path
+    if 'coreplugins' in original_path:
+        base_dir = LOCALIZED_FILES_DIR / "coreplugins"
+    else:
+        base_dir = LOCALIZED_FILES_DIR / "external_plugins"
+    
+    # Add .i18n before the file extension
+    stem = path.stem
+    suffix = path.suffix
+    new_filename = f"{stem}.i18n{suffix}"
+    
+    localized_path = base_dir / path.parent / new_filename
+    return localized_path
+
+
+def load_plugin_translations(plugin_path: str):
+    """Load translations for a specific plugin from disk."""
+
+    translations_file = get_plugin_translations_path(plugin_path)
+    
+    if translations_file.exists():
+        try:
+            with open(translations_file, 'r', encoding='utf-8') as f:
+                return json.load(f)
+        except Exception as e:
+            logger.warning(f"Could not load translations from {translations_file}: {e}")
+    else:
+        logger.warning(f"Translations file does not exist at {translations_file}")
+    return {}
+
+def get_plugin_translations_path(original_path: str) -> Path:
+    """
+    Get the path where translations should be stored for a given file.
+    
+    Example:
+    /files/mindroot/src/mindroot/coreplugins/check_list/inject/admin.jinja2
+    -> translations/coreplugins/check_list/translations.json
+    """
+    plugin_root = extract_plugin_root(original_path)
+    
+    # Determine if this is a core plugin or external plugin based on the absolute path
+    if 'coreplugins' in original_path:
+        base_dir = TRANSLATIONS_DIR / "coreplugins"
+    else:
+        base_dir = TRANSLATIONS_DIR / "external_plugins"
+    
+    # Get just the plugin name (first part of plugin_root)
+    plugin_name = Path(plugin_root).parts[0]
+    
+    return base_dir / plugin_name / "translations.json"
+
+

mindroot/coreplugins/mcp_/__init__.py

@@ -0,0 +1,14 @@
+# This import is required for the plugin to load properly
+from .mod import *
+
+# Import catalog features
+try:
+    from .catalog_commands import *
+except ImportError:
+    pass
+
+# Import additional commands
+try:
+    from .additional_commands import *
+except ImportError:
+    pass