doover-cli 0.4.3__tar.gz → 0.5.1__tar.gz

{doover_cli-0.4.3 → doover_cli-0.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: doover-cli
-Version: 0.4.3
+Version: 0.5.1
 Summary: CLI for Doover
 License-File: LICENSE
 Requires-Python: >=3.11

{doover_cli-0.4.3 → doover_cli-0.5.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "doover-cli"
-version = "0.4.3"
+version = "0.5.1"
 description = "CLI for Doover"
 requires-python = ">=3.11"
 dependencies = [

{doover_cli-0.4.3 → doover_cli-0.5.1}/src/doover_cli/apps/apps.py

@@ -31,6 +31,7 @@ from ..utils.apps import (
     call_with_uv,
     get_docker_path,
     get_app_config,
+    preserve_file,
 )
 from ..utils.crud import (
     build_update_command,
@@ -961,35 +962,40 @@ def publish(
     # Resolve the app name early so subsequent get_app_config calls don't re-prompt.
     app_config = get_app_config(root_fp, app_name=app_name)
 
-    if export_config:
-        try:
-            ctx.invoke(export_config_command, ctx, app_fp=root_fp, validate_=True)
-        except jsonschema.exceptions.SchemaError as exc:
-            summary, remainder = str(exc).split("\n", 1)
-            rich.print(
-                f"[red]Failed to export application configuration: {summary}[/red]\n{remainder}\n"
-            )
-            typer.confirm("Do you want to continue?", abort=True)
-        else:
-            rich.print("[green]Exported application configuration.[/green]")
-            app_config = get_app_config(root_fp)
-
-    if export_ui and _should_export_ui(app_config):
-        try:
-            ctx.invoke(export_ui_command, ctx, app_fp=root_fp, validate_=True)
-        except Exception as exc:
-            rich.print(f"[red]Failed to export UI schema: {exc}[/red]\n")
-            typer.confirm("Do you want to continue?", abort=True)
-        else:
-            rich.print("[green]Exported UI schema.[/green]")
+    # Generate the schema from the Python into doover_config.json so the upload
+    # payload carries the current source, then restore the file -- publishing
+    # never leaves generated config_schema/ui_schema in the working tree. The
+    # Python is the source of truth; the JSON is regenerated on demand.
+    with preserve_file(root_fp / "doover_config.json"):
+        if export_config:
+            try:
+                ctx.invoke(export_config_command, ctx, app_fp=root_fp, validate_=True)
+            except jsonschema.exceptions.SchemaError as exc:
+                summary, remainder = str(exc).split("\n", 1)
+                rich.print(
+                    f"[red]Failed to export application configuration: {summary}[/red]\n{remainder}\n"
+                )
+                typer.confirm("Do you want to continue?", abort=True)
+            else:
+                rich.print("[green]Exported application configuration.[/green]")
+                app_config = get_app_config(root_fp)
 
-    app_config = get_app_config(root_fp)
-    resolved_staging = _resolve_staging(staging)
-    payload = _build_application_payload(
-        app_config,
-        staging=resolved_staging,
-        include_deployment_data=True,
-    )
+        if export_ui and _should_export_ui(app_config):
+            try:
+                ctx.invoke(export_ui_command, ctx, app_fp=root_fp, validate_=True)
+            except Exception as exc:
+                rich.print(f"[red]Failed to export UI schema: {exc}[/red]\n")
+                typer.confirm("Do you want to continue?", abort=True)
+            else:
+                rich.print("[green]Exported UI schema.[/green]")
+
+        app_config = get_app_config(root_fp)
+        resolved_staging = _resolve_staging(staging)
+        payload = _build_application_payload(
+            app_config,
+            staging=resolved_staging,
+            include_deployment_data=True,
+        )
 
     client, renderer = get_state()
 
@@ -1111,6 +1117,13 @@ def release(
         ),
     ] = None,
     notes: Annotated[str, typer.Option(help="Optional release notes.")] = "",
+    alpha: Annotated[
+        bool,
+        typer.Option(
+            help="Publish as a prerelease: the version is created but not "
+            "auto-selected as 'Latest' (reachable only by pinning it explicitly)."
+        ),
+    ] = False,
     staging: Annotated[
         bool | None,
         typer.Option(help="Force staging mode (default: inferred from the API URL)."),
@@ -1155,6 +1168,7 @@ def release(
             tag=tag or "",
             commit=resolved_commit or "",
             notes=notes or "",
+            alpha=alpha,
         )
     rich.print("[green]Released a new application version.[/green]")
     renderer.render(version)

{doover_cli-0.4.3 → doover_cli-0.5.1}/src/doover_cli/config_schema.py

@@ -7,7 +7,12 @@ import rich
 import typer
 import jsf
 
-from .utils.apps import get_app_directory, call_with_uv, get_app_config
+from .utils.apps import (
+    get_app_directory,
+    call_with_uv,
+    get_app_config,
+    preserve_file,
+)
 
 app = typer.Typer(no_args_is_help=True)
 
@@ -63,18 +68,28 @@ def validate(
     export_: Annotated[
         bool,
         typer.Option(
-            "--export",
-            help="Export the configuration before validating.",
+            "--export/--no-export",
+            help="Regenerate the schema from the Python before validating. "
+            "The export is transient -- doover_config.json is restored "
+            "afterwards, so validation never writes to the working tree.",
         ),
     ] = True,
 ):
     """Validate application config is a valid JSON schema."""
     root_fp = get_app_directory(app_fp)
+    config_file = root_fp / "doover_config.json"
 
     if export_ is True:
-        ctx.invoke(export, ctx, app_fp=root_fp, validate_=False)
+        # Validate the schema the Python *currently* generates, without leaving
+        # doover_config.json modified (e.g. when run as a pre-commit hook).
+        with preserve_file(config_file):
+            ctx.invoke(export, ctx, app_fp=root_fp, validate_=False)
+            _validate_config_file(config_file)
+    else:
+        _validate_config_file(config_file)
 
-    config_file = root_fp / "doover_config.json"
+
+def _validate_config_file(config_file: Path):
     if not config_file.exists():
         raise FileNotFoundError(
             "doover_config.json not found. Please ensure there is a doover_config.json file in the application directory."

{doover_cli-0.4.3 → doover_cli-0.5.1}/src/doover_cli/ui_schema.py

@@ -6,7 +6,12 @@ from typing import Annotated
 import rich
 import typer
 
-from .utils.apps import get_app_directory, call_with_uv, get_app_config
+from .utils.apps import (
+    get_app_directory,
+    call_with_uv,
+    get_app_config,
+    preserve_file,
+)
 
 app = typer.Typer(no_args_is_help=True)
 
@@ -55,18 +60,28 @@ def validate(
     export_: Annotated[
         bool,
         typer.Option(
-            "--export",
-            help="Export the UI schema before validating.",
+            "--export/--no-export",
+            help="Regenerate the schema from the Python before validating. "
+            "The export is transient -- doover_config.json is restored "
+            "afterwards, so validation never writes to the working tree.",
         ),
     ] = True,
 ):
     """Validate application UI schema is valid JSON."""
     root_fp = get_app_directory(app_fp)
+    config_file = root_fp / "doover_config.json"
 
     if export_ is True:
-        ctx.invoke(export, ctx, app_fp=root_fp, validate_=False)
+        # Validate the schema the Python *currently* generates, without leaving
+        # doover_config.json modified (e.g. when run as a pre-commit hook).
+        with preserve_file(config_file):
+            ctx.invoke(export, ctx, app_fp=root_fp, validate_=False)
+            _validate_ui_file(config_file)
+    else:
+        _validate_ui_file(config_file)
 
-    config_file = root_fp / "doover_config.json"
+
+def _validate_ui_file(config_file: Path):
     if not config_file.exists():
         raise FileNotFoundError(
             "doover_config.json not found. Please ensure there is a doover_config.json file in the application directory."

{doover_cli-0.4.3 → doover_cli-0.5.1}/src/doover_cli/utils/apps.py

@@ -2,6 +2,7 @@ import os
 import json
 import base64
 import shutil
+import contextlib
 from pathlib import Path
 from typing import Any
 
@@ -19,6 +20,27 @@ def get_id_or_key(data: dict[str, Any], key: str) -> Any:
         return data.get(key)
 
 
+@contextlib.contextmanager
+def preserve_file(path: Path):
+    """Snapshot a file (or its absence) and restore it on exit.
+
+    Lets a command generate schema into ``doover_config.json`` transiently --
+    to validate it or build an upload payload from it -- without leaving the
+    working tree modified. This keeps generated ``config_schema``/``ui_schema``
+    out of git: the Python is the source of truth, the JSON is regenerated on
+    demand. Restores on exceptions too, so a failed run never dirties the tree.
+    """
+    existed = path.exists()
+    original = path.read_text() if existed else None
+    try:
+        yield
+    finally:
+        if existed:
+            path.write_text(original)
+        elif path.exists():
+            path.unlink()
+
+
 class LocalApplication(ControlApplication):
     _model_name = None
 
@@ -366,14 +388,16 @@ def get_app_config(root_fp: Path, app_name: str | None = None) -> Any:
 
     result = []
     for k, v in data.items():
-        if isinstance(v, dict) and "config_schema" in v:
-            # config_schema bit of a prerequisite for an app config entry.
+        if isinstance(v, dict) and "type" in v:
+            # `type` (e.g. DEV/PRO) marks an app entry. Don't key off
+            # config_schema -- it's generated from the Python and may be
+            # absent from the committed file.
             result.append(LocalApplication.from_config(v, root_fp))
 
     if len(result) == 0:
         print(
             f"No application configuration found in the `doover_config.json` file at {root_fp}. "
-            f"Make sure the `type` is set to `application` in the configuration."
+            f"Make sure each application entry has a `type` set in the configuration."
         )
         raise typer.Exit(1)
 

{doover_cli-0.4.3 → doover_cli-0.5.1}/tests/test_apps.py

@@ -943,6 +943,48 @@ def test_app_publish_processor_builds_package_without_release(monkeypatch, tmp_p
     assert renderer.render_calls == [{"id": 303}]
 
 
+def test_app_release_passes_alpha_flag(monkeypatch, tmp_path):
+    captured = {}
+    renderer = FakeRenderer()
+    app_config = FakeAppConfig(app_id=404)
+
+    class FakeControlClient:
+        @staticmethod
+        def create_application_version(application_id, **kwargs):
+            captured["application_id"] = application_id
+            captured["kwargs"] = kwargs
+            return {"id": 1, "number": 1, "alpha": kwargs.get("alpha")}
+
+    monkeypatch.setattr(
+        "doover_cli.apps.apps.get_app_directory", lambda root=None: tmp_path
+    )
+    monkeypatch.setattr(
+        "doover_cli.apps.apps.get_app_config", lambda root_fp, app_name=None: app_config
+    )
+    monkeypatch.setattr(
+        "doover_cli.apps.apps.get_state", lambda: (FakeControlClient(), renderer)
+    )
+    monkeypatch.setattr(
+        "doover_cli.apps.apps._detect_git_commit", lambda root_fp: "deadbeef"
+    )
+
+    result = runner.invoke(
+        app, ["app", "release", str(tmp_path), "--digest", "sha256:abc", "--alpha"]
+    )
+
+    assert result.exit_code == 0
+    assert captured["application_id"] == 404
+    assert captured["kwargs"]["alpha"] is True
+
+    # ...and defaults to False when the flag is omitted.
+    captured.clear()
+    result = runner.invoke(
+        app, ["app", "release", str(tmp_path), "--digest", "sha256:abc"]
+    )
+    assert result.exit_code == 0
+    assert captured["kwargs"]["alpha"] is False
+
+
 def test_publish_processor_package_uses_package_zip(tmp_path):
     package_fp = tmp_path / "package.zip"
     package_fp.write_bytes(b"zip-bytes")

{doover_cli-0.4.3 → doover_cli-0.5.1}/tests/test_utils_apps.py

@@ -63,10 +63,12 @@ def test_get_app_config_caches_explicit_app_name(monkeypatch, tmp_path):
             {
                 "vega_level_sensor": {
                     "name": "vega_level_sensor",
+                    "type": "DEV",
                     "config_schema": {"type": "object"},
                 },
                 "farm_water_dashboard": {
                     "name": "farm_water_dashboard",
+                    "type": "DEV",
                     "config_schema": {"type": "object"},
                 },
             }
@@ -85,17 +87,21 @@ def test_get_app_config_caches_explicit_app_name(monkeypatch, tmp_path):
     assert cached_config.name == "farm_water_dashboard"
 
 
-def test_get_app_config_rejects_unknown_explicit_app_name(monkeypatch, tmp_path, capsys):
+def test_get_app_config_rejects_unknown_explicit_app_name(
+    monkeypatch, tmp_path, capsys
+):
     config_path = tmp_path / "doover_config.json"
     config_path.write_text(
         json.dumps(
             {
                 "vega_level_sensor": {
                     "name": "vega_level_sensor",
+                    "type": "DEV",
                     "config_schema": {"type": "object"},
                 },
                 "farm_water_dashboard": {
                     "name": "farm_water_dashboard",
+                    "type": "DEV",
                     "config_schema": {"type": "object"},
                 },
             }
@@ -124,6 +130,7 @@ def test_get_app_config_rejects_unknown_explicit_app_name_with_single_app(
             {
                 "tracker-app": {
                     "name": "tracker-app",
+                    "type": "DEV",
                     "config_schema": {"type": "object"},
                 },
             }

{doover_cli-0.4.3 → doover_cli-0.5.1}/uv.lock

@@ -544,7 +544,7 @@ wheels = [
 
 [[package]]
 name = "doover-cli"
-version = "0.4.3"
+version = "0.5.1"
 source = { editable = "." }
 dependencies = [
     { name = "click" },