mcli-framework 7.10.0__py3-none-any.whl → 7.10.2__py3-none-any.whl

mcli/lib/custom_commands.py

@@ -107,15 +107,25 @@ class CustomCommandManager:
         """
         Load all custom commands from the commands directory.
 
+        Automatically filters out test commands (starting with 'test_' or 'test-')
+        unless MCLI_INCLUDE_TEST_COMMANDS=true is set.
+
         Returns:
             List of command data dictionaries
         """
         commands = []
+        include_test = os.environ.get('MCLI_INCLUDE_TEST_COMMANDS', 'false').lower() == 'true'
+
         for command_file in self.commands_dir.glob("*.json"):
             # Skip the lockfile
             if command_file.name == "commands.lock.json":
                 continue
 
+            # Skip test commands unless explicitly included
+            if not include_test and command_file.stem.startswith(('test_', 'test-')):
+                logger.debug(f"Skipping test command: {command_file.name}")
+                continue
+
             command_data = self.load_command(command_file)
             if command_data:
                 commands.append(command_data)

mcli/lib/optional_deps.py

@@ -0,0 +1,240 @@
+"""
+Utilities for graceful handling of optional dependencies.
+
+This module provides helper functions and decorators to handle optional
+dependencies gracefully, with clear error messages when features are unavailable.
+"""
+
+import functools
+from typing import Any, Callable, Dict, Optional, Tuple
+
+from mcli.lib.logger.logger import get_logger
+
+logger = get_logger(__name__)
+
+
+class OptionalDependency:
+    """
+    Container for an optional dependency with availability tracking.
+
+    Example:
+        >>> ollama = OptionalDependency("ollama")
+        >>> if ollama.available:
+        ...     client = ollama.module.Client()
+    """
+
+    def __init__(
+        self,
+        module_name: str,
+        import_name: Optional[str] = None,
+        install_hint: Optional[str] = None,
+    ):
+        """
+        Initialize optional dependency handler.
+
+        Args:
+            module_name: Name of the module to import (e.g., "ollama")
+            import_name: Alternative import name if different from module_name
+            install_hint: Custom installation instruction
+        """
+        self.module_name = module_name
+        self.import_name = import_name or module_name
+        self.install_hint = install_hint or f"pip install {module_name}"
+        self.module: Optional[Any] = None
+        self.available = False
+        self.error: Optional[Exception] = None
+
+        self._try_import()
+
+    def _try_import(self):
+        """Attempt to import the module."""
+        try:
+            self.module = __import__(self.import_name)
+            self.available = True
+            logger.debug(f"Optional dependency '{self.module_name}' is available")
+        except ImportError as e:
+            self.available = False
+            self.error = e
+            logger.debug(f"Optional dependency '{self.module_name}' is not available: {e}")
+
+    def require(self, feature_name: Optional[str] = None) -> Any:
+        """
+        Require the dependency to be available, raising an error if not.
+
+        Args:
+            feature_name: Name of the feature requiring this dependency
+
+        Returns:
+            The imported module
+
+        Raises:
+            ImportError: If the dependency is not available
+        """
+        if not self.available:
+            feature_msg = f" for {feature_name}" if feature_name else ""
+            raise ImportError(
+                f"'{self.module_name}' is required{feature_msg} but not installed.\n"
+                f"Install it with: {self.install_hint}"
+            )
+        return self.module
+
+    def __getattr__(self, name: str) -> Any:
+        """Allow direct attribute access to the module."""
+        if not self.available:
+            raise ImportError(
+                f"Cannot access '{name}' from '{self.module_name}' - module not installed.\n"
+                f"Install it with: {self.install_hint}"
+            )
+        return getattr(self.module, name)
+
+
+def optional_import(
+    module_name: str, import_name: Optional[str] = None, install_hint: Optional[str] = None
+) -> Tuple[Optional[Any], bool]:
+    """
+    Try to import an optional dependency.
+
+    Args:
+        module_name: Name of the module to import
+        import_name: Alternative import name if different from module_name
+        install_hint: Custom installation instruction
+
+    Returns:
+        Tuple of (module, available) where module is None if unavailable
+
+    Example:
+        >>> ollama, OLLAMA_AVAILABLE = optional_import("ollama")
+        >>> if OLLAMA_AVAILABLE:
+        ...     client = ollama.Client()
+    """
+    dep = OptionalDependency(module_name, import_name, install_hint)
+    return (dep.module, dep.available)
+
+
+def require_dependency(
+    module_name: str, feature_name: str, install_hint: Optional[str] = None
+) -> Any:
+    """
+    Require a dependency, raising clear error if not available.
+
+    Args:
+        module_name: Name of the module to import
+        feature_name: Name of the feature requiring this dependency
+        install_hint: Custom installation instruction
+
+    Returns:
+        The imported module
+
+    Raises:
+        ImportError: If the dependency is not available
+
+    Example:
+        >>> streamlit = require_dependency("streamlit", "dashboard")
+    """
+    dep = OptionalDependency(module_name, install_hint=install_hint)
+    return dep.require(feature_name)
+
+
+def requires(*dependencies: str, install_all_hint: Optional[str] = None):
+    """
+    Decorator to mark a function as requiring specific dependencies.
+
+    Args:
+        *dependencies: Module names required by the function
+        install_all_hint: Custom installation instruction for all dependencies
+
+    Raises:
+        ImportError: If any required dependency is not available
+
+    Example:
+        >>> @requires("torch", "transformers")
+        ... def train_model():
+        ...     import torch
+        ...     import transformers
+        ...     # training code
+    """
+
+    def decorator(func: Callable) -> Callable:
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            missing = []
+            for dep_name in dependencies:
+                dep = OptionalDependency(dep_name)
+                if not dep.available:
+                    missing.append(dep_name)
+
+            if missing:
+                if install_all_hint:
+                    hint = install_all_hint
+                else:
+                    hint = f"pip install {' '.join(missing)}"
+
+                raise ImportError(
+                    f"Function '{func.__name__}' requires missing dependencies: {', '.join(missing)}\n"
+                    f"Install them with: {hint}"
+                )
+
+            return func(*args, **kwargs)
+
+        return wrapper
+
+    return decorator
+
+
+# Common optional dependencies registry
+OPTIONAL_DEPS: Dict[str, OptionalDependency] = {}
+
+
+def register_optional_dependency(
+    module_name: str, import_name: Optional[str] = None, install_hint: Optional[str] = None
+) -> OptionalDependency:
+    """
+    Register and cache an optional dependency.
+
+    Args:
+        module_name: Name of the module to import
+        import_name: Alternative import name if different from module_name
+        install_hint: Custom installation instruction
+
+    Returns:
+        OptionalDependency instance
+    """
+    if module_name not in OPTIONAL_DEPS:
+        OPTIONAL_DEPS[module_name] = OptionalDependency(module_name, import_name, install_hint)
+    return OPTIONAL_DEPS[module_name]
+
+
+def check_dependencies(*module_names: str) -> Dict[str, bool]:
+    """
+    Check availability of multiple dependencies.
+
+    Args:
+        *module_names: Module names to check
+
+    Returns:
+        Dictionary mapping module names to availability status
+
+    Example:
+        >>> status = check_dependencies("torch", "transformers", "streamlit")
+        >>> print(status)
+        {'torch': True, 'transformers': False, 'streamlit': True}
+    """
+    return {
+        name: OptionalDependency(name).available for name in module_names
+    }
+
+
+# Pre-register common optional dependencies
+_COMMON_DEPS = {
+    "ollama": ("ollama", "pip install ollama"),
+    "streamlit": ("streamlit", "pip install streamlit"),
+    "torch": ("torch", "pip install torch"),
+    "transformers": ("transformers", "pip install transformers"),
+    "mlflow": ("mlflow", "pip install mlflow"),
+    "plotly": ("plotly", "pip install plotly"),
+    "pandas": ("pandas", "pip install pandas"),
+    "numpy": ("numpy", "pip install numpy"),
+}
+
+for module_name, (import_name, hint) in _COMMON_DEPS.items():
+    register_optional_dependency(module_name, import_name, hint)

