mxx-tool 0.1.0__py3-none-any.whl

mxx/cfg_tool/__main__.py

@@ -0,0 +1,14 @@
+import click
+
+
+
+@click.group()
+def main():
+    """MXX Configuration Tool"""
+    pass
+
+from mxx.cfg_tool import app # noqa
+from mxx.cfg_tool.cfg import cfg # noqa
+main.add_command(app)
+main.add_command(cfg)
+

mxx/cfg_tool/app.py

@@ -0,0 +1,117 @@
+import click
+import uuid
+from pathlib import Path
+from pprint import pprint
+from .registry import load_apps_registry, save_apps_registry, get_apps_registry_paths, get_app_by_name
+
+@click.group()
+def app():
+    """MXX App Registry Tool"""
+    pass
+
+@app.command()
+@click.argument("path", help="Path to the application folder")
+@click.argument("app", help="Executable name relative to the path")
+@click.argument("cfgroute", help="Configuration route")
+@click.option("-cfgow","--cfgoverwrite", multiple=True, help="Configuration overrides in KEY=VALUE format")
+@click.option("--alias", multiple=True, help="Aliases for the application")
+@click.option("-cfge", "--cfgexclude", multiple=True, help="Configuration keys to exclude")
+def register(path, app, cfgroute, cfgoverwrite, alias, cfgexclude):
+    """Register an application"""
+    # Load existing registries
+    apps_index, aliases_index = load_apps_registry()
+    
+    # Generate a simple UID
+    simple_uid = str(uuid.uuid4())
+    
+    # Parse configuration overrides into a dictionary
+    cfgow_dict = {}
+    for override in cfgoverwrite:
+        if "=" in override:
+            key, value = override.split("=", 1)
+            cfgow_dict[key] = value
+        else:
+            click.echo(f"Warning: Invalid configuration override format '{override}'. Expected KEY=VALUE", err=True)
+    
+    # Create the app entry
+    app_entry = {
+        "path": str(Path(path).resolve()),
+        "app": app,
+        "cfgroute": cfgroute,
+        "cfgow": cfgow_dict
+    }
+    
+    # Add configuration exclusions if provided
+    if cfgexclude:
+        app_entry["cfge"] = list(cfgexclude)
+    
+    # Add to apps index
+    apps_index[simple_uid] = app_entry
+    
+    # Handle aliases
+    if alias:
+        # Use provided aliases
+        for a in alias:
+            aliases_index[a] = simple_uid
+    else:
+        # Use app executable name if no aliases provided
+        app_name = Path(app).stem
+        aliases_index[app_name] = simple_uid
+    
+    # Save both registries
+    save_apps_registry(apps_index, aliases_index)
+    
+    # Get registry location for feedback
+    apps_index_path, _ = get_apps_registry_paths()
+    apps_dir = apps_index_path.parent
+    
+    # Provide feedback
+    click.echo("Successfully registered application:")
+    click.echo(f"  UID: {simple_uid}")
+    click.echo(f"  Path: {app_entry['path']}")
+    click.echo(f"  App: {app_entry['app']}")
+    click.echo(f"  Config route: {cfgroute}")
+    if cfgow_dict:
+        click.echo(f"  Config overrides: {cfgow_dict}")
+    if cfgexclude:
+        click.echo(f"  Config exclusions: {list(cfgexclude)}")
+    
+    if alias:
+        click.echo(f"  Aliases: {', '.join(alias)}")
+    else:
+        click.echo(f"  Alias: {Path(app).stem}")
+    
+    click.echo(f"  Registry location: {apps_dir}")
+
+
+@app.command()
+@click.argument("name", required=True)
+def get(name):
+    """Get application configuration by name/alias"""
+    app_info = get_app_by_name(name)
+    
+    if app_info:
+        click.echo(f"Configuration for '{name}':")
+        pprint(app_info)
+    else:
+        click.echo(f"Error: Application '{name}' not found in registry", err=True)
+
+
+@app.command()
+def open_folder():
+    """Open the apps registry folder"""
+    import subprocess
+    
+    apps_index_path, _ = get_apps_registry_paths()
+    apps_dir = apps_index_path.parent
+    
+    # Ensure directory exists
+    apps_dir.mkdir(parents=True, exist_ok=True)
+    
+    try:
+        subprocess.run(["explorer", str(apps_dir)], check=True)
+        click.echo(f"Opened registry folder: {apps_dir}")
+    except subprocess.CalledProcessError as e:
+        click.echo(f"Error opening folder: {e}", err=True)
+    except FileNotFoundError:
+        click.echo(f"Could not open folder. Path: {apps_dir}", err=True)

mxx/cfg_tool/cfg.py

