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

llama_deploy/appserver/workflow_loader.py

@@ -0,0 +1,431 @@
+import configparser
+import functools
+import importlib
+import logging
+import os
+import socket
+import subprocess
+import sys
+from dataclasses import dataclass
+from importlib.metadata import version as pkg_version
+from pathlib import Path
+from textwrap import dedent
+
+from dotenv import dotenv_values
+from llama_deploy.appserver.deployment_config_parser import (
+    DeploymentConfig,
+)
+from llama_deploy.appserver.process_utils import run_process, spawn_process
+from llama_deploy.appserver.settings import ApiserverSettings, settings
+from llama_deploy.core.ui_build import ui_build_output_path
+from packaging.version import InvalidVersion, Version
+from workflows import Workflow
+from workflows.server import WorkflowServer
+
+logger = logging.getLogger(__name__)
+
+DEFAULT_SERVICE_ID = "default"
+
+
+def load_workflows(config: DeploymentConfig) -> dict[str, Workflow]:
+    """
+    Creates WorkflowService instances according to the configuration object.
+
+    """
+    workflow_services: dict[str, Workflow] = {}
+
+    if config.app:
+        module_name, app_name = config.app.split(":", 1)
+        module = importlib.import_module(module_name)
+        workflow = getattr(module, app_name)
+        if not isinstance(workflow, WorkflowServer):
+            raise ValueError(
+                f"Workflow {app_name} in {module_name} is not a WorkflowServer object"
+            )
+        # kludge to get the workflows
+        workflow_services = workflow._workflows
+    else:
+        for service_id, workflow_name in config.workflows.items():
+            module_name, workflow_name = workflow_name.split(":", 1)
+            module = importlib.import_module(module_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
+
+    return workflow_services
+
+
+def load_environment_variables(config: DeploymentConfig, source_root: Path) -> None:
+    """
+    Load environment variables from the deployment config.
+    """
+    for key, value in parse_environment_variables(config, source_root).items():
+        if value:
+            os.environ[key] = value
+
+
+def parse_environment_variables(
+    config: DeploymentConfig, source_root: Path
+) -> dict[str, str]:
+    """
+    Parse environment variables from the deployment config.
+    """
+    env_vars = {**config.env} if config.env else {}
+    for env_file in config.env_files or []:
+        env_file_path = source_root / env_file
+        values = dotenv_values(env_file_path)
+        env_vars.update(**values)
+    return env_vars
+
+
+@functools.cache
+def are_we_editable_mode() -> bool:
+    """
+    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 = settings.resolved_config_parent
+    logger.info(f"Installing ensuring venv at {path} and adding appserver to it")
+    _ensure_uv_available()
+    _install_and_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",
+                dedent("""
+                        from importlib.metadata import version
+                        try:
+                            print(version("llama-deploy-appserver"))
+                        except Exception:
+                            pass
+                       """),
+            ],
+            cwd=path,
+            stderr=subprocess.DEVNULL,
+        )
+        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 _install_and_add_appserver_if_missing(
+    path: Path,
+    source_root: Path,
+    save_version: bool = False,
+    sdists: list[Path] | None = None,
+) -> None:
+    """
+    Ensure venv, install project deps, and add the appserver to the venv if it's missing or outdated
+    """
+
+    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 run_uv(cmd: str, args: list[str] = [], extra_env: dict[str, str] | None = None):
+        env = os.environ.copy()
+        if extra_env:
+            env.update(extra_env)
+        run_process(
+            ["uv", cmd] + args,
+            cwd=source_root / path,
+            prefix=f"[uv {cmd}]",
+            color_code="36",
+            use_tty=False,
+            line_transform=_exclude_venv_warning,
+            env=env,
+        )
+
+    def ensure_venv(path: Path, force: bool = False) -> Path:
+        venv_path = source_root / path / ".venv"
+        if force or not venv_path.exists():
+            run_uv("venv", [str(venv_path)])
+        return venv_path
+
+    editable = are_we_editable_mode()
+    venv_path = ensure_venv(path, force=editable)
+    run_uv(
+        "sync",
+        ["--no-dev", "--inexact"],
+        extra_env={"UV_PROJECT_ENVIRONMENT": str(venv_path)},
+    )
+
+    if sdists:
+        run_uv(
+            "pip",
+            ["install"]
+            + [str(s.absolute()) for s in sdists]
+            + ["--prefix", str(venv_path)],
+        )
+    elif are_we_editable_mode():
+        same_python_version = _same_python_version(venv_path)
+        if not same_python_version.is_same:
+            logger.error(
+                f"Python version mismatch. Current: {same_python_version.current_version} != Project: {same_python_version.target_version}. During development, the target environment must be running the same Python version, otherwise the appserver cannot be installed."
+            )
+            raise RuntimeError(
+                f"Python version mismatch. Current: {same_python_version.current_version} != Project: {same_python_version.target_version}"
+            )
+        pyproject = _find_development_pyproject()
+        if pyproject is None:
+            raise RuntimeError("No pyproject.toml found in llama-deploy-appserver")
+        base = (source_root.resolve() / path).resolve()
+        rel = Path(os.path.relpath(pyproject, start=base))
+        target = f"file://{str(rel)}"
+
+        run_uv(
+            "pip",
+            [
+                "install",
+                "--reinstall-package",
+                "llama-deploy-appserver",
+                target,
+                "--prefix",
+                str(venv_path),
+            ],
+        )
+
+    else:
+        version = _is_missing_or_outdated(path)
+        if version is not None:
+            if save_version:
+                run_uv("add", [f"llama-deploy-appserver>={version}"])
+            else:
+                run_uv(
+                    "pip",
+                    [
+                        "install",
+                        f"llama-deploy-appserver=={version}",
+                        "--prefix",
+                        str(venv_path),
+                    ],
+                )
+
+
+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 _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
+    try:
+        subprocess.check_call(
+            ["uv", "--version"],
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+        )
+        uv_available = True
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        pass
+    if not uv_available:
+        # bootstrap uv with pip
+        try:
+            run_process(
+                [
+                    sys.executable,
+                    "-m",
+                    "pip",
+                    "install",
+                    "uv",
+                ],
+                prefix="[python -m pip]",
+                color_code="31",  # red
+            )
+        except subprocess.CalledProcessError as e:
+            msg = f"Unable to install uv. Environment must include uv, or uv must be installed with pip: {e.stderr}"
+            raise RuntimeError(msg)
+
+
+@dataclass
+class SamePythonVersionResult:
+    is_same: bool
+    current_version: str
+    target_version: str | None
+
+
+def _same_python_version(venv_path: Path) -> SamePythonVersionResult:
+    current_version = f"{sys.version_info.major}.{sys.version_info.minor}"
+    target_version = None
+    cfg = venv_path / "pyvenv.cfg"
+    if cfg.exists():
+        parser = configparser.ConfigParser()
+        parser.read_string("[venv]\n" + cfg.read_text())
+        ver_str = parser["venv"].get("version_info", "").strip()
+        if ver_str:
+            try:
+                v = Version(ver_str)
+                target_version = f"{v.major}.{v.minor}"
+            except InvalidVersion:
+                pass
+    return SamePythonVersionResult(
+        is_same=current_version == target_version,
+        current_version=current_version,
+        target_version=target_version,
+    )
+
+
+def install_ui(config: DeploymentConfig, config_parent: Path) -> None:
+    if config.ui is None:
+        return
+    package_manager = config.ui.package_manager
+    try:
+        run_process(
+            [package_manager, "install"],
+            cwd=config_parent / config.ui.directory,
+            prefix=f"[{package_manager} install]",
+            color_code="33",
+            # auto download the package manager
+            env={**os.environ.copy(), "COREPACK_ENABLE_DOWNLOAD_PROMPT": "0"},
+        )
+    except BaseException as e:
+        if "No such file or directory" in str(e):
+            raise RuntimeError(
+                f"Package manager {package_manager} not found. Please download and enable corepack, or install the package manager manually."
+            )
+        raise e
+
+
+def _ui_env(config: DeploymentConfig, settings: ApiserverSettings) -> dict[str, str]:
+    env = os.environ.copy()
+    env["LLAMA_DEPLOY_DEPLOYMENT_URL_ID"] = config.name
+    env["LLAMA_DEPLOY_DEPLOYMENT_BASE_PATH"] = f"/deployments/{config.name}/ui"
+    if config.ui is not None:
+        env["PORT"] = str(settings.proxy_ui_port)
+    return env
+
+
+def build_ui(
+    config_parent: Path, config: DeploymentConfig, settings: ApiserverSettings
+) -> bool:
+    """
+    Returns True if the UI was built (and supports building), otherwise False if there's no build command
+    """
+    if config.ui is None:
+        return False
+    path = Path(config.ui.directory)
+    env = _ui_env(config, settings)
+
+    has_build = ui_build_output_path(config_parent, config)
+    if has_build is None:
+        return False
+
+    run_process(
+        ["npm", "run", "build"],
+        cwd=config_parent / path,
+        env=env,
+        prefix="[npm run build]",
+        color_code="34",
+    )
+    return True
+
+
+def start_dev_ui_process(
+    root: Path, settings: ApiserverSettings, config: DeploymentConfig
+) -> None | subprocess.Popen:
+    ui_port = settings.proxy_ui_port
+    ui = config.ui
+    if ui is None:
+        return None
+
+    # If a UI dev server is already listening on the configured port, do not start another
+    def _is_port_open(port: int) -> bool:
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
+            sock.settimeout(0.2)
+            try:
+                return sock.connect_ex(("127.0.0.1", port)) == 0
+            except Exception:
+                return False
+
+    if _is_port_open(ui_port):
+        logger.info(
+            f"Detected process already running on port {ui_port}; not starting a new one."
+        )
+        return None
+    # start the ui process
+    env = _ui_env(config, settings)
+    # Transform first 20 lines to replace the default UI port with the main server port
+    line_counter = 0
+
+    def _transform(line: str) -> str:
+        nonlocal line_counter
+        if line_counter < 20:
+            line = line.replace(f":{ui_port}", f":{settings.port}")
+        line_counter += 1
+        return line
+
+    return spawn_process(
+        ["npm", "run", ui.serve_command],
+        cwd=root / (ui.directory),
+        env=env,
+        prefix=f"[npm run {ui.serve_command}]",
+        color_code="35",
+        line_transform=_transform,
+        use_tty=False,
+    )

llama_deploy/appserver/workflow_store/agent_data_store.py

@@ -0,0 +1,100 @@
+import logging
+import os
+from typing import List
+
+from llama_cloud.client import AsyncLlamaCloud, httpx
+from llama_cloud_services.beta.agent_data import AsyncAgentDataClient
+from llama_deploy.appserver.settings import ApiserverSettings
+from llama_deploy.core.deployment_config import DeploymentConfig
+from typing_extensions import override
+from workflows.server import AbstractWorkflowStore, HandlerQuery, PersistentHandler
+
+from .keyed_lock import AsyncKeyedLock
+from .lru_cache import LRUCache
+
+logger = logging.getLogger(__name__)
+
+
+class AgentDataStore(AbstractWorkflowStore):
+    def __init__(
+        self, settings: DeploymentConfig, server_settings: ApiserverSettings
+    ) -> None:
+        agent_url_id: str | None = server_settings.cloud_persistence_name
+        collection = "workflow_contexts"
+        if agent_url_id is not None:
+            parts = agent_url_id.split(":")
+            if len(parts) > 1:
+                collection = parts[1]
+            agent_url_id = parts[0]
+        else:
+            agent_url_id = settings.name
+
+        self.settings = settings
+        project_id = os.getenv("LLAMA_DEPLOY_PROJECT_ID")
+        self.client = AsyncAgentDataClient(
+            type=PersistentHandler,
+            collection=collection,
+            agent_url_id=agent_url_id,
+            client=AsyncLlamaCloud(
+                base_url=os.getenv("LLAMA_CLOUD_BASE_URL"),
+                token=os.getenv("LLAMA_CLOUD_API_KEY"),
+                httpx_client=httpx.AsyncClient(
+                    headers={"Project-Id": project_id} if project_id else None,
+                ),
+            ),
+        )
+        self.lock = AsyncKeyedLock()
+        # workflow id -> agent data id
+        self.cache = LRUCache[str, str](maxsize=1024)
+
+    @override
+    async def query(self, query: HandlerQuery) -> List[PersistentHandler]:
+        filters = {}
+        if query.handler_id_in is not None:
+            filters["handler_id"] = {
+                "includes": query.handler_id_in,
+            }
+        if query.workflow_name_in is not None:
+            filters["workflow_name"] = {
+                "includes": query.workflow_name_in,
+            }
+        if query.status_in is not None:
+            filters["status"] = {
+                "includes": query.status_in,
+            }
+        results = await self.client.search(
+            filter=filters,
+            page_size=1000,
+        )
+        return [x.data for x in results.items]
+
+    @override
+    async def update(self, handler: PersistentHandler) -> None:
+        async with self.lock.acquire(handler.handler_id):
+            id = await self._get_item_id(handler)
+            if id is None:
+                item = await self.client.create_item(
+                    data=handler,
+                )
+                if item.id is None:
+                    raise ValueError(f"Failed to create handler {handler.handler_id}")
+                self.cache.set(handler.handler_id, item.id)
+            else:
+                await self.client.update_item(
+                    item_id=id,
+                    data=handler,
+                )
+
+    async def _get_item_id(self, handler: PersistentHandler) -> str | None:
+        cached_id = self.cache.get(handler.handler_id, None)
+        if cached_id is not None:
+            return cached_id
+        results = await self.client.search(
+            filter={"handler_id": {"eq": handler.handler_id}},
+            page_size=1,
+        )
+        if not results.items:
+            return None
+        id = results.items[0].id
+        self.cache.set(handler.handler_id, id)
+        return id

llama_deploy/appserver/workflow_store/keyed_lock.py

@@ -0,0 +1,32 @@
+import asyncio
+from collections import Counter
+from contextlib import asynccontextmanager
+
+
+class AsyncKeyedLock:
+    def __init__(self):
+        self._locks: dict[str, asyncio.Lock] = {}
+        self._refcnt = Counter()
+        self._registry_lock = asyncio.Lock()  # protects _locks/_refcnt
+
+    @asynccontextmanager
+    async def acquire(self, key: str):
+        async with self._registry_lock:
+            lock = self._locks.get(key)
+            if lock is None:
+                lock = asyncio.Lock()
+                self._locks[key] = lock
+            self._refcnt[key] += 1
+
+        try:
+            await lock.acquire()
+            try:
+                yield
+            finally:
+                lock.release()
+        finally:
+            async with self._registry_lock:
+                self._refcnt[key] -= 1
+                if self._refcnt[key] == 0:
+                    self._locks.pop(key, None)
+                    del self._refcnt[key]

llama_deploy/appserver/workflow_store/lru_cache.py

@@ -0,0 +1,49 @@
+from collections import OrderedDict
+from typing import Generic, TypeVar, overload
+
+K = TypeVar("K")
+V = TypeVar("V")
+
+
+class LRUCache(Generic[K, V]):
+    def __init__(self, maxsize: int = 128):
+        self.maxsize = maxsize
+        self._store: OrderedDict[K, V] = OrderedDict()
+
+    @overload
+    def get(self, key: K) -> V | None: ...
+
+    @overload
+    def get(self, key: K, default: V) -> V: ...
+
+    def get(self, key: K, default: V | None = None) -> V | None:
+        if key not in self._store:
+            return default
+        # mark as recently used
+        value = self._store.pop(key)
+        self._store[key] = value
+        return value
+
+    def set(self, key: K, value: V):
+        if key in self._store:
+            # remove old so we can push to end
+            self._store.pop(key)
+        elif len(self._store) >= self.maxsize:
+            # evict least recently used (first item)
+            self._store.popitem(last=False)
+        self._store[key] = value
+
+    def __contains__(self, key: K) -> bool:
+        return key in self._store
+
+    def __getitem__(self, key: K) -> V:
+        return self.get(key)
+
+    def __setitem__(self, key: K, value: V):
+        self.set(key, value)
+
+    def __len__(self) -> int:
+        return len(self._store)
+
+    def __iter__(self):
+        return iter(self._store)

llama_deploy_appserver-0.3.0.dist-info/METADATA

@@ -0,0 +1,25 @@
+Metadata-Version: 2.3
+Name: llama-deploy-appserver
+Version: 0.3.0
+Summary: Application server components for LlamaDeploy
+Author: Massimiliano Pippi, Adrian Lyjak
+Author-email: Massimiliano Pippi <mpippi@gmail.com>, Adrian Lyjak <adrianlyjak@gmail.com>
+License: MIT
+Requires-Dist: llama-index-workflows[server]>=2.2.0
+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.0,<0.4.0
+Requires-Dist: httpx>=0.24.0,<1.0.0
+Requires-Dist: prometheus-fastapi-instrumentator>=7.1.0
+Requires-Dist: packaging>=25.0
+Requires-Dist: structlog>=25.4.0
+Requires-Dist: rich>=14.1.0
+Requires-Dist: pyyaml>=6.0.2
+Requires-Dist: llama-cloud-services>=0.6.60
+Requires-Python: >=3.11, <4
+Description-Content-Type: text/markdown
+
+> [!WARNING]
+> This repository contains pre-release software. It is unstable, incomplete, and subject to breaking changes. Not recommended for use.

llama_deploy_appserver-0.3.0.dist-info/RECORD

@@ -0,0 +1,24 @@
+llama_deploy/appserver/__init__.py,sha256=e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855,0
+llama_deploy/appserver/app.py,sha256=1150ac9d6b2e4bd0bbe4cc70a16249381887e86f49c68492a3ab61024d4567b7,9520
+llama_deploy/appserver/bootstrap.py,sha256=fa32be007f18b4b3af92c878bac417416c9afb09b1beddf51b5cd73115e6b7c6,2453
+llama_deploy/appserver/configure_logging.py,sha256=194dd1ebed3c1d9065d9174f7828d557a577eaac8fb0443b3102430b1f578c19,6329
+llama_deploy/appserver/correlation_id.py,sha256=8ac5bc6160c707b93a9fb818b64dd369a4ef7a53f9f91a6b3d90c4cf446f7327,572
+llama_deploy/appserver/deployment.py,sha256=8bc298caaf765b5fea345287de14f7b9a4aedc06261220f4ed00d1dde9bec502,6092
+llama_deploy/appserver/deployment_config_parser.py,sha256=e2b6c483203d96ab795c4e55df15c694c20458d5a03fab89c2b71e481291a2d3,510
+llama_deploy/appserver/interrupts.py,sha256=14f262a0cedc00bb3aecd3d6c14c41ba0e88e7d2a6df02cd35b5bea1940822a2,1622
+llama_deploy/appserver/process_utils.py,sha256=befee4918c6cf72082dca8bf807afb61ad3d6c83f01bc0c007594b47930570d8,6056
+llama_deploy/appserver/py.typed,sha256=e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855,0
+llama_deploy/appserver/routers/__init__.py,sha256=ee2d14ebf4b067c844947ed1cc98186456e8bfa4919282722eaaf8cca345a138,214
+llama_deploy/appserver/routers/deployments.py,sha256=e7bafd72c1b4b809e5ad57442594a997c85ecab998b8430da65899faa910db1c,7572
+llama_deploy/appserver/routers/status.py,sha256=2af74bc40e52dc5944af2df98c6a021fea7b0cfcda88b56ac124dc383120758c,282
+llama_deploy/appserver/routers/ui_proxy.py,sha256=f63c36c201070594a4011320192d724b1c534d0ec655c49ba65c4e9911dbdd97,8633
+llama_deploy/appserver/settings.py,sha256=279dad9d80f4b54215cb8073bc46ee2beebfbc8ed75f40bccfbb387593f6975a,4984
+llama_deploy/appserver/stats.py,sha256=1f3989f6705a6de3e4d61ee8cdd189fbe04a2c53ec5e720b2e5168acc331427f,691
+llama_deploy/appserver/types.py,sha256=4edc991aafb6b8497f068d12387455df292da3ff8440223637641ab1632553ec,2133
+llama_deploy/appserver/workflow_loader.py,sha256=c15890a00976e022edcdf2af04bf699c02fba020bb06c47960a4911e08255501,14146
+llama_deploy/appserver/workflow_store/agent_data_store.py,sha256=7b8d1b8cb6f741ff631d668fc955ca76a82e8da0bf8a27ee3bc9a8ef71123701,3594
+llama_deploy/appserver/workflow_store/keyed_lock.py,sha256=bb1504d9de09d51a8f60721cc77b14d4051ac5a897ace6f9d9cba494f068465e,950
+llama_deploy/appserver/workflow_store/lru_cache.py,sha256=7511231b6aba81ea96044cf644cd9c1f11d78190b7b7f578b1b5a55e2c218f9f,1323
+llama_deploy_appserver-0.3.0.dist-info/WHEEL,sha256=66530aef82d5020ef5af27ae0123c71abb9261377c5bc519376c671346b12918,79
+llama_deploy_appserver-0.3.0.dist-info/METADATA,sha256=0ee9fc6166c50252991baad2f7186a6b58fc3321e349df0074f809e2a77d34ea,974
+llama_deploy_appserver-0.3.0.dist-info/RECORD,,

{llama_deploy_appserver-0.2.7a1.dist-info → llama_deploy_appserver-0.3.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: uv 0.7.21
+Generator: uv 0.7.20
 Root-Is-Purelib: true
 Tag: py3-none-any

llama_deploy/appserver/__main__.py

@@ -1,14 +0,0 @@
-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/client/__init__.py

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