llama-deploy-core 0.3.0a19__tar.gz → 0.3.0a21__tar.gz

{llama_deploy_core-0.3.0a19 → llama_deploy_core-0.3.0a21}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: llama-deploy-core
-Version: 0.3.0a19
+Version: 0.3.0a21
 Summary: Core models and schemas for LlamaDeploy
 License: MIT
 Requires-Dist: fastapi>=0.115.0

{llama_deploy_core-0.3.0a19 → llama_deploy_core-0.3.0a21}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "llama-deploy-core"
-version = "0.3.0a19"
+version = "0.3.0a21"
 description = "Core models and schemas for LlamaDeploy"
 readme = "README.md"
 license = { text = "MIT" }

{llama_deploy_core-0.3.0a19 → llama_deploy_core-0.3.0a21}/src/llama_deploy/core/client/manage_client.py

@@ -19,17 +19,12 @@ from llama_deploy.core.schema.projects import ProjectsListResponse, ProjectSumma
 from llama_deploy.core.schema.public import VersionResponse
 
 
-class ClientError(Exception):
-    """Base class for client errors."""
-
-    def __init__(self, message: str, status_code: int | None = None) -> None:
-        super().__init__(message)
-        self.status_code = status_code
-
-
 class BaseClient:
-    def __init__(self, base_url: str, api_key: str | None = None) -> None:
+    def __init__(
+        self, base_url: str, api_key: str | None = None, auth: httpx.Auth | None = None
+    ) -> None:
         self.base_url = base_url.rstrip("/")
+        self.api_key = api_key
 
         headers: dict[str, str] = {}
         if api_key:
@@ -38,33 +33,12 @@ class BaseClient:
         self.client = httpx.AsyncClient(
             base_url=self.base_url,
             headers=headers,
-            event_hooks={"response": [self._handle_response]},
+            auth=auth,
         )
         self.hookless_client = httpx.AsyncClient(
-            base_url=self.base_url, headers=headers
+            base_url=self.base_url, headers=headers, auth=auth
         )
 
-    async def _handle_response(self, response: httpx.Response) -> None:
-        try:
-            response.raise_for_status()
-        except httpx.HTTPStatusError as e:
-            try:
-                # Ensure content is loaded for JSON/text extraction
-                await response.aread()
-                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}",
-                e.response.status_code,
-            ) from e
-        except httpx.RequestError as e:
-            raise ClientError(f"Request failed: {e}") from e
-
     async def aclose(self) -> None:
         await self.client.aclose()
         await self.hookless_client.aclose()
@@ -76,9 +50,9 @@ class ControlPlaneClient(BaseClient):
     @classmethod
     @asynccontextmanager
     async def ctx(
-        cls, base_url: str, api_key: str | None = None
+        cls, base_url: str, api_key: str | None = None, auth: httpx.Auth | None = None
     ) -> AsyncIterator[ControlPlaneClient]:
-        client = cls(base_url, api_key)
+        client = cls(base_url, api_key, auth)
         try:
             yield client
         finally:
@@ -87,15 +61,19 @@ class ControlPlaneClient(BaseClient):
             except Exception:
                 pass
 
-    def __init__(self, base_url: str, api_key: str | None = None) -> None:
-        super().__init__(base_url, api_key)
+    def __init__(
+        self, base_url: str, api_key: str | None = None, auth: httpx.Auth | None = None
+    ) -> None:
+        super().__init__(base_url, api_key, auth)
 
     async def server_version(self) -> VersionResponse:
         response = await self.client.get("/api/v1beta1/deployments-public/version")
+        response.raise_for_status()
         return VersionResponse.model_validate(response.json())
 
     async def list_projects(self) -> List[ProjectSummary]:
         response = await self.client.get("/api/v1beta1/deployments/list-projects")
+        response.raise_for_status()
         projects_response = ProjectsListResponse.model_validate(response.json())
         return [project for project in projects_response.projects]
 
