llamactl 0.3.24__tar.gz → 0.3.26__tar.gz

{llamactl-0.3.24 → llamactl-0.3.26}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.3
 Name: llamactl
-Version: 0.3.24
+Version: 0.3.26
 Summary: A command-line interface for managing LlamaDeploy projects and deployments
 Author: Adrian Lyjak
 Author-email: Adrian Lyjak <adrianlyjak@gmail.com>
 License: MIT
-Requires-Dist: llama-deploy-core[client]>=0.3.24,<0.4.0
-Requires-Dist: llama-deploy-appserver>=0.3.24,<0.4.0
+Requires-Dist: llama-deploy-core[client]>=0.3.26,<0.4.0
+Requires-Dist: llama-deploy-appserver>=0.3.26,<0.4.0
 Requires-Dist: vibe-llama-core>=0.1.0
 Requires-Dist: rich>=13.0.0
 Requires-Dist: questionary>=2.0.0

{llamactl-0.3.24 → llamactl-0.3.26}/pyproject.toml

@@ -14,7 +14,7 @@ dev = [
 
 [project]
 name = "llamactl"
-version = "0.3.24"
+version = "0.3.26"
 description = "A command-line interface for managing LlamaDeploy projects and deployments"
 readme = "README.md"
 license = {text = "MIT"}
@@ -23,8 +23,8 @@ authors = [
 ]
 requires-python = ">=3.10, <4"
 dependencies = [
-  "llama-deploy-core[client]>=0.3.24,<0.4.0",
-  "llama-deploy-appserver>=0.3.24,<0.4.0",
+  "llama-deploy-core[client]>=0.3.26,<0.4.0",
+  "llama-deploy-appserver>=0.3.26,<0.4.0",
   "vibe-llama-core>=0.1.0",
   "rich>=13.0.0",
   "questionary>=2.0.0",

{llamactl-0.3.24 → llamactl-0.3.26}/src/llama_deploy/cli/commands/dev.py

@@ -79,6 +79,69 @@ def validate_command(deployment_file: Path, interactive: bool) -> None:
     rprint(f"[green]Validated workflows in {config_dir} successfully.[/green]")
 
 
+@dev.command(
+    "export-json-graph",
+    help="Produce a JSON graph representation of registered workflows",
+    hidden=True,  # perhaps expose if we have a built in visualization (mermaid, etc.)
+)
+@click.argument(
+    "deployment_file",
+    required=False,
+    default=DEFAULT_DEPLOYMENT_FILE_PATH,
+    type=_ClickPath(dir_okay=True, resolve_path=True, path_type=Path),
+)
+@click.option(
+    "--output",
+    help=(
+        "File where output JSON graph will be saved. "
+        "Defaults to workflows.json in the current directory."
+    ),
+    required=False,
+    default=None,
+    type=_ClickPath(dir_okay=True, resolve_path=True, path_type=Path),
+)
+@interactive_option
+@global_options
+def export_json_graph_command(
+    deployment_file: Path,
+    output: Path | None,
+    interactive: bool,
+) -> None:
+    """Export the configured workflows to a JSON document that may be used for graph visualization."""
+    if not deployment_file.exists():
+        rprint(f"[red]Deployment file '{deployment_file}' does not exist[/red]")
+        raise click.Abort()
+
+    _ensure_project_layout(
+        deployment_file, command_name="llamactl dev export-json-graph"
+    )
+    _maybe_inject_llama_cloud_credentials(
+        deployment_file, interactive, require_cloud=False
+    )
+
+    prepare_server(
+        deployment_file=deployment_file,
+        install=True,
+        build=False,
+        install_ui_deps=False,
+    )
+
+    wd = Path.cwd()
+    if output is None:
+        output = wd / "workflows.json"
+
+    try:
+        start_export_json_graph_in_target_venv(
+            cwd=wd,
+            deployment_file=deployment_file,
+            output=output,
+        )
+    except subprocess.CalledProcessError as exc:
+        rprint("[red]Workflow JSON graph export failed. See errors above.[/red]")
+        raise Exit(exc.returncode)
+    rprint(f"[green]Exported workflow JSON graph to {output}[/green]")
+
+
 @dev.command(
     "run",
     help=(
@@ -199,6 +262,21 @@ def start_preflight_in_target_venv(*, cwd: Path, deployment_file: Path) -> None:
     _start_preflight_in_target_venv(cwd=cwd, deployment_file=deployment_file)
 
 
+def start_export_json_graph_in_target_venv(
+    *, cwd: Path, deployment_file: Path, output: Path
+) -> None:
+    """Thin wrapper so tests can monkeypatch `dev.start_export_json_graph_in_target_venv`."""
+    from llama_deploy.appserver.app import (
+        start_export_json_graph_in_target_venv as _start_export_json_graph_in_target_venv,
+    )
+
+    _start_export_json_graph_in_target_venv(
+        cwd=cwd,
+        deployment_file=deployment_file,
+        output=output,
+    )
+
+
 def parse_environment_variables(
     config: DeploymentConfig, config_parent: Path
 ) -> dict[str, str]:
@@ -210,4 +288,4 @@ def parse_environment_variables(
     return _parse_environment_variables(config, config_parent)
 
 
-__all__ = ["dev", "validate_command", "run_command"]
+__all__ = ["dev", "validate_command", "run_command", "export_json_graph_command"]

{llamactl-0.3.24 → llamactl-0.3.26}/src/llama_deploy/cli/config/_config.py

@@ -76,7 +76,8 @@ class ConfigManager:
 
         with sqlite3.connect(self.db_path) as conn:
             # Apply ad-hoc SQL migrations based on PRAGMA user_version
-            run_migrations(conn)
+            # Pass db_path to enable file-based locking across processes
+            run_migrations(conn, self.db_path)
 
             conn.commit()
 

{llamactl-0.3.24 → llamactl-0.3.26}/src/llama_deploy/cli/config/_migrations.py

@@ -6,10 +6,14 @@ Inspired by https://eskerda.com/sqlite-schema-migrations-python/
 from __future__ import annotations
 
 import logging
+import os
 import re
 import sqlite3
 import sys
+from contextlib import contextmanager
 from importlib import import_module, resources
+from pathlib import Path
+from typing import Generator
 
 if sys.version_info >= (3, 11):
     from importlib.resources.abc import Traversable
@@ -23,6 +27,42 @@ _MIGRATIONS_PKG = "llama_deploy.cli.config.migrations"
 _USER_VERSION_PATTERN = re.compile(r"pragma\s+user_version\s*=\s*(\d+)", re.IGNORECASE)
 
 
+def _lock_file_unix(fd: int) -> None:
+    """Acquire exclusive lock on Unix using fcntl."""
+    import fcntl
+
+    fcntl.flock(fd, fcntl.LOCK_EX)
+
+
+def _unlock_file_unix(fd: int) -> None:
+    """Release lock on Unix using fcntl."""
+    import fcntl
+
+    fcntl.flock(fd, fcntl.LOCK_UN)
+
+
+@contextmanager
+def _file_lock(lock_path: Path) -> Generator[None, None, None]:
+    """File lock to serialize migrations across processes.
+
+    Uses fcntl.flock on Unix. On Windows, SQLite's built-in locking provides
+    sufficient protection for typical CLI usage patterns.
+    """
+    if os.name == "nt":
+        # On Windows, rely on SQLite's own file locking
+        yield
+        return
+
+    lock_path.parent.mkdir(parents=True, exist_ok=True)
+    lock_file = open(lock_path, "w")  # noqa: SIM115
+    try:
+        _lock_file_unix(lock_file.fileno())
+        yield
+    finally:
+        _unlock_file_unix(lock_file.fileno())
+        lock_file.close()
+
+
 def _iter_migration_files() -> list[Traversable]:
     """Yield packaged SQL migration files in lexicographic order."""
     pkg = import_module(_MIGRATIONS_PKG)
@@ -40,12 +80,8 @@ def _parse_target_version(sql_text: str) -> int | None:
     return int(match.group(1)) if match else None
 
 
-def run_migrations(conn: sqlite3.Connection) -> None:
-    """Apply pending migrations found under the migrations package.
-
-    Each migration file should start with a `PRAGMA user_version=N;` line.
-    Files are applied in lexicographic order and only when N > current_version.
-    """
+def _apply_pending_migrations(conn: sqlite3.Connection) -> None:
+    """Apply pending migrations (internal, assumes lock is held)."""
     cur = conn.cursor()
     current_version_row = cur.execute("PRAGMA user_version").fetchone()
     current_version = int(current_version_row[0]) if current_version_row else 0
@@ -68,3 +104,20 @@ def run_migrations(conn: sqlite3.Connection) -> None:
         else:
             cur.execute("COMMIT")
             current_version = target_version
+
+
+def run_migrations(conn: sqlite3.Connection, db_path: Path | None = None) -> None:
+    """Apply pending migrations found under the migrations package.
+
+    Each migration file should start with a `PRAGMA user_version=N;` line.
+    Files are applied in lexicographic order and only when N > current_version.
+
+    Uses a file lock to prevent concurrent migrations across processes when
+    db_path is provided.
+    """
+    if db_path is not None:
+        lock_path = db_path.with_suffix(".db.lock")
+        with _file_lock(lock_path):
+            _apply_pending_migrations(conn)
+    else:
+        _apply_pending_migrations(conn)