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

mindroot/lib/plugins/manifest.py

@@ -1,23 +1,242 @@
 import json
 import os
 import shutil
+import tempfile
+import logging
 from datetime import datetime
+from pathlib import Path
 
 # Central definition of manifest file location
 MANIFEST_FILE = 'data/plugin_manifest.json'
 
+# Setup logging
+logger = logging.getLogger(__name__)
+
+def _get_absolute_paths():
+    """Get absolute paths for all manifest-related files.
+    
+    Returns:
+        tuple: (manifest_abs_path, root_manifest_abs_path, data_dir_abs_path)
+    """
+    cwd = os.getcwd()
+    manifest_abs_path = os.path.abspath(os.path.join(cwd, MANIFEST_FILE))
+    root_manifest_abs_path = os.path.abspath(os.path.join(cwd, 'plugin_manifest.json'))
+    data_dir_abs_path = os.path.abspath(os.path.join(cwd, 'data'))
+    
+    return manifest_abs_path, root_manifest_abs_path, data_dir_abs_path
+
+def _backup_manifest(manifest_path):
+    """Create a backup of the existing manifest file.
+    
+    Args:
+        manifest_path (str): Absolute path to the manifest file
+        
+    Returns:
+        str: Path to backup file, or None if backup failed
+    """
+    if not os.path.exists(manifest_path):
+        return None
+        
+    try:
+        timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
+        backup_path = f"{manifest_path}.backup_{timestamp}"
+        shutil.copy2(manifest_path, backup_path)
+        logger.info(f"Created manifest backup: {backup_path}")
+        return backup_path
+    except Exception as e:
+        logger.error(f"Failed to create manifest backup: {e}")
+        return None
+
+def _atomic_write_manifest(manifest_path, manifest_data):
+    """Atomically write manifest data to file.
+    
+    Args:
+        manifest_path (str): Absolute path to the manifest file
+        manifest_data (dict): Manifest data to write
+        
+    Returns:
+        bool: True if successful, False otherwise
+    """
+    try:
+        # Ensure directory exists
+        os.makedirs(os.path.dirname(manifest_path), exist_ok=True)
+        
+        # Write to temporary file first
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.tmp', 
+                                       dir=os.path.dirname(manifest_path), 
+                                       delete=False) as tmp_file:
+            json.dump(manifest_data, tmp_file, indent=2)
+            tmp_path = tmp_file.name
+        
+        # Atomic move to final location
+        shutil.move(tmp_path, manifest_path)
+        logger.debug(f"Atomically wrote manifest to: {manifest_path}")
+        return True
+        
+    except Exception as e:
+        logger.error(f"Failed to atomically write manifest: {e}")
+        # Clean up temp file if it exists
+        try:
+            if 'tmp_path' in locals() and os.path.exists(tmp_path):
+                os.unlink(tmp_path)
+        except:
+            pass
+        return False
+
+def _validate_manifest(manifest_path):
+    """Validate that a manifest file exists and contains valid JSON.
+    
+    Args:
+        manifest_path (str): Absolute path to the manifest file
+        
+    Returns:
+        tuple: (is_valid, manifest_data_or_none)
+    """
+    if not os.path.exists(manifest_path):
+        return False, None
+        
+    try:
+        with open(manifest_path, 'r') as f:
+            manifest_data = json.load(f)
+            
+        # Basic structure validation
+        if not isinstance(manifest_data, dict):
+            logger.warning(f"Manifest is not a dict: {manifest_path}")
+            return False, None
+            
+        if 'plugins' not in manifest_data:
+            logger.warning(f"Manifest missing 'plugins' key: {manifest_path}")
+            return False, None
+            
+        return True, manifest_data
+        
+    except json.JSONDecodeError as e:
+        logger.warning(f"Manifest contains invalid JSON: {manifest_path} - {e}")
+        return False, None
+    except Exception as e:
+        logger.error(f"Error validating manifest: {manifest_path} - {e}")
+        return False, None
+
+def _migrate_manifest_from_root():
+    """Migrate manifest from root directory to data directory if needed.
+    
+    This function consolidates the migration logic and uses absolute paths.
+    
+    Returns:
+        bool: True if migration was successful or not needed, False if failed
+    """
+    manifest_abs_path, root_manifest_abs_path, data_dir_abs_path = _get_absolute_paths()
+    
+    logger.debug(f"Checking for manifest migration:")
+    logger.debug(f"  Target: {manifest_abs_path}")
+    logger.debug(f"  Source: {root_manifest_abs_path}")
+    
+    # If target already exists and is valid, no migration needed
+    is_valid, _ = _validate_manifest(manifest_abs_path)
+    if is_valid:
+        logger.debug(f"Valid manifest already exists at: {manifest_abs_path}")
+        return True
+    
+    # If target exists but is invalid, back it up
+    if os.path.exists(manifest_abs_path):
+        logger.warning(f"Invalid manifest found at {manifest_abs_path}, backing up")
+        _backup_manifest(manifest_abs_path)
+    
+    # Check if source manifest exists and is valid
+    is_valid, manifest_data = _validate_manifest(root_manifest_abs_path)
+    if is_valid:
+        logger.info(f"Migrating manifest from {root_manifest_abs_path} to {manifest_abs_path}")
+        
+        # Ensure data directory exists
+        os.makedirs(data_dir_abs_path, exist_ok=True)
+        
+        # Atomic write to new location
+        if _atomic_write_manifest(manifest_abs_path, manifest_data):
+            # Remove old file only after successful write
+            try:
+                os.unlink(root_manifest_abs_path)
+                logger.info(f"Successfully migrated manifest and removed old file")
+                return True
+            except Exception as e:
+                logger.warning(f"Manifest migrated but failed to remove old file: {e}")
+                return True
+        else:
+            logger.error(f"Failed to write migrated manifest")
+            return False
+    
+    logger.debug(f"No valid manifest found to migrate from {root_manifest_abs_path}")
+    return True  # Not an error - just no migration needed
+
+def create_default_plugin_manifest():
+    """Create a new default manifest file.
+    
+    This function first attempts migration, then creates from default template if needed.
+    """
+    manifest_abs_path, _, data_dir_abs_path = _get_absolute_paths()
+    
+    logger.info(f"Creating default plugin manifest at: {manifest_abs_path}")
+    
+    # First attempt migration from root directory
+    if _migrate_manifest_from_root():
+        # Check if migration was successful
+        is_valid, _ = _validate_manifest(manifest_abs_path)
+        if is_valid:
+            logger.info(f"Manifest successfully migrated from root directory")
+            return
+    
+    # Migration didn't work, create from default template
+    logger.info(f"Creating manifest from default template")
+    
+    # Backup existing file if it exists (even if invalid)
+    if os.path.exists(manifest_abs_path):
+        _backup_manifest(manifest_abs_path)
+    
+    try:
+        # Read default template
+        default_manifest_path = os.path.join(os.path.dirname(__file__), 'default_plugin_manifest.json')
+        with open(default_manifest_path, 'r') as f:
+            default_manifest = json.load(f)
+        
+        # Ensure data directory exists
+        os.makedirs(data_dir_abs_path, exist_ok=True)
+        
+        # Atomic write
+        if _atomic_write_manifest(manifest_abs_path, default_manifest):
+            logger.info(f"Successfully created default manifest")
+        else:
+            logger.error(f"Failed to create default manifest")
+            raise Exception("Failed to write default manifest")
+            
+    except Exception as e:
+        logger.error(f"Failed to create default manifest: {e}")
+        raise
+
 def load_plugin_manifest():
     """Load the plugin manifest file.
     
     Returns:
         dict: The manifest data structure
     """
