llamactl 0.3.0a6__py3-none-any.whl → 0.3.0a8__py3-none-any.whl

llama_deploy/cli/__init__.py

@@ -1,4 +1,5 @@
 from llama_deploy.cli.commands.deployment import deployments
+from llama_deploy.cli.commands.init import init
 from llama_deploy.cli.commands.profile import profiles
 from llama_deploy.cli.commands.serve import serve
 
@@ -10,7 +11,7 @@ def main() -> None:
     app()
 
 
-__all__ = ["app", "deployments", "profiles", "serve"]
+__all__ = ["app", "deployments", "profiles", "serve", "init"]
 
 
 if __name__ == "__main__":

llama_deploy/cli/client.py

@@ -1,6 +1,8 @@
-from typing import List, Optional
+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,
@@ -17,19 +19,24 @@ from rich.console import Console
 from .config import config_manager
 
 
+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, console: Console) -> None:
         self.base_url = base_url.rstrip("/")
         self.console = console
         self.client = httpx.Client(
-            base_url=self.base_url, event_hooks={"response": [self._handle_response]}
+            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:
-        if "X-Warning" in response.headers:
-            self.console.print(
-                f"[yellow]Warning: {response.headers['X-Warning']}[/yellow]"
-            )
         try:
             response.raise_for_status()
         except httpx.HTTPStatusError as e:
@@ -42,9 +49,9 @@ class BaseClient:
                     error_message = str(error_data)
             except (ValueError, KeyError):
                 error_message = e.response.text
-            raise Exception(f"HTTP {e.response.status_code}: {error_message}") from e
+            raise ClientError(f"HTTP {e.response.status_code}: {error_message}") from e
         except httpx.RequestError as e:
-            raise Exception(f"Request failed: {e}") from e
+            raise ClientError(f"Request failed: {e}") from e
 
 
 class ControlPlaneClient(BaseClient):
@@ -59,7 +66,7 @@ class ControlPlaneClient(BaseClient):
         return response.json()
 
     def list_projects(self) -> List[ProjectSummary]:
-        response = self.client.get("/projects/")
+        response = self.client.get("/api/v1beta1/deployments/list-projects")
         projects_response = ProjectsListResponse.model_validate(response.json())
         return [project for project in projects_response.projects]
 
@@ -95,25 +102,35 @@ class ProjectClient(BaseClient):
         self.project_id = project_id
 
     def list_deployments(self) -> List[DeploymentResponse]:
-        response = self.client.get(f"/{self.project_id}/deployments/")
+        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) -> DeploymentResponse:
-        response = self.client.get(f"/{self.project_id}/deployments/{deployment_id}")
+        response = self.client.get(
+            f"/api/v1beta1/deployments/{deployment_id}",
+            params={"project_id": self.project_id},
+        )
         return DeploymentResponse.model_validate(response.json())
 
     def create_deployment(
         self, deployment_data: DeploymentCreate
     ) -> DeploymentResponse:
         response = self.client.post(
-            f"/{self.project_id}/deployments/",
+            "/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"/{self.project_id}/deployments/{deployment_id}")
+        self.client.delete(
+            f"/api/v1beta1/deployments/{deployment_id}",
+            params={"project_id": self.project_id},
+        )
 
     def update_deployment(
         self,
@@ -121,7 +138,8 @@ class ProjectClient(BaseClient):
         update_data: DeploymentUpdate,
     ) -> DeploymentResponse:
         response = self.client.patch(
-            f"/{self.project_id}/deployments/{deployment_id}",
+            f"/api/v1beta1/deployments/{deployment_id}",
+            params={"project_id": self.project_id},
             json=update_data.model_dump(),
         )
         return DeploymentResponse.model_validate(response.json())
@@ -133,7 +151,8 @@ class ProjectClient(BaseClient):
         pat: str | None = None,
     ) -> RepositoryValidationResponse:
         response = self.client.post(
-            f"/{self.project_id}/deployments/validate-repository",
+            "/api/v1beta1/deployments/validate-repository",
+            params={"project_id": self.project_id},
             json=RepositoryValidationRequest(
                 repository_url=repo_url,
                 deployment_id=deployment_id,
@@ -142,6 +161,81 @@ class ProjectClient(BaseClient):
         )
         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
+
 
 def get_control_plane_client(base_url: str | None = None) -> ControlPlaneClient:
     console = Console()
@@ -174,3 +268,6 @@ def get_project_client(
     if not resolved_project_id:
         raise ValueError("Project ID is required")
     return ProjectClient(resolved_base_url, resolved_project_id, console)
+
+
+type Closer = callable[tuple[()], None]

llama_deploy/cli/commands/deployment.py

@@ -19,6 +19,7 @@ from ..interactive_prompts.utils import (
 )
 from ..options import global_options
 from ..textual.deployment_form import create_deployment_form, edit_deployment_form
+from ..textual.deployment_monitor import monitor_deployment_screen
 
 
 @app.group(
@@ -88,7 +89,12 @@ def list_deployments() -> None:
 @deployments.command("get")
 @global_options
 @click.argument("deployment_id", required=False)
-def get_deployment(deployment_id: str | None) -> None:
+@click.option(
+    "--non-interactive",
+    is_flag=True,
+    help="Do not open a live monitor screen showing status and streaming logs",
+)
+def get_deployment(deployment_id: str | None, non_interactive: bool) -> None:
     """Get details of a specific deployment"""
     try:
         client = get_project_client()
@@ -98,6 +104,10 @@ def get_deployment(deployment_id: str | None) -> None:
             rprint("[yellow]No deployment selected[/yellow]")
             return
 
+        if not non_interactive:
+            monitor_deployment_screen(deployment_id)
+            return
+
         deployment = client.get_deployment(deployment_id)
 
         table = Table(title=f"Deployment: {deployment.name}")
@@ -143,7 +153,7 @@ def create_deployment(
     git_ref: str | None,
     personal_access_token: str | None,
 ) -> None:
-    """Create a new deployment"""
+    """Interactively create a new deployment"""
 
     # Use interactive creation
     deployment_form = create_deployment_form()
@@ -214,11 +224,11 @@ def edit_deployment(deployment_id: str | None) -> None:
         raise click.Abort()
 
 
-@deployments.command("refresh")
+@deployments.command("update")
 @global_options
 @click.argument("deployment_id", required=False)
 def refresh_deployment(deployment_id: str | None) -> None:
-    """Refresh a deployment with the latest code from its git reference"""
+    """Update the deployment, pulling the latest code from it's branch"""
     try:
         client = get_project_client()
 

llama_deploy/cli/commands/init.py

@@ -0,0 +1,210 @@
+import os
+import shutil
+import subprocess
+from dataclasses import dataclass
+from pathlib import Path
+
+import click
+import copier
+import questionary
+from click.exceptions import Exit
+from llama_deploy.cli.app import app
+from llama_deploy.cli.options import global_options
+from rich import print as rprint
+
+
+@dataclass
+class TemplateOption:
+    id: str
+    name: str
+    description: str
+    git_url: str
+
+
+options = [
+    TemplateOption(
+        id="basic-ui",
+        name="Basic UI",
+        description="A basic starter workflow with a React Vite UI",
+        git_url="https://github.com/adrianlyjak/qs",
+    ),
+    TemplateOption(
+        id="extraction-review",
+        name="Extraction Agent with Review UI",
+        description="Extract data from documents using a custom schema and Llama Cloud. Includes a UI to review and correct the results",
+        git_url="https://github.com/run-llama/template-workflow-data-extraction",
+    ),
+]
+
+
+@app.command()
+@click.option(
+    "--update",
+    is_flag=True,
+    help="Instead of creating a new app, update the current app to the latest version. Other options will be ignored.",
+)
+@click.option(
+    "--template",
+    type=click.Choice([o.id for o in options]),
+    help="The template to use for the new app",
+)
+@click.option(
+    "--dir",
+    help="The directory to create the new app in",
+    type=click.Path(
+        file_okay=False, dir_okay=True, writable=True, resolve_path=True, path_type=Path
+    ),
+)
+@click.option(
+    "--force",
+    is_flag=True,
+    help="Force overwrite the directory if it exists",
+)
+@global_options
+def init(
+    update: bool,
+    template: str | None,
+    dir: Path | None,
+    force: bool,
+) -> None:
+    """Create a new app repository from a template"""
+    if update:
+        _update()
+    else:
+        _create(template, dir, force)
+
+
+def _create(template: str | None, dir: Path | None, force: bool) -> None:
+    if template is None:
+        template = questionary.select(
+            "Choose a template",
+            choices=[
+                questionary.Choice(title=o.name, value=o.id, description=o.description)
+                for o in options
+            ],
+        ).ask()
+    if template is None:
+        rprint("No template selected")
+        raise Exit(1)
+    if dir is None:
+        dir_str = questionary.text(
+            "Enter the directory to create the new app in", default=template
+        ).ask()
+        if not dir_str:
+            rprint("No directory provided")
+            raise Exit(1)
+        dir = Path(dir_str)
+    resolved_template = next((o for o in options if o.id == template), None)
+    if resolved_template is None:
+        rprint(f"Template {template} not found")
+        raise Exit(1)
+    if dir.exists():
+        is_ok = (
+            force
+            or questionary.confirm("Directory exists. Overwrite?", default=False).ask()
+        )
+        if not is_ok:
+            raise Exit(1)
+        else:
+            shutil.rmtree(dir, ignore_errors=True)
+    copier.run_copy(
+        resolved_template.git_url,
+        dir,
+        quiet=True,
+    )
+    # Initialize git repository if git is available
+    is_git_initialized = False
+    try:
+        subprocess.run(["git", "--version"], check=True, capture_output=True)
+
+        # Change to the new directory and initialize git repo
+        original_cwd = Path.cwd()
+        os.chdir(dir)
+
+        try:
+            subprocess.run(["git", "init"], check=True, capture_output=True)
+            subprocess.run(["git", "add", "."], check=True, capture_output=True)
+            subprocess.run(
+                ["git", "commit", "-m", "Initial commit"],
+                check=True,
+                capture_output=True,
+            )
+            is_git_initialized = True
+        finally:
+            os.chdir(original_cwd)
+
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        # Git not available or failed - continue without git initialization
+        pass
+
+    rprint(
+        f"Successfully created [blue]{dir}[/] using the [blue]{resolved_template.name}[/] template! 🎉 🦙 💾"
+    )
+    rprint("")
+    rprint("[bold]To run locally:[/]")
+    rprint(f"    [orange3]cd[/] {dir}")
+    rprint("    [orange3]uvx[/] llamactl serve")
+    rprint("")
+    rprint("[bold]To deploy:[/]")
+    if not is_git_initialized:
+        rprint("    [orange3]git[/] init")
+        rprint("    [orange3]git[/] add .")
+        rprint("    [orange3]git[/] commit -m 'Initial commit'")
+        rprint("")
+    rprint("[dim](Create a new repo and add it as a remote)[/]")
+    rprint("")
+    rprint("    [orange3]git[/] remote add origin <your-repo-url>")
+    rprint("    [orange3]git[/] push -u origin main")
+    rprint("")
+    # rprint("  [orange3]uvx[/] llamactl login")
+    rprint("    [orange3]uvx[/] llamactl deploy")
+    rprint("")
+
+
+def _update():
+    """Update the app to the latest version"""
+    try:
+        copier.run_update(
+            overwrite=True,
+            skip_answered=True,
+            quiet=True,
+        )
+    except copier.UserMessageError as e:
+        rprint(f"{e}")
+        raise Exit(1)
+
+    # Check git status and warn about conflicts
+    try:
+        result = subprocess.run(
+            ["git", "status", "--porcelain"],
+            check=True,
+            capture_output=True,
+            text=True,
+        )
+
+        if result.stdout.strip():
+            conflicted_files = []
+            modified_files = []
+
+            for line in result.stdout.strip().split("\n"):
+                status = line[:2]
+                filename = line[3:]
+
+                if "UU" in status or "AA" in status or "DD" in status:
+                    conflicted_files.append(filename)
+                elif status.strip():
+                    modified_files.append(filename)
+
+            if conflicted_files:
+                rprint("")
+                rprint("⚠️  [bold]Files with conflicts detected:[/]")
+                for file in conflicted_files:
+                    rprint(f"    {file}")
+                rprint("")
+                rprint(
+                    "Please manually resolve conflicts with a merge editor before proceeding."
+                )
+
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        # Git not available or not in a git repo - continue silently
+        pass

llama_deploy/cli/commands/serve.py

@@ -20,7 +20,7 @@ from ..options import global_options
     "deployment_file",
     required=False,
     default=DEFAULT_DEPLOYMENT_FILE_PATH,
-    type=click.Path(dir_okay=False, resolve_path=True, path_type=Path),
+    type=click.Path(dir_okay=True, resolve_path=True, path_type=Path),
 )
 @click.option(
     "--no-install", is_flag=True, help="Skip installing python and js dependencies"
@@ -34,6 +34,8 @@ from ..options import global_options
     is_flag=True,
     help="Preview mode pre-builds the UI to static files, like a production build",
 )
+@click.option("--port", type=int, help="The port to run the API server on")
+@click.option("--ui-port", type=int, help="The port to run the UI proxy server on")
 @global_options
 def serve(
     deployment_file: Path,
@@ -41,8 +43,10 @@ def serve(
     no_reload: bool,
     no_open_browser: bool,
     preview: bool,
+    port: int | None = None,
+    ui_port: int | None = None,
 ) -> None:
-    """Run llama_deploy API Server in the foreground. If no deployment_file is provided, will look for a llama_deploy.yaml in the current directory."""
+    """Run llama_deploy API Server in the foreground. Reads the deployment configuration from the current directory. Can optionally specify a deployment file path."""
     if not deployment_file.exists():
         rprint(f"[red]Deployment file '{deployment_file}' not found[/red]")
         raise click.Abort()
@@ -58,6 +62,8 @@ def serve(
             proxy_ui=not preview,
             reload=not no_reload,
             open_browser=not no_open_browser,
+            port=port,
+            ui_port=ui_port,
         )
 
     except KeyboardInterrupt:

llama_deploy/cli/config.py

@@ -4,7 +4,7 @@ import os
 import sqlite3
 from dataclasses import dataclass
 from pathlib import Path
-from typing import List, Optional
+from typing import List
 
 
 @dataclass

llama_deploy/cli/interactive_prompts/utils.py

@@ -1,7 +1,5 @@
 """Shared utilities for CLI operations"""
 
-from typing import Optional
-
 import questionary
 from rich import print as rprint
 from rich.console import Console