mcli-framework 7.8.4__py3-none-any.whl → 7.9.0__py3-none-any.whl

mcli/ml/models/__init__.py

@@ -0,0 +1,90 @@
+"""ML Models for Stock Recommendation System"""
+
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+import torch
+
+from .base_models import BaseStockModel, ModelMetrics, ValidationResult
+from .ensemble_models import (
+    AttentionStockPredictor,
+    CNNFeatureExtractor,
+    DeepEnsembleModel,
+    EnsembleConfig,
+    EnsembleTrainer,
+    LSTMStockPredictor,
+    ModelConfig,
+    TransformerStockModel,
+)
+from .recommendation_models import (
+    RecommendationConfig,
+    RecommendationTrainer,
+    StockRecommendationModel,
+)
+
+# Model registry
+_loaded_models: Dict[str, Any] = {}
+
+
+async def load_production_models():
+    """Load production models into memory"""
+    from mcli.ml.config import settings
+    from mcli.ml.logging import get_logger
+
+    logger = get_logger(__name__)
+    model_dir = settings.model.model_dir
+
+    if not model_dir.exists():
+        model_dir.mkdir(parents=True, exist_ok=True)
+        return
+
+    for model_path in model_dir.glob("*.pt"):
+        try:
+            model_id = model_path.stem
+            model = torch.load(model_path, map_location=settings.model.device)
+            _loaded_models[model_id] = model
+            logger.info(f"Loaded model: {model_id}")
+        except Exception as e:
+            logger.error(f"Failed to load model {model_path}: {e}")
+
+
+async def get_model_by_id(model_id: str):
+    """Get loaded model by ID"""
+    from mcli.ml.config import settings
+
+    if model_id not in _loaded_models:
+        # Try to load from disk
+        model_path = settings.model.model_dir / f"{model_id}.pt"
+        if model_path.exists():
+            _loaded_models[model_id] = torch.load(model_path, map_location=settings.model.device)
+
+    return _loaded_models.get(model_id)
+
+
+def initialize_models():
+    """Initialize models on startup"""
+    from mcli.ml.logging import get_logger
+
+    logger = get_logger(__name__)
+    logger.info("Initializing ML models...")
+
+
+__all__ = [
+    "DeepEnsembleModel",
+    "AttentionStockPredictor",
+    "TransformerStockModel",
+    "LSTMStockPredictor",
+    "CNNFeatureExtractor",
+    "EnsembleTrainer",
+    "ModelConfig",
+    "EnsembleConfig",
+    "BaseStockModel",
+    "ModelMetrics",
+    "ValidationResult",
+    "StockRecommendationModel",
+    "RecommendationTrainer",
+    "RecommendationConfig",
+    "load_production_models",
+    "get_model_by_id",
+    "initialize_models",
+]

mcli/ml/monitoring/__init__.py

@@ -0,0 +1,25 @@
+"""ML Model Monitoring and Drift Detection"""
+
+from .drift_detection import (
+    AlertSeverity,
+    ConceptDriftDetector,
+    DataProfile,
+    DriftAlert,
+    DriftType,
+    ModelMetrics,
+    ModelMonitor,
+    OutlierDetector,
+    StatisticalDriftDetector,
+)
+
+__all__ = [
+    "ModelMonitor",
+    "StatisticalDriftDetector",
+    "ConceptDriftDetector",
+    "OutlierDetector",
+    "DriftAlert",
+    "DriftType",
+    "AlertSeverity",
+    "ModelMetrics",
+    "DataProfile",
+]

mcli/ml/optimization/__init__.py

@@ -0,0 +1,27 @@
+"""Advanced Portfolio Optimization"""
+
+from .portfolio_optimizer import (
+    AdvancedPortfolioOptimizer,
+    BaseOptimizer,
+    BlackLittermanOptimizer,
+    CVaROptimizer,
+    KellyCriterionOptimizer,
+    MeanVarianceOptimizer,
+    OptimizationConstraints,
+    OptimizationObjective,
+    PortfolioAllocation,
+    RiskParityOptimizer,
+)
+
+__all__ = [
+    "AdvancedPortfolioOptimizer",
+    "OptimizationObjective",
+    "OptimizationConstraints",
+    "PortfolioAllocation",
+    "MeanVarianceOptimizer",
+    "RiskParityOptimizer",
+    "BlackLittermanOptimizer",
+    "CVaROptimizer",
+    "KellyCriterionOptimizer",
+    "BaseOptimizer",
+]

