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

mcli/workflow/model_service/ollama_efficient_runner.py

@@ -6,13 +6,11 @@ This script uses the Ollama API to pull the most efficient models and then
 integrates them with the MCLI model service for local inference.
 """
 
-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
@@ -20,7 +18,6 @@ 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
 
 # Efficient models from Ollama with their model names
 EFFICIENT_MODELS = {
@@ -73,7 +70,7 @@ EFFICIENT_MODELS = {
 
 
 def check_ollama_installed():
-    """Check if Ollama is installed and running"""
+    """Check if Ollama is installed and running."""
     try:
         # Check if ollama command exists
         result = subprocess.run(["ollama", "--version"], capture_output=True, text=True, timeout=5)
@@ -93,7 +90,7 @@ def check_ollama_installed():
 
 
 def check_ollama_server():
-    """Check if Ollama server is running"""
+    """Check if Ollama server is running."""
     try:
         response = requests.get("http://localhost:11434/api/tags", timeout=5)
         if response.status_code == 200:
@@ -116,7 +113,7 @@ def check_ollama_server():
 
 
 def get_system_info():
-    """Get system information for model selection"""
+    """Get system information for model selection."""
     import psutil
 
     # Get CPU info
@@ -151,7 +148,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")
@@ -175,7 +172,7 @@ def recommend_model(system_info: Dict) -> str:
 
 
 def pull_ollama_model(model_key: str) -> bool:
-    """Pull a model from Ollama"""
+    """Pull a model from Ollama."""
     model_info = EFFICIENT_MODELS[model_key]
 
     print(f"\n📥 Pulling {model_info['name']} from Ollama...")
@@ -209,7 +206,7 @@ def pull_ollama_model(model_key: str) -> bool:
 
 
 def test_ollama_model(model_key: str):
-    """Test the Ollama model with sample prompts"""
+    """Test the Ollama model with sample prompts."""
     model_info = EFFICIENT_MODELS[model_key]
 
     print(f"\n🧪 Testing {model_info['name']} via Ollama...")
@@ -247,7 +244,7 @@ def test_ollama_model(model_key: str):
 
 
 def list_available_models():
-    """List models available in Ollama"""
+    """List models available in Ollama."""
     try:
         response = requests.get("http://localhost:11434/api/tags", timeout=5)
         if response.status_code == 200:
@@ -265,17 +262,16 @@ def list_available_models():
 
 
 def create_mcli_integration_script(model_key: str):
-    """Create a script to integrate the Ollama model with MCLI"""
-    model_info = EFFICIENT_MODELS[model_key]
+    """Create a script to integrate the Ollama model with MCLI."""
+    EFFICIENT_MODELS[model_key]
 
-    script_content = f'''#!/usr/bin/env python3
+    script_content = '''#!/usr/bin/env python3
 """
 Integration script for {model_info['name']} with MCLI model service.
 This script provides a bridge between Ollama and MCLI model service.
 """
 
 import requests
-import json
 import time
 from typing import Dict, Any
 
@@ -363,7 +359,7 @@ if __name__ == "__main__":
 @click.option("--list-models", is_flag=True, help="List available models in Ollama")
 @click.option("--create-bridge", is_flag=True, help="Create MCLI integration script")
 def main(model: Optional[str], auto: bool, test: bool, list_models: bool, create_bridge: bool):
-    """Download and run efficient models from Ollama"""
+    """Download and run efficient models from Ollama."""
 
     print("🚀 Ollama Efficient Model Runner")
     print("=" * 50)
@@ -415,8 +411,8 @@ def main(model: Optional[str], auto: bool, test: bool, list_models: bool, create
     model_info = EFFICIENT_MODELS[selected_model]
     print(f"\n🎉 Setup complete! Model {model_info['name']} is ready to use.")
     print(f"📊 Model: {model_info['ollama_name']}")
-    print(f"🌐 Ollama API: http://localhost:11434")
-    print(f"📝 Use 'ollama list' to see all models")
+    print("🌐 Ollama API: http://localhost:11434")
+    print("📝 Use 'ollama list' to see all models")
 
     return 0
 

mcli/workflow/model_service/openai_adapter.py

@@ -10,9 +10,9 @@ import uuid
 from datetime import datetime
 from typing import Any, AsyncGenerator, Dict, List, Optional
 
-from fastapi import APIRouter, Depends, Header, HTTPException, Request, status
+from fastapi import APIRouter, Depends, Header, HTTPException, status
 from fastapi.responses import StreamingResponse
-from pydantic import BaseModel, Field
+from pydantic import BaseModel
 
 from mcli.lib.logger.logger import get_logger
 
@@ -20,7 +20,7 @@ logger = get_logger(__name__)
 
 
 class Message(BaseModel):
-    """OpenAI message format"""
+    """OpenAI message format."""
 
     role: str
     content: str
@@ -28,7 +28,7 @@ class Message(BaseModel):
 
 
 class ChatCompletionRequest(BaseModel):
-    """OpenAI chat completion request"""
+    """OpenAI chat completion request."""
 
     model: str
     messages: List[Message]
@@ -44,7 +44,7 @@ class ChatCompletionRequest(BaseModel):
 
 
 class ChatCompletionChoice(BaseModel):
-    """Chat completion choice"""
+    """Chat completion choice."""
 
     index: int
     message: Message
@@ -52,7 +52,7 @@ class ChatCompletionChoice(BaseModel):
 
 
 class Usage(BaseModel):
-    """Token usage information"""
+    """Token usage information."""
 
     prompt_tokens: int
     completion_tokens: int
@@ -60,7 +60,7 @@ class Usage(BaseModel):
 
 
 class ChatCompletionResponse(BaseModel):
-    """OpenAI chat completion response"""
+    """OpenAI chat completion response."""
 
     id: str
     object: str = "chat.completion"
@@ -71,7 +71,7 @@ class ChatCompletionResponse(BaseModel):
 
 
 class ModelInfo(BaseModel):
-    """Model information"""
+    """Model information."""
 
     id: str
     object: str = "model"
@@ -80,20 +80,20 @@ class ModelInfo(BaseModel):
 
 
 class ModelListResponse(BaseModel):
-    """Model list response"""
+    """Model list response."""
 
     object: str = "list"
     data: List[ModelInfo]
 
 
 class APIKeyManager:
-    """Manages API key authentication"""
+    """Manages API key authentication."""
 
     def __init__(self):
         self.valid_keys: Dict[str, Dict[str, Any]] = {}
 
     def add_key(self, key: str, name: str = "default", metadata: Optional[Dict] = None):
-        """Add a valid API key"""
+        """Add a valid API key."""
         self.valid_keys[key] = {
             "name": name,
             "created_at": datetime.now().isoformat(),
@@ -102,19 +102,19 @@ class APIKeyManager:
         }
 
     def validate_key(self, key: str) -> bool:
-        """Validate an API key"""
+        """Validate an API key."""
         if key in self.valid_keys:
             self.valid_keys[key]["usage_count"] += 1
             return True
         return False
 
     def remove_key(self, key: str):
-        """Remove an API key"""
+        """Remove an API key."""
         if key in self.valid_keys:
             del self.valid_keys[key]
 
     def list_keys(self) -> List[Dict[str, Any]]:
-        """List all API keys (without showing the actual key)"""
+        """List all API keys (without showing the actual key)."""
         return [
             {
                 "name": info["name"],
@@ -126,7 +126,7 @@ class APIKeyManager:
 
 
 class OpenAIAdapter:
-    """Adapter to make MCLI model service OpenAI-compatible"""
+    """Adapter to make MCLI model service OpenAI-compatible."""
 
     def __init__(self, model_manager, require_auth: bool = True):
         self.model_manager = model_manager
@@ -138,11 +138,11 @@ class OpenAIAdapter:
         self._setup_routes()
 
     def _setup_routes(self):
-        """Setup OpenAI-compatible routes"""
+        """Setup OpenAI-compatible routes."""
 
         @self.router.get("/models", response_model=ModelListResponse)
         async def list_models(api_key: str = Depends(self.verify_api_key)):
-            """List available models (OpenAI compatible)"""
+            """List available models (OpenAI compatible)."""
             models = []
 
             # Get loaded models from model manager
@@ -177,7 +177,7 @@ class OpenAIAdapter:
         async def create_chat_completion(
             request: ChatCompletionRequest, api_key: str = Depends(self.verify_api_key)
         ):
-            """Create a chat completion (OpenAI compatible)"""
+            """Create a chat completion (OpenAI compatible)."""
             try:
                 # Extract the conversation history
                 messages = request.messages
@@ -219,7 +219,7 @@ class OpenAIAdapter:
                 raise HTTPException(status_code=500, detail=str(e))
 
     def _messages_to_prompt(self, messages: List[Message]) -> str:
-        """Convert OpenAI messages format to a simple prompt"""
+        """Convert OpenAI messages format to a simple prompt."""
         prompt_parts = []
 
         for message in messages:
@@ -236,7 +236,7 @@ class OpenAIAdapter:
         return "\n\n".join(prompt_parts)
 
     async def _generate_response(self, request: ChatCompletionRequest, prompt: str) -> str:
-        """Generate a response from the model"""
+        """Generate a response from the model."""
         try:
             # Use the lightweight model server if available
             if hasattr(self.model_manager, "loaded_models"):
@@ -275,7 +275,7 @@ class OpenAIAdapter:
     async def _generate_stream(
         self, request: ChatCompletionRequest, prompt: str
     ) -> AsyncGenerator[str, None]:
-        """Generate a streaming response"""
+        """Generate a streaming response."""
         completion_id = f"chatcmpl-{uuid.uuid4().hex[:24]}"
 
         # Generate response
@@ -304,7 +304,7 @@ class OpenAIAdapter:
         yield "data: [DONE]\n\n"
 
     async def verify_api_key(self, authorization: Optional[str] = Header(None)) -> str:
-        """Verify API key from Authorization header"""
+        """Verify API key from Authorization header."""
         if not self.require_auth:
             return "no-auth-required"
 
@@ -343,5 +343,5 @@ class OpenAIAdapter:
 
 
 def create_openai_adapter(model_manager, require_auth: bool = True) -> OpenAIAdapter:
-    """Create an OpenAI adapter instance"""
+    """Create an OpenAI adapter instance."""
     return OpenAIAdapter(model_manager, require_auth)

mcli/workflow/model_service/pdf_processor.py

@@ -7,19 +7,14 @@ that integrate with the lightweight model service for AI-powered
 document analysis.
 """
 
