llama-deploy-core 0.3.0a10__tar.gz → 0.3.0a11__tar.gz

{llama_deploy_core-0.3.0a10 → llama_deploy_core-0.3.0a11}/PKG-INFO

@@ -1,12 +1,17 @@
 Metadata-Version: 2.3
 Name: llama-deploy-core
-Version: 0.3.0a10
+Version: 0.3.0a11
 Summary: Core models and schemas for LlamaDeploy
 License: MIT
+Requires-Dist: fastapi>=0.115.0
 Requires-Dist: pydantic>=2.0.0
 Requires-Dist: pyyaml>=6.0.2
 Requires-Dist: types-pyyaml>=6.0.12.20250822
+Requires-Dist: httpx>=0.27.0 ; extra == 'client'
+Requires-Dist: fastapi>=0.115.0 ; extra == 'server'
 Requires-Python: >=3.12, <4
+Provides-Extra: client
+Provides-Extra: server
 Description-Content-Type: text/markdown
 
 > [!WARNING]

{llama_deploy_core-0.3.0a10 → llama_deploy_core-0.3.0a11}/pyproject.toml

@@ -1,16 +1,25 @@
 [project]
 name = "llama-deploy-core"
-version = "0.3.0a10"
+version = "0.3.0a11"
 description = "Core models and schemas for LlamaDeploy"
 readme = "README.md"
 license = { text = "MIT" }
 requires-python = ">=3.12, <4"
 dependencies = [
+    "fastapi>=0.115.0",
     "pydantic>=2.0.0",
     "pyyaml>=6.0.2",
     "types-pyyaml>=6.0.12.20250822",
 ]
 
+[project.optional-dependencies]
+server = [
+    "fastapi>=0.115.0",
+]
+client = [
+    "httpx>=0.27.0",
+]
+
 [build-system]
 requires = ["uv_build>=0.7.20,<0.8.0"]
 build-backend = "uv_build"

llama_deploy_core-0.3.0a11/src/llama_deploy/core/client/manage_client.py

