strictcli 0.23.0__tar.gz → 0.24.0__tar.gz

{strictcli-0.23.0 → strictcli-0.24.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: strictcli
-Version: 0.23.0
+Version: 0.24.0
 Summary: A strict, zero-dependency CLI framework for Python
 Project-URL: Homepage, https://github.com/smm-h/strictcli
 Project-URL: Repository, https://github.com/smm-h/strictcli

{strictcli-0.23.0 → strictcli-0.24.0}/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "strictcli",
-  "version": "0.23.0",
+  "version": "0.24.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "strictcli",
-      "version": "0.23.0",
+      "version": "0.24.0",
       "hasInstallScript": true,
       "license": "MIT"
     }

{strictcli-0.23.0 → strictcli-0.24.0}/package.json

@@ -1,6 +1,6 @@
 {
   "name": "strictcli",
-  "version": "0.23.0",
+  "version": "0.24.0",
   "description": "A strict, zero-dependency CLI framework for Python (npm wrapper)",
   "main": "index.js",
   "scripts": {

{strictcli-0.23.0 → strictcli-0.24.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "strictcli"
-version = "0.23.0"
+version = "0.24.0"
 description = "A strict, zero-dependency CLI framework for Python"
 readme = "README.md"
 license = "MIT"

{strictcli-0.23.0 → strictcli-0.24.0}/strictcli/__init__.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-__version__ = "0.23.0"
+__version__ = "0.24.0"
 
 __all__ = [
     "App", "Flag", "Arg", "FlagSet", "MutexGroup", "CoRequired", "Requires",
@@ -1484,7 +1484,38 @@ class Arg:
                     )
         # Validate default type matches declared type
         if not isinstance(self.default, _MissingSentinel) and self.default is not None:
-            if self.type is int:
+            if self.compound == "list":
+                # self.type was normalized to the item type above; the
+                # default itself must be a list of that item type.
+                if not isinstance(self.default, list):
+                    raise ValueError(
+                        f'Arg "{self.name}": list arg default must be a list'
+                    )
+                if len(self.default) == 0:
+                    raise ValueError(
+                        f'Arg "{self.name}": explicit empty default is '
+                        f"redundant for list args, omit the default"
+                    )
+                type_name = {str: "str", int: "int", float: "float"}[self.type]
+                for i, elem in enumerate(self.default):
+                    if self.type is str:
+                        valid = isinstance(elem, str)
+                    elif self.type is int:
+                        valid = isinstance(elem, int) and not isinstance(elem, bool)
+                    else:  # float
+                        valid = (
+                            isinstance(elem, (int, float))
+                            and not isinstance(elem, bool)
+                        )
+                        if valid and isinstance(elem, int):
+                            # Auto-coerce int to float, mirroring list flag defaults
+                            self.default[i] = float(elem)
+                    if not valid:
+                        raise ValueError(
+                            f'Arg "{self.name}": default element {i} '
+                            f"is not of type {type_name}"
+                        )
+            elif self.type is int:
                 if not isinstance(self.default, int) or isinstance(self.default, bool):
                     raise ValueError(
                         f'Arg "{self.name}": type=int requires an int default, '
@@ -1502,6 +1533,12 @@ class Arg:
                         f'Arg "{self.name}": type=bool requires a bool default, '
                         f"got {type(self.default).__name__!r}"
                     )
+            elif self.type is str:
+                if not isinstance(self.default, str):
+                    raise ValueError(
+                        f'Arg "{self.name}": type=str requires a str default, '
+                        f"got {type(self.default).__name__!r}"
+                    )
         # Validate default is in choices
         if self.choices is not None and not isinstance(self.default, _MissingSentinel) and self.default is not None:
             if self.default not in self.choices:
@@ -3185,21 +3222,8 @@ class App:
 
         # Validate choices for global flags
         for f in self._global_flags:
-            if f.choices is not None and f.name in cli_set:
-                if f.repeatable:
-                    for val in cli_set[f.name]:
-                        if val not in f.choices:
-                            choices_str = ", ".join(str(c) for c in f.choices)
-                            raise _ParseError(
-                                f"--{f.name}: invalid value '{val}', must be one of: {choices_str}"
-                            )
-                else:
-                    val = cli_set[f.name]
-                    if val not in f.choices:
-                        choices_str = ", ".join(str(c) for c in f.choices)
-                        raise _ParseError(
-                            f"--{f.name}: invalid value '{val}', must be one of: {choices_str}"
-                        )
+            if f.name in cli_set:
+                _validate_choices(f.name, cli_set[f.name], f.repeatable, f.choices)
 
         return cli_set, remaining
 
@@ -3754,6 +3778,39 @@ def _tokens_contain_help(tokens: list[str]) -> bool:
     return False
 
 
+def _validate_choices(
+    name: str,
+    val: object,
+    repeatable: bool,
+    choices: list | None,
+    *,
+    is_arg: bool = False,
+) -> None:
+    """Validate a resolved flag or arg value against its choices list.
+
+    Raises _ParseError on an invalid value. is_arg selects the message prefix
+    ("argument 'name':" instead of "--name:"); the two f-strings are kept as
+    full literals so conformance/check_error_parity.py can extract them.
+    A None value is exempt from validation: None only arises when the flag or
+    arg was not passed (an unset mutex flag, or default=None on an arg) -- a
+    CLI-supplied value is never None.
+    """
+    if choices is None or val is None:
+        return
+    vals = val if repeatable else [val]
+    for v in vals:
+        if v not in choices:
+            choices_str = ", ".join(str(c) for c in choices)
+            if is_arg:
+                raise _ParseError(
+                    f"argument '{name}': invalid value '{v}', "
+                    f"must be one of: {choices_str}"
+                )
+            raise _ParseError(
+                f"--{name}: invalid value '{v}', must be one of: {choices_str}"
+            )
+
+
 def _validate_and_build_kwargs(
     cmd: Command,
     cli_set: dict[str, object],
@@ -3849,21 +3906,8 @@ def _validate_and_build_kwargs(
 
     # Step 5.5: validate choices
     for f in cmd.flags:
-        if f.choices is not None and f.name in cli_set:
-            if f.repeatable:
-                for val in cli_set[f.name]:
-                    if val not in f.choices:
-                        choices_str = ", ".join(str(c) for c in f.choices)
-                        raise _ParseError(
-                            f"--{f.name}: invalid value '{val}', must be one of: {choices_str}"
-                        )
-            else:
-                val = cli_set[f.name]
-                if val not in f.choices:
-                    choices_str = ", ".join(str(c) for c in f.choices)
-                    raise _ParseError(
-                        f"--{f.name}: invalid value '{val}', must be one of: {choices_str}"
-                    )
+        if f.name in cli_set:
+            _validate_choices(f.name, cli_set[f.name], f.repeatable, f.choices)
 
     # Step 5.6: custom validation
     for f in cmd.flags:
@@ -3874,7 +3918,9 @@ def _validate_and_build_kwargs(
                         f.validate(val)
                     except ValueError as e:
                         raise _ParseError(f"--{f.name}: {e}")
-            else:
+            elif cli_set[f.name] is not None:
+                # None means the flag was not passed (an unset mutex flag) --
+                # there is no value to validate.
                 try:
                     f.validate(cli_set[f.name])
                 except ValueError as e:
@@ -3904,23 +3950,10 @@ def _validate_and_build_kwargs(
 
     # Step 6.5: validate arg choices
     for a in cmd.args:
-        if a.choices is not None and a.name in arg_values:
-            val = arg_values[a.name]
-            if a.variadic:
-                for v in val:
-                    if v not in a.choices:
-                        choices_str = ", ".join(str(c) for c in a.choices)
-                        raise _ParseError(
-                            f"argument '{a.name}': invalid value '{v}', "
-                            f"must be one of: {choices_str}"
-                        )
-            else:
-                if val not in a.choices:
-                    choices_str = ", ".join(str(c) for c in a.choices)
-                    raise _ParseError(
-                        f"argument '{a.name}': invalid value '{val}', "
-                        f"must be one of: {choices_str}"
-                    )
+        if a.name in arg_values:
+            _validate_choices(
+                a.name, arg_values[a.name], a.variadic, a.choices, is_arg=True,
+            )
 
     # Step 7: build kwargs dict (command flags only)
     kwargs: dict[str, object] = {}
@@ -5274,15 +5307,22 @@ def _run_checks(
     warn with ignore_warnings=True), 1 otherwise.
     """
     results: list[tuple[str, CheckResult]] = []
+    # Checks whose dependents should be cascade-skipped: only fail or
+    # cascade-skip qualifies. A warn satisfies the dependency (dependents
+    # still run) regardless of ignore_warnings -- it only affects the exit
+    # code. Explicit skip from an impl is not a failure either.
     failed_checks: set[str] = set()
     exit_code = 0
 
-    # Build reverse dependency map for this execution set
-    dependents_of: dict[str, set[str]] = {name: set() for name in check_names}
-    for name in check_names:
-        for dep in check_defs[name].depends_on:
-            if dep in dependents_of:
-                dependents_of[dep].add(name)
+    def record(name: str, result: CheckResult) -> None:
+        nonlocal exit_code
+        if result.status == "fail":
+            failed_checks.add(name)
+            exit_code = 1
+        elif result.status == "warn":
+            if not ignore_warnings:
+                exit_code = 1
+        # "skip" from an impl or adapter: no cascade, no exit code change.
 
     for name in check_names:
         cdef = check_defs[name]
@@ -5309,33 +5349,14 @@ def _run_checks(
         if cdef.scope and scope_adapter is not None:
             adapted = scope_adapter(context, cdef.scope)
             if isinstance(adapted, CheckResult):
-                result = adapted
-                results.append((name, result))
-                if result.status == "fail":
-                    failed_checks.add(name)
-                    exit_code = 1
-                elif result.status == "warn":
-                    if not ignore_warnings:
-                        failed_checks.add(name)
-                        exit_code = 1
-                elif result.status == "skip":
-                    pass
+                results.append((name, adapted))
+                record(name, adapted)
                 continue
             check_context = adapted
 
         result = cdef.impl(check_context)
         results.append((name, result))
-
-        if result.status == "fail":
-            failed_checks.add(name)
-            exit_code = 1
-        elif result.status == "warn":
-            if not ignore_warnings:
-                failed_checks.add(name)
-                exit_code = 1
-        elif result.status == "skip":
-            # Treat explicit skip from impl as non-failure (no cascade)
-            pass
+        record(name, result)
 
     return results, exit_code
 

strictcli-0.24.0/tests/test_arg_default_validation.py

@@ -0,0 +1,79 @@
+"""Registration-time validation of arg defaults.
+
+str args must reject non-string defaults, and list (variadic) args must
+validate their default as a list with correctly-typed elements.
+"""
+
+import pytest
+
+import strictcli
+
+
+def test_arg_str_default_type_validated():
+    """type=str requires a str default."""
+    with pytest.raises(ValueError, match="type=str requires a str default"):
+        strictcli.Arg(name="x", help="a value", required=False, default=42)
+
+
+def test_arg_str_default_rejects_bool():
+    """type=str rejects a bool default."""
+    with pytest.raises(ValueError, match="type=str requires a str default"):
+        strictcli.Arg(name="x", help="a value", required=False, default=True)
+
+
+def test_arg_list_default_must_be_list():
+    """A list arg default must be a list."""
+    with pytest.raises(ValueError, match="list arg default must be a list"):
+        strictcli.Arg(
+            name="items", help="the items", type=list[str],
+            variadic=True, required=False, default="nope",
+        )
+
+
+def test_arg_list_default_empty_rejected():
+    """An explicit empty list default is redundant and rejected."""
+    with pytest.raises(
+        ValueError,
+        match="explicit empty default is redundant for list args",
+    ):
+        strictcli.Arg(
+            name="items", help="the items", type=list[str],
+            variadic=True, required=False, default=[],
+        )
+
+
+def test_arg_list_default_element_type_validated():
+    """Element types of a list arg default are validated."""
+    with pytest.raises(ValueError, match="default element 1 is not of type str"):
+        strictcli.Arg(
+            name="items", help="the items", type=list[str],
+            variadic=True, required=False, default=["a", 2],
+        )
+
+
+def test_arg_list_default_int_element_type_validated():
+    """Element types of an int list arg default are validated."""
+    with pytest.raises(ValueError, match="default element 0 is not of type int"):
+        strictcli.Arg(
+            name="nums", help="the numbers", type=list[int],
+            variadic=True, required=False, default=["1"],
+        )
+
+
+def test_arg_list_default_valid_str():
+    """A well-typed list default is accepted."""
+    a = strictcli.Arg(
+        name="items", help="the items", type=list[str],
+        variadic=True, required=False, default=["a", "b"],
+    )
+    assert a.default == ["a", "b"]
+
+
+def test_arg_list_default_float_coerces_int():
+    """Int elements in a float list default are coerced to float."""
+    a = strictcli.Arg(
+        name="ratios", help="the ratios", type=list[float],
+        variadic=True, required=False, default=[1, 2.5],
+    )
+    assert a.default == [1.0, 2.5]
+    assert isinstance(a.default[0], float)

{strictcli-0.23.0 → strictcli-0.24.0}/tests/test_check_runner.py

@@ -267,7 +267,10 @@ class TestRunChecks:
         assert exit_code == 1
         assert results[0][1].status == "warn"
 
-    def test_warn_cascades_skip_when_not_ignored(self, tmp_path, monkeypatch):
+    def test_warn_dependency_runs_dependent(self, tmp_path, monkeypatch):
+        # A warn satisfies a dependency: only fail (or cascade-skip) skips
+        # dependents. The warn still makes the run exit non-zero when
+        # ignore_warnings=False, but the dependent must run.
         defs = {
             "b": _make_check_def(
                 "b",
@@ -286,7 +289,66 @@ class TestRunChecks:
         assert exit_code == 1
         statuses = {name: r.status for name, r in results}
         assert statuses["b"] == "warn"
-        assert statuses["a"] == "skip"
+        assert statuses["a"] == "pass"
+
+    def test_warn_dependency_transitive_dependents_run(self, tmp_path, monkeypatch):
+        # warn -> dependent -> transitive dependent: the whole chain runs.
+        defs = {
+            "c": _make_check_def(
+                "c",
+                impl=lambda ctx: CheckResult(status="warn", message="Warning"),
+            ),
+            "b": _make_check_def(
+                "b",
+                depends_on=["c"],
+                impl=lambda ctx: CheckResult(status="pass", message="B OK"),
+            ),
+            "a": _make_check_def(
+                "a",
+                depends_on=["b"],
+                impl=lambda ctx: CheckResult(status="pass", message="A OK"),
+            ),
+        }
+        app = self._make_app_with_checks(defs, tmp_path, monkeypatch)
+        ctx = SimpleContext(project_root=tmp_path)
+        order = _resolve_check_order(app._check_defs, {"a", "b", "c"})
+        results, exit_code = _run_checks(app._check_defs, order, ctx, ignore_warnings=False)
+        assert exit_code == 1
+        statuses = {name: r.status for name, r in results}
+        assert statuses["c"] == "warn"
+        assert statuses["b"] == "pass"
+        assert statuses["a"] == "pass"
+
+    def test_warn_from_scope_adapter_runs_dependent(self, tmp_path, monkeypatch):
+        # When the scope adapter short-circuits a check with a warn result,
+        # the warn must also satisfy dependencies (no cascade-skip).
+        defs = {
+            "b": _make_check_def(
+                "b",
+                impl=lambda ctx: CheckResult(status="pass", message="unused"),
+            ),
+            "a": _make_check_def(
+                "a",
+                depends_on=["b"],
+                impl=lambda ctx: CheckResult(status="pass", message="A OK"),
+            ),
+        }
+        app = self._make_app_with_checks(defs, tmp_path, monkeypatch)
+        # Give "b" a scope so the adapter is consulted for it.
+        app._check_defs["b"].scope = "some-scope"
+
+        def adapter(context, scope):
+            return CheckResult(status="warn", message="adapter warning")
+
+        ctx = SimpleContext(project_root=tmp_path)
+        order = _resolve_check_order(app._check_defs, {"a", "b"})
+        results, exit_code = _run_checks(
+            app._check_defs, order, ctx, ignore_warnings=False, scope_adapter=adapter
+        )
+        assert exit_code == 1
+        statuses = {name: r.status for name, r in results}
+        assert statuses["b"] == "warn"
+        assert statuses["a"] == "pass"
 
     def test_warn_does_not_cascade_when_ignored(self, tmp_path, monkeypatch):
         defs = {

strictcli-0.24.0/tests/test_choices_none.py

@@ -0,0 +1,163 @@
+"""Tests for choices/validate exemption of None values.
+
+A None value only arises when a flag or arg was not passed (an unset mutex
+flag, or an arg with default=None); a CLI-supplied value is never None.
+Choices validation and custom validators must skip None instead of failing
+with "invalid value 'None'".
+"""
+
+import pytest
+
+import strictcli
+
+
+# ---------------------------------------------------------------------------
+# Mutex flags: the unset member resolves to None
+# ---------------------------------------------------------------------------
+
+
+def _mutex_choices_app():
+    mg = strictcli.MutexGroup(
+        flags=[
+            strictcli.Flag(
+                name="format", type=str, help="output format",
+                default=None, choices=["text", "json"],
+            ),
+            strictcli.Flag(name="output", type=str, help="output path", default=None),
+        ],
+    )
+    app = strictcli.App(name="test", version="1.0.0", help="test app")
+
+    @app.command("cmd", help="a command", mutex=[mg])
+    def cmd(format, output):
+        print(f"format={format} output={output}")
+
+    return app
+
+
+def test_mutex_flag_choices_unset_not_validated():
+    """Choices on an unset mutex flag must not fire when the other member is passed."""
+    app = _mutex_choices_app()
+    r = app.test(["cmd", "--output", "out.txt"])
+    assert r.exit_code == 0
+    assert "format=None output=out.txt" in r.stdout
+
+
+def test_mutex_flag_choices_passed_valid():
+    """A valid choice on the mutex flag is still accepted."""
+    app = _mutex_choices_app()
+    r = app.test(["cmd", "--format", "json"])
+    assert r.exit_code == 0
+    assert "format=json output=None" in r.stdout
+
+
+def test_mutex_flag_choices_passed_invalid():
+    """An invalid choice on the mutex flag is still rejected."""
+    app = _mutex_choices_app()
+    r = app.test(["cmd", "--format", "xml"])
+    assert r.exit_code == 1
+    assert "--format: invalid value 'xml', must be one of: text, json" in r.stderr
+
+
+# ---------------------------------------------------------------------------
+# Args: default=None (or no default) resolves to None
+# ---------------------------------------------------------------------------
+
+
+def _arg_choices_app(**arg_kwargs):
+    app = strictcli.App(name="test", version="1.0.0", help="test app")
+
+    @app.command(
+        "cmd",
+        help="a command",
+        args=[strictcli.Arg(
+            name="env", help="target env", required=False,
+            choices=["dev", "staging", "prod"], **arg_kwargs,
+        )],
+    )
+    def cmd(env=None):
+        print(f"env={env}")
+
+    return app
+
+
+def test_arg_none_default_choices_not_passed():
+    """Optional arg with default=None and choices, not passed -> succeeds."""
+    app = _arg_choices_app(default=None)
+    r = app.test(["cmd"])
+    assert r.exit_code == 0
+    assert "env=None" in r.stdout
+
+
+def test_arg_optional_no_default_choices_not_passed():
+    """Optional arg with no default and choices, not passed -> succeeds."""
+    app = _arg_choices_app()
+    r = app.test(["cmd"])
+    assert r.exit_code == 0
+    assert "env=None" in r.stdout
+
+
+def test_arg_none_default_choices_passed_valid():
+    """A valid choice on the optional arg is still accepted."""
+    app = _arg_choices_app(default=None)
+    r = app.test(["cmd", "prod"])
+    assert r.exit_code == 0
+    assert "env=prod" in r.stdout
+
+
+def test_arg_none_default_choices_passed_invalid():
+    """An invalid choice on the optional arg is still rejected."""
+    app = _arg_choices_app(default=None)
+    r = app.test(["cmd", "local"])
+    assert r.exit_code == 1
+    assert (
+        "argument 'env': invalid value 'local', must be one of: dev, staging, prod"
+        in r.stderr
+    )
+
+
+# ---------------------------------------------------------------------------
+# Custom validators: not run for None (not-passed) values
+# ---------------------------------------------------------------------------
+
+
+def _name_validator(val):
+    if not isinstance(val, str):
+        raise ValueError(f"validator received non-string value {val!r}")
+    if val == "bad":
+        raise ValueError("bad name")
+
+
+def _mutex_validate_app():
+    mg = strictcli.MutexGroup(
+        flags=[
+            strictcli.Flag(
+                name="name", type=str, help="a name",
+                default=None, validate=_name_validator,
+            ),
+            strictcli.Flag(name="id", type=str, help="an id", default=None),
+        ],
+    )
+    app = strictcli.App(name="test", version="1.0.0", help="test app")
+
+    @app.command("cmd", help="a command", mutex=[mg])
+    def cmd(name, id):
+        print(f"name={name} id={id}")
+
+    return app
+
+
+def test_mutex_flag_validate_unset_not_called():
+    """A custom validator must not run for an unset mutex flag (value None)."""
+    app = _mutex_validate_app()
+    r = app.test(["cmd", "--id", "42"])
+    assert r.exit_code == 0
+    assert "name=None id=42" in r.stdout
+
+
+def test_mutex_flag_validate_passed_still_runs():
+    """A passed value is still validated."""
+    app = _mutex_validate_app()
+    r = app.test(["cmd", "--name", "bad"])
+    assert r.exit_code == 1
+    assert "--name: bad name" in r.stderr

{strictcli-0.23.0 → strictcli-0.24.0}/uv.lock

@@ -232,7 +232,7 @@ wheels = [
 
 [[package]]
 name = "strictcli"
-version = "0.23.0"
+version = "0.24.0"
 source = { editable = "." }
 
 [package.dev-dependencies]