-import base64
 import json
 import logging
 import os
-import shutil
-import sys
 import tempfile
 from datetime import datetime
 from pathlib import Path
 from typing import Any, Dict, List, Optional
 
-import requests
-
 # PDF processing libraries
 try:
     import fitz  # PyMuPDF
@@ -34,7 +29,7 @@ logger = logging.getLogger(__name__)
 
 
 class PDFProcessor:
-    """PDF processing with lightweight model integration"""
+    """PDF processing with lightweight model integration."""
 
     def __init__(self, models_dir: str = "./models/lightweight", port: int = 8080):
         self.models_dir = Path(models_dir)
@@ -43,7 +38,7 @@ class PDFProcessor:
         self.temp_dir = Path(tempfile.mkdtemp(prefix="pdf_processor_"))
 
     def extract_text_from_pdf(self, pdf_path: str) -> Dict[str, Any]:
-        """Extract text from PDF with enhanced processing"""
+        """Extract text from PDF with enhanced processing."""
         try:
             pdf_path = Path(pdf_path)
             if not pdf_path.exists():
@@ -69,7 +64,7 @@ class PDFProcessor:
             return {"error": str(e)}
 
     def _extract_pdf_text_enhanced(self, pdf_path: Path) -> str:
-        """Enhanced PDF text extraction using multiple methods"""
+        """Enhanced PDF text extraction using multiple methods."""
         text_content = ""
 
         try:
