mcli-framework 7.1.1__py3-none-any.whl → 7.1.2__py3-none-any.whl

mcli/app/main.py

@@ -251,11 +251,11 @@ class LazyCommand(click.Command):
         """Get parameters from the lazily loaded command."""
         cmd = self._load_command()
         return cmd.get_params(ctx)
-    
+
     def shell_complete(self, ctx, param, incomplete):
         """Provide shell completion for the lazily loaded command."""
         cmd = self._load_command()
-        if hasattr(cmd, 'shell_complete'):
+        if hasattr(cmd, "shell_complete"):
             return cmd.shell_complete(ctx, param, incomplete)
         return []
 
@@ -305,11 +305,11 @@ class LazyGroup(click.Group):
         """Get parameters from the lazily loaded group."""
         group = self._load_group()
         return group.get_params(ctx)
-    
+
     def shell_complete(self, ctx, param, incomplete):
         """Provide shell completion for the lazily loaded group."""
         group = self._load_group()
-        if hasattr(group, 'shell_complete'):
+        if hasattr(group, "shell_complete"):
             return group.shell_complete(ctx, param, incomplete)
         return []
 
@@ -333,11 +333,11 @@ def _add_lazy_commands(app: click.Group):
         logger.debug("Added self management commands")
     except Exception as e:
         logger.debug(f"Could not load self commands: {e}")
-    
+
     # Shell completion - load immediately as it's lightweight and useful
     try:
         from mcli.app.completion_cmd import completion
-        
+
         app.add_command(completion, name="completion")
         logger.debug("Added completion commands")
     except ImportError as e:
@@ -346,18 +346,22 @@ def _add_lazy_commands(app: click.Group):
     # Add workflow with completion-aware lazy loading
     try:
         from mcli.app.completion_helpers import create_completion_aware_lazy_group
+
         workflow_group = create_completion_aware_lazy_group(
-            "workflow", 
+            "workflow",
             "mcli.workflow.workflow.workflow",
-            "Workflow commands for automation, video processing, and daemon management"
+            "Workflow commands for automation, video processing, and daemon management",
         )
         app.add_command(workflow_group, name="workflow")
         logger.debug("Added completion-aware workflow group")
     except ImportError as e:
         logger.debug(f"Could not load completion helpers, using standard lazy group: {e}")
         # Fallback to standard lazy group
-        workflow_group = LazyGroup("workflow", "mcli.workflow.workflow.workflow", 
-                                 help="Workflow commands for automation, video processing, and daemon management")
+        workflow_group = LazyGroup(
+            "workflow",
+            "mcli.workflow.workflow.workflow",
+            help="Workflow commands for automation, video processing, and daemon management",
+        )
         app.add_command(workflow_group, name="workflow")
 
     # Lazy load other heavy commands that are used less frequently
@@ -392,15 +396,14 @@ def _add_lazy_commands(app: click.Group):
         # Skip workflow since we already added it with completion support
         if cmd_name == "workflow":
             continue
-            
+
         if cmd_name in ["model", "redis", "logs"]:
             # Use completion-aware LazyGroup for commands that have subcommands
             try:
                 from mcli.app.completion_helpers import create_completion_aware_lazy_group
+
                 lazy_cmd = create_completion_aware_lazy_group(
-                    cmd_name,
-                    cmd_info["import_path"], 
-                    cmd_info["help"]
+                    cmd_name, cmd_info["import_path"], cmd_info["help"]
                 )
             except ImportError:
                 # Fallback to standard LazyGroup

mcli/app/model_cmd.py

@@ -100,7 +100,9 @@ def download(model_name: str):
 
 @model.command()
 @click.option("--model", "-m", help="Specific model to use")