mcli/ml/predictions/__init__.py

@@ -0,0 +1,5 @@
+"""ML Predictions Module"""
+
+from .prediction_engine import PoliticianTradingPredictor
+
+__all__ = ["PoliticianTradingPredictor"]

mcli/ml/preprocessing/__init__.py

@@ -0,0 +1,24 @@
+"""ML Data Preprocessing Module"""
+
+from .data_cleaners import MissingValueHandler, OutlierDetector, TradingDataCleaner
+from .feature_extractors import (
+    MarketFeatureExtractor,
+    PoliticianFeatureExtractor,
+    SentimentFeatureExtractor,
+    TemporalFeatureExtractor,
+)
+from .ml_pipeline import MLDataPipeline, MLDataPipelineConfig
+from .politician_trading_preprocessor import PoliticianTradingPreprocessor
+
+__all__ = [
+    "PoliticianTradingPreprocessor",
+    "PoliticianFeatureExtractor",
+    "MarketFeatureExtractor",
+    "TemporalFeatureExtractor",
+    "SentimentFeatureExtractor",
+    "TradingDataCleaner",
+    "OutlierDetector",
+    "MissingValueHandler",
+    "MLDataPipeline",
+    "MLDataPipelineConfig",
+]

mcli/ml/scripts/__init__.py

@@ -0,0 +1 @@
+"""ML scripts module."""

mcli/ml/trading/__init__.py

@@ -0,0 +1,63 @@
+"""Trading module for portfolio management and trade execution"""
+
+from mcli.ml.trading.alpaca_client import (
+    AlpacaTradingClient,
+    create_trading_client,
+    get_alpaca_config_from_env,
+)
+from mcli.ml.trading.models import (  # Enums; Database models; Pydantic models
+    OrderCreate,
+    OrderResponse,
+    OrderSide,
+    OrderStatus,
+    OrderType,
+    Portfolio,
+    PortfolioCreate,
+    PortfolioPerformanceSnapshot,
+    PortfolioResponse,
+    PortfolioType,
+    Position,
+    PositionResponse,
+    PositionSide,
+    RiskLevel,
+    TradingAccount,
+    TradingAccountCreate,
+    TradingOrder,
+    TradingSignal,
+    TradingSignalResponse,
+)
+from mcli.ml.trading.paper_trading import PaperTradingEngine
+from mcli.ml.trading.risk_management import RiskManager
+from mcli.ml.trading.trading_service import TradingService
+
+__all__ = [
+    # Enums
+    "OrderStatus",
+    "OrderType",
+    "OrderSide",
+    "PositionSide",
+    "PortfolioType",
+    "RiskLevel",
+    # Database models
+    "TradingAccount",
+    "Portfolio",
+    "Position",
+    "TradingOrder",
+    "PortfolioPerformanceSnapshot",
+    "TradingSignal",
+    # Pydantic models
+    "TradingAccountCreate",
+    "PortfolioCreate",
+    "OrderCreate",
+    "PositionResponse",
+    "OrderResponse",
+    "PortfolioResponse",
+    "TradingSignalResponse",
+    # Services
+    "TradingService",
+    "AlpacaTradingClient",
+    "create_trading_client",
+    "get_alpaca_config_from_env",
+    "RiskManager",
+    "PaperTradingEngine",
+]

mcli/ml/training/__init__.py

@@ -0,0 +1,7 @@
+"""ML model training module"""
+
+from .train_model import PoliticianTradingNet, fetch_training_data
+from .train_model import main as train_model
+from .train_model import prepare_dataset
+
+__all__ = ["PoliticianTradingNet", "train_model", "fetch_training_data", "prepare_dataset"]

mcli/mygroup/__init__.py

@@ -0,0 +1,3 @@
+"""
+Mygroup commands for mcli.
+"""

mcli/public/__init__.py

