ob-metaflow-extensions 1.1.142__py2.py3-none-any.whl → 1.4.33__py2.py3-none-any.whl

metaflow_extensions/outerbounds/plugins/ollama/status_card.py

@@ -0,0 +1,292 @@
+from metaflow.cards import Markdown, Table, VegaChart
+from metaflow.metaflow_current import current
+from datetime import datetime
+import threading
+import time
+
+from ..card_utilities.async_cards import CardRefresher
+
+
+class OllamaStatusCard(CardRefresher):
+    """
+    Real-time status card for Ollama system monitoring.
+    Shows circuit breaker state, server health, model status, and recent events.
+    """
+
+    CARD_ID = "ollama_status"
+
+    def __init__(self, refresh_interval=10):
+        self.refresh_interval = refresh_interval
+        self.status_data = {
+            "circuit_breaker": {
+                "state": "CLOSED",
+                "failure_count": 0,
+                "last_failure_time": None,
+                "last_open_time": None,
+            },
+            "server": {
+                "status": "Starting",
+                "uptime_start": None,
+                "restart_attempts": 0,
+                "last_health_check": None,
+                "health_status": "Unknown",
+            },
+            "models": {},  # model_name -> {status, pull_time, load_time, etc}
+            "performance": {
+                "install_time": None,
+                "server_startup_time": None,
+                "total_initialization_time": None,
+            },
+            "versions": {
+                "ollama_system": "Detecting...",
+                "ollama_python": "Detecting...",
+            },
+            "cache": {
+                "policy": "auto",
+                "model_status": {},  # model_name -> cache status
+            },
+            "events": [],  # Recent events log
+        }
+        self._lock = threading.Lock()
+        self._already_rendered = False
+
+    def update_status(self, category, data):
+        """Thread-safe method to update status data"""
+        with self._lock:
+            if category in self.status_data:
+                self.status_data[category].update(data)
+
+    def add_event(self, event_type, message, timestamp=None):
+        """Add an event to the timeline"""
+        if timestamp is None:
+            timestamp = datetime.now()
+
+        with self._lock:
+            self.status_data["events"].insert(
+                0,
+                {
+                    "type": event_type,  # 'info', 'warning', 'error', 'success'
+                    "message": message,
+                    "timestamp": timestamp,
+                },
+            )
+            # Keep only last 10 events
+            self.status_data["events"] = self.status_data["events"][:10]
+
+    def get_circuit_breaker_emoji(self, state):
+        """Get status emoji for circuit breaker state"""
+        emoji_map = {"CLOSED": "🟢", "OPEN": "🔴", "HALF_OPEN": "🟡"}
+        return emoji_map.get(state, "⚪")
+
+    def get_uptime_string(self, start_time):
+        """Calculate uptime string"""
+        if not start_time:
+            return "Not started"
+
+        uptime = datetime.now() - start_time
+        hours, remainder = divmod(int(uptime.total_seconds()), 3600)
+        minutes, seconds = divmod(remainder, 60)
+
+        if hours > 0:
+            return f"{hours}h {minutes}m {seconds}s"
+        elif minutes > 0:
+            return f"{minutes}m {seconds}s"
+        else:
+            return f"{seconds}s"
+
+    def on_startup(self, current_card):
+        """Initialize the card when monitoring starts"""
+        current_card.append(Markdown("# 🦙 `@ollama` Status Dashboard"))
+        current_card.append(Markdown("_Initializing Ollama system..._"))
+        current_card.refresh()
+
+    def render_card_fresh(self, current_card, data):
+        """Render the complete card with all status information"""
+        self._already_rendered = True
+        current_card.clear()
+
+        # Header with version information
+        current_card.append(Markdown("# 🦙 `@ollama` Status Dashboard"))
+
+        # Version information in header
+        versions = data.get("versions", {})
+        system_version = versions.get("ollama_system", "Unknown")
+        python_version = versions.get("ollama_python", "Unknown")
+        current_card.append(
+            Markdown(
+                f"**System:** `{system_version}` | **Python Client:** `{python_version}`"
+            )
+        )
+
+        # Cache policy information
+        cache_info = data.get("cache", {})
+        cache_policy = cache_info.get("policy", "auto")
+        current_card.append(Markdown(f"**Cache Policy:** `{cache_policy}`"))
+
+        current_card.append(
+            Markdown(f"_Last updated: {datetime.now().strftime('%H:%M:%S')}_")
+        )
+
+        # Circuit Breaker Status
+        cb_data = data["circuit_breaker"]
+        cb_emoji = self.get_circuit_breaker_emoji(cb_data["state"])
+        cb_status = f"{cb_emoji} **{cb_data['state']}**"
+        if cb_data["failure_count"] > 0:
+            cb_status += f" (failures: {cb_data['failure_count']})"
+
+        # Server Status
+        server_data = data["server"]
+        uptime = self.get_uptime_string(server_data.get("uptime_start"))
+        server_status = f"**{server_data['status']}**"
+        if server_data["restart_attempts"] > 0:
+            server_status += f" (restarts: {server_data['restart_attempts']})"
+
+        # Status Overview Table
+        status_table = [
+            ["Circuit Breaker", Markdown(cb_status)],
+            ["Server Status", Markdown(server_status)],
+            ["Server Uptime", Markdown(uptime)],
+            [
+                "Last Health Check",
+                Markdown(server_data.get("health_status", "Unknown")),
+            ],
+        ]
+
+        current_card.append(Markdown("## System Status"))
+        current_card.append(Table(status_table, headers=["Component", "Status"]))
+
+        # Models Status
+        if data["models"]:
+            current_card.append(Markdown("## Models"))
+            model_table = []
+            cache_model_status = cache_info.get("model_status", {})
+
+            for model_name, model_info in data["models"].items():
+                status = model_info.get("status", "Unknown")
+                pull_time = model_info.get("pull_time", "N/A")
+                if isinstance(pull_time, (int, float)):
+                    pull_time = f"{pull_time:.1f}s"
+
+                # Add cache status indicator
+                cache_status = cache_model_status.get(model_name, "unknown")
+                cache_emoji = {
+                    "exists": "💾",
+                    "missing": "❌",
+                    "error": "⚠️",
+                    "unknown": "❓",
+                }.get(cache_status, "❓")
+
+                # Get model metadata
+                size_formatted = model_info.get("size_formatted", "Unknown")
+                blob_count = model_info.get("blob_count", "Unknown")
+                if blob_count == 0:
+                    blob_count = "Unknown"
+
+                model_table.append(
+                    [
+                        f"{model_name} {cache_emoji}",
+                        status,
+                        pull_time,
+                        size_formatted,
+                        str(blob_count),
+                    ]
+                )
+
+            current_card.append(
+                Table(
+                    model_table,
+                    headers=["Model (Cache)", "Status", "Pull Time", "Size", "Blobs"],
+                )
+            )
+
+        # Performance Metrics
+        perf_data = data["performance"]
+        if any(v is not None for v in perf_data.values()):
+            current_card.append(Markdown("## Performance"))
+
+            # Separate initialization and shutdown metrics
+            init_metrics = []
+            shutdown_metrics = []
+            other_metrics = []
+
+            for metric, value in perf_data.items():
+                if value is not None:
+                    display_value = value
+                    if isinstance(value, (int, float)):
+                        display_value = f"{value:.1f}s"
+
+                    metric_display = metric.replace("_", " ").title()
+
+                    if "shutdown" in metric.lower():
+                        shutdown_metrics.append([metric_display, display_value])
+                    elif metric in [
+                        "install_time",
+                        "server_startup_time",
+                        "total_initialization_time",
+                    ]:
+                        init_metrics.append([metric_display, display_value])
+                    else:
+                        other_metrics.append([metric_display, display_value])
+
+            # Display metrics in organized sections
+            if init_metrics:
+                current_card.append(Markdown("### Initialization"))
+                current_card.append(Table(init_metrics, headers=["Metric", "Duration"]))
+
+            if shutdown_metrics:
+                current_card.append(Markdown("### Shutdown"))
+                current_card.append(
+                    Table(shutdown_metrics, headers=["Metric", "Value"])
+                )
+
+            if other_metrics:
+                current_card.append(Markdown("### Other"))
+                current_card.append(Table(other_metrics, headers=["Metric", "Value"]))
+
+        # Recent Events
+        if data["events"]:
+            current_card.append(Markdown("## Recent Events"))
+            events_table = []
+            for event in data["events"][:5]:  # Show last 5 events
+                timestamp = event["timestamp"].strftime("%H:%M:%S")
+                event_type = event["type"]
+                message = event["message"]
+
+                # Add emoji based on event type
+                type_emoji = {
+                    "info": "ℹ️",
+                    "success": "✅",
+                    "warning": "⚠️",
+                    "error": "❌",
+                }.get(event_type, "ℹ️")
+
+                events_table.append([timestamp, f"{type_emoji} {message}"])
+
+            current_card.append(Table(events_table, headers=["Time", "Event"]))
+
+        current_card.refresh()
+
+    def on_error(self, current_card, error_message):
+        """Handle errors in card rendering"""
+        if not self._already_rendered:
+            current_card.clear()
+            current_card.append(Markdown("# 🦙 `@ollama` Status Dashboard"))
+            current_card.append(Markdown(f"## ❌ Error: {str(error_message)}"))
+            current_card.refresh()
+
+    def on_update(self, current_card, data_object):
+        """Update the card with new data"""
+        with self._lock:
+            current_data = self.status_data.copy()
+
+        if not self._already_rendered:
+            self.render_card_fresh(current_card, current_data)
+        else:
+            # For frequent updates, we could implement incremental updates here
+            # For now, just re-render the whole card
+            self.render_card_fresh(current_card, current_data)
+
+    def sqlite_fetch_func(self, conn):
+        """Required by CardRefresher (which needs a refactor), but we use in-memory data instead"""
+        with self._lock:
+            return {"status": self.status_data}

