llama-deploy-core 0.3.0a6__py3-none-any.whl → 0.3.0a8__py3-none-any.whl

llama_deploy/core/config.py

@@ -1 +1 @@
-DEFAULT_DEPLOYMENT_FILE_PATH = "llama_deploy.yaml"
+DEFAULT_DEPLOYMENT_FILE_PATH = "."

llama_deploy/core/deployment_config.py

@@ -1,11 +1,288 @@
+from __future__ import annotations
+
+import json
+import tomllib
 from pathlib import Path
 from typing import Any
 
 import yaml
-from pydantic import BaseModel, ConfigDict, Field, model_validator
+from llama_deploy.core.path_util import validate_path_traversal
+from pydantic import BaseModel, ConfigDict, Field, ValidationError, model_validator
+
+DEFAULT_DEPLOYMENT_NAME = "default"
+
+
+def read_deployment_config(source_root: Path, config_path: Path) -> "DeploymentConfig":
+    """
+    Read the deployment config from the config directory.
+
+    - first checks for a llamadeploy.toml in the config_path
+    - then checks for a tool config in the pyproject.toml
+    - then check for a legacy yaml config (if config_path is a file, uses that, otherwise uses the config_path/llama_deploy.yaml)
+    - based on what was resolved here, discovers the package.json, if any ui, and resolves its values from the package.json
+
+    Args:
+        source_root: path to the root of the source code. References should not exit this directory.
+        config_path: path to a deployment config file, or directory containing a deployment config file.
+
+    Returns:
+        DeploymentConfig: the deployment config
+    """
+    config_file: Path | None = None
+    if (source_root / config_path).is_file():
+        config_file = Path(config_path.name)
+        if str(config_file) in {"llama_deploy.toml", "pyproject.toml"}:
+            config_file = None
+        config_path = config_path.parent
+    local_toml_path = source_root / config_path / "llama_deploy.toml"
+    pyproject_path = source_root / config_path / "pyproject.toml"
+    toml_config: DeploymentConfig = DeploymentConfig()
+    # local TOML format
+    if local_toml_path.exists():
+        with open(local_toml_path, "rb") as toml_file:
+            toml_data = tomllib.load(toml_file)
+            if isinstance(toml_data, dict):
+                toml_config = DeploymentConfig.model_validate(toml_data)
+    # pyproject.toml format
+    elif pyproject_path.exists():
+        with open(pyproject_path, "rb") as pyproject_file:
+            pyproject = tomllib.load(pyproject_file)
+            tool = pyproject.get("tool", {})
+            project_name: str | None = None
+            project_metadata = pyproject.get("project", {})
+            if isinstance(project_metadata, dict):
+                name = project_metadata.get("name")
+                if isinstance(name, str):
+                    project_name = name
+            if isinstance(tool, dict):
+                llama_deploy = tool.get("llamadeploy", {})
+                if isinstance(llama_deploy, dict):
+                    if "name" not in llama_deploy:
+                        llama_deploy["name"] = project_name
+                    toml_config = DeploymentConfig.model_validate(llama_deploy)
+    # legacy yaml format, (and why not support yaml in the new format too, since this is doing everything all the ways)
+    if toml_config.has_no_workflows():
+        yaml_path = (
+            source_root / config_path / (config_file or Path("llama_deploy.yaml"))
+        )
+        if yaml_path.exists():
+            with open(yaml_path, "r", encoding="utf-8") as yaml_file:
+                yaml_loaded = yaml.safe_load(yaml_file) or {}
+
+            old_config: DeploymentConfig | None = None
+            new_config: DeploymentConfig | None = None
+            try:
+                old_config = DeprecatedDeploymentConfig.model_validate(
+                    yaml_loaded
+                ).to_deployment_config()
+            except ValidationError:
+                pass
+            try:
+                new_config = DeploymentConfig.model_validate(yaml_loaded)
+            except ValidationError:
+                pass
+            loaded: DeploymentConfig | None = new_config
+            if (
+                old_config is not None
+                and old_config.is_valid()
+                and (new_config is None or not new_config.is_valid())
+            ):
+                loaded = old_config
+            if loaded is not None:
+                toml_config = toml_config.merge_config(loaded)
+
+    # package.json format
+    if toml_config.ui is not None:
+        package_json_path = (
+            source_root / config_path / toml_config.ui.directory / "package.json"
+        )
+        if package_json_path.exists():
+            with open(package_json_path, "r", encoding="utf-8") as package_json_file:
+                package_json = json.load(package_json_file)
+            if isinstance(package_json, dict):
+                # Standard packageManager fallback, e.g. "pnpm@9.0.0" -> "pnpm"
+                pkg_manager_value = package_json.get("packageManager")
+                pkg_manager_name: str | None = None
+                if isinstance(pkg_manager_value, str) and pkg_manager_value:
+                    pkg_manager_name = pkg_manager_value.split("@", 1)[0] or None
+
+                llama_deploy = package_json.get("llamadeploy", {})
+
+                if isinstance(llama_deploy, dict):
+                    # Prepare payload without leaking Path objects into Pydantic
+                    ui_dir = toml_config.ui.directory if toml_config.ui else None
+                    ui_payload: dict[str, object] = {**llama_deploy}
+                    if "directory" not in ui_payload and ui_dir is not None:
+                        ui_payload["directory"] = ui_dir
+                    if (
+                        "package_manager" not in ui_payload
+                        and pkg_manager_name is not None
+                    ):
+                        ui_payload["package_manager"] = pkg_manager_name
+
+                    ui_config = UIConfig.model_validate(ui_payload)
+                    if ui_config.build_output_dir is not None:
+                        ui_config.build_output_dir = str(
+                            Path(toml_config.ui.directory) / ui_config.build_output_dir
+                        )
+                    toml_config.ui = ui_config.merge_config(toml_config.ui)
+
+    if toml_config.ui is not None:
+        validate_path_traversal(
+            config_path / toml_config.ui.directory, source_root, "ui_source"
+        )
+        if toml_config.ui.build_output_dir:
+            validate_path_traversal(
+                config_path / toml_config.ui.build_output_dir,
+                source_root,
+                "ui_build_output_dir",
+            )
+
+    return toml_config
+
+
+def resolve_config_parent(root: Path, deployment_path: Path) -> Path:
+    path = root / deployment_path
+    if path.is_file():
+        return path.parent
+    else:
+        return path
+
+
+DEFAULT_UI_PACKAGE_MANAGER = "npm"
+DEFAULT_UI_BUILD_COMMAND = "build"
+DEFAULT_UI_SERVE_COMMAND = "dev"
+DEFAULT_UI_PROXY_PORT = 4502
+
+
+class DeploymentConfig(BaseModel):
+    name: str = Field(
+        default=DEFAULT_DEPLOYMENT_NAME,
+        description="The url safe path name of the deployment.",
+    )
+    app: str | None = Field(
+        None,
+        description="A full bundle of all workflows as an 'app'. \"path.to_import:app_name\"",
+    )
+    workflows: dict[str, str] = Field(
+        default_factory=dict,
+        description='Deprecated: A map of workflow names to their import paths. "nice_name": "path.to_import:workflow_name"',
+    )
+    env_files: list[str] = Field(
+        default_factory=list,
+        description="The environment files to load. Defaults to ['.env']",
+    )
+    env: dict[str, str] = Field(
+        default_factory=dict,
+        description="Arbitrary environment variables to set. Defaults to {}",
+    )
+    ui: UIConfig | None = Field(
+        None,
+        description="The UI configuration.",
+    )
+
+    def merge_config(self, config: "DeploymentConfig") -> "DeploymentConfig":
+        """Merge the config with another config."""
 