mcli/ml/backtesting/run.py

@@ -18,12 +18,14 @@ def cli():
 @click.option("--end-date", required=True, help="End date (YYYY-MM-DD)")
 @click.option("--initial-capital", default=100000, help="Initial capital")
 @click.option("--output", help="Output file for results")
-def run_backtest(strategy: str, start_date: str, end_date: str, initial_capital: float, output: str):
+def run_backtest(
+    strategy: str, start_date: str, end_date: str, initial_capital: float, output: str
+):
     """Run a backtest with the specified parameters."""
     info(f"Running backtest for strategy: {strategy}")
     info(f"Period: {start_date} to {end_date}")
     info(f"Initial capital: ${initial_capital:,.2f}")
-    
+
     # TODO: Implement actual backtesting logic
     error("Backtesting functionality not yet implemented")
 
@@ -51,4 +53,4 @@ def main():
 
 
 if __name__ == "__main__":
-    main()
+    main()

mcli/ml/models/ensemble_models.py

@@ -9,6 +9,7 @@ import pandas as pd
 import torch
 import torch.nn as nn
 import torch.nn.functional as F
+
 from mcli.ml.models.base_models import BaseStockModel, ModelMetrics, ValidationResult
 
 logger = logging.getLogger(__name__)

mcli/ml/models/recommendation_models.py