@@ -0,0 +1,219 @@
+import contextlib
+from typing import Iterator, List
+
+import httpx
+from llama_deploy.core.schema.base import LogEvent
+from llama_deploy.core.schema.deployments import (
+    DeploymentCreate,
+    DeploymentResponse,
+    DeploymentsListResponse,
+    DeploymentUpdate,
+)
+from llama_deploy.core.schema.git_validation import (
+    RepositoryValidationRequest,
+    RepositoryValidationResponse,
+)
+from llama_deploy.core.schema.projects import ProjectsListResponse, ProjectSummary
+
+
+class ClientError(Exception):
+    """Base class for client errors."""
+
+    def __init__(self, message: str) -> None:
+        super().__init__(message)
+
+
+class BaseClient:
+    def __init__(self, base_url: str) -> None:
+        self.base_url = base_url.rstrip("/")
+        self.client = httpx.Client(
+            base_url=self.base_url,
+            event_hooks={"response": [self._handle_response]},
+        )
+        self.hookless_client = httpx.Client(base_url=self.base_url)
+
+    def _handle_response(self, response: httpx.Response) -> None:
+        try:
+            response.raise_for_status()
+        except httpx.HTTPStatusError as e:
+            try:
+                response.read()
+                error_data = e.response.json()
+                if isinstance(error_data, dict) and "detail" in error_data:
+                    error_message = error_data["detail"]
+                else:
+                    error_message = str(error_data)
+            except (ValueError, KeyError):
+                error_message = e.response.text
+            raise ClientError(f"HTTP {e.response.status_code}: {error_message}") from e
+        except httpx.RequestError as e:
+            raise ClientError(f"Request failed: {e}") from e
+
+
+class ControlPlaneClient(BaseClient):
+    """Unscoped client for non-project endpoints."""
+
+    def health_check(self) -> dict:
+        response = self.client.get("/health")
+        return response.json()
+
+    def server_version(self) -> dict:
+        response = self.client.get("/version")
+        return response.json()
+
+    def list_projects(self) -> List[ProjectSummary]:
+        response = self.client.get("/api/v1beta1/deployments/list-projects")
+        projects_response = ProjectsListResponse.model_validate(response.json())
+        return [project for project in projects_response.projects]
+
+
+class ProjectClient(BaseClient):
+    """Project-scoped client for deployment operations."""
+
+    def __init__(
+        self,
+        base_url: str,
+        project_id: str,
+    ) -> None:
+        super().__init__(base_url)
+        self.project_id = project_id
+
+    def list_deployments(self) -> List[DeploymentResponse]:
+        response = self.client.get(
+            "/api/v1beta1/deployments",
+            params={"project_id": self.project_id},
+        )
+        deployments_response = DeploymentsListResponse.model_validate(response.json())
+        return [deployment for deployment in deployments_response.deployments]
+
+    def get_deployment(
+        self, deployment_id: str, include_events: bool = False
+    ) -> DeploymentResponse:
+        response = self.client.get(
+            f"/api/v1beta1/deployments/{deployment_id}",
+            params={"project_id": self.project_id, "include_events": include_events},
+        )
+        return DeploymentResponse.model_validate(response.json())
+
+    def create_deployment(
+        self, deployment_data: DeploymentCreate
+    ) -> DeploymentResponse:
+        response = self.client.post(
+            "/api/v1beta1/deployments",
+            params={"project_id": self.project_id},
+            json=deployment_data.model_dump(exclude_none=True),
+        )
+        return DeploymentResponse.model_validate(response.json())
+
+    def delete_deployment(self, deployment_id: str) -> None:
+        self.client.delete(
+            f"/api/v1beta1/deployments/{deployment_id}",
+            params={"project_id": self.project_id},
+        )
+
+    def update_deployment(
+        self,
+        deployment_id: str,
+        update_data: DeploymentUpdate,
+    ) -> DeploymentResponse:
+        response = self.client.patch(
+            f"/api/v1beta1/deployments/{deployment_id}",
+            params={"project_id": self.project_id},
+            json=update_data.model_dump(),
+        )
+        return DeploymentResponse.model_validate(response.json())
+
+    def validate_repository(
+        self,
+        repo_url: str,
+        deployment_id: str | None = None,
+        pat: str | None = None,
+    ) -> RepositoryValidationResponse:
+        response = self.client.post(
+            "/api/v1beta1/deployments/validate-repository",
+            params={"project_id": self.project_id},
+            json=RepositoryValidationRequest(
+                repository_url=repo_url,
+                deployment_id=deployment_id,
+                pat=pat,
+            ).model_dump(),
+        )
+        return RepositoryValidationResponse.model_validate(response.json())
+
+    def stream_deployment_logs(
+        self,
+        deployment_id: str,
+        *,
+        include_init_containers: bool = False,
+        since_seconds: int | None = None,
+        tail_lines: int | None = None,
+    ) -> tuple["Closer", Iterator[LogEvent]]:
+        """Stream logs as LogEvent items from the control plane using SSE.
+
+        This yields `LogEvent` models until the stream ends (e.g. rollout).
+        """
+        # Use a separate client without response hooks so we don't consume the stream
+
+        params = {
+            "project_id": self.project_id,
+            "include_init_containers": include_init_containers,
+        }
+        if since_seconds is not None:
+            params["since_seconds"] = since_seconds
+        if tail_lines is not None:
+            params["tail_lines"] = tail_lines
+
+        url = f"/api/v1beta1/deployments/{deployment_id}/logs"
+        headers = {"Accept": "text/event-stream"}
+
+        stack = contextlib.ExitStack()
+        response = stack.enter_context(
+            self.hookless_client.stream(
+                "GET", url, params=params, headers=headers, timeout=None
+            )
+        )
+        try:
+            response.raise_for_status()
+        except Exception:
+            stack.close()
+            raise
+
+        return stack.close, _iterate_log_stream(response, stack.close)
+
+
+def _iterate_log_stream(
+    response: httpx.Response, closer: "Closer"
+) -> Iterator[LogEvent]:
+    event_name: str | None = None
+    data_lines: list[str] = []
+
+    try:
+        for line in response.iter_lines():
+            if line is None:
+                continue
+            line = line.decode() if isinstance(line, (bytes, bytearray)) else line
+            print("got line", line)
+            if line.startswith("event:"):
+                event_name = line[len("event:") :].strip()
+            elif line.startswith("data:"):
+                data_lines.append(line[len("data:") :].lstrip())
+            elif line.strip() == "":
+                if event_name == "log" and data_lines:
+                    data_str = "\n".join(data_lines)
+                    try:
+                        yield LogEvent.model_validate_json(data_str)
+                        print("yielded log event", data_str)
+                    except Exception:
+                        # If parsing fails, skip malformed event
+                        pass
+                # reset for next event
+                event_name = None
+                data_lines = []
+    finally:
+        try:
+            closer()
+        except Exception:
+            pass
+
+
+type Closer = callable[tuple[()], None]