+        return DeploymentConfig(
+            name=_pick_non_default(self.name, config.name, "default"),
+            app=self.app or config.app,
+            workflows={**self.workflows, **config.workflows},
+            env_files=list(set(self.env_files + config.env_files)),
+            env={**self.env, **config.env},
+            ui=self.ui.merge_config(config.ui)
+            if config.ui is not None and self.ui is not None
+            else self.ui or config.ui,
+        )
 
-class ServiceSource(BaseModel):
+    def has_no_workflows(self) -> bool:
+        """Check if the config has no workflows."""
+        return len(self.workflows) == 0 and self.app is None
+
+    def has_both_app_and_workflows(self) -> bool:
+        """Check if the config has both app and workflows."""
+        return self.app is not None and len(self.workflows) > 0
+
+    def is_valid(self) -> bool:
+        """Check if the config is valid."""
+        try:
+            self.validate()
+            return True
+        except ValueError:
+            return False
+
+    def validate(self) -> None:
+        """Validate the config."""
+        if self.has_no_workflows():
+            raise ValueError("Config must have at least one workflow.")
+        if self.has_both_app_and_workflows():
+            raise ValueError("Config cannot have both app and workflows configured.")
+
+    def build_output_path(self) -> Path | None:
+        """get the build output path, or default to the ui directory/dist"""
+        if self.ui is None:
+            return None
+        return (
+            Path(self.ui.build_output_dir)
+            if self.ui.build_output_dir
+            else Path(self.ui.directory) / "dist"
+        )
+
+
+def _pick_non_default[T](a: T, b: T, default: T) -> T:
+    if a != default:
+        return a
+    return b or default
+
+
+class UIConfig(BaseModel):
+    directory: str = Field(
+        ...,
+        description="The directory containing the UI, relative to the pyproject.toml directory",
+    )
+    build_output_dir: str | None = Field(
+        None,
+        description="The directory containing the built UI, relative to the pyproject.toml directory. Defaults to 'dist' relative to the ui_directory, if defined",
+    )
+    package_manager: str = Field(
+        DEFAULT_UI_PACKAGE_MANAGER,
+        description=f"The package manager to use to build the UI. Defaults to '{DEFAULT_UI_PACKAGE_MANAGER}'",
+    )
+    build_command: str = Field(
+        DEFAULT_UI_BUILD_COMMAND,
+        description=f"The npm script command to build the UI. Defaults to '{DEFAULT_UI_BUILD_COMMAND}' if not specified",
+    )
+    serve_command: str = Field(
+        DEFAULT_UI_SERVE_COMMAND,
+        description=f"The command to serve the UI. Defaults to '{DEFAULT_UI_SERVE_COMMAND}' if not specified",
+    )
+    proxy_port: int = Field(
+        DEFAULT_UI_PROXY_PORT,
+        description=f"The port to proxy the UI to. Defaults to '{DEFAULT_UI_PROXY_PORT}' if not specified",
+    )
+
+    def merge_config(self, config: "UIConfig") -> "UIConfig":
+        """Merge the config with the default config."""
+
+        return UIConfig(
+            directory=self.directory,
+            build_output_dir=self.build_output_dir or config.build_output_dir,
+            package_manager=_pick_non_default(
+                self.package_manager, config.package_manager, DEFAULT_UI_PACKAGE_MANAGER
+            ),
+            build_command=_pick_non_default(
+                self.build_command, config.build_command, DEFAULT_UI_BUILD_COMMAND
+            ),
+            serve_command=_pick_non_default(
+                self.serve_command, config.serve_command, DEFAULT_UI_SERVE_COMMAND
+            ),
+            proxy_port=_pick_non_default(
+                self.proxy_port, config.proxy_port, DEFAULT_UI_PROXY_PORT
+            ),
+        )
+
+
+class ServiceSourceV0(BaseModel):
     """Configuration for where to load the workflow or other source. Path is relative to the config file its declared within."""
 
     location: str
