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

mcli/lib/secrets/store.py

@@ -0,0 +1,246 @@
+"""
+Git-based secrets store for synchronization across machines.
+"""
+
+import os
+import shutil
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+import click
+from git import GitCommandError, Repo
+
+from mcli.lib.logger.logger import get_logger
+
+logger = get_logger(__name__)
+from mcli.lib.ui.styling import error, info, success, warning
+
+
+class SecretsStore:
+    """Manages git-based secrets synchronization."""
+
+    def __init__(self, store_path: Optional[Path] = None):
+        """Initialize the secrets store.
+
+        Args:
+            store_path: Path to git repository for secrets. Defaults to ~/repos/mcli-secrets
+        """
+        self.store_path = store_path or Path.home() / "repos" / "mcli-secrets"
+        self.config_file = Path.home() / ".mcli" / "secrets-store.conf"
+        self.load_config()
+
+    def load_config(self) -> None:
+        """Load store configuration."""
+        self.store_config = {}
+        if self.config_file.exists():
+            with open(self.config_file) as f:
+                for line in f:
+                    line = line.strip()
+                    if "=" in line:
+                        key, value = line.split("=", 1)
+                        self.store_config[key.strip()] = value.strip()
+
+        # Override store path if configured
+        if "store_path" in self.store_config:
+            self.store_path = Path(self.store_config["store_path"])
+
+    def save_config(self) -> None:
+        """Save store configuration."""
+        self.config_file.parent.mkdir(parents=True, exist_ok=True)
+        with open(self.config_file, "w") as f:
+            for key, value in self.store_config.items():
+                f.write(f"{key}={value}\n")
+
+    def init(self, remote_url: Optional[str] = None) -> None:
+        """Initialize the secrets store repository.
+
+        Args:
+            remote_url: Optional git remote URL
+        """
+        if self.store_path.exists() and (self.store_path / ".git").exists():
+            error("Store already initialized")
+            return
+
+        self.store_path.mkdir(parents=True, exist_ok=True)
+
+        try:
+            repo = Repo.init(self.store_path)
+
+            # Create README
+            readme_path = self.store_path / "README.md"
+            readme_path.write_text(
+                "# MCLI Secrets Store\n\n"
+                "This repository stores encrypted secrets for MCLI.\n\n"
+                "**WARNING**: This repository contains encrypted sensitive data.\n"
+                "Ensure it is kept private and access is restricted.\n"
+            )
+
+            # Create .gitignore
+            gitignore_path = self.store_path / ".gitignore"
+            gitignore_path.write_text("*.key\n*.tmp\n.DS_Store\n")
+
+            repo.index.add([readme_path.name, gitignore_path.name])
+            repo.index.commit("Initial commit")
+
+            if remote_url:
+                repo.create_remote("origin", remote_url)
+                self.store_config["remote_url"] = remote_url
+                self.save_config()
+                info(f"Remote added: {remote_url}")
+
+            success(f"Secrets store initialized at {self.store_path}")
+
+        except GitCommandError as e:
+            error(f"Failed to initialize store: {e}")
+
+    def push(self, secrets_dir: Path, message: Optional[str] = None) -> None:
+        """Push secrets to the store.
+
+        Args:
+            secrets_dir: Directory containing encrypted secrets
+            message: Commit message
+        """
+        if not self._check_initialized():
+            return
+
+        try:
+            repo = Repo(self.store_path)
+
+            # Copy secrets to store
+            store_secrets_dir = self.store_path / "secrets"
+
+            # Remove existing secrets
+            if store_secrets_dir.exists():
+                shutil.rmtree(store_secrets_dir)
+
+            # Copy new secrets
+            shutil.copytree(secrets_dir, store_secrets_dir)
+
+            # Add to git
+            repo.index.add(["secrets"])
+
+            # Check if there are changes
+            if repo.is_dirty():
+                message = message or f"Update secrets from {os.uname().nodename}"
+                repo.index.commit(message)
+
+                # Push if remote exists
+                if "origin" in repo.remotes:
+                    info("Pushing to remote...")
+                    repo.remotes.origin.push()
+                    success("Secrets pushed to remote")
+                else:
+                    success("Secrets committed locally")
+            else:
+                info("No changes to push")
+
+        except GitCommandError as e:
+            error(f"Failed to push secrets: {e}")
+
+    def pull(self, secrets_dir: Path) -> None:
+        """Pull secrets from the store.
+
+        Args:
+            secrets_dir: Directory to store pulled secrets
+        """
+        if not self._check_initialized():
+            return
+
+        try:
+            repo = Repo(self.store_path)
+
+            # Pull from remote if exists
+            if "origin" in repo.remotes:
+                info("Pulling from remote...")
+                repo.remotes.origin.pull()
+
+            # Copy secrets from store
+            store_secrets_dir = self.store_path / "secrets"
+
+            if not store_secrets_dir.exists():
+                warning("No secrets found in store")
+                return
+
+            # Backup existing secrets
+            if secrets_dir.exists():
+                backup_dir = secrets_dir.parent / f"{secrets_dir.name}.backup"
+                if backup_dir.exists():
+                    shutil.rmtree(backup_dir)
+                shutil.move(str(secrets_dir), str(backup_dir))
+                info(f"Existing secrets backed up to {backup_dir}")
+
+            # Copy secrets from store
+            shutil.copytree(store_secrets_dir, secrets_dir)
+
+            success(f"Secrets pulled to {secrets_dir}")
+
+        except GitCommandError as e:
+            error(f"Failed to pull secrets: {e}")
+
+    def sync(self, secrets_dir: Path, message: Optional[str] = None) -> None:
+        """Synchronize secrets (pull then push).
+
+        Args:
+            secrets_dir: Directory containing secrets
+            message: Commit message
+        """
+        if not self._check_initialized():
+            return
+
+        info("Synchronizing secrets...")
+
+        # First pull
+        self.pull(secrets_dir)
+
+        # Then push
+        self.push(secrets_dir, message)
+
+    def status(self) -> Dict[str, Any]:
+        """Get status of the secrets store.
+
+        Returns:
+            Status information
+        """
+        status = {
+            "initialized": False,
+            "store_path": str(self.store_path),
+            "has_remote": False,
+            "remote_url": None,
+            "clean": True,
+            "branch": None,
+            "commit": None,
+        }
+
+        if not self._check_initialized(silent=True):
+            return status
+
+        try:
+            repo = Repo(self.store_path)
+            status["initialized"] = True
+            status["clean"] = not repo.is_dirty()
+            status["branch"] = repo.active_branch.name
+            status["commit"] = str(repo.head.commit)[:8]
+
+            if "origin" in repo.remotes:
+                status["has_remote"] = True
+                status["remote_url"] = repo.remotes.origin.url
+
+        except Exception:
+            pass
+
+        return status
+
+    def _check_initialized(self, silent: bool = False) -> bool:
+        """Check if store is initialized.
+
+        Args:
+            silent: Don't print error message
+
+        Returns:
+            True if initialized
+        """
+        if not self.store_path.exists() or not (self.store_path / ".git").exists():
+            if not silent:
+                error("Store not initialized. Run 'mcli secrets store init' first.")
+            return False
+        return True