@@ -10,6 +10,7 @@ import pandas as pd
 import torch
 import torch.nn as nn
 import torch.nn.functional as F
+
 from mcli.ml.models.base_models import BaseStockModel, ModelMetrics, ValidationResult
 from mcli.ml.models.ensemble_models import DeepEnsembleModel, EnsembleConfig, ModelConfig
 

mcli/ml/optimization/optimize.py

@@ -18,13 +18,15 @@ def cli():
 @click.option("--end-date", required=True, help="End date (YYYY-MM-DD)")
 @click.option("--risk-free-rate", default=0.02, help="Risk-free rate")
 @click.option("--output", help="Output file for results")
-def optimize_portfolio(symbols: str, start_date: str, end_date: str, risk_free_rate: float, output: str):
+def optimize_portfolio(
+    symbols: str, start_date: str, end_date: str, risk_free_rate: float, output: str
+):
     """Optimize portfolio allocation for given symbols."""
     symbol_list = [s.strip() for s in symbols.split(",")]
     info(f"Optimizing portfolio for: {', '.join(symbol_list)}")
     info(f"Period: {start_date} to {end_date}")
     info(f"Risk-free rate: {risk_free_rate:.2%}")
-    
+
     # TODO: Implement actual optimization
     error("Portfolio optimization not yet implemented")
 
@@ -37,7 +39,7 @@ def efficient_frontier(symbols: str, points: int):
     symbol_list = [s.strip() for s in symbols.split(",")]
     info(f"Generating efficient frontier for: {', '.join(symbol_list)}")
     info(f"Points: {points}")
-    
+
     # TODO: Implement efficient frontier generation
     error("Efficient frontier generation not yet implemented")
 
@@ -48,4 +50,4 @@ def main():
 
 
 if __name__ == "__main__":
-    main()
+    main()

mcli/ml/serving/serve.py

@@ -20,7 +20,7 @@ def start_server(model: str, port: int, host: str):
     """Start the model serving server."""
     info(f"Starting model server for: {model}")
     info(f"Serving on {host}:{port}")
-    
+
     # TODO: Implement actual model serving
     error("Model serving functionality not yet implemented")
 
@@ -47,4 +47,4 @@ def main():
 
 
 if __name__ == "__main__":
-    main()
+    main()

mcli/ml/training/train.py

@@ -19,12 +19,19 @@ def cli():
 @click.option("--batch-size", default=32, help="Batch size for training")
 @click.option("--learning-rate", default=0.001, help="Learning rate")
 @click.option("--output-dir", help="Directory to save trained model")
-def train_model(model_type: str, dataset: str, epochs: int, batch_size: int, learning_rate: float, output_dir: str):
+def train_model(
+    model_type: str,
+    dataset: str,
+    epochs: int,
+    batch_size: int,
+    learning_rate: float,
+    output_dir: str,
+):
     """Train a model with the specified parameters."""
     info(f"Training {model_type} model")
     info(f"Dataset: {dataset}")
     info(f"Epochs: {epochs}, Batch size: {batch_size}, Learning rate: {learning_rate}")
-    
+
     # TODO: Implement actual training logic
     error("Model training functionality not yet implemented")
 
@@ -36,7 +43,7 @@ def resume_training(checkpoint: str, epochs: int):
     """Resume training from a checkpoint."""
     info(f"Resuming training from: {checkpoint}")
     info(f"Additional epochs: {epochs}")
-    
+
     # TODO: Implement resume functionality
     error("Resume training not yet implemented")
 
@@ -46,14 +53,14 @@ def resume_training(checkpoint: str, epochs: int):
 def train_politician_trading(output_dir: str):
     """Train the politician trading prediction model."""
     info("Training politician trading prediction model...")
-    
+
     try:
         # Import the actual training function
         from mcli.ml.training.train_model import train_politician_trading_model
-        
+
         # Run the training
         metrics = train_politician_trading_model(output_dir)
-        
+
         if metrics:
             success(f"Training completed! Final loss: {metrics.get('final_loss', 'N/A')}")
         else:
@@ -70,4 +77,4 @@ def main():
 
 
 if __name__ == "__main__":
-    main()
+    main()

mcli/self/completion_cmd.py

@@ -216,10 +216,10 @@ def completion_status():
 
     click.echo()
     click.echo("💡 To install completion for your shell:")
-    click.echo("   mcli completion install")
+    click.echo("   mcli self completion install")
     click.echo()
     click.echo("💡 To generate completion script manually:")
-    click.echo(f"   mcli completion {shell_name}")
+    click.echo(f"   mcli self completion {shell_name}")
 
 
 # Export the CLI group for registration