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

mcli/lib/erd/erd.py

@@ -86,7 +86,7 @@ class MCLITypeSystem:
                     attr = getattr(self.mcli_obj, attr_name)
                     if hasattr(attr, "meta") and callable(attr.meta):
                         type_names.append(attr_name)
-                except:
+                except Exception:
                     pass
         return type_names
 
@@ -102,7 +102,7 @@ class MCLITypeSystem:
                     attr = getattr(pkg, attr_name)
                     if hasattr(attr, "meta") and callable(attr.meta):
                         type_names.append(f"{package_name}.{attr_name}")
-                except:
+                except Exception:
                     pass
         except Exception:
             pass
@@ -255,7 +255,7 @@ class ERD:
                         label_ = getattr(vt, "name", str(vt))
                 else:
                     label_ = str(field_metadata)
-            except:
+            except Exception:
                 label_ = str(field_metadata)
 
             entries.append((name, label_))
@@ -435,9 +435,9 @@ def do_erd(max_depth=1, type_system: Optional[TypeSystem] = None):
                                         if hasattr(sub_attr, "meta") and callable(sub_attr.meta):
                                             packages.append(attr_name)
                                             break
-                                    except:
+                                    except Exception:
                                         pass
-                        except:
+                        except Exception:
                             pass
 
                 if packages:
@@ -487,9 +487,9 @@ def do_erd(max_depth=1, type_system: Optional[TypeSystem] = None):
                                             ):
                                                 packages.append(attr_name)
                                                 break
-                                        except:
+                                        except Exception:
                                             pass
-                            except:
+                            except Exception:
                                 pass
 
                     if packages:

mcli/lib/files/files.py

@@ -11,7 +11,7 @@ NO_CHANGE_TO_FILE = -1
 
 
 def encode_content(path):
-    """Encode file content and track changes using MD5 fingerprints"""
+    """Encode file content and track changes using MD5 fingerprints."""
     logger.debug(f"encode_content: {path}")
 
     try:

mcli/lib/fs/__init__.py

@@ -1 +1,31 @@
-from .fs import *
+"""File system utilities for MCLI."""
+
+from .fs import (
+    copy_file,
+    delete_directory,
+    delete_file,
+    ensure_directory_exists,
+    file_exists,
+    get_absolute_path,
+    get_file_size,
+    get_user_home,
+    list_files,
+    load_global_value,
+    read_line_from_file,
+    save_global_value,
+)
+
+__all__ = [
+    "copy_file",
+    "delete_directory",
+    "delete_file",
+    "ensure_directory_exists",
+    "file_exists",
+    "get_absolute_path",
+    "get_file_size",
+    "get_user_home",
+    "list_files",
+    "load_global_value",
+    "read_line_from_file",
+    "save_global_value",
+]

mcli/lib/fs/fs.py

@@ -6,45 +6,44 @@ Provides basic file system operations with path normalization
 import json
 import os
 import shutil
-from pathlib import Path
 
 import click
 
 
 def get_absolute_path(pth):
-    """Convert path to absolute path with user expansion"""
+    """Convert path to absolute path with user expansion."""
     pth = os.path.expanduser(pth)
     pth = os.path.abspath(pth)
     return pth
 
 
 def ensure_directory_exists(dirpath):
-    """Create directory if it doesn't exist"""
+    """Create directory if it doesn't exist."""
     dirpath = get_absolute_path(dirpath)
     os.makedirs(dirpath, exist_ok=True)
 
 
 def delete_directory(dirpath):
-    """Delete directory if it exists"""
+    """Delete directory if it exists."""
     dirpath = get_absolute_path(dirpath)
     if os.path.exists(dirpath):
         shutil.rmtree(dirpath)  # Use rmtree for non-empty directories
 
 
 def delete_file(filepath):
-    """Delete file if it exists"""
+    """Delete file if it exists."""
     filepath = get_absolute_path(filepath)
     if os.path.exists(filepath):
         os.remove(filepath)
 
 
 def get_user_home():