-    abs_path = os.path.abspath(MANIFEST_FILE)
-    if not os.path.exists(MANIFEST_FILE):
-        create_default_plugin_manifest()
-
-    with open(MANIFEST_FILE, 'r') as f:
-        return json.load(f)
+    manifest_abs_path, _, _ = _get_absolute_paths()
+    
+    # Validate existing manifest
+    is_valid, manifest_data = _validate_manifest(manifest_abs_path)
+    
+    if is_valid:
+        logger.debug(f"Loaded valid manifest from: {manifest_abs_path}")
+        return manifest_data
+    
+    # Manifest is missing or invalid, create default
+    logger.warning(f"Manifest missing or invalid at {manifest_abs_path}, creating default")
+    create_default_plugin_manifest()
+    
+    # Load the newly created manifest
+    is_valid, manifest_data = _validate_manifest(manifest_abs_path)
+    if is_valid:
+        return manifest_data
+    else:
+        logger.error(f"Failed to create valid default manifest")
+        raise Exception("Could not load or create valid plugin manifest")
 
 def save_plugin_manifest(manifest):
     """Save the plugin manifest file.
@@ -25,8 +244,17 @@ def save_plugin_manifest(manifest):
     Args:
         manifest (dict): The manifest data structure to save
     """
-    with open(MANIFEST_FILE, 'w') as f:
-        json.dump(manifest, f, indent=2)
+    manifest_abs_path, _, _ = _get_absolute_paths()
+    
+    # Backup existing manifest before saving
+    _backup_manifest(manifest_abs_path)
+    
+    # Atomic write
+    if not _atomic_write_manifest(manifest_abs_path, manifest):
+        logger.error(f"Failed to save plugin manifest")
+        raise Exception("Failed to save plugin manifest")
+    
+    logger.debug(f"Successfully saved manifest to: {manifest_abs_path}")
 
 def update_plugin_manifest(plugin_name, source, source_path, remote_source=None, version="0.0.1", metadata=None):
     """Update or add a plugin entry in the manifest.
@@ -67,22 +295,6 @@ def update_plugin_manifest(plugin_name, source, source_path, remote_source=None,
     
     save_plugin_manifest(manifest)
 
-def create_default_plugin_manifest():
-    """Create a new default manifest file."""
-    # First check if there's an existing manifest in the root directory
-    old_manifest_path = 'plugin_manifest.json'
-    if os.path.exists(old_manifest_path):
-        # Move existing manifest from root to data directory
-        os.makedirs(os.path.dirname(MANIFEST_FILE), exist_ok=True)
-        shutil.move(old_manifest_path, MANIFEST_FILE)
-    else:
-        # No existing manifest, create from default template
-        # read from default_plugin_manifest.json in same dir as this file
-        default_manifest_path = os.path.join(os.path.dirname(__file__), 'default_plugin_manifest.json')
-        with open(default_manifest_path, 'r') as f:
-            default_manifest = json.load(f)
-        os.makedirs(os.path.dirname(MANIFEST_FILE), exist_ok=True)
-        save_plugin_manifest(default_manifest)
 def toggle_plugin_state(plugin_name, enabled):
     """Toggle a plugin's enabled state.
     

