mcli-framework 7.1.0__py3-none-any.whl → 7.1.2__py3-none-any.whl

mcli/ml/tests/test_training_dashboard.py

@@ -1,14 +1,15 @@
 """Unit tests for training dashboard functionality"""
 
-import pytest
-import pandas as pd
-import numpy as np
 from datetime import datetime, timedelta
-from unittest.mock import Mock, patch, MagicMock
+from unittest.mock import MagicMock, Mock, patch
 
-from mcli.ml.database.models import Model, ModelStatus, Experiment
+import numpy as np
+import pandas as pd
+import pytest
 from sqlalchemy.orm import Session
 
+from mcli.ml.database.models import Experiment, Model, ModelStatus
+
 
 class TestTrainingDashboard:
     """Test suite for training dashboard functions"""
@@ -27,53 +28,53 @@ class TestTrainingDashboard:
         # Bitcoin-style model comparison data
         model_configs = [
             {
-                'name': 'Random Forest',
-                'type': 'random_forest',
-                'test_rmse': 150.5,
-                'test_mae': 120.3,
-                'test_r2': 0.85,
-                'mape': 5.5
+                "name": "Random Forest",
+                "type": "random_forest",
+                "test_rmse": 150.5,
+                "test_mae": 120.3,
+                "test_r2": 0.85,
+                "mape": 5.5,
             },
             {
-                'name': 'Gradient Boosting',
-                'type': 'gradient_boosting',
-                'test_rmse': 155.2,
-                'test_mae': 125.8,
-                'test_r2': 0.83,
-                'mape': 6.2
+                "name": "Gradient Boosting",
+                "type": "gradient_boosting",
+                "test_rmse": 155.2,
+                "test_mae": 125.8,
+                "test_r2": 0.83,
+                "mape": 6.2,
             },
             {
-                'name': 'Linear Regression',
-                'type': 'linear_regression',
-                'test_rmse': 180.0,
-                'test_mae': 145.0,
-                'test_r2': 0.75,
-                'mape': 8.5
+                "name": "Linear Regression",
+                "type": "linear_regression",
+                "test_rmse": 180.0,
+                "test_mae": 145.0,
+                "test_r2": 0.75,
+                "mape": 8.5,
             },
             {
-                'name': 'Ridge Regression',
-                'type': 'ridge',
-                'test_rmse': 175.5,
-                'test_mae': 140.2,
-                'test_r2': 0.78,
-                'mape': 7.8
+                "name": "Ridge Regression",
+                "type": "ridge",
+                "test_rmse": 175.5,
+                "test_mae": 140.2,
+                "test_r2": 0.78,
+                "mape": 7.8,
             },
             {
-                'name': 'Lasso Regression',
-                'type': 'lasso',
-                'test_rmse': 178.0,
-                'test_mae': 142.5,
-                'test_r2': 0.76,
-                'mape': 8.1
-            }
+                "name": "Lasso Regression",
+                "type": "lasso",
+                "test_rmse": 178.0,
+                "test_mae": 142.5,
+                "test_r2": 0.76,
+                "mape": 8.1,
+            },
         ]
 
         for i, config in enumerate(model_configs):
             model = Mock(spec=Model)
-            model.id = f'model-{i}'
-            model.name = config['name']
-            model.version = '1.0.0'
-            model.model_type = config['type']
+            model.id = f"model-{i}"
+            model.name = config["name"]
+            model.version = "1.0.0"
+            model.model_type = config["type"]
             model.status = ModelStatus.DEPLOYED if i < 2 else ModelStatus.TRAINED
 
             model.train_accuracy = 0.90 + np.random.uniform(-0.05, 0.05)
@@ -85,23 +86,29 @@ class TestTrainingDashboard:
             model.test_loss = 0.20 + np.random.uniform(-0.05, 0.05)
 
             # Bitcoin-style metrics
