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

mcli/workflow/model_service/client.py

@@ -1,9 +1,5 @@
 import json
-import os
-import time
-from datetime import datetime
-from pathlib import Path
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Dict, List, Optional
 
 import click
 import requests
@@ -14,7 +10,7 @@ logger = get_logger(__name__)
 
 
 class ModelServiceClient:
-    """Client for interacting with the model service daemon"""
+    """Client for interacting with the model service daemon."""
 
     def __init__(self, base_url: str = "http://localhost:8000"):
         self.base_url = base_url.rstrip("/")
@@ -24,7 +20,7 @@ class ModelServiceClient:
         )
 
     def _make_request(self, method: str, endpoint: str, data: Optional[Dict] = None) -> Dict:
-        """Make a request to the model service"""
+        """Make a request to the model service."""
         url = f"{self.base_url}{endpoint}"
 
         try:
@@ -54,15 +50,15 @@ class ModelServiceClient:
             raise RuntimeError(f"Request failed: {e}")
 
     def get_status(self) -> Dict[str, Any]:
-        """Get service status"""
+        """Get service status."""
         return self._make_request("GET", "/")
 
     def get_health(self) -> Dict[str, Any]:
-        """Get service health"""
+        """Get service health."""
         return self._make_request("GET", "/health")
 
     def list_models(self) -> List[Dict[str, Any]]:
-        """List all available models"""
+        """List all available models."""
         return self._make_request("GET", "/models")
 
     def load_model(
@@ -77,7 +73,7 @@ class ModelServiceClient:
         top_p: float = 0.9,
         top_k: int = 50,
     ) -> str:
-        """Load a new model"""
+        """Load a new model."""
         data = {
             "name": name,
             "model_type": model_type,
@@ -94,7 +90,7 @@ class ModelServiceClient:
         return result["model_id"]
 
     def unload_model(self, model_id: str) -> bool:
-        """Unload a model"""
+        """Unload a model."""
         try:
             self._make_request("DELETE", f"/models/{model_id}")
             return True
@@ -102,7 +98,7 @@ class ModelServiceClient:
             return False
 
     def update_model(self, model_id: str, updates: Dict[str, Any]) -> bool:
-        """Update model configuration"""
+        """Update model configuration."""
         try:
             self._make_request("PUT", f"/models/{model_id}", updates)
             return True
@@ -110,7 +106,7 @@ class ModelServiceClient:
             return False
 
     def remove_model(self, model_id: str) -> bool:
-        """Remove a model from the database"""
+        """Remove a model from the database."""
         try:
             self._make_request("DELETE", f"/models/{model_id}/remove")
             return True
@@ -126,7 +122,7 @@ class ModelServiceClient:
         top_p: Optional[float] = None,
         top_k: Optional[int] = None,
     ) -> Dict[str, Any]:
