flowyml 1.2.0__py3-none-any.whl → 1.4.0__py3-none-any.whl

flowyml/ui/backend/routers/experiments.py

@@ -1,25 +1,54 @@
 from fastapi import APIRouter, HTTPException
 from flowyml.storage.metadata import SQLiteMetadataStore
+from flowyml.core.project import ProjectManager
+from flowyml.ui.backend.dependencies import get_store
+from pydantic import BaseModel
 
 router = APIRouter()
 
 
-def get_store():
-    return SQLiteMetadataStore()
+def _iter_metadata_stores():
+    """Yield tuples of (project_name, store) including global and project stores."""
+    stores = [(None, SQLiteMetadataStore())]
+    try:
+        manager = ProjectManager()
+        for project_meta in manager.list_projects():
+            name = project_meta.get("name")
+            if not name:
+                continue
+            project = manager.get_project(name)
+            if project:
+                stores.append((name, project.metadata_store))
+    except Exception:
+        pass
+    return stores
 
 
 @router.get("/")
-async def list_experiments(project: str = None):
+async def list_experiments(project: str | None = None):
     """List all experiments, optionally filtered by project."""
     try:
-        store = get_store()
-        experiments = store.list_experiments()
+        combined_experiments = []
+
+        for project_name, store in _iter_metadata_stores():
+            # Skip other projects if filtering
+            if project and project_name and project != project_name:
+                continue
+
+            store_experiments = store.list_experiments()
 
-        # Filter by project if specified
-        if project:
-            experiments = [e for e in experiments if e.get("project") == project]
+            for exp in store_experiments:
+                # Add project info if not already present
+                if project_name and not exp.get("project"):
+                    exp["project"] = project_name
 
-        return {"experiments": experiments}
+                # Skip if filtering by project and doesn't match
+                if project and exp.get("project") != project:
+                    continue
+
+                combined_experiments.append(exp)
+
+        return {"experiments": combined_experiments}
     except Exception as e:
         return {"experiments": [], "error": str(e)}
 
@@ -27,11 +56,15 @@ async def list_experiments(project: str = None):
 @router.get("/{experiment_id}")
 async def get_experiment(experiment_id: str):
     """Get experiment details."""
-    store = get_store()
-    experiment = store.get_experiment(experiment_id)
-    if not experiment:
-        raise HTTPException(status_code=404, detail="Experiment not found")
-    return experiment
+    # Try to find experiment in any store
+    for project_name, store in _iter_metadata_stores():
+        experiment = store.get_experiment(experiment_id)
+        if experiment:
+            if project_name and not experiment.get("project"):
+                experiment["project"] = project_name
+            return experiment
+
+    raise HTTPException(status_code=404, detail="Experiment not found")
 
 
 @router.put("/{experiment_name}/project")
@@ -47,3 +80,53 @@ async def update_experiment_project(experiment_name: str, project_update: dict):
         return {"message": f"Updated experiment {experiment_name} to project {project_name}"}
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
+
+
+class ExperimentCreate(BaseModel):
+    experiment_id: str
+    name: str
+    description: str = ""
+    tags: dict = {}
+    project: str | None = None
+
+
+@router.post("/")
+async def create_experiment(experiment: ExperimentCreate):
+    """Create or update an experiment."""
+    try:
+        store = get_store()
+        store.save_experiment(
+            experiment_id=experiment.experiment_id,
+            name=experiment.name,
+            description=experiment.description,
+            tags=experiment.tags,
+        )
+
+        if experiment.project:
+            store.update_experiment_project(experiment.name, experiment.project)
+
+        return {"status": "success", "experiment_id": experiment.experiment_id}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+class ExperimentRunLog(BaseModel):
+    run_id: str
+    metrics: dict | None = None
+    parameters: dict | None = None
+
+
+@router.post("/{experiment_id}/runs")
+async def log_experiment_run(experiment_id: str, log: ExperimentRunLog):
+    """Log a run to an experiment."""
+    try:
+        store = get_store()
+        store.log_experiment_run(
+            experiment_id=experiment_id,
+            run_id=log.run_id,
+            metrics=log.metrics,
+            parameters=log.parameters,
+        )
+        return {"status": "success"}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

