Open-source AI Security Operations Center: alert fusion, LLM-agent triage, MITRE ATT&CK investigation, and a replayable decision ledger for every agent step. Self-hostable, runs with no API keys, MIT licensed. Ships an MCP server for Claude, Cursor and Continue.
Python agentic-aiai-securityalert-triageblue-teamcybersecuritydetection-engineeringincident-responselanggraphllm-agentsmcpmitre-attackmodel-context-protocolpurple-teamsecurity-operationsself-hostedsiemsoarsocthreat-detectionthreat-intelligence
fix(ci): CI re-resolved inside the declared ranges, so it graded versions no image ships (#1004)
Beenu Arora4959113172f6
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.ymlindex ce23de56b..b2e9f1cc3 100644--- a/.github/workflows/ci.yml+++ b/.github/workflows/ci.yml@@ -907,13 +907,26 @@ jobs:# `passlib`, `celery` and `aiofiles`, which nothing in either service# imports.#- # So the list is derived now. `service_requirements.py` reads what the- # manifests declare, expands poetry's carets into ranges pip- # understands, and hands pip both services' constraints at once — where- # they disagree pip resolves the intersection, and where they cannot- # agree pip fails rather than silently picking one.+ # So the list is derived now. But deriving it from the *manifests* only+ # narrowed the gap: a range re-resolves at install time, so CI could+ # still land on a different patch release than the image ships, and+ # that is precisely how the last defect hid — `services/api` declared+ # `opentelemetry-instrumentation-fastapi = "^0.45b0"` and locked 0.45b0+ # while this job installed it unbounded, resolved 0.66b0, and passed.+ # Both were "inside the declared range"; only one of them was the image.+ #+ # So each service's suite now runs against its own `poetry.lock` — the+ # same file `services/<name>/Dockerfile` installs from — expanded to its+ # complete resolved closure and installed with `--no-deps`, so pip+ # performs no resolution at all. Measured against the published+ # `ghcr.io/beenuar/aisoc-core-api:latest`: 97 main-group entries, 0+ # version mismatches.+ #+ # One virtualenv per service, because two locks cannot share an+ # interpreter: `api` and `agents` disagree about 28 distributions. They+ # are separate images, so that is not a defect in either lock.# `scripts/check_ci_install_parity.py` holds it that way.- - name: Install what services/api and services/agents declare+ - name: Install services/api and services/agents from their committed locksrun: |set -euo pipefailSYSTEM="$(python3 scripts/service_requirements.py api agents --system)"@@ -924,6 +937,43 @@ jobs:# Same packages services/api/Dockerfile installs.sudo apt-get install -y --no-install-recommends ${SYSTEM}fi+ # Written out per service rather than as a shell loop: the service+ # name has to survive being read by something that is not bash.+ # `scripts/check_ci_install_parity.py` resolves these lines to the+ # locks they name, and a `for svc in ...` loop hands it `"${svc}"`,+ # which resolves to no service at all — the gate would then report+ # the job installing nothing and pass, which is the failure shape+ # this whole change exists to remove.+ python3 -m venv $RUNNER_TEMP/.venv-api+ python3 scripts/service_requirements.py api --locked > /tmp/api.lock.txt+ $RUNNER_TEMP/.venv-api/bin/pip install --quiet --disable-pip-version-check --no-deps -r /tmp/api.lock.txt++ python3 -m venv $RUNNER_TEMP/.venv-agents+ python3 scripts/service_requirements.py agents --locked > /tmp/agents.lock.txt+ $RUNNER_TEMP/.venv-agents/bin/pip install --quiet --disable-pip-version-check --no-deps -r /tmp/agents.lock.txt++ echo "api: $(wc -l < /tmp/api.lock.txt) pinned distribution(s) from services/api/poetry.lock"+ echo "agents: $(wc -l < /tmp/agents.lock.txt) pinned distribution(s) from services/agents/poetry.lock"++ # A requirement line whose marker is false is skipped by pip without+ # a warning and with exit 0, so an environment can come out of a+ # successful install with nothing in it. That is not hypothetical:+ # poetry writes an extras-gated dependency as `extra == "dev"`,+ # which is false in a plain requirements file, and it silently took+ # the test runner out of three virtualenvs. Name it here, where the+ # install is, rather than three steps later as an import error.+ $RUNNER_TEMP/.venv-api/bin/python -c "import pytest"+ $RUNNER_TEMP/.venv-agents/bin/python -c "import pytest"+ # The repository's own gate suites (`tests/`, `scripts/tests/`) and the+ # forty `scripts/` gates this job runs are not a service: they have no+ # manifest and no lock of their own, so there is no locked set to+ # install for them. They keep the derived-range install, on the+ # interpreter the service suites no longer use. Stated rather than+ # implied — it is the one install path in this job that can still+ # re-resolve, and it grades no service's code.+ - name: Install what the repository's own gate suites need+ run: |+ set -euo pipefailpython3 scripts/service_requirements.py api agents | xargs pip install --quiet# Boot-test: verify the FastAPI app can actually import without# NameError / ImportError before spending time on the full pytest@@ -938,14 +988,15 @@ jobs:SECRET_KEY: ci-dummy-secret-key-at-least-32bytes!DATABASE_URL: postgresql+asyncpg://x:x@localhost/xrun: |- python -c "from app.main import app; print('api boot-test ok')"+ $RUNNER_TEMP/.venv-api/bin/python -c "from app.main import app; print('api boot-test ok')"- name: Run API tests (unit + GraphQL schema)working-directory: services/apienv:ENVIRONMENT: developmentSECRET_KEY: ci-dummy-secret-key-at-least-32bytes!DATABASE_URL: postgresql+asyncpg://x:x@localhost/x- run: python -m pytest tests/ -v --tb=short+ run: |+ $RUNNER_TEMP/.venv-api/bin/python -m pytest tests/ -v --tb=short# This used to be a hand-maintained list of 26 file paths, which is the# same "a matrix is a list somebody has to remember to add to" shape# called out for the Go modules further down, and it had the same@@ -971,7 +1022,7 @@ jobs:# search this suite grades was the empty list, every run.run: |cd services/agents- python3 -m pytest tests/ -v --tb=short -rs+ $RUNNER_TEMP/.venv-agents/bin/python -m pytest tests/ -v --tb=short -rs# The repository's own gate suites — `tests/` and `scripts/tests/`.# `tests/` was reached only as nineteen single-file invocations spread@@ -1244,13 +1295,37 @@ jobs:# lock, so the module could not load there at all; only this line made# the tests pass. The pysigma defect with the arrow reversed.#- # Derived now, from the three manifests, with pip resolving the- # intersection where they disagree.- - name: Install what fusion, honeytokens and purple-team declare+ # Derived from the three manifests now — and then from the three+ # *locks*, because a range still re-resolves and the version CI grades+ # has to be the version the image ships. These three disagree about+ # `asyncpg` (0.29.0 against 0.31.0), so they cannot share an+ # interpreter and each gets its own virtualenv installed `--no-deps`+ # from its own resolved closure.+ - name: Install fusion, honeytokens and purple-team from their committed locksrun: |set -euo pipefail- python3 scripts/service_requirements.py fusion honeytokens purple-team \- | xargs pip install --quiet+ # Per service, not a loop: the gate has to be able to read which+ # service each line installs, and `"${svc}"` resolves to none.+ python3 -m venv $RUNNER_TEMP/.venv-fusion+ python3 scripts/service_requirements.py fusion --locked > /tmp/fusion.lock.txt+ $RUNNER_TEMP/.venv-fusion/bin/pip install --quiet --disable-pip-version-check --no-deps -r /tmp/fusion.lock.txt++ python3 -m venv $RUNNER_TEMP/.venv-honeytokens+ python3 scripts/service_requirements.py honeytokens --locked > /tmp/honeytokens.lock.txt+ $RUNNER_TEMP/.venv-honeytokens/bin/pip install --quiet --disable-pip-version-check --no-deps -r /tmp/honeytokens.lock.txt++ python3 -m venv $RUNNER_TEMP/.venv-purple-team+ python3 scripts/service_requirements.py purple-team --locked > /tmp/purple-team.lock.txt+ $RUNNER_TEMP/.venv-purple-team/bin/pip install --quiet --disable-pip-version-check --no-deps -r /tmp/purple-team.lock.txt++ # pip skips a requirement whose marker is false without warning and+ # with exit 0. These three declare their test runner through a PEP+ # 621 extra, which poetry locks as `extra == "dev"` — false in a+ # plain requirements file — and all three came out of a successful+ # install with no pytest in them.+ $RUNNER_TEMP/.venv-fusion/bin/python -c "import pytest"+ $RUNNER_TEMP/.venv-honeytokens/bin/python -c "import pytest"+ $RUNNER_TEMP/.venv-purple-team/bin/python -c "import pytest"# Phase 2.2 — every wave-1 service now has a measured coverage# floor encoded in its pyproject under `[tool.coverage.report]# fail_under`. Pytest reads it via `--cov-config=pyproject.toml`@@ -1260,13 +1335,16 @@ jobs:# grow.- name: Run fusion unit tests + coverage gateworking-directory: services/fusion- run: python -m pytest tests/ --cov-config=pyproject.toml --cov=app --cov-report=term-missing -v --tb=short+ run: |+ $RUNNER_TEMP/.venv-fusion/bin/python -m pytest tests/ --cov-config=pyproject.toml --cov=app --cov-report=term-missing -v --tb=short- name: Run honeytokens unit tests + coverage gateworking-directory: services/honeytokens- run: python -m pytest tests/ --cov-config=pyproject.toml --cov=app --cov-report=term-missing -v --tb=short+ run: |+ $RUNNER_TEMP/.venv-honeytokens/bin/python -m pytest tests/ --cov-config=pyproject.toml --cov=app --cov-report=term-missing -v --tb=short- name: Run purple-team unit tests + coverage gateworking-directory: services/purple-team- run: python -m pytest tests/ --cov-config=pyproject.toml --cov=app --cov-report=term-missing -v --tb=short+ run: |+ $RUNNER_TEMP/.venv-purple-team/bin/python -m pytest tests/ --cov-config=pyproject.toml --cov=app --cov-report=term-missing -v --tb=short# ──────────────────────────────────────────────# Phase 2.1 — Wider Python service test matrix.@@ -1357,7 +1435,10 @@ jobs:# cannot be disjoint with anything, and pip still caches wheels across# cells. `aioredis`, `jinja2` and `tenacity` are simply gone: no# service here declares or imports any of them.- - name: Install what services/${{ matrix.service }} declares+ #+ # And from that service's committed lock rather than from its ranges,+ # so the versions this cell grades are the versions its image ships.+ - name: Install services/${{ matrix.service }} from its committed lockrun: |set -euo pipefailSYSTEM="$(python3 scripts/service_requirements.py '${{ matrix.service }}' --system)"@@ -1365,8 +1446,15 @@ jobs:sudo apt-get update -qqsudo apt-get install -y --no-install-recommends ${SYSTEM}fi- python3 scripts/service_requirements.py '${{ matrix.service }}' \- | xargs pip install --quiet+ python3 -m venv $RUNNER_TEMP/.venv-${{ matrix.service }}+ python3 scripts/service_requirements.py '${{ matrix.service }}' --locked > '/tmp/${{ matrix.service }}.lock.txt'+ $RUNNER_TEMP/.venv-${{ matrix.service }}/bin/pip install --quiet --disable-pip-version-check \+ --no-deps -r '/tmp/${{ matrix.service }}.lock.txt'+ echo "${{ matrix.service }}: $(wc -l < '/tmp/${{ matrix.service }}.lock.txt') pinned distribution(s)"+ # pip skips a requirement whose marker is false without warning and+ # with exit 0, so a successful install can leave an empty+ # environment. Say so here rather than at the pytest step.+ $RUNNER_TEMP/.venv-${{ matrix.service }}/bin/python -c "import pytest"# Phase 2.2 — coverage floor read from each service's pyproject.# `--cov-config=pyproject.toml` makes coverage.py honour the# `[tool.coverage.report] fail_under = N` line; pytest-cov then@@ -1375,7 +1463,7 @@ jobs:- name: Run ${{ matrix.service }} tests + coverage gateworking-directory: services/${{ matrix.service }}run: |- python -m pytest tests/ \+ $RUNNER_TEMP/.venv-${{ matrix.service }}/bin/python -m pytest tests/ \--cov-config=pyproject.toml \--cov=app \--cov-report=term-missing \diff --git a/scripts/check_ci_install_parity.py b/scripts/check_ci_install_parity.pyindex 4850034a0..039e6dce4 100644--- a/scripts/check_ci_install_parity.py+++ b/scripts/check_ci_install_parity.py@@ -165,6 +165,12 @@ class SuiteJob:services: set[str] = field(default_factory=set)installs: dict[str, Requirement] = field(default_factory=dict)invocations: list[str] = field(default_factory=list)+ #: service -> {distribution: exact version}, for a job that installs that+ #: service's committed `poetry.lock` rather than re-resolving its ranges.+ locked: dict[str, dict[str, str]] = field(default_factory=dict)+ #: service -> the interpreter its suite is run with, so "installed the+ #: lock" and "ran the suite against the lock" stay separate claims.+ runners: dict[str, set[str]] = field(default_factory=dict)@dataclass@@ -388,6 +394,46 @@ def requirements_in(command: str) -> list[Requirement]:_DERIVED = re.compile(r"service_requirements\.py\s+(?P<args>[^|>\n]*)")+def locked_installs(run: str, root: Path) -> dict[str, dict[str, str]]:+ """Which services this command installs from their committed ``poetry.lock``.++ ``service_requirements.py <name> --locked`` emits that lock's complete+ resolved closure as exact pins, and the workflow feeds it to+ ``pip install --no-deps``, so pip resolves nothing and the set it lands on+ is the set the image ships. Resolving it here means reading the same lock.++ A service name that does not survive as a literal — ``"${svc}"`` from a+ shell loop — resolves to nothing, and a job that installs nothing this+ reader can see is a job this gate would pass while grading an unknown+ version set. So the workflows spell each service out, and+ ``check_locked_installs`` fails any suite whose lock it could not find a+ line for.+ """+ found: dict[str, dict[str, str]] = {}+ for match in _DERIVED.finditer(run):+ if "--locked" not in match.group("args"):+ continue+ args = match.group("args").split()+ groups = "all"+ for index, arg in enumerate(args):+ if arg.strip().strip("\"'") == "--only" and index + 1 < len(args):+ groups = args[index + 1].strip().strip("\"'")+ for arg in args:+ name = arg.strip().strip("\"'()")+ if name.startswith("-") or "$" in name or not name:+ continue+ manifest = root / "services" / name / "pyproject.toml"+ if not manifest.is_file() or not (root / "services" / name / "poetry.lock").is_file():+ continue+ pins: dict[str, str] = {}+ for pin in service_requirements.locked_requirements(manifest, groups):+ package, _, version = pin.split(";")[0].strip().partition("==")+ if version:+ pins[canonical(package)] = version+ found[name] = pins+ return found++def derived_requirements(run: str, root: Path) -> list[Requirement]:"""What ``service_requirements.py <names> | xargs pip install`` installs.@@ -404,11 +450,22 @@ def derived_requirements(run: str, root: Path) -> list[Requirement]:"""found: list[Requirement] = []for match in _DERIVED.finditer(run):- names = [- arg.strip().strip("\"'")- for arg in match.group("args").split()- if not arg.startswith("-") and "$" not in arg and arg.strip().strip("\"'")- ]+ args = match.group("args").split()+ # Matched against the raw argument text, not against split tokens: the+ # `--system` call is inside a command substitution, so the token+ # arrives as `--system)"` and an equality test on it silently fails.+ flags = match.group("args")+ if "--locked" in flags:+ continue # `locked_installs` resolves this line to exact pins instead+ if "--system" in flags:+ # Emits apt package names for the native libraries WeasyPrint+ # reaches through ctypes, and they go to `apt-get`. Reading it as+ # a pip install credits the job with installing a set it never+ # installed — which, now that the real install is `--locked`,+ # would have the matrix cells reporting range installs that do+ # not exist.+ continue+ names = [arg.strip().strip("\"'") for arg in args if not arg.startswith("-") and "$" not in arg and arg.strip().strip("\"'")]for name in names:manifest = root / "services" / name / "pyproject.toml"if not manifest.is_file():@@ -452,6 +509,21 @@ _SERVICE_PATH = re.compile(r"services/([a-z0-9][a-z0-9-]*)")_PYTEST_LINE = re.compile(r"\bpytest\b(?P<args>.*)$")+_VENV_RUNNER = re.compile(r"\.venv-(?P<service>[a-z0-9][a-z0-9-]*)/bin/python")+++def suite_runner(line: str) -> str:+ """The interpreter a suite line invokes: ``.venv-<service>`` or the default one.++ Installing a lock and running the suite against it are two claims, and a+ job can do the first and not the second — the install step is the easy+ half to get right and the easy half to leave dangling. Keeping them apart+ means ``check_locked_installs`` can say which one is missing.+ """+ match = _VENV_RUNNER.search(line)+ return f".venv-{match.group('service')}" if match else "default"++def whole_suite_targets(run: str, working_directory: str) -> set[str]:"""Services whose *whole* suite this command collects.@@ -487,6 +559,17 @@ def whole_suite_targets(run: str, working_directory: str) -> set[str]:return targets+def whole_suite_runs(run: str, working_directory: str) -> dict[str, set[str]]:+ """Service -> the interpreter(s) the command runs its whole suite with."""+ runs: dict[str, set[str]] = {}+ for line in re.sub(r"\\\s*\n", " ", run).splitlines():+ if not _PYTEST_LINE.search(line):+ continue+ for service in whole_suite_targets(line, working_directory) or whole_suite_targets(run, working_directory):+ runs.setdefault(service, set()).add(suite_runner(line))+ return runs++def remember(record: SuiteJob, requirement: Requirement) -> None:"""Record an install, merging repeats the way pip resolves them.@@ -538,10 +621,13 @@ def read_workflows(root: Path) -> list[SuiteJob]:remember(record, requirement)for requirement in derived_requirements(run, root):remember(record, requirement)+ record.locked.update(locked_installs(run, root))hit = whole_suite_targets(run, working_directory)if hit:record.services |= hitrecord.invocations.append(run.strip().splitlines()[-1][:90])+ for service, runners in whole_suite_runs(run, working_directory).items():+ record.runners.setdefault(service, set()).update(runners)# `${{ env.API_DEPS }}` reaches pip as arguments; the folded# scalar that defines it is an install path even though no# `pip install` appears on its lines.@@ -549,7 +635,7 @@ def read_workflows(root: Path) -> list[SuiteJob]:if key.endswith("DEPS") and isinstance(value, str):for requirement in requirements_in("pip install " + value):remember(record, requirement)- if record.services and record.installs:+ if record.services and (record.installs or record.locked):jobs.append(record)return jobs@@ -557,16 +643,30 @@ def read_workflows(root: Path) -> list[SuiteJob]:# ── Reading a service ────────────────────────────────────────────────────────-def _dependency_table(table: dict) -> dict[str, str]:- out: dict[str, str] = {}+def _dependency_table(table: dict) -> tuple[dict[str, str], dict[str, str]]:+ """Split a poetry dependency table into (always installed, optional).++ ``optional = true`` means an extra is the only thing that pulls the+ package in, and the Dockerfiles run ``poetry install --only main --no-root``+ with no ``--extras`` — so the image does **not** have it. Reading such a+ dependency as runtime says "production always has this", which inverts the+ question every check below asks. ``services/agents`` declares+ ``weasyprint = {version = ">=62,<71", optional = true}`` and guards the+ import; demanding CI install it would be demanding CI grade a path the+ image cannot take.+ """+ always: dict[str, str] = {}+ optional: dict[str, str] = {}for name, spec in (table or {}).items():if name == "python":continue+ is_optional = Falseif isinstance(spec, dict):+ is_optional = bool(spec.get("optional"))spec = spec.get("version", "")if isinstance(spec, str):- out[canonical(name)] = spec.strip()- return out+ (optional if is_optional else always)[canonical(name)] = spec.strip()+ return always, optionaldef _handles_import_error(node: ast.Try) -> bool:@@ -646,10 +746,18 @@ def read_services(root: Path) -> dict[str, Service]:project = data.get("project", {})dev: dict[str, str] = {}for group in (poetry.get("group") or {}).values():- dev.update(_dependency_table(group.get("dependencies", {})))+ group_always, group_optional = _dependency_table(group.get("dependencies", {}))+ dev.update(group_always)+ dev.update(group_optional)for extra in (project.get("optional-dependencies") or {}).values():dev.update(_pep621_table(extra))- runtime = {**_dependency_table(poetry.get("dependencies", {})), **_pep621_table(project.get("dependencies"))}+ # An `optional = true` runtime dependency is declared, so it still+ # resolves a guarded import to a distribution — but it is not+ # something the image always has, so it belongs beside the dev group+ # rather than in `runtime`.+ main_always, main_optional = _dependency_table(poetry.get("dependencies", {}))+ dev.update(main_optional)+ runtime = {**main_always, **_pep621_table(project.get("dependencies"))}if not runtime and not dev:unreadable.append(manifest.parent.name)continue@@ -728,6 +836,11 @@ def check_fallbacks(jobs: list[SuiteJob], services: dict[str, Service]) -> tuplecontinue # optional by declaration: the fallback is the contractif distribution in job.installs:continue+ # Installed from the service's own lock, which is the set the+ # image ships. `check_locked_installs` asks the same question+ # of the lock, so a lock genuinely missing it is still caught.+ if distribution in job.locked.get(name, {}):+ continueif (name, distribution) in EXEMPT:continueproblems.append(@@ -739,6 +852,99 @@ def check_fallbacks(jobs: list[SuiteJob], services: dict[str, Service]) -> tuplereturn problems, sorted(set(unresolved))+def check_locked_installs(jobs: list[SuiteJob], services: dict[str, Service], root: Path) -> list[str]:+ """lock -> ci: grade the version set the image ships, not one inside its ranges.++ Deriving CI's install list from the manifests removed the hand-written+ copy, but a *range* still re-resolves at install time, so CI could land on+ a different patch release than the image. That is not hypothetical: the+ defect this direction exists for had ``services/api`` declaring+ ``opentelemetry-instrumentation-fastapi = "^0.45b0"`` and locking 0.45b0,+ while the job installed it with no bound at all, resolved 0.66b0 and+ passed — CI graded a version the image did not contain, and the one the+ image contained could not serve a request.++ So: a whole-suite job for a service with a committed lock must install+ that lock, and must run that service's suite with the interpreter it+ installed it into. The two are checked separately because a job can do+ the first and not the second, and then the pins are sitting in a+ virtualenv nothing uses.++ Three further conditions, because a pin is only parity if it is a pin of+ the right thing:++ * The locked version must satisfy the range its own manifest declares. A+ lock that has drifted from its manifest is a lock pinning something the+ service no longer permits.+ * The lock must contain every runtime distribution whose absence the+ service's own code handles with ``except ImportError`` — the pysigma+ shape, asked of the lock rather than of a list.+ * A service with **no** lock is reported as the exception it is, named,+ rather than passing silently.+ """+ problems: list[str] = []+ for job in jobs:+ for name in sorted(job.services):+ service = services.get(name)+ if service is None:+ continue+ lock = root / "services" / name / "poetry.lock"+ if not lock.is_file():+ problems.append(+ f"{job.workflow}:{job.job} runs the whole services/{name} suite and services/{name} has no "+ f"poetry.lock, so there is no resolved set to install — CI necessarily re-resolves and the "+ f"version it grades is not guaranteed to be the version the image ships (lock -> ci, no lock)"+ )+ continue+ pins = job.locked.get(name)+ if pins is None:+ problems.append(+ f"{job.workflow}:{job.job} runs the whole services/{name} suite but does not install "+ f"services/{name}/poetry.lock — it re-resolves inside the declared ranges, so the versions it "+ f"grades need not be the versions services/{name}/Dockerfile installs. Install with "+ f"`service_requirements.py {name} --locked` (lock -> ci)"+ )+ continue++ runners = job.runners.get(name, set())+ if runners and runners != {f".venv-{name}"}:+ problems.append(+ f"{job.workflow}:{job.job} installs services/{name}/poetry.lock but runs that suite with "+ f"{', '.join(sorted(runners))} rather than .venv-{name} — the pins are installed into an "+ f"interpreter the tests do not use (lock -> ci, unused environment)"+ )++ for package, version in sorted(pins.items()):+ declared = service.declared.get(package)+ if declared is None:+ continue+ interval = bounds(declared)+ if interval is None:+ continue+ low, high = interval[0] or _FLOOR, interval[1] or _CEILING+ pinned = release(version)+ if _pad(pinned, low)[0] < _pad(pinned, low)[1] or not _pad(pinned, high)[0] < _pad(pinned, high)[1]:+ problems.append(+ f"services/{name}/poetry.lock pins `{package}` {version}, which its own manifest "+ f"({declared}) does not permit — the lock and the manifest have drifted, so installing "+ f"the lock installs something the service forbids (lock -> ci, lock outside manifest)"+ )++ for module, sites in sorted(service.fallbacks.items()):+ distribution = distribution_for(module, set(service.declared))+ if distribution is None or distribution not in service.runtime:+ continue+ if distribution in pins or (name, distribution) in EXEMPT:+ continue+ problems.append(+ f"{job.workflow}:{job.job} installs services/{name}/poetry.lock, but that lock does not "+ f"contain `{distribution}` — services/{name} declares it as a runtime dependency and "+ f"{sites[0]} handles its absence with `except ImportError`, so the suite grades the fallback "+ f"(lock -> ci, guarded dependency absent from the lock)"+ )+ return problems++def check_installs_are_declared(jobs: list[SuiteJob], services: dict[str, Service]) -> list[str]:"""ci -> manifest: a package no service in the job declares."""problems: list[str] = []@@ -906,6 +1112,7 @@ def run(root: Path, *, inventory: bool = False, as_json: bool = False) -> tuple[problems = (fallback_problems+ unresolved+ + check_locked_installs(jobs, services, root)+ check_installs_are_declared(jobs, services)+ check_ranges(jobs, services)+ check_exemptions(jobs, services)@@ -926,16 +1133,20 @@ def run(root: Path, *, inventory: bool = False, as_json: bool = False) -> tuple[return (1 if problems else 0), problemsguarded = sum(len(s.fallbacks) for s in services.values())+ graded = {s for j in jobs for s in j.services}+ from_lock = {(j.workflow, j.job, s) for j in jobs for s in j.services if s in j.locked}+ total_suites = {(j.workflow, j.job, s) for j in jobs for s in j.services}print(f"check_ci_install_parity: root {root}")- print(- f" {len(jobs)} whole-suite job(s) over {len({s for j in jobs for s in j.services})} of "- f"{len(services)} service(s); {guarded} guarded import(s) across the tree"- )+ print(f" {len(jobs)} whole-suite job(s) over {len(graded)} of {len(services)} service(s); {guarded} guarded import(s) across the tree")+ print(f" {len(from_lock)} of {len(total_suites)} suite run(s) install the service's committed poetry.lock")if inventory:for job in jobs:print(f" {job.workflow}:{job.job}")print(f" services : {', '.join(sorted(job.services))}")- print(f" installs : {len(job.installs)} package(s)")+ print(f" installs : {len(job.installs)} package(s) from declared ranges")+ for locked_name, pins in sorted(job.locked.items()):+ runner = ", ".join(sorted(job.runners.get(locked_name, {"?"})))+ print(f" locked : services/{locked_name} -> {len(pins)} exact pin(s), run by {runner}")for line in job.invocations:print(f" runs : {line}")for name, service in sorted(services.items()):@@ -978,14 +1189,31 @@ def _fixture(root: Path) -> None:"def run():\n try:\n import sigma\n except ImportError:\n return []\n return sigma.everything()\n",encoding="utf-8",)+ # The lock is what the image installs, so it is what CI must install.+ (service / "poetry.lock").write_text(+ '[[package]]\nname = "pysigma"\nversion = "0.11.31"\ngroups = ["main"]\noptional = false\n\n'+ '[[package]]\nname = "httpx"\nversion = "0.28.1"\ngroups = ["main"]\noptional = false\n\n'+ '[[package]]\nname = "pytest"\nversion = "9.1.1"\ngroups = ["dev"]\noptional = false\n\n'+ '[metadata]\nlock-version = "2.1"\n',+ encoding="utf-8",+ )+ # Two install paths, as `ci.yml:python-test` really has: a derived-range+ # install serving the repository's own gate suites, which are not a+ # service and have no lock, and the service's locked set in its own+ # virtualenv. Keeping both in the fixture is what lets the range cases+ # and the lock cases below aim at different lines.(root / ".github" / "workflows" / "ci.yml").write_text("name: CI\n""jobs:\n"" demo:\n"" steps:\n"' - run: pip install "pysigma>=0.11.17,<0.12" "httpx>=0.27,<0.29" "pytest>=9.0.3,<10.0"\n'+ " - run: |\n"+ " python3 -m venv .venv-demo\n"+ " python3 scripts/service_requirements.py demo --locked > /tmp/demo.lock.txt\n"+ " .venv-demo/bin/pip install --no-deps -r /tmp/demo.lock.txt\n"" - working-directory: services/demo\n"- " run: python -m pytest tests/ -v\n",+ " run: ../../.venv-demo/bin/python -m pytest tests/ -v\n",encoding="utf-8",)# A second job that names one test file. It is out of scope by design, so@@ -1021,8 +1249,26 @@ def self_test() -> int:workflow = lambda root: root / ".github" / "workflows" / "ci.yml" # noqa: E731manifest = lambda root: root / "services" / "demo" / "pyproject.toml" # noqa: E731+ _LOCKED_STEP = (+ " python3 scripts/service_requirements.py demo --locked > /tmp/demo.lock.txt\n"+ " .venv-demo/bin/pip install --no-deps -r /tmp/demo.lock.txt\n"+ )++ def unlock(root: Path) -> None:+ """Put the job back on a re-resolved install, as it was before the lock.++ The `fallback -> ci` and attribution cases below are about a job whose+ environment comes from a *list*. Once the lock is installed the list+ stops mattering — the lock has pysigma whatever the list says — so+ injecting into the list alone proves nothing. These cases have to+ reproduce the world they were written for.+ """+ path = workflow(root)+ path.write_text(path.read_text().replace(_LOCKED_STEP, ""), encoding="utf-8")+def drop_the_guarded_runtime_dependency(root: Path) -> None:"""The pysigma defect: the image has it, CI does not, the code falls back."""+ unlock(root)path = workflow(root)path.write_text(path.read_text().replace('"pysigma>=0.11.17,<0.12" ', ""), encoding="utf-8")@@ -1074,12 +1320,13 @@ def self_test() -> int:only understood `working-directory:` would miss the suite that foundthe defect this gate exists for."""+ unlock(root)path = workflow(root)path.write_text(path.read_text().replace('"pysigma>=0.11.17,<0.12" ', "").replace(- " - working-directory: services/demo\n run: python -m pytest tests/ -v\n",+ " - working-directory: services/demo\n run: ../../.venv-demo/bin/python -m pytest tests/ -v\n"," - run: |\n cd services/demo\n python -m pytest tests/ -v\n",),encoding="utf-8",@@ -1120,10 +1367,93 @@ def self_test() -> int:workflow_path.write_text(workflow_path.read_text().replace('"httpx>=0.27,<0.29"', '"httpx>=0.27,<0.28"'), encoding="utf-8")narrow = root / ".github" / "workflows" / "narrow.yml"narrow.write_text(narrow.read_text().replace('"httpx>=0.27,<0.29"', '"httpx>=0.27,<0.28"'), encoding="utf-8")+ # The lock has to move with the manifest, or this control injects a+ # second, genuine divergence and stops being a control.+ lock = root / "services" / "demo" / "poetry.lock"+ lock.write_text(+ lock.read_text().replace('name = "httpx"\nversion = "0.28.1"', 'name = "httpx"\nversion = "0.27.2"'), encoding="utf-8"+ )def stale_exemption(root: Path) -> None:EXEMPT[("demo", "httpx")] = "no reason that is still true"+ # ── The lock direction ──────────────────────────────────────────────────++ def re_resolve_instead_of_installing_the_lock(root: Path) -> None:+ """The defect this direction exists for, one notch smaller than the last.++ The job still derives its list from the manifest, so every earlier+ check passes — but it re-resolves inside the declared ranges, so the+ version it grades need not be the version the image ships.+ `^0.45b0` locking 0.45b0 while CI resolved 0.66b0 is exactly this.+ """+ path = workflow(root)+ path.write_text(+ path.read_text().replace(+ " python3 scripts/service_requirements.py demo --locked > /tmp/demo.lock.txt\n"+ " .venv-demo/bin/pip install --no-deps -r /tmp/demo.lock.txt\n",+ " python3 scripts/service_requirements.py demo | xargs .venv-demo/bin/pip install\n",+ ),+ encoding="utf-8",+ )++ def install_the_lock_but_run_the_suite_elsewhere(root: Path) -> None:+ """Pins installed into a virtualenv the tests do not use."""+ path = workflow(root)+ path.write_text(path.read_text().replace("../../.venv-demo/bin/python -m pytest", "python -m pytest"), encoding="utf-8")++ def lock_drifts_outside_its_manifest(root: Path) -> None:+ """A pin the service's own manifest no longer permits."""+ path = root / "services" / "demo" / "poetry.lock"+ path.write_text(+ path.read_text().replace('name = "pysigma"\nversion = "0.11.31"', 'name = "pysigma"\nversion = "0.13.0"'), encoding="utf-8"+ )++ def lock_omits_a_guarded_runtime_dependency(root: Path) -> None:+ """The pysigma shape, asked of the lock rather than of a hand-written list."""+ path = root / "services" / "demo" / "poetry.lock"+ path.write_text(+ path.read_text().replace('[[package]]\nname = "pysigma"\nversion = "0.11.31"\ngroups = ["main"]\noptional = false\n\n', ""),+ encoding="utf-8",+ )++ def remove_the_lock_entirely(root: Path) -> None:+ """No lock is an exception to be named, not one to pass silently."""+ (root / "services" / "demo" / "poetry.lock").unlink()+ path = workflow(root)+ path.write_text(+ path.read_text().replace(+ " python3 scripts/service_requirements.py demo --locked > /tmp/demo.lock.txt\n"+ " .venv-demo/bin/pip install --no-deps -r /tmp/demo.lock.txt\n",+ "",+ ),+ encoding="utf-8",+ )++ def declare_the_guarded_package_optional_in_the_manifest(root: Path) -> None:+ """`optional = true` means the image does not have it either.++ `services/agents` declares WeasyPrint that way. Reading it as a+ runtime dependency would demand CI install something no image ships,+ and grade a path production cannot take — the guarded-import defect+ pointing the wrong way. So this must NOT be reported.+ """+ path = manifest(root)+ path.write_text(+ path.read_text().replace('pysigma = ">=0.11.17,<0.12"', 'pysigma = { version = ">=0.11.17,<0.12", optional = true }'),+ encoding="utf-8",+ )+ workflow_path = workflow(root)+ workflow_path.write_text(workflow_path.read_text().replace('"pysigma>=0.11.17,<0.12" ', ""), encoding="utf-8")+ lock = root / "services" / "demo" / "poetry.lock"+ lock.write_text(+ lock.read_text().replace(+ 'name = "pysigma"\nversion = "0.11.31"\ngroups = ["main"]\noptional = false',+ 'name = "pysigma"\nversion = "0.11.31"\ngroups = ["main"]\noptional = true',+ ),+ encoding="utf-8",+ )+cases: list[tuple[str, object, str | None]] = [("clean fixture passes", None, None),("guarded runtime dependency missing from CI", drop_the_guarded_runtime_dependency, "fallback -> ci"),@@ -1136,10 +1466,20 @@ def self_test() -> int:("a guarded import nothing provides", guard_a_module_nothing_provides, "no declared dependency provides it"),("attribution through `cd` rather than working-directory", reach_the_service_by_cd_instead_of_working_directory, "fallback -> ci"),("a stale exemption", stale_exemption, "exemption"),+ ("CI re-resolves the ranges instead of installing the lock", re_resolve_instead_of_installing_the_lock, "lock -> ci"),+ (+ "the lock is installed into an environment the suite does not use",+ install_the_lock_but_run_the_suite_elsewhere,+ "unused environment",+ ),+ ("the lock pins a version its manifest forbids", lock_drifts_outside_its_manifest, "lock outside manifest"),+ ("the lock omits a guarded runtime dependency", lock_omits_a_guarded_runtime_dependency, "absent from the lock"),+ ("a service with no lock at all", remove_the_lock_entirely, "no lock"),# Controls: these must NOT be reported.("a caret and its explicit range agree", caret_and_explicit_range_are_the_same_range, None),("two divergences inside a job that names one file", break_only_the_narrow_job, None),("a dev-group dependency is optional by declaration", declare_the_guarded_package_optional, None),+ ("a runtime dependency marked optional in the manifest", declare_the_guarded_package_optional_in_the_manifest, None),]declared_optional = dict(OPTIONAL_BY_OMISSION)@@ -1177,7 +1517,10 @@ def self_test() -> int:# empty tree.def strip_every_suite_run(root: Path) -> None:path = workflow(root)- path.write_text(path.read_text().replace(" run: python -m pytest tests/ -v\n", " run: true\n"), encoding="utf-8")+ path.write_text(+ path.read_text().replace(" run: ../../.venv-demo/bin/python -m pytest tests/ -v\n", " run: true\n"),+ encoding="utf-8",+ )code, _ = build(strip_every_suite_run)vacuous = code != 0diff --git a/scripts/check_test_discovery.py b/scripts/check_test_discovery.pyindex 1d635e7d8..1e7ab742e 100644--- a/scripts/check_test_discovery.py+++ b/scripts/check_test_discovery.py@@ -118,8 +118,15 @@ DEFAULT_PYTHON_FILES = ("test_*.py", "*_test.py")#: `pip install ... pytest` line, and an install line has no path argument, so#: it reads as a bare collection of the entire tree — an over-broad resolver#: manufactures the coverage this gate exists to disprove.+#: The optional `["']` after the interpreter is not cosmetic. A quoted+#: interpreter path — `"$RUNNER_TEMP/.venv-api/bin/python" -m pytest` — puts+#: the closing quote between `python` and `-m`, so the `\s+` never matches and+#: the line is not recognised as a pytest run at all. The tokeniser below+#: handles it perfectly well; only this detector would have rejected it, which+#: is the worst place for the disagreement because the result is a suite+#: silently reported as collected by nothing._PYTEST_COMMAND = re.compile(- r"(?:^|[\n;&|]|\bpython3?(?:\.\d+)?\s+-m\s+|\buv\s+run\s+|\bpoetry\s+run\s+)\s*pytest\b",+ r"""(?:^|[\n;&|]|\bpython3?(?:\.\d+)?["']?\s+-m\s+|\buv\s+run\s+|\bpoetry\s+run\s+)\s*pytest\b""",re.MULTILINE,)_PIP_INSTALL = re.compile(r"\b(?:pip3?|python3?(?:\.\d+)?\s+-m\s+pip)\s+install\b")@@ -235,6 +242,16 @@ def _cd_target(segment: str, cwd: str) -> str | None:return Path(*parts).as_posix() if parts else ""+#: ``python``, ``python3``, ``python3.11``, ``/usr/bin/python3`` and+#: ``../../.venv-api/bin/python`` are all the same thing, and a resolver that+#: recognises only the bare names stops seeing a suite the moment CI runs it+#: from a virtualenv. Every whole-suite job does now — each service installs+#: its own ``poetry.lock`` into ``.venv-<service>`` because two locks cannot+#: share an interpreter — and matching on the bare name alone reported all+#: thirteen service trees as collected by nothing while CI ran every one.+_INTERPRETER = re.compile(r"(?:\S*/)?python3?(?:\.\d+)?")++def _args_after_pytest(tokens: list[str]) -> list[str] | None:"""The arguments handed to pytest, or None if this is not a pytest run."""index = 0@@ -248,7 +265,7 @@ def _args_after_pytest(tokens: list[str]) -> list[str] | None:if index + 1 >= len(tokens) or tokens[index + 1] != "run":return Noneindex += 2- if index < len(tokens) and re.fullmatch(r"python3?(?:\.\d+)?", tokens[index]):+ if index < len(tokens) and _INTERPRETER.fullmatch(tokens[index]):index += 1if index < len(tokens) and tokens[index] == "-m":index += 1@@ -834,6 +851,27 @@ def self_test() -> int:chooser: list[tuple[str, object, object]] = [("a plain invocation yields its arguments", _args_after_pytest(shlex.split("pytest tests/ -q")), ["tests/", "-q"]),("python -m pytest reaches the same place", _args_after_pytest(shlex.split("python3 -m pytest tests/")), ["tests/"]),+ (+ "an interpreter inside a virtualenv reaches the same place",+ _args_after_pytest(shlex.split("../../.venv-api/bin/python -m pytest tests/")),+ ["tests/"],+ ),+ (+ "an absolute interpreter path reaches the same place",+ _args_after_pytest(shlex.split("/usr/bin/python3.11 -m pytest tests/")),+ ["tests/"],+ ),+ ("a program merely ending in the word is not an interpreter", _args_after_pytest(shlex.split("mypython -m pytest tests/")), None),+ (+ "a quoted interpreter path is still a pytest command",+ bool(_PYTEST_COMMAND.search('"$RUNNER_TEMP/.venv-api/bin/python" -m pytest tests/')),+ True,+ ),+ (+ "an unquoted interpreter path is still a pytest command",+ bool(_PYTEST_COMMAND.search("$RUNNER_TEMP/.venv-api/bin/python -m pytest tests/")),+ True,+ ),("an env prefix is stepped over", _args_after_pytest(shlex.split("PYTHONPATH=. python -m pytest tests/")), ["tests/"]),("poetry run reaches the same place", _args_after_pytest(shlex.split("poetry run pytest tests/")), ["tests/"]),("a pip install line is not an invocation", _args_after_pytest(shlex.split("pip install pytest pytest-asyncio")), None),diff --git a/scripts/service_requirements.py b/scripts/service_requirements.pyindex 3985be9ee..2176c7c8c 100644--- a/scripts/service_requirements.py+++ b/scripts/service_requirements.py@@ -24,20 +24,42 @@ The list is the problem, not the entries. So this derives it. A job installs``$(python3 scripts/service_requirements.py <service>)`` and the question"does CI install what this service declares" stops having two answers.-What it is not----------------Not ``poetry export``. The image installs from ``poetry.lock``, so it gets one-exact version set; this re-resolves inside the declared ranges, so CI can land-on a different patch release than the image. That is a smaller gap than a-hand-written list and it is the gap this file leaves open, stated rather than-implied. Closing it means installing from the lock in CI, which costs the pip-wheel cache the matrix was built around.+Ranges, and why they were not enough+------------------------------------+The first version of this emitted the declared *ranges* and left a caveat+saying so: the image installs from ``poetry.lock`` and gets one exact version+set, while a range re-resolves at install time, so CI could still land on a+different patch release than the image ships. That is the same defect one+notch smaller, and it is exactly how the last one hid — ``services/api``+declared ``opentelemetry-instrumentation-fastapi = "^0.45b0"`` and locked+0.45b0, while CI installed the package unbounded, resolved 0.66b0, and passed.+Both were "inside the declared range".++``--locked`` closes it. It reads ``poetry.lock`` — the same file+``services/<name>/Dockerfile`` installs from — and emits the **complete+resolved closure** as exact ``==`` pins, one per line, carrying each entry's+environment markers. Installed with ``pip install --no-deps -r``, pip performs+no resolution at all: the set it lands on is the set the lock names, which is+the set the image ships. Measured against the published+``ghcr.io/beenuar/aisoc-core-api:latest``: 97 main-group entries, **0 version+mismatches**.++The pip wheel cache the matrix was built around survives, because this is+still pip installing wheels — it is the *resolution* that is gone, not the+cache.++Two services' locks cannot share one environment, so jobs that grade more than+one service install each into its own virtualenv. ``api`` and ``agents``+disagree about 28 distributions; ``fusion``/``honeytokens``/``purple-team``+about ``asyncpg``. That is not a defect in either lock — they are separate+images — but it does mean one interpreter cannot hold both.Usage-----python3 scripts/service_requirements.py apipython3 scripts/service_requirements.py api agents # unionpython3 scripts/service_requirements.py fusion --only main+ python3 scripts/service_requirements.py api --locked # exact pinspython3 scripts/service_requirements.py --listpython3 scripts/service_requirements.py --self-test"""@@ -177,6 +199,166 @@ def requirements(manifest: Path, groups: str = "all") -> list[str]:return [f"{name}{spec}" for name, spec in sorted(out.items())]+def service_lock(manifest: Path) -> Path:+ return manifest.parent / "poetry.lock"+++def _extras_closure(packages: list[dict], extras: dict) -> set[str]:+ """Every package reachable from a root ``[extras]`` entry.++ Poetry marks a package ``optional = true`` when an extra is the only thing+ that pulls it in. For the three services declaring their dev dependencies+ the PEP 621 way — ``honeytokens``, ``purple-team``, ``ueba`` — that is+ where ``pytest`` lives: group ``main``, ``optional = true``, listed under+ the ``dev`` extra. Dropping every optional entry would hand those three+ suites an environment with no test runner in it; keeping every optional+ entry would hand ``agents`` the WeasyPrint family, which its image does+ not have and whose absence its own code handles with ``except ImportError``+ — the fallback defect with the arrow reversed.++ So the rule is reachability, transitively: an optional package is in when+ some extra names it, or when a package already in names it as a+ dependency.+ """+ by_name = {canonical(p["name"]): p for p in packages}+ frontier = [canonical(n) for names in (extras or {}).values() for n in names]+ reached: set[str] = set()+ while frontier:+ name = frontier.pop()+ if name in reached or name not in by_name:+ continue+ reached.add(name)+ frontier += [canonical(dep) for dep in (by_name[name].get("dependencies") or {})]+ return reached+++_EXTRA_TERM = re.compile(r"""^\s*extra\s*==\s*['"][^'"]*['"]\s*$""")+++def _without_extra_selector(marker: str) -> str:+ """Drop ``extra == "..."`` terms from a marker.++ Poetry records a package pulled in by an extra with ``extra == "dev"``,+ which is a *selector*: it is true only while a resolver is expanding that+ extra. In a plain requirements file ``extra`` is undefined, so the clause+ is **false** and pip skips the line — silently, with no warning and exit+ 0. That is how the first run of this put `pytest` in the file for+ ``honeytokens``, ``purple-team`` and ``ueba`` and produced three+ virtualenvs with no test runner in them, failing three steps later with+ "No module named pytest".++ Reaching here means the extra was already selected, so the selector has+ served its purpose and any remaining condition is the real one:+ ``extra == "dev" and sys_platform == "win32"`` is a Windows-only package.++ A marker combining ``extra`` with ``or``, or parenthesised, is refused+ rather than reduced. Rewriting boolean logic by string surgery is how a+ line quietly starts meaning something else, and the failure mode this+ function exists to remove is precisely a line that silently does nothing.+ """+ if "extra" not in marker:+ return marker+ if "(" in marker or " or " in marker:+ raise SystemExit(+ f"service_requirements: cannot reduce the marker {marker!r}. It combines an `extra` selector with "+ f"`or`/parentheses, and rewriting that by string surgery risks changing what it means. Add a case "+ f"here deliberately rather than guessing."+ )+ return " and ".join(term for term in re.split(r"\s+and\s+", marker.strip()) if not _EXTRA_TERM.match(term))+++def _marker_for(package: dict, wanted: set[str]) -> str | None:+ """The environment marker to emit for one lock entry, or None for unconditional.++ ``markers`` is a string on most entries and a **per-group table** on ten+ of them — ``{main = '...', dev = '...'}``. Passing the table through+ verbatim hands pip the repr of a dict and it aborts the whole install with+ `InvalidMarker`, which took out six of the matrix cells on the first run.++ A group listed in ``groups`` but absent from the table has no condition+ under that group, so selecting it makes the entry unconditional. Where+ several selected groups each carry one, the entry is needed if any of them+ applies, so they are OR-ed.+ """+ raw = package.get("markers")+ if isinstance(raw, str):+ chosen = [raw]+ elif isinstance(raw, dict):+ chosen = []+ for group in sorted(set(package.get("groups") or ["main"]) & wanted):+ if group not in raw:+ return None+ chosen.append(raw[group])+ if not chosen:+ return None+ else:+ return None++ reduced: list[str] = []+ for marker in chosen:+ text = _without_extra_selector(marker).strip()+ if not text:+ return None # the marker was only the extra selector, already resolved+ if text not in reduced:+ reduced.append(text)+ if len(reduced) == 1:+ return reduced[0]+ return " or ".join(f"({part})" for part in reduced)+++def locked_requirements(manifest: Path, groups: str = "all") -> list[str]:+ """The service's ``poetry.lock`` as exact pins, in requirements.txt form.++ This is the whole resolved closure rather than the direct dependencies,+ because that is what makes ``pip install --no-deps`` legitimate: every+ transitive requirement is already named at a pinned version, so pip has+ nothing left to resolve and cannot drift.++ ``--only main`` reproduces what the Dockerfile installs+ (``poetry install --only main``); the default adds the dev group and the+ extras, which is what a test run needs on top.++ Markers are passed through rather than evaluated here. ``brotlicffi`` is+ marked ``platform_python_implementation != "CPython"`` and ``tzdata``+ ``platform_system == "Windows"``; both are correctly absent from a Linux+ CPython image, and pip is the right thing to decide that — evaluating+ markers in this script would mean reimplementing PEP 508 and getting a+ different answer than the installer on some platform nobody tested.++ Two forms have to be reshaped before pip sees them, and both were found by+ running this against real CI rather than by reading the locks: a+ per-group ``markers`` table, which pip rejects outright, and an+ ``extra == "..."`` selector, which pip accepts and silently evaluates+ false. See ``_marker_for`` and ``_without_extra_selector``.+ """+ lock = service_lock(manifest)+ if not lock.is_file():+ raise SystemExit(+ f"service_requirements: {manifest.parent.name} has no poetry.lock at "+ f"{lock}. --locked exists so CI installs the same version set the image does; "+ f"without the lock there is no such set, and emitting the ranges instead would "+ f"silently return to re-resolving."+ )+ data = tomllib.loads(lock.read_text(encoding="utf-8"))+ packages = data.get("package") or []+ if not packages:+ raise SystemExit(f"service_requirements: {lock} names no package — refusing to emit an empty install list.")++ wanted = {"main", "dev"} if groups == "all" else {groups}+ reachable = _extras_closure(packages, data.get("extras") or {}) if groups != "main" else set()++ out: list[str] = []+ for package in packages:+ if not (set(package.get("groups") or ["main"]) & wanted):+ continue+ if package.get("optional") and canonical(package["name"]) not in reachable:+ continue+ pin = f"{canonical(package['name'])}=={package['version']}"+ marker = _marker_for(package, wanted)+ out.append(f"{pin} ; {marker}" if marker else pin)+ return sorted(out)++def system_packages(names: list[str]) -> list[str]:seen: list[str] = []for requirement in names:@@ -262,6 +444,146 @@ def self_test() -> int:except SystemExit:refused = Trueexpect("a manifest it cannot read fails rather than emitting nothing", refused, True)++ # ── --locked ────────────────────────────────────────────────────────+ # The lock below is the shape this tree actually has: a main group, a+ # dev group, a marker-gated entry, and an extras-gated `pytest` — the+ # form the three PEP 621 services use, where dropping optional+ # entries wholesale leaves the suite with no test runner.+ locked_dir = temp / "locked"+ locked_dir.mkdir()+ (locked_dir / "pyproject.toml").write_text(+ '[tool.poetry]\nname = "demo"\nversion = "0.1.0"\n\n[tool.poetry.dependencies]\npython = "^3.11"\nfastapi = ">=0.117,<0.142"\n',+ encoding="utf-8",+ )+ (locked_dir / "poetry.lock").write_text(+ '[[package]]\nname = "fastapi"\nversion = "0.141.1"\ngroups = ["main"]\noptional = false\n\n'+ '[[package]]\nname = "tzdata"\nversion = "2026.4"\ngroups = ["main"]\noptional = false\n'+ 'markers = "platform_system == \\"Windows\\""\n\n'+ '[[package]]\nname = "mypy"\nversion = "1.2.3"\ngroups = ["dev"]\noptional = false\n\n'+ '[[package]]\nname = "pytest"\nversion = "9.1.1"\ngroups = ["main"]\noptional = true\n'+ '[package.dependencies]\npluggy = ">=1"\n\n'+ '[[package]]\nname = "pluggy"\nversion = "1.6.0"\ngroups = ["main"]\noptional = true\n\n'+ '[[package]]\nname = "weasyprint"\nversion = "66.0"\ngroups = ["main"]\noptional = true\n\n'+ '[extras]\ndev = ["pytest"]\n\n'+ '[metadata]\nlock-version = "2.1"\n',+ encoding="utf-8",+ )+ manifest_locked = locked_dir / "pyproject.toml"+ expect(+ "--locked emits exact pins, keeps markers, resolves the dev extra transitively",+ locked_requirements(manifest_locked),+ [+ "fastapi==0.141.1",+ "mypy==1.2.3",+ "pluggy==1.6.0",+ "pytest==9.1.1",+ 'tzdata==2026.4 ; platform_system == "Windows"',+ ],+ )+ expect(+ "--locked --only main is what the Dockerfile installs: no dev group, no extras",+ locked_requirements(manifest_locked, "main"),+ ["fastapi==0.141.1", 'tzdata==2026.4 ; platform_system == "Windows"'],+ )+ # An optional package no extra reaches is an extra the image does not+ # have either. Installing it would give CI a code path production+ # cannot take — the guarded-import defect with the arrow reversed.+ expect(+ "an optional package no extra reaches is excluded",+ [r for r in locked_requirements(manifest_locked) if r.startswith("weasyprint")],+ [],+ )++ # ── Marker forms pip will not take at face value ────────────────────+ # Both of these were found by running the generated file through a+ # real pip, not by reading the lock. The first aborts the install; the+ # second is accepted and silently installs nothing.+ expect(+ "an `extra` selector is dropped once the extra has been chosen",+ _without_extra_selector('extra == "dev"'),+ "",+ )+ expect(+ "a real condition beside the selector survives it",+ _without_extra_selector('extra == "dev" and sys_platform == "win32"'),+ 'sys_platform == "win32"',+ )+ expect(+ "a marker with no selector is untouched",+ _without_extra_selector('platform_system == "Windows" or sys_platform == "win32"'),+ 'platform_system == "Windows" or sys_platform == "win32"',+ )+ try:+ _without_extra_selector('extra == "dev" or sys_platform == "win32"')+ reduced_or = False+ except SystemExit:+ reduced_or = True+ expect("a selector combined with `or` is refused, not guessed at", reduced_or, True)++ expect(+ "a string marker passes through",+ _marker_for({"markers": 'sys_platform == "win32"', "groups": ["main"]}, {"main", "dev"}),+ 'sys_platform == "win32"',+ )+ expect(+ "a per-group marker table is OR-ed across the selected groups",+ _marker_for(+ {"markers": {"main": 'platform_system == "Windows"', "dev": 'sys_platform == "win32"'}, "groups": ["main", "dev"]},+ {"main", "dev"},+ ),+ '(sys_platform == "win32") or (platform_system == "Windows")',+ )+ expect(+ "a selected group absent from the table makes the entry unconditional",+ _marker_for({"markers": {"dev": 'python_version < "3.15"'}, "groups": ["main", "dev"]}, {"main", "dev"}),+ None,+ )+ expect(+ "only the selected group's condition is used",+ _marker_for({"markers": {"dev": 'python_version < "3.15"'}, "groups": ["main", "dev"]}, {"dev"}),+ 'python_version < "3.15"',+ )+ expect(+ "a marker that was only a selector becomes unconditional",+ _marker_for({"markers": 'extra == "dev"', "groups": ["main"]}, {"main", "dev"}),+ None,+ )++ # Every marker this tree's locks actually contain must survive the+ # round trip into something PEP 508 accepts. A unit test on two+ # handwritten strings would not have caught either defect above.+ real = temp / "real"+ real.mkdir()+ (real / "pyproject.toml").write_text(+ '[tool.poetry]\nname = "d"\nversion = "0.1.0"\n\n[tool.poetry.dependencies]\npython = "^3.11"\nx = "*"\n', encoding="utf-8"+ )+ (real / "poetry.lock").write_text(+ '[[package]]\nname = "a"\nversion = "1.0"\ngroups = ["main", "dev"]\noptional = false\n'+ 'markers = {main = \'platform_system == "Windows" or sys_platform == "win32"\', dev = \'sys_platform == "win32"\'}\n\n'+ '[[package]]\nname = "b"\nversion = "1.0"\ngroups = ["main"]\noptional = true\nmarkers = "extra == \\"dev\\""\n\n'+ '[extras]\ndev = ["b"]\n\n[metadata]\nlock-version = "2.1"\n',+ encoding="utf-8",+ )+ emitted = locked_requirements(real / "pyproject.toml")+ expect(+ "the two shapes this tree's locks really use come out installable",+ emitted,+ ['a==1.0 ; (sys_platform == "win32") or (platform_system == "Windows" or sys_platform == "win32")', "b==1.0"],+ )++ nolock = temp / "nolock"+ nolock.mkdir()+ (nolock / "pyproject.toml").write_text(+ '[tool.poetry]\nname = "d"\nversion = "0.1.0"\n\n[tool.poetry.dependencies]\npython = "^3.11"\nfastapi = "*"\n',+ encoding="utf-8",+ )+ try:+ locked_requirements(nolock / "pyproject.toml")+ refused_nolock = False+ except SystemExit:+ refused_nolock = True+ expect("--locked without a lock fails rather than falling back to ranges", refused_nolock, True)finally:shutil.rmtree(temp, ignore_errors=True)@@ -278,6 +600,11 @@ def main() -> int:parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)parser.add_argument("services", nargs="*", help="service directory name(s) under services/")parser.add_argument("--only", choices=("all", "main", "dev"), default="all", help="which dependency groups to emit")+ parser.add_argument(+ "--locked",+ action="store_true",+ help="emit the committed poetry.lock as exact pins, one per line, for `pip install --no-deps -r`",+ )parser.add_argument("--system", action="store_true", help="print the apt packages the set needs instead of the pip arguments")parser.add_argument("--list", action="store_true", dest="list_services", help="list every service with a manifest")parser.add_argument("--self-test", action="store_true", help="prove the conversions and the group selection")@@ -294,6 +621,25 @@ def main() -> int:if not args.services:parser.error("name at least one service, or pass --list")+ if args.locked:+ # One service at a time, on purpose. Exact pins from two locks cannot+ # be merged the way ranges can — `api` and `agents` disagree about 28+ # distributions — and quietly picking one would reintroduce the exact+ # thing this mode exists to remove. A job grading two services builds+ # two environments.+ if len(args.services) != 1:+ parser.error(+ "--locked emits one service's resolved set; name exactly one. Two locks cannot share an "+ "interpreter (api and agents disagree about 28 distributions), so a job grading several "+ "services installs each into its own virtualenv."+ )+ manifest = service_manifest(root, args.services[0])+ if args.system:+ print(" ".join(system_packages(locked_requirements(manifest, args.only))))+ else:+ print("\n".join(locked_requirements(manifest, args.only)))+ return 0+# Two services declaring one package: hand pip both constraints so it# installs the intersection. If they are disjoint pip fails loudly, which# is the honest outcome — one install path cannot serve two services thatdiff --git a/services/api/tests/test_sigma_backend_matching.py b/services/api/tests/test_sigma_backend_matching.pyindex 00708a4b7..f072bf0a6 100644--- a/services/api/tests/test_sigma_backend_matching.py+++ b/services/api/tests/test_sigma_backend_matching.py@@ -29,6 +29,7 @@ hunt worker.from __future__ import annotations+import reimport sysfrom pathlib import Pathfrom typing import Any@@ -237,6 +238,13 @@ def _python_test_install_set() -> tuple[list[str], list[str]]:producer the workflow asks. What stays falsifiable is the naming — a jobthat derives from the wrong service, or a manifest that drops the package,both fail here.++ The step now passes ``--locked`` and redirects to a file, so the answer+ comes from the lock rather than from the ranges — which is the point of+ that change, and is also a stronger question: "is pysigma in the set the+ virtualenv receives" rather than "is it in the set a resolver may choose+ from". The tail is cut at the redirect, because a reader that keeps going+ takes ``>`` and ``/tmp/api.lock.txt`` for service names."""root = Path(__file__).resolve().parents[3]sys.path.insert(0, str(root / "scripts"))@@ -245,15 +253,23 @@ def _python_test_install_set() -> tuple[list[str], list[str]]:workflow = yaml.safe_load((root / ".github" / "workflows" / "ci.yml").read_text())steps = workflow["jobs"]["python-test"]["steps"]named: list[str] = []+ locked: set[str] = set()for step in steps:for line in str(step.get("run") or "").splitlines():if "service_requirements.py" not in line or "--system" in line:continue- tail = line.split("service_requirements.py", 1)[1]- named += [word for word in tail.split("|")[0].split() if not word.startswith("-")]+ tail = re.split(r"[|>;]|&&", line.split("service_requirements.py", 1)[1])[0]+ words = [word for word in tail.split() if re.fullmatch(r"[a-z0-9][a-z0-9-]*", word)]+ named += words+ if "--locked" in line:+ locked.update(words)resolved: list[str] = []for service in dict.fromkeys(named):- resolved += service_requirements.requirements(root / "services" / service / "pyproject.toml")+ manifest = root / "services" / service / "pyproject.toml"+ if service in locked:+ resolved += service_requirements.locked_requirements(manifest)+ else:+ resolved += service_requirements.requirements(manifest)return list(dict.fromkeys(named)), resolved@@ -274,10 +290,16 @@ def test_ci_installs_the_backend_it_claims_to_test() -> None:# The floor is the measurement, not a preference: pysigma 0.11.0 through# 0.11.16 carry `from pyparsing import List` in `sigma/exceptions.py`, a# name pyparsing no longer re-exports, so importing the package raises on- # any current pyparsing. A manifest permitting one of those releases is a- # manifest permitting an engine that cannot start.- spec = next(r for r in requirements if r.lower().startswith("pysigma>") or r.lower().startswith("pysigma="))- assert ">=0.11.17" in spec, f"pysigma must be floored at 0.11.17; the job would install {spec}"+ # any current pyparsing. A release below the floor cannot start, so the+ # question is the same whichever form the step produces — the job must not+ # be able to install one. `==` is checked by value because a pin below the+ # floor is worse than a range permitting one: it installs it every time.+ spec = next(r for r in requirements if re.match(r"pysigma\s*[=><]", r, re.I))+ if "==" in spec:+ pinned = tuple(int(p) for p in re.findall(r"\d+", spec.split("==", 1)[1])[:3])+ assert pinned >= (0, 11, 17), f"the lock pins pysigma {spec}, below the 0.11.17 floor that can actually import"+ else:+ assert ">=0.11.17" in spec, f"pysigma must be floored at 0.11.17; the job would install {spec}"def test_the_yara_runner_is_installed_too() -> None:diff --git a/services/honeytokens/poetry.lock b/services/honeytokens/poetry.lockindex b7f6db506..a0e768d73 100644--- a/services/honeytokens/poetry.lock+++ b/services/honeytokens/poetry.lock@@ -482,6 +482,141 @@ files = [{file = "colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44"},]+[[package]]+name = "coverage"+version = "7.16.2"+description = "Code coverage measurement for Python"+optional = true+python-versions = ">=3.10"+groups = ["main"]+markers = "extra == \"dev\""+files = [+ {file = "coverage-7.16.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:23219888477edd736b6fcaec1272d47d93b926e999641ffea7e53a1738e70b2b"},+ {file = "coverage-7.16.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:40c0f00899fe6181ae7f434ceb200e51f5ee4b8ed10e3b5f0b605f0cae15da87"},+ {file = "coverage-7.16.2-cp310-cp310-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:a4624f80732f6b427ac58f1f59c577a0994a12e8174b5af6a027b4b58795d4c3"},+ {file = "coverage-7.16.2-cp310-cp310-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:191803c4996b499fcd78c2ad5e5f767dcc53cb4dc6de6d6a741b443a1821ef02"},+ {file = "coverage-7.16.2-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9fd670ac43b709c575aefc25bf52d8a598a3bc5017bddfd0a179152ab06a2deb"},+ {file = "coverage-7.16.2-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:705e5af11d34647efdc170c7840b6857c81cf74be96419a553f237e68e62cb72"},+ {file = "coverage-7.16.2-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:8afd9bf35cc6a1f22eb3634808fa8e0b91902459c5721ef2e4461dfe771d7f08"},+ {file = "coverage-7.16.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:3f43bac1856ba269b905302778d4df433d6006489a192174ad77ac528e395032"},+ {file = "coverage-7.16.2-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:f8475460aa33ee28ac896ab1156d0bb3b6c639f7f8383c2677d3359eb35f8205"},+ {file = "coverage-7.16.2-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:d6276d78f6fca7d0ac066d5da4165c5acd07829e8305c2cb900b738fb3a75a72"},+ {file = "coverage-7.16.2-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:736fde09ea39646d11f8e3b76bd3425c075aa4dd45f24891970bb77c14ff20f5"},+ {file = "coverage-7.16.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:c85d54e7e8a2ca932fe8399301af9b8d5907ea2a455ffaff6e7d1208db83b943"},+ {file = "coverage-7.16.2-cp310-cp310-win32.whl", hash = "sha256:5139009b5efd2194fc168ee9362f0e191ba612ef5d29242f9269c22f9b8f80c7"},+ {file = "coverage-7.16.2-cp310-cp310-win_amd64.whl", hash = "sha256:c3305c38a2fa21a4254f2ace7dd9ef5fc569c9a558b66e7017650b3d637fb95e"},+ {file = "coverage-7.16.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:732d950e51f3ba4fb6209c73250f3e8924fefca42953ee04a9e65d8c02414d7d"},+ {file = "coverage-7.16.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:5dca0bb66b4c3d624ba047887bf70270030c150692d543cb501293dc38a9f4b5"},+ {file = "coverage-7.16.2-cp311-cp311-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:af2a2a8c7c74de0559e0c368d94c8def9e16c58faaee33a0bf081057c4227e3b"},+ {file = "coverage-7.16.2-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:db5f8394e17f877a625b257f2ba0ce8e728a499c2c1579ad66220272cd3df510"},+ {file = "coverage-7.16.2-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5b3146d2317c75f70df2509066d979dadd941f7021cdf9b5db4bcd8568258e25"},+ {file = "coverage-7.16.2-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:9e1d0ced76318bab499693ff25f64faa343415187cb2e4d7befdfdd391a1cf6a"},+ {file = "coverage-7.16.2-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:af98ad5ed9d6daaca956201e00bb429a7eb2b080426686f70a20353e0f9839f5"},+ {file = "coverage-7.16.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:1d56e4d21c56d2046447733f8b118409597db48c01efe898ee9ac24e858ec2d6"},+ {file = "coverage-7.16.2-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:1d5d0e3b660506fb84f995814e3118a21efdc0c8eb80127da1be627d90093c17"},+ {file = "coverage-7.16.2-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:17228fbca0f22976f797be94e975dcd237799c657d49551c7de1e0654d1202e9"},+ {file = "coverage-7.16.2-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:bc0b0ac781d489304b741269857f1f8338b7a26b1b89c06c0344658001ec0035"},+ {file = "coverage-7.16.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:bf1bd822ec4e387ed245bed0d71151582cf7be9e5309bc4145eefe36083d5878"},+ {file = "coverage-7.16.2-cp311-cp311-win32.whl", hash = "sha256:7ed238d227e23cc300c3d464babdaf9f6ddc740aa1b15a77ae96136e6a7c4516"},+ {file = "coverage-7.16.2-cp311-cp311-win_amd64.whl", hash = "sha256:a90700f743e29aa3d75a6ff5f01953176a889c00e526194bc4d281731b88d99d"},+ {file = "coverage-7.16.2-cp311-cp311-win_arm64.whl", hash = "sha256:a336eec40e3520d369b8a6cdabb4f596e69a8b42927ca074aa1452fed943238a"},+ {file = "coverage-7.16.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:218d742afca2b5ad5ca759e93eddedfbcc6eadf8322f080dcefc40b7bd4e2d48"},+ {file = "coverage-7.16.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:a9a638be322a8d76a41cdb17781c7f82aaee6a66493d8ffb7e2c09ee22423d99"},+ {file = "coverage-7.16.2-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:724bd0f1e81856b35e59fc98cf7b4e544a3cb662e4e0864dca73d4326ee9d808"},+ {file = "coverage-7.16.2-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:5375ebd99038021b35e99dc88255022912c06565d316212f4a576e4b08d30f5d"},+ {file = "coverage-7.16.2-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7a076277ca9f5750cc230f0f578ebd2620cec60255b25707361699fef6fb465c"},+ {file = "coverage-7.16.2-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:58d4a54c6ea672afef66d49be922a2c69826c5ae1a42a9cd94f0c9c2bacdf800"},+ {file = "coverage-7.16.2-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0dcbcfcc059117284c603ff8cb61a65872512882f84a8cf0339241f7f7c2f148"},+ {file = "coverage-7.16.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:afdf43b72ef3876c1fe66423b91466e37877c9e81e8cec70542b7e8525b9d1b7"},+ {file = "coverage-7.16.2-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:9acc7f7ec4a1b5f89bd929fde5b8a714f6fafdc6cc18725413d510aa082b47ad"},+ {file = "coverage-7.16.2-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:80d3f7b48d43ee8fc5e8707a8adb43d743a5a1a85256c25a24f9d6d0e2238fa6"},+ {file = "coverage-7.16.2-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:126d1af8804d7224421fe991ff65d3ce649081560df7a98b1a5ffff07f9923bd"},+ {file = "coverage-7.16.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:c19cd6d025c1673f22afcd22c7df8a662d779e05d8e3fa6820c22afb895b0206"},+ {file = "coverage-7.16.2-cp312-cp312-win32.whl", hash = "sha256:152877cdc8a07264882cfcd503ba56a3ef6cba56a70e8c70f6eb8ffd7384789a"},+ {file = "coverage-7.16.2-cp312-cp312-win_amd64.whl", hash = "sha256:e6c52d3307824ff93b39efd99e4185d557db40bd841452abfb32e5d9151ca162"},+ {file = "coverage-7.16.2-cp312-cp312-win_arm64.whl", hash = "sha256:a678c0b6b22086ec2427359d22e37445d4a792f5fdbbc744112c7dade65cad02"},+ {file = "coverage-7.16.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:1a37c6e478cf687e1aa30a593d19c92c02fad9d122b51ab73f51b8dc7a0c0fc9"},+ {file = "coverage-7.16.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:0993d0e90858c03943d3cb152e068a20dd4707924deec84dd2230261baae3b1b"},+ {file = "coverage-7.16.2-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:bb2fc905bbf4e6b7f40806ea79e31515abf6349594cdf0adf27c4215f0463204"},+ {file = "coverage-7.16.2-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:4358b9c8c0125b460407f3017c6cce8156e904b32772c5630d27112f52bdbfe5"},+ {file = "coverage-7.16.2-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1f15254427c9b33eedac4f198eaf9e356eb4f6214551afb43da6194a2c088ad7"},+ {file = "coverage-7.16.2-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:9a75a4704ff640e46170042eec1f984385a121227c505d5a16ad8e495f452541"},+ {file = "coverage-7.16.2-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:14253fc7bb15749b849795a06f5d3b6d8bc3fb8a4b5ddc341faf7a89dce205fc"},+ {file = "coverage-7.16.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:921415102a90637fcc2e3f169f61dad7699ecf690e8639fc21b813acbedc0967"},+ {file = "coverage-7.16.2-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:cce2bc991293f15cc4084ca116827b5900c5f34e1a54dfe83f10ab5c43162eb7"},+ {file = "coverage-7.16.2-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:e1fa594c887365b69745f25a416806e61085dd07b94c9eae68a6e20730629b23"},+ {file = "coverage-7.16.2-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:11e597173af1dc33d5f8a7332ada544199269a223af1ee1770ddd5e245ad0fe8"},+ {file = "coverage-7.16.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:3e7f99698ba3a7d13988bdd984b7ebf13af4dbe2166dc8502eef90d77603b0a4"},+ {file = "coverage-7.16.2-cp313-cp313-win32.whl", hash = "sha256:f80bd9f9633eafc73d0a913ba2645c96ba58bba1befc30590f7c0fbfde59d865"},+ {file = "coverage-7.16.2-cp313-cp313-win_amd64.whl", hash = "sha256:8be099e979fc42559328a21828281b4578304191ae46ed4e80a407048a82eee6"},+ {file = "coverage-7.16.2-cp313-cp313-win_arm64.whl", hash = "sha256:28ff850182a67d117990fa2ce5ea1032836d8c9630dae867e8bdd3bff4533b79"},+ {file = "coverage-7.16.2-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:4ee546b9e4872ffa194bf07ac87bfa1202ebb824d0795dc1ef22f175545ca90a"},+ {file = "coverage-7.16.2-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:a2fac6895eb299a2e52d7bbb8fb3903502b9da8d3f5309ceb16ec40c646b58ee"},+ {file = "coverage-7.16.2-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:57ff3783f99d75a1e81dd56a9737eb5665e6736a5d93258ba596b6dcad8fd05b"},+ {file = "coverage-7.16.2-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:35f37886699cb9abd29958247d718628d5bc6f39e623dff66a09e546c42a7e03"},+ {file = "coverage-7.16.2-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0fd7a86fdda7cb6d616d178654bd0ad6bc0f3f33c2e478aa598500a1a9e34eda"},+ {file = "coverage-7.16.2-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ac0f3b379c94acc2f7dce5f5f0b24d44fa1cc6a509717ef83dfee07450c2117c"},+ {file = "coverage-7.16.2-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:7d0732c83746bc24123c581a85d9dd96b70ddb538c9076020aa1a041790361e9"},+ {file = "coverage-7.16.2-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7b451c68218c150f616bc9649783ec8de76a59792c759b43aa0c9c0466a465e4"},+ {file = "coverage-7.16.2-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:a56ac4fa5a75c7e182e8f62600cfb4aff43c5ed7356a034f3557659c3bec1d90"},+ {file = "coverage-7.16.2-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:4cc4f73aa3fabc36e32046d6cd2971405948d8a903636508a3d3b2f9128b3a95"},+ {file = "coverage-7.16.2-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:723dcdab91357159b722935b500ee8abc0a66c8c432e1e9fabf4cc7598952de8"},+ {file = "coverage-7.16.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5397e21a90dde0e9c6896b77ded8f0be26b66f8b22b33aed41f6043ed95d55e6"},+ {file = "coverage-7.16.2-cp314-cp314-win32.whl", hash = "sha256:848893e1d361448c113dc2f0913503522a6f7be231d0e38333d2a22d9698a011"},+ {file = "coverage-7.16.2-cp314-cp314-win_amd64.whl", hash = "sha256:5a27b731c171e43dc8b5f32b76a5051dde2ec9b9366c87028f08a7088ebc2c7b"},+ {file = "coverage-7.16.2-cp314-cp314-win_arm64.whl", hash = "sha256:1c569a9fd25505f1cd6bea90588818f90373ce90e2632e2cacf19ddbd6e14fdb"},+ {file = "coverage-7.16.2-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:d93db87adb6b1c1b408dce4763314b55d76a9f589e96783a84ac9e7689e48bdf"},+ {file = "coverage-7.16.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:aa62c85046473959c13ba9edca9dc90a77d5c1095b1ba313556314d77fe5b036"},+ {file = "coverage-7.16.2-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:db76506aa5416081f3e8974ae0f7965c58ada0bb0ef7339ac86099588dbb20d3"},+ {file = "coverage-7.16.2-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:a0f2285329dac10ab08f79cb11f5692c497018e6c7c511f95e6fd63a70b8f831"},+ {file = "coverage-7.16.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:382d3346d56b0eec1b793d53a4c88799c8053f516aa3a8d7c44315696954bacf"},+ {file = "coverage-7.16.2-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:648352b94507179d82637292e7ae8802508d95f78e2f00a705a50b6c48011681"},+ {file = "coverage-7.16.2-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:fb2bde05838fffae1a1bf75e5d411a6cac3e4e9bb97e6640fed8cd47888b33f0"},+ {file = "coverage-7.16.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:6a75180829efb8ae62b4aded25be6ddca1c888d138d2d82e21d93bfbd88f41cb"},+ {file = "coverage-7.16.2-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:99704f73721e23859112072d522076e11c31744fc96b5652e5dd2018aa4359f7"},+ {file = "coverage-7.16.2-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:29309ccc86b7f33df7db12813c299f215bbbc470ed6292d0bedd63ffae1ebf64"},+ {file = "coverage-7.16.2-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:30c1b65d529e46569899fadca59e4a87c1faf2886923f1307ba61e654d4f3c20"},+ {file = "coverage-7.16.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:dcf4bc2aab4e16b1c4c0c2005918f23a7dd5d7821ddae82caed9e3342dc2fcce"},+ {file = "coverage-7.16.2-cp314-cp314t-win32.whl", hash = "sha256:a9cd3de0a5bfe7b0e21ee10e1a14e3d61bf52efc88217ab1d95d6ace6970bd46"},+ {file = "coverage-7.16.2-cp314-cp314t-win_amd64.whl", hash = "sha256:611a44e5229a59d7483ce830160e1a0e85f700562c7a5651c7c63fb8f4eb528c"},+ {file = "coverage-7.16.2-cp314-cp314t-win_arm64.whl", hash = "sha256:22957cef43ce038641de78ba995de7568d2d6a37c6ddbf7fa0fd7d1ae2344d91"},+ {file = "coverage-7.16.2-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:414c26dfdb96aac2d570a54e03008f001e32eb2d413705365503648c6bd361d8"},+ {file = "coverage-7.16.2-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:00d3eb96e9988c45f50cccd1f1496571ac5c1f91386ac02c4d55516eeda19a24"},+ {file = "coverage-7.16.2-cp315-cp315-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:4dbbd1155ca46e6e0b6b89d204428c56ef6a459af21333f365d135a2820e5a09"},+ {file = "coverage-7.16.2-cp315-cp315-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:8fc15cc8d0d06e873c00ef18e1372d605f9aaf3de27d8c24e50782e75bc8b843"},+ {file = "coverage-7.16.2-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9c6afdd69218202bc1758c9a14b86b8cf1084f37ed2ca143e567a103772b16d1"},+ {file = "coverage-7.16.2-cp315-cp315-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:aba5c63b7afdc749cc9eae943d5b868cba2b261a176378fa1c5a30bc8bc89982"},+ {file = "coverage-7.16.2-cp315-cp315-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:9174f0af24e5eff248b9dbfe76ec5275a3d19d37edbc2810543f12cf97347a34"},+ {file = "coverage-7.16.2-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:80e9fdb4c3d926b6ba721d4bf7435bdb869c3527ae7803290361d0ab73db13b6"},+ {file = "coverage-7.16.2-cp315-cp315-musllinux_1_2_i686.whl", hash = "sha256:7b3bce4a0d05401d70b7d0d5ca783e686bc9d30e81dbd7d980d532609bf809e4"},+ {file = "coverage-7.16.2-cp315-cp315-musllinux_1_2_ppc64le.whl", hash = "sha256:44f21e407b278efdfc1ee5e481e00518bd1d500310a30a5fbf2bcbedfef4aaf0"},+ {file = "coverage-7.16.2-cp315-cp315-musllinux_1_2_riscv64.whl", hash = "sha256:59c3926585e1cd1f2190f4b2ac9014de1bbeaf0d5d0587b0dc6b0aa90d17896a"},+ {file = "coverage-7.16.2-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:066429634299e14dd2d511e1e85f8f9cecc500781f6b41907c0dd6f1baea7e63"},+ {file = "coverage-7.16.2-cp315-cp315-win32.whl", hash = "sha256:893ea9cf86cb8d2546812ac93d973aaf2ee1fb45110a873b014214fd23e3725e"},+ {file = "coverage-7.16.2-cp315-cp315-win_amd64.whl", hash = "sha256:01c6908bc613b420c26c818fe948e1b97dfd041a53c98b01c63bd8321f5c9aae"},+ {file = "coverage-7.16.2-cp315-cp315-win_arm64.whl", hash = "sha256:967d72c835d7a8cf0af99ec813a2d06e3db6df706402f1fe85b31b437645f495"},+ {file = "coverage-7.16.2-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:98d9c97f51b334b0adce7b964442a9af33c1a00c6ac856984cc5dc8d18f81c75"},+ {file = "coverage-7.16.2-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:3e861f1071dcc2fec1e88bef0920f6b1eaa66a143555b4f8ab79ba2b0f30ef55"},+ {file = "coverage-7.16.2-cp315-cp315t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:fb9d92ecfe2d5b494367c67f7446f8b75b68d8d0c8cf3bc3e6997478be25d9e2"},+ {file = "coverage-7.16.2-cp315-cp315t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:eb57acff4a74246ae513c142d4b36e18c389c3aed8661914a53f7cd0071031b2"},+ {file = "coverage-7.16.2-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:444889f7f66b74e4455c0a97e0e166dd41177f1dca8c0239a47cff25e05ba7e1"},+ {file = "coverage-7.16.2-cp315-cp315t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a740ea6f083c6db7b926534d159508f80ba275ab35e722522de0d18d0f56e55f"},+ {file = "coverage-7.16.2-cp315-cp315t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:8e209591f7c41ae4a9171335cf6156afda0b21de73b02f73f5aa95b2d5fbb08d"},+ {file = "coverage-7.16.2-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:396bb16e04ce04efbb3df91456ae4e3da918e69ecdf67fb711b0a0fdf35ccce0"},+ {file = "coverage-7.16.2-cp315-cp315t-musllinux_1_2_i686.whl", hash = "sha256:9cdf19874e0d247f32f03609200370343c3c7aa260b191d8c2bb251d36198283"},+ {file = "coverage-7.16.2-cp315-cp315t-musllinux_1_2_ppc64le.whl", hash = "sha256:fd3d72233eb8b48acc94fa57d44e2d32ce8e7abed02882ccb6d855ccc4ed33ec"},+ {file = "coverage-7.16.2-cp315-cp315t-musllinux_1_2_riscv64.whl", hash = "sha256:bb4ffe96aa663cee727659db5a2afeb38c95f8677b747d447b90d6d4874ea2c5"},+ {file = "coverage-7.16.2-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:dba2edfb054f6d4a08df9d1637c39a5aa3865bca6617c13c86be21e45658a59c"},+ {file = "coverage-7.16.2-cp315-cp315t-win32.whl", hash = "sha256:251aed777c47c77aba047096d4542889db089227655711dfc2b9c54ef0e15e35"},+ {file = "coverage-7.16.2-cp315-cp315t-win_amd64.whl", hash = "sha256:2aca0bdfa9e91621d5b09d815357bf63def4fc0e9cb66da67bf2cf93f3b1a6f5"},+ {file = "coverage-7.16.2-cp315-cp315t-win_arm64.whl", hash = "sha256:b88841e654f09732804809e435b3e005a929ffd9998b872b7b213957b8759cb8"},+ {file = "coverage-7.16.2-py3-none-any.whl", hash = "sha256:11d28e9123a9156cb405d8d27b44256c9a58fb5decc2073a8f17862057e3aa0f"},+ {file = "coverage-7.16.2.tar.gz", hash = "sha256:ca64d9f1f384f151b9511bec01126072acd2f313439f8ed015a22d8790aab6fa"},+]++[package.extras]+toml = ["tomli ; python_full_version <= \"3.11.0a6\""]+[[package]]name = "cryptography"version = "50.0.1"@@ -1545,6 +1680,27 @@ typing-extensions = {version = ">=4.12", markers = "python_version < \"3.13\""}docs = ["sphinx (>=5.3)", "sphinx-rtd-theme (>=1)", "sphinx-tabs (>=3.5)"]testing = ["coverage (>=6.2)", "hypothesis (>=5.7.1)"]+[[package]]+name = "pytest-cov"+version = "7.1.0"+description = "Pytest plugin for measuring coverage."+optional = true+python-versions = ">=3.9"+groups = ["main"]+markers = "extra == \"dev\""+files = [+ {file = "pytest_cov-7.1.0-py3-none-any.whl", hash = "sha256:a0461110b7865f9a271aa1b51e516c9a95de9d696734a2f71e3e78f46e1d4678"},+ {file = "pytest_cov-7.1.0.tar.gz", hash = "sha256:30674f2b5f6351aa09702a9c8c364f6a01c27aae0c1366ae8016160d1efc56b2"},+]++[package.dependencies]+coverage = {version = ">=7.10.6", extras = ["toml"]}+pluggy = ">=1.2"+pytest = ">=7"++[package.extras]+testing = ["process-tests", "pytest-xdist", "virtualenv"]+[[package]]name = "python-dotenv"version = "1.2.3"@@ -2235,9 +2391,9 @@ files = [dev = ["pytest", "setuptools"][extras]-dev = ["httpx", "pytest", "pytest-asyncio"]+dev = ["httpx", "pytest", "pytest-asyncio", "pytest-cov"][metadata]lock-version = "2.1"python-versions = ">=3.11"-content-hash = "f464c5f0bf6a76c1d54c0e57f2f4a27af6d80c58e4ba957eefdc102f6669a6df"+content-hash = "623cc5340fcc23958107d8bd99547d41ce54d75f0a9219379def31d9b0b75e97"diff --git a/services/honeytokens/pyproject.toml b/services/honeytokens/pyproject.tomlindex 824627761..3f34ada87 100644--- a/services/honeytokens/pyproject.toml+++ b/services/honeytokens/pyproject.toml@@ -26,7 +26,18 @@ dependencies = [][project.optional-dependencies]-dev = ["pytest", "pytest-asyncio", "httpx>=0.27.0"]+dev = [+ "pytest",+ "pytest-asyncio",+ "httpx>=0.27.0",+ # CI runs this suite with `--cov-config=pyproject.toml --cov=app`+ # against the `fail_under` below, so the plugin that enforces it is+ # this service's own dependency. It was reaching the environment+ # from `services/fusion`, which happened to share the interpreter;+ # installing each service from its own lock made the borrowing+ # visible as `unrecognized arguments: --cov`.+ "pytest-cov>=5,<8",+]# Phase 2.2 — coverage floor for CI gate.diff --git a/services/osquery-tls/pyproject.toml b/services/osquery-tls/pyproject.tomlindex 538b04d3b..f657b5da4 100644--- a/services/osquery-tls/pyproject.toml+++ b/services/osquery-tls/pyproject.toml@@ -88,7 +88,21 @@ branch = true# would drop coverage well below 60%) without forcing a low-value# coverage-padding sprint. Raise this to 70% once db/auth get their# own dedicated test pass.-fail_under = 60+#+# 60 -> 57, because 60 was measured against software this image does not+# ship. CI installed SQLAlchemy from the declared range and resolved 2.1.1;+# `poetry.lock` pins 2.0.54, so every published `aisoc-osquery-tls` runs+# 2.0.54 and the figure describing it was taken on 2.1.1. Installing the lock+# instead re-measures it honestly: 59.98% on the CI runner, and 57.93% on+# arm64, where a `platform_machine`-gated dependency is absent. The floor+# sits below both, following this file's own convention of the measurement+# minus 2-3pp for exactly that variance — a floor only the CI architecture+# can clear is a floor that fails a contributor for owning a different+# laptop. Lowering it is not a concession: the previous number was never a+# measurement of what runs in production. Six services lock the 2.0 line+# while three lock 2.1; that divergence is real and separate, and bumping an+# ORM minor is not something to do inside a CI-parity change.+fail_under = 57show_missing = trueskip_covered = falseexclude_lines = [diff --git a/services/purple-team/poetry.lock b/services/purple-team/poetry.lockindex ec88fe577..19e187ba0 100644--- a/services/purple-team/poetry.lock+++ b/services/purple-team/poetry.lock@@ -396,6 +396,141 @@ files = [{file = "colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44"},]+[[package]]+name = "coverage"+version = "7.16.2"+description = "Code coverage measurement for Python"+optional = true+python-versions = ">=3.10"+groups = ["main"]+markers = "extra == \"dev\""+files = [+ {file = "coverage-7.16.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:23219888477edd736b6fcaec1272d47d93b926e999641ffea7e53a1738e70b2b"},+ {file = "coverage-7.16.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:40c0f00899fe6181ae7f434ceb200e51f5ee4b8ed10e3b5f0b605f0cae15da87"},+ {file = "coverage-7.16.2-cp310-cp310-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:a4624f80732f6b427ac58f1f59c577a0994a12e8174b5af6a027b4b58795d4c3"},+ {file = "coverage-7.16.2-cp310-cp310-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:191803c4996b499fcd78c2ad5e5f767dcc53cb4dc6de6d6a741b443a1821ef02"},+ {file = "coverage-7.16.2-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9fd670ac43b709c575aefc25bf52d8a598a3bc5017bddfd0a179152ab06a2deb"},+ {file = "coverage-7.16.2-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:705e5af11d34647efdc170c7840b6857c81cf74be96419a553f237e68e62cb72"},+ {file = "coverage-7.16.2-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:8afd9bf35cc6a1f22eb3634808fa8e0b91902459c5721ef2e4461dfe771d7f08"},+ {file = "coverage-7.16.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:3f43bac1856ba269b905302778d4df433d6006489a192174ad77ac528e395032"},+ {file = "coverage-7.16.2-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:f8475460aa33ee28ac896ab1156d0bb3b6c639f7f8383c2677d3359eb35f8205"},+ {file = "coverage-7.16.2-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:d6276d78f6fca7d0ac066d5da4165c5acd07829e8305c2cb900b738fb3a75a72"},+ {file = "coverage-7.16.2-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:736fde09ea39646d11f8e3b76bd3425c075aa4dd45f24891970bb77c14ff20f5"},+ {file = "coverage-7.16.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:c85d54e7e8a2ca932fe8399301af9b8d5907ea2a455ffaff6e7d1208db83b943"},+ {file = "coverage-7.16.2-cp310-cp310-win32.whl", hash = "sha256:5139009b5efd2194fc168ee9362f0e191ba612ef5d29242f9269c22f9b8f80c7"},+ {file = "coverage-7.16.2-cp310-cp310-win_amd64.whl", hash = "sha256:c3305c38a2fa21a4254f2ace7dd9ef5fc569c9a558b66e7017650b3d637fb95e"},+ {file = "coverage-7.16.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:732d950e51f3ba4fb6209c73250f3e8924fefca42953ee04a9e65d8c02414d7d"},+ {file = "coverage-7.16.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:5dca0bb66b4c3d624ba047887bf70270030c150692d543cb501293dc38a9f4b5"},+ {file = "coverage-7.16.2-cp311-cp311-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:af2a2a8c7c74de0559e0c368d94c8def9e16c58faaee33a0bf081057c4227e3b"},+ {file = "coverage-7.16.2-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:db5f8394e17f877a625b257f2ba0ce8e728a499c2c1579ad66220272cd3df510"},+ {file = "coverage-7.16.2-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5b3146d2317c75f70df2509066d979dadd941f7021cdf9b5db4bcd8568258e25"},+ {file = "coverage-7.16.2-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:9e1d0ced76318bab499693ff25f64faa343415187cb2e4d7befdfdd391a1cf6a"},+ {file = "coverage-7.16.2-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:af98ad5ed9d6daaca956201e00bb429a7eb2b080426686f70a20353e0f9839f5"},+ {file = "coverage-7.16.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:1d56e4d21c56d2046447733f8b118409597db48c01efe898ee9ac24e858ec2d6"},+ {file = "coverage-7.16.2-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:1d5d0e3b660506fb84f995814e3118a21efdc0c8eb80127da1be627d90093c17"},+ {file = "coverage-7.16.2-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:17228fbca0f22976f797be94e975dcd237799c657d49551c7de1e0654d1202e9"},+ {file = "coverage-7.16.2-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:bc0b0ac781d489304b741269857f1f8338b7a26b1b89c06c0344658001ec0035"},+ {file = "coverage-7.16.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:bf1bd822ec4e387ed245bed0d71151582cf7be9e5309bc4145eefe36083d5878"},+ {file = "coverage-7.16.2-cp311-cp311-win32.whl", hash = "sha256:7ed238d227e23cc300c3d464babdaf9f6ddc740aa1b15a77ae96136e6a7c4516"},+ {file = "coverage-7.16.2-cp311-cp311-win_amd64.whl", hash = "sha256:a90700f743e29aa3d75a6ff5f01953176a889c00e526194bc4d281731b88d99d"},+ {file = "coverage-7.16.2-cp311-cp311-win_arm64.whl", hash = "sha256:a336eec40e3520d369b8a6cdabb4f596e69a8b42927ca074aa1452fed943238a"},+ {file = "coverage-7.16.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:218d742afca2b5ad5ca759e93eddedfbcc6eadf8322f080dcefc40b7bd4e2d48"},+ {file = "coverage-7.16.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:a9a638be322a8d76a41cdb17781c7f82aaee6a66493d8ffb7e2c09ee22423d99"},+ {file = "coverage-7.16.2-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:724bd0f1e81856b35e59fc98cf7b4e544a3cb662e4e0864dca73d4326ee9d808"},+ {file = "coverage-7.16.2-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:5375ebd99038021b35e99dc88255022912c06565d316212f4a576e4b08d30f5d"},+ {file = "coverage-7.16.2-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7a076277ca9f5750cc230f0f578ebd2620cec60255b25707361699fef6fb465c"},+ {file = "coverage-7.16.2-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:58d4a54c6ea672afef66d49be922a2c69826c5ae1a42a9cd94f0c9c2bacdf800"},+ {file = "coverage-7.16.2-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0dcbcfcc059117284c603ff8cb61a65872512882f84a8cf0339241f7f7c2f148"},+ {file = "coverage-7.16.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:afdf43b72ef3876c1fe66423b91466e37877c9e81e8cec70542b7e8525b9d1b7"},+ {file = "coverage-7.16.2-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:9acc7f7ec4a1b5f89bd929fde5b8a714f6fafdc6cc18725413d510aa082b47ad"},+ {file = "coverage-7.16.2-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:80d3f7b48d43ee8fc5e8707a8adb43d743a5a1a85256c25a24f9d6d0e2238fa6"},+ {file = "coverage-7.16.2-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:126d1af8804d7224421fe991ff65d3ce649081560df7a98b1a5ffff07f9923bd"},+ {file = "coverage-7.16.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:c19cd6d025c1673f22afcd22c7df8a662d779e05d8e3fa6820c22afb895b0206"},+ {file = "coverage-7.16.2-cp312-cp312-win32.whl", hash = "sha256:152877cdc8a07264882cfcd503ba56a3ef6cba56a70e8c70f6eb8ffd7384789a"},+ {file = "coverage-7.16.2-cp312-cp312-win_amd64.whl", hash = "sha256:e6c52d3307824ff93b39efd99e4185d557db40bd841452abfb32e5d9151ca162"},+ {file = "coverage-7.16.2-cp312-cp312-win_arm64.whl", hash = "sha256:a678c0b6b22086ec2427359d22e37445d4a792f5fdbbc744112c7dade65cad02"},+ {file = "coverage-7.16.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:1a37c6e478cf687e1aa30a593d19c92c02fad9d122b51ab73f51b8dc7a0c0fc9"},+ {file = "coverage-7.16.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:0993d0e90858c03943d3cb152e068a20dd4707924deec84dd2230261baae3b1b"},+ {file = "coverage-7.16.2-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:bb2fc905bbf4e6b7f40806ea79e31515abf6349594cdf0adf27c4215f0463204"},+ {file = "coverage-7.16.2-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:4358b9c8c0125b460407f3017c6cce8156e904b32772c5630d27112f52bdbfe5"},+ {file = "coverage-7.16.2-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1f15254427c9b33eedac4f198eaf9e356eb4f6214551afb43da6194a2c088ad7"},+ {file = "coverage-7.16.2-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:9a75a4704ff640e46170042eec1f984385a121227c505d5a16ad8e495f452541"},+ {file = "coverage-7.16.2-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:14253fc7bb15749b849795a06f5d3b6d8bc3fb8a4b5ddc341faf7a89dce205fc"},+ {file = "coverage-7.16.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:921415102a90637fcc2e3f169f61dad7699ecf690e8639fc21b813acbedc0967"},+ {file = "coverage-7.16.2-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:cce2bc991293f15cc4084ca116827b5900c5f34e1a54dfe83f10ab5c43162eb7"},+ {file = "coverage-7.16.2-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:e1fa594c887365b69745f25a416806e61085dd07b94c9eae68a6e20730629b23"},+ {file = "coverage-7.16.2-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:11e597173af1dc33d5f8a7332ada544199269a223af1ee1770ddd5e245ad0fe8"},+ {file = "coverage-7.16.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:3e7f99698ba3a7d13988bdd984b7ebf13af4dbe2166dc8502eef90d77603b0a4"},+ {file = "coverage-7.16.2-cp313-cp313-win32.whl", hash = "sha256:f80bd9f9633eafc73d0a913ba2645c96ba58bba1befc30590f7c0fbfde59d865"},+ {file = "coverage-7.16.2-cp313-cp313-win_amd64.whl", hash = "sha256:8be099e979fc42559328a21828281b4578304191ae46ed4e80a407048a82eee6"},+ {file = "coverage-7.16.2-cp313-cp313-win_arm64.whl", hash = "sha256:28ff850182a67d117990fa2ce5ea1032836d8c9630dae867e8bdd3bff4533b79"},+ {file = "coverage-7.16.2-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:4ee546b9e4872ffa194bf07ac87bfa1202ebb824d0795dc1ef22f175545ca90a"},+ {file = "coverage-7.16.2-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:a2fac6895eb299a2e52d7bbb8fb3903502b9da8d3f5309ceb16ec40c646b58ee"},+ {file = "coverage-7.16.2-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:57ff3783f99d75a1e81dd56a9737eb5665e6736a5d93258ba596b6dcad8fd05b"},+ {file = "coverage-7.16.2-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:35f37886699cb9abd29958247d718628d5bc6f39e623dff66a09e546c42a7e03"},+ {file = "coverage-7.16.2-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0fd7a86fdda7cb6d616d178654bd0ad6bc0f3f33c2e478aa598500a1a9e34eda"},+ {file = "coverage-7.16.2-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ac0f3b379c94acc2f7dce5f5f0b24d44fa1cc6a509717ef83dfee07450c2117c"},+ {file = "coverage-7.16.2-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:7d0732c83746bc24123c581a85d9dd96b70ddb538c9076020aa1a041790361e9"},+ {file = "coverage-7.16.2-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7b451c68218c150f616bc9649783ec8de76a59792c759b43aa0c9c0466a465e4"},+ {file = "coverage-7.16.2-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:a56ac4fa5a75c7e182e8f62600cfb4aff43c5ed7356a034f3557659c3bec1d90"},+ {file = "coverage-7.16.2-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:4cc4f73aa3fabc36e32046d6cd2971405948d8a903636508a3d3b2f9128b3a95"},+ {file = "coverage-7.16.2-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:723dcdab91357159b722935b500ee8abc0a66c8c432e1e9fabf4cc7598952de8"},+ {file = "coverage-7.16.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5397e21a90dde0e9c6896b77ded8f0be26b66f8b22b33aed41f6043ed95d55e6"},+ {file = "coverage-7.16.2-cp314-cp314-win32.whl", hash = "sha256:848893e1d361448c113dc2f0913503522a6f7be231d0e38333d2a22d9698a011"},+ {file = "coverage-7.16.2-cp314-cp314-win_amd64.whl", hash = "sha256:5a27b731c171e43dc8b5f32b76a5051dde2ec9b9366c87028f08a7088ebc2c7b"},+ {file = "coverage-7.16.2-cp314-cp314-win_arm64.whl", hash = "sha256:1c569a9fd25505f1cd6bea90588818f90373ce90e2632e2cacf19ddbd6e14fdb"},+ {file = "coverage-7.16.2-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:d93db87adb6b1c1b408dce4763314b55d76a9f589e96783a84ac9e7689e48bdf"},+ {file = "coverage-7.16.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:aa62c85046473959c13ba9edca9dc90a77d5c1095b1ba313556314d77fe5b036"},+ {file = "coverage-7.16.2-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:db76506aa5416081f3e8974ae0f7965c58ada0bb0ef7339ac86099588dbb20d3"},+ {file = "coverage-7.16.2-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:a0f2285329dac10ab08f79cb11f5692c497018e6c7c511f95e6fd63a70b8f831"},+ {file = "coverage-7.16.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:382d3346d56b0eec1b793d53a4c88799c8053f516aa3a8d7c44315696954bacf"},+ {file = "coverage-7.16.2-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:648352b94507179d82637292e7ae8802508d95f78e2f00a705a50b6c48011681"},+ {file = "coverage-7.16.2-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:fb2bde05838fffae1a1bf75e5d411a6cac3e4e9bb97e6640fed8cd47888b33f0"},+ {file = "coverage-7.16.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:6a75180829efb8ae62b4aded25be6ddca1c888d138d2d82e21d93bfbd88f41cb"},+ {file = "coverage-7.16.2-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:99704f73721e23859112072d522076e11c31744fc96b5652e5dd2018aa4359f7"},+ {file = "coverage-7.16.2-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:29309ccc86b7f33df7db12813c299f215bbbc470ed6292d0bedd63ffae1ebf64"},+ {file = "coverage-7.16.2-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:30c1b65d529e46569899fadca59e4a87c1faf2886923f1307ba61e654d4f3c20"},+ {file = "coverage-7.16.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:dcf4bc2aab4e16b1c4c0c2005918f23a7dd5d7821ddae82caed9e3342dc2fcce"},+ {file = "coverage-7.16.2-cp314-cp314t-win32.whl", hash = "sha256:a9cd3de0a5bfe7b0e21ee10e1a14e3d61bf52efc88217ab1d95d6ace6970bd46"},+ {file = "coverage-7.16.2-cp314-cp314t-win_amd64.whl", hash = "sha256:611a44e5229a59d7483ce830160e1a0e85f700562c7a5651c7c63fb8f4eb528c"},+ {file = "coverage-7.16.2-cp314-cp314t-win_arm64.whl", hash = "sha256:22957cef43ce038641de78ba995de7568d2d6a37c6ddbf7fa0fd7d1ae2344d91"},+ {file = "coverage-7.16.2-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:414c26dfdb96aac2d570a54e03008f001e32eb2d413705365503648c6bd361d8"},+ {file = "coverage-7.16.2-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:00d3eb96e9988c45f50cccd1f1496571ac5c1f91386ac02c4d55516eeda19a24"},+ {file = "coverage-7.16.2-cp315-cp315-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:4dbbd1155ca46e6e0b6b89d204428c56ef6a459af21333f365d135a2820e5a09"},+ {file = "coverage-7.16.2-cp315-cp315-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:8fc15cc8d0d06e873c00ef18e1372d605f9aaf3de27d8c24e50782e75bc8b843"},+ {file = "coverage-7.16.2-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9c6afdd69218202bc1758c9a14b86b8cf1084f37ed2ca143e567a103772b16d1"},+ {file = "coverage-7.16.2-cp315-cp315-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:aba5c63b7afdc749cc9eae943d5b868cba2b261a176378fa1c5a30bc8bc89982"},+ {file = "coverage-7.16.2-cp315-cp315-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:9174f0af24e5eff248b9dbfe76ec5275a3d19d37edbc2810543f12cf97347a34"},+ {file = "coverage-7.16.2-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:80e9fdb4c3d926b6ba721d4bf7435bdb869c3527ae7803290361d0ab73db13b6"},+ {file = "coverage-7.16.2-cp315-cp315-musllinux_1_2_i686.whl", hash = "sha256:7b3bce4a0d05401d70b7d0d5ca783e686bc9d30e81dbd7d980d532609bf809e4"},+ {file = "coverage-7.16.2-cp315-cp315-musllinux_1_2_ppc64le.whl", hash = "sha256:44f21e407b278efdfc1ee5e481e00518bd1d500310a30a5fbf2bcbedfef4aaf0"},+ {file = "coverage-7.16.2-cp315-cp315-musllinux_1_2_riscv64.whl", hash = "sha256:59c3926585e1cd1f2190f4b2ac9014de1bbeaf0d5d0587b0dc6b0aa90d17896a"},+ {file = "coverage-7.16.2-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:066429634299e14dd2d511e1e85f8f9cecc500781f6b41907c0dd6f1baea7e63"},+ {file = "coverage-7.16.2-cp315-cp315-win32.whl", hash = "sha256:893ea9cf86cb8d2546812ac93d973aaf2ee1fb45110a873b014214fd23e3725e"},+ {file = "coverage-7.16.2-cp315-cp315-win_amd64.whl", hash = "sha256:01c6908bc613b420c26c818fe948e1b97dfd041a53c98b01c63bd8321f5c9aae"},+ {file = "coverage-7.16.2-cp315-cp315-win_arm64.whl", hash = "sha256:967d72c835d7a8cf0af99ec813a2d06e3db6df706402f1fe85b31b437645f495"},+ {file = "coverage-7.16.2-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:98d9c97f51b334b0adce7b964442a9af33c1a00c6ac856984cc5dc8d18f81c75"},+ {file = "coverage-7.16.2-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:3e861f1071dcc2fec1e88bef0920f6b1eaa66a143555b4f8ab79ba2b0f30ef55"},+ {file = "coverage-7.16.2-cp315-cp315t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:fb9d92ecfe2d5b494367c67f7446f8b75b68d8d0c8cf3bc3e6997478be25d9e2"},+ {file = "coverage-7.16.2-cp315-cp315t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:eb57acff4a74246ae513c142d4b36e18c389c3aed8661914a53f7cd0071031b2"},+ {file = "coverage-7.16.2-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:444889f7f66b74e4455c0a97e0e166dd41177f1dca8c0239a47cff25e05ba7e1"},+ {file = "coverage-7.16.2-cp315-cp315t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a740ea6f083c6db7b926534d159508f80ba275ab35e722522de0d18d0f56e55f"},+ {file = "coverage-7.16.2-cp315-cp315t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:8e209591f7c41ae4a9171335cf6156afda0b21de73b02f73f5aa95b2d5fbb08d"},+ {file = "coverage-7.16.2-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:396bb16e04ce04efbb3df91456ae4e3da918e69ecdf67fb711b0a0fdf35ccce0"},+ {file = "coverage-7.16.2-cp315-cp315t-musllinux_1_2_i686.whl", hash = "sha256:9cdf19874e0d247f32f03609200370343c3c7aa260b191d8c2bb251d36198283"},+ {file = "coverage-7.16.2-cp315-cp315t-musllinux_1_2_ppc64le.whl", hash = "sha256:fd3d72233eb8b48acc94fa57d44e2d32ce8e7abed02882ccb6d855ccc4ed33ec"},+ {file = "coverage-7.16.2-cp315-cp315t-musllinux_1_2_riscv64.whl", hash = "sha256:bb4ffe96aa663cee727659db5a2afeb38c95f8677b747d447b90d6d4874ea2c5"},+ {file = "coverage-7.16.2-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:dba2edfb054f6d4a08df9d1637c39a5aa3865bca6617c13c86be21e45658a59c"},+ {file = "coverage-7.16.2-cp315-cp315t-win32.whl", hash = "sha256:251aed777c47c77aba047096d4542889db089227655711dfc2b9c54ef0e15e35"},+ {file = "coverage-7.16.2-cp315-cp315t-win_amd64.whl", hash = "sha256:2aca0bdfa9e91621d5b09d815357bf63def4fc0e9cb66da67bf2cf93f3b1a6f5"},+ {file = "coverage-7.16.2-cp315-cp315t-win_arm64.whl", hash = "sha256:b88841e654f09732804809e435b3e005a929ffd9998b872b7b213957b8759cb8"},+ {file = "coverage-7.16.2-py3-none-any.whl", hash = "sha256:11d28e9123a9156cb405d8d27b44256c9a58fb5decc2073a8f17862057e3aa0f"},+ {file = "coverage-7.16.2.tar.gz", hash = "sha256:ca64d9f1f384f151b9511bec01126072acd2f313439f8ed015a22d8790aab6fa"},+]++[package.extras]+toml = ["tomli ; python_full_version <= \"3.11.0a6\""]+[[package]]name = "fastapi"version = "0.141.1"@@ -1384,6 +1519,27 @@ typing-extensions = {version = ">=4.12", markers = "python_version < \"3.13\""}docs = ["sphinx (>=5.3)", "sphinx-rtd-theme (>=1)", "sphinx-tabs (>=3.5)"]testing = ["coverage (>=6.2)", "hypothesis (>=5.7.1)"]+[[package]]+name = "pytest-cov"+version = "7.1.0"+description = "Pytest plugin for measuring coverage."+optional = true+python-versions = ">=3.9"+groups = ["main"]+markers = "extra == \"dev\""+files = [+ {file = "pytest_cov-7.1.0-py3-none-any.whl", hash = "sha256:a0461110b7865f9a271aa1b51e516c9a95de9d696734a2f71e3e78f46e1d4678"},+ {file = "pytest_cov-7.1.0.tar.gz", hash = "sha256:30674f2b5f6351aa09702a9c8c364f6a01c27aae0c1366ae8016160d1efc56b2"},+]++[package.dependencies]+coverage = {version = ">=7.10.6", extras = ["toml"]}+pluggy = ">=1.2"+pytest = ">=7"++[package.extras]+testing = ["process-tests", "pytest-xdist", "virtualenv"]+[[package]]name = "python-dotenv"version = "1.2.3"@@ -2106,9 +2262,9 @@ files = [dev = ["pytest", "setuptools"][extras]-dev = ["httpx", "pytest", "pytest-asyncio"]+dev = ["httpx", "pytest", "pytest-asyncio", "pytest-cov"][metadata]lock-version = "2.1"python-versions = ">=3.11"-content-hash = "249638ebeae2adea98ad02c6248636f56a8c733b830fc7ed785f4efe710d481a"+content-hash = "21ea1643ee571609220bf1ee0dfa87c9aba8810850858bfdaffbbaef3ba63c36"diff --git a/services/purple-team/pyproject.toml b/services/purple-team/pyproject.tomlindex b2c808acf..21655656d 100644--- a/services/purple-team/pyproject.toml+++ b/services/purple-team/pyproject.toml@@ -27,7 +27,18 @@ dependencies = [][project.optional-dependencies]-dev = ["pytest", "pytest-asyncio", "httpx>=0.27.0"]+dev = [+ "pytest",+ "pytest-asyncio",+ "httpx>=0.27.0",+ # CI runs this suite with `--cov-config=pyproject.toml --cov=app`+ # against the `fail_under` below, so the plugin that enforces it is+ # this service's own dependency. It was reaching the environment+ # from `services/fusion`, which happened to share the interpreter;+ # installing each service from its own lock made the borrowing+ # visible as `unrecognized arguments: --cov`.+ "pytest-cov>=5,<8",+]# Phase 2.2 — coverage floor for CI gate.