llama_deploy_core-0.3.0a11/src/llama_deploy/core/server/manage_api/__init__.py

@@ -0,0 +1,10 @@
+from ._abstract_deployments_service import AbstractDeploymentsService
+from ._create_deployments_router import create_v1beta1_deployments_router
+from ._exceptions import DeploymentNotFoundError, ReplicaSetNotFoundError
+
+__all__ = [
+    "AbstractDeploymentsService",
+    "create_v1beta1_deployments_router",
+    "DeploymentNotFoundError",
+    "ReplicaSetNotFoundError",
+]

llama_deploy_core-0.3.0a11/src/llama_deploy/core/server/manage_api/_abstract_deployments_service.py

@@ -0,0 +1,149 @@
+from abc import ABC, abstractmethod
+from typing import AsyncGenerator, cast
+
+from llama_deploy.core import schema
+from llama_deploy.core.schema.base import LogEvent
+from llama_deploy.core.schema.deployments import DeploymentResponse
+
+
+class AbstractDeploymentsService(ABC):
+    @abstractmethod
+    async def validate_repository(
+        self,
+        project_id: str,
+        request: schema.RepositoryValidationRequest,
+    ) -> schema.RepositoryValidationResponse:
+        """
+        Validate repository access and return unified response.
+        """
+        ...
+
+    @abstractmethod
+    async def create_deployment(
+        self,
+        project_id: str,
+        deployment_data: schema.DeploymentCreate,
+    ) -> DeploymentResponse:
+        """
+        Create a new deployment
+
+        Args:
+            project_id: The ID of the project to create the deployment in
+            deployment_data: The data for the deployment
+
+        Returns:
+            The created deployment
+        Raises:
+            DeploymentNotFoundError: If the deployment ID is not found
+        """
+        ...
+
+    @abstractmethod
+    async def get_deployments(
+        self,
+        project_id: str,
+    ) -> schema.DeploymentsListResponse:
+        """
+        Get a list of deployments for a project
+
+        Args:
+            project_id: The ID of the project to get the deployments for
+
+        Returns:
+            A list of deployments
+        """
+        ...
+
+    @abstractmethod
+    async def get_deployment(
+        self,
+        project_id: str,
+        deployment_id: str,
+        include_events: bool = False,
+    ) -> schema.DeploymentResponse | None:
+        """
+        Get a deployment by ID
+
+        Args:
+            project_id: The ID of the project to get the deployment for
+            deployment_id: The ID of the deployment to get
+            include_events: Whether to include events in the response
+
+        Returns:
+            The deployment
+        Raises:
+            DeploymentNotFoundError: If the deployment ID is not found
+        """
+        ...
+
+    @abstractmethod
+    async def delete_deployment(
+        self,
+        project_id: str,
+        deployment_id: str,
+    ) -> None:
+        """
+        Delete a deployment
+
+        Args:
+            project_id: The ID of the project to delete the deployment from
+            deployment_id: The ID of the deployment to delete
+
+        Returns:
+            None
+        Raises:
+            DeploymentNotFoundError: If the deployment ID is not found
+        """
+        ...
+
+    @abstractmethod
+    async def update_deployment(
+        self,
+        project_id: str,
+        deployment_id: str,
+        update_data: schema.DeploymentUpdate,
+    ) -> DeploymentResponse:
+        """
+        Update a deployment
+
+        Args:
+            project_id: The ID of the project to update the deployment in
+            deployment_id: The ID of the deployment to update
+            update_data: The data to update the deployment with
+
+        Returns:
+            The updated deployment
+        Raises:
+            DeploymentNotFoundError: If the deployment ID is not found
+        """
+        ...
+
+    @abstractmethod
+    async def stream_deployment_logs(
+        self,
+        project_id: str,
+        deployment_id: str,
+        include_init_containers: bool = False,
+        since_seconds: int | None = None,
+        tail_lines: int | None = None,
+    ) -> AsyncGenerator[LogEvent, None]:
+        """
+        Stream the logs for a deployment
+
+        Args:
+            project_id: The ID of the project to stream the logs for
+            deployment_id: The ID of the deployment to stream the logs for
+            include_init_containers: Whether to include init containers in the logs
+            since_seconds: The number of seconds to stream the logs for
+            tail_lines: The number of lines to stream the logs for
+
+        Returns:
+            A generator of log events
+        Raises:
+            DeploymentNotFoundError: If the deployment ID is not found
+        """
+        # This method is abstract. The following unreachable code ensures type
+        # checkers treat it as an async generator, so call sites can `async for`.
+        raise NotImplementedError
+        if False:
+            yield cast(LogEvent, None)

