doover-cli 0.6.7__tar.gz → 0.6.8__tar.gz

{doover_cli-0.6.7 → doover_cli-0.6.8}/PKG-INFO

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

{doover_cli-0.6.7 → doover_cli-0.6.8}/src/doover_cli/__init__.py

@@ -1,7 +1,7 @@
 from doover_cli.renderer import Renderer
 from typing import Annotated, Optional
 
-__version__ = "0.6.7"
+__version__ = "0.6.8"
 
 import click
 import typer

{doover_cli-0.6.7 → doover_cli-0.6.8}/src/doover_cli/config_schema.py

@@ -14,6 +14,7 @@ from .utils.apps import (
     get_app_config,
     preserve_file,
     run_schema_export,
+    RUST_EXPORT_COMMAND,
 )
 
 app = typer.Typer(no_args_is_help=True)
@@ -65,6 +66,10 @@ def export(
             "export-config",
             app_name=app_config.name,
             cwd=app_fp,
+            # The one exporter that drives a Rust binary: its `export` writes
+            # every schema the app has, so the UI and notification exporters
+            # have nothing left to run.
+            rust_default=RUST_EXPORT_COMMAND,
         )
     else:
         config = get_app_config(app_fp, app_name=app_name)

{doover_cli-0.6.7 → doover_cli-0.6.8}/src/doover_cli/notification_schema.py

