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

llama_deploy/appserver/__main__.py

@@ -0,0 +1,14 @@
+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,
+        port=settings.port,
+    )

llama_deploy/appserver/app.py

@@ -0,0 +1,49 @@
+import logging
+import os
+
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.requests import Request
+from fastapi.responses import JSONResponse, RedirectResponse
+
+from .routers import deployments_router, status_router
+from .server import lifespan, manager
+from .settings import settings
+from .tracing import configure_tracing
+
+
+logger = logging.getLogger("uvicorn.info")
+
+
+app = FastAPI(lifespan=lifespan)
+
+# Setup tracing
+configure_tracing(settings)
+
+# 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(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",
+        }
+    )

llama_deploy/appserver/bootstrap.py

@@ -0,0 +1,43 @@
+"""
+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 asyncio
+from llama_deploy.core.git.git_util import (
+    clone_repo,
+)
+from pydantic import Field
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+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()
+    # 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)
+    pass
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

llama_deploy/appserver/client/__init__.py

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

llama_deploy/appserver/client/base.py

@@ -0,0 +1,30 @@
+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

@@ -0,0 +1,49 @@
+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

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

llama_deploy/appserver/client/models/apiserver.py

@@ -0,0 +1,356 @@
+"""Client functionalities to operate on the API Server.
+
+This module allows the client to use all the functionalities
+from the LlamaDeploy API Server. For this to work, the API
+Server must be up and its URL (by default `http://localhost:4501`)
+reachable by the host executing the client code.
+"""
+
+import asyncio
+import json
+from typing import Any, AsyncGenerator, TextIO
+
+import httpx
+from llama_deploy.appserver.types import (
+    EventDefinition,
+    SessionDefinition,
+    Status,
+    StatusEnum,
+    TaskDefinition,
+    TaskResult,
+)
+from pydantic import Field
+from workflows.context import JsonSerializer
+from workflows.events import Event
+
+from .model import Collection, Model
+
+
+class SessionCollection(Collection):
+    """A model representing a collection of session for a given deployment."""
+
+    deployment_id: str = Field(
+        description="The ID of the deployment containing the sessions."
+    )
+
+    async def delete(self, session_id: str) -> None:
+        """Deletes the session with the provided `session_id`.
+
+        Args:
+            session_id: The id of the session that will be removed
+
+        Raises:
+            HTTPException: If the session couldn't be found with the id provided.
+        """
+        delete_url = f"{self.client.api_server_url}/deployments/{self.deployment_id}/sessions/delete"
+
+        await self.client.request(
+            "POST",
+            delete_url,
+            params={"session_id": session_id},
+            verify=not self.client.disable_ssl,
+            timeout=self.client.timeout,
+        )
+
+    async def create(self) -> SessionDefinition:
+        """Create a new session."""
+        create_url = f"{self.client.api_server_url}/deployments/{self.deployment_id}/sessions/create"
+
+        r = await self.client.request(
+            "POST",
+            create_url,
+            verify=not self.client.disable_ssl,
+            timeout=self.client.timeout,
+        )
+
+        return SessionDefinition(**r.json())
+
+    async def list(self) -> list[SessionDefinition]:
+        """Returns a collection of all the sessions in the given deployment."""
+        sessions_url = (
+            f"{self.client.api_server_url}/deployments/{self.deployment_id}/sessions"
+        )
+        r = await self.client.request(
+            "GET",
+            sessions_url,
+            verify=not self.client.disable_ssl,
+            timeout=self.client.timeout,
+        )
+
+        return r.json()
+
+    async def get(self, id: str) -> SessionDefinition:
+        """Gets a deployment by id."""
+        get_url = f"{self.client.api_server_url}/deployments/{self.deployment_id}/sessions/{id}"
+        await self.client.request(
+            "GET",
+            get_url,
+            verify=not self.client.disable_ssl,
+            timeout=self.client.timeout,
+        )
+        model_class = self._prepare(SessionDefinition)
+        return model_class(client=self.client, id=id)
+
+
+class Task(Model):
+    """A model representing a task belonging to a given session in the given deployment."""
+
+    deployment_id: str = Field(
+        description="The ID of the deployment this task belongs to."
+    )
+    session_id: str = Field(description="The ID of the session this task belongs to.")
+
+    async def results(self) -> TaskResult | None:
+        """Returns the result of a given task."""
+        results_url = f"{self.client.api_server_url}/deployments/{self.deployment_id}/tasks/{self.id}/results"
+
+        r = await self.client.request(
+            "GET",
+            results_url,
+            verify=not self.client.disable_ssl,
+            params={"session_id": self.session_id},
+            timeout=self.client.timeout,
+        )
+        if r.json():
+            return TaskResult.model_validate(r.json())
+        return None
+
+    async def send_event(self, ev: Event, service_name: str) -> EventDefinition:
+        """Sends a human response event."""
+        url = f"{self.client.api_server_url}/deployments/{self.deployment_id}/tasks/{self.id}/events"
+
+        serializer = JsonSerializer()
+        event_def = EventDefinition(
+            event_obj_str=serializer.serialize(ev), service_id=service_name
+        )
+
+        r = await self.client.request(
+            "POST",
+            url,
+            verify=not self.client.disable_ssl,
+            params={"session_id": self.session_id},
+            json=event_def.model_dump(),
+            timeout=self.client.timeout,
+        )
+        return EventDefinition.model_validate(r.json())
+
+    async def events(self) -> AsyncGenerator[dict[str, Any], None]:  # pragma: no cover
+        """Returns a generator object to consume the events streamed from a service."""
+        events_url = f"{self.client.api_server_url}/deployments/{self.deployment_id}/tasks/{self.id}/events"
+
+        while True:
+            try:
+                async with httpx.AsyncClient(
+                    verify=not self.client.disable_ssl
+                ) as client:
+                    async with client.stream(
+                        "GET", events_url, params={"session_id": self.session_id}
+                    ) as response:
+                        response.raise_for_status()
+                        async for line in response.aiter_lines():
+                            json_line = json.loads(line)
+                            yield json_line
+                        break  # Exit the function if successful
+            except httpx.HTTPStatusError as e:
+                if e.response.status_code != 404:
+                    raise  # Re-raise if it's not a 404 error
+                await asyncio.sleep(self.client.poll_interval)
+
+
+class TaskCollection(Collection):
+    """A model representing a collection of tasks for a given deployment."""
+
+    deployment_id: str = Field(
+        description="The ID of the deployment these tasks belong to."
+    )
+
+    async def run(self, task: TaskDefinition) -> Any:
+        """Runs a task and returns the results once it's done.
+
+        Args:
+            task: The definition of the task we want to run.
+        """
+        run_url = (
+            f"{self.client.api_server_url}/deployments/{self.deployment_id}/tasks/run"
+        )
+        if task.session_id:
+            run_url += f"?session_id={task.session_id}"
+
+        r = await self.client.request(
+            "POST",
+            run_url,
+            verify=not self.client.disable_ssl,
+            json=task.model_dump(),
+            timeout=self.client.timeout,
+        )
+
+        return r.json()
+
+    async def create(self, task: TaskDefinition) -> Task:
+        """Runs a task returns it immediately, without waiting for the results."""
+        create_url = f"{self.client.api_server_url}/deployments/{self.deployment_id}/tasks/create"
+
+        r = await self.client.request(
+            "POST",
+            create_url,
+            verify=not self.client.disable_ssl,
+            json=task.model_dump(),
+            timeout=self.client.timeout,
+        )
+        response_fields = r.json()
+
+        model_class = self._prepare(Task)
+        return model_class(
+            client=self.client,
+            deployment_id=self.deployment_id,
+            id=response_fields["task_id"],
+            session_id=response_fields["session_id"],
+        )
+
+    async def list(self) -> list[Task]:
+        """Returns the list of tasks from this collection."""
+        tasks_url = (
+            f"{self.client.api_server_url}/deployments/{self.deployment_id}/tasks"
+        )
+        r = await self.client.request(
+            "GET",
+            tasks_url,
+            verify=not self.client.disable_ssl,
+            timeout=self.client.timeout,
+        )
+        task_model_class = self._prepare(Task)
+        items = {
+            "id": task_model_class(
+                client=self.client,
+                id=task_def.task_id,
+                session_id=task_def.session_id,
+                deployment_id=self.deployment_id,
+            )
+            for task_def in r.json()
+        }
+        model_class = self._prepare(TaskCollection)
+        return model_class(
+            client=self.client, deployment_id=self.deployment_id, items=items
+        )
+
+
+class Deployment(Model):
+    """A model representing a deployment."""
+
+    @property
+    def tasks(self) -> TaskCollection:
+        """Returns a collection of tasks from all the sessions in the given deployment."""
+
+        model_class = self._prepare(TaskCollection)
+        return model_class(client=self.client, deployment_id=self.id, items={})
+
+    @property
+    def sessions(self) -> SessionCollection:
+        """Returns a collection of all the sessions in the given deployment."""
+
+        coll_model_class = self._prepare(SessionCollection)
+        return coll_model_class(client=self.client, deployment_id=self.id, items={})
+
+
+class DeploymentCollection(Collection):
+    """A model representing a collection of deployments currently active."""
+
+    async def create(
+        self, config: TextIO, base_path: str, reload: bool = False, local: bool = False
+    ) -> Deployment:
+        """Creates a new deployment from a deployment file.
+
+        If `reload` is true, an existing deployment will be reloaded, otherwise
+        an error will be raised.
+
+        If `local` is true, the sync managers won't attempt at syncing data.
+        This is mostly for supporting local development.
+
+        Example:
+            ```
+            with open("deployment.yml") as f:
+                await client.apiserver.deployments.create(f)
+            ```
+        """
+        create_url = f"{self.client.api_server_url}/deployments/create"
+
+        files = {"config_file": config.read()}
+        r = await self.client.request(
+            "POST",
+            create_url,
+            files=files,
+            params={"reload": reload, "local": local, "base_path": base_path},
+            verify=not self.client.disable_ssl,
+            timeout=self.client.timeout,
+        )
+
+        model_class = self._prepare(Deployment)
+        return model_class(client=self.client, id=r.json().get("name"))
+
+    async def get(self, id: str) -> Deployment:
+        """Gets a deployment by id."""
+        get_url = f"{self.client.api_server_url}/deployments/{id}"
+        # Current version of apiserver doesn't returns anything useful in this endpoint, let's just ignore it
+        await self.client.request(
+            "GET",
+            get_url,
+            verify=not self.client.disable_ssl,
+            timeout=self.client.timeout,
+        )
+        model_class = self._prepare(Deployment)
+        return model_class(client=self.client, id=id)
+
+    async def list(self) -> list[Deployment]:
+        """Return a list of Deployment instances for this collection."""
+        deployments_url = f"{self.client.api_server_url}/deployments/"
+        r = await self.client.request("GET", deployments_url)
+        model_class = self._prepare(Deployment)
+        deployments = [model_class(client=self.client, id=name) for name in r.json()]
+        return deployments
+
+
+class ApiServer(Model):
+    """A model representing the API Server instance."""
+
+    async def status(self) -> Status:
+        """Returns the status of the API Server."""
+        status_url = f"{self.client.api_server_url}/status/"
+
+        try:
+            r = await self.client.request(
+                "GET",
+                status_url,
+                verify=not self.client.disable_ssl,
+                timeout=self.client.timeout,
+            )
+        except httpx.ConnectError:
+            return Status(
+                status=StatusEnum.DOWN,
+                status_message="API Server is down",
+            )
+
+        if r.status_code >= 400:
+            body = r.json()
+            return Status(status=StatusEnum.UNHEALTHY, status_message=r.text)
+
+        description = "LlamaDeploy is up and running."
+        body = r.json()
+        deployments = body.get("deployments") or []
+        if deployments:
+            description += "\nActive deployments:"
+            for d in deployments:
+                description += f"\n- {d}"
+        else:
+            description += "\nCurrently there are no active deployments"
+
+        return Status(
+            status=StatusEnum.HEALTHY,
+            status_message=description,
+            deployments=deployments,
+        )
+
+    @property
+    def deployments(self) -> DeploymentCollection:
+        """Returns a collection of deployments currently active in the API Server."""
+        model_class = self._prepare(DeploymentCollection)
+        return model_class(client=self.client, items={})

llama_deploy/appserver/client/models/model.py

@@ -0,0 +1,82 @@
+import asyncio
+import inspect
+from typing import Any, AsyncGenerator, Callable, Generic, TypeVar
+
+from asgiref.sync import async_to_sync
+from llama_deploy.appserver.client.base import _BaseClient
+from pydantic import BaseModel, ConfigDict, Field, PrivateAttr
+from typing_extensions import ParamSpec
+
+
+class _Base(BaseModel):
+    """The base model provides fields and functionalities common to derived models and collections."""
+
+    client: _BaseClient = Field(exclude=True)
+    _instance_is_sync: bool = PrivateAttr(default=False)
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    def _prepare(self, _class: type) -> type:
+        if self._instance_is_sync:
+            return make_sync(_class)
+        return _class
+
+
+T = TypeVar("T", bound=_Base)
+
+
+class Model(_Base):
+    id: str
+
+
+class Collection(_Base, Generic[T]):
+    """A generic container of items of the same model type."""
+
+    items: dict[str, T]
+
+    def get(self, id: str) -> T:
+        """Returns an item from the collection."""
+        return self.items[id]
+
+    async def list(self) -> list[T]:
+        """Returns a list of all the items in the collection."""
+        return [self.get(id) for id in self.items.keys()]
+
+
+# Generic type for what's returned by the async generator
+_G = TypeVar("_G")
+# Generic parameter for the wrapped generator method
+_P = ParamSpec("_P")
+# Generic parameter for the wrapped generator method return value
+_R = TypeVar("_R")
+
+
+async def _async_gen_to_list(async_gen: AsyncGenerator[_G, None]) -> list[_G]:
+    return [item async for item in async_gen]
+
+
+def make_sync(_class: type[T]) -> Any:
+    """Wraps the methods of the given model class so that they can be called without `await`."""
+
+    class ModelWrapper(_class):  # type: ignore
+        _instance_is_sync: bool = True
+
+    def generator_wrapper(
+        func: Callable[_P, AsyncGenerator[_G, None]],  # ty: ignore[invalid-type-form] - https://github.com/astral-sh/ty/issues/157
+        /,
+        *args: Any,
+        **kwargs: Any,
+    ) -> Callable[_P, list[_G]]:  # ty: ignore[invalid-type-form] - https://github.com/astral-sh/ty/issues/157
+        def new_func(*fargs: Any, **fkwargs: Any) -> list[_G]:
+            return asyncio.run(_async_gen_to_list(func(*fargs, **fkwargs)))
+
+        return new_func
+
+    for name, method in _class.__dict__.items():
+        # Only wrap async public methods
+        if inspect.isasyncgenfunction(method):
+            setattr(ModelWrapper, name, generator_wrapper(method))
+        elif asyncio.iscoroutinefunction(method) and not name.startswith("_"):
+            setattr(ModelWrapper, name, async_to_sync(method))
+
+    return ModelWrapper