@@ -19,10 +296,10 @@ class ServiceSource(BaseModel):
         return data
 
 
-class Service(BaseModel):
+class DerecatedService(BaseModel):
     """Configuration for a single service."""
 
-    source: ServiceSource | None = Field(None)
+    source: ServiceSourceV0 | None = Field(None)
     import_path: str | None = Field(None)
     env: dict[str, str] | None = Field(None)
     env_files: list[str] | None = Field(None)
@@ -54,22 +331,15 @@ class Service(BaseModel):
         return Path(module_name).name, workflow_name
 
 
-class UIService(Service):
-    port: int = Field(
-        default=3000,
-        description="The TCP port to use for the nextjs server",
-    )
-
-
-class DeploymentConfig(BaseModel):
+class DeprecatedDeploymentConfig(BaseModel):
     """Model definition mapping a deployment config file."""
 
     model_config = ConfigDict(populate_by_name=True, extra="ignore")
 
     name: str
     default_service: str | None = Field(None)
-    services: dict[str, Service]
-    ui: UIService | None = None
+    services: dict[str, DerecatedService]
+    ui: DerecatedService | None = None
 
     @model_validator(mode="before")
     @classmethod
@@ -82,18 +352,42 @@ class DeploymentConfig(BaseModel):
         return data
 
     @classmethod
