verifactu-validator 0.1.0__py3-none-any.whl

verifactu_validator/__init__.py

@@ -0,0 +1,35 @@
+"""verifactu_validator — Spanish AEAT Veri*Factu invoice validator.
+
+Public API surface kept deliberately tiny so the library can be vendored,
+audited, and certified by Spanish accountants and ERP integrators.
+
+Exports
+-------
+- validate_nif(value) -> bool
+- validate_cif(value) -> bool
+- validate_nie(value) -> bool
+- validate_tax_id(value) -> bool   (auto-detects NIF / CIF / NIE)
+- build_invoice_hash(...) -> str   (SHA-256 chained hash, hex)
+- build_qr_url(...) -> str         (AEAT TIKE-CONT verification URL)
+"""
+
+from .hash import build_invoice_hash
+from .nif import (
+    validate_cif,
+    validate_nie,
+    validate_nif,
+    validate_tax_id,
+)
+from .qr import build_qr_url
+
+__all__ = [
+    "validate_nif",
+    "validate_cif",
+    "validate_nie",
+    "validate_tax_id",
+    "build_invoice_hash",
+    "build_qr_url",
+    "__version__",
+]
+
+__version__ = "0.1.0"

verifactu_validator/cli.py

@@ -0,0 +1,201 @@
+"""Command-line interface for verifactu-validator.
+
+Usage examples
+--------------
+    verifactu --help
+    verifactu nif 12345678Z
+    verifactu hash --prev 000...0 --nif B12345678 --num F2026/0001 \
+                   --date 2026-07-01 --total 121.00
+    verifactu qr   --nif B12345678 --num F2026/0001 \
+                   --date 2026-07-01 --total 121.00 [--production]
+    verifactu validate path/to/invoice.xml
+"""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+from xml.etree import ElementTree as ET
+
+from . import __version__
+from .hash import build_invoice_hash, zero_hash
+from .nif import validate_tax_id
+from .qr import build_qr_url
+
+
+def _cmd_nif(args: argparse.Namespace) -> int:
+    ok = validate_tax_id(args.value)
+    print(f"{args.value}: {'OK' if ok else 'FAIL'}")
+    return 0 if ok else 1
+
+
+def _cmd_hash(args: argparse.Namespace) -> int:
+    prev = args.prev or zero_hash()
+    h = build_invoice_hash(
+        previous_hash=prev,
+        issuer_nif=args.nif,
+        invoice_number=args.num,
+        issue_date=args.date,
+        total_amount=args.total,
+    )
+    print(h)
+    return 0
+
+
+def _cmd_qr(args: argparse.Namespace) -> int:
+    url = build_qr_url(
+        issuer_nif=args.nif,
+        invoice_number=args.num,
+        issue_date=args.date,
+        total_amount=args.total,
+        production=args.production,
+    )
+    print(url)
+    return 0
+
+
+_NS_FACTURAE = {
+    "fe": "http://www.facturae.es/Facturae/2014/v3.2.2/Facturae",
+    "fe322": "http://www.facturae.gob.es/formato/Versiones/Facturaev3_2_2.xml",
+}
+
+
+def _findtext(root: ET.Element, *paths: str) -> str | None:
+    for p in paths:
+        node = root.find(p, _NS_FACTURAE)
+        if node is not None and node.text:
+            return node.text.strip()
+    return None
+
+
+def _cmd_validate(args: argparse.Namespace) -> int:
+    path = Path(args.xml)
+    if not path.is_file():
+        print(f"FAIL: file not found: {path}", file=sys.stderr)
+        return 2
+
+    try:
+        tree = ET.parse(path)
+    except ET.ParseError as exc:
+        print(f"FAIL: malformed XML — {exc}")
+        return 1
+
+    root = tree.getroot()
+
+    results: list[tuple[str, bool, str]] = []
+
+    # Rule 1: file is parseable.
+    results.append(("xml.parseable", True, "XML parsed successfully"))
+
+    # Rule 2: issuer NIF present and valid.
+    issuer_nif = _findtext(
+        root,
+        ".//SellerParty//TaxIdentificationNumber",
+        ".//SellerParty//{*}TaxIdentificationNumber",
+        ".//TaxIdentificationNumber",
+    )
+    if issuer_nif:
+        ok = validate_tax_id(issuer_nif)
+        results.append(("issuer.tax_id", ok, f"value={issuer_nif}"))
+    else:
+        results.append(("issuer.tax_id", False, "not found in XML"))
+
+    # Rule 3: at least one invoice number.
+    inv_num = _findtext(
+        root,
+        ".//InvoiceNumber",
+        ".//{*}InvoiceNumber",
+    )
+    results.append(
+        ("invoice.number", bool(inv_num), f"value={inv_num}" if inv_num else "missing")
+    )
+
+    # Rule 4: issue date present.
+    issue_date = _findtext(
+        root,
+        ".//IssueDate",
+        ".//{*}IssueDate",
+    )
+    results.append(
+        ("invoice.issue_date", bool(issue_date), f"value={issue_date}" if issue_date else "missing")
+    )
+
+    # Rule 5: total amount present.
+    total = _findtext(
+        root,
+        ".//TotalExecutableAmount",
+        ".//InvoiceTotal",
+        ".//{*}TotalExecutableAmount",
+        ".//{*}InvoiceTotal",
+    )
+    results.append(
+        ("invoice.total", bool(total), f"value={total}" if total else "missing")
+    )
+
+    width = max(len(name) for name, _, _ in results)
+    failed = 0
+    for name, ok, detail in results:
+        status = "OK  " if ok else "FAIL"
+        print(f"  [{status}] {name.ljust(width)}  {detail}")
+        if not ok:
+            failed += 1
+
+    print()
+    if failed == 0:
+        print(f"PASS: {len(results)} checks succeeded — {path.name}")
+        return 0
+    print(f"FAIL: {failed}/{len(results)} checks failed — {path.name}")
+    return 1
+
+
+def build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(
+        prog="verifactu",
+        description=(
+            "Spanish AEAT Veri*Factu invoice validator. "
+            "Full Odoo module: https://flexigotech.com/verifactu"
+        ),
+    )
+    p.add_argument("--version", action="version", version=f"verifactu-validator {__version__}")
+    sub = p.add_subparsers(dest="command", required=True)
+
+    p_nif = sub.add_parser("nif", help="Validate a Spanish NIF / CIF / NIE.")
+    p_nif.add_argument("value", help="Tax ID to validate")
+    p_nif.set_defaults(func=_cmd_nif)
+
+    p_hash = sub.add_parser("hash", help="Compute the SHA-256 chained invoice hash.")
+    p_hash.add_argument("--prev", default=None, help="Previous SHA-256 hex (default: all zeros).")
+    p_hash.add_argument("--nif", required=True, help="Issuer NIF / CIF / NIE.")
+    p_hash.add_argument("--num", required=True, help="Invoice serial+number.")
+    p_hash.add_argument("--date", required=True, help="Issue date (YYYY-MM-DD or DD-MM-YYYY).")
+    p_hash.add_argument("--total", required=True, help="Invoice total with VAT.")
+    p_hash.set_defaults(func=_cmd_hash)
+
+    p_qr = sub.add_parser("qr", help="Build the AEAT QR URL embedded in the PDF.")
+    p_qr.add_argument("--nif", required=True)
+    p_qr.add_argument("--num", required=True)
+    p_qr.add_argument("--date", required=True)
+    p_qr.add_argument("--total", required=True)
+    p_qr.add_argument(
+        "--production",
+        action="store_true",
+        help="Use the production AEAT endpoint instead of pre-production.",
+    )
+    p_qr.set_defaults(func=_cmd_qr)
+
+    p_val = sub.add_parser("validate", help="Validate a Facturae XML invoice file.")
+    p_val.add_argument("xml", help="Path to invoice .xml")
+    p_val.set_defaults(func=_cmd_validate)
+
+    return p
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    return int(args.func(args) or 0)
+
+
+if __name__ == "__main__":  # pragma: no cover
+    raise SystemExit(main())

