mcli-framework 7.8.3__py3-none-any.whl → 7.8.5__py3-none-any.whl

mcli/ml/database/__init__.py

@@ -0,0 +1,40 @@
+"""Database models and utilities"""
+
+from .models import (
+    Alert,
+    BacktestResult,
+    Base,
+    DataVersion,
+    Experiment,
+    FeatureSet,
+    Model,
+    Politician,
+    Portfolio,
+    Prediction,
+    StockData,
+    Trade,
+    User,
+)
+from .session import AsyncSessionLocal, SessionLocal, async_engine, engine, get_async_db, get_db
+
+__all__ = [
+    "Base",
+    "User",
+    "Trade",
+    "Politician",
+    "StockData",
+    "Prediction",
+    "Portfolio",
+    "Alert",
+    "BacktestResult",
+    "Experiment",
+    "Model",
+    "FeatureSet",
+    "DataVersion",
+    "get_db",
+    "get_async_db",
+    "SessionLocal",
+    "AsyncSessionLocal",
+    "engine",
+    "async_engine",
+]

mcli/ml/experimentation/__init__.py

@@ -0,0 +1,29 @@
+"""ML Experimentation and A/B Testing Framework"""
+
+from .ab_testing import (
+    ABTestingFramework,
+    ExperimentConfig,
+    ExperimentResult,
+    ExperimentStatus,
+    Metric,
+    MetricsCollector,
+    StatisticalAnalyzer,
+    TrafficSplitter,
+    UserAssignment,
+    Variant,
+    VariantType,
+)
+
+__all__ = [
+    "ABTestingFramework",
+    "ExperimentConfig",
+    "Variant",
+    "VariantType",
+    "Metric",
+    "ExperimentStatus",
+    "ExperimentResult",
+    "UserAssignment",
+    "TrafficSplitter",
+    "MetricsCollector",
+    "StatisticalAnalyzer",
+]

mcli/ml/features/__init__.py

@@ -0,0 +1,39 @@
+"""Feature Engineering Module for Stock Recommendation Models"""
+
+from .ensemble_features import (
+    DynamicFeatureSelector,
+    EnsembleFeatureBuilder,
+    FeatureInteractionEngine,
+)
+from .political_features import (
+    CongressionalTrackingFeatures,
+    PolicyImpactFeatures,
+    PoliticalInfluenceFeatures,
+)
+from .recommendation_engine import (
+    RecommendationConfig,
+    RecommendationResult,
+    StockRecommendationEngine,
+)
+from .stock_features import (
+    CrossAssetFeatures,
+    MarketRegimeFeatures,
+    StockRecommendationFeatures,
+    TechnicalIndicatorFeatures,
+)
+
+__all__ = [
+    "StockRecommendationFeatures",
+    "TechnicalIndicatorFeatures",
+    "MarketRegimeFeatures",
+    "CrossAssetFeatures",
+    "PoliticalInfluenceFeatures",
+    "CongressionalTrackingFeatures",
+    "PolicyImpactFeatures",
+    "EnsembleFeatureBuilder",
+    "FeatureInteractionEngine",
+    "DynamicFeatureSelector",
+    "StockRecommendationEngine",
+    "RecommendationConfig",
+    "RecommendationResult",
+]

mcli/ml/mlops/__init__.py

@@ -0,0 +1,19 @@
+"""MLOps components for ML pipeline management"""
+
+from .experiment_tracker import ExperimentRun, ExperimentTracker, MLflowConfig, ModelRegistry
+from .model_serving import ModelEndpoint, ModelServer, PredictionService
+from .pipeline_orchestrator import MLPipeline, PipelineConfig, PipelineExecutor, PipelineStep
+
+__all__ = [
+    "ExperimentTracker",
+    "ModelRegistry",
+    "MLflowConfig",
+    "ExperimentRun",
+    "ModelServer",
+    "PredictionService",
+    "ModelEndpoint",
+    "MLPipeline",
+    "PipelineStep",
+    "PipelineConfig",
+    "PipelineExecutor",
+]

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

@@ -102,79 +102,8 @@ def restore_command_state(hash_value):
     return True
 
 