@@ -106,9 +84,13 @@ class ProjectClient(BaseClient):
     @classmethod
     @asynccontextmanager
     async def ctx(
-        cls, base_url: str, project_id: str, api_key: str | None = None
+        cls,
+        base_url: str,
+        project_id: str,
+        api_key: str | None = None,
+        auth: httpx.Auth | None = None,
     ) -> AsyncIterator[ProjectClient]:
-        client = cls(base_url, project_id, api_key)
+        client = cls(base_url, project_id, api_key, auth)
         try:
             yield client
         finally:
@@ -122,8 +104,9 @@ class ProjectClient(BaseClient):
         base_url: str,
         project_id: str,
         api_key: str | None = None,
+        auth: httpx.Auth | None = None,
     ) -> None:
-        super().__init__(base_url, api_key)
+        super().__init__(base_url, api_key, auth)
         self.project_id = project_id
 
     async def list_deployments(self) -> List[DeploymentResponse]:
@@ -131,6 +114,7 @@ class ProjectClient(BaseClient):
             "/api/v1beta1/deployments",
             params={"project_id": self.project_id},
         )
+        response.raise_for_status()
         deployments_response = DeploymentsListResponse.model_validate(response.json())
         return [deployment for deployment in deployments_response.deployments]
 
@@ -141,6 +125,7 @@ class ProjectClient(BaseClient):
             f"/api/v1beta1/deployments/{deployment_id}",
             params={"project_id": self.project_id, "include_events": include_events},
         )
+        response.raise_for_status()
         return DeploymentResponse.model_validate(response.json())
 
     async def create_deployment(
@@ -151,13 +136,15 @@ class ProjectClient(BaseClient):
             params={"project_id": self.project_id},
             json=deployment_data.model_dump(exclude_none=True),
         )
+        response.raise_for_status()
         return DeploymentResponse.model_validate(response.json())
 
     async def delete_deployment(self, deployment_id: str) -> None:
-        await self.client.delete(
+        response = await self.client.delete(
             f"/api/v1beta1/deployments/{deployment_id}",
             params={"project_id": self.project_id},
         )
+        response.raise_for_status()
 
     async def update_deployment(
         self,
@@ -169,6 +156,7 @@ class ProjectClient(BaseClient):
             params={"project_id": self.project_id},
             json=update_data.model_dump(),
         )
+        response.raise_for_status()
         return DeploymentResponse.model_validate(response.json())
 
     async def validate_repository(
@@ -186,6 +174,7 @@ class ProjectClient(BaseClient):
                 pat=pat,
             ).model_dump(),
         )
