mcli-framework 7.0.0__py3-none-any.whl

mcli/workflow/model_service/test_example.py

@@ -0,0 +1,315 @@
+#!/usr/bin/env python3
+"""
+Test example for the MCLI Model Service
+
+This script demonstrates how to:
+1. Start the model service
+2. Load a simple language model
+3. Make inference requests
+4. Test different model types
+"""
+
+import json
+import os
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+import requests
+
+# Add the current directory to Python path
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+
+from client import ModelServiceClient
+
+
+def check_service_running(url: str = "http://localhost:8000") -> bool:
+    """Check if the model service is running"""
+    try:
+        response = requests.get(f"{url}/health", timeout=5)
+        return response.status_code == 200
+    except:
+        return False
+
+
+def start_service():
+    """Start the model service if not running"""
+    if check_service_running():
+        print("✅ Model service is already running")
+        return True
+
+    print("🚀 Starting model service...")
+    try:
+        # Start the service in the background
+        process = subprocess.Popen(
+            [sys.executable, "model_service.py", "start"],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+        )
+
+        # Wait a bit for the service to start
+        time.sleep(5)
+
+        if check_service_running():
+            print("✅ Model service started successfully")
+            return True
+        else:
+            print("❌ Failed to start model service")
+            return False
+
+    except Exception as e:
+        print(f"❌ Error starting service: {e}")
+        return False
+
+
+def test_text_generation():
+    """Test text generation with a simple model"""
+    print("\n" + "=" * 60)
+    print("🧪 Testing Text Generation")
+    print("=" * 60)
+
+    client = ModelServiceClient()
+
+    try:
+        # Load a simple text generation model
+        print("📥 Loading GPT-2 model...")
+        model_id = client.load_model(
+            name="GPT-2 Test",
+            model_type="text-generation",
+            model_path="gpt2",  # This will download from Hugging Face
+            temperature=0.7,
+            max_length=50,
+        )
+        print(f"✅ Model loaded with ID: {model_id}")
+
+        # Test text generation
+        test_prompts = [
+            "Hello, how are you?",
+            "The future of artificial intelligence is",
+            "Once upon a time, there was a magical",
+            "The best way to learn programming is",
+        ]
+
+        for i, prompt in enumerate(test_prompts, 1):
+            print(f"\n📝 Test {i}: {prompt}")
+            result = client.generate_text(model_id, prompt)
+            print(f"🤖 Generated: {result['generated_text']}")
+            print(f"⏱️  Time: {result['execution_time_ms']} ms")
+
+        # Clean up
+        client.unload_model(model_id)
+        print(f"\n🧹 Model {model_id} unloaded")
+
+    except Exception as e:
+        print(f"❌ Error in text generation test: {e}")
+
+
+def test_text_classification():
+    """Test text classification with a sentiment model"""
+    print("\n" + "=" * 60)
+    print("🧪 Testing Text Classification")
+    print("=" * 60)
+
+    client = ModelServiceClient()
+
+    try:
+        # Load a sentiment classification model
+        print("📥 Loading BERT sentiment model...")
+        model_id = client.load_model(
+            name="BERT Sentiment",
+            model_type="text-classification",
+            model_path="nlptown/bert-base-multilingual-uncased-sentiment",
+        )
+        print(f"✅ Model loaded with ID: {model_id}")
+
+        # Test text classification
+        test_texts = [
+            "I love this product! It's amazing!",
+            "This is the worst experience ever.",
+            "The service was okay, nothing special.",
+            "Absolutely fantastic and wonderful!",
+        ]
+
+        for i, text in enumerate(test_texts, 1):
+            print(f"\n📝 Test {i}: {text}")
+            result = client.classify_text(model_id, text)
+            print("🏷️  Classifications:")
+            for class_name, probability in result["classifications"].items():
+                print(f"   {class_name}: {probability:.4f}")
+            print(f"⏱️  Time: {result['execution_time_ms']} ms")
+
+        # Clean up
+        client.unload_model(model_id)
+        print(f"\n🧹 Model {model_id} unloaded")
+
+    except Exception as e:
+        print(f"❌ Error in text classification test: {e}")
+
+
+def test_translation():
+    """Test translation with a translation model"""
+    print("\n" + "=" * 60)
+    print("🧪 Testing Translation")
+    print("=" * 60)
+
+    client = ModelServiceClient()
+
+    try:
+        # Load a translation model
+        print("📥 Loading Marian translation model...")
+        model_id = client.load_model(
+            name="Marian EN-FR", model_type="translation", model_path="Helsinki-NLP/opus-mt-en-fr"
+        )
+        print(f"✅ Model loaded with ID: {model_id}")
+
+        # Test translation
+        test_texts = [
+            "Hello, how are you?",
+            "The weather is beautiful today.",
+            "I love learning new languages.",
+            "Technology is advancing rapidly.",
+        ]
+
+        for i, text in enumerate(test_texts, 1):
+            print(f"\n📝 Test {i}: {text}")
+            result = client.translate_text(model_id, text, source_lang="en", target_lang="fr")
+            print(f"🌐 Translation: {result['translated_text']}")
+            print(f"⏱️  Time: {result['execution_time_ms']} ms")
+
+        # Clean up
+        client.unload_model(model_id)
+        print(f"\n🧹 Model {model_id} unloaded")
+
+    except Exception as e:
+        print(f"❌ Error in translation test: {e}")
+
+
+def test_batch_operations():
+    """Test batch operations and performance"""
+    print("\n" + "=" * 60)
+    print("🧪 Testing Batch Operations")
+    print("=" * 60)
+
+    client = ModelServiceClient()
+
+    try:
+        # Load a model for batch testing
+        print("📥 Loading model for batch testing...")
+        model_id = client.load_model(
+            name="GPT-2 Batch Test",
+            model_type="text-generation",
+            model_path="gpt2",
+            temperature=0.8,
+            max_length=30,
+        )
+
+        # Generate multiple prompts
+        prompts = [
+            "The quick brown fox",
+            "In a galaxy far away",
+            "The best time to plant a tree",
+            "Life is what happens when",
+            "Success is not final, failure",
+        ]
+
+        print(f"🔄 Processing {len(prompts)} prompts...")
+        start_time = time.time()
+
+        results = []
+        for i, prompt in enumerate(prompts, 1):
+            print(f"  Processing {i}/{len(prompts)}: {prompt[:20]}...")
+            result = client.generate_text(model_id, prompt)
+            results.append(
+                {
+                    "prompt": prompt,
+                    "generated": result["generated_text"],
+                    "time": result["execution_time_ms"],
+                }
+            )
+
+        total_time = time.time() - start_time
+
+        # Display results
+        print(f"\n📊 Batch Results:")
+        print(f"Total time: {total_time:.2f} seconds")
+        print(f"Average time per request: {total_time/len(prompts):.2f} seconds")
+
+        for i, result in enumerate(results, 1):
+            print(f"\n{i}. Prompt: {result['prompt']}")
+            print(f"   Generated: {result['generated']}")
+            print(f"   Time: {result['time']} ms")
+
+        # Clean up
+        client.unload_model(model_id)
+        print(f"\n🧹 Model {model_id} unloaded")
+
+    except Exception as e:
+        print(f"❌ Error in batch operations test: {e}")
+
+
+def test_service_management():
+    """Test service management functions"""
+    print("\n" + "=" * 60)
+    print("🧪 Testing Service Management")
+    print("=" * 60)
+
+    client = ModelServiceClient()
+
+    try:
+        # Get service status
+        print("📊 Getting service status...")
+        status = client.get_status()
+        health = client.get_health()
+
+        print(f"Service: {status['service']}")
+        print(f"Version: {status['version']}")
+        print(f"Status: {status['status']}")
+        print(f"Models loaded: {status['models_loaded']}")
+        print(f"Memory usage: {health.get('memory_usage_mb', 0):.1f} MB")
+
+        # List models
+        print("\n📋 Listing models...")
+        models = client.list_models()
+        if models:
+            print(f"Found {len(models)} models:")
+            for model in models:
+                status_icon = "✅" if model.get("is_loaded") else "⏳"
+                print(f"  {status_icon} {model['name']} ({model['model_type']})")
+        else:
+            print("No models found")
+
+        print("\n✅ Service management test completed")
+
+    except Exception as e:
+        print(f"❌ Error in service management test: {e}")
+
+
+def main():
+    """Main test function"""
+    print("🚀 MCLI Model Service Test Suite")
+    print("=" * 60)
+
+    # Check if service is running
+    if not check_service_running():
+        print("❌ Model service is not running")
+        print("Please start the service first:")
+        print("  python model_service.py start")
+        return
+
+    print("✅ Model service is running")
+
+    # Run tests
+    test_service_management()
+    test_text_generation()
+    test_text_classification()
+    test_translation()
+    test_batch_operations()
+
+    print("\n" + "=" * 60)
+    print("🎉 All tests completed!")
+    print("=" * 60)
+
+
+if __name__ == "__main__":
+    main()