-# Create a Click group for all command management
-@self_app.group("commands")
-def commands_group():
-    """Manage CLI commands and command state."""
-    pass
-
-
-# Move the command-state group under commands_group
-@commands_group.group("state")
-def command_state():
-    """Manage command state lockfile and history."""
-    pass
-
-
-@command_state.command("list")
-def list_states():
-    """List all saved command states (hash, timestamp, #commands)."""
-    states = load_lockfile()
-    if not states:
-        click.echo("No command states found.")
-        return
-    table = Table(title="Command States")
-    table.add_column("Hash", style="cyan")
-    table.add_column("Timestamp", style="green")
-    table.add_column("# Commands", style="yellow")
-    for state in states:
-        table.add_row(state["hash"][:8], state["timestamp"], str(len(state["commands"])))
-    console.print(table)
-
-
-@command_state.command("restore")
-@click.argument("hash_value")
-def restore_state(hash_value):
-    """Restore to a previous command state by hash."""
-    if restore_command_state(hash_value):
-        click.echo(f"Restored to state {hash_value[:8]}")
-    else:
-        click.echo(f"State {hash_value[:8]} not found.", err=True)
-
-
-@command_state.command("write")
-@click.argument("json_file", required=False, type=click.Path(exists=False))
-def write_state(json_file):
-    """Write a new command state to the lockfile from a JSON file or the current app state."""
-    import traceback
-
-    print("[DEBUG] write_state called")
-    print(f"[DEBUG] LOCKFILE_PATH: {LOCKFILE_PATH}")
-    try:
-        if json_file:
-            print(f"[DEBUG] Loading command state from file: {json_file}")
-            with open(json_file, "r") as f:
-                commands = json.load(f)
-            click.echo(f"Loaded command state from {json_file}.")
-        else:
-            print("[DEBUG] Snapshotting current command state.")
-            commands = get_current_command_state()
-        state_hash = hash_command_state(commands)
-        new_state = {
-            "hash": state_hash,
-            "timestamp": datetime.utcnow().isoformat() + "Z",
-            "commands": commands,
-        }
-        append_lockfile(new_state)
-        print(f"[DEBUG] Wrote new command state {state_hash[:8]} to lockfile at {LOCKFILE_PATH}")
-        click.echo(f"Wrote new command state {state_hash[:8]} to lockfile.")
-    except Exception as e:
-        print(f"[ERROR] Exception in write_state: {e}")
-        print(traceback.format_exc())
-        click.echo(f"[ERROR] Failed to write command state: {e}", err=True)
-
-
 # On CLI startup, check and update lockfile if needed
+# NOTE: The commands group has been moved to mcli.app.commands_cmd for better organization
 
 
 def check_and_update_command_lockfile():
@@ -250,76 +179,7 @@ def {name}_command(name: str = "World"):
     return template
 
 
-@self_app.command("search")
-@click.argument("query", required=False)
-@click.option("--full", "-f", is_flag=True, help="Show full command paths and descriptions")
-def search(query, full):
-    """
-    Search for available commands using fuzzy matching.
-
-    Similar to telescope in neovim, this allows quick fuzzy searching
-    through all available commands in mcli.
-
-    If no query is provided, lists all commands.
-    """
-    # Collect all commands from the application
-    commands = collect_commands()
-
-    # Display the commands in a table
-    table = Table(title="mcli Commands")
-    table.add_column("Command", style="green")
-    table.add_column("Group", style="blue")
-    if full:
-        table.add_column("Path", style="dim")
-        table.add_column("Description", style="yellow")
-
-    if query:
-        filtered_commands = []
-
-        # Try to use fuzzywuzzy for better matching if available
-        if process:
-            # Extract command names for matching
-            command_names = [
-                f"{cmd['group']}.{cmd['name']}" if cmd["group"] else cmd["name"] for cmd in commands
-            ]
-            matches = process.extract(query, command_names, limit=10)
-
-            # Filter to matched commands
-            match_indices = [command_names.index(match[0]) for match in matches if match[1] > 50]
-            filtered_commands = [commands[i] for i in match_indices]
-        else:
-            # Fallback to simple substring matching
-            filtered_commands = [
-                cmd
-                for cmd in commands
-                if query.lower() in cmd["name"].lower()
-                or (cmd["group"] and query.lower() in cmd["group"].lower())
-            ]
-
-        commands = filtered_commands
-
-    # Sort commands by group then name
-    commands.sort(key=lambda c: (c["group"] if c["group"] else "", c["name"]))
-
-    # Add rows to the table
-    for cmd in commands:
-        if full:
-            table.add_row(
-                cmd["name"],
-                cmd["group"] if cmd["group"] else "-",
-                cmd["path"],
-                cmd["help"] if cmd["help"] else "",
-            )
-        else:
-            table.add_row(cmd["name"], cmd["group"] if cmd["group"] else "-")
-
-    console.print(table)
-
-    if not commands:
-        logger.info("No commands found matching the search query")
-        click.echo("No commands found matching the search query")
-
-    return 0
+# NOTE: search command has been moved to mcli.app.commands_cmd for better organization
 
 
 def collect_commands() -> List[Dict[str, Any]]:
@@ -575,110 +435,7 @@ logger = get_logger()
             pass
 
 
-@self_app.command("extract-workflow-commands")
-@click.option(
-    "--output", "-o", type=click.Path(), help="Output file (default: workflow-commands.json)"
-)
-def extract_workflow_commands(output):
-    """
-    Extract workflow commands from Python modules to JSON format.
-
-    This command helps migrate existing workflow commands to portable JSON format.
-    """
-    import inspect
-    from pathlib import Path
-
-    output_file = Path(output) if output else Path("workflow-commands.json")
-
-    workflow_commands = []
-
-    # Try to get workflow from the main app
-    try:
-        from mcli.app.main import create_app
-
-        app = create_app()
-
-        # Check if workflow group exists
-        if "workflow" in app.commands:
-            workflow_group = app.commands["workflow"]
-
-            # Force load lazy group if needed
-            if hasattr(workflow_group, "_load_group"):
-                workflow_group = workflow_group._load_group()
-
-            if hasattr(workflow_group, "commands"):
-                for cmd_name, cmd_obj in workflow_group.commands.items():
-                    # Extract command information
-                    command_info = {
-                        "name": cmd_name,
-                        "group": "workflow",
-                        "description": cmd_obj.help or "Workflow command",
-                        "version": "1.0",
-                        "metadata": {"source": "workflow", "migrated": True},
-                    }
-
-                    # Create a template based on command type
-                    # Replace hyphens with underscores for valid Python function names
-                    safe_name = cmd_name.replace("-", "_")
-
-                    if isinstance(cmd_obj, click.Group):
-                        # For groups, create a template
-                        command_info[
-                            "code"
-                        ] = f'''"""
-{cmd_name} workflow command.
-"""
-import click
-
-@click.group(name="{cmd_name}")
-def app():
-    """{cmd_obj.help or 'Workflow command group'}"""
-    pass
-
-# Add your subcommands here
-'''
-                    else:
-                        # For regular commands, create a template
-                        command_info[
-                            "code"
-                        ] = f'''"""
-{cmd_name} workflow command.
-"""
-import click
-
-@click.command(name="{cmd_name}")
-def app():
-    """{cmd_obj.help or 'Workflow command'}"""
-    click.echo("Workflow command: {cmd_name}")
-    # Add your implementation here
-'''
-
-                    workflow_commands.append(command_info)
-
-        if workflow_commands:
-            import json
-
-            with open(output_file, "w") as f:
-                json.dump(workflow_commands, f, indent=2)
-
-            click.echo(f"✅ Extracted {len(workflow_commands)} workflow commands")
-            click.echo(f"📁 Saved to: {output_file}")
-            click.echo(
-                f"\n💡 These are templates. Import with: mcli self import-commands {output_file}"
-            )
-            click.echo("   Then customize the code in ~/.mcli/commands/<command>.json")
-            return 0
-        else:
-            click.echo("⚠️  No workflow commands found to extract")
-            return 1
-
-    except Exception as e:
-        logger.error(f"Failed to extract workflow commands: {e}")
-        click.echo(f"❌ Failed to extract workflow commands: {e}", err=True)
-        import traceback
-
-        click.echo(traceback.format_exc(), err=True)
-        return 1
+# NOTE: extract-workflow-commands has been moved to mcli.app.commands_cmd for better organization
 
 
 @click.group("plugin")
@@ -1280,13 +1037,7 @@ try:
 except ImportError as e:
     logger.debug(f"Could not load visual command: {e}")
 
-try:
-    from mcli.self.store_cmd import store
-
-    self_app.add_command(store, name="store")
-    logger.debug("Added store command to self group")
-except ImportError as e:
-    logger.debug(f"Could not load store command: {e}")
+# NOTE: store command has been moved to mcli.app.commands_cmd for better organization
 
 # This part is important to make the command available to the CLI
 if __name__ == "__main__":