trustrender 0.3.0__tar.gz → 0.3.2__tar.gz

{trustrender-0.3.0/src/trustrender.egg-info → trustrender-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: trustrender
-Version: 0.3.0
+Version: 0.3.2
 Summary: Validate and normalize Stripe, Shopify, and custom billing data for Factur-X/ZUGFeRD
 License-Expression: MIT
 Project-URL: Homepage, https://trustrender.dev
@@ -44,7 +44,7 @@ Dynamic: license-file
 
 Validate and normalize billing data from Stripe, Shopify, and custom systems before Factur-X/ZUGFeRD embedding.
 
-If you're bridging a non-compliant billing platform into EU e-invoicing, libraries like [factur-x](https://github.com/akretion/factur-x) and [drafthorse](https://github.com/pretix/python-drafthorse) assume your data is already correct. TrustRender catches arithmetic mismatches, field misalignment, missing required fields, and structural problems before compliant XML gets embedded.
+If you're bridging a non-compliant billing platform into EU e-invoicing, TrustRender adds a validation and normalization layer before tools like [factur-x](https://github.com/akretion/factur-x) and [drafthorse](https://github.com/pretix/python-drafthorse) generate or embed compliant XML. It catches arithmetic mismatches, field misalignment, missing required fields, and structural problems before handoff.
 
 ```
 pip install trustrender
@@ -141,6 +141,40 @@ else:
 - `normalizations`: field-level provenance (what was renamed, coerced, computed)
 - `zugferd_ready`: bool (if `zugferd=True`)
 
+## Stripe adapter
+
+Raw Stripe Invoice API responses use cents, Unix timestamps, and nested structures. The adapter handles all of it:
+
+```bash
+trustrender validate stripe_invoice.json --source stripe --zugferd
+```
+
+```python
+from trustrender import validate_invoice
+from trustrender.adapters import from_stripe
+
+result = validate_invoice(from_stripe(raw_stripe_response), zugferd=True)
+```
+
+The adapter converts cents to dollars, timestamps to dates, extracts line items from `lines.data[]`, and maps customer fields to recipient. Seller info is not included in Stripe invoices — TrustRender will flag it if required for ZUGFeRD compliance.
+
+## Shopify adapter
+
+Shopify orders use decimal strings, split customer names, and a different structure from invoices:
+
+```bash
+trustrender validate shopify_order.json --source shopify
+```
+
+```python
+from trustrender import validate_invoice
+from trustrender.adapters import from_shopify
+
+result = validate_invoice(from_shopify(raw_shopify_order))
+```
+
+The adapter parses string amounts to floats, combines first_name + last_name, maps order fields to invoice structure, and preserves structured address fields. Shopify orders have no seller info or due date — TrustRender handles both correctly.
+
 ## What it normalizes
 
 90+ vendor field aliases across QuickBooks, Xero, Stripe, and generic CSV/ERP formats:

{trustrender-0.3.0 → trustrender-0.3.2}/README.md

@@ -2,7 +2,7 @@
 
 Validate and normalize billing data from Stripe, Shopify, and custom systems before Factur-X/ZUGFeRD embedding.
 
-If you're bridging a non-compliant billing platform into EU e-invoicing, libraries like [factur-x](https://github.com/akretion/factur-x) and [drafthorse](https://github.com/pretix/python-drafthorse) assume your data is already correct. TrustRender catches arithmetic mismatches, field misalignment, missing required fields, and structural problems before compliant XML gets embedded.
+If you're bridging a non-compliant billing platform into EU e-invoicing, TrustRender adds a validation and normalization layer before tools like [factur-x](https://github.com/akretion/factur-x) and [drafthorse](https://github.com/pretix/python-drafthorse) generate or embed compliant XML. It catches arithmetic mismatches, field misalignment, missing required fields, and structural problems before handoff.
 
 ```
 pip install trustrender
@@ -99,6 +99,40 @@ else:
 - `normalizations`: field-level provenance (what was renamed, coerced, computed)
 - `zugferd_ready`: bool (if `zugferd=True`)
 
+## Stripe adapter
+
+Raw Stripe Invoice API responses use cents, Unix timestamps, and nested structures. The adapter handles all of it:
+
+```bash
+trustrender validate stripe_invoice.json --source stripe --zugferd
+```
+
+```python
+from trustrender import validate_invoice
+from trustrender.adapters import from_stripe
+
+result = validate_invoice(from_stripe(raw_stripe_response), zugferd=True)
+```
+
+The adapter converts cents to dollars, timestamps to dates, extracts line items from `lines.data[]`, and maps customer fields to recipient. Seller info is not included in Stripe invoices — TrustRender will flag it if required for ZUGFeRD compliance.
+
+## Shopify adapter
+
+Shopify orders use decimal strings, split customer names, and a different structure from invoices:
+
+```bash
+trustrender validate shopify_order.json --source shopify
+```
+
+```python
+from trustrender import validate_invoice
+from trustrender.adapters import from_shopify
+
+result = validate_invoice(from_shopify(raw_shopify_order))
+```
+
+The adapter parses string amounts to floats, combines first_name + last_name, maps order fields to invoice structure, and preserves structured address fields. Shopify orders have no seller info or due date — TrustRender handles both correctly.
+
 ## What it normalizes
 
 90+ vendor field aliases across QuickBooks, Xero, Stripe, and generic CSV/ERP formats:

{trustrender-0.3.0 → trustrender-0.3.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "trustrender"
-version = "0.3.0"
+version = "0.3.2"
 description = "Validate and normalize Stripe, Shopify, and custom billing data for Factur-X/ZUGFeRD"
 license = "MIT"
 classifiers = [

{trustrender-0.3.0 → trustrender-0.3.2}/src/trustrender/__init__.py

@@ -36,7 +36,7 @@ class RenderResult:
     trace_id: str | None = None
 
 
-__version__ = "0.3.0"
+__version__ = "0.3.2"
 
 __all__ = [
     # Core API (always available)

trustrender-0.3.2/src/trustrender/adapters/__init__.py

@@ -0,0 +1,15 @@
+"""Source adapters for common billing platforms.
+
+Convert raw API responses into the dict shape that
+ingest_invoice() and validate_invoice() already understand.
+
+Adapters are pure functions. No network, no filesystem,
+no side effects. They do minimal structural transformation
+and leave missing data missing — the validation pipeline
+catches what's wrong.
+"""
+
+from .stripe import from_stripe
+from .shopify import from_shopify
+
+__all__ = ["from_stripe", "from_shopify"]

trustrender-0.3.2/src/trustrender/adapters/shopify.py

@@ -0,0 +1,178 @@
+"""Shopify Order adapter.
+
+Converts a raw Shopify Admin API order response
+(GET /admin/api/2024-01/orders/{id}.json) into a dict that
+ingest_invoice() can normalize and validate.
+
+Shopify has orders, not invoices. This adapter maps order data
+to invoice-like structure for validation before e-invoice embedding.
+
+Key transformations:
+  - Amounts: decimal strings ("100.00") → floats
+  - Dates: ISO 8601 strings → YYYY-MM-DD
+  - Customer name: first_name + last_name → combined name string
+  - Line items: title → description, price (per-unit string) → unit_price (float)
+  - Line totals: computed as quantity × unit_price (Shopify doesn't always include them)
+  - Billing address: structured fields preserved for ZUGFeRD handoff
+  - Seller: NOT included in Shopify orders. Adapter leaves sender empty.
+    The validation pipeline will flag missing sender data — this is correct behavior.
+
+Usage::
+
+    from trustrender import validate_invoice
+    from trustrender.adapters import from_shopify
+
+    result = validate_invoice(from_shopify(raw_shopify_order))
+"""
+
+from __future__ import annotations
+
+
+def from_shopify(raw: dict) -> dict:
+    """Convert raw Shopify Order API response to ingest-ready dict.
+
+    Args:
+        raw: The full JSON response from GET /admin/api/.../orders/{id}.json.
+             Amounts are decimal strings. Currency is uppercase.
+
+    Returns:
+        A dict ready for ingest_invoice(). Not yet canonical,
+        not yet validated — just structurally bridged.
+
+    Raises:
+        ValueError: If raw is not a dict.
+    """
+    if not isinstance(raw, dict):
+        raise ValueError(f"from_shopify expects a dict, got {type(raw).__name__}")
+
+    out: dict = {}
+
+    # ── Order identity ───────────────────────────────────────────
+
+    # Shopify uses "name" ("#1001") or "order_number" (1001)
+    if "name" in raw:
+        out["invoice_number"] = str(raw["name"]).lstrip("#")
+    elif "order_number" in raw:
+        out["invoice_number"] = str(raw["order_number"])
+
+    if "created_at" in raw and isinstance(raw["created_at"], str):
+        out["invoice_date"] = raw["created_at"][:10]  # ISO 8601 → YYYY-MM-DD
+
+    # Shopify orders have no due_date — they are immediate payment
+
+    if "currency" in raw:
+        out["currency"] = raw["currency"]
+
+    # ── Amounts (strings → floats) ───────────────────────────────
+
+    for src, dst in [
+        ("subtotal_price", "subtotal"),
+        ("total_tax", "tax_amount"),
+        ("total_price", "total"),
+    ]:
+        val = raw.get(src)
+        if val is not None:
+            try:
+                out[dst] = float(val)
+            except (ValueError, TypeError):
+                pass
+
+    # ── Tax rate (from top-level tax_lines if available) ─────────
+
+    tax_lines = raw.get("tax_lines")
+    if isinstance(tax_lines, list) and len(tax_lines) == 1:
+        rate = tax_lines[0].get("rate")
+        if isinstance(rate, (int, float)):
+            out["tax_rate"] = rate
+
+    # ── Customer → recipient ─────────────────────────────────────
+
+    recipient: dict = {}
+
+    if isinstance(raw.get("customer"), dict):
+        cust = raw["customer"]
+        name_parts = []
+        if cust.get("first_name"):
+            name_parts.append(cust["first_name"])
+        if cust.get("last_name"):
+            name_parts.append(cust["last_name"])
+        if name_parts:
+            recipient["name"] = " ".join(name_parts)
+        if cust.get("email"):
+            recipient["email"] = cust["email"]
+
+    # Billing address
+    if isinstance(raw.get("billing_address"), dict):
+        addr = raw["billing_address"]
+        # Use billing_address.name as fallback for recipient name
+        if not recipient.get("name") and addr.get("name"):
+            recipient["name"] = addr["name"]
+        # Flatten to string for canonical address field
+        recipient["address"] = _flatten_address(addr)
+        # Preserve structured fields for ZUGFeRD handoff
+        if addr.get("city"):
+            recipient["city"] = addr["city"]
+        if addr.get("zip"):
+            recipient["postal_code"] = addr["zip"]
+        if addr.get("country_code"):
+            recipient["country"] = addr["country_code"]
+
+    if recipient:
+        out["recipient"] = recipient
+
+    # Seller is NOT available in Shopify order objects.
+    # The validation pipeline will flag this as blocked if sender.name is required.
+
+    # ── Line items ───────────────────────────────────────────────
+
+    if isinstance(raw.get("line_items"), list):
+        items = []
+        for li in raw["line_items"]:
+            if not isinstance(li, dict):
+                continue
+            item: dict = {}
+
+            if "title" in li:
+                item["description"] = li["title"]
+            if "quantity" in li:
+                item["quantity"] = li["quantity"]
+
+            # Price is per-unit, as a string
+            if "price" in li:
+                try:
+                    unit_price = float(li["price"])
+                    item["unit_price"] = unit_price
+                    # Compute line_total (Shopify doesn't always include it)
+                    if "quantity" in li:
+                        item["line_total"] = unit_price * li["quantity"]
+                except (ValueError, TypeError):
+                    pass
+
+            if item:
+                items.append(item)
+
+        if items:
+            out["items"] = items
+
+    return out
+
+
+def _flatten_address(addr: dict) -> str:
+    """Flatten Shopify address object into a single string."""
+    parts = []
+    if addr.get("address1"):
+        parts.append(addr["address1"])
+    if addr.get("address2"):
+        parts.append(addr["address2"])
+    city_parts = []
+    if addr.get("city"):
+        city_parts.append(addr["city"])
+    if addr.get("province"):
+        city_parts.append(addr["province"])
+    if addr.get("zip"):
+        city_parts.append(addr["zip"])
+    if city_parts:
+        parts.append(", ".join(city_parts))
+    if addr.get("country"):
+        parts.append(addr["country"])
+    return ", ".join(parts)

trustrender-0.3.2/src/trustrender/adapters/stripe.py

@@ -0,0 +1,172 @@
+"""Stripe Invoice adapter.
+
+Converts a raw Stripe Invoice API response (GET /v1/invoices/:id)
+into a dict that ingest_invoice() can normalize and validate.
+
+Key transformations:
+  - Amounts: cents (int) → dollars (float), divide by 100
+  - Dates: Unix timestamps (int) → YYYY-MM-DD strings
+  - Line items: extract from lines.data[], pull unit_amount from nested price object
+  - Customer: Stripe's customer is the buyer → maps to recipient
+  - Currency: lowercased in Stripe → uppercased for canonical
+  - Seller: NOT included in Stripe invoice objects. Adapter leaves sender empty.
+    The validation pipeline will flag missing sender data — this is correct behavior,
+    not a bug. Users must supply seller identity separately.
+
+Usage::
+
+    from trustrender import validate_invoice
+    from trustrender.adapters import from_stripe
+
+    result = validate_invoice(from_stripe(raw_stripe_response))
+"""
+
+from __future__ import annotations
+
+from datetime import datetime, timezone
+
+
+def from_stripe(raw: dict) -> dict:
+    """Convert raw Stripe Invoice API response to ingest-ready dict.
+
+    Args:
+        raw: The full JSON response from GET /v1/invoices/:id.
+             Amounts must be in cents (Stripe's native format).
+
+    Returns:
+        A dict ready for ingest_invoice(). Not yet canonical,
+        not yet validated — just structurally bridged.
+
+    Raises:
+        ValueError: If raw is not a dict.
+    """
+    if not isinstance(raw, dict):
+        raise ValueError(f"from_stripe expects a dict, got {type(raw).__name__}")
+
+    out: dict = {}
+
+    # ── Invoice identity ─────────────────────────────────────────
+
+    if "number" in raw:
+        out["invoice_number"] = raw["number"]
+
+    if "created" in raw and isinstance(raw["created"], (int, float)):
+        out["invoice_date"] = _unix_to_date(raw["created"])
+
+    if "due_date" in raw and isinstance(raw["due_date"], (int, float)):
+        out["due_date"] = _unix_to_date(raw["due_date"])
+
+    if "currency" in raw:
+        out["currency"] = raw["currency"].upper()
+
+    # ── Amounts (cents → dollars) ────────────────────────────────
+
+    if "subtotal" in raw and isinstance(raw["subtotal"], (int, float)):
+        out["subtotal"] = raw["subtotal"] / 100
+
+    if "tax" in raw and isinstance(raw["tax"], (int, float)):
+        out["tax_amount"] = raw["tax"] / 100
+
+    if "total" in raw and isinstance(raw["total"], (int, float)):
+        out["total"] = raw["total"] / 100
+
+    # ── Customer → recipient ─────────────────────────────────────
+    # Stripe's "customer" is the buyer. Maps to recipient, not sender.
+
+    recipient: dict = {}
+
+    if raw.get("customer_name"):
+        recipient["name"] = raw["customer_name"]
+    if raw.get("customer_email"):
+        recipient["email"] = raw["customer_email"]
+    if isinstance(raw.get("customer_address"), dict):
+        addr = raw["customer_address"]
+        # Flatten to string for the canonical address field
+        recipient["address"] = _flatten_address(addr)
+        # Preserve structured fields for ZUGFeRD XML generation
+        if addr.get("city"):
+            recipient["city"] = addr["city"]
+        if addr.get("postal_code"):
+            recipient["postal_code"] = addr["postal_code"]
+        if addr.get("country"):
+            recipient["country"] = addr["country"]
+
+    # Expanded customer object (if customer was expanded in the API call)
+    if isinstance(raw.get("customer"), dict):
+        cust = raw["customer"]
+        if not recipient.get("name") and cust.get("name"):
+            recipient["name"] = cust["name"]
+        if not recipient.get("email") and cust.get("email"):
+            recipient["email"] = cust["email"]
+
+    if recipient:
+        out["recipient"] = recipient
+
+    # Sender is NOT available in Stripe invoice objects.
+    # The validation pipeline will flag this as blocked if sender.name is required.
+    # This is intentional — users must supply seller identity separately.
+
+    # ── Line items ───────────────────────────────────────────────
+
+    lines_obj = raw.get("lines")
+    if isinstance(lines_obj, dict) and isinstance(lines_obj.get("data"), list):
+        items = []
+        for line in lines_obj["data"]:
+            if not isinstance(line, dict):
+                continue
+            item: dict = {}
+
+            if "description" in line:
+                item["description"] = line["description"]
+            if "quantity" in line and line["quantity"] is not None:
+                item["quantity"] = line["quantity"]
+
+            # unit_amount lives on the nested price object
+            price_obj = line.get("price")
+            if isinstance(price_obj, dict):
+                ua = price_obj.get("unit_amount")
+                if isinstance(ua, (int, float)):
+                    item["unit_price"] = ua / 100
+
+            # line-level amount (cents → dollars)
+            if "amount" in line and isinstance(line["amount"], (int, float)):
+                item["line_total"] = line["amount"] / 100
+
+            if item:
+                items.append(item)
+
+        if items:
+            out["items"] = items
+
+    # ── Metadata passthrough ─────────────────────────────────────
+
+    if isinstance(raw.get("metadata"), dict) and raw["metadata"]:
+        out["_metadata"] = raw["metadata"]
+
+    return out
+
+
+def _unix_to_date(ts: int | float) -> str:
+    """Convert Unix timestamp to YYYY-MM-DD string."""
+    return datetime.fromtimestamp(ts, tz=timezone.utc).strftime("%Y-%m-%d")
+
+
+def _flatten_address(addr: dict) -> str:
+    """Flatten Stripe address object into a single string."""
+    parts = []
+    if addr.get("line1"):
+        parts.append(addr["line1"])
+    if addr.get("line2"):
+        parts.append(addr["line2"])
+    city_state = []
+    if addr.get("city"):
+        city_state.append(addr["city"])
+    if addr.get("state"):
+        city_state.append(addr["state"])
+    if addr.get("postal_code"):
+        city_state.append(addr["postal_code"])
+    if city_state:
+        parts.append(", ".join(city_state))
+    if addr.get("country"):
+        parts.append(addr["country"])
+    return ", ".join(parts)

{trustrender-0.3.0 → trustrender-0.3.2}/src/trustrender/cli.py

@@ -62,6 +62,7 @@ def main(argv: list[str] | None = None) -> int:
     # ── Core: validation (no render deps required) ──
     validate_cmd = sub.add_parser("validate", help="Validate invoice data before Factur-X/ZUGFeRD embedding")
     validate_cmd.add_argument("data", help="Path to JSON invoice data (use '-' for stdin)")
+    validate_cmd.add_argument("--source", choices=["stripe", "shopify"], help="Apply source adapter before validation (e.g. --source stripe)")
     validate_cmd.add_argument("--zugferd", action="store_true", help="Run ZUGFeRD EN 16931 readiness checks")
     validate_cmd.add_argument("--format", choices=["text", "json"], default="text", dest="output_format", help="Output format (default: text)")
 
@@ -302,6 +303,15 @@ def _run_validate(args: argparse.Namespace) -> int:
         print(f"error: file not found: {args.data}", file=sys.stderr)
         return 1
 
+    # Apply source adapter if specified
+    if getattr(args, "source", None):
+        if args.source == "stripe":
+            from .adapters.stripe import from_stripe
+            raw = from_stripe(raw)
+        elif args.source == "shopify":
+            from .adapters.shopify import from_shopify
+            raw = from_shopify(raw)
+
     result = validate_invoice(raw, zugferd=args.zugferd)
 
     if args.output_format == "json":
@@ -877,6 +887,8 @@ def _run_audit(args: argparse.Namespace) -> int:
 
 def _run_baseline(args: argparse.Namespace) -> int:
     """Manage render baselines."""
+    from . import audit
+
     import json as json_mod
 
     if args.baseline_action is None:

{trustrender-0.3.0 → trustrender-0.3.2/src/trustrender.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: trustrender
-Version: 0.3.0
+Version: 0.3.2
 Summary: Validate and normalize Stripe, Shopify, and custom billing data for Factur-X/ZUGFeRD
 License-Expression: MIT
 Project-URL: Homepage, https://trustrender.dev
@@ -44,7 +44,7 @@ Dynamic: license-file
 
 Validate and normalize billing data from Stripe, Shopify, and custom systems before Factur-X/ZUGFeRD embedding.
 
-If you're bridging a non-compliant billing platform into EU e-invoicing, libraries like [factur-x](https://github.com/akretion/factur-x) and [drafthorse](https://github.com/pretix/python-drafthorse) assume your data is already correct. TrustRender catches arithmetic mismatches, field misalignment, missing required fields, and structural problems before compliant XML gets embedded.
+If you're bridging a non-compliant billing platform into EU e-invoicing, TrustRender adds a validation and normalization layer before tools like [factur-x](https://github.com/akretion/factur-x) and [drafthorse](https://github.com/pretix/python-drafthorse) generate or embed compliant XML. It catches arithmetic mismatches, field misalignment, missing required fields, and structural problems before handoff.
 
 ```
 pip install trustrender
@@ -141,6 +141,40 @@ else:
 - `normalizations`: field-level provenance (what was renamed, coerced, computed)
 - `zugferd_ready`: bool (if `zugferd=True`)
 
+## Stripe adapter
+
+Raw Stripe Invoice API responses use cents, Unix timestamps, and nested structures. The adapter handles all of it:
+
+```bash
+trustrender validate stripe_invoice.json --source stripe --zugferd
+```
+
+```python
+from trustrender import validate_invoice
+from trustrender.adapters import from_stripe
+
+result = validate_invoice(from_stripe(raw_stripe_response), zugferd=True)
+```
+
+The adapter converts cents to dollars, timestamps to dates, extracts line items from `lines.data[]`, and maps customer fields to recipient. Seller info is not included in Stripe invoices — TrustRender will flag it if required for ZUGFeRD compliance.
+
+## Shopify adapter
+
+Shopify orders use decimal strings, split customer names, and a different structure from invoices:
+
+```bash
+trustrender validate shopify_order.json --source shopify
+```
+
+```python
+from trustrender import validate_invoice
+from trustrender.adapters import from_shopify
+
+result = validate_invoice(from_shopify(raw_shopify_order))
+```
+
+The adapter parses string amounts to floats, combines first_name + last_name, maps order fields to invoice structure, and preserves structured address fields. Shopify orders have no seller info or due date — TrustRender handles both correctly.
+
 ## What it normalizes
 
 90+ vendor field aliases across QuickBooks, Xero, Stripe, and generic CSV/ERP formats:

{trustrender-0.3.0 → trustrender-0.3.2}/src/trustrender.egg-info/SOURCES.txt

@@ -27,6 +27,9 @@ src/trustrender.egg-info/dependency_links.txt
 src/trustrender.egg-info/entry_points.txt
 src/trustrender.egg-info/requires.txt
 src/trustrender.egg-info/top_level.txt
+src/trustrender/adapters/__init__.py
+src/trustrender/adapters/shopify.py
+src/trustrender/adapters/stripe.py
 src/trustrender/builtin_templates/einvoice.j2.typ
 src/trustrender/builtin_templates/einvoice_data.json
 src/trustrender/builtin_templates/invoice.j2.typ
@@ -50,6 +53,7 @@ src/trustrender/playground/index.html
 src/trustrender/playground/assets/index-Bsf6YnD1.css
 src/trustrender/playground/assets/index-C6K0JsLw.js
 src/trustrender/playground/assets/pdf.worker-C1breYqn.mjs
+tests/test_adapters.py
 tests/test_adversarial_corpus.py
 tests/test_audit_e2e.py
 tests/test_cli.py