mindroot/lib/providers/commands.py

@@ -1,6 +1,7 @@
 import inspect
 import os
 from . import ProviderManager
+from mindroot.lib.utils.debug import debug_box
 
 command_manager = ProviderManager()
 
@@ -14,7 +15,8 @@ def command(*, flags=[]):
             raise ValueError("Cannot determine module of function")
 
         module_name = os.path.basename(os.path.dirname(module.__file__))
- 
+        if module_name == 'l8n':
+            debug_box("registering l8n command!" + name)
         command_manager.register_function(name, module_name, func, signature, docstring, flags)
         return func
     return decorator

mindroot/lib/route_decorators.py

@@ -9,23 +9,23 @@ public_routes: Set[str] = set()
 public_static: Set[str] = set()
 
 def public_route():
-    # include route path/function name
-    print("public_route decorator called", public_routes)
+    """Decorator to mark a route as public (no authentication required)"""
     def decorator(func):
         @wraps(func)
         async def wrapper(*args, **kwargs):
-            print("public route !!!!!!!!!!!")
+            # Mark the request as a public route for any middleware that needs to know
             request: Request = next((arg for arg in args if isinstance(arg, Request)), None)
             if request:
                 request.state.public_route = True
             return await func(*args, **kwargs)
+        
+        # Mark the function as a public route so the startup hook can find it
         wrapper.__public_route__ = True
-        public_routes.add(func.__name__)
-        print("wrapper.__public_route__", wrapper.__public_route__)
         return wrapper
     return decorator
 
 def add_public_static(path_start):
+    """Add a path prefix to the public static routes"""
     public_static.add(path_start)
 
 # New role-based dependency functions

mindroot/lib/templates.py

@@ -4,12 +4,133 @@ from jinja2 import Environment, FileSystemLoader, ChoiceLoader
 from .plugins import list_enabled, get_plugin_path
 from .parent_templates import get_parent_templates_env
 import traceback
+import sys
+
+# Import l8n translation functions
+try:
+    from mindroot.coreplugins.l8n.utils import replace_placeholders, get_localized_file_path, extract_plugin_root
+    from mindroot.coreplugins.l8n.mod import *
+    from mindroot.coreplugins.l8n.middleware import get_request_language
+    from mindroot.coreplugins.l8n.language_detection import get_fallback_language
+    L8N_AVAILABLE = True
+except ImportError as e:
+    trace = traceback.format_exc()
+    print(f"L8n not available: {e} \n{trace}")
+    L8N_AVAILABLE = False
+    sys.exit(1)
 
 # TODO: get_parent_templates_env(plugins):
 # jinja2 environment containing only 1 template per plugin file name,
 # the first one that is found from plugins with that name,
 # need to look at how jinja2 loaders work
 