metaflow_extensions/outerbounds/plugins/optuna/__init__.py

@@ -0,0 +1,48 @@
+import os
+import json
+
+__mf_promote_submodules__ = ["plugins.optuna"]
+
+
+def auth():
+    from metaflow.metaflow_config_funcs import init_config
+
+    conf = init_config()
+    if conf:
+        headers = {"x-api-key": conf["METAFLOW_SERVICE_AUTH_KEY"]}
+    else:
+        headers = json.loads(os.environ["METAFLOW_SERVICE_HEADERS"])
+    return headers
+
+
+def get_deployment_db_access_endpoint(name: str):
+    from ..apps.core.perimeters import PerimeterExtractor
+    from ..apps.core.capsule import CapsuleApi
+
+    perimeter, cap_url = PerimeterExtractor.during_metaflow_execution()
+    deployment = CapsuleApi(cap_url, perimeter).get_by_name(name)
+    if not deployment:
+        raise Exception(f"No app deployment found with name `{name}`")
+
+    if (
+        "status" in deployment
+        and "accessInfo" in deployment["status"]
+        and "extraAccessUrls" in deployment["status"]["accessInfo"]
+    ):
+        for extra_url in deployment["status"]["accessInfo"]["extraAccessUrls"]:
+            if extra_url["name"] == "in_cluster_db_access":
+                db_url = extra_url["url"].replace("http://", "")
+                return db_url
+
+    raise Exception(f"No db access endpoint found for deployment `{name}`")
+
+
+def get_db_url(app_name: str):
+    """
+    Example usage:
+        >>> from metaflow.plugins.optuna import get_db_url
+        >>> s = optuna.create_study(..., storage=get_db_url("optuna-dashboard"))
+    """
+    mf_token = auth()["x-api-key"]
+    app_url = get_deployment_db_access_endpoint(app_name)
+    return f"postgresql://userspace_default:{mf_token}@{app_url}/userspace_default?sslmode=disable"