mcli/workflow/model_service/test_integration.py

@@ -0,0 +1,131 @@
+#!/usr/bin/env python3
+"""
+Test script for lightweight model server integration with MCLI model service
+"""
+
+import json
+import sys
+import time
+from pathlib import Path
+
+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 LIGHTWEIGHT_MODELS, ModelService
+
+
+def test_lightweight_integration():
+    """Test the lightweight server integration"""
+    print("🧪 Testing Lightweight Model Server Integration")
+    print("=" * 60)
+
+    # Create service instance
+    service = ModelService()
+
+    # Test 1: List available lightweight models
+    print("\n1. Testing lightweight models listing...")
+    try:
+        models = service.lightweight_server.downloader.get_downloaded_models()
+        print(f"✅ Downloaded models: {models}")
+
+        print("Available lightweight models:")
+        for key, info in LIGHTWEIGHT_MODELS.items():
+            status = (
+                "✅ Downloaded"
+                if key in service.lightweight_server.loaded_models
+                else "⏳ Not downloaded"
+            )
+            print(f"  {status} - {info['name']} ({info['parameters']})")
+    except Exception as e:
+        print(f"❌ Error listing models: {e}")
+
+    # Test 2: System analysis
+    print("\n2. Testing system analysis...")
+    try:
+        system_info = service.lightweight_server.get_system_info()
+        print(f"✅ System info: {system_info}")
+
+        recommended = service.lightweight_server.recommend_model()
+        print(f"✅ Recommended model: {recommended}")
+    except Exception as e:
+        print(f"❌ Error analyzing system: {e}")
+
+    # Test 3: Download a small model
+    print("\n3. Testing model download...")
+    try:
+        # Use the smallest model for testing
+        test_model = "prajjwal1/bert-tiny"
+        print(f"📥 Downloading {test_model}...")
+
+        success = service.lightweight_server.download_and_load_model(test_model)
+        if success:
+            print(f"✅ Successfully downloaded {test_model}")
+        else:
+            print(f"❌ Failed to download {test_model}")
+    except Exception as e:
+        print(f"❌ Error downloading model: {e}")
+
+    # Test 4: API endpoints (if server is running)
+    print("\n4. Testing API endpoints...")
+    try:
+        # Test lightweight models endpoint
+        response = requests.get("http://localhost:8000/lightweight/models", timeout=5)
+        if response.status_code == 200:
+            data = response.json()
+            print(f"✅ Lightweight models API: {len(data.get('models', {}))} models available")
+        else:
+            print(f"⚠️  Lightweight models API returned status {response.status_code}")
+    except requests.exceptions.ConnectionError:
+        print("⚠️  Model service not running, skipping API tests")
+    except Exception as e:
+        print(f"❌ Error testing API: {e}")
+
+    print("\n✅ Integration test completed!")
+
+
+def test_cli_commands():
+    """Test CLI commands"""
+    print("\n🧪 Testing CLI Commands")
+    print("=" * 40)
+
+    print("Available CLI commands:")
+    print("  mcli model-service lightweight --list")
+    print("  mcli model-service lightweight --auto")
+    print("  mcli model-service lightweight --download prajjwal1/bert-tiny")
+    print("  mcli model-service lightweight --start-server --port 8080")
+    print("  mcli model-service lightweight-run --auto --port 8080")
+    print("  mcli model-service lightweight-run --list-models")
+
+
+def main():
+    """Main test function"""
+    print("🚀 MCLI Lightweight Model Server Integration Test")
+    print("=" * 70)
+
+    test_lightweight_integration()
+    test_cli_commands()
+
+    print("\n📝 Usage Examples:")
+    print("1. List available lightweight models:")
+    print("   mcli model-service lightweight --list")
+    print()
+    print("2. Download recommended model:")
+    print("   mcli model-service lightweight --auto")
+    print()
+    print("3. Start lightweight server:")
+    print("   mcli model-service lightweight --start-server --port 8080")
+    print()
+    print("4. Run standalone lightweight server:")
+    print("   mcli model-service lightweight-run --auto --port 8080")
+    print()
+    print("5. API endpoints (when service is running):")
+    print("   GET  /lightweight/models")
+    print("   POST /lightweight/models/{model_key}/download")
+    print("   POST /lightweight/start")
+    print("   GET  /lightweight/status")
+
+
+if __name__ == "__main__":
+    main()

