flowyml 1.1.0__py3-none-any.whl

flowyml/ui/backend/routers/leaderboard.py

@@ -0,0 +1,118 @@
+from fastapi import APIRouter, HTTPException
+from flowyml.tracking.leaderboard import ModelLeaderboard, compare_runs
+from flowyml.storage.metadata import SQLiteMetadataStore
+
+router = APIRouter()
+
+
+@router.get("/{metric}")
+async def get_leaderboard(
+    metric: str,
+    higher_is_better: bool = True,
+    n: int = 10,
+):
+    """Get leaderboard for a metric."""
+    try:
+        store = SQLiteMetadataStore()
+        leaderboard = ModelLeaderboard(metric, higher_is_better, store)
+
+        top_models = leaderboard.get_top(n=n)
+
+        return {
+            "metric": metric,
+            "higher_is_better": higher_is_better,
+            "models": [
+                {
+                    "rank": i + 1,
+                    "model_name": model.model_name,
+                    "run_id": model.run_id,
+                    "score": model.metric_value,
+                    "timestamp": model.timestamp,
+                    "metadata": model.metadata,
+                }
+                for i, model in enumerate(top_models)
+            ],
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/compare")
+async def compare_model_runs(run_ids: list, metrics: list | None = None):
+    """Compare multiple runs."""
+    comparison = compare_runs(run_ids, metrics)
+    return comparison
+
+
+@router.post("/generate_sample_data")
+async def generate_sample_data():
+    """Generate sample data for the leaderboard."""
+    import random
+    from datetime import datetime, timedelta
+    from flowyml.storage.metadata import SQLiteMetadataStore
+
+    try:
+        store = SQLiteMetadataStore()
+
+        models = ["ResNet50", "BERT-Base", "YOLOv8", "EfficientNet", "GPT-2"]
+
+        for _i in range(10):
+            run_id = f"run_{random.randint(1000, 9999)}"
+            model_name = random.choice(models)
+
+            # Save run metadata
+            store.save_run(
+                run_id,
+                {
+                    "run_id": run_id,
+                    "pipeline_name": "training_pipeline",
+                    "status": "completed",
+                    "start_time": (datetime.now() - timedelta(days=random.randint(0, 30))).isoformat(),
+                    "end_time": datetime.now().isoformat(),
+                    "duration": random.uniform(10, 100),
+                    "success": True,
+                },
+            )
+
+            # Save metrics
+            store.save_metric(run_id, "accuracy", random.uniform(0.7, 0.99))
+            store.save_metric(run_id, "loss", random.uniform(0.01, 0.5))
+            store.save_metric(run_id, "f1_score", random.uniform(0.6, 0.95))
+            store.save_metric(run_id, "latency", random.uniform(10, 200))
+
+            # Save model artifact with timestamp
+            store.save_artifact(
+                f"{run_id}_model",
+                {
+                    "artifact_id": f"{run_id}_model",
+                    "name": model_name,
+                    "type": "Model",
+                    "run_id": run_id,
+                    "step": "train",
+                    "value": f"Model: {model_name}",
+                    "created_at": datetime.now().isoformat(),
+                },
+            )
+
+            # Save leaderboard entry for this model
+            store.save_artifact(
+                f"{run_id}_leaderboard",
+                {
+                    "artifact_id": f"{run_id}_leaderboard",
+                    "name": model_name,
+                    "type": "leaderboard_entry",
+                    "run_id": run_id,
+                    "value": str(
+                        store.get_metrics(run_id, "accuracy")[0]["value"]
+                        if store.get_metrics(run_id, "accuracy")
+                        else 0,
+                    ),
+                    "metric": "accuracy",
+                    "created_at": datetime.now().isoformat(),
+                    "metadata": {"model_type": model_name},
+                },
+            )
+
+        return {"success": True, "message": "Sample data generated"}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

flowyml/ui/backend/routers/notifications.py

@@ -0,0 +1,72 @@
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+from typing import Any
+from flowyml.monitoring.notifications import (
+    get_notifier,
+    configure_notifications,
+    ConsoleNotifier,
+    SlackNotifier,
+    EmailNotifier,
+)
+
+router = APIRouter()
+
+
+class NotificationConfig(BaseModel):
+    console: bool = True
+    slack_webhook: str | None = None
+    email_config: dict[str, Any] | None = None
+
+
+@router.get("/")
+async def get_notification_config():
+    """Get current notification configuration."""
+    notifier = get_notifier()
+    config = {
+        "console": False,
+        "slack": False,
+        "email": False,
+        "channels": [],
+    }
+
+    for channel in notifier.channels:
+        if isinstance(channel, ConsoleNotifier):
+            config["console"] = True
+            config["channels"].append("console")
+        elif isinstance(channel, SlackNotifier):
+            config["slack"] = True
+            config["channels"].append("slack")
+        elif isinstance(channel, EmailNotifier):
+            config["email"] = True
+            config["channels"].append("email")
+
+    return config
+
+
+@router.post("/")
+async def update_notification_config(config: NotificationConfig):
+    """Update notification configuration."""
+    try:
+        configure_notifications(
+            console=config.console,
+            slack_webhook=config.slack_webhook,
+            email_config=config.email_config,
+        )
+        return {"status": "success", "message": "Notification configuration updated"}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/test")
+async def test_notification(channel: str = "console"):
+    """Send a test notification."""
+    notifier = get_notifier()
+    try:
+        notifier.notify(
+            title="Test Notification",
+            message=f"This is a test notification sent to {channel}",
+            level="info",
+        )
+        return {"status": "success"}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

flowyml/ui/backend/routers/pipelines.py

@@ -0,0 +1,110 @@
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+from flowyml.storage.metadata import SQLiteMetadataStore
+from flowyml.utils.config import get_config
+
+router = APIRouter()
+
+
+def get_store():
+    get_config()
+    # Assuming default path or from config
+    # The SQLiteMetadataStore defaults to .flowyml/metadata.db which is what we want for now
+    return SQLiteMetadataStore()
+
+
+@router.get("/")
+async def list_pipelines(project: str = None):
+    """List all unique pipelines, optionally filtered by project."""
+    try:
+        store = get_store()
+        pipelines = store.list_pipelines(project=project)
+        return {"pipelines": pipelines}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/{pipeline_name}/runs")
+async def list_pipeline_runs(pipeline_name: str, limit: int = 10):
+    """List runs for a specific pipeline."""
+    store = get_store()
+    runs = store.query(pipeline_name=pipeline_name)
+    return {"runs": runs[:limit]}
+
+
+@router.get("/stats")
+async def get_all_pipelines_stats():
+    """Get statistics for all pipelines."""
+    try:
+        store = get_store()
+        pipelines = store.list_pipelines()
+
+        if not pipelines:
+            return {"total_pipelines": 0, "total_runs": 0, "pipelines": []}
+
+        stats = []
+        for pipeline_name in pipelines:
+            runs = store.query(pipeline_name=pipeline_name)
+            total = len(runs)
+            successful = len([r for r in runs if r.get("status") == "completed"])
+            stats.append(
+                {
+                    "name": pipeline_name,
+                    "total_runs": total,
+                    "success_rate": successful / total if total > 0 else 0,
+                },
+            )
+
+        return {
+            "total_pipelines": len(pipelines),
+            "total_runs": sum(s["total_runs"] for s in stats),
+            "pipelines": stats,
+        }
+    except Exception as e:
+        # Database might not exist yet
+        return {"total_pipelines": 0, "total_runs": 0, "pipelines": [], "error": str(e)}
+
+
+@router.get("/{pipeline_name}/stats")
+async def get_pipeline_stats(pipeline_name: str):
+    """Get statistics for a specific pipeline."""
+    try:
+        store = get_store()
+        runs = store.query(pipeline_name=pipeline_name)
+
+        total_runs = len(runs)
+        if total_runs == 0:
+            return {"total_runs": 0, "success_rate": 0, "avg_duration": 0}
+
+        successful_runs = [r for r in runs if r.get("status") == "completed"]
+        success_rate = len(successful_runs) / total_runs if total_runs > 0 else 0
+
+        durations = [r.get("duration", 0) for r in runs if r.get("duration") is not None]
+        avg_duration = sum(durations) / len(durations) if durations else 0
+
+        return {
+            "total_runs": total_runs,
+            "success_rate": success_rate,
+            "avg_duration": avg_duration,
+            "last_run": runs[0] if runs else None,
+        }
+    except Exception as e:
+        return {"total_runs": 0, "success_rate": 0, "avg_duration": 0, "error": str(e)}
+
+
+class ProjectUpdate(BaseModel):
+    project_name: str
+
+
+@router.put("/{pipeline_name}/project")
+async def update_pipeline_project(pipeline_name: str, update: ProjectUpdate):
+    """Update the project for a pipeline."""
+    try:
+        store = get_store()
+        # This updates all runs for this pipeline to the new project
+        # In a real system, we might want to just tag the pipeline definition
+        # But since our "pipeline" concept is derived from runs, we update runs
+        store.update_pipeline_project(pipeline_name, update.project_name)
+        return {"status": "success", "project": update.project_name}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

flowyml/ui/backend/routers/plugins.py

@@ -0,0 +1,192 @@
+"""API router for plugin management."""
+
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+from typing import Any
+import sys
+import subprocess
+
+from flowyml.stacks.plugins import get_component_registry
+from flowyml.stacks.migration import StackMigrator
+
+router = APIRouter(prefix="/plugins", tags=["plugins"])
+
+
+class PluginInfo(BaseModel):
+    plugin_id: str
+    name: str
+    version: str
+    author: str
+    description: str
+    downloads: str
+    stars: str
+    tags: list[str]
+    installed: bool
+
+
+class InstallRequest(BaseModel):
+    plugin_id: str
+
+
+class ImportStackRequest(BaseModel):
+    stack_name: str
+
+
+@router.get("/available", response_model=list[PluginInfo])
+async def get_available_plugins():
+    """Get list of available plugins."""
+    import importlib.metadata
+
+    # Helper to check if package is installed
+    def is_installed(package_name: str) -> bool:
+        try:
+            importlib.metadata.distribution(package_name)
+            return True
+        except importlib.metadata.PackageNotFoundError:
+            return False
+
+    # Mock data for now - in production this would query a plugin registry
+    plugins = [
+        PluginInfo(
+            plugin_id="zenml-kubernetes",
+            name="zenml-kubernetes",
+            version="0.45.0",
+            author="ZenML",
+            description="Kubernetes orchestrator integration from ZenML ecosystem.",
+            downloads="12k",
+            stars="450",
+            tags=["orchestrator", "kubernetes", "zenml"],
+            installed=is_installed("zenml-kubernetes"),
+        ),
+        PluginInfo(
+            plugin_id="zenml-mlflow",
+            name="zenml-mlflow",
+            version="0.45.0",
+            author="ZenML",
+            description="MLflow integration for experiment tracking and model deployment.",
+            downloads="8.5k",
+            stars="320",
+            tags=["tracking", "mlflow", "zenml"],
+            installed=is_installed("zenml-mlflow"),
+        ),
+        PluginInfo(
+            plugin_id="airflow-providers-google",
+            name="airflow-providers-google",
+            version="10.1.0",
+            author="Apache Airflow",
+            description="Google Cloud Platform providers for Airflow.",
+            downloads="50k",
+            stars="1.2k",
+            tags=["orchestrator", "gcp", "airflow"],
+            installed=is_installed("airflow-providers-google"),
+        ),
+        PluginInfo(
+            plugin_id="aws-s3",
+            name="aws-s3",
+            version="1.0.0",
+            author="AWS",
+            description="S3 artifact store integration.",
+            downloads="15k",
+            stars="200",
+            tags=["artifact-store", "aws"],
+            installed=is_installed("aws-s3"),
+        ),
+    ]
+
+    return plugins
+
+
+@router.get("/installed", response_model=list[dict[str, Any]])
+async def get_installed_plugins():
+    """Get list of installed plugins."""
+    import importlib.metadata
+
+    # Get all installed packages that could be plugins
+    installed = []
+
+    # List of known plugin packages (you can expand this)
+    potential_plugins = [
+        "zenml",
+        "zenml-kubernetes",
+        "zenml-mlflow",
+        "zenml-s3",
+        "airflow",
+        "airflow-providers-google",
+        "airflow-providers-aws",
+        "aws-s3",
+        "boto3",
+        "kubernetes",
+    ]
+
+    for package_name in potential_plugins:
+        try:
+            dist = importlib.metadata.distribution(package_name)
+            installed.append(
+                {
+                    "id": package_name,
+                    "name": package_name,
+                    "version": dist.version,
+                    "description": dist.metadata.get("Summary", ""),
+                    "status": "active",
+                },
+            )
+        except importlib.metadata.PackageNotFoundError:
+            pass
+
+    return installed
+
+
+@router.post("/install")
+async def install_plugin(request: InstallRequest):
+    """Install a plugin."""
+    registry = get_component_registry()
+
+    try:
+        success = registry.install_plugin(request.plugin_id)
+        if success:
+            return {"success": True, "message": f"Plugin {request.plugin_id} installed successfully"}
+        else:
+            raise HTTPException(status_code=500, detail="Installation failed")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/uninstall/{plugin_id}")
+async def uninstall_plugin(plugin_id: str):
+    """Uninstall a plugin."""
+    import asyncio
+
+    try:
+        # Run subprocess in executor to avoid blocking
+        loop = asyncio.get_event_loop()
+        await loop.run_in_executor(
+            None,
+            subprocess.check_call,
+            [sys.executable, "-m", "pip", "uninstall", "-y", plugin_id],
+        )
+        return {"success": True, "message": f"Plugin {plugin_id} uninstalled successfully"}
+    except subprocess.CalledProcessError as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/import-stack")
+async def import_zenml_stack(request: ImportStackRequest):
+    """Import a ZenML stack."""
+    migrator = StackMigrator()
+
+    try:
+        migration_data = migrator.migrate_zenml_stack(request.stack_name)
+        return {
+            "success": True,
+            "message": "Stack imported successfully",
+            "components": [
+                {"type": comp_type, "name": comp.name if hasattr(comp, "name") else str(comp)}
+                for comp_type, comp in migration_data["stack"]["components"].items()
+            ],
+        }
+    except ImportError:
+        raise HTTPException(status_code=400, detail="ZenML is not installed")
+    except ValueError as e:
+        raise HTTPException(status_code=404, detail=str(e))
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

flowyml/ui/backend/routers/projects.py

@@ -0,0 +1,85 @@
+from fastapi import APIRouter, HTTPException
+from flowyml.core.project import ProjectManager
+from pydantic import BaseModel
+
+router = APIRouter()
+manager = ProjectManager()
+
+
+@router.get("/")
+async def list_projects():
+    """List all projects."""
+    try:
+        projects = manager.list_projects()
+        return projects
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+class ProjectCreate(BaseModel):
+    name: str
+    description: str = ""
+
+
+@router.post("/")
+async def create_project(project: ProjectCreate):
+    """Create a new project."""
+    created_project = manager.create_project(project.name, project.description)
+    return {
+        "name": created_project.name,
+        "description": created_project.description,
+        "created": True,
+    }
+
+
+@router.get("/{project_name}")
+async def get_project(project_name: str):
+    """Get project details."""
+    project = manager.get_project(project_name)
+    if not project:
+        raise HTTPException(status_code=404, detail="Project not found")
+
+    return {
+        "name": project.name,
+        "description": project.description,
+        "metadata": project.metadata,
+        "stats": project.get_stats(),
+        "pipelines": project.get_pipelines(),
+    }
+
+
+@router.get("/{project_name}/runs")
+async def get_project_runs(
+    project_name: str,
+    pipeline_name: str | None = None,
+    limit: int = 100,
+):
+    """Get runs for a project."""
+    project = manager.get_project(project_name)
+    if not project:
+        raise HTTPException(status_code=404, detail="Project not found")
+
+    runs = project.list_runs(pipeline_name=pipeline_name, limit=limit)
+    return runs
+
+
+@router.get("/{project_name}/artifacts")
+async def get_project_artifacts(
+    project_name: str,
+    artifact_type: str | None = None,
+    limit: int = 100,
+):
+    """Get artifacts for a project."""
+    project = manager.get_project(project_name)
+    if not project:
+        raise HTTPException(status_code=404, detail="Project not found")
+
+    artifacts = project.get_artifacts(artifact_type=artifact_type, limit=limit)
+    return artifacts
+
+
+@router.delete("/{project_name}")
+async def delete_project(project_name: str):
+    """Delete a project."""
+    manager.delete_project(project_name, confirm=True)
+    return {"deleted": True}

flowyml/ui/backend/routers/runs.py

@@ -0,0 +1,66 @@
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+from flowyml.storage.metadata import SQLiteMetadataStore
+
+router = APIRouter()
+
+
+def get_store():
+    return SQLiteMetadataStore()
+
+
+@router.get("/")
+async def list_runs(limit: int = 20, project: str = None):
+    """List all runs, optionally filtered by project."""
+    try:
+        store = get_store()
+        runs = store.list_runs(limit=limit)
+
+        # Filter by project if specified
+        if project:
+            runs = [r for r in runs if r.get("project") == project]
+
+        return {"runs": runs}
+    except Exception as e:
+        return {"runs": [], "error": str(e)}
+
+
+@router.get("/{run_id}")
+async def get_run(run_id: str):
+    """Get details for a specific run."""
+    store = get_store()
+    run = store.load_run(run_id)
+    if not run:
+        raise HTTPException(status_code=404, detail="Run not found")
+    return run
+
+
+@router.get("/{run_id}/metrics")
+async def get_run_metrics(run_id: str):
+    """Get metrics for a specific run."""
+    store = get_store()
+    metrics = store.get_metrics(run_id)
+    return {"metrics": metrics}
+
+
+@router.get("/{run_id}/artifacts")
+async def get_run_artifacts(run_id: str):
+    """Get artifacts for a specific run."""
+    store = get_store()
+    artifacts = store.list_assets(run_id=run_id)
+    return {"artifacts": artifacts}
+
+
+class ProjectUpdate(BaseModel):
+    project_name: str
+
+
+@router.put("/{run_id}/project")
+async def update_run_project(run_id: str, update: ProjectUpdate):
+    """Update the project for a run."""
+    store = get_store()
+    try:
+        store.update_run_project(run_id, update.project_name)
+        return {"status": "success", "project": update.project_name}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))