-    """Get user home directory"""
+    """Get user home directory."""
     return os.path.expanduser("~")
 
 
 def read_line_from_file(filepath):
-    """Read first line from file"""
+    """Read first line from file."""
     filepath = get_absolute_path(filepath)
     if not os.path.exists(filepath):
         raise Exception("File does not exist at: " + filepath)
@@ -53,7 +52,7 @@ def read_line_from_file(filepath):
 
 
 def copy_file(srcpath, dstpath):
-    """Copy a file from source to destination"""
+    """Copy a file from source to destination."""
     srcpath = get_absolute_path(srcpath)
     dstpath = get_absolute_path(dstpath)
     if os.path.exists(srcpath):
@@ -65,13 +64,13 @@ def copy_file(srcpath, dstpath):
 
 
 def file_exists(path):
-    """Check if a file exists at the given path"""
+    """Check if a file exists at the given path."""
     path = get_absolute_path(path)
     return os.path.exists(path)
 
 
 def get_file_size(path):
-    """Get the size of a file in bytes"""
+    """Get the size of a file in bytes."""
     path = get_absolute_path(path)
     if file_exists(path):
         return os.path.getsize(path)
@@ -79,7 +78,7 @@ def get_file_size(path):
 
 
 def list_files(directory, pattern="*"):
-    """List files in a directory matching a pattern"""
+    """List files in a directory matching a pattern."""
     import glob
 
     directory = get_absolute_path(directory)
@@ -94,14 +93,14 @@ CONFIG_FILE = os.path.join(click.get_app_dir("mcli"), "config.json")
 
 
 def save_global_value(value):
-    """Save a global configuration value"""
+    """Save a global configuration value."""
     os.makedirs(os.path.dirname(CONFIG_FILE), exist_ok=True)
     with open(CONFIG_FILE, "w") as f:
         json.dump({"GLOBAL_VALUE": value}, f)
 
 
 def load_global_value():
-    """Load a global configuration value"""
+    """Load a global configuration value."""
     try:
         with open(CONFIG_FILE, "r") as f:
             return json.load(f).get("GLOBAL_VALUE")

mcli/lib/lib.py

@@ -25,7 +25,6 @@ def import_public_module(module_name: str):
 @click.group(name="lib", help="Library utilities and secrets management")
 def lib():
     """Library utilities and management commands."""
-    pass
 
 
 # Add secrets as a subcommand

mcli/lib/logger/logger.py

@@ -1,17 +1,14 @@
 import inspect
 import logging
 import os
-import platform
-import signal
 import subprocess
 import sys
 import threading
 import time
 import traceback
 from datetime import datetime
-from pathlib import Path
 from types import FrameType
-from typing import Any, Callable, Dict, List, Optional, Set, Tuple, Union
+from typing import Any, Callable, Dict, List, Optional, Set
 
 import psutil
 
@@ -163,7 +160,7 @@ class McliLogger:
         Register a subprocess.Popen object for monitoring.
         Returns the process ID if successful, 0 otherwise.
         """
-        if proc and proc.pid:
+        if proc and proc.pid:  # noqa: SIM102
             if cls.register_process(proc.pid):
                 return proc.pid
         return 0
@@ -271,7 +268,7 @@ class McliLogger:
             module_name = module_name[:-3]
 
         # Skip excluded modules
-        for excluded in self._excluded_modules:
+        for excluded in self._excluded_modules:  # noqa: SIM111
             if module_name.startswith(excluded):
                 return False
 
@@ -459,7 +456,7 @@ class McliLogger:
                                 if len(arg_val) > 100:
                                     arg_val = arg_val[:97] + "..."
                                 args_str.append(f"{arg_name}={arg_val}")
-                            except:
+                            except Exception:
                                 args_str.append(f"{arg_name}=<error>")
                     args_repr = ", ".join(args_str)
                     self.trace_logger.debug(
@@ -481,7 +478,7 @@ class McliLogger:
                                 else "<source not available>"
                             )
                         self.trace_logger.debug(f"LINE {filename}:{lineno} -> {source}")
-                    except:
+                    except Exception:
                         self.trace_logger.debug(f"LINE {filename}:{lineno}")
                 else:
                     self.trace_logger.debug(f"LINE {filename}:{lineno}")
@@ -507,9 +504,9 @@ class McliLogger:
                     self.trace_logger.debug(f"Traceback:\n{tb_str}")
         except Exception as e:
             # Never let tracing errors crash the program
-            try:
+            try:  # noqa: SIM105
                 self.trace_logger.error(f"Error in trace callback: {e}")
-            except:
+            except Exception:
                 pass
             return None
 

mcli/lib/performance/optimizer.py

@@ -2,21 +2,19 @@
 Main performance optimizer that applies all available optimizations
 """
 