flowyml/ui/backend/routers/metrics.py

@@ -0,0 +1,168 @@
+"""Model metrics logging API endpoints."""
+
+from fastapi import APIRouter, HTTPException, Depends, Security, Query
+from fastapi.security import HTTPAuthorizationCredentials
+from pydantic import BaseModel, Field
+from typing import Any
+
+from flowyml.ui.backend.auth import verify_api_token, security
+from flowyml.ui.backend.dependencies import get_store
+from flowyml.storage.metadata import SQLiteMetadataStore
+from flowyml.core.project import ProjectManager
+from flowyml.utils.config import get_config
+
+router = APIRouter()
+
+
+def require_permission(permission: str):
+    """Create dependency enforcing a given permission."""
+
+    async def _verify(credentials: HTTPAuthorizationCredentials = Security(security)):
+        return await verify_api_token(credentials, required_permission=permission)
+
+    return _verify
+
+
+def get_project_manager() -> ProjectManager:
+    """Get a project manager rooted at configured projects dir."""
+    config = get_config()
+    return ProjectManager(str(config.projects_dir))
+
+
+def get_global_store() -> SQLiteMetadataStore:
+    """Metadata store for shared metrics."""
+    config = get_config()
+    return SQLiteMetadataStore(str(config.metadata_db))
+
+
+class MetricsLogRequest(BaseModel):
+    """Payload for logging production model metrics."""
+
+    project: str = Field(..., description="Project identifier")
+    model_name: str = Field(..., description="Name of the model emitting metrics")
+    metrics: dict[str, float] = Field(..., description="Dictionary of metric_name -> value")
+    run_id: str | None = Field(None, description="Related run identifier (optional)")
+    environment: str | None = Field(None, description="Environment label (e.g., prod, staging)")
+    tags: dict[str, Any] | None = Field(default_factory=dict, description="Optional metadata tags")
+
+
+class MetricLog(BaseModel):
+    run_id: str
+    name: str
+    value: float
+    step: int = 0
+
+
+@router.post("/")
+async def log_metric(metric: MetricLog):
+    """Log a single metric."""
+    try:
+        store = get_global_store()
+        store.save_metric(metric.run_id, metric.name, metric.value, metric.step)
+        return {"status": "success"}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/log")
+async def log_model_metrics(
+    payload: MetricsLogRequest,
+    token_data: dict = Depends(require_permission("write")),
+):
+    """Log production metrics for a model.
+
+    Requires tokens with the `write` permission. Project-scoped tokens
+    may only submit metrics for their project.
+    """
+    if token_data.get("project") and token_data["project"] != payload.project:
+        raise HTTPException(
+            status_code=403,
+            detail=f"Token is scoped to project '{token_data['project']}'",
+        )
+
+    if not payload.metrics:
+        raise HTTPException(status_code=400, detail="metrics dictionary cannot be empty")
+
+    numeric_metrics = {}
+    for name, value in payload.metrics.items():
+        try:
+            numeric_metrics[name] = float(value)
+        except (TypeError, ValueError):
+            raise HTTPException(
+                status_code=400,
+                detail=f"Metric '{name}' must be numeric.",
+            )
+
+    project_manager = get_project_manager()
+    project = project_manager.get_project(payload.project)
+    if not project:
+        project = project_manager.create_project(payload.project)
+
+    shared_store = get_global_store()
+    shared_store.log_model_metrics(
+        project=payload.project,
+        model_name=payload.model_name,
+        metrics=numeric_metrics,
+        run_id=payload.run_id,
+        environment=payload.environment,
+        tags=payload.tags,
+    )
+
+    project.log_model_metrics(
+        model_name=payload.model_name,
+        metrics=numeric_metrics,
+        run_id=payload.run_id,
+        environment=payload.environment,
+        tags=payload.tags,
+    )
+
+    return {
+        "project": payload.project,
+        "model_name": payload.model_name,
+        "logged_metrics": list(numeric_metrics.keys()),
+        "message": "Metrics logged successfully",
+    }
+
+
+@router.get("")
+async def list_model_metrics(
+    project: str | None = Query(default=None, description="Filter by project"),
+    model_name: str | None = Query(default=None, description="Filter by model"),
+    limit: int = Query(default=100, ge=1, le=500),
+    token_data: dict = Depends(require_permission("read")),
+):
+    """Retrieve the latest logged model metrics."""
+    if token_data.get("project"):
+        if project and token_data["project"] != project:
+            raise HTTPException(
+                status_code=403,
+                detail=f"Token is scoped to project '{token_data['project']}'",
+            )
+        project = token_data["project"]
+
+    store: SQLiteMetadataStore
+    if project:
+        project_manager = get_project_manager()
+        project_obj = project_manager.get_project(project)
+        if not project_obj:
+            raise HTTPException(status_code=404, detail=f"Project '{project}' not found")
+        store = project_obj.metadata_store
+    else:
+        store = get_global_store()
+
+    records = store.list_model_metrics(project=project, model_name=model_name, limit=limit)
+    return {"metrics": records}
+
+
+@router.get("/observability/orchestrator")
+async def get_orchestrator_metrics():
+    """Get orchestrator-level performance metrics."""
+    store = get_store()
+    return store.get_orchestrator_metrics(days=30)
+
+
+@router.get("/observability/cache")
+async def get_cache_metrics():
+    """Get cache performance metrics."""
+    store = get_store()
+    return store.get_cache_metrics(days=30)