-    def from_yaml_bytes(cls, src: bytes) -> "DeploymentConfig":
-        """Read config data from bytes containing yaml code."""
-        config = yaml.safe_load(src) or {}
-        return cls(**config)
-
-    @classmethod
-    def from_yaml(cls, path: Path, name: str | None = None) -> "DeploymentConfig":
+    def from_yaml(
+        cls,
+        path: Path,
+    ) -> "DeprecatedDeploymentConfig":
         """Read config data from a yaml file."""
         with open(path, "r", encoding="utf-8") as yaml_file:
             config = yaml.safe_load(yaml_file) or {}
 
-        instance = cls(**config)
-        if name:
-            instance.name = name
+        instance = cls.model_validate(config)
         return instance
+
+    def to_deployment_config(self) -> DeploymentConfig:
+        """Convert the deployment config to a DeploymentConfig."""
+        workflows = {}
+        env_files = []
+        env = {}
+        ui_directory: str | None = None
+        for service_name, service in self.services.items():
+            if service.import_path:
+                path, name = service.module_location()
+                workflows[service_name] = f"{path}:{name}"
+            if service.env_files:
+                env_files.extend(service.env_files)
+            if service.env:
+                env.update(service.env)
+        if self.default_service:
+            workflows["default"] = workflows[self.default_service]
+        env_files = list(set(env_files))
+
+        if self.ui:
+            ui_directory = self.ui.source.location
+
+        return DeploymentConfig(
+            name=self.name,
+            workflows=workflows,
+            env_files=env_files,
+            env=env,
+            ui=UIConfig(directory=ui_directory) if ui_directory else None,
+        )

llama_deploy/core/git/git_util.py