+        response.raise_for_status()
         return RepositoryValidationResponse.model_validate(response.json())
 
     async def stream_deployment_logs(

{llama_deploy_core-0.3.0a19 → llama_deploy_core-0.3.0a21}/src/llama_deploy/core/git/git_util.py

@@ -157,7 +157,9 @@ def clone_repo(
                     _run_process(
                         ["git", "fetch", "origin"], cwd=str(dest_dir.absolute())
                     )
-                _run_process(["git", "checkout", git_ref], cwd=str(dest_dir.absolute()))
+                _run_process(
+                    ["git", "checkout", git_ref, "--"], cwd=str(dest_dir.absolute())
+                )
             # if no ref, stay on whatever the clone gave us/current commit
             # return the resolved sha
             resolved_sha = _run_process(
@@ -269,3 +271,66 @@ def get_git_root() -> Path:
     """
     result = _run_process(["git", "rev-parse", "--show-toplevel"])
     return Path(result.strip())
+
+
+def working_tree_has_changes() -> bool:
+    """
+    Returns True if the working tree has uncommitted or untracked changes.
+    Safe to call; returns False if unable to determine.
+    """
+    try:
+        result = subprocess.run(
+            ["git", "status", "--porcelain"],
+            capture_output=True,
+            text=True,
+            check=False,
+            timeout=30,
+        )
+        return bool((result.stdout or "").strip())
+    except Exception:
+        return False
+
+
+def get_unpushed_commits_count() -> int | None:
+    """
+    Returns the number of local commits ahead of the upstream.
+
+    - Returns an integer >= 0 when an upstream is configured
+    - Returns None when no upstream is configured
+    - Returns 0 if the status cannot be determined
+    """
+    try:
+        upstream = subprocess.run(
+            [
+                "git",
+                "rev-parse",
+                "--abbrev-ref",
+                "--symbolic-full-name",
+                "@{u}",
+            ],
+            capture_output=True,
+            text=True,
+            check=False,
+            timeout=30,
+        )
+        if upstream.returncode != 0:
+            return None
+
+        ahead_behind = subprocess.run(
+            ["git", "rev-list", "--left-right", "--count", "@{u}...HEAD"],
+            capture_output=True,
+            text=True,
+            check=False,
+            timeout=30,
+        )
+        output = (ahead_behind.stdout or "").strip()
+        if not output:
+            return 0
+        parts = output.split()
+        if len(parts) >= 2:
+            # format: behind ahead
+            ahead_count = int(parts[1])
+            return ahead_count
+        return 0
+    except Exception:
+        return 0

llama_deploy_core-0.3.0a21/src/llama_deploy/core/iter_utils.py

@@ -0,0 +1,196 @@
+"""Iterator utilities for buffering, sorting, and debouncing streams."""
+
+from __future__ import annotations
+
+import asyncio
+import time
+from typing import Any, AsyncGenerator, Callable, TypeVar
+
+from typing_extensions import Literal
+
+T = TypeVar("T")
+
+
+async def debounced_sorted_prefix(
+    inner: AsyncGenerator[T, None],
+    *,
+    key: Callable[[T], Any],
+    debounce_seconds: float = 0.1,
+    max_window_seconds: float = 0.1,
+) -> AsyncGenerator[T, None]:
+    """Yield a stream where the initial burst is sorted, then passthrough.
+
+    Behavior:
+    - Buffer early items and sort them by the provided key.
+    - Flush the buffer when either:
+      - No new item arrives for `debounce_seconds`, or
+      - `max_window_seconds` elapses from the first buffered item, or
+    - After the first flush, subsequent items are yielded passthrough, in arrival order.
+
+    This async variant uses an asyncio.Queue and a background task to pump `inner`.
+    """
+
+    buffer: list[T] = []
+    debouncer = Debouncer(debounce_seconds, max_window_seconds)
+    merged = merge_generators(inner, debouncer.aiter())
+
+    async for item in merged:
+        if item == "__COMPLETE__":
+            buffer.sort(key=key)
+            for item in buffer:
+                yield item
+            buffer = []
+        else:
+            if debouncer.is_complete:
+                yield item
+            else:
+                debouncer.extend_window()
+                buffer.append(item)
+
+
+COMPLETE = Literal["__COMPLETE__"]
+
+
+async def merge_generators(
+    *generators: AsyncGenerator[T, None],
+    stop_on_first_completion: bool = False,
+) -> AsyncGenerator[T, None]:
+    """
+    Merge multiple async iterators into a single async iterator, yielding items as
+    soon as any source produces them.
+
+    - If stop_on_first_completion is False (default), continues until all inputs are exhausted.
+    - If stop_on_first_completion is True, stops as soon as any input completes.
+    - Propagates exceptions from any input immediately.
+    """
+    if not generators:
+        return
+
+    active_generators: dict[int, AsyncGenerator[T, None]] = {
+        index: gen for index, gen in enumerate(generators)
+    }
+
+    next_item_tasks: dict[int, asyncio.Task[T]] = {}
+    exception_to_raise: BaseException | None = None
+    stopped_on_first_completion = False
+
+    # Prime one pending task per generator to maintain fairness
+    for index, gen in active_generators.items():
+        next_item_tasks[index] = asyncio.create_task(anext(gen))
+
+    try:
+        while next_item_tasks and exception_to_raise is None:
+            done, _ = await asyncio.wait(
+                set(next_item_tasks.values()),
+                return_when=asyncio.FIRST_COMPLETED,
+            )
+
+            for finished in done:
+                # Locate which generator this task belonged to
+                task_index: int | None = None
+                for index, task in next_item_tasks.items():
+                    if task is finished:
+                        task_index = index
+                        break
+
+                if task_index is None:
+                    # Should not happen, but continue defensively
+                    continue
+
+                try:
+                    value = finished.result()
+                except StopAsyncIteration:
+                    # Generator exhausted
+                    if stop_on_first_completion:
+                        stopped_on_first_completion = True
+                        # Break out of the inner loop; the outer loop will
+                        # observe the stop flag and exit to the finally block
+                        # where pending tasks are cancelled and generators closed.
+                        break
+                    else:
+                        next_item_tasks.pop(task_index, None)
+                        active_generators.pop(task_index, None)
+                        continue
+                except Exception as exc:  # noqa: BLE001 - propagate specific generator error
+                    exception_to_raise = exc
+                    break
+                else:
+                    # Remove the finished task before yielding
+                    next_item_tasks.pop(task_index, None)
+                    yield value
+                    # Schedule the next item fetch for this generator
+                    gen = active_generators.get(task_index)
+                    if gen is not None:
+                        next_item_tasks[task_index] = asyncio.create_task(anext(gen))
+            # If we are configured to stop on first completion and observed one,
+            # exit the outer loop to perform cleanup in the finally block.
+            if stopped_on_first_completion:
+                break
+    finally:
+        # Ensure we do not leak tasks or open generators
+        for task in next_item_tasks.values():
+            task.cancel()
+        if next_item_tasks:
+            try:
+                await asyncio.gather(*next_item_tasks.values(), return_exceptions=True)
+            except Exception:
+                pass
+        for gen in active_generators.values():
+            try:
+                await gen.aclose()
+            except Exception:
+                pass
+
+    if exception_to_raise is not None:
+        raise exception_to_raise
+    if stopped_on_first_completion:
+        return
+
+
+class Debouncer:
+    """
+    Continually extends a complete time while extend is called, up to a max window.
+    Exposes methods that notify on completion
+    """
+
+    def __init__(
+        self,
+        debounce_seconds: float = 0.1,
+        max_window_seconds: float = 1,
+        get_time: Callable[[], float] = time.monotonic,
+    ):
+        self.debounce_seconds = debounce_seconds
+        self.max_window_seconds = max_window_seconds
+        self.complete_signal = asyncio.Event()
+        self.get_time = get_time
+        self.start_time = self.get_time()
+        self.complete_time = self.start_time + self.debounce_seconds
+        self.max_complete_time = self.start_time + self.max_window_seconds
+        asyncio.create_task(self._loop())
+
+    async def _loop(self):
+        while not self.complete_signal.is_set():
+            now = self.get_time()
+            remaining = min(self.complete_time, self.max_complete_time) - now
+            if remaining <= 0:
+                self.complete_signal.set()
+            else:
+                await asyncio.sleep(remaining)
+
+    @property
+    def is_complete(self) -> bool:
+        return self.complete_signal.is_set()
+
+    def extend_window(self) -> None:
+        """Mark a new item has arrived, extending the debounce window."""
+        now = self.get_time()
+        self.complete_time = now + self.debounce_seconds
+
+    async def wait(self) -> None:
+        """Wait for the debounce window to expire, or the max window to elapse."""
+        await self.complete_signal.wait()
+
+    async def aiter(self) -> AsyncGenerator[COMPLETE, None]:
+        """Yield a stream that emits an element when the wait event occurs."""
+        await self.wait()
+        yield "__COMPLETE__"