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

llama_deploy/appserver/__main__.py

@@ -1,12 +1,8 @@
 import uvicorn
-from prometheus_client import start_http_server
 
 from .settings import settings
 
 if __name__ == "__main__":
-    if settings.prometheus_enabled:
-        start_http_server(settings.prometheus_port)
-
     uvicorn.run(
         "llama_deploy.appserver.app:app",
         host=settings.host,

llama_deploy/appserver/app.py

@@ -1,24 +1,75 @@
 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
 
 from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
-from fastapi.requests import Request
-from fastapi.responses import JSONResponse, RedirectResponse
+from llama_deploy.appserver.workflow_loader import (
+    build_ui,
+    do_install,
+    start_dev_ui_process,
+)
+import uvicorn
 
-from .routers import deployments_router, status_router
-from .server import lifespan, manager
-from .settings import settings
-from .tracing import configure_tracing
+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,
+)
+from llama_deploy.appserver.routers.ui_proxy import (
+    create_ui_proxy_router,
+    mount_static_files,
+)
+from llama_deploy.appserver.workflow_loader import (
+    load_workflows,
+)
+
+from .deployment import Deployment
+from .stats import apiserver_state
+import webbrowser
 
 logger = logging.getLogger("uvicorn.info")
 
 
-app = FastAPI(lifespan=lifespan)
+@asynccontextmanager
+async def lifespan(app: FastAPI) -> AsyncGenerator[None, Any]:
+    apiserver_state.state("starting")
+
+    config = get_deployment_config()
+
+    workflows = load_workflows(config)
+    deployment = Deployment(workflows)
+    base_router = create_base_router(config.name)
+    deploy_router = create_deployments_router(config.name, deployment)
+    app.include_router(base_router)
+    app.include_router(deploy_router)
+    # proxy UI in dev mode
+    if config.ui is not None:
+        if settings.proxy_ui:
+            ui_router = create_ui_proxy_router(config.name, config.ui.port)
+            app.include_router(ui_router)
+        else:
+            # otherwise serve the pre-built if available
+            mount_static_files(app, config, settings)
+
+    apiserver_state.state("running")
+    yield
+
+    apiserver_state.state("stopped")
+
 
-# Setup tracing
-configure_tracing(settings)
+app = FastAPI(lifespan=lifespan)
+Instrumentator().instrument(app).expose(app)
 
 # Configure CORS middleware if the environment variable is set
 if not os.environ.get("DISABLE_CORS", False):
@@ -30,20 +81,49 @@ if not os.environ.get("DISABLE_CORS", False):
         allow_headers=["Content-Type", "Authorization"],
     )
 
-app.include_router(deployments_router)
-app.include_router(status_router)
-
-
-@app.get("/", response_model=None)
-async def root(request: Request) -> JSONResponse | RedirectResponse:
-    # for local dev, just redirect to the one UI if we have one
-    if len(manager.deployment_names) == 1:
-        deployment = manager.get_deployment(manager.deployment_names[0])
-        if deployment is not None and deployment._ui_server_process is not None:
-            return RedirectResponse(f"deployments/{deployment.name}/ui")
-    return JSONResponse(
-        {
-            "swagger_docs": f"{request.base_url}docs",
-            "status": f"{request.base_url}status",
-        }
+app.include_router(health_router)
+
+
+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
     )
+    if install:
+        do_install()
+    if build:
+        build_ui(settings.config_parent, get_deployment_config())
+
+    ui_process = None
+    if proxy_ui:
+        ui_process = start_dev_ui_process(
+            settings.config_parent, settings.port, get_deployment_config()
+        )
+    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()
+
+        uvicorn.run(
+            "llama_deploy.appserver.app:app",
+            host=settings.host,
+            port=settings.port,
+            reload=reload,
+        )
+    finally:
+        if ui_process is not None:
+            ui_process.terminate()

llama_deploy/appserver/bootstrap.py

@@ -4,40 +4,92 @@ Bootstraps an application from a remote github repository given environment vari
 This just sets up the files from the repository. It's more of a build process, does not start an application.
 """
 
-import asyncio
+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.workflow_loader import build_ui, do_install
 from llama_deploy.core.git.git_util import (
     clone_repo,
 )
-from pydantic import Field
-from pydantic_settings import BaseSettings, SettingsConfigDict
+from llama_deploy.appserver.app import start_server
+from llama_deploy.appserver.settings import BootstrapSettings, configure_settings
 
+import argparse
 
-class BootstrapSettings(BaseSettings):
-    model_config = SettingsConfigDict(env_prefix="LLAMA_DEPLOY_")
-    git_url: str = Field(..., description="The URL of the git repository to clone")
-    git_token: str | None = Field(
-        default=None, description="The token to use to clone the git repository"
-    )
-    git_ref: str | None = Field(
-        default=None, description="The git reference to checkout"
-    )
-    git_sha: str | None = Field(default=None, description="The git SHA to checkout")
-    deployment_file_path: str = Field(
-        default="llama_deploy.yaml", description="The path to the deployment file"
-    )
-    deployment_name: str | None = Field(
-        default=None, description="The name of the deployment"
-    )
 
-
-async def main():
-    settings = BootstrapSettings()
+def bootstrap_app_from_repo(
+    clone: bool = False,
+    build: bool = False,
+    serve: bool = False,
+    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
-    clone_repo(settings.git_url, "/app/", settings.git_token)
+    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)
+    configure_settings(
+        app_root=Path(target_dir),
+        deployment_file_path=Path(bootstrap_settings.deployment_file_path),
+    )
+
+    built = True
+    if build:
+        do_install()
+        built = build_ui(settings.config_parent, get_deployment_config())
+
+    if serve:
+        start_server(
+            proxy_ui=not built,
+        )
     pass
 
 
 if __name__ == "__main__":
-    asyncio.run(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