-            model.test_rmse = config['test_rmse']
-            model.test_mae = config['test_mae']
-            model.test_r2 = config['test_r2']
+            model.test_rmse = config["test_rmse"]
+            model.test_mae = config["test_mae"]
+            model.test_r2 = config["test_r2"]
 
             model.metrics = {
-                'rmse': config['test_rmse'],
-                'mae': config['test_mae'],
-                'r2': config['test_r2'],
-                'mape': config['mape']
+                "rmse": config["test_rmse"],
+                "mae": config["test_mae"],
+                "r2": config["test_r2"],
+                "mape": config["mape"],
             }
 
             # Feature names
             model.feature_names = [
-                'lag_1', 'lag_7', 'lag_30',
-                'ma_7', 'ma_14', 'ma_30',
-                'volatility_7', 'volatility_14',
-                'price_change_1', 'price_change_7'
+                "lag_1",
+                "lag_7",
+                "lag_30",
+                "ma_7",
+                "ma_14",
+                "ma_30",
+                "volatility_7",
+                "volatility_14",
+                "price_change_1",
+                "price_change_7",
             ]
 
             model.created_at = datetime.utcnow() - timedelta(days=i)
@@ -118,22 +125,22 @@ class TestTrainingDashboard:
 
         for i in range(10):
             exp = Mock(spec=Experiment)
-            exp.id = f'exp-{i}'
-            exp.name = f'Experiment {i}'
-            exp.status = 'completed' if i < 7 else ('running' if i < 9 else 'failed')
-            exp.started_at = datetime.utcnow() - timedelta(hours=i*2)
-            exp.completed_at = datetime.utcnow() - timedelta(hours=i*2-1) if exp.status == 'completed' else None
-            exp.duration_seconds = 3600 if exp.status == 'completed' else None
-
-            exp.hyperparameters = {
-                'learning_rate': 0.01,
-                'n_estimators': 100,
-                'max_depth': 10
-            }
-
-            exp.train_metrics = {'loss': 0.15, 'accuracy': 0.90}
-            exp.val_metrics = {'loss': 0.18, 'accuracy': 0.88}
-            exp.test_metrics = {'loss': 0.20, 'accuracy': 0.85}
+            exp.id = f"exp-{i}"
+            exp.name = f"Experiment {i}"
+            exp.status = "completed" if i < 7 else ("running" if i < 9 else "failed")
+            exp.started_at = datetime.utcnow() - timedelta(hours=i * 2)
+            exp.completed_at = (
+                datetime.utcnow() - timedelta(hours=i * 2 - 1)
+                if exp.status == "completed"
+                else None
+            )
+            exp.duration_seconds = 3600 if exp.status == "completed" else None
+
+            exp.hyperparameters = {"learning_rate": 0.01, "n_estimators": 100, "max_depth": 10}
+
+            exp.train_metrics = {"loss": 0.15, "accuracy": 0.90}
+            exp.val_metrics = {"loss": 0.18, "accuracy": 0.88}
+            exp.test_metrics = {"loss": 0.20, "accuracy": 0.85}
 
             experiments.append(exp)
 
@@ -142,43 +149,45 @@ class TestTrainingDashboard:
     def test_model_comparison_metrics(self, sample_models):
         """Test model comparison metrics calculation"""
         # Convert to DataFrame as the dashboard would
-        df = pd.DataFrame([
-            {
-                'name': m.name,
-                'test_rmse': m.test_rmse,
-                'test_mae': m.test_mae,
-                'test_r2': m.test_r2,
-                'mape': m.metrics['mape']
-            }
-            for m in sample_models
-        ])
+        df = pd.DataFrame(
+            [
+                {
+                    "name": m.name,
+                    "test_rmse": m.test_rmse,
+                    "test_mae": m.test_mae,
+                    "test_r2": m.test_r2,
+                    "mape": m.metrics["mape"],
+                }
+                for m in sample_models
+            ]
+        )
 
         # Test ranking by RMSE
-        sorted_by_rmse = df.sort_values('test_rmse')
-        assert sorted_by_rmse.iloc[0]['name'] == 'Random Forest'
-        assert sorted_by_rmse.iloc[0]['test_rmse'] < 155
+        sorted_by_rmse = df.sort_values("test_rmse")
+        assert sorted_by_rmse.iloc[0]["name"] == "Random Forest"
+        assert sorted_by_rmse.iloc[0]["test_rmse"] < 155
 
         # Test ranking by R²
-        sorted_by_r2 = df.sort_values('test_r2', ascending=False)
-        assert sorted_by_r2.iloc[0]['test_r2'] > 0.8
+        sorted_by_r2 = df.sort_values("test_r2", ascending=False)
+        assert sorted_by_r2.iloc[0]["test_r2"] > 0.8
 
         # Test ranking by MAE
