flowyml 1.7.1__py3-none-any.whl → 1.8.0__py3-none-any.whl

flowyml/ui/frontend/src/router/index.jsx

@@ -18,30 +18,57 @@ import { Settings } from '../app/settings/page';
 import { TokenManagement } from '../app/tokens/page';
 import { RunComparisonPage } from '../app/compare/page';
 import { ExperimentComparisonPage } from '../app/experiments/compare/page';
+import { DeploymentLab } from '../app/deployments/page';
+import { ModelExplorer } from '../app/model-explorer/page';
+import { Login } from '../app/auth/Login';
+import { RequireAuth, AuthProvider } from '../contexts/AuthContext';
+import { Outlet } from 'react-router-dom';
+
+// Layout Wrapper to provide Auth Context
+const AppLayout = () => (
+    <AuthProvider>
+        <Outlet />
+    </AuthProvider>
+);
 
 export const router = createBrowserRouter([
     {
-        path: '/',
-        element: <MainLayout />,
+        element: <AppLayout />, // Wrap everything in AuthProvider
         children: [
-            { index: true, element: <Dashboard /> },
-            { path: 'pipelines', element: <Pipelines /> },
-            { path: 'runs', element: <Runs /> },
-            { path: 'compare', element: <RunComparisonPage /> },
-            { path: 'runs/:runId', element: <RunDetails /> },
-            { path: 'assets', element: <Assets /> },
-            { path: 'experiments', element: <Experiments /> },
-            { path: 'experiments/compare', element: <ExperimentComparisonPage /> },
-            { path: 'experiments/:experimentId', element: <ExperimentDetails /> },
-            { path: 'traces', element: <Traces /> },
-            { path: 'projects', element: <Projects /> },
-            { path: 'projects/:projectId', element: <ProjectDetails /> },
-            { path: 'schedules', element: <Schedules /> },
-            { path: 'observability', element: <Observability /> },
-            { path: 'leaderboard', element: <Leaderboard /> },
-            { path: 'plugins', element: <Plugins /> },
-            { path: 'settings', element: <Settings /> },
-            { path: 'tokens', element: <TokenManagement /> },
+            {
+                path: '/login',
+                element: <Login />,
+            },
+            {
+                path: '/',
+                element: (
+                    <RequireAuth>
+                        <MainLayout />
+                    </RequireAuth>
+                ),
+                children: [
+                    { index: true, element: <Dashboard /> },
+                    { path: 'pipelines', element: <Pipelines /> },
+                    { path: 'runs', element: <Runs /> },
+                    { path: 'compare', element: <RunComparisonPage /> },
+                    { path: 'runs/:runId', element: <RunDetails /> },
+                    { path: 'assets', element: <Assets /> },
+                    { path: 'experiments', element: <Experiments /> },
+                    { path: 'experiments/compare', element: <ExperimentComparisonPage /> },
+                    { path: 'experiments/:experimentId', element: <ExperimentDetails /> },
+                    { path: 'traces', element: <Traces /> },
+                    { path: 'projects', element: <Projects /> },
+                    { path: 'projects/:projectId', element: <ProjectDetails /> },
+                    { path: 'schedules', element: <Schedules /> },
+                    { path: 'observability', element: <Observability /> },
+                    { path: 'leaderboard', element: <Leaderboard /> },
+                    { path: 'plugins', element: <Plugins /> },
+                    { path: 'settings', element: <Settings /> },
+                    { path: 'tokens', element: <TokenManagement /> },
+                    { path: 'deployments', element: <DeploymentLab /> },
+                    { path: 'model-explorer', element: <ModelExplorer /> },
+                ],
+            },
         ],
     },
 ]);

flowyml/ui/frontend/src/services/pluginService.js

@@ -66,8 +66,10 @@ class PluginService {
         }
     }
 
-    async importZenMLStack(stackName) {
+    async importStack(stackName, type = 'zenml') {
         try {
+            // currently backend only supports zenml import at this endpoint
+            // in the future we can add ?type= param or body field
             const response = await fetch(`${API_BASE_URL}/plugins/import-stack`, {
                 method: 'POST',
                 headers: { 'Content-Type': 'application/json' },

flowyml/ui/server_manager.py

@@ -15,8 +15,8 @@ class UIServerManager:
     _lock = threading.Lock()
 
     def __init__(self):
-        self._server_thread: Optional[threading.Thread] = None
-        self._server_process: Optional[subprocess.Popen] = None
+        self._server_thread: threading.Thread | None = None
+        self._server_process: subprocess.Popen | None = None
         # Initialize from config/env vars
         self._host, self._port = get_ui_host_port()
         self._running = False
@@ -148,7 +148,7 @@ class UIServerManager:
         self._running = False
         self._server_thread = None
 
-    def get_url(self) -> Optional[str]:
+    def get_url(self) -> str | None:
         """Get the URL of the running UI server.
 
         Returns:
@@ -160,7 +160,7 @@ class UIServerManager:
         """Check if UI server is running."""
         return is_ui_running(self._host, self._port)
 
-    def get_run_url(self, run_id: str) -> Optional[str]:
+    def get_run_url(self, run_id: str) -> str | None:
         """Get URL to view a specific pipeline run.
 
         Args:
@@ -174,7 +174,7 @@ class UIServerManager:
             return f"{base_url}/runs/{run_id}"
         return None
 
-    def get_pipeline_url(self, pipeline_name: str) -> Optional[str]:
+    def get_pipeline_url(self, pipeline_name: str) -> str | None:
         """Get URL to view a specific pipeline.
 
         Args:

flowyml/ui/utils.py

@@ -1,25 +1,128 @@
 """UI utility functions for checking UI server status and getting URLs."""
 
 import os
+import socket
 import http.client
 
+# Common ports to check for FlowyML unified server (backend serves frontend too)
+# Priority order: 8080 (default), then alternates if port is busy
+DEFAULT_SERVER_PORTS = [8080, 8081, 8082, 3000, 8000]
+
+
+def find_available_port(start_port: int = 8081, max_attempts: int = 10) -> int:
+    """Find an available port starting from the given port.
+
+    Args:
+        start_port: Port to start checking from
+        max_attempts: Maximum number of ports to try
+
+    Returns:
+        First available port found
+    """
+    for offset in range(max_attempts):
+        port = start_port + offset
+        try:
+            with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+                s.bind(("localhost", port))
+                return port
+        except OSError:
+            continue
+    return start_port + max_attempts
+
+
+def _check_port(host: str, port: int, path: str = "/", timeout: float = 1.0) -> bool:
+    """Check if a port is responding to HTTP requests.
+
+    Args:
+        host: Host to check
+        port: Port to check
+        path: Path to request
+        timeout: Connection timeout in seconds
+
+    Returns:
+        True if port is responding, False otherwise
+    """
+    try:
+        conn = http.client.HTTPConnection(host, port, timeout=timeout)
+        conn.request("GET", path)
+        response = conn.getresponse()
+        response.read()  # Must read before closing
+        conn.close()
+        return response.status in (200, 301, 302, 404)  # Accept common status codes
+    except Exception:
+        return False
+
+
+def discover_server(host: str = "localhost") -> tuple[str, int] | None:
+    """Auto-discover the running FlowyML server.
+
+    The FlowyML backend serves both API and frontend on the same port.
+    This function finds where the unified server is running.
+
+    Args:
+        host: Host to check
+
+    Returns:
+        Tuple of (host, port) if found, None otherwise
+    """
+    # First check environment variables
+    env_port = os.getenv("FLOWYML_UI_PORT") or os.getenv("FLOWYML_SERVER_PORT")
+    if env_port:
+        port = int(env_port)
+        if _check_port(host, port, "/api/health"):
+            return (host, port)
+
+    # Check environment URL
+    env_url = os.getenv("FLOWYML_REMOTE_SERVER_URL")
+    if env_url:
+        try:
+            from urllib.parse import urlparse
+
+            parsed = urlparse(env_url)
+            if parsed.port and _check_port(host, parsed.port, "/api/health"):
+                return (host, parsed.port)
+        except Exception:
+            pass
+
+    # Check common server ports
+    for port in DEFAULT_SERVER_PORTS:
+        if _check_port(host, port, "/api/health"):
+            return (host, port)
+
+    return None
+
+
+# Keep these as aliases for backwards compatibility
+def discover_ui_server(host: str = "localhost") -> tuple[str, int] | None:
+    """Alias for discover_server (unified server serves both UI and API)."""
+    return discover_server(host)
+
+
+def discover_api_server(host: str = "localhost") -> tuple[str, int] | None:
+    """Alias for discover_server (unified server serves both UI and API)."""
+    return discover_server(host)
+
 
 def get_ui_server_url() -> str:
-    """Get the UI server URL from configuration or environment variables.
+    """Get the unified server URL, auto-discovering if possible.
+
+    The FlowyML backend serves both API and frontend on the same port.
 
     Priority order:
     1. FLOWYML_SERVER_URL environment variable (explicit override)
     2. FLOWYML_REMOTE_UI_URL from config (for centralized deployments)
-    3. FLOWYML_UI_HOST and FLOWYML_UI_PORT from config/env
-    4. Default: http://localhost:8080
+    3. Auto-discover running server
+    4. FLOWYML_UI_HOST and FLOWYML_UI_PORT from config/env
+    5. Default: http://localhost:8080
 
     Returns:
-        Base URL of the UI server (e.g., "http://localhost:8080" or "https://flowyml.example.com")
+        Base URL of the server
     """
     # Check for explicit server URL override
     server_url = os.getenv("FLOWYML_SERVER_URL")
     if server_url:
-        return server_url.rstrip("/")
+        # Strip /api suffix if present since we want base URL
+        return server_url.rstrip("/").replace("/api", "")
 
     # Check for remote UI URL (centralized deployment)
     try:
@@ -28,29 +131,46 @@ def get_ui_server_url() -> str:
         config = get_config()
         if config.remote_ui_url:
             return config.remote_ui_url.rstrip("/")
+    except Exception:
+        pass
 
-        # Use config values for host/port
-        host = os.getenv("FLOWYML_UI_HOST", config.ui_host)
-        port = int(os.getenv("FLOWYML_UI_PORT", str(config.ui_port)))
+    # Try auto-discovery
+    host = os.getenv("FLOWYML_UI_HOST", "localhost")
+    discovered = discover_server(host)
+    if discovered:
+        h, p = discovered
+        protocol = "https" if p == 443 else "http"
+        return f"{protocol}://{h}:{p}"
 
-        # Determine protocol based on port (443 = https, else http)
-        protocol = "https" if port == 443 else "http"
+    # Fallback to config or defaults
+    try:
+        from flowyml.utils.config import get_config
 
-        return f"{protocol}://{host}:{port}"
+        config = get_config()
+        host = os.getenv("FLOWYML_UI_HOST", config.ui_host)
+        port = int(os.getenv("FLOWYML_UI_PORT", str(config.ui_port)))
     except Exception:
-        # Fallback to defaults
         host = os.getenv("FLOWYML_UI_HOST", "localhost")
         port = int(os.getenv("FLOWYML_UI_PORT", "8080"))
-        protocol = "https" if port == 443 else "http"
-        return f"{protocol}://{host}:{port}"
+
+    protocol = "https" if port == 443 else "http"
+    return f"{protocol}://{host}:{port}"
 
 
 def get_ui_host_port() -> tuple[str, int]:
-    """Get UI host and port from configuration.
+    """Get server host and port, auto-discovering if possible.
 
     Returns:
         Tuple of (host, port)
     """
+    host = os.getenv("FLOWYML_UI_HOST", "localhost")
+
+    # Try auto-discovery first
+    discovered = discover_server(host)
+    if discovered:
+        return discovered
+
+    # Fallback to config or defaults
     try:
         from flowyml.utils.config import get_config
 
@@ -59,61 +179,59 @@ def get_ui_host_port() -> tuple[str, int]:
         port = int(os.getenv("FLOWYML_UI_PORT", str(config.ui_port)))
         return (host, port)
     except Exception:
-        host = os.getenv("FLOWYML_UI_HOST", "localhost")
         port = int(os.getenv("FLOWYML_UI_PORT", "8080"))
         return (host, port)
 
 
-def is_ui_running(host: str = "localhost", port: int = 8080) -> bool:
+def is_ui_running(host: str = "localhost", port: int | None = None) -> bool:
     """Check if the flowyml UI server is running.
 
     Args:
         host: Host to check (default: localhost)
-        port: Port to check (default: 8080)
+        port: Port to check (default: auto-discover)
 
     Returns:
         True if UI server is running and responding, False otherwise
     """
-    try:
-        conn = http.client.HTTPConnection(host, port, timeout=2)
-        conn.request("GET", "/api/health")
-        response = conn.getresponse()
+    if port is None:
+        # Try auto-discovery
+        discovered = discover_ui_server(host)
+        return discovered is not None
 
-        # Check if response is successful and from flowyml
-        # Note: must read data BEFORE closing connection
-        if response.status == 200:
-            data = response.read().decode("utf-8")
-            conn.close()
-            return "flowyml" in data.lower() or "ok" in data.lower()
-        conn.close()
-        return False
-    except Exception:
-        return False
+    return _check_port(host, port)
 
 
-def get_ui_url(host: str = "localhost", port: int = 8080) -> str | None:
+def get_ui_url(host: str = "localhost", port: int | None = None) -> str | None:
     """Get the URL of the running flowyml UI server.
 
     Args:
         host: Host of the UI server (default: localhost)
-        port: Port of the UI server (default: 8080)
+        port: Port of the UI server (default: auto-discover)
 
     Returns:
         URL string if server is running, None otherwise
     """
-    if is_ui_running(host, port):
+    if port is None:
+        discovered = discover_ui_server(host)
+        if discovered:
+            h, p = discovered
+            protocol = "https" if p == 443 else "http"
+            return f"{protocol}://{h}:{p}"
+        return None
+
+    if _check_port(host, port):
         protocol = "https" if port == 443 else "http"
         return f"{protocol}://{host}:{port}"
     return None
 
 
-def get_run_url(run_id: str, host: str = "localhost", port: int = 8080) -> str | None:
+def get_run_url(run_id: str, host: str = "localhost", port: int | None = None) -> str | None:
     """Get the URL to view a specific pipeline run.
 
     Args:
         run_id: ID of the pipeline run
         host: Host of the UI server (default: localhost)
-        port: Port of the UI server (default: 8080)
+        port: Port of the UI server (default: auto-discover)
 
     Returns:
         URL string to the run view if server is running, None otherwise
@@ -124,13 +242,13 @@ def get_run_url(run_id: str, host: str = "localhost", port: int = 8080) -> str |
     return None
 
 
-def get_pipeline_url(pipeline_name: str, host: str = "localhost", port: int = 8080) -> str | None:
+def get_pipeline_url(pipeline_name: str, host: str = "localhost", port: int | None = None) -> str | None:
     """Get the URL to view a specific pipeline.
 
     Args:
         pipeline_name: Name of the pipeline
         host: Host of the UI server (default: localhost)
-        port: Port of the UI server (default: 8080)
+        port: Port of the UI server (default: auto-discover)
 
     Returns:
         URL string to the pipeline view if server is running, None otherwise

flowyml/utils/config.py

@@ -25,6 +25,7 @@ class FlowymlConfig:
     execution_mode: str = "local"  # local or remote
     remote_server_url: str = ""
     remote_ui_url: str = ""
+    api_token: str | None = None
     remote_services: list[dict[str, str]] = field(default_factory=list)
     enable_caching: bool = True
     enable_checkpointing: bool = True  # Enable checkpointing by default
@@ -99,6 +100,7 @@ class FlowymlConfig:
             "execution_mode": self.execution_mode,
             "remote_server_url": self.remote_server_url,
             "remote_ui_url": self.remote_ui_url,
+            "api_token": self.api_token,
             "remote_services": self.remote_services,
             "enable_caching": self.enable_caching,
             "enable_checkpointing": self.enable_checkpointing,
@@ -184,6 +186,15 @@ def get_config() -> FlowymlConfig:
             # Load from default location
             _global_config = FlowymlConfig.load()
 
+        # Apply environment variable overrides
+        env_config = get_env_config()
+        for key, value in env_config.items():
+            if hasattr(_global_config, key):
+                setattr(_global_config, key, value)
+
+        # Re-normalize paths after env var overrides (env vars are strings, not Path objects)
+        _global_config.__post_init__()
+
         # Create necessary directories
         _global_config.create_directories()
 
@@ -202,9 +213,19 @@ def set_config(config: FlowymlConfig) -> None:
 
 
 def reset_config() -> None:
-    """Reset global configuration to defaults."""
+    """Reset global configuration to defaults and apply environment variable overrides."""
     global _global_config
     _global_config = FlowymlConfig()
+
+    # Apply environment variable overrides
+    env_config = get_env_config()
+    for key, value in env_config.items():
+        if hasattr(_global_config, key):
+            setattr(_global_config, key, value)
+
+    # Re-normalize paths after env var overrides (env vars are strings, not Path objects)
+    _global_config.__post_init__()
+
     _global_config.create_directories()
 
 
@@ -272,20 +293,21 @@ def get_env_config() -> dict[str, Any]:
 
     # Map environment variables to config fields
     env_mappings = {
-        "flowyml_HOME": "flowyml_home",
-        "flowyml_ARTIFACTS_DIR": "artifacts_dir",
-        "flowyml_METADATA_DB": "metadata_db",
-        "flowyml_CACHE_DIR": "cache_dir",
-        "flowyml_DEFAULT_STACK": "default_stack",
-        "flowyml_EXECUTION_MODE": "execution_mode",
-        "flowyml_REMOTE_SERVER_URL": "remote_server_url",
-        "flowyml_REMOTE_UI_URL": "remote_ui_url",
-        "flowyml_SERVER_URL": "remote_ui_url",  # Alias for FLOWYML_SERVER_URL -> remote_ui_url
-        "flowyml_ENABLE_CACHING": "enable_caching",
-        "flowyml_LOG_LEVEL": "log_level",
-        "flowyml_UI_HOST": "ui_host",
-        "flowyml_UI_PORT": "ui_port",
-        "flowyml_DEBUG": "debug_mode",
+        "FLOWYML_HOME": "flowyml_home",
+        "FLOWYML_ARTIFACTS_DIR": "artifacts_dir",
+        "FLOWYML_METADATA_DB": "metadata_db",
+        "FLOWYML_CACHE_DIR": "cache_dir",
+        "FLOWYML_DEFAULT_STACK": "default_stack",
+        "FLOWYML_EXECUTION_MODE": "execution_mode",
+        "FLOWYML_REMOTE_SERVER_URL": "remote_server_url",
+        "FLOWYML_REMOTE_UI_URL": "remote_ui_url",
+        "FLOWYML_API_TOKEN": "api_token",
+        "FLOWYML_SERVER_URL": "remote_server_url",  # Alias
+        "FLOWYML_ENABLE_CACHING": "enable_caching",
+        "FLOWYML_LOG_LEVEL": "log_level",
+        "FLOWYML_UI_HOST": "ui_host",
+        "FLOWYML_UI_PORT": "ui_port",
+        "FLOWYML_DEBUG": "debug_mode",
     }
 
     for env_var, config_key in env_mappings.items():

flowyml/utils/model_introspection.py

@@ -0,0 +1,123 @@
+"""Utilities for introspecting machine learning models."""
+
+import contextlib
+from typing import Any
+
+
+def introspect_model(model: Any, framework: str) -> dict[str, Any]:
+    """Introspect a model to extract input/output schema and metadata.
+
+    Args:
+        model: The loaded model object
+        framework: Framework name (keras, tensorflow, sklearn, pytorch)
+
+    Returns:
+        Dictionary containing schema information like:
+        - input_shape: List[int]
+        - output_shape: List[int]
+        - input_names: List[str]
+        - output_names: List[str]
+        - input_features: int
+        - total_params: int
+    """
+    info = {
+        "framework": framework,
+    }
+
+    if framework in ["keras", "tensorflow"]:
+        _introspect_keras(model, info)
+    elif framework == "sklearn":
+        _introspect_sklearn(model, info)
+    elif framework == "pytorch":
+        _introspect_pytorch(model, info)
+
+    return info
+
+
+def _introspect_keras(model: Any, info: dict[str, Any]) -> None:
+    """Extract metadata from Keras/TensorFlow models."""
+    try:
+        # Input Shape
+        if hasattr(model, "input_shape"):
+            shape = model.input_shape
+            info["input_shape"] = [s if s else None for s in shape]
+            # Try to guess feature count from last dim
+            if isinstance(shape, (list, tuple)):
+                info["input_features"] = shape[-1] if len(shape) > 1 and shape[-1] else None
+
+        # Output Shape
+        if hasattr(model, "output_shape"):
+            shape = model.output_shape
+            info["output_shape"] = [s if s else None for s in shape]
+
+        # Input Names
+        if hasattr(model, "input_names") and model.input_names:
+            info["input_names"] = model.input_names
+        elif hasattr(model, "inputs"):
+            info["input_names"] = [inp.name.split(":")[0] for inp in model.inputs]
+
+        # Output Names
+        if hasattr(model, "output_names") and model.output_names:
+            info["output_names"] = model.output_names
+        elif hasattr(model, "outputs"):
+            info["output_names"] = [out.name.split(":")[0] for out in model.outputs]
+
+        # Layer info
+        if hasattr(model, "layers"):
+            info["layer_count"] = len(model.layers)
+            info["first_layer"] = model.layers[0].name if model.layers else None
+            info["last_layer"] = model.layers[-1].name if model.layers else None
+
+        # Params
+        with contextlib.suppress(Exception):
+            info["total_params"] = model.count_params()
+
+    except Exception as e:
+        info["introspection_error"] = str(e)
+
+
+def _introspect_sklearn(model: Any, info: dict[str, Any]) -> None:
+    """Extract metadata from Scikit-Learn models."""
+    try:
+        if hasattr(model, "n_features_in_"):
+            info["input_features"] = model.n_features_in_
+            # Create synthetic input shape [None, n_features]
+            info["input_shape"] = [None, model.n_features_in_]
+
+        if hasattr(model, "feature_names_in_"):
+            info["input_names"] = list(model.feature_names_in_)
+
+        if hasattr(model, "classes_"):
+            info["classes"] = list(model.classes_)
+            info["output_shape"] = [None, 1]  # Binary/Multi-class usually outputs 1 prediction or probas
+
+        if hasattr(model, "n_classes_"):
+            info["n_classes"] = model.n_classes_
+
+    except Exception as e:
+        info["introspection_error"] = str(e)
+
+
+def _introspect_pytorch(model: Any, info: dict[str, Any]) -> None:
+    """Extract metadata from PyTorch models."""
+    try:
+        if hasattr(model, "parameters"):
+            info["total_params"] = sum(p.numel() for p in model.parameters())
+
+        # Try to infer input features from first layer if possible
+        # This is heuristic and might not work for all architectures
+        for _, module in getattr(model, "named_children", lambda: [])():
+            if hasattr(module, "in_features"):
+                info["input_features"] = module.in_features
+                info["input_shape"] = [None, module.in_features]
+                break
+            elif hasattr(module, "weight") and hasattr(module.weight, "shape") and len(module.weight.shape) >= 2:
+                # Conv2d weight: [out_channels, in_channels, kH, kW] -> unrelated to input *features* in flat sense usually
+                # Linear weight: [out_features, in_features]
+                if module.__class__.__name__ == "Linear":
+                    info["input_features"] = module.weight.shape[1]
+                    info["input_shape"] = [None, module.weight.shape[1]]
+                    break
+
+    except Exception as e:
+        info["introspection_error"] = str(e)

flowyml/utils/observability.py

@@ -0,0 +1,30 @@
+from functools import wraps
+from typing import Any
+from collections.abc import Callable
+from opentelemetry import trace
+
+tracer = trace.get_tracer("flowyml")
+
+
+def trace_execution(operation_name: str | None = None) -> Callable:
+    """Decorator to trace function execution with OpenTelemetry."""
+
+    def decorator(func: Callable) -> Callable:
+        @wraps(func)
+        def wrapper(*args: Any, **kwargs: Any) -> Any:
+            span_name = operation_name or func.__name__
+            with tracer.start_as_current_span(span_name) as span:
+                # Add basic attributes
+                span.set_attribute("function.name", func.__name__)
+                span.set_attribute("function.module", func.__module__)
+
+                try:
+                    return func(*args, **kwargs)
+                except Exception as e:
+                    span.record_exception(e)
+                    span.set_status(trace.Status(trace.StatusCode.ERROR))
+                    raise e
+
+        return wrapper
+
+    return decorator