llama-deploy-appserver 0.3.0a4__py3-none-any.whl → 0.3.0a6__py3-none-any.whl

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/bootstrap.py

@@ -1,100 +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, does not start an application.
+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.settings import settings
+
 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,
-    do_install,
+    inject_appserver_into_target,
+    install_ui,
     load_environment_variables,
 )
 from llama_deploy.core.git.git_util import (
     clone_repo,
 )
-from llama_deploy.appserver.app import start_server
-from llama_deploy.appserver.settings import BootstrapSettings, configure_settings
-
-import argparse
 
 
 def bootstrap_app_from_repo(
-    clone: bool = False,
-    build: bool = False,
-    serve: bool = False,
-    target_dir: str = "/opt/app/",
+    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
-    if clone:
-        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)
+
+    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)
 
-    built = True
-    load_environment_variables(get_deployment_config(), Path(target_dir))
-    if build:
-        do_install()
-        built = build_ui(settings.config_parent, get_deployment_config())
+    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)
 
-    if serve:
-        start_server(
-            proxy_ui=not built,
-        )
     pass
 
 
 if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-        "--clone",
-        action=argparse.BooleanOptionalAction,
-        default=False,
-        help="Clone the repository before bootstrapping (use --no-clone to disable)",
-    )
-    parser.add_argument(
-        "--build",
-        action=argparse.BooleanOptionalAction,
-        default=False,
-        help="Build the UI/assets (use --no-build to disable)",
-    )
-    parser.add_argument(
-        "--serve",
-        action=argparse.BooleanOptionalAction,
-        default=False,
-        help="Start the API server after bootstrap (use --no-serve to disable)",
-    )
-    args = parser.parse_args()
-    try:
-        bootstrap_app_from_repo(
-            clone=args.clone,
-            build=args.build,
-            serve=args.serve,
-        )
-    except Exception as e:
-        import logging
-
-        logging.exception("Error during bootstrap. Pausing for debugging.")
-        import time
-
-        time.sleep(1000000)
-        raise e
+    bootstrap_app_from_repo()

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/deployment_config_parser.py

@@ -1,103 +1,7 @@
 import functools
-from pathlib import Path
-from typing import Any
 
-
-from llama_deploy.appserver.settings import settings, BootstrapSettings
-import yaml
-from pydantic import BaseModel, ConfigDict, Field, model_validator
-
-
-class ServiceSource(BaseModel):
-    """Configuration for where to load the workflow or other source. Path is relative to the config file its declared within."""
-
-    location: str
-
-    @model_validator(mode="before")
-    @classmethod
-    def validate_fields(cls, data: Any) -> Any:
-        if isinstance(data, dict):
-            if "name" in data:
-                data["location"] = data.pop("name")
-        return data
-
-
-class Service(BaseModel):
-    """Configuration for a single service."""
-
-    source: ServiceSource | None = Field(None)
-    import_path: str | None = Field(None)
-    env: dict[str, str] | None = Field(None)
-    env_files: list[str] | None = Field(None)
-    python_dependencies: list[str] | None = Field(None)
-
-    @model_validator(mode="before")
-    @classmethod
-    def validate_fields(cls, data: Any) -> Any:
-        if isinstance(data, dict):
-            # Handle YAML aliases
-            if "path" in data:
-                data["import_path"] = data.pop("path")
-            if "import-path" in data:
-                data["import_path"] = data.pop("import-path")
-            if "env-files" in data:
-                data["env_files"] = data.pop("env-files")
-
-        return data
-
-    def module_location(self) -> tuple[str, str]:
-        """
-        Parses the import path, and target, discarding legacy file path portion, if any
-
-        "src/module.workflow:my_workflow" -> ("module.workflow", "my_workflow")
-        """
-        module_name, workflow_name = self.import_path.split(":")
-        return Path(module_name).name, workflow_name
-
-
-class UIService(Service):
-    port: int = Field(
-        default=3000,
-        description="The TCP port to use for the nextjs server",
-    )
-
-
-class DeploymentConfig(BaseModel):
-    """Model definition mapping a deployment config file."""
-
-    model_config = ConfigDict(populate_by_name=True, extra="ignore")
-
-    name: str
-    default_service: str | None = Field(None)
-    services: dict[str, Service]
-    ui: UIService | None = None
-
-    @model_validator(mode="before")
-    @classmethod
-    def validate_fields(cls, data: Any) -> Any:
-        # Handle YAML aliases
-        if isinstance(data, dict):
-            if "default-service" in data:
-                data["default_service"] = data.pop("default-service")
-
-        return data
-
-    @classmethod
-    def from_yaml_bytes(cls, src: bytes) -> "DeploymentConfig":
-        """Read config data from bytes containing yaml code."""
-        config = yaml.safe_load(src) or {}
-        return cls(**config)
-
-    @classmethod
-    def from_yaml(cls, path: Path, name: str | None = None) -> "DeploymentConfig":
-        """Read config data from a yaml file."""
-        with open(path, "r") as yaml_file:
-            config = yaml.safe_load(yaml_file) or {}
-
-        instance = cls(**config)
-        if name:
-            instance.name = name
-        return instance
+from llama_deploy.appserver.settings import BootstrapSettings, settings
+from llama_deploy.core.deployment_config import DeploymentConfig
 
 
 @functools.lru_cache

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/routers/__init__.py