mcli/lib/toml/__init__.py

@@ -0,0 +1 @@
+from .toml import read_from_toml

mcli/ml/__init__.py

@@ -0,0 +1,16 @@
+"""MCLI Machine Learning Module for Stock Recommendation System"""
+
+from .configs.dvc_config import get_dvc_config, setup_dvc
+from .configs.mlflow_config import get_mlflow_config, setup_mlflow
+from .configs.mlops_manager import MLOpsManager, get_mlops_manager
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "get_mlops_manager",
+    "MLOpsManager",
+    "get_mlflow_config",
+    "setup_mlflow",
+    "get_dvc_config",
+    "setup_dvc",
+]

mcli/ml/api/__init__.py

@@ -0,0 +1,30 @@
+"""API routes and endpoints for ML system"""
+
+from .app import create_app, get_application
+from .routers import (
+    admin_router,
+    auth_router,
+    backtest_router,
+    data_router,
+    model_router,
+    monitoring_router,
+    portfolio_router,
+    prediction_router,
+    trade_router,
+    websocket_router,
+)
+
+__all__ = [
+    "auth_router",
+    "model_router",
+    "prediction_router",
+    "portfolio_router",
+    "data_router",
+    "trade_router",
+    "backtest_router",
+    "monitoring_router",
+    "admin_router",
+    "websocket_router",
+    "create_app",
+    "get_application",
+]

mcli/ml/api/routers/__init__.py

@@ -0,0 +1,27 @@
+"""API routers"""
+
+from . import (
+    admin_router,
+    auth_router,
+    backtest_router,
+    data_router,
+    model_router,
+    monitoring_router,
+    portfolio_router,
+    prediction_router,
+    trade_router,
+    websocket_router,
+)
+
+__all__ = [
+    "auth_router",
+    "model_router",
+    "prediction_router",
+    "portfolio_router",
+    "data_router",
+    "trade_router",
+    "backtest_router",
+    "monitoring_router",
+    "admin_router",
+    "websocket_router",
+]

mcli/ml/auth/__init__.py

@@ -0,0 +1,41 @@
+"""Authentication and authorization system"""
+
+from .auth_manager import (
+    AuthManager,
+    create_access_token,
+    get_current_active_user,
+    get_current_user,
+    hash_password,
+    require_role,
+    verify_access_token,
+    verify_password,
+)
+from .models import (
+    PasswordChange,
+    PasswordReset,
+    TokenResponse,
+    UserCreate,
+    UserLogin,
+    UserResponse,
+)
+from .permissions import Permission, check_permission, has_permission
+
+__all__ = [
+    "AuthManager",
+    "create_access_token",
+    "verify_access_token",
+    "get_current_user",
+    "get_current_active_user",
+    "require_role",
+    "hash_password",
+    "verify_password",
+    "UserCreate",
+    "UserLogin",
+    "UserResponse",
+    "TokenResponse",
+    "PasswordReset",
+    "PasswordChange",
+    "Permission",
+    "check_permission",
+    "has_permission",
+]

