cbpr-usage-rules 0.1.2__tar.gz → 0.2.0__tar.gz

{cbpr_usage_rules-0.1.2 → cbpr_usage_rules-0.2.0}/CHANGELOG.md

@@ -4,6 +4,25 @@ All notable changes to this project are documented here. The format is based on
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) and this project adheres
 to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.2.0]
+
+### Added
+- `--format {text,compact,json}` CLI option. The new `compact` format prints one
+  finding per line, compiler/linter-style (`file:line: severity [rule] message | at
+  xpath`) with a stable `VALID:`/`INVALID:` summary line — easy for tools and coding
+  agents to parse. `--json` is now an alias for `--format json`; the default rich
+  text output is unchanged.
+
+## [0.1.3]
+
+### Changed
+- Country (`VAL-CTRY`) and currency (`VAL-CCY`) validation are now single universal
+  rules, like IBAN/LEI. `VAL-CTRY` checks every `<Ctry>` element; `VAL-CCY` checks
+  every `Ccy` attribute and `<Ccy>` element, document-wide, for all message types.
+  This closes gaps where country was unvalidated (e.g. pacs.008 2025, the pacs.009
+  family) and currency was unvalidated (pacs.002 2025), and replaces the ~13
+  per-module `VAL-CTRY` and ~19 per-module `VAL-CCY` rules.
+
 ## [0.1.2]
 
 ### Changed