-@click.option("--port", "-p", default=None, help="Port to run server on (default: from config or 51234)")
+@click.option(
+    "--port", "-p", default=None, help="Port to run server on (default: from config or 51234)"
+)
 @click.option(
     "--auto-download",
     is_flag=True,
@@ -113,6 +115,7 @@ def start(model: Optional[str], port: Optional[int], auto_download: bool):
     if port is None:
         try:
             from mcli.lib.config.config import load_config
+
             config = load_config()
             port = config.get("model", {}).get("server_port", 51234)
         except Exception:
@@ -201,13 +204,19 @@ def recommend():
 
 
 @model.command()
-@click.option("--port", "-p", default=None, help="Port where server is running (default: from config or 51234)")
+@click.option(
+    "--port",
+    "-p",
+    default=None,
+    help="Port where server is running (default: from config or 51234)",
+)
 def status(port: Optional[int]):
     """Check status of the lightweight model server."""
     # Load port from config if not specified
     if port is None:
         try:
             from mcli.lib.config.config import load_config
+
             config = load_config()
             port = config.get("model", {}).get("server_port", 51234)
         except Exception:
@@ -243,20 +252,26 @@ def status(port: Optional[int]):
 
 
 @model.command()
-@click.option("--port", "-p", default=None, help="Port where server is running (default: from config or 51234)")
+@click.option(
+    "--port",
+    "-p",
+    default=None,
+    help="Port where server is running (default: from config or 51234)",
+)
 def stop(port: Optional[int]):
     """Stop the lightweight model server."""
     # Load port from config if not specified
     if port is None:
         try:
             from mcli.lib.config.config import load_config
+
             config = load_config()
             port = config.get("model", {}).get("server_port", 51234)
         except Exception:
             port = 51234  # Default ephemeral port
 
-    import requests
     import psutil
+    import requests
 
     try:
         # First check if server is running

mcli/chat/chat.py

@@ -7,6 +7,7 @@ import requests
 # Optional ollama import - gracefully handle if not installed
 try:
     import ollama
+
     OLLAMA_AVAILABLE = True
 except ImportError:
     OLLAMA_AVAILABLE = False
@@ -937,8 +938,8 @@ Respond naturally and helpfully, considering both MCLI commands and system contr
                     console.print("[yellow]For local model support, install ollama:[/yellow]")
                     console.print("  pip install ollama")
                     console.print("\n[yellow]Or switch to OpenAI by configuring:[/yellow]")
-                    console.print("  provider = \"openai\"")
-                    console.print("  openai_api_key = \"your-key-here\"")
+                    console.print('  provider = "openai"')
+                    console.print('  openai_api_key = "your-key-here"')
                     return
 
                 # Use Ollama SDK for local model inference

mcli/lib/search/cached_vectorizer.py

@@ -14,6 +14,7 @@ import numpy as np
 # Optional redis import - gracefully handle if not installed
 try:
     import redis.asyncio as redis
+
     REDIS_AVAILABLE = True
 except ImportError:
     REDIS_AVAILABLE = False

mcli/lib/services/data_pipeline.py

@@ -6,11 +6,12 @@ Handles ETL processes for data received from LSH daemon
 import asyncio
 import json
 import time
-from typing import Any, Dict, List, Optional, Callable
 from datetime import datetime, timezone
 from pathlib import Path
+from typing import Any, Callable, Dict, List, Optional
 
 from mcli.lib.logger.logger import get_logger
+
 from .lsh_client import LSHClient, LSHEventProcessor
 
 logger = get_logger(__name__)
@@ -186,7 +187,9 @@ class DataProcessor:
                 # Validate
                 if self.config.enable_validation:
                     if not await self.validator.validate_trading_record(record):
-                        self.logger.warning(f"Validation failed for record: {record.get('id', 'unknown')}")
+                        self.logger.warning(
+                            f"Validation failed for record: {record.get('id', 'unknown')}"
+                        )
                         continue
 
                 # Enrich
@@ -208,7 +211,9 @@ class DataProcessor:
         self.logger.info(f"Processed {len(processed_records)}/{len(records)} trading records")
         return processed_records
 
-    async def process_supabase_sync(self, table: str, operation: str, data: Dict[str, Any]) -> Dict[str, Any]:
+    async def process_supabase_sync(
+        self, table: str, operation: str, data: Dict[str, Any]
+    ) -> Dict[str, Any]:
         """Process Supabase sync data"""
         try:
             # Validate
@@ -231,7 +236,9 @@ class DataProcessor:
             self.logger.error(f"Error processing Supabase sync: {e}")
             return {}
 
-    async def _transform_supabase_data(self, table: str, operation: str, data: Dict[str, Any]) -> Dict[str, Any]:
+    async def _transform_supabase_data(
+        self, table: str, operation: str, data: Dict[str, Any]
+    ) -> Dict[str, Any]:
         """Transform Supabase data based on table schema"""
         transformed = data.copy()
 
@@ -457,4 +464,4 @@ class LSHDataPipeline:
                 "batch_timeout": self.config.batch_timeout,
                 "output_dir": str(self.config.output_dir),
             },