@@ -1,5 +1,5 @@
 from .deployments import create_deployments_router
-from .ui_proxy import create_ui_proxy_router
 from .status import health_router
+from .ui_proxy import create_ui_proxy_router
 
 __all__ = ["create_deployments_router", "create_ui_proxy_router", "health_router"]

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/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"

llama_deploy/appserver/workflow_loader.py

@@ -1,146 +1,61 @@
+import functools
 import importlib
-from pathlib import Path
 import logging
+import os
 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 importlib.metadata import version as pkg_version
+from pathlib import Path
+
+from dotenv import dotenv_values
 from llama_deploy.appserver.deployment_config_parser import (
     DeploymentConfig,
-    get_deployment_config,
 )
+from llama_deploy.appserver.process_utils import run_process, spawn_process
+from llama_deploy.core.ui_build import ui_build_output_path
+from packaging.version import InvalidVersion, Version
 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 = {}
+
+    # Pre-compute per-service import info
+    per_service: list[tuple[str, str]] = []
     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()
+        raw_mod_path, workflow_name = service_config.import_path.split(":", 1)
+        module_name = Path(raw_mod_path).name
+        per_service.append((service_id, workflow_name))
+
+    for service_id, workflow_name in per_service:
+        import_path = config.services[service_id].import_path
+        if import_path is None:
+            continue
+        raw_mod_path = import_path.split(":", 1)[0]
+        module_name = Path(raw_mod_path).name
+
         module = importlib.import_module(module_name)
-        workflow_services[service_id] = getattr(module, workflow_name)
+
+        if hasattr(module, workflow_name):
+            workflow = getattr(module, workflow_name)
+            if not isinstance(workflow, Workflow):
+                logger.warning(
+                    f"Workflow {workflow_name} in {module_name} is not a Workflow object",
+                )
+            workflow_services[service_id] = workflow
+        else:
+            logger.warning("Workflow %s not found in %s", workflow_name, module_name)
 
     if config.default_service:
         if config.default_service in workflow_services:
@@ -169,37 +84,202 @@ def load_environment_variables(config: DeploymentConfig, source_root: Path) -> N
                 os.environ[key] = value
 
 
-def install_python_dependencies(config: DeploymentConfig, source_root: Path) -> None:
+@functools.cache
+def are_we_editable_mode() -> bool:
     """
-    Sync the deployment to the base path.
+    Check if we're in editable mode.
+    """
+    # Heuristic: if the package path does not include 'site-packages', treat as editable
+    top_level_pkg = "llama_deploy.appserver"
+    try:
+        pkg = importlib.import_module(top_level_pkg)
+        pkg_path = Path(getattr(pkg, "__file__", "")).resolve()
+        if not pkg_path.exists():
+            return False
+
+        return "site-packages" not in pkg_path.parts
+    except Exception:
+        return False
+
+
+def inject_appserver_into_target(
+    config: DeploymentConfig, source_root: Path, sdists: list[Path] | None = None
+) -> None:
+    """
+    Ensures uv, and uses it to add the appserver as a dependency to the target app.
+    - If sdists are provided, they will be installed directly for offline-ish installs (still fetches dependencies)
+    - If the appserver is currently editable, it will be installed directly from the source repo
+    - otherwise fetches the current version from pypi
+
+    Args:
+        config: The deployment config
+        source_root: The root directory of the deployment
+        sdists: A list of tar.gz sdists files to install instead of installing the appserver
     """
     path = _find_install_target(source_root, config)