{cbpr_usage_rules-0.1.2/src/cbpr_usage_rules.egg-info → cbpr_usage_rules-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cbpr-usage-rules
-Version: 0.1.2
+Version: 0.2.0
 Summary: Validate ISO 20022 CBPR+ XML messages against SWIFT usage (business) rules.
 Author: Pete Houghton
 License: MIT License
@@ -112,8 +112,11 @@ result = cbpr_rules.validate_string(xml_text, year=2026)
 # Human-readable (default). Exit code is non-zero if there are violations.
 cbpr-validate payment.xml --year 2025
 
-# JSON output
-cbpr-validate payment.xml --year 2025 --json
+# Compact, one finding per line (compiler-style) — for tools and coding agents
+cbpr-validate payment.xml --year 2025 --format compact
+
+# JSON output (full machine-readable result)
+cbpr-validate payment.xml --year 2025 --json   # same as --format json
 
 # Read from stdin
 cat payment.xml | cbpr-validate --year 2026
@@ -127,6 +130,20 @@ cbpr-validate payment.xml --year 2025 --xsd pacs.008.001.08.xsd
 
 Each reported violation shows the rule, **why** this instance failed (`Problem:`),
 the **offending XML** from your file (`Found:`), and its line + xpath (`At:`).
+
+**For tools and coding agents**, prefer `--format compact` (one finding per line,
+parseable like a compiler/linter) or `--json` (the full structured result):
+
+```text
+$ cbpr-validate payment.xml --year 2025 --format compact
+payment.xml:7: violation [pacs.008:R2] From vs Instructing Agent: ABCDGB2LXXX != GGGGGB2LXXX | at /AppHdr/Fr/FIId/FinInstnId/BICFI
+payment.xml:63: violation [pacs.008:VAL-IBAN] invalid IBAN: 'GB29NWBK60161331926818' | at /Document/.../DbtrAcct/Id/IBAN
+INVALID: 5 violations (87 rules)
+```
+
+Each line is `file:line: severity [rule] message | at xpath`, and the final
+`VALID:` / `INVALID:` line is a stable summary to grep for. With `--xsd`, schema
+errors appear as `schema-error` lines and are counted in the summary.
 Advisory rules are summarised as a count by default; pass `--advisory` to list them.
 
 ---
@@ -141,7 +158,7 @@ Both `validate_file` and `validate_string` return a dictionary:
   "message_type": "pacs.008",         # the rule set that was applied
   "detected_message_type": "pacs.008",# auto-detected from the Document namespace
   "year": 2025,
-  "rules_evaluated": 86,
+  "rules_evaluated": 87,
   "violations": [
     {
       "rule_number": "pacs.008:R41",   # unique within the message type

{cbpr_usage_rules-0.1.2 → cbpr_usage_rules-0.2.0}/README.md

@@ -57,8 +57,11 @@ result = cbpr_rules.validate_string(xml_text, year=2026)
 # Human-readable (default). Exit code is non-zero if there are violations.
 cbpr-validate payment.xml --year 2025
 
-# JSON output
-cbpr-validate payment.xml --year 2025 --json
+# Compact, one finding per line (compiler-style) — for tools and coding agents
+cbpr-validate payment.xml --year 2025 --format compact
+
+# JSON output (full machine-readable result)
+cbpr-validate payment.xml --year 2025 --json   # same as --format json
 
 # Read from stdin
 cat payment.xml | cbpr-validate --year 2026
@@ -72,6 +75,20 @@ cbpr-validate payment.xml --year 2025 --xsd pacs.008.001.08.xsd
 
 Each reported violation shows the rule, **why** this instance failed (`Problem:`),
 the **offending XML** from your file (`Found:`), and its line + xpath (`At:`).
+
+**For tools and coding agents**, prefer `--format compact` (one finding per line,
+parseable like a compiler/linter) or `--json` (the full structured result):
+
+```text
+$ cbpr-validate payment.xml --year 2025 --format compact
+payment.xml:7: violation [pacs.008:R2] From vs Instructing Agent: ABCDGB2LXXX != GGGGGB2LXXX | at /AppHdr/Fr/FIId/FinInstnId/BICFI
+payment.xml:63: violation [pacs.008:VAL-IBAN] invalid IBAN: 'GB29NWBK60161331926818' | at /Document/.../DbtrAcct/Id/IBAN
+INVALID: 5 violations (87 rules)
+```
+
+Each line is `file:line: severity [rule] message | at xpath`, and the final
+`VALID:` / `INVALID:` line is a stable summary to grep for. With `--xsd`, schema
+errors appear as `schema-error` lines and are counted in the summary.
 Advisory rules are summarised as a count by default; pass `--advisory` to list them.
 
 ---
@@ -86,7 +103,7 @@ Both `validate_file` and `validate_string` return a dictionary:
   "message_type": "pacs.008",         # the rule set that was applied
   "detected_message_type": "pacs.008",# auto-detected from the Document namespace
   "year": 2025,
-  "rules_evaluated": 86,
+  "rules_evaluated": 87,
   "violations": [
     {
       "rule_number": "pacs.008:R41",   # unique within the message type

{cbpr_usage_rules-0.1.2 → cbpr_usage_rules-0.2.0}/src/cbpr_rules/__init__.py

@@ -4,7 +4,7 @@ This package is AI generated. See the README for details and caveats.
 """
 from __future__ import annotations
 
-__version__ = "0.1.2"
+__version__ = "0.2.0"
 
 from .models import Rule, Severity, Violation
 from .engine import validate_file, validate_string, list_rules, available

{cbpr_usage_rules-0.1.2 → cbpr_usage_rules-0.2.0}/src/cbpr_rules/cli.py

@@ -26,7 +26,18 @@ def _build_parser() -> argparse.ArgumentParser:
         help="Message type override, e.g. pacs.008 or pacs.008_stp "
         "(auto-detected from the Document namespace if omitted).",
     )
-    p.add_argument("--json", action="store_true", help="Emit JSON instead of text.")
+    p.add_argument(
+        "--format",
+        choices=("text", "compact", "json"),
+        default="text",
+        help="Output format: text (rich, default), compact (one finding per line, "
+        "compiler-style — for tools/agents), or json (full machine-readable).",
+    )
+    p.add_argument(
+        "--json",
+        action="store_true",
+        help="Alias for --format json.",
+    )
     p.add_argument(
         "--xsd",
         action="append",
@@ -125,6 +136,43 @@ def _format_text(result: dict, show_advisory: bool = False) -> str:
     return "\n".join(lines)
 
 
+def _format_compact(result: dict, source: str) -> str:
+    """One finding per line, compiler/linter-style, for tools and coding agents.
+
+    ``<source>:<line>: <severity> [<rule>] <message> | at <xpath>`` per violation,
+    followed by a single greppable ``VALID:``/``INVALID:`` summary line. Advisory
+    (non-enforced) rules are omitted; use --json or text --advisory for those.
+    """
+    lines: List[str] = []
+    for v in result["violations"]:
+        line = v["line"] if v["line"] is not None else "?"
+        message = " ".join((v.get("detail") or v["description"] or "").split())
+        suffix = f" | at {v['xpath']}" if v.get("xpath") else ""
+        lines.append(f"{source}:{line}: {v['severity']} [{v['rule_number']}] {message}{suffix}")
+
+    xsd = result.get("xsd")
+    schema_errors = 0
+    if xsd is not None:
+        for s in xsd["schemas"]:
+            if s.get("load_error"):
+                schema_errors += 1
+                lines.append(f"{s['file']}: schema-error could not load schema: {s['load_error']}")
+            for e in s["errors"]:
+                schema_errors += 1
+                eline = e["line"] if e.get("line") is not None else "?"
+                msg = " ".join((e.get("message") or "").split())
+                lines.append(f"{s['file']}:{eline}: schema-error {msg}")
+
+    n = len(result["violations"])
+    verdict = "VALID" if result["valid"] else "INVALID"
+    parts = [f"{n} violation{'s' if n != 1 else ''}"]
+    if xsd is not None:
+        parts.append(f"{schema_errors} schema error{'s' if schema_errors != 1 else ''}")
+    summary = f"{verdict}: {', '.join(parts)} ({result['rules_evaluated']} rules)"
+    lines.append(summary)
+    return "\n".join(lines)
+
+
 def main(argv: Optional[List[str]] = None) -> int:
     args = _build_parser().parse_args(argv)
 
@@ -153,6 +201,7 @@ def main(argv: Optional[List[str]] = None) -> int:
         print("error: --year is required to validate", file=sys.stderr)
         return 2
 
+    source = args.file or "<stdin>"
     try:
         if args.file:
             result = validate_file(args.file, args.year, args.msgtype, xsd=args.xsd)
@@ -163,8 +212,11 @@ def main(argv: Optional[List[str]] = None) -> int:
         print(f"error: {exc}", file=sys.stderr)
         return 2
 
-    if args.json:
+    fmt = "json" if args.json else args.format
+    if fmt == "json":
         print(json.dumps(result, indent=2))
+    elif fmt == "compact":
+        print(_format_compact(result, source))
     else:
         print(_format_text(result, show_advisory=args.advisory))
 

{cbpr_usage_rules-0.1.2 → cbpr_usage_rules-0.2.0}/src/cbpr_rules/registry.py

@@ -11,7 +11,7 @@ import pkgutil
 from typing import Callable, Dict, List, Tuple
 
 from .models import Rule, Severity, Violation
-from .validators import is_valid_iban, is_valid_lei
+from .validators import is_valid_country, is_valid_currency, is_valid_iban, is_valid_lei
 
 # (year, message_type) -> list[Rule]
 _REGISTRY: Dict[Tuple[int, str], List[Rule]] = {}
@@ -99,24 +99,32 @@ def _discover(year: int) -> None:
 
 
 # Cross-cutting datatype validations applied to every message type. In ISO 20022
-# these elements are self-validating datatypes wherever they appear, so a single
+# these are self-validating datatypes wherever they appear, so a single
 # document-wide scan covers all message types (and all party positions - Debtor,
 # Creditor, Agent, Intermediary) correctly:
 #   <IBAN> is IBAN2007Identifier (ISO 7064 mod-97);
-#   <LEI>  is LEIIdentifier (ISO 17442, 18 alphanumerics + 2 ISO 7064 check digits).
+#   <LEI>  is LEIIdentifier (ISO 17442, 18 alphanumerics + 2 ISO 7064 check digits);
+#   <Ctry> is CountryCode (ISO 3166-1 alpha-2).
 # (number, element, validator, name, description)
-_UNIVERSAL = [
+_UNIVERSAL_ELEMENT = [
     ("VAL-IBAN", "IBAN", is_valid_iban, "CBPR_Valid_IBAN",
      "Every IBAN must be structurally valid and pass the ISO 7064 mod-97 check."),
     ("VAL-LEI", "LEI", is_valid_lei, "CBPR_Valid_LEI",
      "Every LEI must be a structurally valid ISO 17442 identifier with correct check digits."),
+    ("VAL-CTRY", "Ctry", is_valid_country, "CBPR_Valid_Country",
+     "Every Country must be a valid ISO 3166-1 alpha-2 country code."),
 ]
 
+# Currency is carried as the ``Ccy`` XML attribute on amount elements
+# (ActiveCurrencyAndAmount etc.) and occasionally as a ``<Ccy>`` element (account
+# currency). Both must be a valid ISO 4217 code.
+_CCY_DESC = "Every currency must be a valid ISO 4217 currency code."
+
 
 def _universal_rules(msgtype: str) -> List[Rule]:
-    """Build the cross-cutting datatype rules (IBAN, LEI) for a message type."""
+    """Build the cross-cutting datatype rules (IBAN, LEI, country, currency)."""
     rules: List[Rule] = []
-    for number, element, validator, name, description in _UNIVERSAL:
+    for number, element, validator, name, description in _UNIVERSAL_ELEMENT:
         rule_id = f"{msgtype}:{number}"
 
         def check(msg, _el=element, _val=validator, _id=rule_id, _name=name, _desc=description):
@@ -138,9 +146,50 @@ def _universal_rules(msgtype: str) -> List[Rule]:
             return out
 
         rules.append(Rule(rule_id, name, description, Severity.VIOLATION, check))
+
+    rules.append(_currency_rule(msgtype))
     return rules
 
 
+def _currency_rule(msgtype: str) -> Rule:
+    rule_id = f"{msgtype}:VAL-CCY"
+
+    def check(msg) -> List[Violation]:
+        out: List[Violation] = []
+
+        def flag(el, code):
+            out.append(
+                Violation(
+                    rule_number=rule_id,
+                    name="CBPR_Valid_Currency",
+                    description=_CCY_DESC,
+                    detail=f"invalid currency '{code}'",
+                    found=msg.snippet_of(el),
+                    xpath=msg.xpath_of(el),
+                    line=msg.line_of(el),
+                )
+            )
+
+        # Every ``Ccy`` attribute, anywhere in the message.
+        for root in (msg.bah, msg.document):
+            if root is None:
+                continue
+            for el in root.iter():
+                if not isinstance(el.tag, str):
+                    continue
+                code = el.get("Ccy")
+                if code and not is_valid_currency(code):
+                    flag(el, code)
+        # Standalone ``<Ccy>`` elements (e.g. account currency).
+        for el in msg.iter_local("Ccy"):
+            code = msg.text_of(el)
+            if code and not is_valid_currency(code):
+                flag(el, code)
+        return out
+
+    return Rule(rule_id, "CBPR_Valid_Currency", _CCY_DESC, Severity.VIOLATION, check)
+
+
 def load_rules(year: int, msgtype: str) -> List[Rule]:
     _discover(int(year))
     rules = list(_REGISTRY.get(_key(year, msgtype), []))

{cbpr_usage_rules-0.1.2 → cbpr_usage_rules-0.2.0}/src/cbpr_rules/rules/y2025/camt_052.py

@@ -11,7 +11,7 @@ rules are surfaced as advisory guidance. Algorithmic field validations
 from __future__ import annotations
 
 from ...registry import advisory, rule
-from ...validators import is_valid_bic, is_valid_country, is_valid_currency
+from ...validators import is_valid_bic
 from ...helpers import (
     amount_equals_sum,
     business_msg_id_carries_group_id,
@@ -117,34 +117,6 @@ reg("VAL-BIC", "CBPR_Valid_Agent_BIC",
     _val_bic)
 
 
-def _val_ctry(msg, report):
-    for node in msg.find(RPT + "/Acct/Svcr/FinInstnId/PstlAdr/Ctry"):
-        val = msg.text_of(node)
-        if val and not is_valid_country(val):
-            report(node, detail=f"invalid country '{val}'")
-    for node in msg.find(RPT + "/Acct/Ownr/PstlAdr/Ctry"):
-        val = msg.text_of(node)
-        if val and not is_valid_country(val):
-            report(node, detail=f"invalid country '{val}'")
-
-
-reg("VAL-CTRY", "CBPR_Valid_Country",
-    "Every PostalAddress Country must be a valid ISO 3166 alpha-2 code.",
-    _val_ctry)
-
-
-def _val_ccy(msg, report):
-    for p in (RPT + "/Bal/Amt", RPT + "/Ntry/Amt"):
-        for el, ccy in msg.attr_nodes(p, "Ccy"):
-            if ccy and not is_valid_currency(ccy):
-                report(el, detail=f"invalid currency '{ccy}'")
-
-
-reg("VAL-CCY", "CBPR_Valid_Amount_Currency",
-    "Balance and Entry amount currency must be a valid ISO 4217 code.",
-    _val_ccy)
-
-
 # ---------------------------------------------------------------------------
 # Advisory textual rules (not mechanically enforceable - surfaced as guidance)
 # ---------------------------------------------------------------------------

{cbpr_usage_rules-0.1.2 → cbpr_usage_rules-0.2.0}/src/cbpr_rules/rules/y2025/camt_054.py

@@ -8,7 +8,7 @@ mechanizable textual rules are enforced, the rest are surfaced as advisories.
 from __future__ import annotations
 
 from ...registry import advisory, rule
-from ...validators import is_valid_bic, is_valid_country, is_valid_currency
+from ...validators import is_valid_bic
 from ...helpers import (
     business_msg_id_carries_group_id,
     code_in,
@@ -76,22 +76,10 @@ reg("R4", "CBPR_Message_Definition_Identifier_TextualRule",
 # ---------------------------------------------------------------------------
 # Algorithmic field validations (brief), only for fields present in camt.054
 # ---------------------------------------------------------------------------
-reg("VAL-CCY", "CBPR_Valid_Entry_Currency",
-    "Entry Amount currency must be a valid ISO 4217 code.",
-    lambda msg, report: [
-        report(el, detail=f"invalid currency '{ccy}'")
-        for el, ccy in msg.attr_nodes(ENTRY + "/Amt", "Ccy")
-        if ccy and not is_valid_currency(ccy)
-    ])
-
 reg("VAL-BIC", "CBPR_Valid_Account_Servicer_BIC",
     "Account Servicer BICFI must be a structurally valid BIC.",
     each_value_valid(NTFCTN + "/Acct/Svcr/FinInstnId/BICFI", is_valid_bic, "BIC"))
 
-reg("VAL-CTRY", "CBPR_Valid_Account_Owner_Country",
-    "Account Owner postal address Country must be a valid ISO 3166 code.",
-    each_value_valid(NTFCTN + "/Acct/Ownr/PstlAdr/Ctry", is_valid_country, "country"))
-
 
 # ---------------------------------------------------------------------------
 # Advisory textual / guideline rules (not mechanically enforceable)

{cbpr_usage_rules-0.1.2 → cbpr_usage_rules-0.2.0}/src/cbpr_rules/rules/y2025/pacs_002.py

@@ -12,7 +12,7 @@ Paths are the short ISO 20022 tags from the guideline's XML Path column.
 from __future__ import annotations
 
 from ...registry import advisory, rule
-from ...validators import is_valid_bic, is_valid_country
+from ...validators import is_valid_bic
 from ...helpers import (
     address_hybrid,
     address_lines_max_length,
@@ -172,10 +172,6 @@ reg("VAL-BIC", "CBPR_Valid_Agent_BIC",
     "Instructing/Instructed Agent BICFI must be a structurally valid BIC.",
     each_value_valid(TX + "/InstgAgt/FinInstnId/BICFI", is_valid_bic, "BIC"))
 
-reg("VAL-CTRY", "CBPR_Valid_Originator_Country",
-    "Originator Postal Address Country must be a valid ISO 3166 country code.",
-    each_value_valid(ORGTR + "/PstlAdr/Ctry", is_valid_country, "country"))
-
 
 # ---------------------------------------------------------------------------
 # Advisory textual rules (not mechanically enforceable - surfaced as guidance)

{cbpr_usage_rules-0.1.2 → cbpr_usage_rules-0.2.0}/src/cbpr_rules/rules/y2025/pacs_004.py

@@ -12,7 +12,7 @@ from __future__ import annotations
 import re
 
 from ...registry import advisory, rule
-from ...validators import is_valid_bic, is_valid_country, is_valid_currency
+from ...validators import is_valid_bic
 from ...helpers import (
     address_hybrid,
     address_lines_max_length,
@@ -691,23 +691,6 @@ def _run_all(*checks):
     return check
 
 
-def _valid_ccy(path):
-    def check(msg, report):
-        for el, ccy in msg.attr_nodes(path, "Ccy"):
-            if ccy and not is_valid_currency(ccy):
-                report(el, detail=f"invalid currency '{ccy}'")
-    return check
-
-
-reg("VAL-CCY", "CBPR_Valid_Settlement_Currency",
-    "Settlement amount currencies must be valid ISO 4217 codes.",
-    _run_all(
-        _valid_ccy(TX + "/OrgnlIntrBkSttlmAmt"),
-        _valid_ccy(TX + "/RtrdIntrBkSttlmAmt"),
-        _valid_ccy(TX + "/RtrdInstdAmt"),
-        _valid_ccy(OTR + "/IntrBkSttlmAmt"),
-    ))
-
 reg("VAL-BIC", "CBPR_Valid_Agent_BIC",
     "Instructing/Instructed Agent BICFI must be a structurally valid BIC.",
     _run_all(
@@ -715,15 +698,6 @@ reg("VAL-BIC", "CBPR_Valid_Agent_BIC",
         each_value_valid(TX + "/InstdAgt/FinInstnId/BICFI", is_valid_bic, "BIC"),
     ))
 
-reg("VAL-CTRY", "CBPR_Valid_Country",
-    "Every Country code must be a valid ISO 3166 country code.",
-    _run_all(
-        each_value_valid(RC + "/Dbtr/Pty/PstlAdr/Ctry", is_valid_country, "country"),
-        each_value_valid(RC + "/Cdtr/Pty/PstlAdr/Ctry", is_valid_country, "country"),
-        each_value_valid(OTR + "/Dbtr/Pty/PstlAdr/Ctry", is_valid_country, "country"),
-        each_value_valid(OTR + "/Cdtr/Pty/PstlAdr/Ctry", is_valid_country, "country"),
-    ))
-
 # ---------------------------------------------------------------------------
 # Advisory textual / guideline rules (not mechanically enforceable)
 # ---------------------------------------------------------------------------

{cbpr_usage_rules-0.1.2 → cbpr_usage_rules-0.2.0}/src/cbpr_rules/rules/y2025/pacs_008.py

@@ -11,7 +11,7 @@ XML paths are the short ISO 20022 tags from its Full_View / XML Path column.
 from __future__ import annotations
 
 from ...registry import advisory, rule
-from ...validators import is_valid_bic, is_valid_currency
+from ...validators import is_valid_bic
 from ...helpers import (
     address_hybrid,
     address_lines_max_length,
@@ -302,14 +302,6 @@ reg("R44", "CBPR_DEBT_Rule_1_TextualRule",
 
 # Specific validations required by the brief (algorithmic), applied to the
 # fields where these data types appear in pacs.008.
-reg("VAL-CCY", "CBPR_Valid_Settlement_Currency",
-    "Interbank Settlement Amount currency must be a valid ISO 4217 code.",
-    lambda msg, report: [
-        report(el, detail=f"invalid currency '{ccy}'")
-        for el, ccy in msg.attr_nodes(TX + "/IntrBkSttlmAmt", "Ccy")
-        if ccy and not is_valid_currency(ccy)
-    ])
-
 reg("VAL-BIC", "CBPR_Valid_Agent_BIC",
     "Instructing/Instructed Agent BICFI must be a structurally valid BIC.",
     each_value_valid(TX + "/InstgAgt/FinInstnId/BICFI", is_valid_bic, "BIC"))

{cbpr_usage_rules-0.1.2 → cbpr_usage_rules-0.2.0}/src/cbpr_rules/rules/y2025/pacs_008_stp.py

@@ -13,7 +13,7 @@ from __future__ import annotations
 import re as _re
 
 from ...registry import advisory, rule
-from ...validators import is_valid_bic, is_valid_country, is_valid_currency
+from ...validators import is_valid_bic
 from ...helpers import (
     address_hybrid,
     address_lines_max_length,
@@ -251,22 +251,10 @@ reg("R8", "CBPR_Business_Service_Usage_TextualRule",
     code_in("/AppHdr/BizSvc", ["swift.cbprplus.stp.03"]))
 
 
-reg("VAL-CCY", "CBPR_Valid_Settlement_Currency",
-    "Interbank Settlement Amount currency must be a valid ISO 4217 code.",
-    lambda msg, report: [
-        report(el, detail=f"invalid currency '{ccy}'")
-        for el, ccy in msg.attr_nodes(TX + "/IntrBkSttlmAmt", "Ccy")
-        if ccy and not is_valid_currency(ccy)
-    ])
-
 reg("VAL-BIC", "CBPR_Valid_Agent_BIC",
     "Instructing/Instructed Agent BICFI must be a structurally valid BIC.",
     each_value_valid(TX + "/InstgAgt/FinInstnId/BICFI", is_valid_bic, "BIC"))
 
-reg("VAL-CTRY", "CBPR_Valid_Country",
-    "Every Postal Address Country must be a valid ISO 3166 country code.",
-    each_value_valid(TX + "/Dbtr/PstlAdr/Ctry", is_valid_country, "country"))
-
 
 # ---------------------------------------------------------------------------
 # Promoted from advisory: mechanizable textual rules now enforced.

{cbpr_usage_rules-0.1.2 → cbpr_usage_rules-0.2.0}/src/cbpr_rules/rules/y2025/pacs_009.py

@@ -11,7 +11,7 @@ Name/PostalAddress follow the *agent* (present-together) rule via FinInstnId.
 from __future__ import annotations
 
 from ...registry import advisory, rule
-from ...validators import is_valid_bic, is_valid_country, is_valid_currency
+from ...validators import is_valid_bic
 from ...helpers import (
     address_hybrid,
     address_lines_max_length,
@@ -199,22 +199,10 @@ reg("R28", "CBPR_Duplication_Postal_Address_TextualRule",
     no_postal_address_duplication())
 
 # Algorithmic validations required by the brief, for fields present in pacs.009.
-reg("VAL-CCY", "CBPR_Valid_Settlement_Currency",
-    "Interbank Settlement Amount currency must be a valid ISO 4217 code.",
-    lambda msg, report: [
-        report(el, detail=f"invalid currency '{ccy}'")
-        for el, ccy in msg.attr_nodes(TX + "/IntrBkSttlmAmt", "Ccy")
-        if ccy and not is_valid_currency(ccy)
-    ])
-
 reg("VAL-BIC", "CBPR_Valid_Agent_BIC",
     "Instructing/Instructed Agent BICFI must be a structurally valid BIC.",
     each_value_valid(TX + "/InstgAgt/FinInstnId/BICFI", is_valid_bic, "BIC"))
 
-reg("VAL-CTRY", "CBPR_Valid_Postal_Country",
-    "Every Postal Address Country must be a valid ISO 3166 country code.",
-    each_value_valid(TX + "/CdtrAgt/FinInstnId/PstlAdr/Ctry", is_valid_country, "country"))
-
 
 # ---------------------------------------------------------------------------
 # Advisory textual rules (not mechanically enforceable - surfaced as guidance)

{cbpr_usage_rules-0.1.2 → cbpr_usage_rules-0.2.0}/src/cbpr_rules/rules/y2025/pacs_009_adv.py

@@ -12,7 +12,7 @@ Name/PostalAddress + grace-period rules (not the customer party rules).
 from __future__ import annotations
 
 from ...registry import advisory, rule
-from ...validators import is_valid_bic, is_valid_currency
+from ...validators import is_valid_bic
 from ...helpers import (
     address_hybrid,
     address_lines_max_length,
@@ -198,14 +198,6 @@ reg("R20", "CBPR_Duplication_Postal_Address_TextualRule",
 # ---------------------------------------------------------------------------
 # Specific algorithmic validations required by the brief (fields present here).
 # ---------------------------------------------------------------------------
-reg("VAL-CCY", "CBPR_Valid_Settlement_Currency",
-    "Interbank Settlement Amount currency must be a valid ISO 4217 code.",
-    lambda msg, report: [
-        report(el, detail=f"invalid currency '{ccy}'")
-        for el, ccy in msg.attr_nodes(TX + "/IntrBkSttlmAmt", "Ccy")
-        if ccy and not is_valid_currency(ccy)
-    ])
-
 reg("VAL-BIC", "CBPR_Valid_Agent_BIC",
     "Instructing/Instructed Agent BICFI must be a structurally valid BIC.",
     each_value_valid(TX + "/InstgAgt/FinInstnId/BICFI", is_valid_bic, "BIC"))

{cbpr_usage_rules-0.1.2 → cbpr_usage_rules-0.2.0}/src/cbpr_rules/rules/y2025/pacs_009_cov.py

@@ -10,7 +10,7 @@ are the short ISO 20022 tags from its Full_View / XML Path column.
 from __future__ import annotations
 
 from ...registry import advisory, rule
-from ...validators import is_valid_bic, is_valid_currency
+from ...validators import is_valid_bic
 from ...helpers import (
     address_hybrid,
     address_lines_max_length,
@@ -235,14 +235,6 @@ reg("R8", "CBPR_Business_Service_Usage_TextualRule",
     code_in("/AppHdr/BizSvc", ["swift.cbprplus.cov.03"]))
 
 # Algorithmic validations (brief), for fields present in pacs.009 COV.
-reg("VAL-CCY", "CBPR_Valid_Settlement_Currency",
-    "Interbank Settlement Amount currency must be a valid ISO 4217 code.",
-    lambda msg, report: [
-        report(el, detail=f"invalid currency '{ccy}'")
-        for el, ccy in msg.attr_nodes(TX + "/IntrBkSttlmAmt", "Ccy")
-        if ccy and not is_valid_currency(ccy)
-    ])
-
 reg("VAL-BIC", "CBPR_Valid_Agent_BIC",
     "Instructing/Instructed Agent BICFI must be a structurally valid BIC.",
     each_value_valid(TX + "/InstgAgt/FinInstnId/BICFI", is_valid_bic, "BIC"))

{cbpr_usage_rules-0.1.2 → cbpr_usage_rules-0.2.0}/src/cbpr_rules/rules/y2025/pain_001.py

@@ -9,7 +9,7 @@ module (``pacs_008``): combinator-built rules go through ``reg``/``_agent_block`
 from __future__ import annotations
 
 from ...registry import advisory, rule
-from ...validators import is_valid_bic, is_valid_country, is_valid_currency
+from ...validators import is_valid_bic
 from ...helpers import (
     address_hybrid,
     address_lines_max_length,
@@ -141,14 +141,6 @@ reg("R69", "CBPR_Structured_Remittance_Information_TextualRule",
 # ---------------------------------------------------------------------------
 # Algorithmic field validation (brief), only for fields present in pain.001.
 # ---------------------------------------------------------------------------
-reg("VAL-CCY", "CBPR_Valid_Instructed_Amount_Currency",
-    "Instructed Amount currency must be a valid ISO 4217 code.",
-    lambda msg, report: [
-        report(el, detail=f"invalid currency '{ccy}'")
-        for el, ccy in msg.attr_nodes(TX + "/Amt/InstdAmt", "Ccy")
-        if ccy and not is_valid_currency(ccy)
-    ])
-
 reg("VAL-BIC", "CBPR_Valid_Agent_BIC",
     "Every Financial Institution BICFI must be a structurally valid BIC.",
     lambda msg, report: [
@@ -164,23 +156,6 @@ reg("VAL-BIC", "CBPR_Valid_Agent_BIC",
         if msg.text_of(node) and not is_valid_bic(msg.text_of(node))
     ])
 
-reg("VAL-CTRY", "CBPR_Valid_Country",
-    "Every Country must be a valid ISO 3166-1 alpha-2 code.",
-    lambda msg, report: [
-        report(node, detail=f"invalid country '{msg.text_of(node)}'")
-        for path in (
-            PMTINF + "/Dbtr/PstlAdr/Ctry",
-            PMTINF + "/DbtrAgt/FinInstnId/PstlAdr/Ctry",
-            TX + "/Cdtr/PstlAdr/Ctry",
-            TX + "/CdtrAgt/FinInstnId/PstlAdr/Ctry",
-            TX + "/IntrmyAgt1/FinInstnId/PstlAdr/Ctry",
-            TX + "/IntrmyAgt2/FinInstnId/PstlAdr/Ctry",
-            TX + "/IntrmyAgt3/FinInstnId/PstlAdr/Ctry",
-        )
-        for node in msg.find(path)
-        if msg.text_of(node) and not is_valid_country(msg.text_of(node))
-    ])
-
 
 # ---------------------------------------------------------------------------
 # Advisory textual rules (not mechanically enforceable - surfaced as guidance)

{cbpr_usage_rules-0.1.2 → cbpr_usage_rules-0.2.0}/src/cbpr_rules/rules/y2026/camt_052.py

@@ -11,8 +11,6 @@ from __future__ import annotations
 from ...registry import advisory, rule
 from ...validators import (
     is_valid_bic,
-    is_valid_country,
-    is_valid_currency,
 )
 from ...helpers import (
     amount_equals_sum,
@@ -89,22 +87,10 @@ reg("R13", "CBPR_Original_Instruction_Identification_FormalRule",
 # ---------------------------------------------------------------------------
 # Algorithmic field validations (brief), for fields present in camt.052
 # ---------------------------------------------------------------------------
-reg("VAL-CCY", "CBPR_Valid_Balance_Currency",
-    "Balance Amount currency must be a valid ISO 4217 code.",
-    lambda msg, report: [
-        report(el, detail=f"invalid currency '{ccy}'")
-        for el, ccy in msg.attr_nodes(RPT + "/Bal/Amt", "Ccy")
-        if ccy and not is_valid_currency(ccy)
-    ])
-
 reg("VAL-BIC", "CBPR_Valid_Account_Servicer_BIC",
     "Account Servicer BICFI must be a structurally valid BIC.",
     each_value_valid(RPT + "/Acct/Svcr/FinInstnId/BICFI", is_valid_bic, "BIC"))
 
-reg("VAL-CTRY", "CBPR_Valid_Account_Owner_Country",
-    "Account Owner Postal Address Country must be a valid ISO 3166 code.",
-    each_value_valid(RPT + "/Acct/Ownr/PstlAdr/Ctry", is_valid_country, "Country"))
-
 
 # ---------------------------------------------------------------------------
 # Mechanizable textual rules promoted from advisory to enforced.

{cbpr_usage_rules-0.1.2 → cbpr_usage_rules-0.2.0}/src/cbpr_rules/rules/y2026/camt_054.py

@@ -11,7 +11,7 @@ rules are surfaced via ``advisory``.
 from __future__ import annotations
 
 from ...registry import advisory, rule
-from ...validators import is_valid_bic, is_valid_country, is_valid_currency
+from ...validators import is_valid_bic
 from ...helpers import (
     business_msg_id_carries_group_id,
     each_value_valid,
@@ -97,23 +97,10 @@ reg("R13", "CBPR_Original_Instruction_Identification_FormalRule",
 # Algorithmic field validation (brief-required VAL-* checks), applied to the
 # fields where these data types appear in camt.054.
 # ---------------------------------------------------------------------------
-reg("VAL-CCY", "CBPR_Valid_Entry_Amount_Currency",
-    "Entry Amount currency must be a valid ISO 4217 code.",
-    lambda msg, report: [
-        report(el, detail=f"invalid currency '{ccy}'")
-        for el, ccy in msg.attr_nodes(ENTRY + "/Amt", "Ccy")
-        if ccy and not is_valid_currency(ccy)
-    ])
-
 reg("VAL-BIC", "CBPR_Valid_Account_Servicer_BIC",
     "Account Servicer BICFI must be a structurally valid BIC.",
     each_value_valid(NTFCTN + "/Acct/Svcr/FinInstnId/BICFI", is_valid_bic, "BIC"))
 
-reg("VAL-CTRY", "CBPR_Valid_Account_Servicer_Country",
-    "Account Servicer postal address Country must be a valid ISO 3166 code.",
-    each_value_valid(NTFCTN + "/Acct/Svcr/FinInstnId/PstlAdr/Ctry",
-                     is_valid_country, "country"))
-
 
 # ---------------------------------------------------------------------------
 # Mechanizable textual rules promoted from advisory to enforced. Both are

{cbpr_usage_rules-0.1.2 → cbpr_usage_rules-0.2.0}/src/cbpr_rules/rules/y2026/pacs_002.py

@@ -10,7 +10,7 @@ from __future__ import annotations
 import re as _re
 
 from ...registry import advisory, rule
-from ...validators import is_valid_bic, is_valid_currency
+from ...validators import is_valid_bic
 from ...helpers import (
     business_msg_id_carries_group_id,
     header_msg_def_id_matches,
@@ -141,15 +141,6 @@ reg("R20", "CBPR_Party_Name_Any_BIC_FormalRule",
 # ---------------------------------------------------------------------------
 # Algorithmic field validation (project brief) - only fields present here.
 # ---------------------------------------------------------------------------
-reg("VAL-CCY", "CBPR_Valid_Original_Interbank_Settlement_Currency",
-    "Original Interbank Settlement Amount currency must be a valid ISO 4217 code.",
-    lambda msg, report: [
-        report(el, detail=f"invalid currency '{ccy}'")
-        for el, ccy in msg.attr_nodes(TX + "/OrgnlTxRef/IntrBkSttlmAmt", "Ccy")
-        if ccy and not is_valid_currency(ccy)
-    ])
-
-
 @rule(MT, YEAR, "VAL-BIC", "CBPR_Valid_Agent_BIC",
       "Every Instructing/Instructed Agent BICFI must be a structurally valid BIC.")
 def _val_bic(msg, report):

{cbpr_usage_rules-0.1.2 → cbpr_usage_rules-0.2.0}/src/cbpr_rules/rules/y2026/pacs_004.py

@@ -10,7 +10,7 @@ Structure mirrors the reference module ``y2025/pacs_008.py``.
 from __future__ import annotations
 
 from ...registry import advisory, rule
-from ...validators import is_valid_bic, is_valid_country, is_valid_currency
+from ...validators import is_valid_bic
 from ...helpers import (
     bic_presence_exclusive,
     business_msg_id_carries_group_id,
@@ -258,23 +258,6 @@ def _run_all(*checks):
     return check
 
 
-def _valid_ccy(path: str):
-    def check(msg, report):
-        for el, ccy in msg.attr_nodes(path, "Ccy"):
-            if ccy and not is_valid_currency(ccy):
-                report(el, detail=f"invalid currency '{ccy}'")
-    return check
-
-
-reg("VAL-CCY", "CBPR_Valid_Settlement_Currency",
-    "Settlement amount currencies must be valid ISO 4217 codes.",
-    _run_all(
-        _valid_ccy(TX + "/OrgnlIntrBkSttlmAmt"),
-        _valid_ccy(TX + "/RtrdIntrBkSttlmAmt"),
-        _valid_ccy(TX + "/RtrdInstdAmt"),
-        _valid_ccy(OTR + "/IntrBkSttlmAmt"),
-    ))
-
 reg("VAL-BIC", "CBPR_Valid_Agent_BIC",
     "Instructing/Instructed Agent BICFI must be a structurally valid BIC.",
     _run_all(
@@ -282,15 +265,6 @@ reg("VAL-BIC", "CBPR_Valid_Agent_BIC",
         each_value_valid(TX + "/InstdAgt/FinInstnId/BICFI", is_valid_bic, "BIC"),
     ))
 
-reg("VAL-CTRY", "CBPR_Valid_Country",
-    "Every Country code must be a valid ISO 3166 country code.",
-    _run_all(
-        each_value_valid(RC + "/Dbtr/Pty/PstlAdr/Ctry", is_valid_country, "country"),
-        each_value_valid(RC + "/Cdtr/Pty/PstlAdr/Ctry", is_valid_country, "country"),
-        each_value_valid(OTR + "/Dbtr/Pty/PstlAdr/Ctry", is_valid_country, "country"),
-        each_value_valid(OTR + "/Cdtr/Pty/PstlAdr/Ctry", is_valid_country, "country"),
-    ))
-
 
 # ---------------------------------------------------------------------------
 # Mechanizable textual rules + advisory textual rules.

{cbpr_usage_rules-0.1.2 → cbpr_usage_rules-0.2.0}/src/cbpr_rules/rules/y2026/pacs_008.py

@@ -9,7 +9,7 @@ registered as advisories.
 from __future__ import annotations
 
 from ...registry import advisory, rule
-from ...validators import is_valid_bic, is_valid_country, is_valid_currency
+from ...validators import is_valid_bic
 from ...helpers import (
     bic_presence_exclusive,
     business_msg_id_carries_group_id,
@@ -307,22 +307,10 @@ reg("R63", "CBPR_Structured_RemittanceInformation_TextualRule",
 # ---------------------------------------------------------------------------
 # Algorithmic field validation required by the project brief
 # ---------------------------------------------------------------------------
-reg("VAL-CCY", "CBPR_Valid_Settlement_Currency",
-    "Interbank Settlement Amount currency must be a valid ISO 4217 code.",
-    lambda msg, report: [
-        report(el, detail=f"invalid currency '{ccy}'")
-        for el, ccy in msg.attr_nodes(TX + "/IntrBkSttlmAmt", "Ccy")
-        if ccy and not is_valid_currency(ccy)
-    ])
-
 reg("VAL-BIC", "CBPR_Valid_Agent_BIC",
     "Every BICFI in the message must be a structurally valid BIC.",
     each_value_valid(TX + "/InstgAgt/FinInstnId/BICFI", is_valid_bic, "BIC"))
 
-reg("VAL-CTRY", "CBPR_Valid_Country",
-    "Every Country code must be a valid ISO 3166 code.",
-    each_value_valid(TX + "/Dbtr/PstlAdr/Ctry", is_valid_country, "Country"))
-
 
 # ---------------------------------------------------------------------------
 # Advisory textual rules (not mechanically enforceable - surfaced as guidance)

{cbpr_usage_rules-0.1.2 → cbpr_usage_rules-0.2.0}/src/cbpr_rules/rules/y2026/pacs_008_stp.py

@@ -11,7 +11,7 @@ from __future__ import annotations
 import re
 
 from ...registry import advisory, rule
-from ...validators import is_valid_bic, is_valid_country, is_valid_currency
+from ...validators import is_valid_bic
 from ...helpers import (
     bic_presence_exclusive,
     business_msg_id_carries_group_id,
@@ -309,22 +309,10 @@ def _r20(msg, report):
 # ---------------------------------------------------------------------------
 # Algorithmic field validation (VAL-*) - only for fields present in this message
 # ---------------------------------------------------------------------------
-reg("VAL-CCY", "CBPR_Valid_Settlement_Currency",
-    "Interbank Settlement Amount currency must be a valid ISO 4217 code.",
-    lambda msg, report: [
-        report(el, detail=f"invalid currency '{ccy}'")
-        for el, ccy in msg.attr_nodes(TX + "/IntrBkSttlmAmt", "Ccy")
-        if ccy and not is_valid_currency(ccy)
-    ])
-
 reg("VAL-BIC", "CBPR_Valid_Agent_BIC",
     "Instructing/Instructed Agent BICFI must be a structurally valid BIC.",
     each_value_valid(TX + "/InstgAgt/FinInstnId/BICFI", is_valid_bic, "BIC"))
 
-reg("VAL-CTRY", "CBPR_Valid_Country",
-    "Every PostalAddress Country must be a valid ISO 3166 alpha-2 code.",
-    each_value_valid(TX + "/Dbtr/PstlAdr/Ctry", is_valid_country, "country"))
-
 
 # ---------------------------------------------------------------------------
 # Advisory textual rules (not mechanically enforceable - surfaced as guidance)

{cbpr_usage_rules-0.1.2 → cbpr_usage_rules-0.2.0}/src/cbpr_rules/rules/y2026/pacs_009.py

@@ -9,7 +9,7 @@ otherwise surfaced as advisories.
 from __future__ import annotations
 
 from ...registry import advisory, rule
-from ...validators import is_valid_bic, is_valid_currency
+from ...validators import is_valid_bic
 from ...helpers import (
     business_msg_id_carries_group_id,
     header_msg_def_id_matches,
@@ -161,15 +161,6 @@ for _num, _path in _AGENT_NAME_ADR.items():
 # ---------------------------------------------------------------------------
 # Algorithmic field validation (brief), only for fields present in pacs.009.
 # ---------------------------------------------------------------------------
-reg("VAL-CCY", "CBPR_Valid_Settlement_Currency",
-    "Interbank Settlement Amount currency must be a valid ISO 4217 code.",
-    lambda msg, report: [
-        report(el, detail=f"invalid currency '{ccy}'")
-        for el, ccy in msg.attr_nodes(TX + "/IntrBkSttlmAmt", "Ccy")
-        if ccy and not is_valid_currency(ccy)
-    ])
-
-
 @rule(MT, YEAR, "VAL-BIC", "CBPR_Valid_Agent_BIC",
       "Every Agent BICFI in the message must be a structurally valid BIC.")
 def _val_bic(msg, report):

{cbpr_usage_rules-0.1.2 → cbpr_usage_rules-0.2.0}/src/cbpr_rules/rules/y2026/pacs_009_adv.py

@@ -9,7 +9,7 @@ otherwise surfaced as advisories.
 from __future__ import annotations
 
 from ...registry import advisory, rule
-from ...validators import is_valid_bic, is_valid_currency
+from ...validators import is_valid_bic
 from ...helpers import (
     not_matching_pattern,
     presence_together,
@@ -167,15 +167,6 @@ for _num, _path in _AGENT_NAME_ADR.items():
 # ---------------------------------------------------------------------------
 # Algorithmic field validation (brief), only for fields present in pacs.009 ADV.
 # ---------------------------------------------------------------------------
-reg("VAL-CCY", "CBPR_Valid_Settlement_Currency",
-    "Interbank Settlement Amount currency must be a valid ISO 4217 code.",
-    lambda msg, report: [
-        report(el, detail=f"invalid currency '{ccy}'")
-        for el, ccy in msg.attr_nodes(TX + "/IntrBkSttlmAmt", "Ccy")
-        if ccy and not is_valid_currency(ccy)
-    ])
-
-
 @rule(MT, YEAR, "VAL-BIC", "CBPR_Valid_Agent_BIC",
       "Every Agent BICFI in the message must be a structurally valid BIC.")
 def _val_bic(msg, report):

{cbpr_usage_rules-0.1.2 → cbpr_usage_rules-0.2.0}/src/cbpr_rules/rules/y2026/pacs_009_cov.py

@@ -10,7 +10,7 @@ are the short ISO 20022 tags from its Full_View / XML Path column.
 from __future__ import annotations
 
 from ...registry import advisory, rule
-from ...validators import is_valid_bic, is_valid_currency
+from ...validators import is_valid_bic
 from ...helpers import (
     bic_presence_exclusive,
     business_msg_id_carries_group_id,
@@ -210,14 +210,6 @@ _party_name_adr("R59", UND + "/UltmtCdtr")
 # ---------------------------------------------------------------------------
 # Algorithmic field validation (brief), for fields present in pacs.009 COV.
 # ---------------------------------------------------------------------------
-reg("VAL-CCY", "CBPR_Valid_Settlement_Currency",
-    "Interbank Settlement Amount currency must be a valid ISO 4217 code.",
-    lambda msg, report: [
-        report(el, detail=f"invalid currency '{ccy}'")
-        for el, ccy in msg.attr_nodes(TX + "/IntrBkSttlmAmt", "Ccy")
-        if ccy and not is_valid_currency(ccy)
-    ])
-
 reg("VAL-BIC", "CBPR_Valid_Agent_BIC",
     "Instructing/Instructed Agent BICFI must be a structurally valid BIC.",
     each_value_valid(TX + "/InstgAgt/FinInstnId/BICFI", is_valid_bic, "BIC"))

{cbpr_usage_rules-0.1.2 → cbpr_usage_rules-0.2.0}/src/cbpr_rules/rules/y2026/pain_001.py

@@ -9,7 +9,7 @@ small helpers, and cross-field / cross-schema logic is written as bespoke
 from __future__ import annotations
 
 from ...registry import advisory, rule
-from ...validators import is_valid_bic, is_valid_country, is_valid_currency
+from ...validators import is_valid_bic
 from ...helpers import (
     business_msg_id_carries_group_id,
     header_msg_def_id_matches,
@@ -182,14 +182,6 @@ _CTRY_PATHS = [
 ]
 
 
-@rule(MT, YEAR, "VAL-CCY", "CBPR_Valid_Instructed_Amount_Currency",
-      "Instructed Amount currency must be a valid ISO 4217 code.")
-def _val_ccy(msg, report):
-    for el, ccy in msg.attr_nodes(TX + "/Amt/InstdAmt", "Ccy"):
-        if ccy and not is_valid_currency(ccy):
-            report(el, detail=f"invalid currency '{ccy}'")
-
-
 @rule(MT, YEAR, "VAL-BIC", "CBPR_Valid_Agent_BIC",
       "Every Financial Institution BICFI must be a structurally valid BIC.")
 def _val_bic(msg, report):
@@ -200,16 +192,6 @@ def _val_bic(msg, report):
                 report(node, detail=f"invalid BIC: '{val}'")
 
 
-@rule(MT, YEAR, "VAL-CTRY", "CBPR_Valid_Country",
-      "Every Country code in a Postal Address must be a valid ISO 3166 code.")
-def _val_ctry(msg, report):
-    for path in _CTRY_PATHS:
-        for node in msg.find(path):
-            val = msg.text_of(node)
-            if val and not is_valid_country(val):
-                report(node, detail=f"invalid country: '{val}'")
-
-
 # ---------------------------------------------------------------------------
 # Promoted from advisory: mechanizable header / address / remittance rules.
 # Each combinator is conservative: it skips when its inputs are absent or

{cbpr_usage_rules-0.1.2 → cbpr_usage_rules-0.2.0/src/cbpr_usage_rules.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cbpr-usage-rules
-Version: 0.1.2
+Version: 0.2.0
 Summary: Validate ISO 20022 CBPR+ XML messages against SWIFT usage (business) rules.
 Author: Pete Houghton
 License: MIT License
@@ -112,8 +112,11 @@ result = cbpr_rules.validate_string(xml_text, year=2026)
 # Human-readable (default). Exit code is non-zero if there are violations.
 cbpr-validate payment.xml --year 2025
 
-# JSON output
-cbpr-validate payment.xml --year 2025 --json
+# Compact, one finding per line (compiler-style) — for tools and coding agents
+cbpr-validate payment.xml --year 2025 --format compact
+
+# JSON output (full machine-readable result)
+cbpr-validate payment.xml --year 2025 --json   # same as --format json
 
 # Read from stdin
 cat payment.xml | cbpr-validate --year 2026
@@ -127,6 +130,20 @@ cbpr-validate payment.xml --year 2025 --xsd pacs.008.001.08.xsd
 
 Each reported violation shows the rule, **why** this instance failed (`Problem:`),
 the **offending XML** from your file (`Found:`), and its line + xpath (`At:`).
+
+**For tools and coding agents**, prefer `--format compact` (one finding per line,
+parseable like a compiler/linter) or `--json` (the full structured result):
+
+```text
+$ cbpr-validate payment.xml --year 2025 --format compact
+payment.xml:7: violation [pacs.008:R2] From vs Instructing Agent: ABCDGB2LXXX != GGGGGB2LXXX | at /AppHdr/Fr/FIId/FinInstnId/BICFI
+payment.xml:63: violation [pacs.008:VAL-IBAN] invalid IBAN: 'GB29NWBK60161331926818' | at /Document/.../DbtrAcct/Id/IBAN
+INVALID: 5 violations (87 rules)
+```
+
+Each line is `file:line: severity [rule] message | at xpath`, and the final
+`VALID:` / `INVALID:` line is a stable summary to grep for. With `--xsd`, schema
+errors appear as `schema-error` lines and are counted in the summary.
 Advisory rules are summarised as a count by default; pass `--advisory` to list them.
 
 ---
@@ -141,7 +158,7 @@ Both `validate_file` and `validate_string` return a dictionary:
   "message_type": "pacs.008",         # the rule set that was applied
   "detected_message_type": "pacs.008",# auto-detected from the Document namespace
   "year": 2025,
-  "rules_evaluated": 86,
+  "rules_evaluated": 87,
   "violations": [
     {
       "rule_number": "pacs.008:R41",   # unique within the message type