-        }
+        }

mcli/lib/services/lsh_client.py

@@ -8,7 +8,7 @@ import json
 import logging
 import os
 import time
-from typing import Any, Dict, List, Optional, Callable
+from typing import Any, Callable, Dict, List, Optional
 from urllib.parse import urljoin
 
 import aiohttp
@@ -51,9 +51,7 @@ class LSHClient:
         """Initialize aiohttp session"""
         if not self.session:
             connector = aiohttp.TCPConnector(limit=10)
-            self.session = aiohttp.ClientSession(
-                connector=connector, timeout=self.timeout
-            )
+            self.session = aiohttp.ClientSession(connector=connector, timeout=self.timeout)
             logger.info(f"Connected to LSH API at {self.base_url}")
 
     async def disconnect(self):
@@ -81,9 +79,7 @@ class LSHClient:
         headers = self._get_headers()
 
         try:
-            async with self.session.request(
-                method, url, headers=headers, json=data
-            ) as response:
+            async with self.session.request(method, url, headers=headers, json=data) as response:
                 if response.status == 401:
                     raise ValueError("LSH API authentication failed - check API key")
 
@@ -104,9 +100,7 @@ class LSHClient:
         endpoint = "/api/jobs"
         if filter_params:
             # Convert filter to query params
-            endpoint += "?" + "&".join(
-                f"{k}={v}" for k, v in filter_params.items()
-            )
+            endpoint += "?" + "&".join(f"{k}={v}" for k, v in filter_params.items())
         return await self._request("GET", endpoint)
 
     async def get_job(self, job_id: str) -> Dict[str, Any]:
@@ -261,12 +255,15 @@ class LSHEventProcessor:
         self.logger.info(f"LSH job started: {job_name} ({job_id})")
 
         # Emit mcli-specific event
-        await self._emit_mcli_event("lsh.job.started", {
-            "job_id": job_id,
-            "job_name": job_name,
-            "timestamp": data.get("timestamp"),
-            "job_data": job_data
-        })
+        await self._emit_mcli_event(
+            "lsh.job.started",
+            {
+                "job_id": job_id,
+                "job_name": job_name,
+                "timestamp": data.get("timestamp"),
+                "job_data": job_data,
+            },
+        )
 
     async def _handle_job_completed(self, data: Dict[str, Any]):
         """Handle job completion event"""
@@ -289,14 +286,17 @@ class LSHEventProcessor:
             await self._process_supabase_job(job_data)
 
         # Emit mcli-specific event
-        await self._emit_mcli_event("lsh.job.completed", {
-            "job_id": job_id,
-            "job_name": job_name,
-            "timestamp": data.get("timestamp"),
-            "job_data": job_data,
-            "stdout": stdout,
-            "stderr": stderr
-        })
+        await self._emit_mcli_event(
+            "lsh.job.completed",
+            {
+                "job_id": job_id,
+                "job_name": job_name,
+                "timestamp": data.get("timestamp"),
+                "job_data": job_data,
+                "stdout": stdout,
+                "stderr": stderr,
+            },
+        )
 
     async def _handle_job_failed(self, data: Dict[str, Any]):
         """Handle job failure event"""
