strictcli 0.32.1__tar.gz → 0.32.2__tar.gz

{strictcli-0.32.1 → strictcli-0.32.2}/PKG-INFO

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

{strictcli-0.32.1 → strictcli-0.32.2}/pyproject.toml

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

{strictcli-0.32.1 → strictcli-0.32.2}/strictcli/__init__.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-__version__ = "0.32.1"
+__version__ = "0.32.2"
 
 __all__ = [
     "App", "Flag", "Arg", "FlagSet", "MutexGroup", "CoRequired", "Requires",
@@ -1341,6 +1341,10 @@ def _strict_int(s: str) -> int:
     """
     if s != s.strip():
         raise ValueError(f"expected integer, got '{s}'")
+    # Python's int() accepts PEP 515 underscore digit separators ('1_000');
+    # Go's strconv and the TypeScript parser reject them. Reject to match canon.
+    if "_" in s:
+        raise ValueError(f"expected integer, got '{s}'")
     try:
         n = int(s)
     except ValueError:
@@ -1363,7 +1367,13 @@ def _strict_float(s: str) -> float:
         raise ValueError("NaN is not allowed")
     if low in ("inf", "-inf", "+inf", "infinity", "-infinity", "+infinity"):
         raise ValueError("Inf is not allowed")
-    return float(s)
+    result = float(s)
+    # A finite literal that overflows to +/-inf ('1e999') is a parse failure,
+    # not an Inf literal. Go and TypeScript reject it as an invalid float; use
+    # the generic "expected float" path (not "Inf is not allowed") to match.
+    if math.isinf(result):
+        raise ValueError(f"invalid literal for float(): {s!r}")
+    return result
 
 
 def _float_parse_error(
@@ -2801,7 +2811,6 @@ class App:
         # Test-coverage instrumentation. When enabled, every test() and call()
         # invocation records which command was dispatched so a check can verify
         # that every command in the app's surface has been exercised.
-        self._coverage_shard_counter: int = 0
         self._coverage_shard_path: str | None = None
         self._coverage_dir: str | None = None
         self._coverage_manifest_path: str | None = None
@@ -2819,7 +2828,7 @@ class App:
             )
             self._coverage_shard_path = os.path.join(
                 self._coverage_dir,
-                f"{os.getpid()}-{{n}}.jsonl",
+                f"{os.getpid()}.jsonl",
             )
             os.makedirs(self._coverage_dir, exist_ok=True)
             self.register_check_provider(self._test_coverage_provider)
@@ -2847,14 +2856,14 @@ class App:
     def _record_coverage(self, cmd_path: str) -> None:
         """Append a coverage record for the resolved command path.
 
-        Each test() or call() invocation writes one JSONL line to a per-process
-        shard file. The shard counter increments on each write to keep files
-        small and unique (handles pytest-xdist where multiple workers share a
-        PID namespace within the coverage directory).
+        Each test() or call() invocation appends one JSONL line to the
+        process's shard file (named "<pid>.jsonl"). Uniqueness across concurrent
+        writers comes from the PID and O_APPEND; one shard per process is
+        sufficient, so there is no per-write shard counter.
         """
         if self._coverage_shard_path is None:
             return
-        path = self._coverage_shard_path.format(n=self._coverage_shard_counter)
+        path = self._coverage_shard_path
         os.makedirs(os.path.dirname(path), exist_ok=True)
         with open(path, "a", encoding="utf-8") as f:
             f.write(json.dumps({"command": cmd_path}) + "\n")

{strictcli-0.32.1 → strictcli-0.32.2}/tests/test_coverage.py

@@ -84,6 +84,9 @@ class TestCoverageRecording:
         shards = list(coverage_dir.glob("*.jsonl"))
         assert len(shards) >= 1
 
+        # One shard per process, named "<pid>.jsonl" (no shard counter suffix).
+        assert shards[0].name == f"{os.getpid()}.jsonl"
+
         entries = []
         for shard in shards:
             for line in shard.read_text().strip().splitlines():

{strictcli-0.32.1 → strictcli-0.32.2}/tests/test_float_type.py

@@ -158,6 +158,42 @@ def test_float_flag_reject_negative_inf():
     assert "Inf is not allowed" in r.stderr
 
 
+def test_float_flag_reject_overflow_to_infinity():
+    """'1e999' overflows to inf and is rejected via the generic parse error."""
+    app = _make_app_with_float_flag()
+    r = app.test(["cmd", "--rate", "1e999"])
+    assert r.exit_code == 1
+    assert "expected float" in r.stderr
+    assert "'1e999'" in r.stderr
+    # Overflow uses the generic message, not the literal-Inf rejection.
+    assert "Inf is not allowed" not in r.stderr
+
+
+def test_float_flag_reject_negative_overflow_to_infinity():
+    """'-1e999' overflows to -inf and is rejected via the generic parse error."""
+    app = _make_app_with_float_flag()
+    r = app.test(["cmd", "--rate", "-1e999"])
+    assert r.exit_code == 1
+    assert "expected float" in r.stderr
+    assert "'-1e999'" in r.stderr
+
+
+def test_float_flag_reject_overflow_env_value(monkeypatch):
+    """Overflowing float env var is rejected with the env suffix."""
+    app = strictcli.App(name="test", version="1.0.0", help="test app", env_prefix="MYAPP")
+
+    @app.command("cmd", help="a command")
+    @strictcli.flag("rate", type=float, help="the rate", default=1.0, env="MYAPP_RATE")
+    def cmd(ctx, rate):
+        print(f"rate={rate}")
+
+    monkeypatch.setenv("MYAPP_RATE", "1e999")
+    r = app.test(["cmd"])
+    assert r.exit_code == 1
+    assert "expected float" in r.stderr
+    assert "(from env var 'MYAPP_RATE')" in r.stderr
+
+
 def test_float_flag_reject_whitespace():
     """Whitespace-padded values are rejected."""
     app = _make_app_with_float_flag()

{strictcli-0.32.1 → strictcli-0.32.2}/tests/test_int_type.py

@@ -88,6 +88,31 @@ def test_int_flag_bad_env_value(monkeypatch):
     assert "'abc'" in r.stderr
 
 
+def test_int_flag_reject_underscore_separators():
+    """'1_000' (PEP 515 digit separators) is rejected to match Go/TypeScript."""
+    app = _make_app_with_int_flag()
+    r = app.test(["cmd", "--port", "1_000"])
+    assert r.exit_code == 1
+    assert "expected integer" in r.stderr
+    assert "'1_000'" in r.stderr
+
+
+def test_int_flag_reject_underscore_env_value(monkeypatch):
+    """Underscore-separated int env var is rejected."""
+    app = strictcli.App(name="test", version="1.0.0", help="test app", env_prefix="MYAPP")
+
+    @app.command("cmd", help="a command")
+    @strictcli.flag("port", type=int, help="the port", default=80, env="MYAPP_PORT")
+    def cmd(ctx, port):
+        print(f"port={port}")
+
+    monkeypatch.setenv("MYAPP_PORT", "1_000")
+    r = app.test(["cmd"])
+    assert r.exit_code == 1
+    assert "expected integer" in r.stderr
+    assert "'1_000'" in r.stderr
+
+
 def test_int_flag_required():
     """Int flag with no default and omitted -> exit 1, stderr says required."""
     app = _make_app_with_int_flag()

{strictcli-0.32.1 → strictcli-0.32.2}/tests/test_typed_args.py

@@ -126,6 +126,23 @@ def test_int_arg_rejects_float_string():
     assert "expected integer" in r.stderr
 
 
+def test_int_arg_rejects_underscore_separators():
+    """Int arg rejects '1_000' (PEP 515 digit separators), matching Go/TypeScript."""
+    app = strictcli.App(name="test", version="1.0.0", help="test app")
+
+    @app.command(
+        "cmd",
+        help="a command",
+        args=[strictcli.Arg(name="count", help="a count", type=int)],
+    )
+    def cmd(ctx, count):
+        pass
+
+    r = app.test(["cmd", "1_000"])
+    assert r.exit_code == 1
+    assert "argument 'count': expected integer, got '1_000'" in r.stderr
+
+
 def test_int_arg_negative():
     """Int arg handles negative values (after -- separator)."""
     app = strictcli.App(name="test", version="1.0.0", help="test app")
@@ -211,6 +228,23 @@ def test_float_arg_rejects_inf():
     assert "Inf is not allowed" in r.stderr
 
 
+def test_float_arg_rejects_overflow_to_infinity():
+    """Float arg rejects '1e999' (overflows to inf), using the generic parse error."""
+    app = strictcli.App(name="test", version="1.0.0", help="test app")
+
+    @app.command(
+        "cmd",
+        help="a command",
+        args=[strictcli.Arg(name="ratio", help="a ratio", type=float)],
+    )
+    def cmd(ctx, ratio):
+        pass
+
+    r = app.test(["cmd", "1e999"])
+    assert r.exit_code == 1
+    assert "argument 'ratio': expected float, got '1e999'" in r.stderr
+
+
 def test_float_arg_integer_string():
     """Float arg accepts integer string (coerces to float)."""
     app = strictcli.App(name="test", version="1.0.0", help="test app")

{strictcli-0.32.1 → strictcli-0.32.2}/uv.lock

@@ -232,7 +232,7 @@ wheels = [
 
 [[package]]
 name = "strictcli"
-version = "0.32.1"
+version = "0.32.2"
 source = { editable = "." }
 dependencies = [
     { name = "tomlkit" },