@@ -0,0 +1 @@
+# logger.info("I am in mcli.public.__init__.py")

mcli/public/commands/__init__.py

@@ -0,0 +1,2 @@
+# User-generated commands directory
+# Commands created through the MCLI chat interface are stored here

mcli/self/__init__.py

@@ -0,0 +1,3 @@
+"""
+Self-management module for mcli.
+"""

mcli/self/self_cmd.py

@@ -1029,6 +1029,14 @@ try:
 except ImportError as e:
     logger.debug(f"Could not load redis command: {e}")
 
+try:
+    from mcli.self.zsh_cmd import zsh_group
+
+    self_app.add_command(zsh_group, name="zsh")
+    logger.debug("Added zsh command to self group")
+except ImportError as e:
+    logger.debug(f"Could not load zsh command: {e}")
+
 try:
     from mcli.self.visual_cmd import visual
 

mcli/self/zsh_cmd.py

@@ -0,0 +1,259 @@
+"""
+ZSH-specific commands and utilities for MCLI.
+"""
+
+import os
+import subprocess
+from pathlib import Path
+from typing import Optional
+
+import click
+
+from mcli.lib.logger.logger import get_logger
+
+logger = get_logger(__name__)
+from mcli.lib.ui.styling import error, info, success, warning
+
+
+@click.group(name="zsh", help="ZSH shell integration and utilities")
+def zsh_group():
+    """ZSH-specific commands and utilities."""
+    pass
+
+
+@zsh_group.command(name="config", help="Configure ZSH for optimal MCLI experience")
+@click.option("--force", is_flag=True, help="Force reconfiguration even if already set up")
+def zsh_config(force: bool):
+    """Configure ZSH with MCLI-specific settings."""
+    zshrc = Path.home() / ".zshrc"
+
+    if not zshrc.exists():
+        if click.confirm("No .zshrc found. Create one?"):
+            zshrc.touch()
+        else:
+            warning("Configuration cancelled")
+            return
+
+    configs_added = []  # noqa: F841
+
+    # Read existing content
+    content = zshrc.read_text()
+
+    # MCLI configuration block
+    mcli_block_start = "# BEGIN MCLI ZSH CONFIG"
+    mcli_block_end = "# END MCLI ZSH CONFIG"
+
+    if mcli_block_start in content and not force:
+        info("MCLI ZSH configuration already exists. Use --force to reconfigure.")
+        return
+
+    # Remove old block if forcing
+    if mcli_block_start in content and force:
+        lines = content.split("\n")
+        new_lines = []
+        in_block = False
+
+        for line in lines:
+            if line.strip() == mcli_block_start:
+                in_block = True
+            elif line.strip() == mcli_block_end:
+                in_block = False
+                continue
+            elif not in_block:
+                new_lines.append(line)
+
+        content = "\n".join(new_lines)
+
+    # Build configuration
+    config_lines = [
+        "",
+        mcli_block_start,
+        "# MCLI aliases",
+        "alias m='mcli'",
+        "alias mc='mcli chat'",
+        "alias mw='mcli workflow'",
+        "alias ms='mcli self'",
+        "alias mls='mcli lib secrets'",
+        "alias mlsr='mcli lib secrets repl'",
+        "",
+        "# MCLI environment",
+        'export MCLI_HOME="$HOME/.mcli"',
+        'export PATH="$MCLI_HOME/bin:$PATH"',
+        "",
+        "# MCLI completion",
+        'fpath=("$HOME/.config/zsh/completions" $fpath)',
+        "autoload -U compinit && compinit",
+        "",
+        "# MCLI prompt integration (optional)",
+        '# PS1="%{$fg[cyan]%}[mcli]%{$reset_color%} $PS1"',
+        "",
+        mcli_block_end,
+        "",
+    ]
+
+    # Append configuration
+    with zshrc.open("a") as f:
+        f.write("\n".join(config_lines))
+
+    success("ZSH configuration added successfully!")
+
+    # Install completion if not already installed
+    completion_dir = Path.home() / ".config" / "zsh" / "completions"
+    completion_file = completion_dir / "_mcli"
+
+    if not completion_file.exists():
+        info("Installing ZSH completion...")
+        try:
+            subprocess.run(["mcli", "self", "completion", "install", "--shell=zsh"], check=True)
+            configs_added.append("completion")
+        except subprocess.CalledProcessError:
+            warning("Failed to install completion automatically")
+
+    info("\nConfigured:")
+    info("  • Aliases: m, mc, mw, ms, mls, mlsr")
+    info("  • Environment variables: MCLI_HOME, PATH")
+    info("  • Shell completion support")
+    info("\nReload your shell configuration:")
+    info("  source ~/.zshrc")
+
+
+@zsh_group.command(name="aliases", help="Show available ZSH aliases")
+def zsh_aliases():
+    """Display MCLI ZSH aliases."""
+    aliases = [
+        ("m", "mcli", "Main MCLI command"),
+        ("mc", "mcli chat", "Open chat interface"),
+        ("mw", "mcli workflow", "Workflow commands"),
+        ("ms", "mcli self", "Self management commands"),
+        ("mls", "mcli lib secrets", "Secrets management"),
+        ("mlsr", "mcli lib secrets repl", "Secrets REPL"),
+    ]
+
+    info("MCLI ZSH Aliases:")
+    for alias, command, desc in aliases:
+        click.echo(f"  {alias:<6} → {command:<25} # {desc}")
+
+
+@zsh_group.command(name="prompt", help="Configure ZSH prompt with MCLI integration")
+@click.option("--style", type=click.Choice(["simple", "powerline", "minimal"]), default="simple")
+def zsh_prompt(style: str):
+    """Add MCLI status to ZSH prompt."""
+    zshrc = Path.home() / ".zshrc"
+
+    if not zshrc.exists():
+        error("No .zshrc found")
+        return
+
+    prompt_configs = {
+        "simple": 'PS1="%{$fg[cyan]%}[mcli]%{$reset_color%} $PS1"',
+        "powerline": 'PS1="%{$fg[cyan]%} mcli %{$reset_color%}$PS1"',
+        "minimal": 'PS1="◆ $PS1"',
+    }
+
+    config = prompt_configs[style]
+
+    # Check if prompt section exists
+    content = zshrc.read_text()
+    prompt_marker = "# MCLI prompt integration"
+
+    if prompt_marker in content:
+        # Update existing prompt
+        lines = content.split("\n")
+        for i, line in enumerate(lines):
+            if line.strip() == prompt_marker:
+                if i + 1 < len(lines) and lines[i + 1].startswith("PS1="):
+                    lines[i + 1] = config
+                    content = "\n".join(lines)
+                    zshrc.write_text(content)
+                    success(f"Updated prompt to {style} style")
+                    break
+    else:
+        warning("MCLI ZSH configuration not found. Run 'mcli self zsh config' first.")
+
+
+@zsh_group.command(name="functions", help="Install useful ZSH functions")
+def zsh_functions():
+    """Install MCLI-specific ZSH functions."""
+    functions_dir = Path.home() / ".config" / "zsh" / "functions"
+    functions_dir.mkdir(parents=True, exist_ok=True)
+
+    # Create mcli-quick function
+    quick_func = functions_dir / "mcli-quick"
+    quick_func.write_text(
+        """# Quick MCLI command runner
+mcli-quick() {
+    local cmd=$1
+    shift
+    mcli $cmd "$@" | head -20
+}"""
+    )
+
+    # Create mcli-fzf function for fuzzy finding
+    fzf_func = functions_dir / "mcli-fzf"
+    fzf_func.write_text(
+        """# Fuzzy find MCLI commands
+mcli-fzf() {
+    local cmd=$(mcli --help | grep -E '^  [a-z]' | awk '{print $1}' | fzf)
+    if [[ -n $cmd ]]; then
+        print -z "mcli $cmd "
+    fi
+}"""
+    )
+
+    # Add to zshrc
+    zshrc = Path.home() / ".zshrc"
+    if zshrc.exists():
+        content = zshrc.read_text()
+        fpath_line = f'fpath=("{functions_dir}" $fpath)'
+
+        if str(functions_dir) not in content:
+            with zshrc.open("a") as f:
+                f.write(f"\n# MCLI ZSH functions\n{fpath_line}\nautoload -U mcli-quick mcli-fzf\n")
+
+    success("ZSH functions installed:")
+    info("  • mcli-quick: Run MCLI commands with truncated output")
+    info("  • mcli-fzf: Fuzzy find MCLI commands (requires fzf)")
+
+
+@zsh_group.command(name="test", help="Test ZSH integration")
+def zsh_test():
+    """Test ZSH integration and configuration."""
+    checks = []
+
+    # Check if running in ZSH
+    shell = os.environ.get("SHELL", "")
+    if "zsh" in shell:
+        checks.append(("ZSH shell detected", True))
+    else:
+        checks.append(("ZSH shell detected", False))
+
+    # Check completion
+    completion_file = Path.home() / ".config" / "zsh" / "completions" / "_mcli"
+    checks.append(("Completion installed", completion_file.exists()))
+
+    # Check zshrc
+    zshrc = Path.home() / ".zshrc"
+    if zshrc.exists():
+        content = zshrc.read_text()
+        checks.append(("MCLI config in .zshrc", "BEGIN MCLI ZSH CONFIG" in content))
+        checks.append(("Completion in fpath", ".config/zsh/completions" in content))
+    else:
+        checks.append((".zshrc exists", False))
+
+    # Check aliases
+    try:
+        result = subprocess.run(["zsh", "-c", "alias | grep mcli"], capture_output=True, text=True)
+        checks.append(("Aliases configured", result.returncode == 0))
+    except:
+        checks.append(("Aliases configured", False))
+
+    # Display results
+    info("ZSH Integration Test Results:")
+    for check, passed in checks:
+        status = "✅" if passed else "❌"
+        click.echo(f"  {status} {check}")
+
+    if all(passed for _, passed in checks):
+        success("\nAll checks passed! ZSH integration is working correctly.")
+    else:
+        warning("\nSome checks failed. Run 'mcli self zsh config' to set up integration.")