@@ -261,3 +261,11 @@ def get_current_branch() -> str | None:
     """
     result = _run_process(["git", "branch", "--show-current"])
     return result.strip() if result.strip() else None
+
+
+def get_git_root() -> Path:
+    """
+    get the root of the current git repo
+    """
+    result = _run_process(["git", "rev-parse", "--show-toplevel"])
+    return Path(result.strip())

llama_deploy/core/path_util.py

@@ -0,0 +1,24 @@
+from pathlib import Path
+
+
+def validate_path_traversal(
+    path: Path, source_root: Path, path_type: str = "path"
+) -> None:
+    """Validates that a path is within the source root to prevent path traversal attacks.
+
+    Args:
+        path: The path to validate
+        source_root: The root directory that paths should be relative to
+        path_type: Description of the path type for error messages
+
+    Raises:
+        DeploymentError: If the path is outside the source root
+    """
+    resolved_path = (source_root / path).resolve()
+    resolved_source_root = source_root.resolve()
+
+    if not resolved_path.is_relative_to(resolved_source_root):
+        msg = (
+            f"{path_type} {path} is not a subdirectory of the source root {source_root}"
+        )
+        raise RuntimeError(msg)

llama_deploy/core/schema/__init__.py

@@ -1,4 +1,4 @@
-from .base import Base
+from .base import Base, LogEvent
 from .deployments import (
     DeploymentCreate,
     DeploymentResponse,
@@ -13,6 +13,7 @@ from .projects import ProjectsListResponse, ProjectSummary
 
 __all__ = [
     "Base",
+    "LogEvent",
     "DeploymentCreate",
     "DeploymentResponse",
     "DeploymentUpdate",

llama_deploy/core/schema/base.py

@@ -1,3 +1,5 @@
+from datetime import datetime
+
 from pydantic import BaseModel, ConfigDict
 
 base_config = ConfigDict(
@@ -18,3 +20,10 @@ base_config = ConfigDict(
 
 class Base(BaseModel):
     model_config = base_config
+
+
+class LogEvent(Base):
+    pod: str
+    container: str
+    text: str
+    timestamp: datetime

llama_deploy/core/schema/deployments.py

@@ -30,6 +30,7 @@ class DeploymentResponse(Base):
     secret_names: list[str] | None = None
     apiserver_url: HttpUrl | None
     status: LlamaDeploymentPhase
+    warning: str | None = None
 
 
 class DeploymentsListResponse(Base):
@@ -65,7 +66,7 @@ class LlamaDeploymentSpec(Base):
 
     projectId: str
     repoUrl: str
-    deploymentFilePath: str = "llama_deploy.yaml"
+    deploymentFilePath: str = "."
     gitRef: str | None = None
     gitSha: str | None = None
     name: str
@@ -164,7 +165,6 @@ def apply_deployment_update(
     updated_spec.staticAssetsPath = (
         str(update.static_assets_path) if update.static_assets_path else None
     )
-    print(f"staticAssetsPath: {updated_spec.staticAssetsPath}")
 
     # Track secret changes
     secret_adds: dict[str, str] = {}

llama_deploy/core/schema/git_validation.py

@@ -1,5 +1,4 @@
 from pathlib import Path
-from typing import Optional
 
 from pydantic import BaseModel, Field
 

llama_deploy/core/ui_build.py

@@ -10,8 +10,7 @@ def resolve_ui_root(config_parent: Path, config: DeploymentConfig) -> Path | Non
     """Return the absolute path to the UI root if UI is configured; otherwise None."""
     if config.ui is None:
         return None
-    rel = config.ui.source.location if config.ui.source else "."
-    return (config_parent / rel).resolve()
+    return (config_parent / config.ui.directory).resolve()
 
 
 def ui_build_output_path(config_parent: Path, config: DeploymentConfig) -> Path | None:
@@ -20,22 +19,26 @@ def ui_build_output_path(config_parent: Path, config: DeploymentConfig) -> Path
     Right now, assumes its just `/dist` in the UI root.
 
     Returns:
-    - True if a package.json exists and contains a "build" script
-    - False if a package.json exists but lacks a "build" script
+    - Path to the build output directory if a package.json exists and contains a "build" script
     - None if there is no UI configured or no package.json exists
     """
     ui_root = resolve_ui_root(config_parent, config)
     if ui_root is None:
         return None
+    if config.ui is None:
+        return None
     package_json = ui_root / "package.json"
     if not package_json.exists():
         return None
     try:
         with open(package_json, "r", encoding="utf-8") as f:
             pkg = json.load(f)
+        if not isinstance(pkg, dict):
+            return None
         scripts = pkg.get("scripts", {}) or {}
-        if "build" in scripts:
-            return (ui_root / "dist").relative_to(config_parent)
+        if config.ui.build_command in scripts:
+            return config.build_output_path()
+        return None
     except Exception:
         # Do not raise for malformed package.json in validation contexts
         return None