-    if path is not None:
-        logger.info(f"Installing python dependencies from {path}")
-        _ensure_uv_available()
-        _install_to_current_python(path, source_root)
+    if path is None:
+        logger.warning(
+            "No python_dependencies and no root pyproject.toml; skipping dependency installation."
+        )
+        return
+    logger.info(f"Installing ensuring venv at {path} and adding appserver to it")
+    _ensure_uv_available()
+    _add_appserver_if_missing(path, source_root, sdists=sdists)
+
+
+def _get_installed_version_within_target(path: Path) -> Version | None:
+    try:
+        result = subprocess.check_output(
+            [
+                "uv",
+                "run",
+                "python",
+                "-c",
+                """from importlib.metadata import version; print(version("llama-deploy-appserver"))""",
+            ],
+            cwd=path,
+        )
+        try:
+            return Version(result.decode("utf-8").strip())
+        except InvalidVersion:
+            return None
+    except subprocess.CalledProcessError:
+        return None
+
+
+def _get_current_version() -> Version:
+    return Version(pkg_version("llama-deploy-appserver"))
+
+
+def _is_missing_or_outdated(path: Path) -> Version | None:
+    """
+    returns the current version if the installed version is missing or outdated, otherwise None
+    """
+    installed = _get_installed_version_within_target(path)
+    current = _get_current_version()
+    if installed is None or installed < current:
+        return current
+    return None
+
+
+def _add_appserver_if_missing(
+    path: Path,
+    source_root: Path,
+    save_version: bool = False,
+    sdists: list[Path] | None = None,
+) -> None:
+    """
+    Add the appserver to the venv if it's not already there.
+    """
+
+    if not (source_root / path / "pyproject.toml").exists():
+        logger.warning(
+            f"No pyproject.toml found at {source_root / path}, skipping appserver injection. The server will likely not be able to install your workflows."
+        )
+        return
+
+    def ensure_venv(path: Path) -> Path:
+        venv_path = source_root / path / ".venv"
+        if not venv_path.exists():
+            run_process(
+                ["uv", "venv", str(venv_path)],
+                cwd=source_root / path,
+                prefix="[uv venv]",
+                color_code="36",
+            )
+        return venv_path
+
+    if sdists:
+        run_process(
+            ["uv", "pip", "install"]
+            + [str(s.absolute()) for s in sdists]
+            + ["--prefix", str(ensure_venv(path))],
+            cwd=source_root / path,
+            prefix="[uv pip install]",
+            color_code="36",
+        )
+    elif are_we_editable_mode():
+        pyproject = _find_development_pyproject()
+        if pyproject is None:
+            raise RuntimeError("No pyproject.toml found in llama-deploy-appserver")
+        target = f"file://{str(pyproject.relative_to(source_root.resolve() / path, walk_up=True))}"
+        run_process(
+            [
+                "uv",
+                "pip",
+                "install",
+                "--reinstall",
+                target,
+                "--prefix",
+                str(ensure_venv(path)),
+            ],
+            cwd=source_root / path,
+            prefix="[uv pip install]",
+            color_code="36",
+        )
+    else:
+        version = _is_missing_or_outdated(path)
+        if version is not None:
+            if save_version:
+                run_process(
+                    ["uv", "add", f"llama-deploy-appserver>={version}"],
+                    cwd=source_root / path,
+                    prefix="[uv add]",
+                    color_code="36",
+                    line_transform=_exclude_venv_warning,
+                )
+            else:
+                run_process(
+                    [
+                        "uv",
+                        "pip",
+                        "install",
+                        f"llama-deploy-appserver=={version}",
+                        "--prefix",
+                        str(ensure_venv(path)),
+                    ],
+                    cwd=source_root / path,
+                    prefix="[uv pip install]",
+                    color_code="36",
+                )
 
 
-def _find_install_target(base: Path, config: DeploymentConfig) -> str | None:
-    path: str | None = None
+def _find_development_pyproject() -> Path | None:
+    dir = Path(__file__).parent.resolve()
+    while not (dir / "pyproject.toml").exists():
+        dir = dir.parent
+        if dir == dir.root:
+            return None
+    return dir
+
+
+def find_python_pyproject(base: Path, config: DeploymentConfig) -> Path | None:
+    path: Path | 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]
+            this_path = 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
+            else:
+                path = this_path
     if path is None:
         if (base / "pyproject.toml").exists():