-        sorted_by_mae = df.sort_values('test_mae')
-        assert sorted_by_mae.iloc[0]['test_mae'] < 125
+        sorted_by_mae = df.sort_values("test_mae")
+        assert sorted_by_mae.iloc[0]["test_mae"] < 125
 
     def test_model_performance_aggregation(self, sample_models):
         """Test aggregation of model performance"""
         metrics = {
-            'total_models': len(sample_models),
-            'deployed_models': sum(1 for m in sample_models if m.status == ModelStatus.DEPLOYED),
-            'avg_rmse': np.mean([m.test_rmse for m in sample_models]),
-            'avg_r2': np.mean([m.test_r2 for m in sample_models]),
+            "total_models": len(sample_models),
+            "deployed_models": sum(1 for m in sample_models if m.status == ModelStatus.DEPLOYED),
+            "avg_rmse": np.mean([m.test_rmse for m in sample_models]),
+            "avg_r2": np.mean([m.test_r2 for m in sample_models]),
         }
 
-        assert metrics['total_models'] == 5
-        assert metrics['deployed_models'] == 2
-        assert 150 < metrics['avg_rmse'] < 180
-        assert 0.75 < metrics['avg_r2'] < 0.85
+        assert metrics["total_models"] == 5
+        assert metrics["deployed_models"] == 2
+        assert 150 < metrics["avg_rmse"] < 180
+        assert 0.75 < metrics["avg_r2"] < 0.85
 
     def test_feature_importance_calculation(self, sample_models):
         """Test feature importance extraction and ranking"""
@@ -186,18 +195,17 @@ class TestTrainingDashboard:
 
         # Simulate feature importance
         importance = np.random.dirichlet(np.ones(len(model.feature_names)))
-        feature_df = pd.DataFrame({
-            'feature': model.feature_names,
-            'importance': importance
-        }).sort_values('importance', ascending=False)
+        feature_df = pd.DataFrame(
+            {"feature": model.feature_names, "importance": importance}
+        ).sort_values("importance", ascending=False)
 
         # Test that importances sum to 1
-        assert np.isclose(feature_df['importance'].sum(), 1.0)
+        assert np.isclose(feature_df["importance"].sum(), 1.0)
 
         # Test top features
         top_5 = feature_df.head(5)
         assert len(top_5) == 5
-        assert all(top_5['importance'] > 0)
+        assert all(top_5["importance"] > 0)
 
     def test_residuals_analysis(self):
         """Test residual analysis calculations"""
@@ -220,6 +228,7 @@ class TestTrainingDashboard:
 
         # Test normality (using simple statistics)
         from scipy import stats
+
         _, p_value = stats.normaltest(residuals)
         # With random data, should generally pass normality test
         assert 0 <= p_value <= 1
@@ -240,7 +249,7 @@ class TestTrainingDashboard:
 
     def test_training_duration_analysis(self, sample_experiments):
         """Test training duration analysis"""
-        completed = [exp for exp in sample_experiments if exp.status == 'completed']
+        completed = [exp for exp in sample_experiments if exp.status == "completed"]
 
         durations = [exp.duration_seconds for exp in completed]
         avg_duration = np.mean(durations)
@@ -252,54 +261,72 @@ class TestTrainingDashboard:
 
     def test_model_comparison_ranking(self, sample_models):
         """Test ranking models by multiple metrics"""
-        df = pd.DataFrame([
-            {
-                'name': m.name,
-                'test_rmse': m.test_rmse,
-                'test_mae': m.test_mae,
-                'test_r2': m.test_r2,
-            }
-            for m in sample_models
-        ])
+        df = pd.DataFrame(
+            [
+                {
+                    "name": m.name,
+                    "test_rmse": m.test_rmse,
+                    "test_mae": m.test_mae,
+                    "test_r2": m.test_r2,
+                }
+                for m in sample_models
+            ]
+        )
 
         # Rank by RMSE (lower is better)
-        df['rank_rmse'] = df['test_rmse'].rank()
+        df["rank_rmse"] = df["test_rmse"].rank()
 
         # Rank by R² (higher is better)