@@ -0,0 +1,184 @@
+import click
+import shutil
+from datetime import datetime
+from pathlib import Path
+from .registry import get_app_by_name, load_json_config, save_json_config
+from mxx.utils.nested import nested_get, nested_set, nested_remove
+
+
+@click.group()
+def cfg():
+    """Configuration Export/Import Tools"""
+    pass
+
+
+@cfg.command()
+@click.argument("app_name")
+@click.option("--output", "-o", help="Output name (default: uses timestamp)")
+def export(app_name, output):
+    """Export application configuration folder"""
+    # Get app info
+    app_info = get_app_by_name(app_name)
+    if not app_info:
+        click.echo(f"Error: Application '{app_name}' not found in registry", err=True)
+        return
+    
+    app_config = app_info["config"]
+    uid = app_info["uid"]
+    
+    # Get the source config folder path
+    config_folder = Path(app_config["path"]) / app_config["cfgroute"]
+    if not config_folder.exists():
+        click.echo(f"Error: Config folder not found at {config_folder}", err=True)
+        return
+    
+    if not config_folder.is_dir():
+        click.echo(f"Error: {config_folder} is not a directory", err=True)
+        return
+    
+    # Determine output location
+    exports_base = Path.home() / ".mxx" / "exports" / uid
+    exports_base.mkdir(parents=True, exist_ok=True)
+    
+    if output:
+        output_dir = exports_base / output
+    else:
+        # Use timestamp as folder name when no output name specified
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        output_dir = exports_base / timestamp
+    
+    # Copy the entire config folder
+    if output_dir.exists():
+        shutil.rmtree(output_dir)
+    shutil.copytree(config_folder, output_dir)
+    
+    # Process all JSON files in the copied folder to apply exclusions and remove overrides
+    processed_files = []
+    for json_file in output_dir.rglob("*.json"):
+        try:
+            config_data = load_json_config(json_file)
+            
+            # Apply exclusions (remove cfge keys)
+            if "cfge" in app_config:
+                for exclude_key in app_config["cfge"]:
+                    nested_remove(config_data, exclude_key)
+            
+            # Apply overrides (remove cfgow keys)
+            if "cfgow" in app_config:
+                for override_key in app_config["cfgow"]:
+                    nested_remove(config_data, override_key)
+            
+            # Save the processed config
+            save_json_config(json_file, config_data)
+            processed_files.append(json_file.name)
+        except Exception as e:
+            click.echo(f"Warning: Could not process {json_file.name}: {e}", err=True)
+    
+    click.echo(f"Exported configuration folder for '{app_name}':")
+    click.echo(f"  Source: {config_folder}")
+    click.echo(f"  Output: {output_dir}")
+    click.echo(f"  Processed {len(processed_files)} JSON files")
+    click.echo(f"  Excluded {len(app_config.get('cfge', []))} key patterns")
+    click.echo(f"  Removed {len(app_config.get('cfgow', {}))} override key patterns")
+
+
+@cfg.command()
+@click.argument("app_name")
+@click.argument("import_folder")
+def import_config(app_name, import_folder):
+    """Import and merge configuration folder for an application"""
+    # Get app info
+    app_info = get_app_by_name(app_name)
+    if not app_info:
+        click.echo(f"Error: Application '{app_name}' not found in registry", err=True)
+        return
+    
+    app_config = app_info["config"]
+    
+    # Get the target config folder path
+    target_config_folder = Path(app_config["path"]) / app_config["cfgroute"]
+    
+    # Resolve import folder path - first try relative to app's exports directory
+    uid = app_info["uid"]
+    app_exports_dir = Path.home() / ".mxx" / "exports" / uid
+    
+    import_path = Path(import_folder)
+    
+    # If it's not an absolute path, try relative to app's exports directory first
+    if not import_path.is_absolute():
+        relative_import_path = app_exports_dir / import_folder
+        if relative_import_path.exists() and relative_import_path.is_dir():
+            import_path = relative_import_path
+        # Otherwise keep the original path (which might be relative to current directory)
+    
+    if not import_path.exists():
+        click.echo(f"Error: Import folder not found at {import_path}", err=True)
+        if not import_path.is_absolute():
+            click.echo(f"  Also tried: {app_exports_dir / import_folder}", err=True)
+        return
+    
+    if not import_path.is_dir():
+        click.echo(f"Error: {import_path} is not a directory", err=True)
+        return
+    
+    # Ensure target config folder exists
+    target_config_folder.mkdir(parents=True, exist_ok=True)
+    
+    # Process all JSON files in the import folder
+    processed_files = []
+    preserved_counts = {}
+    
+    for import_json_file in import_path.rglob("*.json"):
+        try:
+            # Get relative path to maintain folder structure
+            rel_path = import_json_file.relative_to(import_path)
+            target_json_file = target_config_folder / rel_path
+            
+            # Ensure target directory exists
+            target_json_file.parent.mkdir(parents=True, exist_ok=True)
+            
+            # Load import data
+            import_config_data = load_json_config(import_json_file)
+            
+            # Load existing target config or create empty
+            if target_json_file.exists():
+                target_config = load_json_config(target_json_file)
+            else:
+                target_config = {}
+            
+            # Preserve excluded keys (cfge) from target
+            preserved_values = {}
+            if "cfge" in app_config:
+                for exclude_key in app_config["cfge"]:
+                    value = nested_get(target_config, exclude_key)
+                    if value is not None:
+                        preserved_values[exclude_key] = value
+            
+            # Update target config with imported data
+            target_config.update(import_config_data)
+            
+            # Restore preserved excluded keys
+            for key, value in preserved_values.items():
+                nested_set(target_config, key, value)
+            
+            # Apply overrides (cfgow)
+            if "cfgow" in app_config:
+                for override_key, override_value in app_config["cfgow"].items():
+                    nested_set(target_config, override_key, override_value)
+            
+            # Save updated config
+            save_json_config(target_json_file, target_config)
+            processed_files.append(rel_path)
+            preserved_counts[str(rel_path)] = len(preserved_values)
+            
+        except Exception as e:
+            click.echo(f"Warning: Could not process {import_json_file.name}: {e}", err=True)
+    
+    total_preserved = sum(preserved_counts.values())
+    
+    click.echo(f"Imported configuration folder for '{app_name}':")
+    click.echo(f"  Import source: {import_path}")
+    click.echo(f"  Target: {target_config_folder}")
+    click.echo(f"  Processed {len(processed_files)} JSON files")
+    click.echo(f"  Preserved {total_preserved} excluded keys across all files")
+    click.echo(f"  Applied {len(app_config.get('cfgow', {}))} override patterns to all files")