flowyml/ui/backend/routers/pipelines.py

@@ -1,25 +1,74 @@
 from fastapi import APIRouter, HTTPException
 from pydantic import BaseModel
-from flowyml.storage.metadata import SQLiteMetadataStore
-from flowyml.utils.config import get_config
+from flowyml.ui.backend.dependencies import get_store
+from flowyml.core.project import ProjectManager
 
 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()
+def _iter_metadata_stores():
+    """Yield tuples of (project_name, store) including global and project stores."""
+    stores = [(None, get_store())]
+    try:
+        manager = ProjectManager()
+        for project_meta in manager.list_projects():
+            name = project_meta.get("name")
+            if not name:
+                continue
+            project = manager.get_project(name)
+            if project:
+                stores.append((name, project.metadata_store))
+    except Exception:
+        pass
+    return stores
 
 
 @router.get("/")
-async def list_pipelines(project: str = None):
-    """List all unique pipelines, optionally filtered by project."""
+async def list_pipelines(project: str | None = None, limit: int = 100):
+    """List all unique pipelines with details, optionally filtered by project."""
     try:
-        store = get_store()
-        pipelines = store.list_pipelines(project=project)
-        return {"pipelines": pipelines}
+        pipeline_map = {}  # pipeline_name -> data
+
+        for project_name, store in _iter_metadata_stores():
+            # Skip other projects if filtering
+            if project and project_name and project != project_name:
+                continue
+
+            # Get pipeline names from this store
+            store_pipeline_names = store.list_pipelines()
+
+            for name in store_pipeline_names:
+                # Get runs for this pipeline
+                filters = {"pipeline_name": name}
+                runs = store.query(**filters)
+
+                if not runs:
+                    continue
+
+                last_run = runs[0]
+                run_project = last_run.get("project") or project_name
+
+                # Skip if filtering by project and doesn't match
+                if project and run_project != project:
+                    continue
+
+                # Use composite key if we already have this pipeline from another project
+                key = f"{name}:{run_project}" if run_project else name
+
+                if key not in pipeline_map:
+                    pipeline_map[key] = {
+                        "name": name,
+                        "created": last_run.get("start_time"),
+                        "version": last_run.get("git_sha", "latest")[:7] if last_run.get("git_sha") else "1.0",
+                        "status": last_run.get("status", "unknown"),
+                        "run_count": len(runs),
+                        "last_run_id": last_run.get("run_id"),
+                        "project": run_project,
+                    }
+
+        # Return list of pipelines
+        enriched_pipelines = list(pipeline_map.values())[:limit]
+        return {"pipelines": enriched_pipelines}
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
 