+def get_current_language():
+    """Get the current language for translation."""
+    if not L8N_AVAILABLE:
+        return 'en'
+    
+    try:
+        # Try to get language from request context
+        lang = get_request_language()
+        return get_fallback_language(lang) if lang else 'en'
+    except Exception as e:
+        print(f"Error getting current language: {e}")
+        return 'en'
+
+def apply_translations_to_content(content, template_path=None):
+    """Apply l8n translations to template content.
+    
+    Args:
+        content (str): Template content with __TRANSLATE_key__ placeholders
+        template_path (str): Path to the template file for plugin context
+        
+    Returns:
+        str or None: Content with translations applied, or None if translations are incomplete
+    """
+    if not L8N_AVAILABLE or not content:
+        return content
+    
+    try:
+        current_language = get_current_language()
+        
+        # If we have a template path, use it for plugin context
+        if template_path:
+            # Check if translation failed (missing translations)
+            translated = replace_placeholders(content, current_language, template_path)
+            if translated is None:
+                return None  # Signal that translations are incomplete
+            return translated
+        else:
+            # Fallback: try to replace without plugin context
+            return replace_placeholders(content, current_language)
+    except Exception as e:
+        print(f"Error applying translations: {e}")
+        return content
+
+def check_for_localized_template(template_path):
+    """Check if a localized version of a template exists.
+    
+    Args:
+        template_path (str): Original template path
+        
+    Returns:
+        str: Path to localized template if it exists, None otherwise
+    """
+    if not L8N_AVAILABLE:
+        return None
+        
+    try:
+        localized_path = get_localized_file_path(template_path)
+        if localized_path.exists():
+            return str(localized_path)
+    except Exception as e:
+        print(f"Error checking for localized template: {e}")
+    
+    return None
+
+def load_template_with_translation(template_path):
+    """Load a template and apply translations if available and complete.
+    
+    If translations are missing for the current language, this function
+    will fall back to serving the original template to avoid showing
+    __TRANSLATE_key__ placeholders to users.
+    
+    Args:
+        template_path (str): Path to the template file
+        
+    Returns:
+        str: Template content with translations applied, or original content
+             if translations are incomplete for the current language
+    """
+    # First check for localized version
+    localized_path = check_for_localized_template(template_path)
+    
+    if localized_path:
+        # Load localized template and apply translations
+        try:
+            with open(localized_path, 'r', encoding='utf-8') as f:
+                content = f.read()
+            
+            # Apply translations - if None is returned, translations are incomplete
+            translated_content = apply_translations_to_content(content, localized_path)
+            if translated_content is None:
+                # Fall back to original template
+                print(f"L8n: Falling back to original template due to missing translations: {template_path}")
+                with open(template_path, 'r', encoding='utf-8') as f:
+                    return f.read()
+            return translated_content
+        except Exception as e:
+            print(f"Error loading localized template {localized_path}: {e}")
+    
+    # Fallback to original template
+    try:
+        with open(template_path, 'r', encoding='utf-8') as f:
+            content = f.read()
+        return content  # Don't apply translations to original templates
+    except Exception as e:
+        print(f"Error loading template {template_path}: {e}")
+        return ""
+
 def setup_template_environment(plugins=None):
     """Set up Jinja2 environment with multiple template paths.
     
@@ -106,7 +227,6 @@ async def find_parent_template(page_name, plugins):
                                 return rel_path
                     return alt_path
     return None
-
 async def find_plugin_template(page_name, plugins):
     """Find a template in a plugin's templates directory.
     
@@ -148,7 +268,7 @@ async def find_plugin_template(page_name, plugins):
     return None, None
 
 async def load_plugin_templates(page_name, plugins):
-    """Load templates from plugins.
+    """Load templates from plugins with translation support.
     
     Args:
         page_name (str): Name of the template page
@@ -180,9 +300,11 @@ async def load_plugin_templates(page_name, plugins):
             
             for path in inject_paths:
                 if os.path.exists(path):
-                    with open(path) as f:
+                    # Load template content with translation support
+                    content = load_template_with_translation(path)
+                    if content:
                         #print(f"Found inject template at: {path}")
-                        templates.append({'type': 'inject', 'template': env.from_string(f.read())})
+                        templates.append({'type': 'inject', 'template': env.from_string(content)})
                         break
                 #else:
                 #