mxx/cfg_tool/registry.py

@@ -0,0 +1,118 @@
+"""
+Configuration file utilities for MXX cfg_tool.
+
+Provides independent components for loading and saving JSON configuration files.
+"""
+
+import json
+from pathlib import Path
+from typing import Dict, Any
+
+
+def load_json_config(file_path: Path) -> Dict[str, Any]:
+    """
+    Load JSON configuration from file.
+    
+    Args:
+        file_path: Path to the JSON file
+        
+    Returns:
+        Dictionary containing the loaded configuration
+        
+    Raises:
+        FileNotFoundError: If the file doesn't exist
+        json.JSONDecodeError: If the file contains invalid JSON
+    """
+    if not file_path.exists():
+        return {}
+    
+    with open(file_path, 'r', encoding='utf-8') as f:
+        return json.load(f)
+
+
+def save_json_config(file_path: Path, config: Dict[str, Any]) -> None:
+    """
+    Save configuration to JSON file.
+    
+    Args:
+        file_path: Path where to save the JSON file
+        config: Dictionary to save as JSON
+        
+    Raises:
+        OSError: If the file cannot be written
+    """
+    # Ensure parent directory exists
+    file_path.parent.mkdir(parents=True, exist_ok=True)
+    
+    with open(file_path, 'w', encoding='utf-8') as f:
+        json.dump(config, f, indent=2, ensure_ascii=False)
+
+
+def get_apps_registry_paths() -> tuple[Path, Path]:
+    """
+    Get the standard paths for apps registry files.
+    
+    Returns:
+        Tuple of (apps_index_path, aliases_index_path)
+    """
+    apps_dir = Path.home() / ".mxx" / "apps"
+    apps_index_path = apps_dir / "apps.json"
+    aliases_index_path = apps_dir / "aliases.json"
+    
+    return apps_index_path, aliases_index_path
+
+
+def load_apps_registry() -> tuple[Dict[str, Any], Dict[str, str]]:
+    """
+    Load both apps and aliases registries.
+    
+    Returns:
+        Tuple of (apps_index, aliases_index)
+    """
+    apps_index_path, aliases_index_path = get_apps_registry_paths()
+    
+    apps_index = load_json_config(apps_index_path)
+    aliases_index = load_json_config(aliases_index_path)
+    
+    return apps_index, aliases_index
+
+
+def save_apps_registry(apps_index: Dict[str, Any], aliases_index: Dict[str, str]) -> None:
+    """
+    Save both apps and aliases registries.
+    
+    Args:
+        apps_index: Apps registry dictionary
+        aliases_index: Aliases registry dictionary
+    """
+    apps_index_path, aliases_index_path = get_apps_registry_paths()
+    
+    save_json_config(apps_index_path, apps_index)
+    save_json_config(aliases_index_path, aliases_index)
+
+
+def get_app_by_name(name: str) -> Dict[str, Any] | None:
+    """
+    Get application configuration by name/alias.
+    
+    Args:
+        name: Application name or alias
+        
+    Returns:
+        Dictionary containing app info with keys: name, uid, config
+        Returns None if app not found
+    """
+    apps_index, aliases_index = load_apps_registry()
+    
+    # Check if name is an alias
+    if name in aliases_index:
+        uid = aliases_index[name]
+        if uid in apps_index:
+            app_config = apps_index[uid]
+            return {
+                "name": name,
+                "uid": uid,
+                "config": app_config
+            }
+    
+    return None

mxx/client/__init__.py

@@ -0,0 +1,9 @@
+"""
+MXX Client Package
+
+Command-line client for interacting with MXX Scheduler Server.
+"""
+
+from mxx.client.client import cli
+
+__all__ = ['cli']