llama-deploy-appserver 0.2.7a1__tar.gz → 0.3.0a1__tar.gz

{llama_deploy_appserver-0.2.7a1 → llama_deploy_appserver-0.3.0a1}/PKG-INFO

@@ -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.2.7a1 → llama_deploy_appserver-0.3.0a1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "llama-deploy-appserver"
-version = "0.2.7a1"
+version = "0.3.0a1"
 description = "Application server components for LlamaDeploy"
 readme = "README.md"
 license = { text = "MIT" }
@@ -9,17 +9,14 @@ authors = [
 ]
 requires-python = ">=3.12, <4"
 dependencies = [
-    "asgiref>=3.9.1",
     "llama-index-workflows>=1.1.0",
     "pydantic-settings>=2.10.1",
     "uvicorn>=0.24.0",
-    "prometheus-client>=0.20.0",
-    "python-multipart>=0.0.18,<0.0.19",
     "fastapi>=0.100.0",
     "websockets>=12.0",
-    "gitpython>=3.1.40,<4",
-    "llama-deploy-core>=0.2.7a1,<0.3.0",
+    "llama-deploy-core>=0.3.0a1,<0.4.0",
     "httpx>=0.28.1",
+    "prometheus-fastapi-instrumentator>=7.1.0",
 ]
 
 [build-system]
@@ -32,3 +29,10 @@ module-name = "llama_deploy.appserver"
 
 [tool.uv.sources]
 llama-deploy-core = { workspace = true }
+
+[dependency-groups]
+dev = [
+    "pytest>=8.4.1",
+    "pytest-asyncio>=0.25.3",
+    "respx>=0.22.0",
+]

{llama_deploy_appserver-0.2.7a1 → llama_deploy_appserver-0.3.0a1}/src/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-0.3.0a1/src/llama_deploy/appserver/app.py

@@ -0,0 +1,129 @@
+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 llama_deploy.appserver.workflow_loader import (
+    build_ui,
+    do_install,
+    start_dev_ui_process,
+)
+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,
+)
+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")
+
+
+@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")
+
+
+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):
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=["*"],  # Allows all origins
+        allow_credentials=True,
+        allow_methods=["GET", "POST"],
+        allow_headers=["Content-Type", "Authorization"],
+    )
+
+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-0.3.0a1/src/llama_deploy/appserver/bootstrap.py

@@ -0,0 +1,95 @@
+"""
+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.
+"""
+
+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 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/",
+):
+    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)
+    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__":
+    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

llama_deploy_appserver-0.3.0a1/src/llama_deploy/appserver/deployment.py

@@ -0,0 +1,81 @@
+import asyncio
+import json
+import logging
+from typing import Any, Tuple
+
+from llama_deploy.appserver.types import generate_id
+from llama_deploy.appserver.workflow_loader import DEFAULT_SERVICE_ID
+from workflows import Context, Workflow
+from workflows.handler import WorkflowHandler
+
+
+logger = logging.getLogger()
+
+
+class DeploymentError(Exception): ...
+
+
+class Deployment:
+    def __init__(
+        self,
+        workflows: dict[str, Workflow],
+    ) -> None:
+        """Creates a Deployment instance.
+
+        Args:
+            config: The configuration object defining this deployment
+            root_path: The path on the filesystem used to store deployment data
+            local: Whether the deployment is local. If true, sources won't be synced
+        """
+
+        self._default_service: str | None = workflows.get(DEFAULT_SERVICE_ID)
+        self._service_tasks: list[asyncio.Task] = []
+        # Ready to load services
+        self._workflow_services: dict[str, Workflow] = workflows
+        self._contexts: dict[str, Context] = {}
+        self._handlers: dict[str, WorkflowHandler] = {}
+        self._handler_inputs: dict[str, str] = {}
+
+    @property
+    def default_service(self) -> Workflow | None:
+        return self._default_service
+
+    @property
+    def name(self) -> str:
+        """Returns the name of this deployment."""
+        return self._name
+
+    @property
+    def service_names(self) -> list[str]:
+        """Returns the list of service names in this deployment."""
+        return list(self._workflow_services.keys())
+
+    async def run_workflow(
+        self, service_id: str, session_id: str | None = None, **run_kwargs: dict
+    ) -> Any:
+        workflow = self._workflow_services[service_id]
+        if session_id:
+            context = self._contexts[session_id]
+            return await workflow.run(context=context, **run_kwargs)
+
+        if run_kwargs:
+            return await workflow.run(**run_kwargs)
+
+        return await workflow.run()
+
+    def run_workflow_no_wait(
+        self, service_id: str, session_id: str | None = None, **run_kwargs: dict
+    ) -> Tuple[str, str]:
+        workflow = self._workflow_services[service_id]
+        if session_id:
+            context = self._contexts[session_id]
+            handler = workflow.run(context=context, **run_kwargs)
+        else:
+            handler = workflow.run(**run_kwargs)
+            session_id = generate_id()
+            self._contexts[session_id] = handler.ctx or Context(workflow)
+
+        handler_id = generate_id()
+        self._handlers[handler_id] = handler
+        self._handler_inputs[handler_id] = json.dumps(run_kwargs)
+        return handler_id, session_id

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

@@ -0,0 +1,109 @@
+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
+
+
+@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.0a1/src/llama_deploy/appserver/routers/__init__.py

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