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

llama_deploy/appserver/client/models/apiserver.py

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

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

llama_deploy/appserver/run_autodeploy.py

@@ -1,141 +0,0 @@
-import os
-import shutil
-import subprocess
-from pathlib import Path
-
-import uvicorn
-import yaml
-from prometheus_client import start_http_server
-
-from llama_deploy.appserver.settings import settings
-
-CLONED_REPO_FOLDER = Path("cloned_repo")
-RC_PATH = Path("/data")
-
-
-def run_process(args: list[str], cwd: str | None = None) -> None:
-    kwargs = {
-        "args": args,
-        "capture_output": True,
-        "text": True,
-        "check": False,
-    }
-    if cwd:
-        kwargs["cwd"] = cwd
-    process = subprocess.run(**kwargs)  # type: ignore
-    if process.returncode != 0:
-        stderr = process.stderr or ""
-        raise Exception(stderr)
-
-
-def setup_repo(
-    work_dir: Path, source: str, token: str | None = None, force: bool = False
-) -> None:
-    repo_url, ref_name = _parse_source(source, token)
-    dest_dir = work_dir / CLONED_REPO_FOLDER
-
-    # Remove existing repo if force=True
-    if dest_dir.exists() and force:
-        shutil.rmtree(dest_dir)
-
-    if not dest_dir.exists():
-        # need to do a full clone to resolve any kind of ref without exploding in
-        # complexity (tag, branch, commit, short commit)
-        clone_args = ["git", "clone", repo_url, str(dest_dir.absolute())]
-        run_process(clone_args, cwd=str(work_dir.absolute()))
-    else:
-        run_process(["git", "fetch", "origin"], cwd=str(dest_dir.absolute()))
-
-    # Checkout the ref (let git resolve it)
-    if ref_name:
-        run_process(["git", "checkout", ref_name], cwd=str(dest_dir.absolute()))
-    # If no ref specified, stay on whatever the clone gave us (default branch)
-
-
-def _is_valid_uri(uri: str) -> bool:
-    """Check if string looks like a valid URI"""
-    return "://" in uri and "/" in uri.split("://", 1)[1]
-
-
-def _parse_source(source: str, pat: str | None = None) -> tuple[str, str | None]:
-    """Accept Github urls like https://github.com/run-llama/llama_deploy.git@main
-    or https://user:token@github.com/run-llama/llama_deploy.git@v1.0.0
-    Returns the final URL (with auth if needed) and ref name (branch, tag, or commit SHA)"""
-
-    # Try splitting on last @ to see if we have a ref specifier
-    url = source
-    ref_name = None
-
-    if "@" in source:
-        potential_url, potential_ref = source.rsplit("@", 1)
-        if _is_valid_uri(potential_url):
-            url = potential_url
-            ref_name = potential_ref
-
-    # Inject PAT auth if provided and URL doesn't already have auth
-    if pat and "://" in url and "@" not in url:
-        url = url.replace("https://", f"https://{pat}@")
-
-    return url, ref_name
-
-
-def copy_sources(work_dir: Path, deployment_file_path: Path) -> None:
-    app_folder = deployment_file_path.parent
-    for item in app_folder.iterdir():
-        if item.is_dir():
-            # For directories, use copytree with dirs_exist_ok=True
-            shutil.copytree(
-                item, f"{work_dir.absolute()}/{item.name}", dirs_exist_ok=True
-            )
-        else:
-            # For files, use copy2 to preserve metadata
-            shutil.copy2(item, str(work_dir))
-
-
-if __name__ == "__main__":
-    if settings.prometheus_enabled:
-        start_http_server(settings.prometheus_port)
-
-    repo_url = os.environ.get("REPO_URL", "")
-    if not repo_url.startswith("https://") and not repo_url.startswith("http://"):
-        raise ValueError("Git remote must HTTP(S)")
-    repo_token = os.environ.get("GITHUB_PAT")
-    work_dir = Path(os.environ.get("WORK_DIR", RC_PATH))
-    work_dir.mkdir(exist_ok=True, parents=True)
-
-    setup_repo(work_dir, repo_url, repo_token)
-
-    if not settings.deployment_file_path:
-        # first fall back to none LLAMA_DEPLOY_APISERVER_ prefixed env var (settings requires the prefix)
-        settings.deployment_file_path = os.environ.get(
-            "DEPLOYMENT_FILE_PATH", "deployment.yml"
-        )
-    deployment_file_path = settings.deployment_file_path
-    deployment_file_abspath = work_dir / CLONED_REPO_FOLDER / deployment_file_path
-    if not deployment_file_abspath.exists():
-        raise ValueError(f"File {deployment_file_abspath} does not exist")
-
-    deployment_override_name = os.environ.get("DEPLOYMENT_NAME")
-    if deployment_override_name:
-        with open(deployment_file_abspath) as f:
-            # Replace deployment name with the overridden value
-            data = yaml.safe_load(f)
-
-        # Avoid failing here if the deployment config file has a wrong format,
-        # let's do nothing if there's no field `name`
-        if "name" in data:
-            data["name"] = deployment_override_name
-            with open(deployment_file_abspath, "w") as f:
-                yaml.safe_dump(data, f)
-
-    copy_sources(work_dir, deployment_file_abspath)
-    shutil.rmtree(work_dir / CLONED_REPO_FOLDER)
-
-    # update rc_path directly, as it has already been loaded, so setting the environment variable
-    # doesn't work
-    settings.rc_path = work_dir
-    uvicorn.run(
-        "llama_deploy.appserver.app:app",
-        host=settings.host,
-        port=settings.port,
-    )

