mcli-framework 7.12.1__py3-none-any.whl → 7.12.3__py3-none-any.whl

mcli/lib/pickles/__init__.py

@@ -1 +0,0 @@
-from .pickles import ObjectCache

mcli/lib/pickles/pickles.py

@@ -3,8 +3,6 @@ import pickle
 from pathlib import Path
 from typing import Callable, Generic, Type, TypeVar
 
-import click
-
 T = TypeVar("T")
 
 

mcli/lib/secrets/commands.py

@@ -17,7 +17,6 @@ from .store import SecretsStore
 @click.group(name="secrets", help="Secure secrets management with encryption and git sync")
 def secrets_group():
     """Secrets management commands."""
-    pass
 
 
 @secrets_group.command(name="repl", help="Launch interactive secrets shell")
@@ -127,7 +126,6 @@ def secrets_import(env_file: str, namespace: str):
 @secrets_group.group(name="store", help="Git-based secrets synchronization")
 def store_group():
     """Store management commands."""
-    pass
 
 
 @store_group.command(name="init", help="Initialize secrets store")

mcli/lib/secrets/manager.py

@@ -3,7 +3,6 @@ Secrets manager for handling secure storage and retrieval of secrets.
 """
 
 import base64
-import json
 import os
 from pathlib import Path
 from typing import Dict, List, Optional

mcli/lib/secrets/repl.py

@@ -2,7 +2,6 @@
 REPL (Read-Eval-Print Loop) for LSH secrets management.
 """
 
-import os
 from pathlib import Path
 from typing import List
 
@@ -13,13 +12,13 @@ from prompt_toolkit.completion import WordCompleter
 from prompt_toolkit.history import FileHistory
 
 from mcli.lib.logger.logger import get_logger
-
-logger = get_logger(__name__)
 from mcli.lib.ui.styling import console, error, info, success, warning
 
 from .manager import SecretsManager
 from .store import SecretsStore
 
+logger = get_logger(__name__)
+
 
 class SecretsREPL:
     """Interactive REPL for secrets management."""

mcli/lib/secrets/store.py

@@ -7,13 +7,12 @@ 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
+from mcli.lib.ui.styling import error, info, success, warning
 
 logger = get_logger(__name__)
-from mcli.lib.ui.styling import error, info, success, warning
 
 
 class SecretsStore:

mcli/lib/services/data_pipeline.py

@@ -8,7 +8,7 @@ import json
 import time
 from datetime import datetime, timezone
 from pathlib import Path
-from typing import Any, Callable, Dict, List, Optional
+from typing import Any, Dict, List, Optional
 
 from mcli.lib.logger.logger import get_logger
 
@@ -18,7 +18,7 @@ logger = get_logger(__name__)
 
 
 class DataPipelineConfig:
-    """Configuration for data pipeline"""
+    """Configuration for data pipeline."""
 
     def __init__(self):
         self.batch_size = 100
@@ -31,13 +31,13 @@ class DataPipelineConfig:
 
 
 class DataValidator:
-    """Validates incoming data"""
+    """Validates incoming data."""
 
     def __init__(self):
         self.logger = get_logger(f"{__name__}.validator")
 
     async def validate_trading_record(self, record: Dict[str, Any]) -> bool:
-        """Validate politician trading record"""
+        """Validate politician trading record."""
         required_fields = [
             "politician_name",
             "transaction_date",
@@ -69,7 +69,7 @@ class DataValidator:
         return True
 
     async def validate_supabase_record(self, table: str, record: Dict[str, Any]) -> bool:
-        """Validate Supabase record based on table schema"""
+        """Validate Supabase record based on table schema."""
         if not record:
             return False
 
@@ -82,13 +82,13 @@ class DataValidator:
 
 
 class DataEnricher:
-    """Enriches data with additional information"""
+    """Enriches data with additional information."""
 
     def __init__(self):
         self.logger = get_logger(f"{__name__}.enricher")
 
     async def enrich_trading_record(self, record: Dict[str, Any]) -> Dict[str, Any]:
-        """Enrich trading record with additional data"""
+        """Enrich trading record with additional data."""
         enriched = record.copy()
 
         # Add processing timestamp
@@ -115,7 +115,7 @@ class DataEnricher:
         return enriched
 
     def _categorize_amount(self, amount: float) -> str:
-        """Categorize transaction amount"""
+        """Categorize transaction amount."""
         if amount < 1000:
             return "micro"
         elif amount < 15000:
@@ -128,7 +128,7 @@ class DataEnricher:
             return "mega"
 
     def _bucket_amount(self, amount: float) -> str:
-        """Bucket amounts for analysis"""
+        """Bucket amounts for analysis."""
         if amount < 1000:
             return "0-1K"
         elif amount < 10000:
@@ -145,7 +145,7 @@ class DataEnricher:
             return "1M+"
 
     async def _get_politician_metadata(self, politician_name: str) -> Dict[str, Any]:
-        """Get politician metadata (placeholder for external API)"""
+        """Get politician metadata (placeholder for external API)."""
         # This would typically call an external API
         return {
             "enriched_at": datetime.now(timezone.utc).isoformat(),
@@ -154,7 +154,7 @@ class DataEnricher:
         }
 
     async def _get_market_context(self, asset_name: str, transaction_date: str) -> Dict[str, Any]:
-        """Get market context for the transaction (placeholder)"""
+        """Get market context for the transaction (placeholder)."""
         # This would typically call financial APIs
         return {
             "enriched_at": datetime.now(timezone.utc).isoformat(),
@@ -164,7 +164,7 @@ class DataEnricher:
 
 
 class DataProcessor:
-    """Main data processing engine"""
+    """Main data processing engine."""
 
     def __init__(self, config: DataPipelineConfig):
         self.config = config
@@ -179,13 +179,13 @@ class DataProcessor:
         self.config.output_dir.mkdir(parents=True, exist_ok=True)
 
     async def process_trading_data(self, records: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
-        """Process politician trading data"""
+        """Process politician trading data."""
         processed_records = []
 
         for record in records:
             try:
                 # Validate
-                if self.config.enable_validation:
+                if self.config.enable_validation:  # noqa: SIM102
                     if not await self.validator.validate_trading_record(record):
                         self.logger.warning(
                             f"Validation failed for record: {record.get('id', 'unknown')}"
@@ -214,10 +214,10 @@ class DataProcessor:
     async def process_supabase_sync(
         self, table: str, operation: str, data: Dict[str, Any]
     ) -> Dict[str, Any]:
-        """Process Supabase sync data"""
+        """Process Supabase sync data."""
         try:
             # Validate
-            if self.config.enable_validation:
+            if self.config.enable_validation:  # noqa: SIM102
                 if not await self.validator.validate_supabase_record(table, data):
                     self.logger.warning(f"Validation failed for {table} record")
                     return {}
@@ -239,7 +239,7 @@ class DataProcessor:
     async def _transform_supabase_data(
         self, table: str, operation: str, data: Dict[str, Any]
     ) -> Dict[str, Any]:
-        """Transform Supabase data based on table schema"""
+        """Transform Supabase data based on table schema."""
         transformed = data.copy()
 
         # Apply table-specific transformations
@@ -251,7 +251,7 @@ class DataProcessor:
         return transformed
 
     async def _transform_politician_table(self, data: Dict[str, Any]) -> Dict[str, Any]:
-        """Transform politician table data"""
+        """Transform politician table data."""
         # Normalize names
         if "name" in data:
             data["name_normalized"] = data["name"].title()
@@ -263,14 +263,14 @@ class DataProcessor:
         return data
 
     async def _transform_trading_table(self, data: Dict[str, Any]) -> Dict[str, Any]:
-        """Transform trading table data"""
+        """Transform trading table data."""
         # Normalize asset names
         if "asset_name" in data:
             data["asset_name_normalized"] = data["asset_name"].upper()
 
         # Convert amounts to float
         if "amount" in data and isinstance(data["amount"], str):
-            try:
+            try:  # noqa: SIM105
                 data["amount_float"] = float(data["amount"])
             except ValueError:
                 pass
@@ -278,7 +278,7 @@ class DataProcessor:
         return data
 
     async def add_to_batch(self, record: Dict[str, Any]):
-        """Add record to batch for processing"""
+        """Add record to batch for processing."""
         async with self._processing_lock:
             self.batch_buffer.append(record)
 
@@ -293,7 +293,7 @@ class DataProcessor:
                 await self._process_batch()
 
     async def _process_batch(self):
-        """Process accumulated batch"""
+        """Process accumulated batch."""
         if not self.batch_buffer:
             return
 
@@ -319,7 +319,7 @@ class DataProcessor:
             self.batch_buffer.extend(batch)
 
     async def _save_batch(self, batch: List[Dict[str, Any]]):
-        """Save processed batch to file"""
+        """Save processed batch to file."""
         if not batch:
             return
 
@@ -338,18 +338,18 @@ class DataProcessor:
             self.logger.error(f"Failed to save batch: {e}")
 
     async def _emit_batch_completed(self, batch: List[Dict[str, Any]]):
-        """Emit batch completion event"""
+        """Emit batch completion event."""
         self.logger.info(f"Batch processing completed: {len(batch)} records")
 
     async def flush_batch(self):
-        """Force process current batch"""
+        """Force process current batch."""
         async with self._processing_lock:
             if self.batch_buffer:
                 await self._process_batch()
 
 
 class LSHDataPipeline:
-    """Main integration service for LSH-mcli data pipeline"""
+    """Main integration service for LSH-mcli data pipeline."""
 
     def __init__(self, lsh_client: LSHClient, config: Optional[DataPipelineConfig] = None):
         self.lsh_client = lsh_client
@@ -363,13 +363,13 @@ class LSHDataPipeline:
         self._setup_pipeline_handlers()
 
     def _setup_pipeline_handlers(self):
-        """Setup event handlers for pipeline processing"""
+        """Setup event handlers for pipeline processing."""
         self.lsh_client.on("lsh.job.completed", self._handle_job_completed)
         self.lsh_client.on("lsh.supabase.sync", self._handle_supabase_sync)
         self.lsh_client.on("trading.data.processed", self._handle_trading_data)
 
     async def _handle_job_completed(self, event_data: Dict[str, Any]):
-        """Handle LSH job completion"""
+        """Handle LSH job completion."""
         job_name = event_data.get("job_name", "")
         job_id = event_data.get("job_id", "")
 
@@ -382,7 +382,7 @@ class LSHDataPipeline:
                 await self._process_job_output(job_id, stdout)
 
     async def _handle_supabase_sync(self, event_data: Dict[str, Any]):
-        """Handle Supabase sync event"""
+        """Handle Supabase sync event."""
         table = event_data.get("table", "")
         operation = event_data.get("operation", "")
         data = event_data.get("data", {})
@@ -394,7 +394,7 @@ class LSHDataPipeline:
             await self.processor.add_to_batch(processed_data)
 
     async def _handle_trading_data(self, event_data: Dict[str, Any]):
-        """Handle processed trading data"""
+        """Handle processed trading data."""
         records = event_data.get("records", [])
 
         self.logger.info(f"Received {len(records)} trading records for pipeline processing")
@@ -403,7 +403,7 @@ class LSHDataPipeline:
             await self.processor.add_to_batch(record)
 
     async def _process_job_output(self, job_id: str, output: str):
-        """Process job output data"""
+        """Process job output data."""
         try:
             # Parse output lines as JSON
             records = []
@@ -425,7 +425,7 @@ class LSHDataPipeline:
             self.logger.error(f"Error processing job output: {e}")
 
     async def start(self):
-        """Start the data pipeline"""
+        """Start the data pipeline."""
         if self._is_running:
             self.logger.warning("Pipeline already running")
             return
@@ -443,7 +443,7 @@ class LSHDataPipeline:
             raise
 
     async def stop(self):
-        """Stop the data pipeline"""
+        """Stop the data pipeline."""
         if not self._is_running:
             return
 
@@ -454,7 +454,7 @@ class LSHDataPipeline:
         await self.processor.flush_batch()
 
     async def get_stats(self) -> Dict[str, Any]:
-        """Get pipeline statistics"""
+        """Get pipeline statistics."""
         return {
             "is_running": self._is_running,
             "batch_buffer_size": len(self.processor.batch_buffer),

mcli/lib/services/lsh_client.py

@@ -5,14 +5,12 @@ Provides integration with LSH daemon API server for data pipeline processing
 
 import asyncio
 import json
-import logging
 import os
 import time
 from typing import Any, Callable, Dict, List, Optional
 from urllib.parse import urljoin
 
 import aiohttp
-import aiomqtt
 from aiohttp_sse_client import client as sse_client
 
 from mcli.lib.logger.logger import get_logger
@@ -21,7 +19,7 @@ logger = get_logger(__name__)
 
 
 class LSHClient:
-    """Client for connecting to LSH daemon API server"""
+    """Client for connecting to LSH daemon API server."""
 
     def __init__(
         self,
@@ -39,30 +37,30 @@ class LSHClient:
             logger.warning("LSH_API_KEY not set - authentication may fail")
 
     async def __aenter__(self):
-        """Async context manager entry"""
+        """Async context manager entry."""
         await self.connect()
         return self
 
     async def __aexit__(self, exc_type, exc_val, exc_tb):
-        """Async context manager exit"""
+        """Async context manager exit."""
         await self.disconnect()
 
     async def connect(self):
-        """Initialize aiohttp session"""
+        """Initialize aiohttp session."""
         if not self.session:
             connector = aiohttp.TCPConnector(limit=10)
             self.session = aiohttp.ClientSession(connector=connector, timeout=self.timeout)
             logger.info(f"Connected to LSH API at {self.base_url}")
 
     async def disconnect(self):
-        """Close aiohttp session"""
+        """Close aiohttp session."""
         if self.session:
             await self.session.close()
             self.session = None
             logger.info("Disconnected from LSH API")
 
     def _get_headers(self) -> Dict[str, str]:
-        """Get HTTP headers with authentication"""
+        """Get HTTP headers with authentication."""
         headers = {"Content-Type": "application/json"}
         if self.api_key:
             headers["X-API-Key"] = self.api_key
@@ -71,7 +69,7 @@ class LSHClient:
     async def _request(
         self, method: str, endpoint: str, data: Optional[Dict] = None
     ) -> Dict[str, Any]:
-        """Make HTTP request to LSH API"""
+        """Make HTTP request to LSH API."""
         if not self.session:
             await self.connect()
 
@@ -92,11 +90,11 @@ class LSHClient:
 
     # Job Management
     async def get_status(self) -> Dict[str, Any]:
-        """Get LSH daemon status"""
+        """Get LSH daemon status."""
         return await self._request("GET", "/api/status")
 
     async def list_jobs(self, filter_params: Optional[Dict] = None) -> List[Dict]:
-        """List all jobs from LSH daemon"""
+        """List all jobs from LSH daemon."""
         endpoint = "/api/jobs"
         if filter_params:
             # Convert filter to query params
@@ -104,60 +102,60 @@ class LSHClient:
         return await self._request("GET", endpoint)
 
     async def get_job(self, job_id: str) -> Dict[str, Any]:
-        """Get specific job details"""
+        """Get specific job details."""
         return await self._request("GET", f"/api/jobs/{job_id}")
 
     async def create_job(self, job_spec: Dict[str, Any]) -> Dict[str, Any]:
-        """Create a new job in LSH daemon"""
+        """Create a new job in LSH daemon."""
         return await self._request("POST", "/api/jobs", job_spec)
 
     async def trigger_job(self, job_id: str) -> Dict[str, Any]:
-        """Trigger job execution"""
+        """Trigger job execution."""
         return await self._request("POST", f"/api/jobs/{job_id}/trigger")
 
     async def start_job(self, job_id: str) -> Dict[str, Any]:
-        """Start a job"""
+        """Start a job."""
         return await self._request("POST", f"/api/jobs/{job_id}/start")
 
     async def stop_job(self, job_id: str, signal: str = "SIGTERM") -> Dict[str, Any]:
-        """Stop a job"""
+        """Stop a job."""
         return await self._request("POST", f"/api/jobs/{job_id}/stop", {"signal": signal})
 
     async def remove_job(self, job_id: str, force: bool = False) -> None:
-        """Remove a job"""
+        """Remove a job."""
         params = {"force": str(force).lower()}
         endpoint = f"/api/jobs/{job_id}?" + "&".join(f"{k}={v}" for k, v in params.items())
         await self._request("DELETE", endpoint)
 
     async def bulk_create_jobs(self, jobs: List[Dict[str, Any]]) -> Dict[str, Any]:
-        """Create multiple jobs"""
+        """Create multiple jobs."""
         return await self._request("POST", "/api/jobs/bulk", {"jobs": jobs})
 
     # Data Export
     async def export_jobs(self, format: str = "json") -> str:
-        """Export job data"""
+        """Export job data."""
         endpoint = f"/api/export/jobs?format={format}"
         return await self._request("GET", endpoint)
 
     # Webhook Management
     async def list_webhooks(self) -> Dict[str, Any]:
-        """List configured webhooks"""
+        """List configured webhooks."""
         return await self._request("GET", "/api/webhooks")
 
     async def add_webhook(self, endpoint_url: str) -> Dict[str, Any]:
-        """Add webhook endpoint"""
+        """Add webhook endpoint."""
         return await self._request("POST", "/api/webhooks", {"endpoint": endpoint_url})
 
     # Event Handling
     def on(self, event_type: str, handler: Callable):
-        """Register event handler"""
+        """Register event handler."""
         if event_type not in self._event_handlers:
             self._event_handlers[event_type] = []
         self._event_handlers[event_type].append(handler)
         logger.info(f"Registered handler for event: {event_type}")
 
     async def _emit_event(self, event_type: str, data: Any):
-        """Emit event to registered handlers"""
+        """Emit event to registered handlers."""
         if event_type in self._event_handlers:
             for handler in self._event_handlers[event_type]:
                 try:
@@ -169,7 +167,7 @@ class LSHClient:
                     logger.error(f"Error in event handler for {event_type}: {e}")
 
     async def stream_events(self):
-        """Stream events from LSH API using Server-Sent Events"""
+        """Stream events from LSH API using Server-Sent Events."""
         if not self.session:
             await self.connect()
 
@@ -207,13 +205,13 @@ class LSHClient:
     async def trigger_supabase_sync(
         self, table: str, operation: str, data: Dict[str, Any]
     ) -> Dict[str, Any]:
-        """Trigger Supabase data sync notification"""
+        """Trigger Supabase data sync notification."""
         payload = {"table": table, "operation": operation, "data": data}
         return await self._request("POST", "/api/supabase/sync", payload)
 
     # Health Check
     async def health_check(self) -> bool:
-        """Check if LSH API is healthy"""
+        """Check if LSH API is healthy."""
         try:
             if not self.session:
                 await self.connect()
@@ -227,7 +225,7 @@ class LSHClient:
 
 
 class LSHEventProcessor:
-    """Process events from LSH daemon for data pipeline integration"""
+    """Process events from LSH daemon for data pipeline integration."""
 
     def __init__(self, lsh_client: LSHClient):
         self.client = lsh_client
@@ -235,7 +233,7 @@ class LSHEventProcessor:
         self._setup_event_handlers()
 
     def _setup_event_handlers(self):
-        """Setup default event handlers"""
+        """Setup default event handlers."""
         self.client.on("job:completed", self._handle_job_completed)
         self.client.on("job:failed", self._handle_job_failed)
         self.client.on("job:started", self._handle_job_started)
@@ -243,11 +241,11 @@ class LSHEventProcessor:
         self.client.on("connected", self._handle_connected)
 
     async def _handle_connected(self, data: Dict[str, Any]):
-        """Handle connection established event"""
+        """Handle connection established event."""
         self.logger.info("Connected to LSH event stream")
 
     async def _handle_job_started(self, data: Dict[str, Any]):
-        """Handle job started event"""
+        """Handle job started event."""
         job_data = data.get("data", {})
         job_id = job_data.get("id", "unknown")
         job_name = job_data.get("name", "unknown")
@@ -266,7 +264,7 @@ class LSHEventProcessor:
         )
 
     async def _handle_job_completed(self, data: Dict[str, Any]):
-        """Handle job completion event"""
+        """Handle job completion event."""
         job_data = data.get("data", {})
         job_id = job_data.get("id", "unknown")
         job_name = job_data.get("name", "unknown")
@@ -299,7 +297,7 @@ class LSHEventProcessor:
         )
 
     async def _handle_job_failed(self, data: Dict[str, Any]):
-        """Handle job failure event"""
+        """Handle job failure event."""
         job_data = data.get("data", {})
         job_id = job_data.get("id", "unknown")
         job_name = job_data.get("name", "unknown")
@@ -320,7 +318,7 @@ class LSHEventProcessor:
         )
 
     async def _handle_supabase_sync(self, data: Dict[str, Any]):
-        """Handle Supabase data sync event"""
+        """Handle Supabase data sync event."""
         table = data.get("table", "unknown")
         operation = data.get("operation", "unknown")
         sync_data = data.get("data", {})
@@ -343,7 +341,7 @@ class LSHEventProcessor:
         )
 
     async def _process_trading_data(self, job_data: Dict, stdout: str):
-        """Process politician trading data from job output"""
+        """Process politician trading data from job output."""
         try:
             # Parse trading data from stdout
             if stdout.strip():
@@ -374,7 +372,7 @@ class LSHEventProcessor:
             self.logger.error(f"Error processing trading data: {e}")
 
     async def _process_supabase_job(self, job_data: Dict):
-        """Process Supabase synchronization job"""
+        """Process Supabase synchronization job."""
         try:
             # Check for database sync metadata
             sync_info = job_data.get("databaseSync", {})
@@ -391,7 +389,7 @@ class LSHEventProcessor:
             self.logger.error(f"Error processing Supabase job: {e}")
 
     async def _process_politician_data(self, table: str, operation: str, data: Dict):
-        """Process politician-related data changes"""
+        """Process politician-related data changes."""
         try:
             self.logger.info(f"Processing politician data: {operation} on {table}")
 
@@ -414,7 +412,7 @@ class LSHEventProcessor:
             self.logger.error(f"Error processing politician data: {e}")
 
     async def _transform_politician_data(self, table: str, operation: str, data: Dict) -> Dict:
-        """Transform politician data based on business rules"""
+        """Transform politician data based on business rules."""
         # Apply transformations here
         transformed = data.copy()
 
@@ -431,7 +429,7 @@ class LSHEventProcessor:
         return transformed
 
     def _categorize_amount(self, amount: float) -> str:
-        """Categorize transaction amounts"""
+        """Categorize transaction amounts."""
         if amount < 1000:
             return "small"
         elif amount < 50000:
@@ -442,11 +440,11 @@ class LSHEventProcessor:
             return "very_large"
 
     async def _emit_mcli_event(self, event_type: str, data: Dict[str, Any]):
-        """Emit mcli-specific events (can be extended to use message queue)"""
+        """Emit mcli-specific events (can be extended to use message queue)."""
         self.logger.debug(f"Emitting mcli event: {event_type}")
         # For now, just log - can be extended to use Redis, RabbitMQ, etc.
 
     async def start_processing(self):
-        """Start processing LSH events"""
+        """Start processing LSH events."""
         self.logger.info("Starting LSH event processing...")
         await self.client.stream_events()

mcli/lib/shell/shell.py

@@ -5,7 +5,7 @@ import shutil
 import subprocess
 import sys
 from pathlib import Path
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict
 
 from mcli.lib.logger.logger import get_logger, register_subprocess
 
@@ -13,7 +13,7 @@ logger = get_logger(__name__)
 
 
 def shell_exec(script_path: str, function_name: str, *args) -> Dict[str, Any]:
-    """Execute a shell script function with security checks and better error handling"""
+    """Execute a shell script function with security checks and better error handling."""
     # Validate script path
     script_path = Path(script_path).resolve()
     if not script_path.exists():

mcli/lib/toml/__init__.py

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