proactive-gate 0.8.0__tar.gz → 0.8.2__tar.gz

{proactive_gate-0.8.0 → proactive_gate-0.8.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: proactive-gate
-Version: 0.8.0
+Version: 0.8.2
 Summary: Decide whether a proactive assistant may speak now: ordered checks, budgets, quiet hours, JSON policies, shared conformance fixtures with the TypeScript package.
 Project-URL: Homepage, https://bubblegunn.github.io/proactive-gate/
 Project-URL: Documentation, https://bubblegunn.github.io/proactive-gate/start/

{proactive_gate-0.8.0 → proactive_gate-0.8.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "proactive-gate"
-version = "0.8.0"
+version = "0.8.2"
 description = "Decide whether a proactive assistant may speak now: ordered checks, budgets, quiet hours, JSON policies, shared conformance fixtures with the TypeScript package."
 readme = "README.md"
 requires-python = ">=3.11"

{proactive_gate-0.8.0 → proactive_gate-0.8.2}/src/proactive_gate/__init__.py

@@ -22,7 +22,7 @@ from .types import (
     UserState,
 )
 
-__version__ = "0.8.0"
+__version__ = "0.8.2"
 
 __all__ = [
     "EN", "PRIORITY_RANK", "KNOWN_CHECKS", "AsyncGate", "AsyncMemoryStore", "AsyncSqliteStore", "AsyncStore", "Candidate", "Check",

{proactive_gate-0.8.0 → proactive_gate-0.8.2}/src/proactive_gate/explain.py

@@ -295,7 +295,9 @@ PARSERS: dict[str, dict[str, Parser | Callable[[str], Facts]]] = {
         "stop": _match(r"trust ramp: day (\d+) of (\S+), priority (\w+) is below (\w+)", ("day", "days", "priority", "floor")),
         "skip": _fixed("no createdAt on the user; ramp cannot be evaluated"),
     },
-    "dismissalCooldown": {"stop": _match(r'(\d+) dismissals of "(.+)" in (\S+) days; silent until (.+)', ("count", "type", "within", "until"))},
+    # The instant is an ISO timestamp, so \S+: with (.+) the type and the
+    # instant could both absorb a crafted reason and the match went quadratic.
+    "dismissalCooldown": {"stop": _match(r'(\d+) dismissals of "(.+)" in (\S+) days; silent until (\S+)', ("count", "type", "within", "until"))},
     "adaptiveTiming": {
         "adjust": _first(
             _match(r"deliver at (\S+); surfaces (.+)", ("at", "surfaces")),

{proactive_gate-0.8.0 → proactive_gate-0.8.2}/tests/test_explain.py

@@ -2,6 +2,7 @@
 from __future__ import annotations
 
 import re
+import time
 from datetime import datetime, timezone
 from typing import Any
 
@@ -322,6 +323,36 @@ def test_shadowed_stop_is_what_would_have_happened() -> None:
     assert "quietHours would have stopped it but ran in shadow mode" in e.summary
 
 
+def test_dismissal_cooldown_type_with_the_reasons_own_separators() -> None:
+    store = MemoryStore()
+    gate = Gate([checks.DismissalCooldown()], store=store)
+    u = user()
+    kind = 'a" in 9 days; silent until b'
+    for day in (1, 2, 3):
+        gate.record(u, Candidate(id=f"c{day}", type=kind), "dismissed", datetime(2026, 9, day, 10, 0, tzinfo=UTC))
+    d = gate.evaluate(EvaluateInput(u, candidate(type=kind), datetime(2026, 9, 5, 10, 0, tzinfo=UTC)))
+    assert explain(d).summary == f'Held because the user has dismissed "{kind}" messages 3 times in 30 days, so this type stays silent until 2026-09-10T10:00:00.000Z.'
+
+
+def test_dismissal_cooldown_reason_built_to_backtrack_reads_in_linear_time() -> None:
+    # The pattern CodeQL flagged as js/polynomial-redos in the TypeScript twin;
+    # Python's re backtracks the same way on "silent until (.+)".
+    reason = '9 dismissals of "a" in ! days; silent until ' + 'a" in ! days; silent until a' * 20_000 + "\n"
+    d = Decision(
+        id="u1:c1:2026-09-04T09:00:00.000Z#1",
+        allowed=False,
+        user_id="u1",
+        candidate_id="c1",
+        surfaces=(),
+        trace=(TraceEntry(id="dismissalCooldown", outcome="reject", ms=0.0, reason=reason),),
+        evaluated_at=NOON,
+    )
+    started = time.perf_counter()
+    explain(d)
+    elapsed = time.perf_counter() - started
+    assert elapsed < 1.0, f"explain took {elapsed:.2f} s on a 20,000-repeat reason"
+
+
 def test_shadowed_pass_does_not_claim_it_would_have_stopped() -> None:
     d = Decision(
         id="u1:c1:2026-09-04T09:00:00.000Z#1",

proactive_gate-0.8.2/tests/test_requirements_ci.py

@@ -0,0 +1,54 @@
+"""CI installs ``requirements-ci.txt`` with ``--require-hashes``; it has to cover what it is compiled from.
+
+The file is compiled (command in its header) from the dev extra in pyproject.toml and
+from requirements-ci.in, so pip can install the test, build and check tools pinned by
+hash, and the package itself goes in with ``--no-deps``. A requirement added to either
+input without recompiling would otherwise surface only as an ImportError in CI, and a
+pin outside its range would mean CI tests against a version the inputs exclude.
+"""
+from __future__ import annotations
+
+import re
+import tomllib
+
+from packaging.requirements import Requirement
+from packaging.utils import canonicalize_name
+
+from conftest import ROOT
+
+PYTHON = ROOT / "python"
+
+
+def _inputs() -> list[Requirement]:
+    with (PYTHON / "pyproject.toml").open("rb") as handle:
+        dev = tomllib.load(handle)["project"]["optional-dependencies"]["dev"]
+    lines = (PYTHON / "requirements-ci.in").read_text(encoding="utf-8").splitlines()
+    tools = [line for line in (raw.split("#", 1)[0].strip() for raw in lines) if line]
+    return [Requirement(spec) for spec in [*dev, *tools]]
+
+
+def _pins() -> dict[str, tuple[str, int]]:
+    text = (PYTHON / "requirements-ci.txt").read_text(encoding="utf-8")
+    pins: dict[str, tuple[str, int]] = {}
+    # A requirement starts at column 0; its hashes follow on indented continuation lines.
+    for block in re.split(r"\n(?=[a-z0-9])", text):
+        m = re.match(r"([a-z0-9][a-z0-9._-]*)==(\S+)", block)
+        if m:
+            pins[canonicalize_name(m.group(1))] = (m.group(2), len(re.findall(r"--hash=sha256:[0-9a-f]{64}", block)))
+    return pins
+
+
+def test_every_input_is_pinned_inside_its_range() -> None:
+    pins = _pins()
+    wrong = []
+    for req in _inputs():
+        pinned = pins.get(canonicalize_name(req.name))
+        if pinned is None or not req.specifier.contains(pinned[0], prereleases=True):
+            wrong.append(f"{req} -> {pinned[0] if pinned else 'not pinned'}")
+    assert wrong == []
+
+
+def test_every_pin_carries_a_hash() -> None:
+    pins = _pins()
+    assert len(pins) > 0
+    assert [name for name, (_, hashes) in pins.items() if hashes == 0] == []