@@ -308,13 +308,16 @@ class LSHEventProcessor:
         self.logger.error(f"LSH job failed: {job_name} ({job_id}) - {error}")
 
         # Emit mcli-specific event
-        await self._emit_mcli_event("lsh.job.failed", {
-            "job_id": job_id,
-            "job_name": job_name,
-            "timestamp": data.get("timestamp"),
-            "error": error,
-            "job_data": job_data
-        })
+        await self._emit_mcli_event(
+            "lsh.job.failed",
+            {
+                "job_id": job_id,
+                "job_name": job_name,
+                "timestamp": data.get("timestamp"),
+                "error": error,
+                "job_data": job_data,
+            },
+        )
 
     async def _handle_supabase_sync(self, data: Dict[str, Any]):
         """Handle Supabase data sync event"""
@@ -329,12 +332,15 @@ class LSHEventProcessor:
             await self._process_politician_data(table, operation, sync_data)
 
         # Emit mcli-specific event
-        await self._emit_mcli_event("lsh.supabase.sync", {
-            "table": table,
-            "operation": operation,
-            "data": sync_data,
-            "timestamp": data.get("timestamp")
-        })
+        await self._emit_mcli_event(
+            "lsh.supabase.sync",
+            {
+                "table": table,
+                "operation": operation,
+                "data": sync_data,
+                "timestamp": data.get("timestamp"),
+            },
+        )
 
     async def _process_trading_data(self, job_data: Dict, stdout: str):
         """Process politician trading data from job output"""
@@ -343,7 +349,7 @@ class LSHEventProcessor:
             if stdout.strip():
                 # Assuming JSON output format
                 trading_records = []
-                for line in stdout.strip().split('\n'):
+                for line in stdout.strip().split("\n"):
                     try:
                         record = json.loads(line)
                         trading_records.append(record)
@@ -354,12 +360,15 @@ class LSHEventProcessor:
                     self.logger.info(f"Processed {len(trading_records)} trading records")
 
                     # Emit processed data event
-                    await self._emit_mcli_event("trading.data.processed", {
-                        "records": trading_records,
-                        "count": len(trading_records),
-                        "job_id": job_data.get("id"),
-                        "timestamp": time.time()
-                    })
+                    await self._emit_mcli_event(
+                        "trading.data.processed",
+                        {
+                            "records": trading_records,
+                            "count": len(trading_records),
+                            "job_id": job_data.get("id"),
+                            "timestamp": time.time(),
+                        },
+                    )
 
         except Exception as e:
             self.logger.error(f"Error processing trading data: {e}")
@@ -373,11 +382,10 @@ class LSHEventProcessor:
             self.logger.info(f"Processing Supabase sync job: {job_data.get('name')}")
 
             # Emit database sync event
-            await self._emit_mcli_event("database.sync.completed", {
-                "job_id": job_data.get("id"),
-                "sync_info": sync_info,
-                "timestamp": time.time()
-            })
+            await self._emit_mcli_event(
+                "database.sync.completed",
+                {"job_id": job_data.get("id"), "sync_info": sync_info, "timestamp": time.time()},
+            )
 
         except Exception as e:
             self.logger.error(f"Error processing Supabase job: {e}")
@@ -391,13 +399,16 @@ class LSHEventProcessor:
             processed_data = await self._transform_politician_data(table, operation, data)
 
             # Emit transformed data event
-            await self._emit_mcli_event("politician.data.updated", {
-                "table": table,
-                "operation": operation,
-                "original_data": data,
-                "processed_data": processed_data,
-                "timestamp": time.time()
-            })
+            await self._emit_mcli_event(
+                "politician.data.updated",
+                {
+                    "table": table,
+                    "operation": operation,
+                    "original_data": data,
+                    "processed_data": processed_data,
+                    "timestamp": time.time(),
+                },
+            )
 
         except Exception as e:
             self.logger.error(f"Error processing politician data: {e}")
