llama-deploy-appserver 0.2.7a1__py3-none-any.whl → 0.3.0a1__py3-none-any.whl

llama_deploy/appserver/workflow_loader.py

@@ -0,0 +1,383 @@
+import importlib
+from pathlib import Path
+import logging
+import socket
+import subprocess
+import sys
+import os
+import site
+import threading
+from typing import TextIO, Callable, cast
+import json
+from llama_deploy.appserver.settings import settings
+from llama_deploy.appserver.deployment_config_parser import (
+    DeploymentConfig,
+    get_deployment_config,
+)
+from workflows import Workflow
+from dotenv import dotenv_values
+
+logger = logging.getLogger(__name__)
+
+DEFAULT_SERVICE_ID = "default"
+
+
+def _stream_subprocess_output(
+    process: subprocess.Popen,
+    prefix: str,
+    color_code: str,
+) -> None:
+    """Stream a subprocess's stdout to our stdout with a colored prefix.
+
+    The function runs in the caller thread and returns when the subprocess exits
+    or its stdout closes.
+    """
+
+    def _forward_output_with_prefix(pipe: TextIO | None) -> None:
+        if pipe is None:
+            return
+        if sys.stdout.isatty():
+            colored_prefix = f"\x1b[{color_code}m{prefix}\x1b[0m"
+        else:
+            colored_prefix = prefix
+        for line in iter(pipe.readline, ""):
+            sys.stdout.write(f"{colored_prefix} {line}")
+            sys.stdout.flush()
+        try:
+            pipe.close()
+        except Exception:
+            pass
+
+    _forward_output_with_prefix(cast(TextIO, process.stdout))
+
+
+def _run_with_prefix(
+    cmd: list[str],
+    *,
+    cwd: Path | None = None,
+    env: dict[str, str] | None = None,
+    prefix: str,
+    color_code: str = "36",  # cyan by default
+) -> None:
+    """Run a command streaming output with a colored prefix.
+
+    Raises RuntimeError on non-zero exit.
+    """
+    process = subprocess.Popen(
+        cmd,
+        cwd=cwd,
+        env=env,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+        bufsize=1,
+        text=True,
+    )
+    _stream_subprocess_output(process, prefix, color_code)
+    ret = process.wait()
+    if ret != 0:
+        raise RuntimeError(f"Command failed ({ret}): {' '.join(cmd)}")
+
+
+def _start_streaming_process(
+    cmd: list[str],
+    *,
+    cwd: Path | None = None,
+    env: dict[str, str] | None = None,
+    prefix: str,
+    color_code: str,
+    line_transform: Callable[[str], str] | None = None,
+) -> subprocess.Popen:
+    """Start a subprocess and stream its output on a background thread with a colored prefix.
+
+    Returns the Popen object immediately; caller is responsible for lifecycle.
+    """
+    process = subprocess.Popen(
+        cmd,
+        cwd=cwd,
+        env=env,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+        bufsize=1,
+        text=True,
+    )
+
+    def _forward(pipe: TextIO | None) -> None:
+        if pipe is None:
+            return
+        if sys.stdout.isatty():
+            colored_prefix = f"\x1b[{color_code}m{prefix}\x1b[0m"
+        else:
+            colored_prefix = prefix
+        for line in iter(pipe.readline, ""):
+            out_line = line_transform(line) if line_transform else line
+            sys.stdout.write(f"{colored_prefix} {out_line}")
+            sys.stdout.flush()
+        try:
+            pipe.close()
+        except Exception:
+            pass
+
+    threading.Thread(target=_forward, args=(process.stdout,), daemon=True).start()
+    return process
+
+
+def do_install():
+    config = get_deployment_config()
+
+    install_python_dependencies(config, settings.config_parent)
+    install_ui(config, settings.config_parent)
+
+
+def load_workflows(config: DeploymentConfig) -> dict[str, Workflow]:
+    """
+    Creates WorkflowService instances according to the configuration object.
+
+    """
+    workflow_services = {}
+    for service_id, service_config in config.services.items():
+        # Search for a workflow instance in the service path
+        if service_config.import_path is None:
+            continue
+        module_name, workflow_name = service_config.module_location()
+        module = importlib.import_module(module_name)
+        workflow_services[service_id] = getattr(module, workflow_name)
+
+    if config.default_service:
+        if config.default_service in workflow_services:
+            workflow_services[DEFAULT_SERVICE_ID] = workflow_services[
+                config.default_service
+            ]
+        else:
+            msg = f"Service with id '{config.default_service}' does not exist, cannot set it as default."
+            logger.warning(msg)
+
+    return workflow_services
+
+
+def load_environment_variables(config: DeploymentConfig, source_root: Path) -> None:
+    """
+    Load environment variables from the deployment config.
+    """
+    for service_id, service_config in config.services.items():
+        if service_config.env:
+            env_vars = {**service_config.env}
+            for env_file in service_config.env_files or []:
+                env_file_path = source_root / env_file
+                env_vars.update(**dotenv_values(env_file_path))
+            for key, value in env_vars.items():
+                if value:
+                    os.environ[key] = value
+
+
+def install_python_dependencies(config: DeploymentConfig, source_root: Path) -> None:
+    """
+    Sync the deployment to the base path.
+    """
+    path = _find_install_target(source_root, config)
+    if path is not None:
+        print(f"Installing python dependencies from {path}")
+        _ensure_uv_available()
+        _install_to_current_python(path, source_root)
+
+
+def _find_install_target(base: Path, config: DeploymentConfig) -> str | None:
+    path: str | None = None
+    for service_id, service_config in config.services.items():
+        if service_config.python_dependencies:
+            if len(service_config.python_dependencies) > 1:
+                logger.warning(
+                    "Llama Deploy now only supports installing from a single pyproject.toml path"
+                )
+            this_path = service_config.python_dependencies[0]
+            if path is not None and this_path != path:
+                logger.warning(
+                    f"Llama Deploy now only supports installing from a single pyproject.toml path, ignoring {this_path}"
+                )
+            path = this_path
+    if path is None:
+        if (base / "pyproject.toml").exists():
+            path = "."
+    return path
+
+
+def _ensure_uv_available() -> None:
+    # Check if uv is available on the path
+    uv_available = False
+    try:
+        subprocess.check_call(
+            ["uv", "--version"],
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+        )
+        uv_available = True
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        pass
+    if not uv_available:
+        # bootstrap uv with pip
+        try:
+            _run_with_prefix(
+                [
+                    sys.executable,
+                    "-m",
+                    "pip",
+                    "install",
+                    "uv",
+                ],
+                prefix="[pip]",
+                color_code="31",  # red
+            )
+        except subprocess.CalledProcessError as e:
+            msg = f"Unable to install uv. Environment must include uv, or uv must be installed with pip: {e.stderr}"
+            raise RuntimeError(msg)
+
+
+def _install_to_current_python(path: str, source_root: Path) -> None:
+    # Bit of an ugly hack, install to whatever python environment we're currently in
+    # Find the python bin path and get its parent dir, and install into whatever that
+    # python is. Hopefully we're in a container or a venv, otherwise this is installing to
+    # the system python
+    # https://docs.astral.sh/uv/concepts/projects/config/#project-environment-path
+    python_bin_path = os.path.dirname(sys.executable)
+    python_parent_dir = os.path.dirname(python_bin_path)
+    _validate_path_is_safe(path, source_root, "python_dependencies")
+    print(
+        f"Installing python dependencies from {path} to {python_parent_dir} to {source_root}"
+    )
+    try:
+        _run_with_prefix(
+            [
+                "uv",
+                "pip",
+                "install",
+                f"--prefix={python_parent_dir}",
+                path,
+            ],
+            cwd=source_root,
+            prefix="[uv]",
+            color_code="36",
+        )
+
+        # Force Python to refresh its package discovery after installing new packages
+        site.main()  # Refresh site-packages paths
+        # Clear import caches to ensure newly installed packages are discoverable
+        importlib.invalidate_caches()
+
+    except subprocess.CalledProcessError as e:
+        msg = f"Unable to install service dependencies using command '{e.cmd}': {e.stderr}"
+        raise RuntimeError(msg) from None
+
+
+def _validate_path_is_safe(
+    path: str, source_root: Path, path_type: str = "path"
+) -> None:
+    """Validates that a path is within the source root to prevent path traversal attacks.
+
+    Args:
+        path: The path to validate
+        source_root: The root directory that paths should be relative to
+        path_type: Description of the path type for error messages
+
+    Raises:
+        DeploymentError: If the path is outside the source root
+    """
+    resolved_path = (source_root / path).resolve()
+    resolved_source_root = source_root.resolve()
+
+    if not resolved_path.is_relative_to(resolved_source_root):
+        msg = (
+            f"{path_type} {path} is not a subdirectory of the source root {source_root}"
+        )
+        raise RuntimeError(msg)
+
+
+def install_ui(config: DeploymentConfig, config_parent: Path) -> None:
+    if config.ui is None:
+        return
+    path = config.ui.source.location if config.ui.source else "."
+    _validate_path_is_safe(path, config_parent, "ui_source")
+    _run_with_prefix(
+        ["pnpm", "install"],
+        cwd=config_parent / path,
+        prefix="[pnpm-install]",
+        color_code="33",
+    )
+
+
+def _ui_env(config: DeploymentConfig) -> dict[str, str]:
+    env = os.environ.copy()
+    env["LLAMA_DEPLOY_DEPLOYMENT_URL_ID"] = config.name
+    env["LLAMA_DEPLOY_DEPLOYMENT_BASE_PATH"] = f"/deployments/{config.name}/ui"
+    if config.ui is not None:
+        env["PORT"] = str(config.ui.port)
+    return env
+
+
+def build_ui(config_parent: Path, config: DeploymentConfig) -> bool:
+    """
+    Returns True if the UI was built (and supports building), otherwise False if there's no build command
+    """
+    if config.ui is None:
+        return False
+    path = config.ui.source.location if config.ui.source else "."
+    _validate_path_is_safe(path, config_parent, "ui_source")
+    env = _ui_env(config)
+
+    package_json_path = config_parent / path / "package.json"
+
+    with open(package_json_path, "r", encoding="utf-8") as f:
+        pkg = json.load(f)
+    scripts = pkg.get("scripts", {})
+    if "build" not in scripts:
+        return False
+
+    _run_with_prefix(
+        ["pnpm", "build"],
+        cwd=config_parent / path,
+        env=env,
+        prefix="[pnpm-build]",
+        color_code="34",
+    )
+    return True
+
+
+def start_dev_ui_process(
+    root: Path, main_port: int, config: DeploymentConfig
+) -> None | subprocess.Popen:
+    ui = config.ui
+    if ui is None:
+        return None
+
+    # If a UI dev server is already listening on the configured port, do not start another
+    def _is_port_open(port: int) -> bool:
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
+            sock.settimeout(0.2)
+            try:
+                return sock.connect_ex(("127.0.0.1", port)) == 0
+            except Exception:
+                return False
+
+    if _is_port_open(ui.port):
+        logger.info(
+            "Detected process already running on port %s; not starting a new one.",
+            ui.port,
+        )
+        return None
+    # start the ui process
+    env = _ui_env(config)
+    # Transform first 20 lines to replace the default UI port with the main server port
+    line_counter = {"n": 0}
+
+    def _transform(line: str) -> str:
+        if line_counter["n"] < 20:
+            line = line.replace(f":{ui.port}", f":{main_port}")
+        line_counter["n"] += 1
+        return line
+
+    return _start_streaming_process(
+        ["pnpm", "run", "dev"],
+        cwd=root / (ui.source.location if ui.source else "."),
+        env=env,
+        prefix="[ui-server]",
+        color_code="35",  # magenta
+        line_transform=_transform,
+    )

{llama_deploy_appserver-0.2.7a1.dist-info → llama_deploy_appserver-0.3.0a1.dist-info}/METADATA

@@ -1,21 +1,18 @@
 Metadata-Version: 2.3
 Name: llama-deploy-appserver
-Version: 0.2.7a1
+Version: 0.3.0a1
 Summary: Application server components for LlamaDeploy
 Author: Massimiliano Pippi
 Author-email: Massimiliano Pippi <mpippi@gmail.com>
 License: MIT
-Requires-Dist: asgiref>=3.9.1
 Requires-Dist: llama-index-workflows>=1.1.0
 Requires-Dist: pydantic-settings>=2.10.1
 Requires-Dist: uvicorn>=0.24.0
-Requires-Dist: prometheus-client>=0.20.0
-Requires-Dist: python-multipart>=0.0.18,<0.0.19
 Requires-Dist: fastapi>=0.100.0
 Requires-Dist: websockets>=12.0
-Requires-Dist: gitpython>=3.1.40,<4
-Requires-Dist: llama-deploy-core>=0.2.7a1,<0.3.0
+Requires-Dist: llama-deploy-core>=0.3.0a1,<0.4.0
 Requires-Dist: httpx>=0.28.1
+Requires-Dist: prometheus-fastapi-instrumentator>=7.1.0
 Requires-Python: >=3.12, <4
 Description-Content-Type: text/markdown
 

llama_deploy_appserver-0.3.0a1.dist-info/RECORD

@@ -0,0 +1,17 @@
+llama_deploy/appserver/__init__.py,sha256=e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855,0
+llama_deploy/appserver/__main__.py,sha256=32eff329cadb4f883c9df3a1b2bcb908d5adde765e7c7e761d25b7df4827b9ca,196
+llama_deploy/appserver/app.py,sha256=cc19f4f955fd9b5ef6d7ebb009800444073082e13482c165e2550d244c24ad0a,3598
+llama_deploy/appserver/bootstrap.py,sha256=abf2ab94a4f15b851689de9b48ae5c57aa3a648de95c4102465ca5350cecabad,2988
+llama_deploy/appserver/deployment.py,sha256=bd35b20e0068c44965e0b76126170a292c151665417a0b322b977641ce88bfc1,2671
+llama_deploy/appserver/deployment_config_parser.py,sha256=27b3f20b95703293059182e6ef2a5a44b59c66ae73517eba9f53b62cd5b0f833,3395
+llama_deploy/appserver/routers/__init__.py,sha256=ed8fa7613eb5584bcc1b40e18a40a0e29ce39cc9c8d4bf9ad8c79e5b1d050700,214
+llama_deploy/appserver/routers/deployments.py,sha256=4b4179c4cbd48548a0cde9bbc07f3668c8f5abcffa4bfb1c98654e81e40b8329,7291
+llama_deploy/appserver/routers/status.py,sha256=eead8e0aebbc7e5e3ca8f0c00d0c1b6df1d6cde7844edfbe9350bf64ab85006f,257
+llama_deploy/appserver/routers/ui_proxy.py,sha256=9bf7e433e387bb3aa3c6fabee09313c95ca715c41dea5915ee55cd8acaa792ef,7194
+llama_deploy/appserver/settings.py,sha256=741b2ac12f37ea4bd7da4fbac4170ca7719095f123ff7a451ae8be36a530b4a6,2820
+llama_deploy/appserver/stats.py,sha256=1f3989f6705a6de3e4d61ee8cdd189fbe04a2c53ec5e720b2e5168acc331427f,691
+llama_deploy/appserver/types.py,sha256=4edc991aafb6b8497f068d12387455df292da3ff8440223637641ab1632553ec,2133
+llama_deploy/appserver/workflow_loader.py,sha256=304f4532a6a51a326a57bbdea251ab7a6398cdf5aff16081b295cb915c6fd231,12266
+llama_deploy_appserver-0.3.0a1.dist-info/WHEEL,sha256=66530aef82d5020ef5af27ae0123c71abb9261377c5bc519376c671346b12918,79
+llama_deploy_appserver-0.3.0a1.dist-info/METADATA,sha256=a7f4a18efe0e4054a057ad96c3ada3dbd7810c66796a5bb9ad70d80c4be209de,746
+llama_deploy_appserver-0.3.0a1.dist-info/RECORD,,

{llama_deploy_appserver-0.2.7a1.dist-info → llama_deploy_appserver-0.3.0a1.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: uv 0.7.21
+Generator: uv 0.7.20
 Root-Is-Purelib: true
 Tag: py3-none-any

llama_deploy/appserver/client/__init__.py

@@ -1,3 +0,0 @@
-from .client import Client
-
-__all__ = ["Client"]

llama_deploy/appserver/client/base.py

@@ -1,30 +0,0 @@
-from typing import Any
-
-import httpx
-from pydantic_settings import BaseSettings, SettingsConfigDict
-
-
-class _BaseClient(BaseSettings):
-    """Base type for clients, to be used in Pydantic models to avoid circular imports.
-
-    Settings can be passed to the Client constructor when creating an instance, or defined with environment variables
-    having names prefixed with the string `LLAMA_DEPLOY_`, e.g. `LLAMA_DEPLOY_DISABLE_SSL`.
-    """
-
-    model_config = SettingsConfigDict(env_prefix="LLAMA_DEPLOY_")
-
-    api_server_url: str = "http://localhost:4501"
-    disable_ssl: bool = False
-    timeout: float | None = 120.0
-    poll_interval: float = 0.5
-
-    async def request(
-        self, method: str, url: str | httpx.URL, **kwargs: Any
-    ) -> httpx.Response:
-        """Performs an async HTTP request using httpx."""
-        verify = kwargs.pop("verify", True)
-        timeout = kwargs.pop("timeout", self.timeout)
-        async with httpx.AsyncClient(verify=verify) as client:
-            response = await client.request(method, url, timeout=timeout, **kwargs)
-            response.raise_for_status()
-            return response

llama_deploy/appserver/client/client.py

@@ -1,49 +0,0 @@
-import asyncio
-from typing import Any
-
-from .base import _BaseClient
-from .models import ApiServer, make_sync
-
-
-class Client(_BaseClient):
-    """The LlamaDeploy Python client.
-
-    The client is gives access to both the asyncio and non-asyncio APIs. To access the sync
-    API just use methods of `client.sync`.
-
-    Example usage:
-    ```py
-    from llama_deploy.client import Client
-
-    # Use the same client instance
-    c = Client()
-
-    async def an_async_function():
-        status = await client.apiserver.status()
-
-    def normal_function():
-        status = client.sync.apiserver.status()
-    ```
-    """
-
-    @property
-    def sync(self) -> "_SyncClient":
-        """Returns the sync version of the client API."""
-        try:
-            asyncio.get_running_loop()
-        except RuntimeError:
-            return _SyncClient(**self.model_dump())
-
-        msg = "You cannot use the sync client within an async event loop - just await the async methods directly."
-        raise RuntimeError(msg)
-
-    @property
-    def apiserver(self) -> ApiServer:
-        """Access the API Server functionalities."""
-        return ApiServer(client=self, id="apiserver")
-
-
-class _SyncClient(_BaseClient):
-    @property
-    def apiserver(self) -> Any:
-        return make_sync(ApiServer)(client=self, id="apiserver")

llama_deploy/appserver/client/models/__init__.py

@@ -1,4 +0,0 @@
-from .apiserver import ApiServer
-from .model import Collection, Model, make_sync
-
-__all__ = ["ApiServer", "Collection", "Model", "make_sync"]