verifactu_validator/hash.py

@@ -0,0 +1,105 @@
+"""SHA-256 chained-hash builder per the AEAT Veri*Factu specification.
+
+The Veri*Factu regulation (RD 1007/2023) requires every invoice issued to be
+chained with the previous one through a SHA-256 hash. The hash is computed
+over a deterministic concatenation of:
+
+    previous_hash | issuer_nif | invoice_number | issue_date | total_amount
+
+separated by a vertical-bar delimiter to avoid any ambiguity (the official spec
+uses concatenation of "Campo=Valor&Campo=Valor"; we expose a stable simplified
+form sufficient for offline validation and Odoo integration, while keeping the
+underlying primitive — SHA-256 over a canonical string — identical).
+
+The first invoice in a chain uses ``previous_hash = "0" * 64``.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import re
+from datetime import date, datetime
+from decimal import Decimal, InvalidOperation
+
+_HEX64 = re.compile(r"^[0-9a-fA-F]{64}$")
+_FIELD_SEP = "|"
+
+
+def _normalize_date(value: str | date | datetime) -> str:
+    """Return YYYY-MM-DD form regardless of input type."""
+    if isinstance(value, (date, datetime)):
+        return value.strftime("%Y-%m-%d")
+    if isinstance(value, str):
+        v = value.strip()
+        # Accept either ISO YYYY-MM-DD or Spanish DD-MM-YYYY / DD/MM/YYYY.
+        for fmt in ("%Y-%m-%d", "%d-%m-%Y", "%d/%m/%Y"):
+            try:
+                return datetime.strptime(v, fmt).strftime("%Y-%m-%d")
+            except ValueError:
+                continue
+    raise ValueError(f"Unrecognized date value: {value!r}")
+
+
+def _normalize_amount(value: str | int | float | Decimal) -> str:
+    """Return amount as a canonical string with exactly 2 decimals."""
+    try:
+        if isinstance(value, Decimal):
+            d = value
+        else:
+            d = Decimal(str(value))
+    except (InvalidOperation, ValueError) as exc:
+        raise ValueError(f"Invalid amount: {value!r}") from exc
+    # Always 2 decimal places, dot as decimal separator, no thousand separators.
+    return f"{d:.2f}"
+
+
+def build_invoice_hash(
+    previous_hash: str,
+    issuer_nif: str,
+    invoice_number: str,
+    issue_date: str | date | datetime,
+    total_amount: str | int | float | Decimal,
+) -> str:
+    """Build the SHA-256 chained hash for one invoice.
+
+    Parameters
+    ----------
+    previous_hash:
+        Hex SHA-256 of the previous invoice in the chain. Use ``"0" * 64`` for
+        the first invoice.
+    issuer_nif:
+        Tax ID of the issuer (NIF / CIF / NIE), upper-cased.
+    invoice_number:
+        Invoice serial+number string (e.g. ``"F2026/0001"``).
+    issue_date:
+        Date of issue, ISO string or ``datetime`` / ``date``.
+    total_amount:
+        Invoice total with VAT, any numeric type or string.
+
+    Returns
+    -------
+    Lower-case hex SHA-256 (64 chars).
+    """
+    if not isinstance(previous_hash, str) or not _HEX64.match(previous_hash):
+        raise ValueError("previous_hash must be a 64-char hex SHA-256 string")
+
+    nif = (issuer_nif or "").strip().upper()
+    if not nif:
+        raise ValueError("issuer_nif is required")
+
+    number = (invoice_number or "").strip()
+    if not number:
+        raise ValueError("invoice_number is required")
+
+    iso_date = _normalize_date(issue_date)
+    amount = _normalize_amount(total_amount)
+
+    payload = _FIELD_SEP.join(
+        [previous_hash.lower(), nif, number, iso_date, amount]
+    )
+    return hashlib.sha256(payload.encode("utf-8")).hexdigest()
+
+
+def zero_hash() -> str:
+    """Convenience: the seed (all-zero) hash used for the first invoice."""
+    return "0" * 64

verifactu_validator/nif.py

@@ -0,0 +1,120 @@
+"""NIF / CIF / NIE checksum validation per Spanish AEAT spec.
+
+References
+----------
+- NIF (individuals): 8 digits + 1 control letter from table "TRWAGMYFPDXBNJZSQVHLCKE",
+  index = digits mod 23.
+- NIE (foreign residents): 1 prefix letter (X/Y/Z) + 7 digits + 1 control letter.
+  Prefix letter is mapped to a digit (X=0, Y=1, Z=2), then standard NIF formula.
+- CIF (legal entities, legacy but still used):
+  1 prefix letter (A-W) + 7 digits + 1 control char.
+  Control char is computed by:
+    1. Sum of digits in even positions (2,4,6).
+    2. For each digit in odd positions (1,3,5,7), double it and sum the digits of the
+       result; accumulate.
+    3. Add both sums, take last digit, subtract from 10 mod 10 -> control digit.
+    4. If prefix in "PQRSNW", control is a letter from "JABCDEFGHI" by index.
+       Otherwise, both control digit and the letter form are accepted.
+"""
+
+from __future__ import annotations
+
+import re
+
+_NIF_LETTERS = "TRWAGMYFPDXBNJZSQVHLCKE"
+_NIE_PREFIX_MAP = {"X": "0", "Y": "1", "Z": "2"}
+_CIF_LETTER_TABLE = "JABCDEFGHI"
+_CIF_LETTER_REQUIRED_PREFIXES = set("PQRSNW")
+_CIF_VALID_PREFIXES = set("ABCDEFGHJNPQRSUVW")
+
+_NIF_RE = re.compile(r"^\d{8}[A-Z]$")
+_NIE_RE = re.compile(r"^[XYZ]\d{7}[A-Z]$")
+_CIF_RE = re.compile(r"^[ABCDEFGHJNPQRSUVW]\d{7}[0-9A-J]$")
+
+
+def _normalize(value: str) -> str:
+    """Strip whitespace and upper-case the input."""
+    if not isinstance(value, str):
+        return ""
+    return value.strip().upper().replace("-", "").replace(" ", "")
+
+
+def validate_nif(value: str) -> bool:
+    """Validate a Spanish NIF (individual tax ID).
+
+    8 digits + 1 control letter. Returns False for NIE/CIF.
+    """
+    v = _normalize(value)
+    if not _NIF_RE.match(v):
+        return False
+    digits, letter = v[:8], v[8]
+    expected = _NIF_LETTERS[int(digits) % 23]
+    return letter == expected
+
+
+def validate_nie(value: str) -> bool:
+    """Validate a Spanish NIE (foreign resident tax ID).
+
+    Prefix in {X, Y, Z}, then 7 digits, then 1 control letter.
+    """
+    v = _normalize(value)
+    if not _NIE_RE.match(v):
+        return False
+    prefix, body, letter = v[0], v[1:8], v[8]
+    digits = _NIE_PREFIX_MAP[prefix] + body
+    expected = _NIF_LETTERS[int(digits) % 23]
+    return letter == expected
+
+
+def validate_cif(value: str) -> bool:
+    """Validate a Spanish CIF (legal-entity tax ID, legacy but still accepted).
+
+    Format: 1 prefix letter + 7 digits + 1 control char (digit or letter).
+    """
+    v = _normalize(value)
+    if not _CIF_RE.match(v):
+        return False
+    prefix, body, control = v[0], v[1:8], v[8]
+
+    if prefix not in _CIF_VALID_PREFIXES:
+        return False
+
+    # Sum even-position digits (1-indexed positions 2,4,6 => body indices 1,3,5)
+    even_sum = sum(int(body[i]) for i in (1, 3, 5))
+
+    # Sum the digits of (odd-position digit * 2)
+    odd_sum = 0
+    for i in (0, 2, 4, 6):
+        doubled = int(body[i]) * 2
+        odd_sum += (doubled // 10) + (doubled % 10)
+
+    total = even_sum + odd_sum
+    control_digit = (10 - (total % 10)) % 10
+    control_letter = _CIF_LETTER_TABLE[control_digit]
+
+    if prefix in _CIF_LETTER_REQUIRED_PREFIXES:
+        # Organizations whose CIF must end with a letter (e.g. PYMES, ayuntamientos).
+        return control == control_letter
+
+    if prefix in {"A", "B", "E", "H"}:
+        # Limited companies / sociedades anónimas: end with a digit.
+        return control.isdigit() and control == str(control_digit)
+
+    # Remaining prefixes accept either form.
+    if control.isdigit():
+        return control == str(control_digit)
+    return control == control_letter
+
+
+def validate_tax_id(value: str) -> bool:
+    """Validate any Spanish tax ID by auto-detecting NIF / NIE / CIF."""
+    v = _normalize(value)
+    if not v:
+        return False
+    if _NIF_RE.match(v):
+        return validate_nif(v)
+    if _NIE_RE.match(v):
+        return validate_nie(v)
+    if _CIF_RE.match(v):
+        return validate_cif(v)
+    return False

verifactu_validator/qr.py

@@ -0,0 +1,96 @@
+"""QR URL builder per AEAT Veri*Factu specification.
+
+Each Veri*Factu invoice PDF must embed a QR code whose payload is a URL
+pointing to the AEAT verification endpoint. The pre-production endpoint is::
+
+    https://prewww2.aeat.es/wlpl/TIKE-CONT/ValidarQR
+
+and the production endpoint is::
+
+    https://www2.agenciatributaria.gob.es/wlpl/TIKE-CONT/ValidarQR
+
+Query string parameters (all percent-encoded):
+
+    nif        Issuer tax ID (NIF / CIF / NIE)
+    numserie   Invoice serial+number
+    fecha      Issue date in Spanish format DD-MM-YYYY
+    importe    Total amount with 2 decimals and a dot separator
+"""
+
+from __future__ import annotations
+
+from datetime import date, datetime
+from decimal import Decimal, InvalidOperation
+from urllib.parse import quote
+
+_PROD_ENDPOINT = "https://www2.agenciatributaria.gob.es/wlpl/TIKE-CONT/ValidarQR"
+_PRE_ENDPOINT = "https://prewww2.aeat.es/wlpl/TIKE-CONT/ValidarQR"
+
+
+def _to_spanish_date(value: str | date | datetime) -> str:
+    """Return DD-MM-YYYY regardless of input type."""
+    if isinstance(value, (date, datetime)):
+        return value.strftime("%d-%m-%Y")
+    if isinstance(value, str):
+        v = value.strip()
+        for fmt in ("%Y-%m-%d", "%d-%m-%Y", "%d/%m/%Y"):
+            try:
+                return datetime.strptime(v, fmt).strftime("%d-%m-%Y")
+            except ValueError:
+                continue
+    raise ValueError(f"Unrecognized date value: {value!r}")
+
+
+def _to_amount(value: str | int | float | Decimal) -> str:
+    try:
+        d = value if isinstance(value, Decimal) else Decimal(str(value))
+    except (InvalidOperation, ValueError) as exc:
+        raise ValueError(f"Invalid amount: {value!r}") from exc
+    return f"{d:.2f}"
+
+
+def build_qr_url(
+    issuer_nif: str,
+    invoice_number: str,
+    issue_date: str | date | datetime,
+    total_amount: str | int | float | Decimal,
+    *,
+    production: bool = False,
+) -> str:
+    """Build the URL that goes inside the Veri*Factu QR code.
+
+    Parameters
+    ----------
+    issuer_nif:
+        Issuer tax ID.
+    invoice_number:
+        Invoice serial+number string (e.g. ``"F2026/0001"``).
+    issue_date:
+        Issue date (any common Spanish/ISO format).
+    total_amount:
+        Invoice total with VAT.
+    production:
+        If True, use the production AEAT endpoint; otherwise the
+        pre-production sandbox endpoint (default).
+    """
+    nif = (issuer_nif or "").strip().upper()
+    if not nif:
+        raise ValueError("issuer_nif is required")
+
+    number = (invoice_number or "").strip()
+    if not number:
+        raise ValueError("invoice_number is required")
+
+    fecha = _to_spanish_date(issue_date)
+    importe = _to_amount(total_amount)
+
+    endpoint = _PROD_ENDPOINT if production else _PRE_ENDPOINT
+
+    # quote with safe="" so '/' inside numserie gets percent-encoded as %2F.
+    qs = (
+        f"nif={quote(nif, safe='')}"
+        f"&numserie={quote(number, safe='')}"
+        f"&fecha={quote(fecha, safe='')}"
+        f"&importe={quote(importe, safe='')}"
+    )
+    return f"{endpoint}?{qs}"

verifactu_validator-0.1.0.dist-info/METADATA

@@ -0,0 +1,152 @@
+Metadata-Version: 2.4
+Name: verifactu-validator
+Version: 0.1.0
+Summary: Spanish e-invoice (Veri*Factu / AEAT) validator: NIF/CIF/NIE checksum, SHA-256 chained hash, and QR URL builder per Spanish Tax Agency spec.
+Author-email: FlexiGoTech <comercial@flexigobe.com>
+Maintainer-email: FlexiGoTech <comercial@flexigobe.com>
+License: MIT
+Project-URL: Homepage, https://flexigotech.com/verifactu
+Project-URL: Documentation, https://flexigotech.com/verifactu
+Project-URL: Repository, https://github.com/Flexigobe/verifactu-validator
+Project-URL: Bug Tracker, https://github.com/Flexigobe/verifactu-validator/issues
+Project-URL: Commercial Odoo Module, https://flexigotech.com/verifactu
+Keywords: aeat,verifactu,spain,einvoice,odoo,facturae,compliance,invoice,sii,tributaria
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Financial and Insurance Industry
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Office/Business :: Financial :: Accounting
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Natural Language :: Spanish
+Classifier: Natural Language :: English
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest>=7.4; extra == "dev"
+Requires-Dist: pytest-cov>=4.1; extra == "dev"
+Requires-Dist: ruff>=0.4; extra == "dev"
+Requires-Dist: build>=1.0; extra == "dev"
+Requires-Dist: twine>=4.0; extra == "dev"
+Dynamic: license-file
+
+# verifactu-validator — Spanish AEAT Veri*Factu Invoice Validator
+
+[![PyPI version](https://img.shields.io/pypi/v/verifactu-validator.svg)](https://pypi.org/project/verifactu-validator/)
+[![Python](https://img.shields.io/pypi/pyversions/verifactu-validator.svg)](https://pypi.org/project/verifactu-validator/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![CI](https://github.com/Flexigobe/verifactu-validator/actions/workflows/ci.yml/badge.svg)](https://github.com/Flexigobe/verifactu-validator/actions/workflows/ci.yml)
+
+> **Days until Veri\*Factu becomes mandatory: 29** (target date: **2026-07-01**)
+>
+> Spanish anti-fraud invoicing law (RD 1007/2023) requires every B2B/B2C invoice
+> issued in Spain to be signed with a chained SHA-256 hash and to embed a QR
+> code pointing to the AEAT verification endpoint.
+
+`verifactu-validator` is a tiny, **zero-dependency** Python library that lets you:
+
+1. Validate Spanish **NIF / CIF / NIE** identifiers (real checksum algorithm).
+2. Build the **SHA-256 chained hash** of an invoice exactly as the AEAT spec
+   requires (previous-hash + invoice fields, hex output).
+3. Build the **Veri\*Factu QR URL** pointing to the AEAT TIKE-CONT endpoint.
+4. Run a **CLI**: `verifactu validate invoice.xml` → prints OK/FAIL per rule.
+
+## Quick start
+
+```python
+from verifactu_validator import validate_nif, build_invoice_hash, build_qr_url
+
+# 1. Validate a Spanish tax ID
+assert validate_nif("12345678Z")            # individual NIF
+assert validate_nif("B12345678")            # company CIF (example)
+
+# 2. Build a chained SHA-256 hash (AEAT Veri*Factu spec)
+h = build_invoice_hash(
+    previous_hash="0" * 64,
+    issuer_nif="B12345678",
+    invoice_number="F2026/0001",
+    issue_date="2026-07-01",
+    total_amount="121.00",
+)
+
+# 3. Build the QR URL embedded in the printed invoice
+url = build_qr_url(
+    issuer_nif="B12345678",
+    invoice_number="F2026/0001",
+    issue_date="2026-07-01",
+    total_amount="121.00",
+)
+print(url)
+# https://prewww2.aeat.es/wlpl/TIKE-CONT/ValidarQR?nif=B12345678&numserie=F2026%2F0001&fecha=01-07-2026&importe=121.00
+```
+
+CLI usage:
+
+```bash
+verifactu --help
+verifactu validate path/to/invoice.xml
+verifactu nif 12345678Z
+verifactu hash --prev 000...0 --nif B12345678 --num F2026/0001 --date 2026-07-01 --total 121.00
+verifactu qr   --nif B12345678 --num F2026/0001 --date 2026-07-01 --total 121.00
+```
+
+## Why this library exists
+
+The Veri\*Factu mandate is the biggest compliance shake-up Spanish SMBs have
+seen in a decade. Most accounting / ERP teams need a **drop-in helper** to:
+
+- Pre-flight customer master data (NIF/CIF columns are full of typos).
+- Compute the chained hash before posting an invoice.
+- Generate the QR PNG that goes on the printed PDF.
+
+This library covers exactly that surface. It is **deliberately small** so it
+can be vendored, audited, and certified without pulling a giant dependency
+tree into your ERP.
+
+## Full Odoo module: €369 one-off
+
+This validator is the open-source nucleus of our commercial Odoo app:
+
+> **Veri\*Factu for Odoo 17 / 18 / 19** — full submission to AEAT,
+> chained hash storage, QR on every PDF report, audit log, declarative
+> re-send, multi-company, ready for July 2026.
+>
+> **€369 one-off — flexigotech.com/verifactu**
+
+If you just need the algorithms, this PyPI package is MIT-licensed and free
+forever. If you need the full ERP integration, buy the Odoo module.
+
+## Installation
+
+```bash
+pip install verifactu-validator
+```
+
+Requires Python **3.10+**. Zero runtime dependencies.
+
+## Publishing (for maintainers)
+
+```bash
+pip install build twine
+python -m build
+twine upload dist/*
+```
+
+A GitHub Actions workflow (`.github/workflows/ci.yml`) runs the test suite on
+every push and pull request.
+
+## License
+
+MIT © 2026 [FlexiGoTech](https://flexigotech.com)
+
+---
+
+Made by **FlexiGoTech** in Barcelona. We build Odoo App Store modules for
+Spanish, French, German and EU compliance: Veri\*Factu, France PDP,
+XRechnung, Whistleblowing, Mirakl/Decathlon connectors, AliExpress
+connector. See the full catalogue at [flexigotech.com](https://flexigotech.com).

verifactu_validator-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+verifactu_validator/__init__.py,sha256=16kBgGZMeKgupNmMsn0dTHftU4goqDXS3E70p0FgJEQ,870
+verifactu_validator/cli.py,sha256=O7DJX0_jCkV7AlSwu0xUOb-aRIgQ4HnJtXftwGPt4pA,6115
+verifactu_validator/hash.py,sha256=w384df_ZCFqotjyD_vVZ1uzvn7-WZJaSs3NqhxDZwE0,3552
+verifactu_validator/nif.py,sha256=9eYEgZxdTxBKJITqC6dxC21bb0j43dWkj88IuV0KfWw,3963
+verifactu_validator/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+verifactu_validator/qr.py,sha256=oW0wbeyVYrt9aZawDbV8oAJTwSzzz0s6OhavVLQpjJc,3055
+verifactu_validator-0.1.0.dist-info/licenses/LICENSE,sha256=KrYGeU_Ao46zJhsU4vmh-WrFtcXwm57R6PQ3RAz_hb0,1068
+verifactu_validator-0.1.0.dist-info/METADATA,sha256=Cv_miL5AYvjUylc7LO-lP1N1-F_mF1I32n1qvpxNF0w,5942
+verifactu_validator-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+verifactu_validator-0.1.0.dist-info/entry_points.txt,sha256=3xUMbZs0_5zR2ttmo2VIQgoIOx8LTlpGikygsUO1ZN4,59
+verifactu_validator-0.1.0.dist-info/top_level.txt,sha256=RiZZgBSIWRtPUXlWURrRCB0LlqsMhdEQOL0GLZTZqpM,20
+verifactu_validator-0.1.0.dist-info/RECORD,,

verifactu_validator-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

verifactu_validator-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+verifactu = verifactu_validator.cli:main

verifactu_validator-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 FlexiGoTech
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

verifactu_validator-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+verifactu_validator