-import asyncio
-import importlib.util
 import os
 import sys
 from typing import Any, Dict, Optional
 
 from mcli.lib.logger.logger import get_logger
-from mcli.lib.performance.rust_bridge import check_rust_extensions, print_performance_summary
+from mcli.lib.performance.rust_bridge import check_rust_extensions
 from mcli.lib.performance.uvloop_config import get_event_loop_info, install_uvloop
 
 logger = get_logger(__name__)
 
 
 class PerformanceOptimizer:
-    """Centralized performance optimizer for MCLI"""
+    """Centralized performance optimizer for MCLI."""
 
     def __init__(self):
         self.optimizations_applied = {}
@@ -25,8 +23,8 @@ class PerformanceOptimizer:
         self.uvloop_installed = False
 
     def apply_all_optimizations(self) -> Dict[str, Any]:
-        """Apply all available performance optimizations"""
-        results = {}
+        """Apply all available performance optimizations."""
+        results = {}  # noqa: SIM904
 
         # 1. Install UVLoop for better async performance
         results["uvloop"] = self._optimize_event_loop()
@@ -47,7 +45,7 @@ class PerformanceOptimizer:
         return results
 
     def _optimize_event_loop(self) -> Dict[str, Any]:
-        """Optimize asyncio event loop with UVLoop"""
+        """Optimize asyncio event loop with UVLoop."""
         try:
             self.uvloop_installed = install_uvloop()
 
@@ -64,7 +62,7 @@ class PerformanceOptimizer:
             return {"success": False, "error": str(e)}
 
     def _initialize_rust_extensions(self) -> Dict[str, Any]:
-        """Initialize Rust extensions for maximum performance"""
+        """Initialize Rust extensions for maximum performance."""
         try:
             self.rust_status = check_rust_extensions()
 
@@ -90,7 +88,7 @@ class PerformanceOptimizer:
                         import mcli_rust
 
                         # Test file watcher
-                        watcher = mcli_rust.FileWatcher()
+                        mcli_rust.FileWatcher()
                         extensions_loaded["file_watcher"] = True
                     except Exception as e:
                         logger.warning(f"File watcher extension test failed: {e}")
@@ -101,7 +99,7 @@ class PerformanceOptimizer:
                         import mcli_rust
 
                         # Test command matcher
-                        matcher = mcli_rust.CommandMatcher()
+                        mcli_rust.CommandMatcher()
                         extensions_loaded["command_matcher"] = True
                     except Exception as e:
                         logger.warning(f"Command matcher extension test failed: {e}")
@@ -112,7 +110,7 @@ class PerformanceOptimizer:
                         import mcli_rust
 
                         # Test process manager
-                        manager = mcli_rust.ProcessManager()
+                        mcli_rust.ProcessManager()
                         extensions_loaded["process_manager"] = True
                     except Exception as e:
                         logger.warning(f"Process manager extension test failed: {e}")
@@ -135,7 +133,7 @@ class PerformanceOptimizer:
             return {"success": False, "error": str(e)}
 
     def _check_redis_availability(self) -> Dict[str, Any]:
-        """Check Redis availability for caching"""
+        """Check Redis availability for caching."""
         try:
             import redis
 
@@ -164,7 +162,7 @@ class PerformanceOptimizer:
             }
 
     def _optimize_python_settings(self) -> Dict[str, Any]:
-        """Apply Python-specific optimizations"""
+        """Apply Python-specific optimizations."""
         optimizations = {}
 
         # 1. Disable garbage collection during critical operations
@@ -174,7 +172,7 @@ class PerformanceOptimizer:
         optimizations["gc_tuned"] = True
 
         # 2. Optimize import system
-        if hasattr(sys, "dont_write_bytecode"):
+        if hasattr(sys, "dont_write_bytecode"):  # noqa: SIM102
             # In production, enable bytecode for faster imports
             if not os.environ.get("MCLI_DEBUG"):
                 sys.dont_write_bytecode = False
@@ -190,7 +188,7 @@ class PerformanceOptimizer:
         try:
             import multiprocessing as mp
 
-            if hasattr(mp, "set_start_method"):
+            if hasattr(mp, "set_start_method"):  # noqa: SIM102
                 if sys.platform != "win32":
                     mp.set_start_method("fork", force=True)
                     optimizations["multiprocessing_optimized"] = True
@@ -205,7 +203,7 @@ class PerformanceOptimizer:
         }
 
     def _apply_environment_optimizations(self) -> Dict[str, Any]:
-        """Apply environment-specific optimizations"""
+        """Apply environment-specific optimizations."""
         optimizations = {}
 
         # 1. Production vs Development optimizations
@@ -258,7 +256,7 @@ class PerformanceOptimizer:
                 # Enable aggressive caching
                 os.environ["MCLI_AGGRESSIVE_CACHE"] = "1"
                 optimizations["aggressive_caching"] = True
-        except:
+        except Exception:
             pass
 
         return {
@@ -268,7 +266,7 @@ class PerformanceOptimizer:
         }
 
     def get_optimization_summary(self) -> Dict[str, Any]:
-        """Get a summary of all applied optimizations"""
+        """Get a summary of all applied optimizations."""
         if not self.optimizations_applied:
             self.apply_all_optimizations()
 
@@ -284,7 +282,7 @@ class PerformanceOptimizer:
         return summary
 
     def _estimate_performance_gain(self) -> str:
-        """Estimate overall performance gain"""
+        """Estimate overall performance gain."""
         gains = []
 
         if self.optimizations_applied.get("uvloop", {}).get("success"):
@@ -304,7 +302,7 @@ class PerformanceOptimizer:
             return "Baseline performance with Python optimizations"
 
     def benchmark_performance(self, test_size: str = "small") -> Dict[str, Any]:
-        """Run performance benchmarks"""
+        """Run performance benchmarks."""
         from mcli.lib.performance.rust_bridge import PerformanceMonitor
 
         monitor = PerformanceMonitor()
@@ -333,19 +331,19 @@ class PerformanceOptimizer:
         }
 
     def print_performance_report(self):
-        """Print a detailed performance report"""
+        """Print a detailed performance report."""
         summary = self.get_optimization_summary()
 
         print("\n" + "=" * 60)
         print("🚀 MCLI PERFORMANCE OPTIMIZATION REPORT")
         print("=" * 60)
 
-        print(f"\n📊 Optimization Summary:")
+        print("\n📊 Optimization Summary:")
         print(f"   • Total optimizations attempted: {summary['total_optimizations']}")
         print(f"   • Successful optimizations: {summary['successful_optimizations']}")
         print(f"   • Estimated performance gain: {summary['estimated_performance_gain']}")
 
-        print(f"\n⚡ Applied Optimizations:")
+        print("\n⚡ Applied Optimizations:")
         for name, details in summary["details"].items():
             status = "✅" if details.get("success") else "❌"
             print(f"   {status} {name.replace('_', ' ').title()}")
@@ -354,7 +352,7 @@ class PerformanceOptimizer:
             if details.get("reason"):
                 print(f"      → {details['reason']}")
 
-        print(f"\n🔧 Recommendations:")
+        print("\n🔧 Recommendations:")
 
         # Rust extensions
         if not self.optimizations_applied.get("rust", {}).get("success"):