-        df['rank_r2'] = df['test_r2'].rank(ascending=False)
+        df["rank_r2"] = df["test_r2"].rank(ascending=False)
 
         # Composite rank
-        df['composite_rank'] = (df['rank_rmse'] + df['rank_r2']) / 2
+        df["composite_rank"] = (df["rank_rmse"] + df["rank_r2"]) / 2
 
-        best_overall = df.loc[df['composite_rank'].idxmin()]
+        best_overall = df.loc[df["composite_rank"].idxmin()]
 
         # Random Forest should be among the best
-        assert best_overall['test_r2'] > 0.8
-        assert best_overall['test_rmse'] < 160
+        assert best_overall["test_r2"] > 0.8
+        assert best_overall["test_rmse"] < 160
 
     def test_feature_categorization(self):
         """Test feature categorization (lag, MA, volatility, etc.)"""
         features = [
-            'lag_1', 'lag_7', 'lag_30',
-            'ma_7', 'ma_14', 'sma_30', 'ema_20',
-            'volatility_7', 'volatility_14', 'std_30',
-            'price_change_1', 'pct_change_7',
-            'rsi_14', 'macd', 'bollinger_upper'
+            "lag_1",
+            "lag_7",
+            "lag_30",
+            "ma_7",
+            "ma_14",
+            "sma_30",
+            "ema_20",
+            "volatility_7",
+            "volatility_14",
+            "std_30",
+            "price_change_1",
+            "pct_change_7",
+            "rsi_14",
+            "macd",
+            "bollinger_upper",
         ]
 
         categories = {
-            'Lag Features': [f for f in features if 'lag' in f.lower()],
-            'Moving Averages': [f for f in features if any(x in f.lower() for x in ['ma', 'sma', 'ema'])],
-            'Volatility': [f for f in features if any(x in f.lower() for x in ['volatility', 'std'])],
-            'Price Changes': [f for f in features if 'change' in f.lower() or 'pct' in f.lower()],
-            'Technical': [f for f in features if any(x in f.lower() for x in ['rsi', 'macd', 'bollinger'])]
+            "Lag Features": [f for f in features if "lag" in f.lower()],
+            "Moving Averages": [
+                f for f in features if any(x in f.lower() for x in ["ma", "sma", "ema"])
+            ],
+            "Volatility": [
+                f for f in features if any(x in f.lower() for x in ["volatility", "std"])
+            ],
+            "Price Changes": [f for f in features if "change" in f.lower() or "pct" in f.lower()],
+            "Technical": [
+                f for f in features if any(x in f.lower() for x in ["rsi", "macd", "bollinger"])
+            ],
         }
 
-        assert len(categories['Lag Features']) == 3
-        assert len(categories['Moving Averages']) == 4
-        assert len(categories['Volatility']) == 3
-        assert len(categories['Price Changes']) == 2
-        assert len(categories['Technical']) == 3
+        assert len(categories["Lag Features"]) == 3
+        assert len(categories["Moving Averages"]) == 4
+        assert len(categories["Volatility"]) == 3
+        assert len(categories["Price Changes"]) == 2
+        assert len(categories["Technical"]) == 3
 
     def test_mape_calculation(self):
         """Test Mean Absolute Percentage Error calculation"""
@@ -318,7 +345,7 @@ class TestTrainingDashboard:
         errors = np.array([5, 3, 8, 2, 10])
 
         mae = np.mean(np.abs(errors))
-        rmse = np.sqrt(np.mean(errors ** 2))
+        rmse = np.sqrt(np.mean(errors**2))
 
         assert rmse >= mae
 
@@ -347,9 +374,9 @@ class TestTrainingDashboard:
         for exp in sample_experiments:
             status_counts[exp.status] = status_counts.get(exp.status, 0) + 1
 
-        assert status_counts['completed'] == 7
-        assert status_counts['running'] == 2
-        assert status_counts['failed'] == 1
+        assert status_counts["completed"] == 7
+        assert status_counts["running"] == 2
+        assert status_counts["failed"] == 1
         assert sum(status_counts.values()) == 10
 
 
@@ -358,10 +385,10 @@ class TestModelVersioning:
 
     def test_version_comparison(self):
         """Test semantic version comparison"""
