validibot-shared 0.11.0__tar.gz → 0.12.0__tar.gz

{validibot_shared-0.11.0 → validibot_shared-0.12.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: validibot-shared
-Version: 0.11.0
+Version: 0.12.0
 Summary: Shared library for data interchange between Validibot and validator containers
 Project-URL: Homepage, https://validibot.com
 Project-URL: Documentation, https://docs.validibot.com
@@ -28,7 +28,7 @@ Requires-Dist: defusedxml<0.8,>=0.7.1
 Requires-Dist: pydantic<3.0,>=2.13
 Provides-Extra: dev
 Requires-Dist: pytest==9.1.1; extra == 'dev'
-Requires-Dist: ruff==0.15.18; extra == 'dev'
+Requires-Dist: ruff==0.15.20; extra == 'dev'
 Description-Content-Type: text/markdown
 
 <div align="center">

{validibot_shared-0.11.0 → validibot_shared-0.12.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "validibot-shared"
-version = "0.11.0"
+version = "0.12.0"
 description = "Shared library for data interchange between Validibot and validator containers"
 readme = "README.md"
 license = { text = "MIT" }
@@ -37,7 +37,7 @@ classifiers = [
 dependencies = ["pydantic>=2.13,<3.0", "defusedxml>=0.7.1,<0.8"]
 
 [project.optional-dependencies]
-dev = ["pytest==9.1.1", "ruff==0.15.18"]
+dev = ["pytest==9.1.1", "ruff==0.15.20"]
 
 [project.urls]
 Homepage = "https://validibot.com"

{validibot_shared-0.11.0 → validibot_shared-0.12.0}/tests/test_schematron_envelopes.py

@@ -1,18 +1,19 @@
 """Tests for the Schematron container contract (ADR-2026-07-01, D4b/D9).
 
-The Schematron validator ships an **artefact reference** (staged URI +
-checksums) rather than inlined rule text, and its outputs carry an
-``engine_status`` failure taxonomy where ``passed`` is *tri-state* —
-True/False when the engine ran, ``None`` (unknown) when it could not. These
-tests pin those contract properties so a refactor cannot silently weaken
-them: the Django side and the validator backend both program against exactly
-this shape.
+The Schematron validator ships the author's rules **inline as text** (the
+SHACL ``shapes_text`` pattern — the container compiles them itself), and its
+outputs carry an ``engine_status`` failure taxonomy where ``passed`` is
+*tri-state* — True/False when the engine ran, ``None`` (unknown) when it
+could not. These tests pin those contract properties so a refactor cannot
+silently weaken them: the Django side and the validator backend both program
+against exactly this shape.
 """
 
 import pytest
 from pydantic import ValidationError
 
 from validibot_shared.schematron.envelopes import (
+    ENGINE_ERROR_RULES_INVALID,
     ENGINE_STATUS_OK,
     ENGINE_STATUS_TIMEOUT,
     SchematronFinding,
@@ -32,7 +33,13 @@ from validibot_shared.validations.envelopes import (
 DEFAULT_MAX_FINDINGS = 500
 DEFAULT_XSLT_TIMEOUT = 60
 TEST_ERROR_COUNT = 3
-ARTIFACT_SHA = "b" * 64
+RULES_SHA = "b" * 64
+
+SCH_SOURCE = (
+    '<schema xmlns="http://purl.oclc.org/dsdl/schematron">'
+    "<pattern><rule context='/'><assert test='true()'>ok</assert></rule>"
+    "</pattern></schema>"
+)
 
 
 class _ValidatorStub:
@@ -45,46 +52,43 @@ class _ValidatorStub:
 
 def _inputs(**overrides) -> SchematronInputs:
     base = {
-        "pack_id": "en16931-ubl",
-        "pack_version": "1.3.16",
-        "artifact_uri": "gs://bucket/run-1/pack.xslt",
-        "artifact_sha256": ARTIFACT_SHA,
-        "query_binding": "xslt2",
+        "schematron_text": SCH_SOURCE,
+        "schematron_sha256": RULES_SHA,
     }
     base.update(overrides)
     return SchematronInputs(**base)
 
 
-def test_schematron_inputs_carry_artifact_reference_and_limit_defaults():
-    """Inputs pin the staged artefact + checksum and default the D8 limits.
+def test_inputs_carry_inline_rules_and_limit_defaults():
+    """Inputs ship the rules inline with provenance sha and D8 defaults.
 
-    The container MUST be able to verify what it fetched before executing —
-    so the artefact URI and sha256 are required — while the resource limits
-    default to the ADR's table values for direct consumers.
+    Inline text is the whole delivery model (no staging, no artefact URIs):
+    the container gets everything it needs from the envelope alone, exactly
+    like SHACL's shapes_text.
     """
     inputs = _inputs()
 
-    assert inputs.artifact_uri == "gs://bucket/run-1/pack.xslt"
-    assert inputs.artifact_sha256 == ARTIFACT_SHA
+    assert inputs.schematron_text == SCH_SOURCE
+    assert inputs.schematron_sha256 == RULES_SHA
     assert inputs.max_findings == DEFAULT_MAX_FINDINGS
     assert inputs.xslt_timeout_seconds == DEFAULT_XSLT_TIMEOUT
 
 
-def test_schematron_inputs_require_the_artifact_fields():
-    """Omitting the artefact reference is a validation error, not a default.
+def test_inputs_require_the_rules_text():
+    """Omitting schematron_text is a validation error, not a default.
 
-    An input envelope without a verifiable artefact would force the container
-    to either refuse (good, but late) or trust an unpinned path (never).
+    An input envelope without rules would force the container to run
+    nothing and report... something. Refuse at the contract layer.
     """
     with pytest.raises(ValidationError):
-        SchematronInputs(pack_id="x", pack_version="1")
+        SchematronInputs()
 
 
 def test_outputs_default_to_unknown_passed_not_false():
     """``passed`` defaults to None — unknown, not failed (D9).
 
     A default of False would make an unpopulated envelope read as "the
-    invoice failed the rules"; None forces every consumer to distinguish
+    document failed the rules"; None forces every consumer to distinguish
     "engine didn't run" from "rules failed".
     """
     outputs = SchematronOutputs()
@@ -92,35 +96,46 @@ def test_outputs_default_to_unknown_passed_not_false():
     assert outputs.engine_status == ENGINE_STATUS_OK
 
 
-def test_engine_failure_shape_round_trips():
-    """A timeout outputs object serializes and re-validates losslessly.
+def test_engine_failure_shapes_round_trip():
+    """Timeout and rules-invalid outputs serialize and re-validate losslessly.
 
     The callback path deserializes output.json with this model; the D9
-    fields must survive the JSON round trip exactly.
+    fields must survive the JSON round trip exactly, including the
+    machine hint that lets Django distinguish "your rules don't compile"
+    from a generic engine error.
     """
-    outputs = SchematronOutputs(
+    timeout = SchematronOutputs(
         engine_status=ENGINE_STATUS_TIMEOUT,
         engine_message="Transform exceeded 60s",
         passed=None,
-        error_count=0,
-    )
-    envelope = SchematronOutputEnvelope(
-        run_id="run-1",
-        validator={"id": "v1", "type": ValidatorType.SCHEMATRON, "version": "1"},
-        status=ValidationStatus.FAILED_RUNTIME,
-        timing={},
-        outputs=outputs,
     )
-
-    restored = SchematronOutputEnvelope.model_validate(
-        envelope.model_dump(mode="json"),
+    invalid_rules = SchematronOutputs(
+        engine_status="error",
+        engine_error_code=ENGINE_ERROR_RULES_INVALID,
+        engine_message="Schematron failed to compile: unexpected element",
+        passed=None,
     )
-    assert restored.outputs.engine_status == ENGINE_STATUS_TIMEOUT
-    assert restored.outputs.passed is None
-
-
-def test_findings_and_rule_id_map_round_trip():
-    """Findings keep native ids/locations and the map keeps its D2 shape."""
+    for outputs, status in (
+        (timeout, ValidationStatus.FAILED_RUNTIME),
+        (invalid_rules, ValidationStatus.FAILED_RUNTIME),
+    ):
+        envelope = SchematronOutputEnvelope(
+            run_id="run-1",
+            validator={"id": "v1", "type": ValidatorType.SCHEMATRON, "version": "1"},
+            status=status,
+            timing={},
+            outputs=outputs,
+        )
+        restored = SchematronOutputEnvelope.model_validate(
+            envelope.model_dump(mode="json"),
+        )
+        assert restored.outputs.engine_status == outputs.engine_status
+        assert restored.outputs.engine_error_code == outputs.engine_error_code
+        assert restored.outputs.passed is None
+
+
+def test_findings_map_and_provenance_round_trip():
+    """Findings keep native ids/locations; provenance keeps the rules sha."""
     outputs = SchematronOutputs(
         engine_status=ENGINE_STATUS_OK,
         passed=False,
@@ -135,12 +150,17 @@ def test_findings_and_rule_id_map_round_trip():
                 flag="fatal",
             ),
         ],
+        schematron_sha256=RULES_SHA,
+        query_binding="xslt2",
+        engine="SaxonC-HE 12.9",
     )
 
     restored = SchematronOutputs.model_validate(outputs.model_dump(mode="json"))
     assert restored.finding_rule_ids_by_severity["BR-CO-15"] == "ERROR"
     assert restored.findings[0].rule_id == "BR-CO-15"
     assert restored.findings[0].location_xpath == "/Invoice/LegalMonetaryTotal"
+    assert restored.schematron_sha256 == RULES_SHA
+    assert restored.query_binding == "xslt2"
 
 
 def test_outputs_forbid_unknown_fields():
@@ -148,9 +168,10 @@ def test_outputs_forbid_unknown_fields():
 
     Contract models must reject unknown keys so a mismatched backend/Django
     version pair surfaces as an explicit error instead of dropped data.
+    This also guards the 0.11 → 0.12 break: old pack_* fields are refused.
     """
     with pytest.raises(ValidationError):
-        SchematronOutputs(engine_status="ok", not_a_field=1)
+        SchematronOutputs(engine_status="ok", pack_id="stale-field")
 
 
 def test_build_schematron_input_envelope_assembles_the_xml_submission():
@@ -180,4 +201,4 @@ def test_build_schematron_input_envelope_assembles_the_xml_submission():
     assert file_item.name == "submission.xml"
     assert file_item.mime_type == SupportedMimeType.APPLICATION_XML
     assert file_item.role == "primary-model"
-    assert envelope.inputs.pack_id == "en16931-ubl"
+    assert envelope.inputs.schematron_text == SCH_SOURCE

{validibot_shared-0.11.0 → validibot_shared-0.12.0}/tests/test_schematron_svrl.py

@@ -64,9 +64,7 @@ def _failed_assert(
     if role:
         attrs += f' role="{role}"'
     return (
-        f"<svrl:failed-assert{attrs}>"
-        f"<svrl:text>{text}</svrl:text>"
-        "</svrl:failed-assert>"
+        f"<svrl:failed-assert{attrs}><svrl:text>{text}</svrl:text></svrl:failed-assert>"
     )
 
 

{validibot_shared-0.11.0 → validibot_shared-0.12.0}/validibot_shared/schematron/__init__.py

@@ -1,8 +1,8 @@
 """Schematron Advanced validator envelopes and models."""
 
 from validibot_shared.schematron.envelopes import (
-    ENGINE_ERROR_ARTIFACT_MISMATCH,
     ENGINE_ERROR_BACKEND_UNAVAILABLE,
+    ENGINE_ERROR_RULES_INVALID,
     ENGINE_STATUS_ERROR,
     ENGINE_STATUS_OK,
     ENGINE_STATUS_TIMEOUT,
@@ -26,8 +26,8 @@ from validibot_shared.schematron.svrl import (
 )
 
 __all__ = [
-    "ENGINE_ERROR_ARTIFACT_MISMATCH",
     "ENGINE_ERROR_BACKEND_UNAVAILABLE",
+    "ENGINE_ERROR_RULES_INVALID",
     "ENGINE_STATUS_ERROR",
     "ENGINE_STATUS_OK",
     "ENGINE_STATUS_TIMEOUT",

{validibot_shared-0.11.0 → validibot_shared-0.12.0}/validibot_shared/schematron/envelopes.py

@@ -2,27 +2,27 @@
 Pydantic envelopes for the Schematron Advanced validator backend.
 
 The Schematron validator is an Advanced validator — it runs in an isolated
-container/Cloud Run Job rather than inside the Django worker. The official
-rule packs (EN 16931, Peppol BIS Billing 3.0) are authored with
-``queryBinding="xslt2"`` and require a Saxon engine executing rule-pack XSLT
-over untrusted submitted XML; that never runs next to the worker's database
-credentials, identity, or network (see ADR-2026-07-01, decision D4).
-
-These schemas define the contract between Django and the Schematron container:
-
-- **Input envelope**: the XML submission (as an ``InputFileItem`` URI) plus a
-  reference to the *staged* rule-pack artefact — a container-visible URI
-  (``gs://…`` on Cloud Run, ``file://…`` for local Docker) together with the
-  pinned checksums and query binding. Unlike SHACL, which inlines merged
-  shapes *text*, Schematron ships an artefact reference: the compiled XSLT is
-  large, and the container MUST fetch it by URI and verify ``artifact_sha256``
-  before executing (D4b). The D8 resource limits ride along, already clamped
+container/Cloud Run Job rather than inside the Django worker. Schematron
+rules compile to XSLT (a full programming language), so author-uploaded
+rules are executable code and only ever run inside the sandboxed container:
+no database, no secrets, no network egress, locked-down engine
+(ADR-2026-07-01, decisions D4/D8).
+
+These schemas define the contract between Django and the Schematron
+container:
+
+- **Input envelope**: the XML submission (as an ``InputFileItem`` URI) plus
+  the author's Schematron rules **inline as text** — exactly how SHACL
+  ships its merged shapes text. Django resolves the rules from the step's
+  ``Ruleset`` before dispatch; the container compiles them (SchXslt2 →
+  XSLT, baked into the image as fixed tooling) and runs the result over the
+  submission. The D8 resource limits ride along, already clamped
   Django-side; the container re-clamps defensively.
 - **Output envelope**: the parsed SVRL summary — per-severity counts, the
-  ``finding_rule_ids_by_severity`` map, structured findings preserving native
-  rule ids/locations — plus ``engine_status`` (D9: findings are only
-  meaningful when the engine actually ran) and the full artefact/engine
-  provenance (D5).
+  ``finding_rule_ids_by_severity`` map, structured findings preserving
+  native rule ids/locations — plus ``engine_status`` (D9: findings are only
+  meaningful when the engine actually ran) and provenance (the sha256 of
+  the executed rules, the detected query binding, and the engine that ran).
 """
 
 from __future__ import annotations
@@ -49,10 +49,15 @@ ENGINE_STATUS_TIMEOUT = "timeout"
 
 # Machine hints for ``SchematronOutputs.engine_error_code`` — Django maps
 # these to its reserved ``schematron.*`` finding codes.
-ENGINE_ERROR_ARTIFACT_MISMATCH = "artifact_mismatch"
+#
+# ``rules_invalid``: the author's uploaded Schematron failed to compile.
+# That's a workflow-authoring problem, not a fact about the submitted
+# document — the submitter's run still reads "the check couldn't run".
+ENGINE_ERROR_RULES_INVALID = "rules_invalid"
 ENGINE_ERROR_BACKEND_UNAVAILABLE = "backend_unavailable"
 
-# Query bindings a pack may declare (mirrors the Django-side pack registry).
+# Schematron query bindings (declared by the .sch root's ``queryBinding``
+# attribute; the container detects and echoes it for provenance).
 QUERY_BINDING_XSLT1 = "xslt1"
 QUERY_BINDING_XSLT2 = "xslt2"
 
@@ -60,38 +65,26 @@ QUERY_BINDING_XSLT2 = "xslt2"
 class SchematronInputs(BaseModel):
     """Schematron run configuration resolved by Django for the container.
 
-    Everything the container needs without database access: which pinned
-    pack to run (by *staged artefact reference*, never a Django package
-    path), the checksums to verify before executing, and the D8 resource
-    limits (already clamped Django-side; re-clamped in the container).
+    Everything the container needs without database access: the author's
+    rules inline (the SHACL ``shapes_text`` pattern — a ``.sch`` is a text
+    document, typically tens to hundreds of KB) and the D8 resource limits
+    (already clamped Django-side; re-clamped in the container).
     """
 
-    pack_id: str = Field(description="Identifier of the vetted rule pack.")
-    pack_version: str = Field(description="Pinned version of the rule pack.")
-    artifact_uri: str = Field(
+    schematron_text: str = Field(
         description=(
-            "Container-visible URI of the staged compiled XSLT "
-            "(gs://… on Cloud Run, file://… for local Docker)."
+            "The Schematron source (.sch) to compile and run, resolved from "
+            "the step's Ruleset by Django. The container compiles it with "
+            "the SchXslt2 transpiler baked into the image."
         ),
     )
-    artifact_sha256: str = Field(
+    schematron_sha256: str = Field(
+        default="",
         description=(
-            "sha256 of the compiled XSLT. The container MUST verify the "
-            "fetched artefact against this before executing (D4b)."
+            "sha256 of schematron_text, computed by Django at dispatch — "
+            "the provenance identity of the rules this run executed."
         ),
     )
-    source_sha256: str = Field(
-        default="",
-        description="sha256 of the pinned .sch source (provenance echo).",
-    )
-    query_binding: str = Field(
-        default=QUERY_BINDING_XSLT2,
-        description="Schematron query binding of the pack: xslt1 | xslt2.",
-    )
-    engine: str = Field(
-        default="saxonc-he",
-        description="XSLT engine the pack requires (e.g. saxonc-he).",
-    )
 
     # ── D8 resource limits (clamped Django-side; re-clamped in container) ──
     max_input_bytes: int = Field(default=10_000_000, gt=0)
@@ -108,7 +101,7 @@ class SchematronFinding(BaseModel):
 
     Both ``svrl:failed-assert`` and ``svrl:successful-report`` entries are
     active findings (a ``<report>`` can carry a publisher-authored error).
-    ``rule_id`` is the publisher's native identifier (``BR-CO-15``,
+    ``rule_id`` is the rule's native identifier (``BR-CO-15``,
     ``PEPPOL-EN16931-R010``) and becomes ``ValidationFinding.code`` in
     Django; ``location_xpath`` preserves the SVRL ``@location`` so the
     finding can point at the offending element. ``flag``/``role`` carry the
@@ -155,7 +148,7 @@ class SchematronOutputs(BaseModel):
     engine_error_code: str = Field(
         default="",
         description=(
-            "Machine hint for the failure kind (e.g. artifact_mismatch, "
+            "Machine hint for the failure kind (e.g. rules_invalid, "
             "backend_unavailable); maps to Django's reserved codes."
         ),
     )
@@ -200,18 +193,21 @@ class SchematronOutputs(BaseModel):
         description="How many findings the cap suppressed (counts stay full).",
     )
 
-    # ── Provenance of the exact executed artefact + engine (D5) ──
-    pack_id: str = Field(default="")
-    pack_version: str = Field(default="")
-    pack_source_sha256: str = Field(default="")
-    pack_artifact_sha256: str = Field(
+    # ── Provenance of the executed rules + engine (D5) ──
+    schematron_sha256: str = Field(
+        default="",
+        description="sha256 of the Schematron source that was executed.",
+    )
+    query_binding: str = Field(
         default="",
-        description="sha256 of the compiled XSLT actually executed.",
+        description=(
+            "Query binding detected from the .sch root (xslt1/xslt2/…), "
+            "echoed for provenance."
+        ),
     )
-    query_binding: str = Field(default="")
     engine: str = Field(
         default="",
-        description="Engine name + version that ran, e.g. 'SaxonC-HE 12.5'.",
+        description="Engine name + version that ran, e.g. 'SaxonC-HE 12.9'.",
     )
 
     execution_seconds: float = Field(default=0.0, ge=0)
@@ -259,8 +255,7 @@ def build_schematron_input_envelope(
         org_id / org_name: Organization identity.
         workflow_id / step_id / step_name: Workflow context.
         submission_uri: Storage URI for the XML submission (gs:// or file://).
-        inputs: Fully-resolved ``SchematronInputs`` (staged artefact
-            reference + checksums + limits).
+        inputs: Fully-resolved ``SchematronInputs`` (inline rules + limits).
         callback_url: URL the container POSTs to on completion.
         execution_bundle_uri: Base URI for this run's bundle.
         callback_id: Idempotency key echoed back in the callback.

{validibot_shared-0.11.0 → validibot_shared-0.12.0}/validibot_shared/schematron/svrl.py

@@ -152,9 +152,7 @@ def parse_svrl(
         raise SvrlParseError("Empty SVRL content.")
 
     raw = (
-        svrl_content.encode("utf-8")
-        if isinstance(svrl_content, str)
-        else svrl_content
+        svrl_content.encode("utf-8") if isinstance(svrl_content, str) else svrl_content
     )
     try:
         root = SafeET.fromstring(raw, forbid_dtd=True)
@@ -192,13 +190,10 @@ def parse_svrl(
                 existing is None
                 or _SEVERITY_RANK[finding.severity] < _SEVERITY_RANK[existing]
             ):
-                summary.finding_rule_ids_by_severity[finding.rule_id] = (
-                    finding.severity
-                )
+                summary.finding_rule_ids_by_severity[finding.rule_id] = finding.severity
         else:
             logger.warning(
-                "SVRL %s finding has no @id; kept without a rule id "
-                "(message=%r)",
+                "SVRL %s finding has no @id; kept without a rule id (message=%r)",
                 finding.element,
                 finding.message[:120],
             )