@@ -108,3 +157,19 @@ async def update_pipeline_project(pipeline_name: str, update: ProjectUpdate):
         return {"status": "success", "project": update.project_name}
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
+
+
+class PipelineDefinitionCreate(BaseModel):
+    pipeline_name: str
+    definition: dict
+
+
+@router.post("/")
+async def save_pipeline_definition(data: PipelineDefinitionCreate):
+    """Save a pipeline definition."""
+    try:
+        store = get_store()
+        store.save_pipeline_definition(data.pipeline_name, data.definition)
+        return {"status": "success", "pipeline_name": data.pipeline_name}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

flowyml/ui/backend/routers/projects.py

@@ -1,17 +1,23 @@
-from fastapi import APIRouter, HTTPException
+from fastapi import APIRouter, HTTPException, Depends
 from flowyml.core.project import ProjectManager
+from flowyml.utils.config import get_config
 from pydantic import BaseModel
 
 router = APIRouter()
-manager = ProjectManager()
+
+
+def get_projects_manager() -> ProjectManager:
+    """Instantiate a ProjectManager bound to the current config."""
+    config = get_config()
+    return ProjectManager(str(config.projects_dir))
 
 
 @router.get("/")
-async def list_projects():
+async def list_projects(manager: ProjectManager = Depends(get_projects_manager)):
     """List all projects."""
     try:
         projects = manager.list_projects()
-        return projects
+        return {"projects": projects}
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
 
@@ -22,7 +28,7 @@ class ProjectCreate(BaseModel):
 
 
 @router.post("/")
-async def create_project(project: ProjectCreate):
+async def create_project(project: ProjectCreate, manager: ProjectManager = Depends(get_projects_manager)):
     """Create a new project."""
     created_project = manager.create_project(project.name, project.description)
     return {
@@ -33,7 +39,7 @@ async def create_project(project: ProjectCreate):
 
 
 @router.get("/{project_name}")
-async def get_project(project_name: str):
+async def get_project(project_name: str, manager: ProjectManager = Depends(get_projects_manager)):
     """Get project details."""
     project = manager.get_project(project_name)
     if not project:
@@ -53,6 +59,7 @@ async def get_project_runs(
     project_name: str,
     pipeline_name: str | None = None,
     limit: int = 100,
+    manager: ProjectManager = Depends(get_projects_manager),
 ):
     """Get runs for a project."""
     project = manager.get_project(project_name)
@@ -68,6 +75,7 @@ async def get_project_artifacts(
     project_name: str,
     artifact_type: str | None = None,
     limit: int = 100,
+    manager: ProjectManager = Depends(get_projects_manager),
 ):
     """Get artifacts for a project."""
     project = manager.get_project(project_name)
@@ -78,8 +86,26 @@ async def get_project_artifacts(
     return artifacts
 
 
+@router.get("/{project_name}/metrics")
+async def get_project_metrics(
+    project_name: str,
+    model_name: str | None = None,
+    limit: int = 100,
+    manager: ProjectManager = Depends(get_projects_manager),
+):
+    """Get logged production metrics for a project."""
+    project = manager.get_project(project_name)
+    if not project:
+        raise HTTPException(status_code=404, detail="Project not found")
+
+    return {
+        "project": project_name,
+        "metrics": project.list_model_metrics(model_name=model_name, limit=limit),
+    }
+
+
 @router.delete("/{project_name}")
-async def delete_project(project_name: str):
+async def delete_project(project_name: str, manager: ProjectManager = Depends(get_projects_manager)):
     """Delete a project."""
     manager.delete_project(project_name, confirm=True)
     return {"deleted": True}