-        versions = ['1.0.0', '1.1.0', '1.0.1', '2.0.0', '1.2.0']
+        versions = ["1.0.0", "1.1.0", "1.0.1", "2.0.0", "1.2.0"]
 
         # Parse and sort versions
-        parsed = [tuple(map(int, v.split('.'))) for v in versions]
+        parsed = [tuple(map(int, v.split("."))) for v in versions]
         sorted_versions = sorted(parsed)
 
         assert sorted_versions[0] == (1, 0, 0)
@@ -370,18 +397,18 @@ class TestModelVersioning:
     def test_model_deployment_tracking(self):
         """Test tracking which models are deployed"""
         models = [
-            {'name': 'model-a', 'version': '1.0.0', 'deployed': True},
-            {'name': 'model-a', 'version': '1.1.0', 'deployed': False},
-            {'name': 'model-b', 'version': '1.0.0', 'deployed': True},
+            {"name": "model-a", "version": "1.0.0", "deployed": True},
+            {"name": "model-a", "version": "1.1.0", "deployed": False},
+            {"name": "model-b", "version": "1.0.0", "deployed": True},
         ]
 
-        deployed = [m for m in models if m['deployed']]
+        deployed = [m for m in models if m["deployed"]]
         assert len(deployed) == 2
 
         # Test that only one version of each model is deployed
-        deployed_names = [m['name'] for m in deployed]
+        deployed_names = [m["name"] for m in deployed]
         assert len(deployed_names) == len(set(deployed_names))
 
 
-if __name__ == '__main__':
-    pytest.main([__file__, '-v'])
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])

mcli/mygroup/test_cmd.py

@@ -1 +1,2 @@
-def test(): pass
+def test():
+    pass

mcli/self/self_cmd.py

@@ -1137,11 +1137,8 @@ def check_ci_status(version: str) -> tuple[bool, Optional[str]]:
         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
+            headers={"Accept": "application/vnd.github.v3+json", "User-Agent": "mcli-cli"},
+            timeout=10,
         )
 
         if response.status_code == 200:
@@ -1150,7 +1147,8 @@ def check_ci_status(version: str) -> tuple[bool, Optional[str]]:
 
             # Find the most recent completed run for main branch
             main_runs = [
-                run for run in runs
+                run
+                for run in runs
                 if run.get("head_branch") == "main" and run.get("status") == "completed"
             ]
 
@@ -1209,7 +1207,10 @@ def update(check: bool, pre: bool, yes: bool, skip_ci_check: bool):
         if pre:
             # Include pre-releases
             all_versions = list(pypi_data["releases"].keys())
-            latest_version = max(all_versions, key=lambda v: [int(x) for x in v.split(".")] if v[0].isdigit() else [0])
+            latest_version = max(
+                all_versions,
+                key=lambda v: [int(x) for x in v.split(".")] if v[0].isdigit() else [0],
+            )
         else:
             # Only stable releases
             latest_version = pypi_data["info"]["version"]
@@ -1232,7 +1233,9 @@ def update(check: bool, pre: bool, yes: bool, skip_ci_check: bool):
         latest_parsed = parse_version(latest_version)
 
         if current_parsed >= latest_parsed:
-            console.print(f"[green]✅ Your version ({current_version}) is up to date or newer[/green]")
+            console.print(
+                f"[green]✅ Your version ({current_version}) is up to date or newer[/green]"
+            )
             return
 
         console.print(f"[yellow]⬆️  Update available: {current_version} → {latest_version}[/yellow]")
@@ -1250,6 +1253,7 @@ def update(check: bool, pre: bool, yes: bool, skip_ci_check: bool):
         # Ask for confirmation unless --yes flag is used
         if not yes:
             from rich.prompt import Confirm
+
             if not Confirm.ask(f"[yellow]Install mcli {latest_version}?[/yellow]"):
                 console.print("[yellow]Update cancelled[/yellow]")
                 return
@@ -1263,8 +1267,12 @@ def update(check: bool, pre: bool, yes: bool, skip_ci_check: bool):
                 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]")
+                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]")
@@ -1273,20 +1281,27 @@ def update(check: bool, pre: bool, yes: bool, skip_ci_check: bool):
         console.print(f"[cyan]📦 Installing mcli {latest_version}...[/cyan]")
 
         # Detect if we're running from a uv tool installation