mcli/workflow/model_service/test_new_features.py

@@ -0,0 +1,149 @@
+#!/usr/bin/env python3
+"""
+Test script for the new model service features:
+1. List models functionality
+2. Add model from URL functionality
+"""
+
+import os
+import sys
+from pathlib import Path
+
+# 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
+
+
+def test_list_models():
+    """Test the list models functionality"""
+    print("🧪 Testing list models functionality...")
+
+    try:
+        service = ModelService()
+        models = service.model_manager.db.get_all_models()
+
+        print(f"📝 Found {len(models)} models in database")
+
+        if models:
+            print("Models:")
+            for model in models:
+                status = "🟢 Loaded" if model.is_loaded else "⚪ Not Loaded"
+                print(f"  {status} - {model.name} ({model.model_type})")
+        else:
+            print("No models found in database")
+
+        # Test summary
+        summary = service.model_manager.get_models_summary()
+        print(f"\n📊 Summary:")
+        print(f"  Total models: {summary['total_models']}")
+        print(f"  Loaded models: {summary['loaded_models']}")
+        print(f"  Total memory: {summary['total_memory_mb']:.1f} MB")
+
+        print("✅ List models test passed!")
+
+    except Exception as e:
+        print(f"❌ List models test failed: {e}")
+        return False
+
+    return True
+
+
+def test_add_model_from_url():
+    """Test the add model from URL functionality"""
+    print("\n🧪 Testing add model from URL functionality...")
+
+    try:
+        service = ModelService()
+
+        # Test with a simple model URL (this is just a test URL)
+        test_model_url = (
+            "https://huggingface.co/microsoft/DialoGPT-small/resolve/main/pytorch_model.bin"
+        )
+        test_tokenizer_url = (
+            "https://huggingface.co/microsoft/DialoGPT-small/resolve/main/tokenizer.json"
+        )
+
+        print(f"🌐 Testing with URL: {test_model_url}")
+
+        # Note: This would actually download the model, so we'll just test the function exists
+        # In a real scenario, you'd want to test with a smaller model or mock the download
+
+        # Test that the method exists and can be called
+        if hasattr(service.model_manager, "add_model_from_url"):
+            print("✅ add_model_from_url method exists")
+        else:
+            print("❌ add_model_from_url method not found")
+            return False
+
+        if hasattr(service.model_manager, "download_model_from_url"):
+            print("✅ download_model_from_url method exists")
+        else:
+            print("❌ download_model_from_url method not found")
+            return False
+
+        print("✅ Add model from URL test passed!")
+
+    except Exception as e:
+        print(f"❌ Add model from URL test failed: {e}")
+        return False
+
+    return True
+
+
+def test_api_endpoints():
+    """Test that the new API endpoints are properly defined"""
+    print("\n🧪 Testing API endpoints...")
+
+    try:
+        service = ModelService()
+
+        # Check if the new endpoints are defined
+        routes = [route.path for route in service.app.routes]
+
+        expected_routes = ["/models", "/models/summary", "/models/from-url"]
+
+        for route in expected_routes:
+            if route in routes:
+                print(f"✅ Route {route} found")
+            else:
+                print(f"❌ Route {route} not found")
+                return False
+
+        print("✅ API endpoints test passed!")
+
+    except Exception as e:
+        print(f"❌ API endpoints test failed: {e}")
+        return False
+
+    return True
+
+
+def main():
+    """Run all tests"""
+    print("🚀 Testing new model service features...")
+    print("=" * 50)
+
+    tests = [test_list_models, test_add_model_from_url, test_api_endpoints]
+
+    passed = 0
+    total = len(tests)
+
+    for test in tests:
+        if test():
+            passed += 1
+        print()
+
+    print("=" * 50)
+    print(f"📊 Test Results: {passed}/{total} tests passed")
+
+    if passed == total:
+        print("🎉 All tests passed!")
+        return 0
+    else:
+        print("❌ Some tests failed!")
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