mcli/workflow/daemon/__init__.py

@@ -0,0 +1,15 @@
+"""
+Daemon service for command management and execution.
+
+This module provides a background daemon service that can store, manage, and execute
+commands written in various programming languages (Python, Node.js, Lua, Shell).
+Commands are stored in a SQLite database with embeddings for similarity search and
+hierarchical grouping.
+
+The daemon CLI commands are now loaded from portable JSON files in ~/.mcli/commands/
+"""
+
+from .daemon import Command, CommandExecutor, DaemonService
+
+# Export main components
+__all__ = ["Command", "CommandExecutor", "DaemonService"]

mcli/workflow/dashboard/__init__.py

@@ -0,0 +1,5 @@
+"""Dashboard workflow module."""
+
+from .dashboard_cmd import dashboard
+
+__all__ = ["dashboard"]

mcli/workflow/gcloud/__init__.py

@@ -0,0 +1 @@
+from .gcloud import gcloud

mcli/workflow/politician_trading/__init__.py

@@ -0,0 +1,4 @@
+"""
+Politician Trading Data Workflow
+Tracks publicly available trading information for US and EU politicians
+"""

mcli/workflow/scheduler/__init__.py

@@ -0,0 +1,25 @@
+"""
+MCLI Scheduler Module
+
+A robust cron-like job scheduling system with the following features:
+- Cron expression parsing and job scheduling
+- Job monitoring and persistence across restarts
+- JSON API for frontend integration
+- System automation capabilities
+- Desktop file cleanup and management
+"""
+
+from .cron_parser import CronExpression
+from .job import JobStatus, ScheduledJob
+from .monitor import JobMonitor
+from .persistence import JobStorage
+from .scheduler import JobScheduler
+
+__all__ = [
+    "JobScheduler",
+    "ScheduledJob",
+    "JobStatus",
+    "CronExpression",
+    "JobStorage",
+    "JobMonitor",
+]

mcli/workflow/sync/__init__.py

@@ -0,0 +1,5 @@
+"""Multi-cloud sync module for mcli workflow system."""
+
+from .sync_cmd import sync
+
+__all__ = ["sync"]

mcli/workflow/videos/__init__.py

@@ -0,0 +1 @@
+# Videos workflow module