llama_deploy_core-0.3.0a11/src/llama_deploy/core/server/manage_api/_create_deployments_router.py

@@ -0,0 +1,167 @@
+import logging
+from typing import Awaitable, Callable
+
+from fastapi import APIRouter, Depends, HTTPException, Request, Response
+from fastapi.params import Query
+from fastapi.responses import StreamingResponse
+from llama_deploy.control_plane import k8s_client
+from llama_deploy.core import schema
+from typing_extensions import Annotated
+
+from ._abstract_deployments_service import AbstractDeploymentsService
+from ._exceptions import DeploymentNotFoundError, ReplicaSetNotFoundError
+
+logger = logging.getLogger(__name__)
+
+
+async def get_project_id(project_id: Annotated[str, Query()]) -> str:
+    return project_id
+
+
+def create_v1beta1_deployments_router(
+    deployments_service: AbstractDeploymentsService,
+    get_project_id: Callable[[str], Awaitable[str]] = get_project_id,
+) -> APIRouter:
+    router = APIRouter(prefix="/api/v1beta1/deployments", tags=["v1beta1-deployments"])
+
+    @router.get("/list-projects")
+    async def get_projects() -> schema.ProjectsListResponse:
+        """Get all unique projects with their deployment counts"""
+        projects_data = await k8s_client.get_projects_with_deployment_count()
+        return schema.ProjectsListResponse(projects=projects_data)
+
+    @router.post("/validate-repository")
+    async def validate_repository(
+        project_id: Annotated[str, Depends(get_project_id)],
+        request: schema.RepositoryValidationRequest,
+    ) -> schema.RepositoryValidationResponse:
+        """Validate repository access and return unified response."""
+        return await deployments_service.validate_repository(
+            project_id=project_id,
+            request=request,
+        )
+
+    @router.post("", response_model=schema.DeploymentResponse)
+    async def create_deployment(
+        project_id: Annotated[str, Depends(get_project_id)],
+        deployment_data: schema.DeploymentCreate,
+    ) -> Response:
+        deployment_response = await deployments_service.create_deployment(
+            project_id=project_id,
+            deployment_data=deployment_data,
+        )
+        # Return deployment response with warning header if there are git issues
+
+        response = Response(
+            content=deployment_response.model_dump_json(),
+            status_code=201,
+            media_type="application/json",
+        )
+        return response
+
+    @router.get("")
+    async def get_deployments(
+        project_id: Annotated[str, Depends(get_project_id)],
+    ) -> schema.DeploymentsListResponse:
+        return await deployments_service.get_deployments(project_id=project_id)
+
+    @router.get("/{deployment_id}")
+    async def get_deployment(
+        project_id: Annotated[str, Depends(get_project_id)],
+        deployment_id: str,
+        include_events: Annotated[bool, Query()] = False,
+    ) -> schema.DeploymentResponse:
+        deployment = await deployments_service.get_deployment(
+            project_id=project_id,
+            deployment_id=deployment_id,
+            include_events=include_events,
+        )
+        if deployment is None:
+            raise HTTPException(
+                status_code=404,
+                detail=f"Deployment with id {deployment_id} not found",
+            )
+
+        return deployment
+
+    @router.delete("/{deployment_id}")
+    async def delete_deployment(
+        project_id: Annotated[str, Depends(get_project_id)],
+        deployment_id: str,
+    ) -> None:
+        await deployments_service.delete_deployment(
+            project_id=project_id, deployment_id=deployment_id
+        )
+
+    @router.patch("/{deployment_id}", response_model=schema.DeploymentResponse)
+    async def update_deployment(
+        project_id: Annotated[str, Depends(get_project_id)],
+        deployment_id: str,
+        update_data: schema.DeploymentUpdate,
+    ) -> Response:
+        """Update an existing deployment with patch-style changes
+
+        Args:
+            project_id: The project ID
+            deployment_id: The deployment ID to update
+            update_data: The patch-style update data
+        """
+
+        deployment_response = await deployments_service.update_deployment(
+            project_id=project_id,
+            deployment_id=deployment_id,
+            update_data=update_data,
+        )
+
+        response = Response(
+            content=deployment_response.model_dump_json(),
+            status_code=200,
+            media_type="application/json",
+        )
+        return response
+
+    @router.get("/{deployment_id}/logs")
+    async def stream_deployment_logs(
+        request: Request,
+        project_id: Annotated[str, Depends(get_project_id)],
+        deployment_id: str,
+        include_init_containers: Annotated[bool, Query()] = False,
+        since_seconds: Annotated[int | None, Query()] = None,
+        tail_lines: Annotated[int | None, Query()] = None,
+    ):
+        """Stream logs for the latest ReplicaSet of a deployment.
+
+        The stream ends when the latest ReplicaSet changes (e.g., a new rollout occurs).
+        """
+
+        try:
+            inner = deployments_service.stream_deployment_logs(
+                project_id=project_id,
+                deployment_id=deployment_id,
+                include_init_containers=include_init_containers,
+                since_seconds=since_seconds,
+                tail_lines=tail_lines,
+            )
+
+            async def sse_lines():
+                async for data in inner:
+                    yield "event: log\n"
+                    yield f"data: {data.model_dump_json()}\n\n"
+
+            return StreamingResponse(
+                sse_lines(),
+                media_type="text/event-stream",
+                headers={
+                    "Cache-Control": "no-cache",
+                    "Connection": "keep-alive",
+                    "X-Accel-Buffering": "no",
+                },
+            )
+
+        except DeploymentNotFoundError as e:
+            raise HTTPException(status_code=404, detail=str(e))
+        except ReplicaSetNotFoundError as e:
+            # Deployment exists but hasn't created a ReplicaSet yet
+            raise HTTPException(status_code=409, detail=str(e))
+
+    return router

llama_deploy_core-0.3.0a11/src/llama_deploy/core/server/manage_api/_exceptions.py

@@ -0,0 +1,14 @@
+class DeploymentNotFoundError(Exception):
+    """
+    Raised when a deployment is not found
+    """
+
+    pass
+
+
+class ReplicaSetNotFoundError(Exception):
+    """
+    May be raised if a deployment does not set have a replica set
+    """
+
+    pass