-        """Generate text using a model"""
+        """Generate text using a model."""
         data = {
             "prompt": prompt,
             "max_length": max_length,
@@ -141,14 +137,14 @@ class ModelServiceClient:
         return self._make_request("POST", f"/models/{model_id}/generate", data)
 
     def classify_text(self, model_id: str, text: str) -> Dict[str, Any]:
-        """Classify text using a model"""
+        """Classify text using a model."""
         data = {"text": text}
         return self._make_request("POST", f"/models/{model_id}/classify", data)
 
     def translate_text(
         self, model_id: str, text: str, source_lang: str = "en", target_lang: str = "fr"
     ) -> Dict[str, Any]:
-        """Translate text using a model"""
+        """Translate text using a model."""
         data = {"text": text, "source_lang": source_lang, "target_lang": target_lang}
         return self._make_request("POST", f"/models/{model_id}/translate", data)
 
@@ -156,14 +152,13 @@ class ModelServiceClient:
 # CLI Commands
 @click.group(name="model-client")
 def model_client():
-    """Client for interacting with the model service daemon"""
-    pass
+    """Client for interacting with the model service daemon."""
 
 
 @model_client.command()
 @click.option("--url", default="http://localhost:8000", help="Model service URL")
 def status(url: str):
-    """Get model service status"""
+    """Get model service status."""
     try:
         client = ModelServiceClient(url)
         status_info = client.get_status()
@@ -187,7 +182,7 @@ def status(url: str):
 @model_client.command()
 @click.option("--url", default="http://localhost:8000", help="Model service URL")
 def list_models(url: str):
-    """List all available models"""
+    """List all available models."""
     try:
         client = ModelServiceClient(url)
         models = client.list_models()
@@ -240,7 +235,7 @@ def load_model(
     top_p: float = 0.9,
     top_k: int = 50,
 ):
-    """Load a model into the service"""
+    """Load a model into the service."""
     try:
         client = ModelServiceClient(url)
 
@@ -268,7 +263,7 @@ def load_model(
 @click.argument("model_id")
 @click.option("--url", default="http://localhost:8000", help="Model service URL")
 def unload_model(model_id: str, url: str):
-    """Unload a model from the service"""
+    """Unload a model from the service."""
     try:
         client = ModelServiceClient(url)
 
@@ -303,7 +298,7 @@ def update_model(
     top_k: Optional[int] = None,
     device: Optional[str] = None,
 ):
-    """Update model configuration"""
+    """Update model configuration."""
     try:
         client = ModelServiceClient(url)
 
@@ -350,7 +345,7 @@ def update_model(
 @click.option("--url", default="http://localhost:8000", help="Model service URL")
 @click.option("--force", is_flag=True, help="Force removal without confirmation")
 def remove_model(model_id: str, url: str, force: bool = False):
-    """Remove a model from the database"""
+    """Remove a model from the database."""
     try:
         client = ModelServiceClient(url)
 
@@ -364,7 +359,7 @@ def remove_model(model_id: str, url: str, force: bool = False):
                     break
 
             if model_info:
-                click.echo(f"Model to remove:")
+                click.echo("Model to remove:")
                 click.echo(f"  Name: {model_info['name']}")
                 click.echo(f"  Type: {model_info['model_type']}")
                 click.echo(f"  Path: {model_info['model_path']}")
@@ -406,7 +401,7 @@ def generate(
     top_p: Optional[float] = None,
     top_k: Optional[int] = None,
 ):
-    """Generate text using a model"""
+    """Generate text using a model."""
     try:
         client = ModelServiceClient(url)
 
@@ -437,7 +432,7 @@ def generate(
 @click.argument("text")
 @click.option("--url", default="http://localhost:8000", help="Model service URL")
 def classify(model_id: str, text: str, url: str):
-    """Classify text using a model"""
+    """Classify text using a model."""
     try:
         client = ModelServiceClient(url)
 
@@ -465,7 +460,7 @@ def classify(model_id: str, text: str, url: str):
 @click.option("--source-lang", default="en", help="Source language")
 @click.option("--target-lang", default="fr", help="Target language")
 def translate(model_id: str, text: str, url: str, source_lang: str = "en", target_lang: str = "fr"):
-    """Translate text using a model"""
+    """Translate text using a model."""
     try:
         client = ModelServiceClient(url)
 
@@ -491,7 +486,7 @@ def translate(model_id: str, text: str, url: str, source_lang: str = "en", targe
 @click.option("--model-id", required=True, help="Model ID to test")
 @click.option("--prompt", default="Hello, how are you?", help="Test prompt")
 def test_model(url: str, model_id: str, prompt: str):
-    """Test a model with a simple prompt"""
+    """Test a model with a simple prompt."""
     try:
         client = ModelServiceClient(url)
 
@@ -524,7 +519,7 @@ def batch_test(
     model_id: Optional[str] = None,
     output: Optional[str] = None,
 ):
-    """Run batch tests on a model"""
+    """Run batch tests on a model."""
     try:
         client = ModelServiceClient(url)
 

mcli/workflow/model_service/download_and_run_efficient_models.py

@@ -6,21 +6,17 @@ This script identifies the most efficient models in terms of compute and accurac
 downloads them, and runs them using the MCLI model service.
 """
 
-import json
-import os
-import subprocess
 import sys
 import time
 from pathlib import Path
-from typing import Dict, List, Optional
+from typing import Dict, Optional
 
 import click
-import requests
 
 # Add the parent directory to the path so we can import the model service
 sys.path.insert(0, str(Path(__file__).parent.parent.parent.parent))
 
-from mcli.workflow.model_service.model_service import ModelManager, ModelService
+from mcli.workflow.model_service.model_service import ModelService
 
 # Efficient models from Ollama search results
 EFFICIENT_MODELS = {
@@ -68,7 +64,7 @@ EFFICIENT_MODELS = {
 
 
 def get_system_info():
-    """Get system information for model selection"""
+    """Get system information for model selection."""
     import psutil
 
     # Get CPU info
@@ -103,7 +99,7 @@ def get_system_info():
 
 
 def recommend_model(system_info: Dict) -> str:
-    """Recommend the best model based on system capabilities"""
+    """Recommend the best model based on system capabilities."""
     print("🔍 Analyzing system capabilities...")
     print(f"  CPU Cores: {system_info['cpu_count']}")
     print(f"  CPU Frequency: {system_info['cpu_freq_mhz']:.0f} MHz")
@@ -127,7 +123,7 @@ def recommend_model(system_info: Dict) -> str:
 
 
 def download_and_setup_model(model_key: str, service: ModelService) -> Optional[str]:
-    """Download and setup a model using the MCLI service"""
+    """Download and setup a model using the MCLI service."""
     model_info = EFFICIENT_MODELS[model_key]
 
     print(f"\n🚀 Setting up {model_info['name']}...")
@@ -159,7 +155,7 @@ def download_and_setup_model(model_key: str, service: ModelService) -> Optional[
 
 
 def test_model(service: ModelService, model_id: str, model_name: str):
-    """Test the model with sample prompts"""
+    """Test the model with sample prompts."""
     print(f"\n🧪 Testing {model_name}...")
 
     test_prompts = [
@@ -190,7 +186,7 @@ def test_model(service: ModelService, model_id: str, model_name: str):
 
 
 def start_model_service():
-    """Start the MCLI model service"""
+    """Start the MCLI model service."""
     print("🔧 Starting MCLI model service...")
 
     try:
@@ -233,7 +229,7 @@ def start_model_service():
     "--service-only", is_flag=True, help="Only start the model service without downloading models"
 )
 def main(model: Optional[str], auto: bool, test: bool, service_only: bool):
-    """Download and run efficient models from Ollama using MCLI"""
+    """Download and run efficient models from Ollama using MCLI."""
 
     print("🚀 MCLI Efficient Model Runner")
     print("=" * 50)
@@ -278,8 +274,8 @@ def main(model: Optional[str], auto: bool, test: bool, service_only: bool):
 
     print(f"\n🎉 Setup complete! Model {EFFICIENT_MODELS[selected_model]['name']} is ready to use.")
     print(f"📊 Model ID: {model_id}")
-    print(f"🌐 API available at: http://localhost:8000")
-    print(f"📝 Use 'mcli model-service list-models' to see all models")
+    print("🌐 API available at: http://localhost:8000")
+    print("📝 Use 'mcli model-service list-models' to see all models")
 
     return 0
 

mcli/workflow/model_service/lightweight_embedder.py

@@ -6,11 +6,8 @@ This module provides lightweight text embedding capabilities
 that don't require heavy ML libraries like PyTorch or transformers.
 """
 
-import hashlib
 import json
 import logging
-import os
-import sys
 from datetime import datetime
 from pathlib import Path
 from typing import Any, Dict, List, Optional
@@ -18,27 +15,21 @@ from typing import Any, Dict, List, Optional
 import numpy as np
 
 # Try to import lightweight alternatives
-try:
-    import sentence_transformers
-
-    HAS_SENTENCE_TRANSFORMERS = True
-except ImportError:
-    HAS_SENTENCE_TRANSFORMERS = False
+HAS_SENTENCE_TRANSFORMERS = False  # Placeholder for future implementation
 
 try:
-    import sklearn
     from sklearn.feature_extraction.text import TfidfVectorizer
-    from sklearn.metrics.pairwise import cosine_similarity
 
     HAS_SKLEARN = True
 except ImportError:
     HAS_SKLEARN = False
+    TfidfVectorizer = None  # type: ignore
 
 logger = logging.getLogger(__name__)
 
 
 class LightweightEmbedder:
-    """Lightweight text embedder with multiple fallback methods"""
+    """Lightweight text embedder with multiple fallback methods."""
 
     def __init__(self, models_dir: str = "./models/embeddings"):
         self.models_dir = Path(models_dir)
@@ -47,23 +38,23 @@ class LightweightEmbedder:
         self.embedding_cache = {}
 
     def get_embedding_method(self) -> str:
-        """Determine the best available embedding method"""
+        """Determine the best available embedding method."""
         if HAS_SENTENCE_TRANSFORMERS:
             return "sentence_transformers"
         elif HAS_SKLEARN:
-            return "tfidf"
+            return "tfid"
         else:
             return "simple_hash"
 
     def embed_text(self, text: str, method: Optional[str] = None) -> Dict[str, Any]:
-        """Embed text using the specified or best available method"""
+        """Embed text using the specified or best available method."""
         if not method:
             method = self.get_embedding_method()
 
         try:
             if method == "sentence_transformers":
                 return self._embed_with_sentence_transformers(text)
-            elif method == "tfidf":
+            elif method == "tfid":
                 return self._embed_with_tfidf(text)
             else:
                 return self._embed_with_simple_hash(text)
@@ -73,7 +64,7 @@ class LightweightEmbedder:
             return self._embed_with_simple_hash(text)
 
     def _embed_with_sentence_transformers(self, text: str) -> Dict[str, Any]:
-        """Embed text using sentence-transformers"""
+        """Embed text using sentence-transformers."""
         try:
             from sentence_transformers import SentenceTransformer
 
@@ -97,9 +88,8 @@ class LightweightEmbedder:
             raise
 
     def _embed_with_tfidf(self, text: str) -> Dict[str, Any]:
-        """Embed text using TF-IDF"""
+        """Embed text using TF-IDF."""
         try:
-            from sklearn.feature_extraction.text import TfidfVectorizer
 
             # Create or reuse vectorizer
             if self.vectorizer is None:
@@ -114,8 +104,8 @@ class LightweightEmbedder:
             embedding = tfidf_vector.toarray()[0]
 
             return {
-                "method": "tfidf",
-                "model": "sklearn_tfidf",
+                "method": "tfid",
+                "model": "sklearn_tfid",
                 "embedding": embedding.tolist(),
                 "dimensions": len(embedding),
                 "text_length": len(text),
@@ -126,7 +116,7 @@ class LightweightEmbedder:
             raise
 
     def _embed_with_simple_hash(self, text: str) -> Dict[str, Any]:
-        """Embed text using simple hash-based method"""
+        """Embed text using simple hash-based method."""
         try:
             # Create a simple hash-based embedding
             words = text.lower().split()
@@ -165,7 +155,7 @@ class LightweightEmbedder:
             raise
 
     def chunk_text(self, text: str, chunk_size: int = 1000, overlap: int = 200) -> List[str]:
-        """Split text into overlapping chunks"""
+        """Split text into overlapping chunks."""
         chunks = []
         start = 0
 
@@ -181,7 +171,7 @@ class LightweightEmbedder:
         return chunks
 
     def embed_document(self, text: str, chunk_size: int = 1000) -> Dict[str, Any]:
-        """Embed a document by chunking and embedding each chunk"""
+        """Embed a document by chunking and embedding each chunk."""
         try:
             # Split text into chunks
             chunks = self.chunk_text(text, chunk_size)
@@ -222,7 +212,7 @@ class LightweightEmbedder:
             return {"success": False, "error": str(e)}
 
     def search_similar(self, query: str, embeddings: List[Dict], top_k: int = 5) -> List[Dict]:
-        """Search for similar documents using embeddings"""
+        """Search for similar documents using embeddings."""
         try:
             # Embed the query
             query_embedding = self.embed_text(query)
@@ -263,11 +253,11 @@ class LightweightEmbedder:
             return []
 
     def get_status(self) -> Dict[str, Any]:
-        """Get the status of the embedder"""
+        """Get the status of the embedder."""
         return {
             "available_methods": {
                 "sentence_transformers": HAS_SENTENCE_TRANSFORMERS,
-                "tfidf": HAS_SKLEARN,
+                "tfid": HAS_SKLEARN,
                 "simple_hash": True,  # Always available
             },
             "current_method": self.get_embedding_method(),
@@ -277,9 +267,9 @@ class LightweightEmbedder:
 
 
 def create_embedder_api():
-    """Create a simple API for the embedder"""
+    """Create a simple API for the embedder."""
     import urllib.parse
-    from http.server import BaseHTTPRequestHandler, HTTPServer
+    from http.server import BaseHTTPRequestHandler
 
     class EmbedderHandler(BaseHTTPRequestHandler):
         def __init__(self, *args, embedder=None, **kwargs):
@@ -287,7 +277,7 @@ def create_embedder_api():
             super().__init__(*args, **kwargs)
 
         def do_POST(self):
-            """Handle embedding requests"""
+            """Handle embedding requests."""
             parsed_path = urllib.parse.urlparse(self.path)
             path = parsed_path.path
 
@@ -301,7 +291,7 @@ def create_embedder_api():
                 self._send_response(404, {"error": "Endpoint not found"})
 
         def do_GET(self):
-            """Handle status requests"""
+            """Handle status requests."""
             parsed_path = urllib.parse.urlparse(self.path)
             path = parsed_path.path
 
@@ -312,7 +302,7 @@ def create_embedder_api():
                 self._send_response(404, {"error": "Endpoint not found"})
 
         def _handle_embed_text(self):
-            """Handle text embedding requests"""
+            """Handle text embedding requests."""
             try:
                 content_length = int(self.headers.get("Content-Length", 0))
                 post_data = self.rfile.read(content_length)
@@ -332,7 +322,7 @@ def create_embedder_api():
                 self._send_response(500, {"error": str(e)})
 
         def _handle_embed_document(self):
-            """Handle document embedding requests"""
+            """Handle document embedding requests."""
             try:
                 content_length = int(self.headers.get("Content-Length", 0))
                 post_data = self.rfile.read(content_length)
@@ -352,7 +342,7 @@ def create_embedder_api():
                 self._send_response(500, {"error": str(e)})
 
         def _handle_search(self):
-            """Handle search requests"""
+            """Handle search requests."""
             try:
                 content_length = int(self.headers.get("Content-Length", 0))
                 post_data = self.rfile.read(content_length)
@@ -373,7 +363,7 @@ def create_embedder_api():
                 self._send_response(500, {"error": str(e)})
 
         def _send_response(self, status_code, data):
-            """Send JSON response"""
+            """Send JSON response."""
             self.send_response(status_code)
             self.send_header("Content-Type", "application/json")
             self.send_header("Access-Control-Allow-Origin", "*")