@@ -438,4 +449,4 @@ class LSHEventProcessor:
     async def start_processing(self):
         """Start processing LSH events"""
         self.logger.info("Starting LSH event processing...")
-        await self.client.stream_events()
+        await self.client.stream_events()

mcli/ml/api/app.py

@@ -1,37 +1,38 @@
 """FastAPI application factory and configuration"""
 
 from contextlib import asynccontextmanager
-from typing import Dict, Any
+from typing import Any, Dict
 
+import uvicorn
 from fastapi import FastAPI, Request, Response
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.middleware.gzip import GZipMiddleware
 from fastapi.middleware.trustedhost import TrustedHostMiddleware
 from fastapi.responses import JSONResponse
 from starlette.middleware.sessions import SessionMiddleware
-import uvicorn
 
+from mcli.ml.cache import init_cache
 from mcli.ml.config import settings
 from mcli.ml.database.session import init_db
-from mcli.ml.cache import init_cache
-from mcli.ml.logging import setup_logging, get_logger
+from mcli.ml.logging import get_logger, setup_logging
+
+from .middleware import (
+    ErrorHandlingMiddleware,
+    RateLimitMiddleware,
+    RequestLoggingMiddleware,
+)
 from .routers import (
+    admin_router,
     auth_router,
+    backtest_router,
+    data_router,
     model_router,
-    prediction_router,
+    monitoring_router,
     portfolio_router,
-    data_router,
+    prediction_router,
     trade_router,
-    backtest_router,
-    monitoring_router,
-    admin_router,
     websocket_router,
 )
-from .middleware import (
-    RequestLoggingMiddleware,
-    RateLimitMiddleware,
-    ErrorHandlingMiddleware,
-)
 
 logger = get_logger(__name__)
 
@@ -52,6 +53,7 @@ async def lifespan(app: FastAPI):
 
     # Initialize ML models
     from mcli.ml.models import load_production_models
+
     await load_production_models()
     logger.info("ML models loaded")
 
@@ -62,10 +64,12 @@ async def lifespan(app: FastAPI):
 
     # Cleanup cache connections
     from mcli.ml.cache import close_cache
+
     await close_cache()
 
     # Cleanup database connections
     from mcli.ml.database.session import async_engine
+
     await async_engine.dispose()
 
 
@@ -109,10 +113,7 @@ def create_app() -> FastAPI:
 
     # Trusted host middleware
     if settings.is_production:
-        app.add_middleware(
-            TrustedHostMiddleware,
-            allowed_hosts=["*.mcli-ml.com", "mcli-ml.com"]
-        )
+        app.add_middleware(TrustedHostMiddleware, allowed_hosts=["*.mcli-ml.com", "mcli-ml.com"])
 
     # Include routers
     app.include_router(auth_router.router, prefix="/api/v1/auth", tags=["Authentication"])
@@ -130,18 +131,14 @@ def create_app() -> FastAPI:
     @app.get("/health", tags=["Health"])
     async def health_check():
         """Health check endpoint"""
-        return {
-            "status": "healthy",
-            "environment": settings.environment,
-            "version": "1.0.0"
-        }
+        return {"status": "healthy", "environment": settings.environment, "version": "1.0.0"}
 
     # Ready check endpoint
     @app.get("/ready", tags=["Health"])
     async def ready_check():
         """Readiness check endpoint"""
-        from mcli.ml.database.session import check_database_health
         from mcli.ml.cache import check_cache_health
+        from mcli.ml.database.session import check_database_health
 
         db_healthy = await check_database_health()
         cache_healthy = await check_cache_health()
@@ -154,8 +151,8 @@ def create_app() -> FastAPI:
                 content={
                     "status": "not ready",
                     "database": "healthy" if db_healthy else "unhealthy",
-                    "cache": "healthy" if cache_healthy else "unhealthy"
-                }
+                    "cache": "healthy" if cache_healthy else "unhealthy",
+                },
             )
 
     # Metrics endpoint (Prometheus format)
