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

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

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