metaflow_extensions/outerbounds/plugins/profilers/simple_card_decorator.py

@@ -0,0 +1,96 @@
+from datetime import datetime
+from metaflow.decorators import StepDecorator
+from ..card_utilities.injector import CardDecoratorInjector
+
+
+class DynamicCardAppendDecorator(StepDecorator):
+    """
+    A simple decorator that demonstrates using CardDecoratorInjector
+    to inject a card and render simple markdown content.
+    """
+
+    name = "test_append_card"
+
+    defaults = {
+        "title": "Simple Card",
+        "message": "Hello from DynamicCardAppendDecorator!",
+        "show_timestamp": True,
+        "refresh_interval": 5,
+    }
+
+    CARD_ID = "simple_card"
+
+    def step_init(
+        self, flow, graph, step_name, decorators, environment, flow_datastore, logger
+    ):
+        """Initialize the decorator and inject the card."""
+        self.deco_injector = CardDecoratorInjector()
+        self.deco_injector.attach_card_decorator(
+            flow,
+            step_name,
+            self.CARD_ID,
+            "blank",
+            refresh_interval=self.attributes["refresh_interval"],
+        )
+
+    def task_decorate(
+        self, step_func, flow, graph, retry_count, max_user_code_retries, ubf_context
+    ):
+        """Decorate the step function to add card content."""
+        from metaflow import current
+        from metaflow.cards import Markdown
+
+        # Create the card content
+        title = self.attributes["title"]
+        message = self.attributes["message"]
+        show_timestamp = self.attributes["show_timestamp"]
+
+        # Add title to the card
+        current.card[self.CARD_ID].append(Markdown(f"# {title}"))
+
+        # Add message to the card
+        current.card[self.CARD_ID].append(Markdown(f"**Message:** {message}"))
+
+        # Add timestamp if requested
+        if show_timestamp:
+            timestamp = datetime.now().astimezone().strftime("%Y-%m-%d %H:%M:%S %z")
+            current.card[self.CARD_ID].append(Markdown(f"**Created at:** {timestamp}"))
+
+        # Add step information
+        current.card[self.CARD_ID].append(Markdown(f"**Step:** `{current.pathspec}`"))
+
+        # Add a simple divider
+        current.card[self.CARD_ID].append(Markdown("---"))
+
+        # Add some dynamic content that shows this is working
+        current.card[self.CARD_ID].append(
+            Markdown("**Status:** Card successfully injected! 🎉")
+        )
+
+        def wrapped_step_func():
+            """Execute the original step function."""
+            try:
+                # Before execution
+                current.card[self.CARD_ID].append(
+                    Markdown("**Execution:** Step started...")
+                )
+                current.card[self.CARD_ID].refresh()
+
+                # Execute the original step
+                step_func()
+
+                # After execution
+                current.card[self.CARD_ID].append(
+                    Markdown("**Execution:** Step completed successfully! ✅")
+                )
+                current.card[self.CARD_ID].refresh()
+
+            except Exception as e:
+                # Handle errors
+                current.card[self.CARD_ID].append(
+                    Markdown(f"**Error:** Step failed with error: `{str(e)}` ❌")
+                )
+                current.card[self.CARD_ID].refresh()
+                raise
+
+        return wrapped_step_func

metaflow_extensions/outerbounds/plugins/s3_proxy/__init__.py

@@ -0,0 +1,7 @@
+from .s3_proxy_decorator import (
+    S3ProxyDecorator,
+    NebiusS3ProxyDecorator,
+    CoreWeaveS3ProxyDecorator,
+)
+
+__all__ = ["S3ProxyDecorator", "NebiusS3ProxyDecorator", "CoreWeaveS3ProxyDecorator"]

metaflow_extensions/outerbounds/plugins/s3_proxy/binary_caller.py

@@ -0,0 +1,132 @@
+import sys
+import os
+import subprocess
+from metaflow.mflog.mflog import decorate
+from metaflow.mflog import TASK_LOG_SOURCE
+from typing import Union, TextIO, BinaryIO, Callable, Optional
+from queue import Queue, Empty
+from concurrent.futures import ThreadPoolExecutor
+import subprocess
+
+
+def enqueue_output(file, queue):
+    for line in iter(file.readline, ""):
+        queue.put(line)
+    file.close()
+
+
+def read_popen_pipes(p: subprocess.Popen):
+
+    with ThreadPoolExecutor(2) as pool:
+        q_stdout, q_stderr = Queue(), Queue()
+        pool.submit(enqueue_output, p.stdout, q_stdout)
+        pool.submit(enqueue_output, p.stderr, q_stderr)
+        while True:
+
+            if p.poll() is not None and q_stdout.empty() and q_stderr.empty():
+                break
+
+            out_line = err_line = ""
+
+            try:
+                out_line = q_stdout.get_nowait()
+            except Empty:
+                pass
+            try:
+                err_line = q_stderr.get_nowait()
+            except Empty:
+                pass
+
+            yield (out_line, err_line)
+
+
+class LogBroadcaster:
+    def __init__(
+        self,
+        process: subprocess.Popen,
+    ):
+        self._process = process
+        self._file_descriptors_and_parsers = []
+
+    def add_channel(
+        self, file_path: str, parser: Optional[Callable[[str], str]] = None
+    ):
+        self._file_descriptors_and_parsers.append((open(file_path, "a"), parser))
+
+    def _broadcast_lines(self, out_line: str, err_line: str):
+        for file_descriptor, parser in self._file_descriptors_and_parsers:
+            if out_line != "":
+                if parser:
+                    out_line = parser(out_line)
+                print(out_line, file=file_descriptor, end="", flush=True)
+            if err_line != "":
+                if parser:
+                    err_line = parser(err_line)
+                print(err_line, file=file_descriptor, end="", flush=True)
+
+    def publish_line(self, out_line: str, err_line: str):
+        self._broadcast_lines(out_line, err_line)
+
+    def broadcast_logs_to_files(self):
+        for out_line, err_line in read_popen_pipes(self._process):
+            self._broadcast_lines(out_line, err_line)
+
+        self._process.wait()
+
+        for file_descriptor, _ in self._file_descriptors_and_parsers:
+            file_descriptor.close()
+
+
+def run_with_mflog_capture(command, debug=False):
+    """
+    Run a subprocess with proper mflog integration for stdout/stderr capture.
+    This mimics what bash_capture_logs does but in Python.
+    """
+    # Get the log file paths from environment variables
+    stdout_path = os.environ.get("MFLOG_STDOUT")
+    stderr_path = os.environ.get("MFLOG_STDERR")
+
+    if not stdout_path or not stderr_path:
+        # Fallback to regular subprocess if mflog env vars aren't set
+        return subprocess.run(command, check=True, shell=True)
+
+    pipe = subprocess.PIPE if debug else subprocess.DEVNULL
+    # Start the subprocess with pipes
+    process = subprocess.Popen(
+        command,
+        shell=True,
+        stdout=pipe,
+        stderr=pipe,
+        text=False,  # Use bytes for proper mflog handling
+        bufsize=0,  # Unbuffered for real-time logging
+    )
+
+    broadcaster = LogBroadcaster(process)
+
+    broadcaster.add_channel(
+        stderr_path, lambda line: decorate(TASK_LOG_SOURCE, line).decode("utf-8")
+    )
+    broadcaster.publish_line(f"[S3 PROXY] Starting Fast S3 Proxy.....\n", "")
+    broadcaster.broadcast_logs_to_files()
+
+    # Check the return code and raise if non-zero
+    if process.returncode != 0:
+        raise subprocess.CalledProcessError(process.returncode, command)
+
+    return process.returncode
+
+
+if __name__ == "__main__":
+    s3_proxy_binary_path = os.environ.get("S3_PROXY_BINARY_COMMAND")
+    s3_proxy_debug = bool(os.environ.get("S3_PROXY_BINARY_DEBUG", False))
+    if not s3_proxy_binary_path:
+        print("S3_PROXY_BINARY_COMMAND environment variable not set")
+        sys.exit(1)
+
+    try:
+        run_with_mflog_capture(s3_proxy_binary_path, debug=s3_proxy_debug)
+    except subprocess.CalledProcessError as e:
+        sys.exit(e.returncode)
+    except Exception as e:
+        print(f"Error running S3 proxy binary: {e}", file=sys.stderr)
+        sys.exit(1)

metaflow_extensions/outerbounds/plugins/s3_proxy/constants.py

@@ -0,0 +1,11 @@
+S3_PROXY_BINARY_URLS = {
+    "aarch64": "https://fast-s3-proxy.outerbounds.sh/linux-arm64/s3-proxy-0.1.1.gz",
+    "x86_64": "https://fast-s3-proxy.outerbounds.sh/linux-amd64/s3-proxy-0.1.1.gz",
+}
+
+DEFAULT_PROXY_PORT = 8081
+DEFAULT_PROXY_HOST = "localhost"
+S3_PROXY_WRITE_MODES = [
+    "origin-and-cache",
+    "origin",
+]

metaflow_extensions/outerbounds/plugins/s3_proxy/exceptions.py

@@ -0,0 +1,13 @@
+from metaflow.exception import MetaflowException
+
+
+class S3ProxyException(MetaflowException):
+    headline = "S3 Proxy Error"
+
+
+class S3ProxyConfigException(S3ProxyException):
+    headline = "S3 Proxy Configuration Error"
+
+
+class S3ProxyApiException(S3ProxyException):
+    headline = "S3 Proxy API Error"

metaflow_extensions/outerbounds/plugins/s3_proxy/proxy_bootstrap.py

@@ -0,0 +1,59 @@
+from .s3_proxy_manager import S3ProxyManager
+from metaflow._vendor import click
+from metaflow import JSONType
+import json
+
+
+@click.group()
+def cli():
+    pass
+
+
+@cli.command()
+@click.option(
+    "--integration-name", type=str, help="The integration name", required=True
+)
+@click.option("--write-mode", type=str, help="The write mode")
+@click.option("--debug", type=bool, help="The debug mode", default=False)
+@click.option(
+    "--uc-proxy-cfg-write-path",
+    type=str,
+    help="The path to write the user code proxy config",
+    required=True,
+)
+@click.option(
+    "--proxy-status-write-path",
+    type=str,
+    help="The path to write the proxy status",
+    required=True,
+)
+def bootstrap(
+    integration_name,
+    write_mode,
+    debug,
+    uc_proxy_cfg_write_path,
+    proxy_status_write_path,
+):
+    manager = S3ProxyManager(
+        integration_name=integration_name,
+        write_mode=write_mode,
+        debug=debug,
+    )
+    user_code_proxy_config, proxy_pid, config_path, binary_path = manager.setup_proxy()
+    with open(uc_proxy_cfg_write_path, "w") as f:
+        f.write(json.dumps(user_code_proxy_config))
+    with open(proxy_status_write_path, "w") as f:
+        f.write(
+            json.dumps(
+                {
+                    "proxy_pid": proxy_pid,
+                    "config_path": config_path,
+                    "binary_path": binary_path,
+                }
+            )
+        )
+
+
+if __name__ == "__main__":
+    print("[@s3_proxy] Jumpstarting the proxy....")
+    cli()