llama_deploy/appserver/server.py

@@ -1,60 +0,0 @@
-import asyncio
-import logging
-from contextlib import asynccontextmanager
-from typing import Any, AsyncGenerator
-
-from fastapi import FastAPI
-
-from .deployment import Manager
-from .deployment_config_parser import DeploymentConfig
-from .settings import settings
-from .stats import apiserver_state
-
-logger = logging.getLogger("uvicorn.info")
-manager = Manager()
-
-
-@asynccontextmanager
-async def lifespan(app: FastAPI) -> AsyncGenerator[None, Any]:
-    apiserver_state.state("starting")
-
-    manager.set_deployments_path(settings.deployments_path)
-    t = asyncio.create_task(manager.serve())
-    await asyncio.sleep(0)
-
-    logger.info(f"deployments folder: {settings.deployments_path}")
-    logger.info(f"rc folder: {settings.rc_path}")
-
-    if settings.rc_path.exists():
-        if settings.deployment_file_path:
-            logger.info(
-                f"Browsing the rc folder {settings.rc_path} for deployment file {settings.deployment_file_path}"
-            )
-        else:
-            logger.info(
-                f"Browsing the rc folder {settings.rc_path} for deployments to start"
-            )
-
-        # if a deployment_file_path is provided, use it, otherwise glob all .yml/.yaml files
-        # q match both .yml and .yaml files with the glob
-        files = (
-            [settings.rc_path / settings.deployment_file_path]
-            if settings.deployment_file_path
-            else [
-                x for x in settings.rc_path.iterdir() if x.suffix in (".yml", ".yaml")
-            ]
-        )
-        for yaml_file in files:
-            try:
-                logger.info(f"Deploying startup configuration from {yaml_file}")
-                config = DeploymentConfig.from_yaml(yaml_file)
-                await manager.deploy(config, base_path=str(settings.rc_path))
-            except Exception as e:
-                logger.error(f"Failed to deploy {yaml_file}: {str(e)}")
-
-    apiserver_state.state("running")
-    yield
-
-    t.cancel()
-
-    apiserver_state.state("stopped")

llama_deploy/appserver/source_managers/__init__.py

@@ -1,5 +0,0 @@
-from .base import SourceManager
-from .git import GitSourceManager
-from .local import LocalSourceManager
-
-__all__ = ["GitSourceManager", "LocalSourceManager", "SourceManager"]

llama_deploy/appserver/source_managers/base.py

@@ -1,33 +0,0 @@
-from abc import ABC, abstractmethod
-from pathlib import Path
-
-from llama_deploy.appserver.deployment_config_parser import DeploymentConfig, SyncPolicy
-
-
-class SourceManager(ABC):
-    """Protocol to be implemented by classes responsible for managing Deployment sources."""
-
-    def __init__(self, config: DeploymentConfig, base_path: Path | None = None) -> None:
-        self._config = config
-        self._base_path = base_path
-
-    @abstractmethod
-    def sync(
-        self,
-        source: str,
-        destination: str | None = None,
-        sync_policy: SyncPolicy = SyncPolicy.REPLACE,
-    ) -> None:  # pragma: no cover
-        """Fetches resources from `source` so they can be used in a deployment.
-
-        Optionally uses `destination` to store data when this makes sense for the
-        specific source type.
-        """
-
-    def relative_path(self, source: str) -> str:
-        """Unfortunately, there's a difference in behavior of how the source managers sync.
-        The local source manager syncs the source into the <destination_path>/<source>, whereas
-        the git source manager just syncs the source into the <destination_path>. This is a temporary shim, since
-        changing this behavior is a breaking change to deployment.yaml configurations. Local source manager
-        overrides it. In a future major version, this behavior will be made consistent"""
-        return ""