-        # uv tool installations are typically in ~/.local/share/uv/tools/
-        is_uv_tool = ".local/share/uv/tools/" in sys.executable or \
-                     "\\AppData\\Local\\uv\\tools\\" in sys.executable
+        # uv tool installations are typically in ~/.local/share/uv/tools/ or similar
+        executable_path = str(sys.executable).replace("\\", "/")  # Normalize path separators
+
+        is_uv_tool = (
+            "/uv/tools/" in executable_path
+            or "/.local/share/uv/tools/" in executable_path
+            or "\\AppData\\Local\\uv\\tools\\" in str(sys.executable)
+        )
 
         if is_uv_tool:
-            # Use uv tool install for uv tool environments
+            # Use uv tool install for uv tool environments (uv doesn't include pip)
             console.print("[dim]Detected uv tool installation, using 'uv tool install'[/dim]")
             cmd = ["uv", "tool", "install", "--force", "mcli-framework"]
             if pre:
                 # For pre-releases, we'd need to specify the version explicitly
                 # For now, --pre is not supported with uv tool install in this context
-                console.print("[yellow]⚠️  Pre-release flag not supported with uv tool install[/yellow]")
+                console.print(
+                    "[yellow]⚠️  Pre-release flag not supported with uv tool install[/yellow]"
+                )
         else:
-            # Use pip to upgrade for regular installations
+            # Use pip to upgrade for regular installations (requires pip in environment)
             cmd = [sys.executable, "-m", "pip", "install", "--upgrade", "mcli-framework"]
             if pre:
                 cmd.append("--pre")
@@ -1296,9 +1311,13 @@ def update(check: bool, pre: bool, yes: bool, skip_ci_check: bool):
         if result.returncode == 0:
             console.print(f"[green]✅ Successfully updated to mcli {latest_version}![/green]")
             if is_uv_tool:
-                console.print("[yellow]ℹ️  Run 'hash -r' to refresh your shell's command cache[/yellow]")
+                console.print(
+                    "[yellow]ℹ️  Run 'hash -r' to refresh your shell's command cache[/yellow]"
+                )
             else:
-                console.print("[yellow]ℹ️  Restart your terminal or run 'hash -r' to use the new version[/yellow]")
+                console.print(
+                    "[yellow]ℹ️  Restart your terminal or run 'hash -r' to use the new version[/yellow]"
+                )
         else:
             console.print(f"[red]❌ Update failed:[/red]")
             console.print(result.stderr)
@@ -1306,6 +1325,7 @@ def update(check: bool, pre: bool, yes: bool, skip_ci_check: bool):
     except Exception as e:
         console.print(f"[red]❌ Error during update: {e}[/red]")
         import traceback
+
         console.print(f"[dim]{traceback.format_exc()}[/dim]")
 
 

mcli/self/test_cmd.py

@@ -1 +1,2 @@
-def test(): pass
+def test():
+    pass

mcli/workflow/dashboard/dashboard_cmd.py

@@ -36,11 +36,17 @@ def launch(port, host, debug):
 
     # Build streamlit command
     cmd = [
-        sys.executable, "-m", "streamlit", "run",
+        sys.executable,
+        "-m",
+        "streamlit",
+        "run",
         str(dashboard_path),
-        "--server.port", str(port),
-        "--server.address", host,
-        "--browser.gatherUsageStats", "false"
+        "--server.port",
+        str(port),
+        "--server.address",
+        host,
+        "--browser.gatherUsageStats",
+        "false",
     ]
 
     if debug:
@@ -68,8 +74,8 @@ def info():
 
     # Check if dependencies are installed
     try:
-        import streamlit
         import plotly
+        import streamlit
 
         click.echo("✅ Dashboard dependencies installed")
         click.echo(f"   Streamlit version: {streamlit.__version__}")
@@ -81,6 +87,7 @@ def info():
     # Check database connection
     try:
         from mcli.ml.config import settings
+
         click.echo(f"\n📁 Database URL: {settings.database.url}")
         click.echo(f"📍 Redis URL: {settings.redis.url}")
     except Exception as e:
@@ -110,4 +117,4 @@ def service(action):
 
 
 if __name__ == "__main__":
-    dashboard()
+    dashboard()