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

mindroot/coreplugins/l8n/monkey_patch_to_delete.py

@@ -0,0 +1,186 @@
+to_delete = """
+import os
+import re
+from pathlib import Path
+from typing import Optional
+
+# Import the translation replacement function
+from .mod import replace_placeholders, LOCALIZED_FILES_DIR
+
+# Import the enhanced language detection
+from .language_detection import get_fallback_language
+from .middleware import get_request_language
+
+# Store original Jinja2 loader methods
+_original_get_source = None
+_original_loader_get_source = None
+
+def get_current_language() -> str:
+    """
+    Get the current language for the request using enhanced detection.
+    """
+    return get_fallback_language(get_request_language())
+
+def find_localized_template(template_name: str) -> Optional[Path]:
+    """
+    Find a localized version of a template.
+    
+    Uses relative path matching to find templates regardless of installation directory.
+    
+    Args:
+        template_name: Original template name/path
+    
+    Returns:
+        Path to localized template if found, None otherwise
+    """
+    if not LOCALIZED_FILES_DIR.exists():
+        return None
+    
+    # Convert template name to potential localized paths
+    template_path = Path(template_name)
+    stem = template_path.stem
+    suffix = template_path.suffix
+    
+    # Create the .i18n version filename
+    localized_filename = f"{stem}.i18n{suffix}"
+    
+    # Search strategies in order of preference:
+    search_strategies = [
+        # 1. Exact filename match anywhere in localized_files
+        lambda: list(LOCALIZED_FILES_DIR.rglob(localized_filename)),
+        
+        # 2. Match last 2 path components
+        lambda: _find_by_path_components(template_path, localized_filename, 2),
+        
+        # 3. Match last 3 path components
+        lambda: _find_by_path_components(template_path, localized_filename, 3),
+    ]
+    
+    for strategy in search_strategies:
+        matches = strategy()
+        if matches:
+            # Return the first match
+            return matches[0]
+    
+    return None
+
+def _find_by_path_components(original_path: Path, localized_filename: str, num_components: int) -> list:
+    """
+    Find localized templates by matching the last N path components.
+    
+    Args:
+        original_path: Original template path
+        localized_filename: Localized filename to search for
+        num_components: Number of path components to match
+    
+    Returns:
+        List of matching paths
+    """
+    if len(original_path.parts) < num_components:
+        return []
+    
+    # Get the last N-1 components (excluding filename) + localized filename
+    target_components = original_path.parts[-(num_components-1):]
+    target_path_pattern = '/'.join(target_components[:-1]) + '/' + localized_filename
+    
+    matches = []
+    for candidate in LOCALIZED_FILES_DIR.rglob(localized_filename):
+        candidate_relative = candidate.relative_to(LOCALIZED_FILES_DIR)
+        if str(candidate_relative).endswith(target_path_pattern):
+            matches.append(candidate)
+    
+    return matches
+
+def patched_get_source(self, environment, template):
+    """
+    Patched version of Jinja2 loader's get_source method.
+    
+    This intercepts template loading and:
+    1. Checks for localized versions
+    2. Replaces placeholders with translations
+    3. Falls back to original templates if no localized version exists
+    """
+    # First, try to find a localized version
+    localized_path = find_localized_template(template)
+    
+    if localized_path and localized_path.exists():
+        try:
+            # Read the localized template
+            with open(localized_path, 'r', encoding='utf-8') as f:
+                source = f.read()
+            
+            # Replace placeholders with translations
+            current_language = get_current_language()
+            translated_source = replace_placeholders(source, current_language, str(localized_path))
+            
+            # Return the translated source
+            # Note: We use the original template name for caching purposes
+            return translated_source, str(localized_path), lambda: True
+        
+        except Exception as e:
+            # If there's an error reading the localized template, fall back to original
+            print(f"Error loading localized template {localized_path}: {e}")
+    
+    # Fall back to original template loading
+    return _original_get_source(self, environment, template)
+
+def install_monkey_patch():
+    """
+    Install the monkey patch for Jinja2 template loading.
+    
+    This patches the FileSystemLoader.get_source method to intercept
+    template loading and provide localized versions when available.
+    """
+    global _original_get_source
+    return
+    try:
+        from jinja2 import FileSystemLoader
+        
+        # Store the original method
+        if _original_get_source is None:
+            _original_get_source = FileSystemLoader.get_source
+        
+        # Install the patch
+        FileSystemLoader.get_source = patched_get_source
+        
+        print("L8n monkey patch installed successfully")
+        return True
+    
+    except ImportError:
+        print("Warning: Could not import Jinja2 for monkey patching")
+        return False
+    except Exception as e:
+        print(f"Error installing l8n monkey patch: {e}")
+        return False
+
+def uninstall_monkey_patch():
+    """
+    Remove the monkey patch and restore original Jinja2 behavior.
+    """
+    global _original_get_source
+    
+    try:
+        from jinja2 import FileSystemLoader
+        
+        if _original_get_source is not None:
+            FileSystemLoader.get_source = _original_get_source
+            print("L8n monkey patch removed successfully")
+            return True
+        else:
+            print("No monkey patch to remove")
+            return False
+    
+    except ImportError:
+        print("Warning: Could not import Jinja2 for monkey patch removal")
+        return False
+    except Exception as e:
+        print(f"Error removing l8n monkey patch: {e}")
+        return False
+
+# Auto-install the monkey patch when this module is imported
+# Prevent double installation by checking if already installed
+if __name__ != '__main__' and not hasattr(install_monkey_patch, '_auto_installed'):
+    install_monkey_patch()
+    install_monkey_patch._auto_installed = True
+
+"""

