mcli-framework 7.12.2__py3-none-any.whl → 7.12.4__py3-none-any.whl

mcli/workflow/daemon/process_manager.py

@@ -2,9 +2,6 @@ import json
 import os
 import signal
 import subprocess
-import tempfile
-import threading
-import time
 import uuid
 from dataclasses import asdict, dataclass
 from datetime import datetime
@@ -29,7 +26,7 @@ class ProcessStatus(Enum):
 
 @dataclass
 class ProcessInfo:
-    """Information about a managed process"""
+    """Information about a managed process."""
 
     id: str
     name: str
@@ -50,7 +47,7 @@ class ProcessInfo:
 
 
 class ProcessContainer:
-    """Manages a single containerized process"""
+    """Manages a single containerized process."""
 
     def __init__(self, process_info: ProcessInfo):
         self.info = process_info
@@ -61,7 +58,7 @@ class ProcessContainer:
         self._setup_container_environment()
 
     def _setup_container_environment(self):
-        """Setup isolated environment for the process"""
+        """Setup isolated environment for the process."""
         # Create container directory
         base_dir = Path.home() / ".local" / "mcli" / "containers"
         self.container_dir = base_dir / self.info.id
@@ -77,15 +74,15 @@ class ProcessContainer:
             json.dump(asdict(self.info), f, indent=2, default=str)
 
     def start(self) -> bool:
-        """Start the containerized process"""
+        """Start the containerized process."""
         try:
             if self.process and self.process.poll() is None:
                 logger.warning(f"Process {self.info.id} is already running")
                 return False
 
             # Open log files