@@ -198,9 +320,11 @@ async def load_plugin_templates(page_name, plugins):
             
             for path in override_paths:
                 if os.path.exists(path):
-                    with open(path) as f:
+                    # Load template content with translation support
+                    content = load_template_with_translation(path)
+                    if content:
                         #print(f"Found override template at: {path}")
-                        templates.append({'type': 'override', 'template': env.from_string(f.read())})
+                        templates.append({'type': 'override', 'template': env.from_string(content)})
                         break
                         
         except Exception as e:
@@ -232,7 +356,7 @@ async def collect_content(template, blocks, template_type, data):
     return content
 
 async def render_combined_template(page_name, plugins, context):
-    """Render combined template with injections and overrides.
+    """Render combined template with injections and overrides, including translation support.
     
     Args:
         page_name (str): Name of the template page
@@ -242,7 +366,37 @@ async def render_combined_template(page_name, plugins, context):
     Returns:
         str: Rendered HTML
     """
-    parent_template = parent_env.get_template(f"{page_name}.jinja2")
+    # Load parent template with translation support
+    parent_template = None
+    parent_template_path = None
+    
+    # Find the parent template file path
+    # We need to search through the parent_env loaders to find the actual file
+    for loader in parent_env.loader.loaders:
+        for template_dir in loader.searchpath:
+            potential_path = os.path.join(template_dir, f"{page_name}.jinja2")
+            if os.path.exists(potential_path):
+                parent_template_path = potential_path
+                break
+        if parent_template_path:
+            break
+    
+    if parent_template_path:
+        # Load the parent template with translation support
+        parent_content = load_template_with_translation(parent_template_path)
+        if parent_content:
+            # Create a template object from the translated content
+            parent_template = env.from_string(parent_content)
+            # We need to preserve the original template name for Jinja2 inheritance
+            parent_template.name = f"{page_name}.jinja2"
+            parent_template.filename = parent_template_path
+        else:
+            # Fallback to loading without translation if something went wrong
+            parent_template = parent_env.get_template(f"{page_name}.jinja2")
+    else:
+        # Fallback to original method if we can't find the file path
+        parent_template = parent_env.get_template(f"{page_name}.jinja2")
+    
     print(f"parent_template", parent_template)
     child_templates = await load_plugin_templates(page_name, plugins)
     parent_blocks = parent_template.blocks.keys()
@@ -307,7 +461,7 @@ async def render_combined_template(page_name, plugins, context):
     return rendered_html
 
 async def render_direct_template(template_path, context):
-    """Render a template directly without combining with a parent template.
+    """Render a template directly without combining with a parent template, with translation support.
     
     Args:
         template_path (str): Path to the template
@@ -320,6 +474,25 @@ async def render_direct_template(template_path, context):
     context = context or {}
     
     try:
+        # Check if we need to load with translation support
+        template_full_path = None
+        for loader in env.loader.loaders:
+            for template_dir in loader.searchpath:
+                potential_path = os.path.join(template_dir, template_path)
+                if os.path.exists(potential_path):
+                    template_full_path = potential_path
+                    break
+            if template_full_path:
+                break
+        
+        if template_full_path:
+            # Load with translation support
+            content = load_template_with_translation(template_full_path)
+            if content:
+                template = env.from_string(content)
+                return template.render(**context)
+        
+        # Fallback to normal template loading
         template = env.get_template(template_path)
         return template.render(**context)
     except Exception as e:
@@ -327,7 +500,7 @@ async def render_direct_template(template_path, context):
         return f"<h1>Error rendering template</h1><p>{str(e)}</p>"
 
 async def render(page_name, context):
-    """Render a template with plugin injections and overrides.
+    """Render a template with plugin injections, overrides, and translation support.
     If no parent template exists, tries to render a template directly from a plugin.
     
     Args:
@@ -368,4 +541,3 @@ async def render(page_name, context):
         trace = traceback.format_exc()
         print(f"Error rendering {page_name}: {e}\n\n{trace}")
         return f"<h1>Error Rendering Page</h1><p>{str(e)}</p><pre>{trace}</pre>"
-

mindroot/lib/utils/merge_arrays.py

@@ -141,7 +141,7 @@ def merge_json_arrays(data, partial=False):
                     pass
     
     # Combine all parsed arrays into a single list
-    if arrays:
+    if len(arrays) > 0:
         return list(chain.from_iterable(arrays))
     
     # If all else fails, try the original json.loads as fallback