{llama_deploy_core-0.3.0a6.dist-info → llama_deploy_core-0.3.0a8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: llama-deploy-core
-Version: 0.3.0a6
+Version: 0.3.0a8
 Summary: Core models and schemas for LlamaDeploy
 License: MIT
 Requires-Dist: pydantic>=2.0.0

llama_deploy_core-0.3.0a8.dist-info/RECORD

@@ -0,0 +1,14 @@
+llama_deploy/core/__init__.py,sha256=112612bf2e928c2e0310d6556bb13fc28c00db70297b90a8527486cd2562e408,43
+llama_deploy/core/config.py,sha256=69bb0ea8ac169eaa4e808cd60a098b616bddd3145d26c6c35e56db38496b0e6a,35
+llama_deploy/core/deployment_config.py,sha256=ff10cc96f2c64abc4761eb83c5372fd22f3770159b45503818264723b578de4e,15092
+llama_deploy/core/git/git_util.py,sha256=c581c1da13871b4e89eda58f56ddb074139454c06ae9b04c0b396fdb2b9a5176,9193
+llama_deploy/core/path_util.py,sha256=14d50c0c337c8450ed46cafc88436027056b365a48370a69cdb76c88d7c26fd1,798
+llama_deploy/core/schema/__init__.py,sha256=cc60a6fb54983d7ca13e2cc86d414a0d006a79c20e44344701f9fbe3b1d21577,739
+llama_deploy/core/schema/base.py,sha256=c02e33e35e7e4540b3065a82267febeb6da169222210a1d1c2479f6a7f1c6a4b,802
+llama_deploy/core/schema/deployments.py,sha256=fe4c540d39a3e369e3fa286df128398043f591ddc4a623ccb2d432596c53dca6,6108
+llama_deploy/core/schema/git_validation.py,sha256=27b306aa6ecabe58cab6381d92551545f263fe7550c58b3087115410bc71fd21,1915
+llama_deploy/core/schema/projects.py,sha256=c97eda38207d80354c2ee3a237cba9c3f6838148197cfa2d97b9a18d3da1a38b,294
+llama_deploy/core/ui_build.py,sha256=290dafa951918e5593b9035570fa4c66791d7e5ea785bd372ad11e99e8283857,1514
+llama_deploy_core-0.3.0a8.dist-info/WHEEL,sha256=66530aef82d5020ef5af27ae0123c71abb9261377c5bc519376c671346b12918,79
+llama_deploy_core-0.3.0a8.dist-info/METADATA,sha256=f5fe24509ec6739b64202009cd19dc590052aa2a35cddf114ba985e430969993,402
+llama_deploy_core-0.3.0a8.dist-info/RECORD,,

llama_deploy_core-0.3.0a6.dist-info/RECORD

@@ -1,13 +0,0 @@
-llama_deploy/core/__init__.py,sha256=112612bf2e928c2e0310d6556bb13fc28c00db70297b90a8527486cd2562e408,43
-llama_deploy/core/config.py,sha256=41c5a1baa25a67f0bb58b701ef8f0b8b3281714d7116580b8f87674eb9e396a3,51
-llama_deploy/core/deployment_config.py,sha256=2907106ca4cb504fda407bf2c7b1114a50ed12da00b3876e4340016f2ffbb78d,3143
-llama_deploy/core/git/git_util.py,sha256=d3a57ce6c8bce3da26bd554df222988ea02fb1e20f3f5192dad69a2bbd1395a4,9007
-llama_deploy/core/schema/__init__.py,sha256=3e838d5304bc1f11c42590ba78267405e957e11add783e280d00bf5766728072,713
-llama_deploy/core/schema/base.py,sha256=2de6d23e58c36b6bb311ec0aea4b902661867056c1250c6b7ce3bad17141fe15,677
-llama_deploy/core/schema/deployments.py,sha256=b23a458f71cebc4b13ab32e922ba6759dcb7f69eeca2b5e28cda10766a109251,6157
-llama_deploy/core/schema/git_validation.py,sha256=ce58491992252fd0bba6dcf3fc776f57995eb407a531aeb0a050a4f0587f6e50,1943
-llama_deploy/core/schema/projects.py,sha256=c97eda38207d80354c2ee3a237cba9c3f6838148197cfa2d97b9a18d3da1a38b,294
-llama_deploy/core/ui_build.py,sha256=88226f6f2b9a91b86de7d4c49024ef254d946b6519057712bb51bcae8a8deaeb,1472
-llama_deploy_core-0.3.0a6.dist-info/WHEEL,sha256=66530aef82d5020ef5af27ae0123c71abb9261377c5bc519376c671346b12918,79
-llama_deploy_core-0.3.0a6.dist-info/METADATA,sha256=fb6f43d57436b11908fa44388c04c3326e3322b3329a4941522ac3032dfb251c,402
-llama_deploy_core-0.3.0a6.dist-info/RECORD,,