@@ -100,7 +95,7 @@ class PDFProcessor:
         return text_content
 
     def process_pdf_with_ai(self, pdf_path: str, model_key: Optional[str] = None) -> Dict[str, Any]:
-        """Process PDF with AI model for enhanced analysis"""
+        """Process PDF with AI model for enhanced analysis."""
         try:
             # Extract text first
             extraction_result = self.extract_text_from_pdf(pdf_path)
@@ -137,7 +132,7 @@ class PDFProcessor:
             return {"error": str(e)}
 
     def _analyze_text_with_ai(self, text_content: str, model_key: str) -> Dict[str, Any]:
-        """Analyze text content with AI model"""
+        """Analyze text content with AI model."""
         try:
             # For now, provide basic analysis
             # In a full implementation, this would use the actual model for inference
@@ -159,7 +154,7 @@ class PDFProcessor:
             return {"error": str(e)}
 
     def _generate_summary(self, text: str) -> str:
-        """Generate a basic summary of the text"""
+        """Generate a basic summary of the text."""
         sentences = text.split(".")
         if len(sentences) <= 3:
             return text[:500] + "..." if len(text) > 500 else text
@@ -169,7 +164,7 @@ class PDFProcessor:
         return summary[:500] + "..." if len(summary) > 500 else summary
 
     def _extract_key_topics(self, text: str) -> List[str]:
-        """Extract key topics from text"""
+        """Extract key topics from text."""
         # Simple keyword extraction
         words = text.lower().split()
         word_freq = {}
@@ -187,7 +182,7 @@ class PDFProcessor:
             "at",
             "to",
             "for",
-            "of",
+            "o",
             "with",
             "by",
             "is",
@@ -236,7 +231,7 @@ class PDFProcessor:
         return [word for word, freq in sorted_words[:5]]
 
     def _classify_document_type(self, text: str) -> str:
-        """Classify the type of document"""
+        """Classify the type of document."""
         text_lower = text.lower()
 
         if any(word in text_lower for word in ["contract", "agreement", "terms", "conditions"]):
@@ -253,7 +248,7 @@ class PDFProcessor:
             return "general"
 
     def _calculate_complexity_score(self, text: str) -> float:
-        """Calculate text complexity score (0-1)"""
+        """Calculate text complexity score (0-1)."""
         sentences = text.split(".")
         words = text.split()
 
@@ -268,7 +263,7 @@ class PDFProcessor:
         return min(1.0, max(0.0, complexity))
 
     def start_pdf_processing_service(self, port: int = 8080) -> bool:
-        """Start the PDF processing service"""
+        """Start the PDF processing service."""
         try:
             self.port = port
             self.lightweight_server.port = port
@@ -280,7 +275,7 @@ class PDFProcessor:
             return False
 
     def get_service_status(self) -> Dict[str, Any]:
-        """Get the status of the PDF processing service"""
+        """Get the status of the PDF processing service."""
         return {
             "service_running": self.lightweight_server.running,
             "port": self.port,
@@ -291,9 +286,9 @@ class PDFProcessor:
 
 
 def create_pdf_processor_api():
-    """Create a simple API for PDF processing"""
+    """Create a simple API for PDF processing."""
     import urllib.parse
-    from http.server import BaseHTTPRequestHandler, HTTPServer
+    from http.server import BaseHTTPRequestHandler
 
     class PDFProcessorHandler(BaseHTTPRequestHandler):
         def __init__(self, *args, processor=None, **kwargs):
@@ -301,11 +296,11 @@ def create_pdf_processor_api():
             super().__init__(*args, **kwargs)
 
         def do_POST(self):
-            """Handle PDF processing requests"""
+            """Handle PDF processing requests."""
             parsed_path = urllib.parse.urlparse(self.path)
             path = parsed_path.path
 
-            if path == "/process-pdf":
+            if path == "/process-pd":
                 self._handle_process_pdf()
             elif path == "/extract-text":
                 self._handle_extract_text()
@@ -313,7 +308,7 @@ def create_pdf_processor_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
 
@@ -324,7 +319,7 @@ def create_pdf_processor_api():
                 self._send_response(404, {"error": "Endpoint not found"})
 
         def _handle_process_pdf(self):
-            """Handle PDF processing with AI"""
+            """Handle PDF processing with AI."""
             try:
                 content_length = int(self.headers.get("Content-Length", 0))
                 post_data = self.rfile.read(content_length)
@@ -344,7 +339,7 @@ def create_pdf_processor_api():
                 self._send_response(500, {"error": str(e)})
 
         def _handle_extract_text(self):
-            """Handle text extraction from PDF"""
+            """Handle text extraction from PDF."""
             try:
                 content_length = int(self.headers.get("Content-Length", 0))
                 post_data = self.rfile.read(content_length)
@@ -363,7 +358,7 @@ def create_pdf_processor_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", "*")
@@ -378,7 +373,7 @@ if __name__ == "__main__":
     processor = PDFProcessor()
 
     # Test with a sample PDF if available
-    test_pdf = "test.pdf"
+    test_pdf = "test.pd"
     if os.path.exists(test_pdf):
         result = processor.process_pdf_with_ai(test_pdf)
         print(json.dumps(result, indent=2))

mcli/workflow/model_service/test_efficient_runner.py

@@ -3,20 +3,22 @@
 Test script for the efficient model runner functionality.
 """
 
-import os
 import sys
 from pathlib import Path
 
+import psutil
+
 # Add the parent directory to the path so we can import the modules
 sys.path.insert(0, str(Path(__file__).parent.parent.parent.parent))
 
+from mcli.workflow.model_service.model_service import ModelService
+
 
 def test_imports():
-    """Test that all required modules can be imported"""
+    """Test that all required modules can be imported."""
     print("🧪 Testing imports...")
 
     try:
-        import requests
 
         print("✅ requests imported")
     except ImportError as e:
@@ -24,7 +26,6 @@ def test_imports():
         return False
 
     try:
-        import click
 
         print("✅ click imported")
     except ImportError as e:
@@ -32,7 +33,6 @@ def test_imports():
         return False
 
     try:
-        import psutil
 
         print("✅ psutil imported")
     except ImportError as e:
@@ -40,7 +40,6 @@ def test_imports():
         return False
 
     try:
-        from mcli.workflow.model_service.model_service import ModelService
 
         print("✅ ModelService imported")
     except ImportError as e:
@@ -51,11 +50,10 @@ def test_imports():
 
 
 def test_system_analysis():
-    """Test system analysis functionality"""
+    """Test system analysis functionality."""
     print("\n🧪 Testing system analysis...")
 
     try:
-        import psutil
 
         # Get basic system info
         cpu_count = psutil.cpu_count()
@@ -84,7 +82,7 @@ def test_system_analysis():
 
 
 def test_model_selection():
-    """Test model selection logic"""
+    """Test model selection logic."""
     print("\n🧪 Testing model selection...")
 
     try:
@@ -102,7 +100,7 @@ def test_model_selection():
 
         # Test system info
         system_info = get_system_info()
-        print(f"✅ System info collected")
+        print("✅ System info collected")
 
         # Test model recommendation
         recommended = recommend_model(system_info)
@@ -116,7 +114,7 @@ def test_model_selection():
 
 
 def test_ollama_check():
-    """Test Ollama installation check"""
+    """Test Ollama installation check."""
     print("\n🧪 Testing Ollama check...")
 
     try:
@@ -138,11 +136,10 @@ def test_ollama_check():
 
 
 def test_mcli_service():
-    """Test MCLI model service functionality"""
+    """Test MCLI model service functionality."""
     print("\n🧪 Testing MCLI model service...")
 
     try:
-        from mcli.workflow.model_service.model_service import ModelService
 
         # Create service instance
         service = ModelService()
@@ -164,11 +161,10 @@ def test_mcli_service():
 
 
 def test_api_endpoints():
-    """Test API endpoint definitions"""
+    """Test API endpoint definitions."""
     print("\n🧪 Testing API endpoints...")
 
     try:
-        from mcli.workflow.model_service.model_service import ModelService
 
         service = ModelService()
 
@@ -191,7 +187,7 @@ def test_api_endpoints():
 
 
 def main():
-    """Run all tests"""
+    """Run all tests."""
     print("🚀 Testing Efficient Model Runner")
     print("=" * 50)