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

mindroot/coreplugins/l8n/test_l8n_standalone.py

@@ -0,0 +1,251 @@
+#!/usr/bin/env python3
+"""
+Standalone test script for the l8n localization plugin.
+
+This script tests the core functionality without MindRoot dependencies.
+"""
+
+import asyncio
+import os
+import re
+from pathlib import Path
+
+# Simulate the command decorator for testing
+def command():
+    def decorator(func):
+        return func
+    return decorator
+
+# Copy the core functions from mod.py without MindRoot dependencies
+TRANSLATIONS = {}
+LOCALIZED_FILES_DIR = Path(__file__).parent / "localized_files"
+
+def extract_plugin_root(absolute_path: str) -> str:
+    """Extract the plugin root from an absolute path."""
+    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):
+            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 get_localized_file_path(original_path: str) -> Path:
+    """Convert an original file path to its localized version path."""
+    plugin_root = extract_plugin_root(original_path)
+    path = Path(plugin_root)
+    
+    # Determine if this is a core plugin or external plugin
+    if any(core_plugin in plugin_root for core_plugin in ['chat', 'admin', 'l8n']):
+        # Core plugin
+        base_dir = LOCALIZED_FILES_DIR / "coreplugins"
+    else:
+        # External plugin
+        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
+
+async def write_localized_file(original_path: str, content: str, context=None):
+    """Write a localized version of a file with static placeholders."""
+    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)}"
+
+async def append_localized_file(original_path: str, content: str, context=None):
+    """Append content to an existing localized file."""
+    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)}"
+
+async def set_translations(language: str, translations: dict, context=None):
+    """Set translations for a specific language."""
+    try:
+        if not isinstance(translations, dict):
+            return "Error: translations must be a dictionary"
+        
+        # Validate translation keys
+        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: {invalid_keys}"
+        
+        # Store translations
+        if language not in TRANSLATIONS:
+            TRANSLATIONS[language] = {}
+        
+        TRANSLATIONS[language].update(translations)
+        
+        return f"Set {len(translations)} translations for language '{language}'. Total languages: {len(TRANSLATIONS)}"
+    
+    except Exception as e:
+        return f"Error setting translations: {str(e)}"
+
+async def get_translations(language: str = None, context=None):
+    """Get translations for a specific language or all languages."""
+    try:
+        if language:
+            return TRANSLATIONS.get(language, {})
+        else:
+            return TRANSLATIONS
+    
+    except Exception as e:
+        return f"Error getting translations: {str(e)}"
+
+async def list_localized_files(context=None):
+    """List all localized files that have been created."""
+    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)}"
+
+def replace_placeholders(content: str, language: str) -> str:
+    """Replace __TRANSLATE_key__ placeholders with actual translations."""
+    if language not in TRANSLATIONS:
+        return content
+    
+    translations = TRANSLATIONS[language]
+    
+    def replace_match(match):
+        key = match.group(1)
+        return translations.get(key, match.group(0))  # Return original if no translation
+    
+    # Replace all __TRANSLATE_key__ patterns
+    return re.sub(r'__TRANSLATE_([a-z0-9_]+)__', replace_match, content)
+
+async def test_basic_functionality():
+    """Test the basic l8n functionality."""
+    print("Testing MindRoot l8n Plugin (Standalone)...\n")
+    
+    # Test 1: Create a localized file
+    print("1. Testing write_localized_file...")
+    test_path = "/files/mindroot/src/mindroot/coreplugins/chat/templates/chat.jinja2"
+    test_content = "<h1>__TRANSLATE_chat_title__</h1><button>__TRANSLATE_buttons_send__</button>"
+    
+    result = await write_localized_file(test_path, test_content)
+    print(f"   Result: {result}")
+    
+    # Test 2: Append to the file
+    print("\n2. Testing append_localized_file...")
+    append_content = "<p>__TRANSLATE_welcome_message__</p>"
+    
+    result = await append_localized_file(test_path, append_content)
+    print(f"   Result: {result}")
+    
+    # Test 3: Set translations
+    print("\n3. Testing set_translations...")
+    spanish_translations = {
+        'chat_title': 'Interfaz de Chat',
+        'buttons_send': 'Enviar Mensaje',
+        'welcome_message': 'Bienvenido al chat'
+    }
+    
+    result = await set_translations('es', spanish_translations)
+    print(f"   Result: {result}")
+    
+    # Test 4: Set more translations
+    french_translations = {
+        'chat_title': 'Interface de Chat',
+        'buttons_send': 'Envoyer le Message',
+        'welcome_message': 'Bienvenue dans le chat'
+    }
+    
+    result = await set_translations('fr', french_translations)
+    print(f"   Result: {result}")
+    
+    # Test 5: Get translations
+    print("\n4. Testing get_translations...")
+    es_translations = await get_translations('es')
+    print(f"   Spanish translations: {es_translations}")
+    
+    all_translations = await get_translations()
+    print(f"   All languages: {list(all_translations.keys())}")
+    
+    # Test 6: List localized files
+    print("\n5. Testing list_localized_files...")
+    files_result = await list_localized_files()
+    print(f"   Result: {files_result}")
+    
+    # Test 7: Test placeholder replacement
+    print("\n6. Testing placeholder replacement...")
+    test_template = "<h1>__TRANSLATE_chat_title__</h1><button>__TRANSLATE_buttons_send__</button><p>__TRANSLATE_welcome_message__</p>"
+    
+    spanish_result = replace_placeholders(test_template, 'es')
+    print(f"   Spanish: {spanish_result}")
+    
+    french_result = replace_placeholders(test_template, 'fr')
+    print(f"   French: {french_result}")
+    
+    # Test 8: Test with unknown language (should return original)
+    unknown_result = replace_placeholders(test_template, 'de')
+    print(f"   German (unknown): {unknown_result}")
+    
+    # Test 9: Check created file content
+    print("\n7. Checking created file content...")
+    localized_path = get_localized_file_path(test_path)
+    if localized_path.exists():
+        with open(localized_path, 'r', encoding='utf-8') as f:
+            file_content = f.read()
+        print(f"   File content: {repr(file_content)}")
+        
+        # Test replacement on actual file content
+        spanish_file_result = replace_placeholders(file_content, 'es')
+        print(f"   Spanish version: {spanish_file_result}")
+    else:
+        print(f"   File not found: {localized_path}")
+    
+    print("\n✅ All tests completed!")
+
+if __name__ == "__main__":
+    asyncio.run(test_basic_functionality())

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())