mcli/workflow/openai/openai.py

@@ -0,0 +1,99 @@
+import os
+
+import click
+import requests
+
+from mcli.lib.logger.logger import get_logger
+
+logger = get_logger(__name__)
+
+
+OPENAI_NASTY_CATEGORIES = {
+    "sexual",
+    "hate",
+    "harassment",
+    "self-harm",
+    "sexual/minors",
+    "hate/threatening",
+    "violence/graphic",
+    "self-harm/intent",
+    "self-harm/instructions",
+    "harassment/threatening",
+    "violence",
+}
+
+# Get API key from environment variable
+openai_api_key = os.environ.get("OPENAI_API_KEY", "")
+start_sequence = "\nA:"
+restart_sequence = "\n\nQ: "
+
+
+class OpenAI:
+    def __init__(self):
+        self.class_name = self.__class__.__name__
+
+    def log_error(self, error, exception=None, warning=False):
+        if warning:
+            logger.error(error)
+        else:
+            logger.error(error)
+
+    def is_text_risky(self, text: str) -> object:
+        """Ask the openai moderation endpoint if the text is risky.
+
+        See https://platform.openai.com/docs/guides/moderation/quickstart for details.
+        """
+        allowed_categories = {"violence"}  # Can be triggered by some AI safety terms
+
+        response = None
+        try:
+            http_response = requests.post(
+                "https://api.openai.com/v1/moderations",
+                headers={
+                    "Content-Type": "application/json",
+                    "Authorization": f"Bearer {openai_api_key}",
+                },
+                json={"input": text},
+            )
+        except Exception as e:
+            self.log_error("Error in Requests module trying to moderate content", e)
+            return True
+
+        if http_response.status_code == 401:
+            self.log_error("OpenAI Authentication Failed")
+            return True
+        elif http_response.status_code == 429:
+            self.log_error("OpenAI Rate Limit Exceeded", warning=True)
+            return True
+        elif http_response.status_code != 200:
+            self.log_error(
+                f"Possible issue with the OpenAI API. Status: {http_response.status_code}, Content: {http_response.text}"
+            )
+            return True
+        response = http_response.json()
+        logger.info(response)
+
+        return response
+
+
+@click.group(name="openai")
+def openai():
+    """OpenAI CLI command group."""
+    pass
+
+
+@openai.command(name="is_text_risky")
+@click.argument("text")
+def is_text_risky(text: str):
+    """Check if the provided text is risky using OpenAI moderation."""
+    openai_instance = OpenAI()
+    result = openai_instance.is_text_risky(text)
+    click.echo(f"Is the text risky? {result}")
+
+
+if __name__ == "__main__":
+    oai = OpenAI()
+    # Example usage
+    text_to_check = "This is a test message."
+    is_risky = oai.is_text_risky(text_to_check)
+    print(f"Is the text risky? {is_risky}")