mcli/ml/backtesting/__init__.py

@@ -0,0 +1,33 @@
+"""Backtesting framework for trading strategies"""
+
+from .backtest_engine import (
+    BacktestConfig,
+    BacktestEngine,
+    BacktestResult,
+    PositionManager,
+    TradingStrategy,
+)
+from .performance_metrics import (
+    PerformanceAnalyzer,
+    PortfolioMetrics,
+    RiskMetrics,
+    plot_performance,
+)
+from .trading_simulator import MarketSimulator, Order, Portfolio, Position, TradingSimulator
+
+__all__ = [
+    "BacktestEngine",
+    "BacktestConfig",
+    "BacktestResult",
+    "TradingStrategy",
+    "PositionManager",
+    "PerformanceAnalyzer",
+    "PortfolioMetrics",
+    "RiskMetrics",
+    "plot_performance",
+    "TradingSimulator",
+    "Order",
+    "Position",
+    "Portfolio",
+    "MarketSimulator",
+]

mcli/ml/cli/__init__.py

@@ -0,0 +1,5 @@
+"""CLI interface for ML system"""
+
+from .main import app
+
+__all__ = ["app"]

mcli/ml/config/__init__.py

@@ -0,0 +1,33 @@
+"""Configuration management for ML system"""
+
+from .settings import (
+    APISettings,
+    DatabaseSettings,
+    DataSettings,
+    MLflowSettings,
+    ModelSettings,
+    MonitoringSettings,
+    RedisSettings,
+    SecuritySettings,
+    Settings,
+    create_settings,
+    get_settings,
+    settings,
+    update_settings,
+)
+
+__all__ = [
+    "Settings",
+    "DatabaseSettings",
+    "RedisSettings",
+    "MLflowSettings",
+    "ModelSettings",
+    "DataSettings",
+    "APISettings",
+    "MonitoringSettings",
+    "SecuritySettings",
+    "settings",
+    "get_settings",
+    "update_settings",
+    "create_settings",
+]

mcli/ml/configs/__init__.py

@@ -0,0 +1,16 @@
+"""ML Configuration Module"""
+
+from .dvc_config import DVCConfig, get_dvc_config, setup_dvc
+from .mlflow_config import MLflowConfig, get_mlflow_config, setup_mlflow
+from .mlops_manager import MLOpsManager, get_mlops_manager
+
+__all__ = [
+    "MLflowConfig",
+    "get_mlflow_config",
+    "setup_mlflow",
+    "DVCConfig",
+    "get_dvc_config",
+    "setup_dvc",
+    "MLOpsManager",
+    "get_mlops_manager",
+]

mcli/ml/dashboard/__init__.py

@@ -0,0 +1,12 @@
+"""ML Dashboard for real-time monitoring"""
+
+from .app import main
+from .cli import app as cli_app
+
+
+def main():
+    """Main entry point for dashboard CLI"""
+    cli_app()
+
+
+__all__ = ["main", "cli_app"]

mcli/ml/dashboard/components/__init__.py

@@ -0,0 +1,7 @@
+"""Reusable Streamlit dashboard components"""
+
+from .charts import *
+from .metrics import *
+from .tables import *
+
+__all__ = ["charts", "tables", "metrics"]

mcli/ml/dashboard/pages/__init__.py

@@ -0,0 +1,6 @@
+"""Dashboard page modules"""
+
+from .cicd import show_cicd_dashboard
+from .workflows import show_workflows_dashboard
+
+__all__ = ["show_cicd_dashboard", "show_workflows_dashboard"]

mcli/ml/data_ingestion/__init__.py

@@ -0,0 +1,29 @@
+"""Real-time data ingestion pipeline"""
+
+from .api_connectors import (
+    AlphaVantageConnector,
+    CongressionalDataAPI,
+    PolygonIOConnector,
+    QuiverQuantConnector,
+    StockMarketAPI,
+    YahooFinanceConnector,
+)
+from .data_pipeline import DataLoader, DataTransformer, DataValidator, IngestionPipeline
+from .stream_processor import DataStream, KafkaConsumer, StreamProcessor, WebSocketConsumer
+
+__all__ = [
+    "StreamProcessor",
+    "DataStream",
+    "KafkaConsumer",
+    "WebSocketConsumer",
+    "CongressionalDataAPI",
+    "StockMarketAPI",
+    "AlphaVantageConnector",
+    "YahooFinanceConnector",
+    "PolygonIOConnector",
+    "QuiverQuantConnector",
+    "IngestionPipeline",
+    "DataValidator",
+    "DataTransformer",
+    "DataLoader",
+]

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",
+]