mindroot/coreplugins/l8n/test_enhanced.py

@@ -0,0 +1,298 @@
+#!/usr/bin/env python3
+"""
+Enhanced test script for the l8n localization plugin with language detection.
+"""
+
+import asyncio
+import os
+import sys
+from pathlib import Path
+
+# Add the current directory to Python path for imports
+sys.path.insert(0, str(Path(__file__).parent))
+
+from test_l8n_standalone import (
+    write_localized_file,
+    set_translations,
+    replace_placeholders,
+    TRANSLATIONS
+)
+
+from language_detection import (
+    get_current_language_from_request,
+    get_fallback_language,
+    set_language_for_request,
+    get_supported_languages,
+    is_language_supported,
+    _parse_accept_language_header
+)
+
+async def test_language_detection():
+    """Test the enhanced language detection functionality."""
+    print("Testing Enhanced Language Detection...\n")
+    
+    # Test 1: Default language detection
+    print("1. Testing default language detection...")
+    default_lang = get_current_language_from_request()
+    print(f"   Default language: {default_lang}")
+    
+    # Test 2: Environment variable override
+    print("\n2. Testing environment variable override...")
+    os.environ['MINDROOT_LANGUAGE'] = 'es'
+    env_lang = get_current_language_from_request()
+    print(f"   Language with MINDROOT_LANGUAGE=es: {env_lang}")
+    
+    # Test 3: Language fallback system
+    print("\n3. Testing language fallback system...")
+    supported = get_supported_languages()
+    print(f"   Supported languages: {supported}")
+    
+    test_languages = ['es', 'fr', 'de', 'zh-cn', 'pt-br', 'invalid-lang']
+    for lang in test_languages:
+        fallback = get_fallback_language(lang)
+        supported_check = is_language_supported(lang)
+        print(f"   {lang} -> {fallback} (supported: {supported_check})")
+    
+    # Test 4: Accept-Language header parsing
+    print("\n4. Testing Accept-Language header parsing...")
+    test_headers = [
+        'en-US,en;q=0.9,es;q=0.8,fr;q=0.7',
+        '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:
+        parsed = _parse_accept_language_header(header)
+        print(f"   '{header}' -> {parsed}")
+    
+    # Test 5: Set language for request
+    print("\n5. Testing set_language_for_request...")
+    set_language_for_request('fr')
+    current_lang = get_current_language_from_request()
+    print(f"   After setting to 'fr': {current_lang}")
+    
+    # Reset for next tests
+    os.environ.pop('MINDROOT_LANGUAGE', None)
+    
+    print("\n✅ Language detection tests completed!")
+
+async def test_integrated_translation():
+    """Test the integrated translation system with language detection."""
+    print("\nTesting Integrated Translation System...\n")
+    
+    # Set up translations for multiple languages
+    print("1. Setting up translations...")
+    
+    # English (default)
+    await set_translations('en', {
+        'welcome_title': 'Welcome to MindRoot',
+        'nav_home': 'Home',
+        'nav_settings': 'Settings',
+        'button_save': 'Save',
+        'button_cancel': 'Cancel'
+    })
+    
+    # Spanish
+    await set_translations('es', {
+        'welcome_title': 'Bienvenido a MindRoot',
+        'nav_home': 'Inicio',
+        'nav_settings': 'Configuración',
+        'button_save': 'Guardar',
+        'button_cancel': 'Cancelar'
+    })
+    
+    # French
+    await set_translations('fr', {
+        'welcome_title': 'Bienvenue à MindRoot',
+        'nav_home': 'Accueil',
+        'nav_settings': 'Paramètres',
+        'button_save': 'Enregistrer',
+        'button_cancel': 'Annuler'
+    })
+    
+    # German
+    await set_translations('de', {
+        'welcome_title': 'Willkommen bei MindRoot',
+        'nav_home': 'Startseite',
+        'nav_settings': 'Einstellungen',
+        'button_save': 'Speichern',
+        'button_cancel': 'Abbrechen'
+    })
+    
+    print(f"   Set up translations for {len(TRANSLATIONS)} languages")
+    
+    # Test template with placeholders
+    template_content = """
+<html>
+<head>
+    <title>__TRANSLATE_welcome_title__</title>
+</head>
+<body>
+    <nav>
+        <a href="/">__TRANSLATE_nav_home__</a>
+        <a href="/settings">__TRANSLATE_nav_settings__</a>
+    </nav>
+    <main>
+        <h1>__TRANSLATE_welcome_title__</h1>
+        <div class="actions">
+            <button>__TRANSLATE_button_save__</button>
+            <button>__TRANSLATE_button_cancel__</button>
+        </div>
+    </main>
+</body>
+</html>
+""".strip()
+    
+    # Test translation for each language
+    print("\n2. Testing translation for each language...")
+    
+    test_languages = ['en', 'es', 'fr', 'de', 'pt']  # pt should fallback to en
+    
+    for lang in test_languages:
+        print(f"\n   Language: {lang}")
+        
+        # Set the language
+        set_language_for_request(lang)
+        
+        # Get the fallback language
+        fallback_lang = get_fallback_language(lang)
+        print(f"   Fallback: {fallback_lang}")
+        
+        # Translate the template
+        translated = replace_placeholders(template_content, fallback_lang)
+        
+        # Show a snippet of the translation
+        title_line = [line for line in translated.split('\n') if '<title>' in line][0]
+        h1_line = [line for line in translated.split('\n') if '<h1>' in line][0]
+        
+        print(f"   Title: {title_line.strip()}")
+        print(f"   H1: {h1_line.strip()}")
+    
+    print("\n✅ Integrated translation tests completed!")
+
+async def test_file_integration():
+    """Test creating localized files and using language detection."""
+    print("\nTesting File Integration...\n")
+    
+    # Create a localized template file
+    print("1. Creating localized template file...")
+    
+    template_path = "/files/mindroot/src/mindroot/coreplugins/admin/templates/admin.jinja2"
+    template_content = """
+<!DOCTYPE html>
+<html>
+<head>
+    <title>__TRANSLATE_admin_title__</title>
+</head>
+<body>
+    <header>
+        <h1>__TRANSLATE_admin_header__</h1>
+        <nav>
+            <a href="/admin/users">__TRANSLATE_nav_users__</a>
+            <a href="/admin/settings">__TRANSLATE_nav_settings__</a>
+            <a href="/admin/logs">__TRANSLATE_nav_logs__</a>
+        </nav>
+    </header>
+    <main>
+        <section>
+            <h2>__TRANSLATE_section_overview__</h2>
+            <p>__TRANSLATE_overview_description__</p>
+        </section>
+        <div class="actions">
+            <button class="primary">__TRANSLATE_button_create__</button>
+            <button class="secondary">__TRANSLATE_button_refresh__</button>
+        </div>
+    </main>
+</body>
+</html>
+""".strip()
+    
+    result = await write_localized_file(template_path, template_content)
+    print(f"   {result}")
+    
+    # Set up admin-specific translations
+    print("\n2. Setting up admin translations...")
+    
+    admin_translations = {
+        'en': {
+            'admin_title': 'MindRoot Administration',
+            'admin_header': 'Admin Dashboard',
+            'nav_users': 'Users',
+            'nav_settings': 'Settings',
+            'nav_logs': 'Logs',
+            'section_overview': 'System Overview',
+            'overview_description': 'Manage your MindRoot installation from this dashboard.',
+            'button_create': 'Create New',
+            'button_refresh': 'Refresh Data'
+        },
+        'es': {
+            'admin_title': 'Administración de MindRoot',
+            'admin_header': 'Panel de Administración',
+            'nav_users': 'Usuarios',
+            'nav_settings': 'Configuración',
+            'nav_logs': 'Registros',
+            'section_overview': 'Resumen del Sistema',
+            'overview_description': 'Gestiona tu instalación de MindRoot desde este panel.',
+            'button_create': 'Crear Nuevo',
+            'button_refresh': 'Actualizar Datos'
+        },
+        'fr': {
+            'admin_title': 'Administration MindRoot',
+            'admin_header': 'Tableau de Bord Admin',
+            'nav_users': 'Utilisateurs',
+            'nav_settings': 'Paramètres',
+            'nav_logs': 'Journaux',
+            'section_overview': 'Aperçu du Système',
+            'overview_description': 'Gérez votre installation MindRoot depuis ce tableau de bord.',
+            'button_create': 'Créer Nouveau',
+            'button_refresh': 'Actualiser les Données'
+        }
+    }
+    
+    for lang, translations in admin_translations.items():
+        result = await set_translations(lang, translations)
+        print(f"   {result}")
+    
+    # Test the complete workflow
+    print("\n3. Testing complete localization workflow...")
+    
+    for lang in ['en', 'es', 'fr']:
+        print(f"\n   Testing {lang.upper()} localization:")
+        
+        # Set language
+        set_language_for_request(lang)
+        current = get_current_language_from_request()
+        fallback = get_fallback_language(current)
+        
+        # Translate template
+        translated = replace_placeholders(template_content, fallback)
+        
+        # Extract and show key elements
+        lines = translated.split('\n')
+        title = next((line for line in lines if '<title>' in line), '').strip()
+        header = next((line for line in lines if '<h1>' in line), '').strip()
+        
+        print(f"     Language: {current} -> Fallback: {fallback}")
+        print(f"     {title}")
+        print(f"     {header}")
+    
+    print("\n✅ File integration tests completed!")
+
+async def main():
+    """Run all enhanced tests."""
+    print("=" * 60)
+    print("MindRoot l8n Plugin - Enhanced Testing Suite")
+    print("=" * 60)
+    
+    await test_language_detection()
+    await test_integrated_translation()
+    await test_file_integration()
+    
+    print("\n" + "=" * 60)
+    print("✅ All enhanced tests completed successfully!")
+    print("=" * 60)
+
+if __name__ == "__main__":
+    asyncio.run(main())

mindroot/coreplugins/l8n/test_l8n.py

@@ -0,0 +1,95 @@
+#!/usr/bin/env python3
+"""
+Simple test script for the l8n localization plugin.
+
+This script tests the basic functionality of the localization commands
+without requiring the full MindRoot environment.
+"""
+
+import asyncio
+import sys
+from pathlib import Path
+
+# Add the current directory to Python path for imports
+sys.path.insert(0, str(Path(__file__).parent))
+
+from mod import (
+    write_localized_file,
+    append_localized_file,
+    set_translations,
+    get_translations,
+    list_localized_files,
+    replace_placeholders
+)
+
+async def test_basic_functionality():
+    """Test the basic l8n functionality."""
+    print("Testing MindRoot l8n Plugin...\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}")
+    
+    print("\n✅ All tests completed!")
+
+if __name__ == "__main__":
+    asyncio.run(test_basic_functionality())