-            stdout_handle = open(self.stdout_file, "w")
-            stderr_handle = open(self.stderr_file, "w")
+            stdout_handle = open(self.stdout_file, "w")  # noqa: SIM115
+            stderr_handle = open(self.stderr_file, "w")  # noqa: SIM115
 
             # Start process
             self.process = subprocess.Popen(
@@ -110,7 +107,7 @@ class ProcessContainer:
             return False
 
     def stop(self, timeout: int = 10) -> bool:
-        """Stop the process gracefully"""
+        """Stop the process gracefully."""
         if not self.process or self.process.poll() is not None:
             return True
 
@@ -140,7 +137,7 @@ class ProcessContainer:
             return False
 
     def kill(self) -> bool:
-        """Force kill the process"""
+        """Force kill the process."""
         if not self.process or self.process.poll() is not None:
             return True
 
@@ -160,13 +157,13 @@ class ProcessContainer:
             return False
 
     def is_running(self) -> bool:
-        """Check if process is currently running"""
+        """Check if process is currently running."""
         if not self.process:
             return False
         return self.process.poll() is None
 
     def get_logs(self, lines: Optional[int] = None, follow: bool = False) -> Dict[str, str]:
-        """Get process logs"""
+        """Get process logs."""
         logs = {"stdout": "", "stderr": ""}
 
         try:
@@ -190,7 +187,7 @@ class ProcessContainer:
         return logs
 
     def get_stats(self) -> Dict[str, Any]:
-        """Get process statistics"""
+        """Get process statistics."""
         stats = {
             "cpu_percent": 0.0,
             "memory_mb": 0.0,
@@ -215,7 +212,7 @@ class ProcessContainer:
         return stats
 
     def cleanup(self):
-        """Clean up container resources"""
+        """Clean up container resources."""
         try:
             # Stop process if running
             if self.is_running():
@@ -229,7 +226,7 @@ class ProcessContainer:
 
 
 class ProcessManager:
-    """Docker-like process management system"""
+    """Docker-like process management system."""
 
     def __init__(self):
         self.containers: Dict[str, ProcessContainer] = {}
@@ -240,7 +237,7 @@ class ProcessManager:
         self._load_existing_containers()
 
     def _load_existing_containers(self):
-        """Load existing containers from disk"""
+        """Load existing containers from disk."""
         try:
             for container_dir in self.base_dir.iterdir():
                 if container_dir.is_dir():
@@ -281,7 +278,7 @@ class ProcessManager:
         working_dir: str = None,
         environment: Dict[str, str] = None,
     ) -> str:
-        """Create a new process container"""
+        """Create a new process container."""
         process_id = str(uuid.uuid4())
 
         process_info = ProcessInfo(
@@ -301,7 +298,7 @@ class ProcessManager:
         return process_id
 
     def start(self, process_id: str) -> bool:
-        """Start a process container"""
+        """Start a process container."""
         if process_id not in self.containers:
             logger.error(f"Container {process_id} not found")
             return False
@@ -309,7 +306,7 @@ class ProcessManager:
         return self.containers[process_id].start()
 
     def stop(self, process_id: str, timeout: int = 10) -> bool:
-        """Stop a process container"""
+        """Stop a process container."""
         if process_id not in self.containers:
             logger.error(f"Container {process_id} not found")
             return False
@@ -317,7 +314,7 @@ class ProcessManager:
         return self.containers[process_id].stop(timeout)
 
     def kill(self, process_id: str) -> bool:
-        """Kill a process container"""
+        """Kill a process container."""
         if process_id not in self.containers:
             logger.error(f"Container {process_id} not found")
             return False
@@ -325,7 +322,7 @@ class ProcessManager:
         return self.containers[process_id].kill()
 
     def remove(self, process_id: str, force: bool = False) -> bool:
-        """Remove a process container"""
+        """Remove a process container."""
         if process_id not in self.containers:
             logger.error(f"Container {process_id} not found")
             return False
@@ -347,7 +344,7 @@ class ProcessManager:
         return True
 
     def list_processes(self, all_processes: bool = False) -> List[Dict[str, Any]]:
-        """List all process containers (Docker ps style)"""
+        """List all process containers (Docker ps style)."""
         result = []
 
         for container in self.containers.values():
@@ -380,7 +377,7 @@ class ProcessManager:
         return result
 
     def inspect(self, process_id: str) -> Optional[Dict[str, Any]]:
-        """Get detailed information about a process container"""
+        """Get detailed information about a process container."""
         if process_id not in self.containers:
             return None
 
@@ -413,7 +410,7 @@ class ProcessManager:
     def logs(
         self, process_id: str, lines: Optional[int] = None, follow: bool = False
     ) -> Optional[Dict[str, str]]:
-        """Get logs from a process container"""
+        """Get logs from a process container."""
         if process_id not in self.containers:
             return None
 
@@ -428,7 +425,7 @@ class ProcessManager:
         environment: Dict[str, str] = None,
         detach: bool = True,
     ) -> str:
-        """Create and start a process container in one step"""
+        """Create and start a process container in one step."""
         process_id = self.create(name, command, args, working_dir, environment)
 
         if self.start(process_id):

mcli/workflow/daemon/test_daemon.py

@@ -9,12 +9,11 @@ example commands in different programming languages.
 import os
 import subprocess
 import tempfile
-import time
 from pathlib import Path
 
 
 def create_test_scripts():
-    """Create test scripts for different languages"""
+    """Create test scripts for different languages."""
     scripts = {}
 
     # Python script
@@ -88,7 +87,7 @@ echo "=== End ==="
 
 
 def test_daemon_functionality():
-    """Test the daemon functionality"""
+    """Test the daemon functionality."""
     print("🧪 Testing MCLI Daemon Service")
     print("=" * 50)
 
@@ -190,7 +189,7 @@ def test_daemon_functionality():
 
 
 def show_usage_examples():
-    """Show usage examples"""
+    """Show usage examples."""
     print("\n📚 Usage Examples")
     print("=" * 50)
 
@@ -239,7 +238,7 @@ def show_usage_examples():
 
 
 def main():
-    """Main test function"""
+    """Main test function."""
     print("🚀 MCLI Daemon Service Test Suite")
     print("=" * 60)
 

mcli/workflow/dashboard/dashboard_cmd.py

@@ -14,7 +14,6 @@ logger = get_logger(__name__)
 @click.group(name="dashboard")
 def dashboard():
     """ML monitoring dashboard commands."""
-    pass
 
 
 @dashboard.command()

mcli/workflow/doc_convert.py

@@ -9,7 +9,6 @@ Uses temporary directory with hard links to avoid path issues.
 import os
 import shutil
 import subprocess
-import tempfile
 from dataclasses import dataclass
 from enum import Enum
 from glob import glob as file_glob
@@ -39,7 +38,7 @@ FORMAT_ALIASES = {
     "htm": "html",
     "xhtml": "html",
     # PDF
-    "pdf": "pdf",
+    "pd": "pd",
     # LaTeX
     "tex": "latex",
     "latex": "latex",
@@ -58,13 +57,13 @@ FORMAT_ALIASES = {
     "org": "org",
     "mediawiki": "mediawiki",
     "textile": "textile",
-    "rtf": "rtf",
+    "rt": "rt",
     "epub": "epub",
 }
 
 
 class ConversionMethod(Enum):
-    """Available conversion methods"""
+    """Available conversion methods."""
 
     PANDOC = "pandoc"
     NBCONVERT = "nbconvert"
@@ -74,7 +73,7 @@ class ConversionMethod(Enum):
 
 @dataclass
 class ConversionStrategy:
-    """Represents a conversion strategy with command and description"""
+    """Represents a conversion strategy with command and description."""
 
     method: ConversionMethod
     description: str
@@ -82,7 +81,7 @@ class ConversionStrategy:
 
 
 def get_temp_conversion_dir() -> Path:
-    """Get or create temporary conversion directory in ~/.mcli/commands/temp/"""
+    """Get or create temporary conversion directory in ~/.mcli/commands/temp/."""
     commands_dir = get_custom_commands_dir()
     temp_dir = commands_dir / "temp" / "conversions"
     temp_dir.mkdir(parents=True, exist_ok=True)
@@ -148,7 +147,7 @@ def get_conversion_strategies(
     strategies = []
 
     # Special handling for Jupyter notebook to PDF (notoriously problematic)
-    if from_format == "ipynb" and to_format == "pdf":
+    if from_format == "ipynb" and to_format == "pd":
         # Strategy 1: nbconvert (most reliable for notebooks)
         strategies.append(
             ConversionStrategy(
@@ -191,7 +190,7 @@ def get_conversion_strategies(
         strategies.append(ConversionStrategy(method=ConversionMethod.PANDOC, description="pandoc"))
 
     # PDF output (general)
-    elif to_format == "pdf":
+    elif to_format == "pd":
         strategies.append(
             ConversionStrategy(
                 method=ConversionMethod.PANDOC_LATEX, description="pandoc with LaTeX"
@@ -255,7 +254,7 @@ def execute_conversion_strategy(
             cmd = [
                 "pandoc",
                 str(temp_input),
-                "-f",
+                "-",
                 from_format,
                 "-o",
                 str(temp_output),
@@ -276,7 +275,7 @@ def execute_conversion_strategy(
             cmd_html = [
                 "pandoc",
                 str(temp_input),
-                "-f",
+                "-",
                 from_format,
                 "-t",
                 "html",
@@ -291,7 +290,7 @@ def execute_conversion_strategy(
                 return False, f"HTML intermediate failed: {result.stderr}"
 
             # Step 2: Convert HTML to PDF
-            cmd = ["pandoc", str(html_temp), "-f", "html", "-t", "pdf", "-o", str(temp_output)]
+            cmd = ["pandoc", str(html_temp), "-", "html", "-t", "pd", "-o", str(temp_output)]
 
             result = subprocess.run(
                 cmd, capture_output=True, text=True, check=True, timeout=120, cwd=str(temp_dir)
@@ -299,9 +298,9 @@ def execute_conversion_strategy(
 
         else:  # PANDOC
             # Standard pandoc conversion
-            cmd = ["pandoc", str(temp_input), "-f", from_format, "-o", str(temp_output)]
+            cmd = ["pandoc", str(temp_input), "-", from_format, "-o", str(temp_output)]
             # Use xelatex for PDF conversions (better Unicode support)
-            if to_format == "pdf":
+            if to_format == "pd":
                 cmd.append("--pdf-engine=xelatex")
             if pandoc_args:
                 cmd.extend(pandoc_args.split())
@@ -330,8 +329,7 @@ def execute_conversion_strategy(
 
 @click.group(name="doc-convert")
 def doc_convert():
-    """Document conversion with automatic fallback strategies"""
-    pass
+    """Document conversion with automatic fallback strategies."""
 
 
 @doc_convert.command()
@@ -573,7 +571,7 @@ def convert(from_format, to_format, path, output_dir, pandoc_args, no_fallback):
             output_path = input_path.parent / f"{input_path.stem}.{output_ext}"
 
         info(f"🔄 Converting: {input_path.name} → {output_path.name}")
-        info(f"   📁 Using temp directory: ~/.mcli/commands/temp/conversions/")
+        info("   📁 Using temp directory: ~/.mcli/commands/temp/conversions/")
 
         # Get conversion strategies
         strategies = get_conversion_strategies(
@@ -616,7 +614,7 @@ def convert(from_format, to_format, path, output_dir, pandoc_args, no_fallback):
         if conversion_succeeded:
             success_count += 1
         else:
-            error(f"   ❌ All conversion methods failed")
+            error("   ❌ All conversion methods failed")
             if last_error:
                 error(f"   ℹ️  Last error: {last_error[:200]}")
             error_count += 1

mcli/workflow/gcloud/__init__.py

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

mcli/workflow/gcloud/gcloud.py

@@ -1,33 +1,36 @@
 import click
 
+from mcli.lib.logger.logger import get_logger
+
 # from mcli.public.mcli.lib.shell.shell import shell_exec, get_shell_script_path
 from mcli.lib.shell.shell import get_shell_script_path, shell_exec
 
+logger = get_logger(__name__)
+
 
 # Click CLI group renamed to 'gcloud'
 @click.group()
 def gcloud():
-    """gcloud utility - use this to interact with gcloud"""
-    pass
+    """gcloud utility - use this to interact with gcloud."""
 
 
 @click.command()
 def start():
-    """Start a gcloud instance"""
+    """Start a gcloud instance."""
     scripts_path = get_shell_script_path("gcloud", __file__)
     shell_exec(scripts_path, "start")
 
 
 @gcloud.command()
 def stop():
-    """Start a gcloud instance"""
+    """Start a gcloud instance."""
     scripts_path = get_shell_script_path("gcloud", __file__)
     shell_exec(scripts_path, "stop")
 
 
 @gcloud.command()
 def describe():
-    """Start a gcloud instance"""
+    """Start a gcloud instance."""
     scripts_path = get_shell_script_path("gcloud", __file__)
     shell_exec(scripts_path, "describe")
 
@@ -36,7 +39,7 @@ def describe():
 @click.argument("remote-port", type=str)
 @click.argument("local-port", type=str)
 def tunnel(remote_port: str, local_port: str):
-    """Create an alpha tunnel using the instance"""
+    """Create an alpha tunnel using the instance."""
     logger.info(f"Creating a tunnel at {remote_port} to local port {local_port}")
     scripts_path = get_shell_script_path("gcloud", __file__)
     shell_exec(scripts_path, "tunnel", remote_port, local_port)
@@ -44,8 +47,8 @@ def tunnel(remote_port: str, local_port: str):
 
 @gcloud.command()
 def login(remote_port: str, local_port: str):
-    """Login to gcloud"""
-    logger.info(f"Authenticating into gcloud")
+    """Login to gcloud."""
+    logger.info("Authenticating into gcloud")
     scripts_path = get_shell_script_path("gcloud", __file__)
     shell_exec(scripts_path, "login", remote_port, local_port)
 

mcli/workflow/git_commit/ai_service.py

@@ -1,6 +1,4 @@
-import json
-import logging
-from typing import Any, Dict, Optional
+from typing import Any, Dict
 
 from mcli.lib.logger.logger import get_logger
 from mcli.lib.optional_deps import optional_import
@@ -13,7 +11,7 @@ logger = get_logger(__name__)
 
 
 class GitCommitAIService:
-    """AI service for generating intelligent git commit messages"""
+    """AI service for generating intelligent git commit messages."""
 
     def __init__(self):
         self.config = self._load_config()
@@ -24,7 +22,7 @@ class GitCommitAIService:
         self.ollama_base_url = self.config.get("ollama_base_url", "http://localhost:11434")
 
     def _load_config(self) -> Dict[str, Any]:
-        """Load LLM configuration from config.toml"""
+        """Load LLM configuration from config.toml."""
         try:
             config = read_from_toml("config.toml", "llm") or {}
 
@@ -48,7 +46,7 @@ class GitCommitAIService:
             }
 
     def _analyze_file_patterns(self, changes: Dict[str, Any]) -> Dict[str, Any]:
-        """Analyze file patterns to understand the scope of changes"""
+        """Analyze file patterns to understand the scope of changes."""
         analysis = {"languages": set(), "categories": set(), "scope": "unknown", "confidence": 0.0}
 
         all_files = (
@@ -109,7 +107,7 @@ class GitCommitAIService:
             ],
             "backend": [".py", ".go", ".rs", ".java", ".cpp", "api/", "server/", "backend/"],
             "database": [".sql", "migration", "schema", "models/", "db/"],
-            "infra": ["docker", "deploy", "infrastructure", ".tf", "kubernetes", "helm"],
+            "infra": ["docker", "deploy", "infrastructure", ".t", "kubernetes", "helm"],
         }
 
         for file in all_files:
@@ -149,12 +147,14 @@ class GitCommitAIService:
     def _create_commit_prompt(
         self, changes: Dict[str, Any], diff_content: str, analysis: Dict[str, Any]
     ) -> str:
-        """Create a detailed prompt for AI commit message generation"""
+        """Create a detailed prompt for AI commit message generation."""
 
         # Truncate diff if too long (keep first 2000 chars)
-        truncated_diff = diff_content[:2000] + "..." if len(diff_content) > 2000 else diff_content
+        _truncated_diff = (
+            diff_content[:2000] + "..." if len(diff_content) > 2000 else diff_content
+        )  # noqa: F841
 
-        prompt = f"""You are an expert software developer writing git commit messages following conventional commit standards.
+        prompt = """You are an expert software developer writing git commit messages following conventional commit standards.
 
 CHANGE ANALYSIS:
 - Files changed: {changes['total_files']}
@@ -204,7 +204,7 @@ Generate ONLY the commit message, nothing else:"""
         return prompt
 
     def generate_commit_message(self, changes: Dict[str, Any], diff_content: str) -> str:
-        """Generate an AI-powered commit message"""
+        """Generate an AI-powered commit message."""
         try:
             # Check if ollama is available
             if not OLLAMA_AVAILABLE:
@@ -254,7 +254,7 @@ Generate ONLY the commit message, nothing else:"""
             )
 
     def _clean_commit_message(self, message: str) -> str:
-        """Clean up AI generated commit message"""
+        """Clean up AI generated commit message."""
         lines = message.strip().split("\n")
 
         # Remove any introductory text
@@ -274,8 +274,7 @@ Generate ONLY the commit message, nothing else:"""
         return "\n".join(cleaned_lines) if cleaned_lines else ""
 
     def _generate_fallback_message(self, changes: Dict[str, Any], analysis: Dict[str, Any]) -> str:
-        """Generate fallback commit message using rules"""
-        summary_parts = []
+        """Generate fallback commit message using rules."""
 
         # Determine commit type based on analysis
         if "tests" in analysis["categories"]:
@@ -317,7 +316,7 @@ Generate ONLY the commit message, nothing else:"""
         return f"{commit_type}{scope}: {description}"
 
     def test_ai_service(self) -> bool:
-        """Test if the AI service is working properly"""
+        """Test if the AI service is working properly."""
         try:
             # Test with minimal changes
             test_changes = {

mcli/workflow/lsh_integration.py

@@ -10,12 +10,10 @@ import sys
 from pathlib import Path
 from typing import Any, Dict, Optional
 
-import click
-
 from mcli.lib.api import mcli_decorators as mcli
 from mcli.lib.logger.logger import get_logger
 from mcli.lib.services.data_pipeline import DataPipelineConfig, LSHDataPipeline
-from mcli.lib.services.lsh_client import LSHClient, LSHEventProcessor
+from mcli.lib.services.lsh_client import LSHClient
 
 logger = get_logger(__name__)
 
@@ -26,7 +24,7 @@ logger = get_logger(__name__)
 )
 @mcli.option("--api-key", default=None, help="LSH API key (default: $LSH_API_KEY)")
 async def lsh_status(url: Optional[str], api_key: Optional[str]):
-    """Check LSH daemon connection and status"""
+    """Check LSH daemon connection and status."""
     try:
         async with LSHClient(base_url=url, api_key=api_key) as client:
             # Test connection
@@ -64,7 +62,7 @@ async def lsh_status(url: Optional[str], api_key: Optional[str]):
 @mcli.option("--url", default=None, help="LSH API URL")
 @mcli.option("--api-key", default=None, help="LSH API key")
 async def lsh_jobs(status: Optional[str], format: str, url: Optional[str], api_key: Optional[str]):
-    """List LSH jobs"""
+    """List LSH jobs."""
     try:
         async with LSHClient(base_url=url, api_key=api_key) as client:
             filter_params = {}
@@ -125,7 +123,7 @@ async def lsh_create_job(
     url: Optional[str],
     api_key: Optional[str],
 ):
-    """Create a new LSH job"""
+    """Create a new LSH job."""
     try:
         async with LSHClient(base_url=url, api_key=api_key) as client:
             job_spec = {
@@ -173,7 +171,7 @@ async def lsh_pipeline(
     url: Optional[str],
     api_key: Optional[str],
 ):
-    """Start LSH data pipeline listener"""
+    """Start LSH data pipeline listener."""
     try:
         # Configure pipeline
         config = DataPipelineConfig()
@@ -221,7 +219,7 @@ async def lsh_pipeline(
 @mcli.option("--api-key", default=None, help="LSH API key")
 @mcli.option("--filter", help="Event type filter (e.g., 'job:completed')")
 async def lsh_listen(url: Optional[str], api_key: Optional[str], filter: Optional[str]):
-    """Listen to LSH events for debugging"""
+    """Listen to LSH events for debugging."""
     try:
         mcli.echo(mcli.style("👂 Listening to LSH events...", fg="blue", bold=True))
         mcli.echo("Press Ctrl+C to stop")
@@ -259,7 +257,7 @@ async def lsh_listen(url: Optional[str], api_key: Optional[str], filter: Optiona
 async def lsh_webhook(
     action: str, endpoint: Optional[str], url: Optional[str], api_key: Optional[str]
 ):
-    """Manage LSH webhooks"""
+    """Manage LSH webhooks."""
     try:
         async with LSHClient(base_url=url, api_key=api_key) as client:
             if action == "list":
@@ -289,7 +287,7 @@ async def lsh_webhook(
 @mcli.option("--set-api-key", help="Set LSH API key")
 @mcli.option("--show", is_flag=True, help="Show current configuration")
 def lsh_config(set_url: Optional[str], set_api_key: Optional[str], show: bool):
-    """Configure LSH integration settings"""
+    """Configure LSH integration settings."""
     env_file = Path.home() / ".mcli" / "lsh.env"
     env_file.parent.mkdir(exist_ok=True)
 
@@ -339,5 +337,5 @@ def lsh_config(set_url: Optional[str], set_api_key: Optional[str], show: bool):
 
 # Register all commands with mcli
 def register_lsh_commands():
-    """Register LSH integration commands with mcli"""
+    """Register LSH integration commands with mcli."""
     pass  # Commands are automatically registered via decorators