@@ -163,6 +160,7 @@ def create_app() -> FastAPI:
     async def metrics():
         """Prometheus metrics endpoint"""
         from mcli.ml.monitoring.metrics import get_metrics
+
         return Response(content=get_metrics(), media_type="text/plain")
 
     # Root endpoint
@@ -172,24 +170,18 @@ def create_app() -> FastAPI:
         return {
             "message": "MCLI ML System API",
             "version": "1.0.0",
-            "docs": "/docs" if settings.debug else None
+            "docs": "/docs" if settings.debug else None,
         }
 
     # Exception handlers
     @app.exception_handler(404)
     async def not_found_handler(request: Request, exc):
-        return JSONResponse(
-            status_code=404,
-            content={"detail": "Resource not found"}
-        )
+        return JSONResponse(status_code=404, content={"detail": "Resource not found"})
 
     @app.exception_handler(500)
     async def internal_server_error_handler(request: Request, exc):
         logger.error(f"Internal server error: {exc}")
-        return JSONResponse(
-            status_code=500,
-            content={"detail": "Internal server error"}
-        )
+        return JSONResponse(status_code=500, content={"detail": "Internal server error"})
 
     return app
 
@@ -212,4 +204,4 @@ if __name__ == "__main__":
         workers=settings.api.workers,
         reload=settings.debug,
         log_level="debug" if settings.debug else "info",
-    )
+    )

mcli/ml/api/middleware.py

@@ -2,11 +2,11 @@
 
 import time
 import uuid
-from typing import Callable
 from collections import defaultdict
 from datetime import datetime, timedelta
+from typing import Callable
 
-from fastapi import Request, Response, HTTPException
+from fastapi import HTTPException, Request, Response
 from fastapi.responses import JSONResponse
 from starlette.middleware.base import BaseHTTPMiddleware
 from starlette.types import ASGIApp
@@ -34,8 +34,7 @@ class RequestLoggingMiddleware(BaseHTTPMiddleware):
         # Log response
         process_time = time.time() - start_time
         logger.info(
-            f"Response {request_id}: status={response.status_code} "
-            f"duration={process_time:.3f}s"
+            f"Response {request_id}: status={response.status_code} " f"duration={process_time:.3f}s"
         )
 
         # Add headers
@@ -67,8 +66,7 @@ class RateLimitMiddleware(BaseHTTPMiddleware):
 
         # Clean old requests
         self.clients[client_ip] = [
-            req_time for req_time in self.clients[client_ip]
-            if req_time > minute_ago
+            req_time for req_time in self.clients[client_ip] if req_time > minute_ago
         ]
 
         # Check if limit exceeded
@@ -77,7 +75,7 @@ class RateLimitMiddleware(BaseHTTPMiddleware):
             return JSONResponse(
                 status_code=429,
                 content={"detail": "Rate limit exceeded. Please try again later."},
-                headers={"Retry-After": "60"}
+                headers={"Retry-After": "60"},
             )
 
         # Record request
@@ -102,18 +100,12 @@ class ErrorHandlingMiddleware(BaseHTTPMiddleware):
         except Exception as e:
             # Log unexpected errors
             request_id = getattr(request.state, "request_id", "unknown")
-            logger.error(
-                f"Unhandled exception in request {request_id}: {str(e)}",
-                exc_info=True
-            )
+            logger.error(f"Unhandled exception in request {request_id}: {str(e)}", exc_info=True)
 
             # Return generic error response
             return JSONResponse(
                 status_code=500,
-                content={
-                    "detail": "An internal error occurred",
-                    "request_id": request_id
-                }
+                content={"detail": "An internal error occurred", "request_id": request_id},
             )
 
 
@@ -221,4 +213,4 @@ class MetricsMiddleware(BaseHTTPMiddleware):
                     "min_duration": min(durations),
                     "max_duration": max(durations),
                 }
-        return metrics
+        return metrics