@@ -379,7 +377,7 @@ _global_optimizer: Optional[PerformanceOptimizer] = None
 
 
 def get_global_optimizer() -> PerformanceOptimizer:
-    """Get the global performance optimizer instance"""
+    """Get the global performance optimizer instance."""
     global _global_optimizer
 
     if _global_optimizer is None:
@@ -389,13 +387,13 @@ def get_global_optimizer() -> PerformanceOptimizer:
 
 
 def apply_optimizations() -> Dict[str, Any]:
-    """Apply all available optimizations"""
+    """Apply all available optimizations."""
     optimizer = get_global_optimizer()
     return optimizer.apply_all_optimizations()
 
 
 def print_optimization_report():
-    """Print the optimization report"""
+    """Print the optimization report."""
     optimizer = get_global_optimizer()
     optimizer.print_performance_report()
 

mcli/lib/performance/rust_bridge.py

@@ -2,10 +2,8 @@
 Bridge module for integrating Rust extensions with Python code
 """
 
-import importlib.util
 import os
-import sys
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Dict, List
 
 from mcli.lib.logger.logger import get_logger
 
@@ -20,7 +18,7 @@ _RUST_PROCESS_MANAGER = None
 
 
 def check_rust_extensions() -> Dict[str, bool]:
-    """Check which Rust extensions are available"""
+    """Check which Rust extensions are available."""
     global _RUST_AVAILABLE, _RUST_TFIDF, _RUST_FILE_WATCHER, _RUST_COMMAND_MATCHER, _RUST_PROCESS_MANAGER
 
     if _RUST_AVAILABLE is not None:
@@ -64,7 +62,7 @@ def check_rust_extensions() -> Dict[str, bool]:
 
 
 def get_tfidf_vectorizer(use_rust: bool = True, **kwargs):
-    """Get the best available TF-IDF vectorizer"""
+    """Get the best available TF-IDF vectorizer."""
     rust_status = check_rust_extensions()
 
     if use_rust and rust_status["tfidf"]:
@@ -85,7 +83,7 @@ def get_tfidf_vectorizer(use_rust: bool = True, **kwargs):
 
 
 def get_file_watcher(use_rust: bool = True):
-    """Get the best available file watcher"""
+    """Get the best available file watcher."""
     rust_status = check_rust_extensions()
 
     if use_rust and rust_status["file_watcher"]:
@@ -106,7 +104,7 @@ def get_file_watcher(use_rust: bool = True):
 
 
 def get_command_matcher(use_rust: bool = True, **kwargs):
-    """Get the best available command matcher"""
+    """Get the best available command matcher."""
     rust_status = check_rust_extensions()
 
     if use_rust and rust_status["command_matcher"]:
@@ -127,7 +125,7 @@ def get_command_matcher(use_rust: bool = True, **kwargs):
 
 
 def get_process_manager(use_rust: bool = True):
-    """Get the best available process manager"""
+    """Get the best available process manager."""
     rust_status = check_rust_extensions()
 
     if use_rust and rust_status["process_manager"]:
@@ -148,14 +146,14 @@ def get_process_manager(use_rust: bool = True):
 
 
 class PerformanceMonitor:
-    """Monitor performance differences between Rust and Python implementations"""
+    """Monitor performance differences between Rust and Python implementations."""
 
     def __init__(self):
         self.benchmarks = {}
         self.rust_status = check_rust_extensions()
 
     def benchmark_tfidf(self, documents: List[str], queries: List[str]) -> Dict[str, Any]:
-        """Benchmark TF-IDF performance"""
+        """Benchmark TF-IDF performance."""
         import time
 
         results = {"rust": None, "python": None, "speedup": None}
@@ -203,7 +201,7 @@ class PerformanceMonitor:
         return results
 
     def _cosine_similarity(self, vec1, vec2):
-        """Simple cosine similarity implementation"""
+        """Simple cosine similarity implementation."""
         import numpy as np
 
         dot_product = np.dot(
@@ -219,7 +217,7 @@ class PerformanceMonitor:
         return dot_product / (norm1 * norm2)
 
     def benchmark_file_watching(self, test_dir: str, num_operations: int = 100) -> Dict[str, Any]:
-        """Benchmark file watching performance"""
+        """Benchmark file watching performance."""
         import os
         import tempfile
         import time
@@ -243,7 +241,7 @@ class PerformanceMonitor:
 
                     # Give time for events to be processed
                     time.sleep(0.1)
-                    events = watcher.get_events()
+                    watcher.get_events()
                     rust_time = time.perf_counter() - start_time
 
                     watcher.stop_watching()
@@ -258,7 +256,7 @@ class PerformanceMonitor:
         return results
 
     def get_system_info(self) -> Dict[str, Any]:
-        """Get system information relevant to performance"""
+        """Get system information relevant to performance."""
         import platform
 
         import psutil
@@ -276,7 +274,7 @@ class PerformanceMonitor:
 
 
 class PythonFileWatcher:
-    """Fallback Python file watcher using watchdog"""
+    """Fallback Python file watcher using watchdog."""
 
     def __init__(self):
         from watchdog.events import FileSystemEventHandler
@@ -300,7 +298,7 @@ class PythonFileWatcher:
         self.is_watching = False
 
     def start_watching(self, paths: List[str], recursive: bool = True):
-        from watchdog.observers import Observer
+        pass
 
         for path in paths:
             self.observer.schedule(self.handler, path, recursive=recursive)
@@ -321,7 +319,7 @@ class PythonFileWatcher:
 
 
 class PythonCommandMatcher:
-    """Fallback Python command matcher"""
+    """Fallback Python command matcher."""
 
     def __init__(self, fuzzy_threshold: float = 0.3):
         self.fuzzy_threshold = fuzzy_threshold
@@ -331,7 +329,7 @@ class PythonCommandMatcher:
         self.commands.extend(commands)
 
     def search(self, query: str, limit: int = 10) -> List[Dict[str, Any]]:
-        import re
+        pass
 
         results = []
         query_lower = query.lower()
@@ -376,14 +374,11 @@ _RUST_EXTENSIONS_STATUS = check_rust_extensions()
 
 
 def print_performance_summary():
-    """Print a stunning visual summary of available performance optimizations"""
+    """Print a stunning visual summary of available performance optimizations."""
     try:
-        from rich.columns import Columns
-        from rich.panel import Panel
         from rich.rule import Rule
-        from rich.text import Text
 
-        from mcli.lib.ui.visual_effects import ColorfulOutput, MCLIBanner, VisualTable, console
+        from mcli.lib.ui.visual_effects import ColorfulOutput, VisualTable, console
 
         status = check_rust_extensions()
 
@@ -405,7 +400,7 @@ def print_performance_summary():
 
         # Check UVLoop
         try:
-            import uvloop
+            pass
 
             optimization_data["uvloop"]["success"] = True
             optimization_data["uvloop"]["reason"] = "High-performance event loop active"
@@ -429,7 +424,7 @@ def print_performance_summary():
 
         # Check AIOSQLite
         try:
-            import aiosqlite
+            pass
 
             optimization_data["aiosqlite"]["success"] = True
             optimization_data["aiosqlite"]["reason"] = "Async database operations enabled"
@@ -474,7 +469,7 @@ def print_performance_summary():
 
         # Check other optimizations
         try:
-            import uvloop
+            pass
 
             print("✅ UVLoop available for async performance")
         except ImportError:
@@ -488,7 +483,7 @@ def print_performance_summary():
             print("⚠️  Redis not available - caching disabled")
 
         try:
-            import aiosqlite
+            pass
 
             print("✅ AIOSQLite available for async database operations")
         except ImportError:

mcli/lib/performance/uvloop_config.py

@@ -5,7 +5,6 @@ UVLoop configuration for enhanced asyncio performance
 import asyncio
 import os
 import sys
-from typing import Optional
 
 
 def install_uvloop(force: bool = False) -> bool: