llama-deploy-appserver 0.3.0a4__tar.gz → 0.3.0a6__tar.gz

{llama_deploy_appserver-0.3.0a4 → llama_deploy_appserver-0.3.0a6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: llama-deploy-appserver
-Version: 0.3.0a4
+Version: 0.3.0a6
 Summary: Application server components for LlamaDeploy
 Author: Massimiliano Pippi
 Author-email: Massimiliano Pippi <mpippi@gmail.com>
@@ -10,9 +10,10 @@ Requires-Dist: pydantic-settings>=2.10.1
 Requires-Dist: uvicorn>=0.24.0
 Requires-Dist: fastapi>=0.100.0
 Requires-Dist: websockets>=12.0
-Requires-Dist: llama-deploy-core>=0.3.0a4,<0.4.0
+Requires-Dist: llama-deploy-core>=0.3.0a6,<0.4.0
 Requires-Dist: httpx>=0.28.1
 Requires-Dist: prometheus-fastapi-instrumentator>=7.1.0
+Requires-Dist: packaging>=25.0
 Requires-Python: >=3.12, <4
 Description-Content-Type: text/markdown
 

{llama_deploy_appserver-0.3.0a4 → llama_deploy_appserver-0.3.0a6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "llama-deploy-appserver"
-version = "0.3.0a4"
+version = "0.3.0a6"
 description = "Application server components for LlamaDeploy"
 readme = "README.md"
 license = { text = "MIT" }
@@ -14,9 +14,10 @@ dependencies = [
     "uvicorn>=0.24.0",
     "fastapi>=0.100.0",
     "websockets>=12.0",
-    "llama-deploy-core>=0.3.0a4,<0.4.0",
+    "llama-deploy-core>=0.3.0a6,<0.4.0",
     "httpx>=0.28.1",
     "prometheus-fastapi-instrumentator>=7.1.0",
+    "packaging>=25.0",
 ]
 
 [build-system]

{llama_deploy_appserver-0.3.0a4 → llama_deploy_appserver-0.3.0a6}/src/llama_deploy/appserver/app.py

@@ -1,28 +1,19 @@
+import argparse
 import logging
 import os
-from pathlib import Path
 import threading
 import time
-from llama_deploy.appserver.deployment_config_parser import (
-    get_deployment_config,
-)
-from llama_deploy.appserver.settings import configure_settings, settings
+import webbrowser
+from contextlib import asynccontextmanager
+from pathlib import Path
+from typing import Any, AsyncGenerator
 
+import uvicorn
 from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
-from llama_deploy.appserver.workflow_loader import (
-    build_ui,
-    do_install,
-    load_environment_variables,
-    start_dev_ui_process,
+from llama_deploy.appserver.deployment_config_parser import (
+    get_deployment_config,
 )
-import uvicorn
-
-from .routers import health_router
-from prometheus_fastapi_instrumentator import Instrumentator
-from contextlib import asynccontextmanager
-from typing import Any, AsyncGenerator
-
 from llama_deploy.appserver.routers.deployments import (
     create_base_router,
     create_deployments_router,
@@ -31,13 +22,23 @@ from llama_deploy.appserver.routers.ui_proxy import (
     create_ui_proxy_router,
     mount_static_files,
 )
+from llama_deploy.appserver.settings import configure_settings, settings
 from llama_deploy.appserver.workflow_loader import (
+    _exclude_venv_warning,
+    build_ui,
+    find_python_pyproject,
+    inject_appserver_into_target,
+    install_ui,
+    load_environment_variables,
     load_workflows,
+    start_dev_ui_process,
 )
+from prometheus_fastapi_instrumentator import Instrumentator
 
 from .deployment import Deployment
+from .process_utils import run_process
+from .routers import health_router
 from .stats import apiserver_state
-import webbrowser
 
 logger = logging.getLogger("uvicorn.info")
 
@@ -45,7 +46,6 @@ logger = logging.getLogger("uvicorn.info")
 @asynccontextmanager
 async def lifespan(app: FastAPI) -> AsyncGenerator[None, Any]:
     apiserver_state.state("starting")
-
     config = get_deployment_config()
 
     workflows = load_workflows(config)
@@ -85,24 +85,44 @@ if not os.environ.get("DISABLE_CORS", False):
 app.include_router(health_router)
 
 
+def open_browser_async(host: str, port: int) -> None:
+    def _open_with_delay() -> None:
+        time.sleep(1)
+        webbrowser.open(f"http://{host}:{port}")
+
+    threading.Thread(target=_open_with_delay).start()
+
+
+def prepare_server(
+    deployment_file: Path | None = None,
+    install: bool = False,
+    build: bool = False,
+) -> None:
+    configure_settings(deployment_file_path=deployment_file)
+    load_environment_variables(get_deployment_config(), settings.config_parent)
+    if install:
+        config = get_deployment_config()
+        inject_appserver_into_target(config, settings.config_parent)
+        install_ui(config, settings.config_parent)
+    if build:
+        build_ui(settings.config_parent, get_deployment_config())
+
+
 def start_server(
     proxy_ui: bool = False,
     reload: bool = False,
     cwd: Path | None = None,
     deployment_file: Path | None = None,
-    install: bool = False,
-    build: bool = False,
     open_browser: bool = False,
 ) -> None:
     # Configure via environment so uvicorn reload workers inherit the values
     configure_settings(
-        proxy_ui=proxy_ui, app_root=cwd, deployment_file_path=deployment_file
+        proxy_ui=proxy_ui,
+        app_root=cwd,
+        deployment_file_path=deployment_file,
+        reload=reload,
     )
     load_environment_variables(get_deployment_config(), settings.config_parent)
-    if install:
-        do_install()
-    if build:
-        build_ui(settings.config_parent, get_deployment_config())
 
     ui_process = None
     if proxy_ui:
@@ -111,14 +131,7 @@ def start_server(
         )
     try:
         if open_browser:
-
-            def open_with_delay():
-                time.sleep(1)
-                webbrowser.open(f"http://{settings.host}:{settings.port}")
-
-            threading.Thread(
-                target=open_with_delay,
-            ).start()
+            open_browser_async(settings.host, settings.port)
 
         uvicorn.run(
             "llama_deploy.appserver.app:app",
@@ -129,3 +142,52 @@ def start_server(
     finally:
         if ui_process is not None:
             ui_process.terminate()
+
+
+def start_server_in_target_venv(
+    proxy_ui: bool = False,
+    reload: bool = False,
+    cwd: Path | None = None,
+    deployment_file: Path | None = None,
+    open_browser: bool = False,
+) -> None:
+    cfg = get_deployment_config()
+    path = find_python_pyproject(cwd or Path.cwd(), cfg)
+
+    args = ["uv", "run", "python", "-m", "llama_deploy.appserver.app"]
+    if proxy_ui:
+        args.append("--proxy-ui")
+    if reload:
+        args.append("--reload")
+    if deployment_file:
+        args.append("--deployment-file")
+        args.append(str(deployment_file))
+    if open_browser:
+        args.append("--open-browser")
+    # All the streaming/PTY/pipe handling is centralized
+    ret = run_process(
+        args,
+        cwd=path,
+        env=None,
+        line_transform=_exclude_venv_warning,
+    )
+
+    if ret != 0:
+        raise SystemExit(ret)
+
+
+if __name__ == "__main__":
+    print("starting server")
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--proxy-ui", action="store_true")
+    parser.add_argument("--reload", action="store_true")
+    parser.add_argument("--deployment-file", type=Path)
+    parser.add_argument("--open-browser", action="store_true")
+
+    args = parser.parse_args()
+    start_server(
+        proxy_ui=args.proxy_ui,
+        reload=args.reload,
+        deployment_file=args.deployment_file,
+        open_browser=args.open_browser,
+    )

llama_deploy_appserver-0.3.0a6/src/llama_deploy/appserver/bootstrap.py

@@ -0,0 +1,70 @@
+"""
+Bootstraps an application from a remote github repository given environment variables.
+
+This just sets up the files from the repository. It's more of a build process.
+"""
+
+import os
+from pathlib import Path
+
+from llama_deploy.appserver.deployment_config_parser import get_deployment_config
+from llama_deploy.appserver.settings import BootstrapSettings, configure_settings
+from llama_deploy.appserver.workflow_loader import (
+    build_ui,
+    inject_appserver_into_target,
+    install_ui,
+    load_environment_variables,
+)
+from llama_deploy.core.git.git_util import (
+    clone_repo,
+)
+
+
+def bootstrap_app_from_repo(
+    target_dir: str = "/opt/app",
+):
+    bootstrap_settings = BootstrapSettings()
+    # Needs the github url+auth, and the deployment file path
+    # clones the repo to a standard directory
+    # (eventually) runs the UI build process and moves that to a standard directory for a file server
+
+    repo_url = bootstrap_settings.repo_url
+    if repo_url is None:
+        raise ValueError("repo_url is required to bootstrap")
+    clone_repo(
+        repository_url=repo_url,
+        git_ref=bootstrap_settings.git_sha or bootstrap_settings.git_ref,
+        basic_auth=bootstrap_settings.auth_token,
+        dest_dir=target_dir,
+    )
+    # Ensure target_dir exists locally when running tests outside a container
+    os.makedirs(target_dir, exist_ok=True)
+    os.chdir(target_dir)
+    configure_settings(
+        app_root=Path(target_dir),
+        deployment_file_path=Path(bootstrap_settings.deployment_file_path),
+    )
+    config = get_deployment_config()
+    base_path = Path(target_dir)
+    load_environment_variables(config, base_path)
+
+    sdists = None
+    if bootstrap_settings.bootstrap_sdists:
+        sdists = [
+            Path(bootstrap_settings.bootstrap_sdists) / f
+            for f in os.listdir(bootstrap_settings.bootstrap_sdists)
+        ]
+        sdists = [f for f in sdists if f.is_file() and f.name.endswith(".tar.gz")]
+        if not sdists:
+            sdists = None
+    # Use the explicit base path rather than relying on global settings so tests
+    # can safely mock configure_settings without affecting call arguments.
+    inject_appserver_into_target(config, base_path, sdists)
+    install_ui(config, base_path)
+    build_ui(base_path, config)
+
+    pass
+
+
+if __name__ == "__main__":
+    bootstrap_app_from_repo()

{llama_deploy_appserver-0.3.0a4 → llama_deploy_appserver-0.3.0a6}/src/llama_deploy/appserver/deployment.py

@@ -8,7 +8,6 @@ from llama_deploy.appserver.workflow_loader import DEFAULT_SERVICE_ID
 from workflows import Context, Workflow
 from workflows.handler import WorkflowHandler
 
-
 logger = logging.getLogger()
 
 

llama_deploy_appserver-0.3.0a6/src/llama_deploy/appserver/deployment_config_parser.py

@@ -0,0 +1,13 @@
+import functools
+
+from llama_deploy.appserver.settings import BootstrapSettings, settings
+from llama_deploy.core.deployment_config import DeploymentConfig
+
+
+@functools.lru_cache
+def get_deployment_config() -> DeploymentConfig:
+    base_settings = BootstrapSettings()
+    base = settings.app_root.resolve()
+    yaml_file = base / settings.deployment_file_path
+    name = base_settings.deployment_name
+    return DeploymentConfig.from_yaml(yaml_file, name)

llama_deploy_appserver-0.3.0a6/src/llama_deploy/appserver/process_utils.py

@@ -0,0 +1,201 @@
+import functools
+import os
+import platform
+import pty
+import subprocess
+import sys
+import threading
+from typing import Callable, TextIO, cast
+
+
+def run_process(
+    cmd: list[str],
+    *,
+    cwd: os.PathLike | None = None,
+    env: dict[str, str] | None = None,
+    prefix: str | None = None,
+    color_code: str = "36",
+    line_transform: Callable[[str], str | None] | None = None,
+    use_tty: bool | None = None,
+) -> None:
+    """Run a process and stream its output with optional TTY semantics.
+
+    If use_tty is None, a PTY will be used only when the parent's stdout is a TTY
+    and the platform supports PTYs. When a PTY is used, stdout/stderr are merged.
+    """
+    use_pty = _should_use_pty(use_tty)
+    prefixer = _make_prefixer(prefix, color_code, line_transform)
+
+    process, sources, cleanup = _spawn_process(cmd, cwd=cwd, env=env, use_pty=use_pty)
+    threads: list[threading.Thread] = []
+    try:
+        cleanup()
+        threads = _start_stream_threads(sources, prefixer)
+        ret = process.wait()
+        if ret != 0:
+            raise subprocess.CalledProcessError(ret, cmd)
+    finally:
+        for t in threads:
+            t.join()
+
+
+def spawn_process(
+    cmd: list[str],
+    *,
+    cwd: os.PathLike | None = None,
+    env: dict[str, str] | None = None,
+    prefix: str | None = None,
+    color_code: str = "36",
+    line_transform: Callable[[str], str | None] | None = None,
+    use_tty: bool | None = None,
+) -> subprocess.Popen:
+    """Spawn a process and stream its output in background threads.
+
+    Returns immediately with the Popen object. Streaming threads are daemons.
+    """
+    use_pty = _should_use_pty(use_tty)
+    prefixer = _make_prefixer(prefix, color_code, line_transform)
+
+    process, sources, cleanup = _spawn_process(cmd, cwd=cwd, env=env, use_pty=use_pty)
+    cleanup()
+    _start_stream_threads(sources, prefixer)
+    return process
+
+
+@functools.cache
+def _use_color() -> bool:
+    """Return True if ANSI colors should be emitted to stdout.
+
+    Respects common environment variables and falls back to TTY detection.
+    """
+    force_color = os.environ.get("FORCE_COLOR")
+
+    return sys.stdout.isatty() or force_color is not None and force_color != "0"
+
+
+def _colored_prefix(prefix: str, color_code: str) -> str:
+    return f"\x1b[{color_code}m{prefix}\x1b[0m " if _use_color() else f"{prefix} "
+
+
+def _make_prefixer(
+    prefix: str | None,
+    color_code: str,
+    line_transform: Callable[[str], str | None] | None = None,
+) -> Callable[[str], str | None]:
+    colored = _colored_prefix(prefix, color_code) if prefix else ""
+
+    def _prefixer(line: str) -> str | None:
+        transformed = line_transform(line) if line_transform else line
+        if transformed is None:
+            return None
+        return f"{colored}{transformed}"
+
+    return _prefixer
+
+
+# Unified PTY/Pipe strategy helpers
+
+
+def _should_use_pty(use_tty: bool | None) -> bool:
+    if platform.system() == "Windows":
+        return False
+    if use_tty is None:
+        return sys.stdout.isatty()
+    return use_tty and sys.stdout.isatty()
+
+
+def _spawn_process(
+    cmd: list[str],
+    *,
+    cwd: os.PathLike | None,
+    env: dict[str, str] | None,
+    use_pty: bool,
+) -> tuple[subprocess.Popen, list[tuple[int | TextIO, TextIO]], Callable[[], None]]:
+    if use_pty:
+        master_fd, slave_fd = pty.openpty()
+        process = subprocess.Popen(
+            cmd,
+            env=env,
+            cwd=cwd,
+            stdin=slave_fd,
+            stdout=slave_fd,
+            stderr=slave_fd,
+            close_fds=True,
+        )
+
+        def cleanup() -> None:
+            try:
+                os.close(slave_fd)
+            except OSError:
+                pass
+
+        sources: list[tuple[int | TextIO, TextIO]] = [
+            (master_fd, cast(TextIO, sys.stdout)),
+        ]
+        return process, sources, cleanup
+
+    process = subprocess.Popen(
+        cmd,
+        env=env,
+        cwd=cwd,
+        stdin=None,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        text=True,
+        encoding="utf-8",
+    )
+
+    def cleanup() -> None:
+        return None
+
+    assert process.stdout is not None and process.stderr is not None
+    sources = [
+        (process.stdout, cast(TextIO, sys.stdout)),
+        (process.stderr, cast(TextIO, sys.stderr)),
+    ]
+    return process, sources, cleanup
+
+
+def _stream_source(
+    source: int | TextIO,
+    writer: TextIO,
+    transform: Callable[[str], str | None] | None,
+) -> None:
+    if isinstance(source, int):
+        try:
+            with os.fdopen(
+                source, "r", encoding="utf-8", errors="replace", buffering=1
+            ) as f:
+                for line in f:
+                    out = transform(line) if transform else line
+                    if out is not None:
+                        writer.write(out)
+                        writer.flush()
+        except OSError:
+            # PTY EOF may raise EIO; ignore
+            pass
+    else:
+        for line in iter(source.readline, ""):
+            out = transform(line) if transform else line
+            if out is None:
+                continue
+            writer.write(out)
+            writer.flush()
+        try:
+            source.close()
+        except Exception:
+            pass
+
+
+def _start_stream_threads(
+    sources: list[tuple[int | TextIO, TextIO]],
+    transform: Callable[[str], str | None] | None,
+) -> list[threading.Thread]:
+    threads: list[threading.Thread] = []
+    for src, dst in sources:
+        t = threading.Thread(
+            target=_stream_source, args=(src, dst, transform), daemon=True
+        )
+        t.start()
+        threads.append(t)
+    return threads

{llama_deploy_appserver-0.3.0a4 → llama_deploy_appserver-0.3.0a6}/src/llama_deploy/appserver/routers/ui_proxy.py

@@ -2,19 +2,19 @@ import asyncio
 import logging
 from typing import List, Optional
 
-from fastapi.staticfiles import StaticFiles
-from fastapi import FastAPI
 import httpx
-from llama_deploy.appserver.deployment_config_parser import DeploymentConfig
-from llama_deploy.appserver.settings import ApiserverSettings
 import websockets
 from fastapi import (
     APIRouter,
+    FastAPI,
     HTTPException,
     Request,
     WebSocket,
 )
 from fastapi.responses import StreamingResponse
+from fastapi.staticfiles import StaticFiles
+from llama_deploy.appserver.settings import ApiserverSettings
+from llama_deploy.core.deployment_config import DeploymentConfig
 from starlette.background import BackgroundTask
 
 logger = logging.getLogger(__name__)
@@ -37,7 +37,7 @@ async def _ws_proxy(ws: WebSocket, upstream_url: str) -> None:
 
     try:
         # Parse subprotocols if present
-        subprotocols: Optional[List[websockets.Subprotocol]] = None
+        subprotocols: List[websockets.Subprotocol] | None = None
         if "sec-websocket-protocol" in ws.headers:
             # Parse comma-separated subprotocols
             subprotocols = [

{llama_deploy_appserver-0.3.0a4 → llama_deploy_appserver-0.3.0a6}/src/llama_deploy/appserver/settings.py

@@ -1,9 +1,9 @@
 import os
 from pathlib import Path
 
+from llama_deploy.core.config import DEFAULT_DEPLOYMENT_FILE_PATH
 from pydantic import Field
 from pydantic_settings import BaseSettings, SettingsConfigDict
-from llama_deploy.core.config import DEFAULT_DEPLOYMENT_FILE_PATH
 
 
 class BootstrapSettings(BaseSettings):
@@ -30,6 +30,10 @@ class BootstrapSettings(BaseSettings):
     deployment_name: str | None = Field(
         default=None, description="The name of the deployment"
     )
+    bootstrap_sdists: str | None = Field(
+        default=None,
+        description="A directory containing tar.gz sdists to install instead of installing the appserver",
+    )
 
 
 class ApiserverSettings(BaseSettings):
@@ -59,6 +63,11 @@ class ApiserverSettings(BaseSettings):
         description="If true, proxy a development UI server instead of serving built assets",
     )
 
+    reload: bool = Field(
+        default=False,
+        description="If true, reload the workflow modules, for use in a dev server environment",
+    )
+
     @property
     def config_parent(self) -> Path:
         return (self.app_root / self.deployment_file_path).parent
@@ -71,6 +80,7 @@ def configure_settings(
     proxy_ui: bool | None = None,
     deployment_file_path: Path | None = None,
     app_root: Path | None = None,
+    reload: bool | None = None,
 ) -> None:
     if proxy_ui is not None:
         settings.proxy_ui = proxy_ui
@@ -83,3 +93,6 @@ def configure_settings(
     if app_root is not None:
         settings.app_root = app_root
         os.environ["LLAMA_DEPLOY_APISERVER_APP_ROOT"] = str(app_root)
+    if reload is not None:
+        settings.reload = reload
+        os.environ["LLAMA_DEPLOY_APISERVER_RELOAD"] = "true" if reload else "false"