@@ -46,16 +46,16 @@ def export(
         print("App requested no notification export. Skipping...")
         return
 
+    print("Exporting notification schema...")
     run_schema_export(
         root_fp,
         app_config.export_notification_command,
         "export-notifications",
+        optional=True,
         app_name=app_config.name,
         cwd=app_fp,
     )
 
-    print("Exporting notification schema...")
-
     if validate_ is True:
         print("Validating notification schema...")
         ctx.invoke(validate, ctx, app_fp=app_fp, export_=False)

{doover_cli-0.6.7 → doover_cli-0.6.8}/src/doover_cli/utils/apps.py

@@ -1,6 +1,7 @@
 import os
 import json
 import sys
+import tomllib
 import base64
 import shutil
 import contextlib
@@ -624,40 +625,94 @@ def detect_language(app_dir: Path) -> str | None:
 
 
 # What a Rust app runs to regenerate its schemas. The framework gives every
-# application binary an `export [path] [--app-name NAME]` subcommand that writes
-# the config schema and, when the app has one, the UI schema -- one command for
-# both, with the same read-merge-write over doover_config.json that pydoover's
-# exporters do. Driven through cargo so it works from a plain checkout with
-# nothing built yet, which is the state CI is always in.
+# application binary a single `export [path] [--app-name NAME]` subcommand that
+# writes the config schema and, when the app has one, the UI schema -- with the
+# same read-merge-write over doover_config.json that pydoover's exporters do.
+# Driven through cargo so it works from a plain checkout with nothing built yet,
+# which is the state CI is always in.
+#
+# One command for every schema, which is why only the config exporter passes it
+# as its `rust_default`: see run_schema_export.
 RUST_EXPORT_COMMAND = "cargo run --quiet -- export doover_config.json"
 
 
+def python_declares_script(app_dir: Path, script: str) -> bool | None:
+    """Whether `app_dir`'s pyproject.toml declares the `script` console script.
+
+    None when there is nothing to go on -- no pyproject.toml, or one this can't
+    read -- so a caller can fall back to running the script and finding out.
+    """
+    pyproject = app_dir / "pyproject.toml"
+    if not pyproject.exists():
+        return None
+    try:
+        data = tomllib.loads(pyproject.read_text())
+    except (tomllib.TOMLDecodeError, OSError):
+        return None
+
+    scripts = data.get("project", {}).get("scripts")
+    if not isinstance(scripts, dict):
+        # A pyproject with no scripts table declares no exporters at all, which
+        # is an answer rather than a gap.
+        return False
+    return script in scripts
+
+
 def run_schema_export(
     app_dir: Path,
     command: str | None,
     python_default: str,
     app_name: str | None = None,
     cwd: Path | None = None,
+    rust_default: str | None = None,
+    optional: bool = False,
 ) -> None:
     """Regenerate an app's schemas by running its own exporter.
 
-    Python apps run a console script under uv, as they always have. Rust apps
-    run their binary's built-in `export` subcommand, so the schema in
-    doover_config.json comes from the source in both languages rather than from
-    whatever was committed.
+    Python apps run a console script under uv, as they always have: one script
+    per schema, each with its own default.
+
+    Rust apps have no such split. The framework gives a binary one `export`
+    subcommand that writes every schema it has, so exactly one exporter drives
+    it -- the config one, which passes `rust_default`. The others do nothing for
+    a Rust app unless it names a command explicitly, because there is nothing
+    left for them to write and no second subcommand to call.
+
+    That asymmetry is not cosmetic. Inventing `cargo run -- export` as the
+    default for *any* schema kind means a repo whose binary is not a doover-rs
+    application runs it anyway: doover-device-agent's binary rejects `export`
+    and fails the publish, and doover-device-runtime's supervisor accepts any
+    argv, so it started supervising and hung a CI job for 75 minutes. Both had
+    already opted out of every exporter that existed when they were written; the
+    next one to be added found them again.
 
     `command` is the app's own `export_*_command`, honoured verbatim when set --
     an app whose binary is not what `cargo run` picks by default (a workspace
     with several) says so there rather than being unbuildable by CI.
     """
     if detect_language(app_dir) == "rs":
-        cmd = command or RUST_EXPORT_COMMAND
+        cmd = command or rust_default
+        if cmd is None:
+            print(
+                "Rust app: its `export` subcommand writes every schema it has, "
+                "and the config export already ran it. Skipping..."
+            )
+            return
         # The binary otherwise falls back to APP_KEY or its own file name, which
         # is not the application name in a repo whose binary is spelled with
         # hyphens and whose app is spelled with underscores.
         if app_name and "--app-name" not in cmd:
             cmd = f"{cmd} --app-name {app_name}"
         run(cmd, cwd=app_dir)
+    elif (
+        optional
+        and command is None
+        and (python_declares_script(app_dir, python_default) is False)
+    ):
+        print(
+            f"App declares no `{python_default}` script, so it has no schema of "
+            "this kind. Skipping..."
+        )
     else:
         call_with_uv(command or python_default, in_shell=True, cwd=cwd)
 

{doover_cli-0.6.7 → doover_cli-0.6.8}/tests/test_schema_export.py

@@ -60,7 +60,13 @@ class TestRunSchemaExport:
     def test_rust_app_runs_its_export_subcommand(self, tmp_path, calls):
         (tmp_path / "Cargo.toml").touch()
 
-        apps_utils.run_schema_export(tmp_path, None, "export-config", app_name="foo")
+        apps_utils.run_schema_export(
+            tmp_path,
+            None,
+            "export-config",
+            app_name="foo",
+            rust_default=apps_utils.RUST_EXPORT_COMMAND,
+        )
 
         assert calls["uv"] == []
         cmd, cwd = calls["run"][0]
@@ -71,10 +77,44 @@ class TestRunSchemaExport:
     def test_rust_app_without_an_app_name_leaves_the_flag_off(self, tmp_path, calls):
         (tmp_path / "Cargo.toml").touch()
 
-        apps_utils.run_schema_export(tmp_path, None, "export-config")
+        apps_utils.run_schema_export(
+            tmp_path, None, "export-config", rust_default=apps_utils.RUST_EXPORT_COMMAND
+        )
 
         assert "--app-name" not in calls["run"][0][0]
 
+    def test_a_rust_app_runs_nothing_for_a_second_schema_kind(self, tmp_path, calls):
+        """The UI and notification exporters, which pass no rust_default.
+
+        A doover-rs binary has one `export` that writes every schema it has, so
+        the config exporter already ran it. Inventing the same command again is
+        what hung doover-device-runtime for 75 minutes: its binary is a
+        supervisor that accepts any argv, so `export` started it supervising.
+        """
+        (tmp_path / "Cargo.toml").touch()
+
+        apps_utils.run_schema_export(tmp_path, None, "export-ui", app_name="foo")
+
+        assert calls["run"] == []
+        assert calls["uv"] == []
+
+    def test_a_rust_app_still_honours_an_explicit_command(self, tmp_path, calls):
+        """An app that really does have a second exporter says so."""
+        (tmp_path / "Cargo.toml").touch()
+
+        apps_utils.run_schema_export(
+            tmp_path, "cargo run --bin exporter -- ui", "export-ui", app_name="foo"
+        )
+
+        assert calls["run"][0][0].startswith("cargo run --bin exporter -- ui")
+
+    def test_a_python_app_is_unaffected_by_the_rust_default(self, tmp_path, calls):
+        (tmp_path / "pyproject.toml").touch()
+
+        apps_utils.run_schema_export(tmp_path, None, "export-ui", app_name="foo")
+
+        assert calls["uv"][0][0] == ("export-ui",)
+
     def test_a_configured_rust_command_wins(self, tmp_path, calls):
         """A workspace with several binaries names the one to run itself."""
         (tmp_path / "Cargo.toml").touch()
@@ -104,6 +144,81 @@ class TestRunSchemaExport:
         assert calls["run"][0][0].endswith("explicit")
 
 
+class TestOptionalSchema:
+    """`optional=True` -- the notification schema, which most apps don't have.
+
+    An app declares its exporters in its own `[project.scripts]`, so the absence
+    of one there is the app saying it has no notifications. Running it anyway
+    meant `uv run export-notifications` failed on nearly every Python app: a red
+    error and a reported handled exception for the ordinary case.
+    """
+
+    def _pyproject(self, tmp_path, body):
+        (tmp_path / "pyproject.toml").write_text(body)
+        return tmp_path
+
+    def test_skipped_when_the_script_is_not_declared(self, tmp_path, calls):
+        self._pyproject(
+            tmp_path,
+            '[project.scripts]\nexport-config = "app.app_config:export"\n',
+        )
+
+        apps_utils.run_schema_export(
+            tmp_path, None, "export-notifications", app_name="foo", optional=True
+        )
+
+        assert calls["uv"] == []
+        assert calls["run"] == []
+
+    def test_run_when_the_script_is_declared(self, tmp_path, calls):
+        self._pyproject(
+            tmp_path,
+            "[project.scripts]\n"
+            'export-notifications = "app.app_notifications:export"\n',
+        )
+
+        apps_utils.run_schema_export(
+            tmp_path, None, "export-notifications", app_name="foo", optional=True
+        )
+
+        assert calls["uv"][0][0] == ("export-notifications",)
+
+    def test_an_explicit_command_is_never_probed(self, tmp_path, calls):
+        """An app naming its own exporter has said it has one, whatever the
+        scripts table looks like -- a second app in the repo exports through a
+        differently-named script."""
+        self._pyproject(tmp_path, '[project]\nname = "app"\n')
+
+        apps_utils.run_schema_export(
+            tmp_path,
+            "export-notifications-processor",
+            "export-notifications",
+            app_name="foo",
+            optional=True,
+        )
+
+        assert calls["uv"][0][0] == ("export-notifications-processor",)
+
+    def test_an_unreadable_pyproject_still_runs_the_export(self, tmp_path, calls):
+        """No answer is not the same as `no`: run it and let it fail loudly."""
+        self._pyproject(tmp_path, "this is not valid toml [[[")
+
+        apps_utils.run_schema_export(
+            tmp_path, None, "export-notifications", app_name="foo", optional=True
+        )
+
+        assert calls["uv"][0][0] == ("export-notifications",)
+
+    def test_a_required_schema_is_run_regardless(self, tmp_path, calls):
+        """Config and UI are not optional: every app of their type has one, so a
+        missing script there is a real failure worth surfacing."""
+        self._pyproject(tmp_path, '[project]\nname = "app"\n')
+
+        apps_utils.run_schema_export(tmp_path, None, "export-config", app_name="foo")
+
+        assert calls["uv"][0][0] == ("export-config",)
+
+
 class TestNoExport:
     """`export_config_command: NO_EXPORT` -- an app that holds no config of its
     own. Publishing one used to require giving it an exporter that wrote