-            path = "."
+            path = Path(".")
     return path
 
 
+def _exclude_venv_warning(line: str) -> str | None:
+    if "use `--active` to target the active environment instead" in line:
+        return None
+    return line
+
+
 def _ensure_uv_available() -> None:
     # Check if uv is available on the path
     uv_available = False
@@ -215,7 +295,7 @@ def _ensure_uv_available() -> None:
     if not uv_available:
         # bootstrap uv with pip
         try:
-            _run_with_prefix(
+            run_process(
                 [
                     sys.executable,
                     "-m",
@@ -223,7 +303,7 @@ def _ensure_uv_available() -> None:
                     "install",
                     "uv",
                 ],
-                prefix="[pip]",
+                prefix="[python -m pip]",
                 color_code="31",  # red
             )
         except subprocess.CalledProcessError as e:
@@ -231,41 +311,12 @@ def _ensure_uv_available() -> None:
             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")
-    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 _find_install_target(base: Path, config: DeploymentConfig) -> Path | None:
+    return find_python_pyproject(base, config)
 
 
 def _validate_path_is_safe(
-    path: str, source_root: Path, path_type: str = "path"
+    path: Path, source_root: Path, path_type: str = "path"
 ) -> None:
     """Validates that a path is within the source root to prevent path traversal attacks.
 
@@ -290,12 +341,12 @@ def _validate_path_is_safe(
 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 "."
+    path = Path(config.ui.source.location) if config.ui.source else Path(".")
     _validate_path_is_safe(path, config_parent, "ui_source")
-    _run_with_prefix(
+    run_process(
         ["pnpm", "install"],
         cwd=config_parent / path,
-        prefix="[pnpm-install]",
+        prefix="[pnpm install]",
         color_code="33",
     )
 
@@ -315,23 +366,19 @@ def build_ui(config_parent: Path, config: DeploymentConfig) -> bool:
     """
     if config.ui is None:
         return False
-    path = config.ui.source.location if config.ui.source else "."
+    path = Path(config.ui.source.location) if config.ui.source else Path(".")
     _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:
+    has_build = ui_build_output_path(config_parent, config)
+    if has_build is None:
         return False
 
-    _run_with_prefix(
-        ["pnpm", "build"],
+    run_process(
+        ["pnpm", "run", "build"],
         cwd=config_parent / path,
         env=env,
-        prefix="[pnpm-build]",
+        prefix="[pnpm run build]",
         color_code="34",
     )
     return True
@@ -362,19 +409,20 @@ def start_dev_ui_process(
     # 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}
+    line_counter = 0
 
     def _transform(line: str) -> str:
-        if line_counter["n"] < 20:
+        nonlocal line_counter
+        if line_counter < 20:
             line = line.replace(f":{ui.port}", f":{main_port}")
-        line_counter["n"] += 1
+        line_counter += 1
         return line
 
-    return _start_streaming_process(
+    return spawn_process(
         ["pnpm", "run", "dev"],
         cwd=root / (ui.source.location if ui.source else "."),
         env=env,
-        prefix="[ui-server]",
+        prefix="[pnpm run dev]",
         color_code="35",  # magenta
         line_transform=_transform,
     )

{llama_deploy_appserver-0.3.0a4.dist-info → llama_deploy_appserver-0.3.0a6.dist-info}/METADATA

@@ -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.0a6.dist-info/RECORD

@@ -0,0 +1,18 @@
+llama_deploy/appserver/__init__.py,sha256=e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855,0
+llama_deploy/appserver/__main__.py,sha256=32eff329cadb4f883c9df3a1b2bcb908d5adde765e7c7e761d25b7df4827b9ca,196
+llama_deploy/appserver/app.py,sha256=9a4b453f65f7004413dee654baf6d3fb7cc359730b01c271449a66b0efc4a5e1,5628
+llama_deploy/appserver/bootstrap.py,sha256=b2b032af98f477c1e3b515442251890027f4a83c5e73c19af43b36a2c5e1e479,2361
+llama_deploy/appserver/deployment.py,sha256=8dc31107a8dbe30feb3d414540a5cbd4753faffd617fdab69407ee19a0ecd1bb,2670
+llama_deploy/appserver/deployment_config_parser.py,sha256=160f6ead40028de8d92af927ac8427c13e62fdfaccbcaf605906d0645e06ba74,455
+llama_deploy/appserver/process_utils.py,sha256=4fae398607fd84187343b7aeefb16d7314366cbec91c82f0fbb76479386104fb,5668
+llama_deploy/appserver/routers/__init__.py,sha256=ee2d14ebf4b067c844947ed1cc98186456e8bfa4919282722eaaf8cca345a138,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=8b034dd2615bc6f992b0e825c644bdef256ee2b46eac00184bf7dedfdb7a2309,7164
+llama_deploy/appserver/settings.py,sha256=46d209715f4e143eb1f4a44906bacfbd8eb79593d54b9de29fb49e7edc6a2a51,3326
+llama_deploy/appserver/stats.py,sha256=1f3989f6705a6de3e4d61ee8cdd189fbe04a2c53ec5e720b2e5168acc331427f,691
+llama_deploy/appserver/types.py,sha256=4edc991aafb6b8497f068d12387455df292da3ff8440223637641ab1632553ec,2133
+llama_deploy/appserver/workflow_loader.py,sha256=ba863d36cef3bc65ce1227ed3302b9e569e2765e6dd53ba9dcbbf30c0800c1c8,14168
+llama_deploy_appserver-0.3.0a6.dist-info/WHEEL,sha256=66530aef82d5020ef5af27ae0123c71abb9261377c5bc519376c671346b12918,79
+llama_deploy_appserver-0.3.0a6.dist-info/METADATA,sha256=ad52ee37a3964e138ec2f64995dd3698ac0a86ae921476ed6aedcd0e73dca01e,777
+llama_deploy_appserver-0.3.0a6.dist-info/RECORD,,

llama_deploy_appserver-0.3.0a4.dist-info/RECORD

@@ -1,17 +0,0 @@
-llama_deploy/appserver/__init__.py,sha256=e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855,0
-llama_deploy/appserver/__main__.py,sha256=32eff329cadb4f883c9df3a1b2bcb908d5adde765e7c7e761d25b7df4827b9ca,196
-llama_deploy/appserver/app.py,sha256=b426223a4f1a7077c3705e818938ecd7696fa8cc625304f1ae6fe1a687195311,3710
-llama_deploy/appserver/bootstrap.py,sha256=e98e58ff38c44eb68ecf2ea3644d8376111d0e18e650589d6aef29e4caef1e15,3107
-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=26cf958f8d1ec5fcb266ce465292d883b4f7c64b2832abca04bbf69ae303393d,12160
-llama_deploy_appserver-0.3.0a4.dist-info/WHEEL,sha256=66530aef82d5020ef5af27ae0123c71abb9261377c5bc519376c671346b12918,79
-llama_deploy_appserver-0.3.0a4.dist-info/METADATA,sha256=a50e0888f6a99eec2c09c0c1d7b0b84912920470bfb431e32070b31608c42956,746
-llama_deploy_appserver-0.3.0a4.dist-info/RECORD,,