mcli-framework 7.0.1__tar.gz → 7.0.5__tar.gz

{mcli_framework-7.0.1 → mcli_framework-7.0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcli-framework
-Version: 7.0.1
+Version: 7.0.5
 Summary: 🚀 High-performance CLI framework with Rust extensions, AI chat, and stunning visuals
 Author-email: Luis Fernandez de la Vara <luis@lefv.io>
 Maintainer-email: Luis Fernandez de la Vara <luis@lefv.io>

{mcli_framework-7.0.1 → mcli_framework-7.0.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mcli-framework"
-version = "7.0.1"
+version = "7.0.5"
 description = "🚀 High-performance CLI framework with Rust extensions, AI chat, and stunning visuals"
 readme = "README.md"
 requires-python = ">=3.9"

{mcli_framework-7.0.1 → mcli_framework-7.0.5}/src/mcli/app/completion_helpers.py

@@ -137,8 +137,12 @@ LAZY_COMMAND_COMPLETIONS = {
         "subcommands": [
             "download",
             "list",
-            "remove",
-            "info"
+            "start",
+            "stop",
+            "pull",
+            "delete",
+            "recommend",
+            "status"
         ]
     },
     "cron-test": {

{mcli_framework-7.0.1 → mcli_framework-7.0.5}/src/mcli/app/model_cmd.py

@@ -7,6 +7,7 @@ from pathlib import Path
 from typing import Optional
 
 import click
+import psutil
 
 from mcli.lib.logger.logger import get_logger
 from mcli.workflow.model_service.lightweight_model_server import (
@@ -223,5 +224,106 @@ def status(port: int):
         click.echo(f"❌ Error checking server: {e}")
 
 
+@model.command()
+@click.option("--port", "-p", default=8080, help="Port where server is running")
+def stop(port: int):
+    """Stop the lightweight model server."""
+    import requests
+    import psutil
+
+    try:
+        # First check if server is running
+        try:
+            response = requests.get(f"http://localhost:{port}/health", timeout=2)
+            if response.status_code != 200:
+                click.echo(f"❌ No server running on port {port}")
+                return
+        except requests.exceptions.ConnectionError:
+            click.echo(f"❌ No server running on port {port}")
+            return
+
+        # Find and kill the process using the port
+        for proc in psutil.process_iter(["pid", "name", "connections"]):
+            try:
+                connections = proc.info.get("connections")
+                if connections:
+                    for conn in connections:
+                        if hasattr(conn, "laddr") and conn.laddr.port == port:
+                            click.echo(f"🛑 Stopping server (PID: {proc.pid})...")
+                            proc.terminate()
+                            proc.wait(timeout=5)
+                            click.echo("✅ Server stopped successfully")
+                            return
+            except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.TimeoutExpired):
+                continue
+
+        click.echo("⚠️  Could not find server process")
+
+    except Exception as e:
+        click.echo(f"❌ Error stopping server: {e}")
+
+
+@model.command()
+@click.argument("model_name")
+def pull(model_name: str):
+    """Pull (download) a specific lightweight model."""
+    if model_name not in LIGHTWEIGHT_MODELS:
+        click.echo(f"❌ Model '{model_name}' not found.")
+        click.echo("Available models:")
+        for key in LIGHTWEIGHT_MODELS.keys():
+            click.echo(f"  • {key}")
+        sys.exit(1)
+
+    server = LightweightModelServer()
+
+    click.echo(f"Pulling model: {model_name}")
+    success = server.download_and_load_model(model_name)
+
+    if success:
+        click.echo(f"✅ Successfully pulled {model_name}")
+    else:
+        click.echo(f"❌ Failed to pull {model_name}")
+        sys.exit(1)
+
+
+@model.command()
+@click.argument("model_name")
+@click.option("--force", "-f", is_flag=True, help="Force deletion without confirmation")
+def delete(model_name: str, force: bool):
+    """Delete a downloaded lightweight model."""
+    server = LightweightModelServer()
+    downloaded_models = server.downloader.get_downloaded_models()
+
+    if model_name not in downloaded_models:
+        click.echo(f"❌ Model '{model_name}' not found.")
+        click.echo("Downloaded models:")
+        if downloaded_models:
+            for model in downloaded_models:
+                click.echo(f"  • {model}")
+        else:
+            click.echo("  (none)")
+        sys.exit(1)
+
+    # Confirm deletion unless --force is used
+    if not force:
+        model_info = LIGHTWEIGHT_MODELS.get(model_name, {})
+        name = model_info.get("name", model_name)
+        size = model_info.get("size_mb", "unknown")
+        click.echo(f"⚠️  About to delete:")
+        click.echo(f"   Model: {name}")
+        click.echo(f"   Size: {size} MB")
+        if not click.confirm("Are you sure you want to delete this model?"):
+            click.echo("❌ Deletion cancelled")
+            return
+
+    success = server.delete_model(model_name)
+
+    if success:
+        click.echo(f"✅ Successfully deleted {model_name}")
+    else:
+        click.echo(f"❌ Failed to delete {model_name}")
+        sys.exit(1)
+
+
 if __name__ == "__main__":
     model()

{mcli_framework-7.0.1 → mcli_framework-7.0.5}/src/mcli/self/self_cmd.py

@@ -774,18 +774,15 @@ def logs(type: str, lines: int, follow: bool, date: str, grep: str, level: str):
     from datetime import datetime
     from pathlib import Path
 
-    # Find the logs directory
-    current_file = Path(__file__)
-    # Go up 5 levels: file -> self -> mcli -> src -> repo_root
-    project_root = current_file.parents[4]
-    logs_dir = project_root / "logs"
+    # Import get_logs_dir to get the correct logs directory
+    from mcli.lib.paths import get_logs_dir
 
-    # Alternative: try current working directory first
-    if not logs_dir.exists():
-        logs_dir = Path.cwd() / "logs"
+    # Get the logs directory (creates it if it doesn't exist)
+    logs_dir = get_logs_dir()
 
     if not logs_dir.exists():
         click.echo("❌ Logs directory not found", err=True)
+        click.echo(f"Expected location: {logs_dir}", err=True)
         return
 
     # Determine which log files to read
@@ -1129,11 +1126,53 @@ def dashboard(refresh: float, once: bool):
         console.print(f"[red]Error launching dashboard: {e}[/red]")
 
 
+def check_ci_status(version: str) -> tuple[bool, Optional[str]]:
+    """
+    Check GitHub Actions CI status for the main branch.
+    Returns (passing, url) tuple.
+    """
+    try:
+        import requests
+
+        response = requests.get(
+            "https://api.github.com/repos/gwicho38/mcli/actions/runs",
+            params={"per_page": 5},
+            headers={
+                "Accept": "application/vnd.github.v3+json",
+                "User-Agent": "mcli-cli"
+            },
+            timeout=10
+        )
+
+        if response.status_code == 200:
+            data = response.json()
+            runs = data.get("workflow_runs", [])
+
+            # Find the most recent completed run for main branch
+            main_runs = [
+                run for run in runs
+                if run.get("head_branch") == "main" and run.get("status") == "completed"
+            ]
+
+            if main_runs:
+                latest_run = main_runs[0]
+                passing = latest_run.get("conclusion") == "success"
+                url = latest_run.get("html_url")
+                return (passing, url)
+
+        # If we can't check CI, don't block the update
+        return (True, None)
+    except Exception:
+        # On error, don't block the update
+        return (True, None)
+
+
 @self_app.command()
 @click.option("--check", is_flag=True, help="Only check for updates, don't install")
 @click.option("--pre", is_flag=True, help="Include pre-release versions")
 @click.option("--yes", "-y", is_flag=True, help="Skip confirmation prompt")
-def update(check: bool, pre: bool, yes: bool):
+@click.option("--skip-ci-check", is_flag=True, help="Skip CI status check and install anyway")
+def update(check: bool, pre: bool, yes: bool, skip_ci_check: bool):
     """🔄 Check for and install mcli updates from PyPI"""
     import subprocess
     import sys
@@ -1215,6 +1254,21 @@ def update(check: bool, pre: bool, yes: bool):
                 console.print("[yellow]Update cancelled[/yellow]")
                 return
 
+        # Check CI status before installing (unless skipped)
+        if not skip_ci_check:
+            console.print("[cyan]🔍 Checking CI status...[/cyan]")
+            ci_passing, ci_url = check_ci_status(latest_version)
+
+            if not ci_passing:
+                console.print("[red]✗ CI build is failing for the latest version[/red]")
+                if ci_url:
+                    console.print(f"[yellow]  View CI status: {ci_url}[/yellow]")
+                console.print("[yellow]⚠️  Update blocked to prevent installing a broken version[/yellow]")
+                console.print("[dim]  Use --skip-ci-check to install anyway (not recommended)[/dim]")
+                return
+            else:
+                console.print("[green]✓ CI build is passing[/green]")
+
         # Install update
         console.print(f"[cyan]📦 Installing mcli {latest_version}...[/cyan]")
 

{mcli_framework-7.0.1 → mcli_framework-7.0.5}/src/mcli/workflow/model_service/lightweight_model_server.py

@@ -566,6 +566,43 @@ class LightweightModelServer:
         else:
             return "distilbert-base-uncased"  # Standard small model
 
+    def stop_server(self) -> bool:
+        """Stop the lightweight server"""
+        if not self.running:
+            print("⚠️  Server is not running")
+            return False
+
+        try:
+            self.running = False
+            print("🛑 Server stopped")
+            return True
+        except Exception as e:
+            print(f"❌ Error stopping server: {e}")
+            return False
+
+    def delete_model(self, model_key: str) -> bool:
+        """Delete a downloaded model"""
+        try:
+            model_dir = self.models_dir / model_key
+
+            if not model_dir.exists():
+                print(f"⚠️  Model '{model_key}' not found")
+                return False
+
+            # Remove from loaded models if present
+            if model_key in self.loaded_models:
+                del self.loaded_models[model_key]
+                print(f"✅ Unloaded model: {model_key}")
+
+            # Delete the model directory
+            shutil.rmtree(model_dir)
+            print(f"✅ Deleted model: {model_key}")
+            return True
+
+        except Exception as e:
+            print(f"❌ Error deleting model {model_key}: {e}")
+            return False
+
 
 def create_simple_client():
     """Create a simple client script for testing"""

{mcli_framework-7.0.1 → mcli_framework-7.0.5}/src/mcli_framework.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcli-framework
-Version: 7.0.1
+Version: 7.0.5
 Summary: 🚀 High-performance CLI framework with Rust extensions, AI chat, and stunning visuals
 Author-email: Luis Fernandez de la Vara <luis@lefv.io>
 Maintainer-email: Luis Fernandez de la Vara <luis@lefv.io>

{mcli_framework-7.0.1 → mcli_framework-7.0.5}/src/mcli_framework.egg-info/SOURCES.txt

@@ -243,6 +243,7 @@ tests/test_main_app_functions.py
 tests/test_ml_auth.py
 tests/test_ml_models.py
 tests/test_ml_pipeline.py
+tests/test_model_cmd.py
 tests/test_oi.py
 tests/test_optional_dependencies.py
 tests/test_politician_trading_integration.py

mcli_framework-7.0.5/tests/test_model_cmd.py

@@ -0,0 +1,362 @@
+"""
+Unit tests for mcli.app.model_cmd module
+"""
+
+import pytest
+from unittest.mock import Mock, patch, MagicMock
+from click.testing import CliRunner
+
+from mcli.app.model_cmd import model, list, download, start, stop, pull, delete, recommend, status
+
+
+class TestModelCommands:
+    """Test suite for model command functionality"""
+
+    def setup_method(self):
+        """Setup test environment"""
+        self.runner = CliRunner()
+
+    def test_model_group_exists(self):
+        """Test that model command group is properly defined"""
+        assert model is not None
+        assert hasattr(model, 'commands')
+        assert model.name == 'model'
+
+    def test_list_command_exists(self):
+        """Test that list command is properly defined"""
+        assert list is not None
+        assert list.name == 'list'
+
+    @patch('mcli.app.model_cmd.LightweightModelServer')
+    def test_list_command_basic(self, mock_server_class):
+        """Test list command basic functionality"""
+        mock_server = Mock()
+        mock_server_class.return_value = mock_server
+        mock_server.downloader.get_downloaded_models.return_value = []
+        mock_server.get_system_info.return_value = {
+            'cpu_count': 4,
+            'memory_gb': 8.0,
+            'disk_free_gb': 100.0
+        }
+        mock_server.recommend_model.return_value = "distilbert-base-uncased"
+
+        result = self.runner.invoke(model, ['list'])
+
+        assert result.exit_code == 0
+        assert 'Available Lightweight Models' in result.output
+
+    @patch('mcli.app.model_cmd.LightweightModelServer')
+    def test_download_command_success(self, mock_server_class):
+        """Test download command with successful download"""
+        mock_server = Mock()
+        mock_server_class.return_value = mock_server
+        mock_server.download_and_load_model.return_value = True
+
+        result = self.runner.invoke(model, ['download', 'distilbert-base-uncased'])
+
+        assert result.exit_code == 0
+        assert 'Successfully downloaded' in result.output
+        mock_server.download_and_load_model.assert_called_once_with('distilbert-base-uncased')
+
+    @patch('mcli.app.model_cmd.LightweightModelServer')
+    def test_download_command_failure(self, mock_server_class):
+        """Test download command with failed download"""
+        mock_server = Mock()
+        mock_server_class.return_value = mock_server
+        mock_server.download_and_load_model.return_value = False
+
+        result = self.runner.invoke(model, ['download', 'distilbert-base-uncased'])
+
+        assert result.exit_code == 1
+        assert 'Failed to download' in result.output
+
+    def test_download_command_invalid_model(self):
+        """Test download command with invalid model name"""
+        result = self.runner.invoke(model, ['download', 'invalid-model-name'])
+
+        assert result.exit_code == 1
+        assert 'not found' in result.output
+
+    @patch('mcli.app.model_cmd.LightweightModelServer')
+    def test_pull_command_success(self, mock_server_class):
+        """Test pull command with successful pull"""
+        mock_server = Mock()
+        mock_server_class.return_value = mock_server
+        mock_server.download_and_load_model.return_value = True
+
+        result = self.runner.invoke(model, ['pull', 'distilbert-base-uncased'])
+
+        assert result.exit_code == 0
+        assert 'Successfully pulled' in result.output
+        mock_server.download_and_load_model.assert_called_once_with('distilbert-base-uncased')
+
+    @patch('mcli.app.model_cmd.LightweightModelServer')
+    def test_pull_command_failure(self, mock_server_class):
+        """Test pull command with failed pull"""
+        mock_server = Mock()
+        mock_server_class.return_value = mock_server
+        mock_server.download_and_load_model.return_value = False
+
+        result = self.runner.invoke(model, ['pull', 'distilbert-base-uncased'])
+
+        assert result.exit_code == 1
+        assert 'Failed to pull' in result.output
+
+    def test_pull_command_invalid_model(self):
+        """Test pull command with invalid model name"""
+        result = self.runner.invoke(model, ['pull', 'invalid-model-name'])
+
+        assert result.exit_code == 1
+        assert 'not found' in result.output
+
+    @patch('mcli.app.model_cmd.LightweightModelServer')
+    def test_delete_command_success_with_force(self, mock_server_class):
+        """Test delete command with successful deletion using force flag"""
+        mock_server = Mock()
+        mock_server_class.return_value = mock_server
+        mock_server.downloader.get_downloaded_models.return_value = ['distilbert-base-uncased']
+        mock_server.delete_model.return_value = True
+
+        result = self.runner.invoke(model, ['delete', 'distilbert-base-uncased', '--force'])
+
+        assert result.exit_code == 0
+        assert 'Successfully deleted' in result.output
+        mock_server.delete_model.assert_called_once_with('distilbert-base-uncased')
+
+    @patch('mcli.app.model_cmd.LightweightModelServer')
+    def test_delete_command_failure(self, mock_server_class):
+        """Test delete command with failed deletion"""
+        mock_server = Mock()
+        mock_server_class.return_value = mock_server
+        mock_server.downloader.get_downloaded_models.return_value = ['distilbert-base-uncased']
+        mock_server.delete_model.return_value = False
+
+        result = self.runner.invoke(model, ['delete', 'distilbert-base-uncased', '--force'])
+
+        assert result.exit_code == 1
+        assert 'Failed to delete' in result.output
+
+    @patch('mcli.app.model_cmd.LightweightModelServer')
+    def test_delete_command_model_not_found(self, mock_server_class):
+        """Test delete command with model not found"""
+        mock_server = Mock()
+        mock_server_class.return_value = mock_server
+        mock_server.downloader.get_downloaded_models.return_value = []
+
+        result = self.runner.invoke(model, ['delete', 'distilbert-base-uncased', '--force'])
+
+        assert result.exit_code == 1
+        assert 'not found' in result.output
+
+    @patch('mcli.app.model_cmd.LightweightModelServer')
+    def test_delete_command_with_confirmation(self, mock_server_class):
+        """Test delete command with user confirmation"""
+        mock_server = Mock()
+        mock_server_class.return_value = mock_server
+        mock_server.downloader.get_downloaded_models.return_value = ['distilbert-base-uncased']
+        mock_server.delete_model.return_value = True
+
+        # Simulate user confirming deletion
+        result = self.runner.invoke(model, ['delete', 'distilbert-base-uncased'], input='y\n')
+
+        assert result.exit_code == 0
+        assert 'Successfully deleted' in result.output
+
+    @patch('mcli.app.model_cmd.LightweightModelServer')
+    def test_delete_command_cancelled(self, mock_server_class):
+        """Test delete command when user cancels"""
+        mock_server = Mock()
+        mock_server_class.return_value = mock_server
+        mock_server.downloader.get_downloaded_models.return_value = ['distilbert-base-uncased']
+
+        # Simulate user cancelling deletion
+        result = self.runner.invoke(model, ['delete', 'distilbert-base-uncased'], input='n\n')
+
+        assert result.exit_code == 0
+        assert 'cancelled' in result.output
+        mock_server.delete_model.assert_not_called()
+
+    def test_stop_command_success(self):
+        """Test stop command with successful stop"""
+        with patch('requests.get') as mock_get, \
+             patch('psutil.process_iter') as mock_proc_iter:
+
+            mock_response = Mock()
+            mock_response.status_code = 200
+            mock_get.return_value = mock_response
+
+            mock_proc = Mock()
+            mock_proc.pid = 1234
+            mock_proc.info = {'connections': [Mock(laddr=Mock(port=8080))]}
+            mock_proc_iter.return_value = [mock_proc]
+
+            result = self.runner.invoke(model, ['stop'])
+
+            assert result.exit_code == 0
+            assert 'Server stopped successfully' in result.output or 'Stopping server' in result.output
+
+    def test_stop_command_no_server(self):
+        """Test stop command when no server is running"""
+        import requests
+        with patch('requests.get') as mock_get:
+            mock_get.side_effect = requests.exceptions.ConnectionError()
+
+            result = self.runner.invoke(model, ['stop'])
+
+            assert result.exit_code == 0
+            assert 'No server running' in result.output
+
+    def test_status_command_server_running(self):
+        """Test status command when server is running"""
+        with patch('requests.get') as mock_get:
+            mock_health_response = Mock()
+            mock_health_response.status_code = 200
+
+            mock_models_response = Mock()
+            mock_models_response.status_code = 200
+            mock_models_response.json.return_value = {
+                'models': [
+                    {'name': 'distilbert-base-uncased', 'parameters': '66M'}
+                ]
+            }
+
+            mock_get.side_effect = [mock_health_response, mock_models_response]
+
+            result = self.runner.invoke(model, ['status'])
+
+            assert result.exit_code == 0
+            assert 'Server is running' in result.output
+
+    def test_status_command_server_not_running(self):
+        """Test status command when server is not running"""
+        import requests
+        with patch('requests.get') as mock_get:
+            mock_get.side_effect = requests.exceptions.ConnectionError()
+
+            result = self.runner.invoke(model, ['status'])
+
+            assert result.exit_code == 0
+            assert 'No server running' in result.output
+
+    @patch('mcli.app.model_cmd.LightweightModelServer')
+    def test_recommend_command(self, mock_server_class):
+        """Test recommend command"""
+        mock_server = Mock()
+        mock_server_class.return_value = mock_server
+        mock_server.recommend_model.return_value = "distilbert-base-uncased"
+        mock_server.get_system_info.return_value = {
+            'cpu_count': 4,
+            'memory_gb': 8.0,
+            'disk_free_gb': 100.0
+        }
+        mock_server.downloader.get_downloaded_models.return_value = []
+
+        result = self.runner.invoke(model, ['recommend'])
+
+        assert result.exit_code == 0
+        assert 'Recommended Model' in result.output
+
+    @patch('mcli.app.model_cmd.LightweightModelServer')
+    def test_start_command_with_auto_download(self, mock_server_class):
+        """Test start command with auto-download"""
+        mock_server = Mock()
+        mock_server_class.return_value = mock_server
+        mock_server.recommend_model.return_value = "distilbert-base-uncased"
+        mock_server.downloader.get_downloaded_models.return_value = []
+        mock_server.download_and_load_model.return_value = True
+
+        # Use a timeout to avoid hanging on the infinite loop
+        import signal
+
+        def timeout_handler(signum, frame):
+            raise KeyboardInterrupt()
+
+        old_handler = signal.signal(signal.SIGALRM, timeout_handler)
+        signal.alarm(1)
+
+        try:
+            result = self.runner.invoke(model, ['start', '--auto-download'])
+            # Command will be interrupted by KeyboardInterrupt
+        except KeyboardInterrupt:
+            pass
+        finally:
+            signal.alarm(0)
+            signal.signal(signal.SIGALRM, old_handler)
+
+        # Verify the model was downloaded
+        mock_server.download_and_load_model.assert_called()
+
+
+class TestModelCommandHelp:
+    """Test suite for model command help text"""
+
+    def setup_method(self):
+        """Setup test environment"""
+        self.runner = CliRunner()
+
+    def test_model_help(self):
+        """Test model command help text"""
+        result = self.runner.invoke(model, ['--help'])
+
+        assert result.exit_code == 0
+        assert 'Model management commands' in result.output
+
+    def test_list_help(self):
+        """Test list command help text"""
+        result = self.runner.invoke(model, ['list', '--help'])
+
+        assert result.exit_code == 0
+        assert 'List available and downloaded models' in result.output
+
+    def test_download_help(self):
+        """Test download command help text"""
+        result = self.runner.invoke(model, ['download', '--help'])
+
+        assert result.exit_code == 0
+        assert 'Download a specific lightweight model' in result.output
+
+    def test_pull_help(self):
+        """Test pull command help text"""
+        result = self.runner.invoke(model, ['pull', '--help'])
+
+        assert result.exit_code == 0
+        assert 'Pull' in result.output or 'download' in result.output
+
+    def test_delete_help(self):
+        """Test delete command help text"""
+        result = self.runner.invoke(model, ['delete', '--help'])
+
+        assert result.exit_code == 0
+        assert 'Delete a downloaded lightweight model' in result.output
+
+    def test_stop_help(self):
+        """Test stop command help text"""
+        result = self.runner.invoke(model, ['stop', '--help'])
+
+        assert result.exit_code == 0
+        assert 'Stop the lightweight model server' in result.output
+
+    def test_start_help(self):
+        """Test start command help text"""
+        result = self.runner.invoke(model, ['start', '--help'])
+
+        assert result.exit_code == 0
+        assert 'Start the lightweight model server' in result.output
+
+    def test_status_help(self):
+        """Test status command help text"""
+        result = self.runner.invoke(model, ['status', '--help'])
+
+        assert result.exit_code == 0
+        assert 'Check status of the lightweight model server' in result.output
+
+    def test_recommend_help(self):
+        """Test recommend command help text"""
+        result = self.runner.invoke(model, ['recommend', '--help'])
+
+        assert result.exit_code == 0
+        assert 'Get model recommendation' in result.output
+
+
+if __name__ == '__main__':
+    pytest.main([__file__, '-v'])