openom-cli 0.1.2__tar.gz → 0.1.5__tar.gz

{openom_cli-0.1.2 → openom_cli-0.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: openom-cli
-Version: 0.1.2
+Version: 0.1.5
 Summary: openOM CLI - the `om` command over openom-core. Zero inference.
 Project-URL: Homepage, https://openom.app
 Project-URL: Documentation, https://openom.app/docs/

{openom_cli-0.1.2 → openom_cli-0.1.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "openom-cli"
-version = "0.1.2"
+version = "0.1.5"
 description = "openOM CLI - the `om` command over openom-core. Zero inference."
 readme = "README.md"
 requires-python = ">=3.11"

{openom_cli-0.1.2 → openom_cli-0.1.5}/src/openom_cli/buildout.py

@@ -1,207 +1,220 @@
-# SPDX-License-Identifier: MIT
-"""Deterministic Buildout listing -> openOM payload mapper (the connector->manifest bridge).
-
-Grounded in the REAL Buildout `get_listing` shape (nested ``core.research_property_attributes.*`` +
-``custom_fields.*`` + ``financials``). Pure + zero-inference: it normalizes names/units and omits
-anything absent - it never guesses. The human/CLI supplies the assertion identity (assertedBy,
-assertedDate, noiType, noiAsOfDate); those are never inferred from Buildout. The output is a schema-
-valid openOM payload ready for ``om embed-batch``.
-
-Note the two cap rates: ``cap_rate`` is Buildout's stated "Average CAP Rate" over the term (often
-absent); ``cap_rate_derived`` is current NOI/price. We map the derived one because it is what the
-openOM consistency check (NOI/price vs capRate) expects and what the OM's headline cap reflects.
-"""
-
-from __future__ import annotations
-
-from typing import Any
-
-NS = "https://openom.app/ns/0.1"
-
-
-def _num(v: Any) -> float | None:
-    try:
-        return float(str(v).replace(",", "").strip())
-    except (TypeError, ValueError):
-        return None
-
-
-def _int(v: Any) -> int | None:
-    n = _num(v)
-    return int(n) if n is not None else None
-
-
-def _pct_to_fraction(v: Any) -> float | None:
-    n = _num(v)
-    return round(n / 100, 6) if n is not None else None
-
-
-def _iso_date(mdy: Any) -> str | None:
-    """'10/1/2026' -> '2026-10-01'. Returns None if not an M/D/Y date."""
-    if not mdy:
-        return None
-    parts = str(mdy).strip().split("/")
-    if len(parts) != 3:
-        return None
-    try:
-        m, d, y = (int(p) for p in parts)
-    except ValueError:
-        return None
-    if not (1 <= m <= 12 and 1 <= d <= 31 and y > 1900):
-        return None
-    return f"{y:04d}-{m:02d}-{d:02d}"
-
-
-def _state_code(v: Any) -> str | None:
-    """'GA - Georgia' -> 'GA'; 'GA' -> 'GA'."""
-    if not v:
-        return None
-    head = str(v).split("-")[0].strip()
-    return head.upper() if len(head) == 2 else None
-
-
-def _lease_type(v: Any) -> str | None:
-    """Map Buildout's free-text lease type to the openOM asserted value."""
-    if not v:
-        return None
-    s = str(v).upper()
-    if "NNN" in s:
-        return "NNN"
-    if "NN" in s:
-        return "NN"
-    if "GROSS" in s:
-        return "gross"
-    return str(v)
-
-
-def _compact(d: dict[str, Any]) -> dict[str, Any]:
-    # drop absent values, incl. empty strings (schema forbids ""), but keep 0/0.0/False
-    return {k: v for k, v in d.items() if v not in (None, "", {}, [])}
-
-
-def _months_between(start_iso: str | None, end_iso: str | None) -> int | None:
-    """Whole months between two ISO (YYYY-MM-DD) dates, or None. Deterministic (no clock)."""
-    if not start_iso or not end_iso:
-        return None
-    try:
-        sy, sm, sd = (int(x) for x in start_iso.split("-"))
-        ey, em, ed = (int(x) for x in end_iso.split("-"))
-    except ValueError:
-        return None
-    months = (ey - sy) * 12 + (em - sm)
-    if ed < sd:  # a partial trailing month doesn't count
-        months -= 1
-    return months if months >= 0 else None
-
-
-# Canonical fields tracked for a back-catalog coverage report (the numbers a buyer underwrites).
-# Used to flag near-empty payloads before a bulk embed (Rule 6: review at scale).
-_COVERAGE_FIELDS: tuple[tuple[str, tuple[str, ...]], ...] = (
-    ("askingPrice", ("deal", "askingPrice")),
-    ("capRate", ("deal", "capRate")),
-    ("noi", ("deal", "noi")),
-    ("address", ("property", "address")),
-    ("buildingSF", ("property", "buildingSF")),
-    ("tenant", ("lease", "tenantEntity")),
-    ("leaseType", ("lease", "leaseTypeAsserted")),
-    ("expiration", ("lease", "expiration")),
-)
-
-
-def payload_coverage(payload: dict[str, Any]) -> dict[str, Any]:
-    """Which tracked fields a mapped payload actually carries - for a pre-embed coverage report."""
-    present: list[str] = []
-    missing: list[str] = []
-    for name, path in _COVERAGE_FIELDS:
-        cur: Any = payload
-        for seg in path:
-            cur = cur.get(seg) if isinstance(cur, dict) else None
-        (present if cur not in (None, "", {}, []) else missing).append(name)
-    return {
-        "filled": len(present), "of": len(_COVERAGE_FIELDS),
-        "present": present, "missing": missing,
-    }
-
-
-def listing_to_payload(
-    listing: dict[str, Any],
-    *,
-    asserted_by: dict[str, str],
-    asserted_date: str,
-    noi_type: str,
-    noi_as_of: str | None = None,
-) -> dict[str, Any]:
-    """Map one Buildout ``get_listing`` object to a schema-valid openOM payload (partial fields only
-    where Buildout has them). ``asserted_by``/``asserted_date``/``noi_type``/``noi_as_of`` are the
-    human's assertion identity and are stamped verbatim, never inferred."""
-    core: dict[str, Any] = listing.get("core", {})
-    cf: dict[str, Any] = listing.get("custom_fields", {})
-    fin: dict[str, Any] = listing.get("financials", {})
-
-    def rp(attr: str) -> Any:
-        return core.get(f"research_property_attributes.{attr}")
-
-    address = _compact({
-        "streetAddress": rp("address"),
-        "addressLocality": rp("city"),
-        "addressRegion": _state_code(rp("state")),
-        "postalCode": rp("zip"),
-        "addressCountry": "US" if str(rp("country_id")) == "1" else None,
-    })
-    lat, lng = _num(rp("latitude")), _num(rp("longitude"))
-    geo = {"latitude": lat, "longitude": lng} if lat is not None and lng is not None else None
-    lot = _num(rp("lot_size")) if str(rp("lot_size_units")).lower().startswith("acre") else None
-    building_sf = _int(rp("building_size"))
-    units = _int(rp("number_of_units"))
-    # propertyType ([M4]): the primary asset-class filter, trivially mappable and never auto-filled
-    # before. Buildout exposes it as a research attribute; omitted (never guessed) when absent.
-    prop_type = rp("property_type") or rp("property_sub_type") or cf.get("Property type")
-    property_ = _compact({
-        "propertyType": str(prop_type).strip().lower() if prop_type else None,
-        "address": address or None,
-        "geo": geo,
-        "buildingSF": building_sf,
-        "yearBuilt": _int(rp("year_built")),
-        "lotAcres": lot,
-        "units": units,
-        "occupancy": _pct_to_fraction(rp("occupancy_pct")),
-    })
-
-    price = _int(fin.get("sale_price"))
-    deal = _compact({
-        "askingPrice": price,
-        "capRate": _pct_to_fraction(fin.get("cap_rate_derived") or fin.get("cap_rate")),
-        "noi": _int(fin.get("noi") or cf.get("NOI")),
-        # Deterministically derived from mapped values ([M4]); not in Buildout, computed here.
-        "pricePerUnit": round(price / units) if price and units else None,
-        "pricePerSF": round(price / building_sf, 2) if price and building_sf else None,
-        "noiType": noi_type,
-        "noiAsOfDate": noi_as_of or asserted_date,
-        "status": "active",
-    })
-
-    commencement = _iso_date(cf.get("Lease start date"))
-    expiration = _iso_date(cf.get("Lease expiration date"))
-    guarantor_name = cf.get("Lease guarantor")
-    lease = _compact({
-        "tenantEntity": cf.get("Tenant"),
-        "leaseTypeAsserted": _lease_type(cf.get("Lease type")),
-        "commencement": commencement,
-        "expiration": expiration,
-        # termMonths ([M4]): derived from the two dates above, deterministic (no clock).
-        "termMonths": _months_between(commencement, expiration),
-        "guarantor": {"name": guarantor_name, "type": "corporate"} if guarantor_name else None,
-    })
-
-    return _compact({
-        "@context": ["https://schema.org", NS],
-        "@type": "RealEstateListing",
-        "specVersion": "0.1",
-        "assertedBy": _compact(dict(asserted_by)),
-        "assertedDate": asserted_date,
-        "property": property_ or None,
-        "deal": deal or None,
-        "lease": lease or None,
-        # A fresh assertion has no prior; a re-embed records supersedes = prior payload hash (core).
-        "meta": {"supersedes": None},
-    })
+# SPDX-License-Identifier: MIT
+"""Deterministic Buildout listing -> openOM payload mapper (the connector->manifest bridge).
+
+Grounded in the REAL Buildout `get_listing` shape (nested ``core.research_property_attributes.*`` +
+``custom_fields.*`` + ``financials``). Pure + zero-inference: it normalizes names/units and omits
+anything absent - it never guesses. The human/CLI supplies the assertion identity (assertedBy,
+assertedDate, noiType, noiAsOfDate); those are never inferred from Buildout. The output is a schema-
+valid openOM payload ready for ``om embed-batch``.
+
+Note the two cap rates: ``cap_rate`` is Buildout's stated "Average CAP Rate" over the term (often
+absent); ``cap_rate_derived`` is current NOI/price. We map the derived one because it is what the
+openOM consistency check (NOI/price vs capRate) expects and what the OM's headline cap reflects.
+"""
+
+from __future__ import annotations
+
+import math
+from typing import Any
+
+NS = "https://openom.app/ns/0.1"
+
+
+def _num(v: Any) -> float | None:
+    try:
+        n = float(str(v).replace(",", "").strip())
+    except (TypeError, ValueError):
+        return None
+    # A non-finite cell (1e400 / inf / nan) is omitted, not propagated - mirrors the JS connector's
+    # Number.isFinite guard and stops _int() raising OverflowError (which aborted the batch).
+    return n if math.isfinite(n) else None
+
+
+def _int(v: Any) -> int | None:
+    n = _num(v)
+    return int(n) if n is not None else None
+
+
+def _round_half_up(x: float, ndigits: int = 0) -> float:
+    # Match JS Math.round(x*m)/m EXACTLY (half-UP), not Python's banker's round(): the derived facts
+    # (pricePerUnit/pricePerSF/pctToFraction) must be byte-identical across the CLI mapper and the
+    # JS connector - a .5 tie is where round()-half-even and Math.round-half-up silently forked. All
+    # mapper inputs are positive, so floor(x*m + 0.5)/m == Math.round(x*m)/m.
+    m: int = 10**ndigits
+    return float(math.floor(x * m + 0.5)) / m
+
+
+def _pct_to_fraction(v: Any) -> float | None:
+    n = _num(v)
+    return _round_half_up(n / 100, 6) if n is not None else None
+
+
+def _iso_date(mdy: Any) -> str | None:
+    """'10/1/2026' -> '2026-10-01'. Returns None if not an M/D/Y date."""
+    if not mdy:
+        return None
+    parts = str(mdy).strip().split("/")
+    if len(parts) != 3:
+        return None
+    try:
+        m, d, y = (int(p) for p in parts)
+    except ValueError:
+        return None
+    if not (1 <= m <= 12 and 1 <= d <= 31 and y > 1900):
+        return None
+    return f"{y:04d}-{m:02d}-{d:02d}"
+
+
+def _state_code(v: Any) -> str | None:
+    """'GA - Georgia' -> 'GA'; 'GA' -> 'GA'."""
+    if not v:
+        return None
+    head = str(v).split("-")[0].strip()
+    return head.upper() if len(head) == 2 else None
+
+
+def _lease_type(v: Any) -> str | None:
+    """Map Buildout's free-text lease type to the openOM asserted value."""
+    if not v:
+        return None
+    s = str(v).upper()
+    if "NNN" in s:
+        return "NNN"
+    if "NN" in s:
+        return "NN"
+    if "GROSS" in s:
+        return "gross"
+    return str(v)
+
+
+def _compact(d: dict[str, Any]) -> dict[str, Any]:
+    # drop absent values, incl. empty strings (schema forbids ""), but keep 0/0.0/False
+    return {k: v for k, v in d.items() if v not in (None, "", {}, [])}
+
+
+def _months_between(start_iso: str | None, end_iso: str | None) -> int | None:
+    """Whole months between two ISO (YYYY-MM-DD) dates, or None. Deterministic (no clock)."""
+    if not start_iso or not end_iso:
+        return None
+    try:
+        sy, sm, sd = (int(x) for x in start_iso.split("-"))
+        ey, em, ed = (int(x) for x in end_iso.split("-"))
+    except ValueError:
+        return None
+    months = (ey - sy) * 12 + (em - sm)
+    if ed < sd:  # a partial trailing month doesn't count
+        months -= 1
+    return months if months >= 0 else None
+
+
+# Canonical fields tracked for a back-catalog coverage report (the numbers a buyer underwrites).
+# Used to flag near-empty payloads before a bulk embed (Rule 6: review at scale).
+_COVERAGE_FIELDS: tuple[tuple[str, tuple[str, ...]], ...] = (
+    ("askingPrice", ("deal", "askingPrice")),
+    ("capRate", ("deal", "capRate")),
+    ("noi", ("deal", "noi")),
+    ("address", ("property", "address")),
+    ("buildingSF", ("property", "buildingSF")),
+    ("tenant", ("lease", "tenantEntity")),
+    ("leaseType", ("lease", "leaseTypeAsserted")),
+    ("expiration", ("lease", "expiration")),
+)
+
+
+def payload_coverage(payload: dict[str, Any]) -> dict[str, Any]:
+    """Which tracked fields a mapped payload actually carries - for a pre-embed coverage report."""
+    present: list[str] = []
+    missing: list[str] = []
+    for name, path in _COVERAGE_FIELDS:
+        cur: Any = payload
+        for seg in path:
+            cur = cur.get(seg) if isinstance(cur, dict) else None
+        (present if cur not in (None, "", {}, []) else missing).append(name)
+    return {
+        "filled": len(present), "of": len(_COVERAGE_FIELDS),
+        "present": present, "missing": missing,
+    }
+
+
+def listing_to_payload(
+    listing: dict[str, Any],
+    *,
+    asserted_by: dict[str, str],
+    asserted_date: str,
+    noi_type: str,
+    noi_as_of: str | None = None,
+) -> dict[str, Any]:
+    """Map one Buildout ``get_listing`` object to a schema-valid openOM payload (partial fields only
+    where Buildout has them). ``asserted_by``/``asserted_date``/``noi_type``/``noi_as_of`` are the
+    human's assertion identity and are stamped verbatim, never inferred."""
+    core: dict[str, Any] = listing.get("core", {})
+    cf: dict[str, Any] = listing.get("custom_fields", {})
+    fin: dict[str, Any] = listing.get("financials", {})
+
+    def rp(attr: str) -> Any:
+        return core.get(f"research_property_attributes.{attr}")
+
+    address = _compact({
+        "streetAddress": rp("address"),
+        "addressLocality": rp("city"),
+        "addressRegion": _state_code(rp("state")),
+        "postalCode": rp("zip"),
+        "addressCountry": "US" if str(rp("country_id")) == "1" else None,
+    })
+    lat, lng = _num(rp("latitude")), _num(rp("longitude"))
+    geo = {"latitude": lat, "longitude": lng} if lat is not None and lng is not None else None
+    lot = _num(rp("lot_size")) if str(rp("lot_size_units")).lower().startswith("acre") else None
+    building_sf = _int(rp("building_size"))
+    units = _int(rp("number_of_units"))
+    # propertyType ([M4]): the primary asset-class filter, trivially mappable and never auto-filled
+    # before. Buildout exposes it as a research attribute; omitted (never guessed) when absent.
+    prop_type = rp("property_type") or rp("property_sub_type") or cf.get("Property type")
+    property_ = _compact({
+        "propertyType": str(prop_type).strip().lower() if prop_type else None,
+        "address": address or None,
+        "geo": geo,
+        "buildingSF": building_sf,
+        "yearBuilt": _int(rp("year_built")),
+        "lotAcres": lot,
+        "units": units,
+        "occupancy": _pct_to_fraction(rp("occupancy_pct")),
+    })
+
+    price = _int(fin.get("sale_price"))
+    deal = _compact({
+        "askingPrice": price,
+        "capRate": _pct_to_fraction(fin.get("cap_rate_derived") or fin.get("cap_rate")),
+        "noi": _int(fin.get("noi") or cf.get("NOI")),
+        # Deterministically derived from mapped values ([M4]); not in Buildout, computed here.
+        "pricePerUnit": int(_round_half_up(price / units)) if price and units else None,
+        "pricePerSF": _round_half_up(price / building_sf, 2) if price and building_sf else None,
+        "noiType": noi_type,
+        "noiAsOfDate": noi_as_of or asserted_date,
+        "status": "active",
+    })
+
+    commencement = _iso_date(cf.get("Lease start date"))
+    expiration = _iso_date(cf.get("Lease expiration date"))
+    guarantor_name = cf.get("Lease guarantor")
+    lease = _compact({
+        "tenantEntity": cf.get("Tenant"),
+        "leaseTypeAsserted": _lease_type(cf.get("Lease type")),
+        "commencement": commencement,
+        "expiration": expiration,
+        # termMonths ([M4]): derived from the two dates above, deterministic (no clock).
+        "termMonths": _months_between(commencement, expiration),
+        "guarantor": {"name": guarantor_name, "type": "corporate"} if guarantor_name else None,
+    })
+
+    return _compact({
+        "@context": ["https://schema.org", NS],
+        "@type": "RealEstateListing",
+        "specVersion": "0.1",
+        "assertedBy": _compact(dict(asserted_by)),
+        "assertedDate": asserted_date,
+        "property": property_ or None,
+        "deal": deal or None,
+        "lease": lease or None,
+        # A fresh assertion has no prior; a re-embed records supersedes = prior payload hash (core).
+        "meta": {"supersedes": None},
+    })

{openom_cli-0.1.2 → openom_cli-0.1.5}/src/openom_cli/csv_map.py

@@ -1,171 +1,172 @@
-# SPDX-License-Identifier: MIT
-"""Deterministic CSV row -> openOM payload mapper (the spreadsheet on-ramp for bulk seeding).
-
-A broker with a back catalog usually has a spreadsheet + a folder of PDFs, not Buildout JSON. This
-maps one CSV row (a documented canonical column set) to a schema-valid openOM payload, ready for
-``om embed-batch`` - the same output shape as the Buildout bridge, different input. Pure + zero
-inference: every value comes from the broker's own cell (that IS the assertion); absent cells are
-omitted, never guessed. The assertion identity (assertedBy / assertedDate / noiType / noiAsOfDate)
-is supplied by the caller and stamped verbatim.
-
-Numeric/date/state normalization reuses the SAME helpers as the Buildout mapper, so a number, a
-percent, or an M/D/Y date maps identically on both on-ramps. Percentage columns are named ``*Pct``
-(e.g. ``capRatePct`` = 6.25, not 0.0625) so a non-technical broker can't misread the unit.
-"""
-
-from __future__ import annotations
-
-import csv
-import io
-from collections.abc import Mapping
-from typing import Any
-
-from .buildout import (
-    NS,
-    _compact,
-    _int,
-    _iso_date,
-    _lease_type,
-    _months_between,
-    _num,
-    _pct_to_fraction,
-    _state_code,
-)
-
-# The canonical header vocabulary a broker fills in. Order is the template's column order. Every
-# column is optional except that a row must name its PDF (an ``id`` -> <id>.pdf, or an explicit
-# ``pdf`` filename) and produce a schema-valid payload. ``*Pct`` columns are percentages.
-CANONICAL_COLUMNS: tuple[str, ...] = (
-    "id", "pdf",
-    "broker", "brokerage", "license", "noiType", "noiAsOfDate",
-    "streetAddress", "city", "state", "postalCode", "country",
-    "propertyType", "buildingSF", "yearBuilt", "lotAcres", "units", "occupancyPct",
-    "latitude", "longitude",
-    "askingPrice", "capRatePct", "noi", "status",
-    "tenant", "leaseType", "commencement", "expiration", "guarantor",
-)
-
-# Per-row overrides of the assertion identity (a catalog can span brokers / NOI types).
-_OVERRIDE_COLUMNS: tuple[str, ...] = ("broker", "brokerage", "license", "noiType", "noiAsOfDate")
-
-_EXAMPLE_ROW: dict[str, str] = {
-    "id": "123-main", "pdf": "123-main.pdf",
-    "streetAddress": "123 Main St", "city": "Austin", "state": "TX", "postalCode": "78701",
-    "propertyType": "retail", "buildingSF": "9100", "yearBuilt": "2019",
-    "askingPrice": "1850000", "capRatePct": "6.25", "noi": "115625",
-    "tenant": "Example Retail, LLC", "leaseType": "NNN",
-    "commencement": "5/1/2019", "expiration": "4/30/2034",
-}
-
-
-def _cell(row: Mapping[str, str], key: str) -> str | None:
-    """A trimmed cell value, or None when the column is absent/blank (so _compact drops it)."""
-    v = row.get(key)
-    if v is None:
-        return None
-    s = str(v).strip()
-    return s or None
-
-
-def _date(v: str | None) -> str | None:
-    """Accept either an ISO date (pass-through) or an M/D/Y spreadsheet date."""
-    if not v:
-        return None
-    s = str(v).strip()
-    parts = s.split("-")
-    if len(parts) == 3 and len(parts[0]) == 4:  # already ISO-ish -> validate via round-trip
-        try:
-            y, m, d = (int(p) for p in parts)
-        except ValueError:
-            return None
-        if 1 <= m <= 12 and 1 <= d <= 31 and y > 1900:
-            return f"{y:04d}-{m:02d}-{d:02d}"
-        return None
-    return _iso_date(s)
-
-
-def override_identity(row: Mapping[str, str]) -> dict[str, str]:
-    """The per-row assertion-identity overrides present in this row (subset of the override set)."""
-    return {k: v for k in _OVERRIDE_COLUMNS if (v := _cell(row, k)) is not None}
-
-
-def row_to_payload(
-    row: Mapping[str, str],
-    *,
-    asserted_by: dict[str, str],
-    asserted_date: str,
-    noi_type: str,
-    noi_as_of: str | None = None,
-) -> dict[str, Any]:
-    """Map one canonical CSV row to a schema-valid openOM payload (only the fields the row carries).
-    ``asserted_by``/``asserted_date``/``noi_type``/``noi_as_of`` are the assertion identity and are
-    stamped verbatim, never inferred from the row."""
-    address = _compact({
-        "streetAddress": _cell(row, "streetAddress"),
-        "addressLocality": _cell(row, "city"),
-        "addressRegion": _state_code(_cell(row, "state")),
-        "postalCode": _cell(row, "postalCode"),
-        "addressCountry": _cell(row, "country") or ("US" if _cell(row, "state") else None),
-    })
-    lat, lng = _num(_cell(row, "latitude")), _num(_cell(row, "longitude"))
-    geo = {"latitude": lat, "longitude": lng} if lat is not None and lng is not None else None
-    building_sf = _int(_cell(row, "buildingSF"))
-    units = _int(_cell(row, "units"))
-    prop_type = _cell(row, "propertyType")
-    property_ = _compact({
-        "propertyType": prop_type.lower() if prop_type else None,
-        "address": address or None,
-        "geo": geo,
-        "buildingSF": building_sf,
-        "yearBuilt": _int(_cell(row, "yearBuilt")),
-        "lotAcres": _num(_cell(row, "lotAcres")),
-        "units": units,
-        "occupancy": _pct_to_fraction(_cell(row, "occupancyPct")),
-    })
-
-    price = _int(_cell(row, "askingPrice"))
-    deal = _compact({
-        "askingPrice": price,
-        "capRate": _pct_to_fraction(_cell(row, "capRatePct")),
-        "noi": _int(_cell(row, "noi")),
-        "pricePerUnit": round(price / units) if price and units else None,
-        "pricePerSF": round(price / building_sf, 2) if price and building_sf else None,
-        "noiType": noi_type,
-        "noiAsOfDate": noi_as_of or asserted_date,
-        "status": _cell(row, "status") or "active",
-    })
-
-    commencement = _date(_cell(row, "commencement"))
-    expiration = _date(_cell(row, "expiration"))
-    guarantor_name = _cell(row, "guarantor")
-    lease = _compact({
-        "tenantEntity": _cell(row, "tenant"),
-        "leaseTypeAsserted": _lease_type(_cell(row, "leaseType")),
-        "commencement": commencement,
-        "expiration": expiration,
-        "termMonths": _months_between(commencement, expiration),
-        "guarantor": {"name": guarantor_name, "type": "corporate"} if guarantor_name else None,
-    })
-
-    return _compact({
-        "@context": ["https://schema.org", NS],
-        "@type": "RealEstateListing",
-        "specVersion": "0.1",
-        "assertedBy": _compact(dict(asserted_by)),
-        "assertedDate": asserted_date,
-        "property": property_ or None,
-        "deal": deal or None,
-        "lease": lease or None,
-        "meta": {"supersedes": None},
-    })
-
-
-def template_csv() -> str:
-    """A blank template: the canonical header row + one worked example, so a broker knows exactly
-    what to fill in. Assertion identity (broker/brokerage/license/noiType) normally comes from the
-    command flags; the columns exist only for a catalog that spans brokers."""
-    buf = io.StringIO()
-    writer = csv.writer(buf, lineterminator="\n")  # csv.writer quotes cells containing commas
-    writer.writerow(CANONICAL_COLUMNS)
-    writer.writerow([_EXAMPLE_ROW.get(c, "") for c in CANONICAL_COLUMNS])
-    return buf.getvalue()
+# SPDX-License-Identifier: MIT
+"""Deterministic CSV row -> openOM payload mapper (the spreadsheet on-ramp for bulk seeding).
+
+A broker with a back catalog usually has a spreadsheet + a folder of PDFs, not Buildout JSON. This
+maps one CSV row (a documented canonical column set) to a schema-valid openOM payload, ready for
+``om embed-batch`` - the same output shape as the Buildout bridge, different input. Pure + zero
+inference: every value comes from the broker's own cell (that IS the assertion); absent cells are
+omitted, never guessed. The assertion identity (assertedBy / assertedDate / noiType / noiAsOfDate)
+is supplied by the caller and stamped verbatim.
+
+Numeric/date/state normalization reuses the SAME helpers as the Buildout mapper, so a number, a
+percent, or an M/D/Y date maps identically on both on-ramps. Percentage columns are named ``*Pct``
+(e.g. ``capRatePct`` = 6.25, not 0.0625) so a non-technical broker can't misread the unit.
+"""
+
+from __future__ import annotations
+
+import csv
+import io
+from collections.abc import Mapping
+from typing import Any
+
+from .buildout import (
+    NS,
+    _compact,
+    _int,
+    _iso_date,
+    _lease_type,
+    _months_between,
+    _num,
+    _pct_to_fraction,
+    _round_half_up,
+    _state_code,
+)
+
+# The canonical header vocabulary a broker fills in. Order is the template's column order. Every
+# column is optional except that a row must name its PDF (an ``id`` -> <id>.pdf, or an explicit
+# ``pdf`` filename) and produce a schema-valid payload. ``*Pct`` columns are percentages.
+CANONICAL_COLUMNS: tuple[str, ...] = (
+    "id", "pdf",
+    "broker", "brokerage", "license", "noiType", "noiAsOfDate",
+    "streetAddress", "city", "state", "postalCode", "country",
+    "propertyType", "buildingSF", "yearBuilt", "lotAcres", "units", "occupancyPct",
+    "latitude", "longitude",
+    "askingPrice", "capRatePct", "noi", "status",
+    "tenant", "leaseType", "commencement", "expiration", "guarantor",
+)
+
+# Per-row overrides of the assertion identity (a catalog can span brokers / NOI types).
+_OVERRIDE_COLUMNS: tuple[str, ...] = ("broker", "brokerage", "license", "noiType", "noiAsOfDate")
+
+_EXAMPLE_ROW: dict[str, str] = {
+    "id": "123-main", "pdf": "123-main.pdf",
+    "streetAddress": "123 Main St", "city": "Austin", "state": "TX", "postalCode": "78701",
+    "propertyType": "retail", "buildingSF": "9100", "yearBuilt": "2019",
+    "askingPrice": "1850000", "capRatePct": "6.25", "noi": "115625",
+    "tenant": "Example Retail, LLC", "leaseType": "NNN",
+    "commencement": "5/1/2019", "expiration": "4/30/2034",
+}
+
+
+def _cell(row: Mapping[str, str], key: str) -> str | None:
+    """A trimmed cell value, or None when the column is absent/blank (so _compact drops it)."""
+    v = row.get(key)
+    if v is None:
+        return None
+    s = str(v).strip()
+    return s or None
+
+
+def _date(v: str | None) -> str | None:
+    """Accept either an ISO date (pass-through) or an M/D/Y spreadsheet date."""
+    if not v:
+        return None
+    s = str(v).strip()
+    parts = s.split("-")
+    if len(parts) == 3 and len(parts[0]) == 4:  # already ISO-ish -> validate via round-trip
+        try:
+            y, m, d = (int(p) for p in parts)
+        except ValueError:
+            return None
+        if 1 <= m <= 12 and 1 <= d <= 31 and y > 1900:
+            return f"{y:04d}-{m:02d}-{d:02d}"
+        return None
+    return _iso_date(s)
+
+
+def override_identity(row: Mapping[str, str]) -> dict[str, str]:
+    """The per-row assertion-identity overrides present in this row (subset of the override set)."""
+    return {k: v for k in _OVERRIDE_COLUMNS if (v := _cell(row, k)) is not None}
+
+
+def row_to_payload(
+    row: Mapping[str, str],
+    *,
+    asserted_by: dict[str, str],
+    asserted_date: str,
+    noi_type: str,
+    noi_as_of: str | None = None,
+) -> dict[str, Any]:
+    """Map one canonical CSV row to a schema-valid openOM payload (only the fields the row carries).
+    ``asserted_by``/``asserted_date``/``noi_type``/``noi_as_of`` are the assertion identity and are
+    stamped verbatim, never inferred from the row."""
+    address = _compact({
+        "streetAddress": _cell(row, "streetAddress"),
+        "addressLocality": _cell(row, "city"),
+        "addressRegion": _state_code(_cell(row, "state")),
+        "postalCode": _cell(row, "postalCode"),
+        "addressCountry": _cell(row, "country") or ("US" if _cell(row, "state") else None),
+    })
+    lat, lng = _num(_cell(row, "latitude")), _num(_cell(row, "longitude"))
+    geo = {"latitude": lat, "longitude": lng} if lat is not None and lng is not None else None
+    building_sf = _int(_cell(row, "buildingSF"))
+    units = _int(_cell(row, "units"))
+    prop_type = _cell(row, "propertyType")
+    property_ = _compact({
+        "propertyType": prop_type.lower() if prop_type else None,
+        "address": address or None,
+        "geo": geo,
+        "buildingSF": building_sf,
+        "yearBuilt": _int(_cell(row, "yearBuilt")),
+        "lotAcres": _num(_cell(row, "lotAcres")),
+        "units": units,
+        "occupancy": _pct_to_fraction(_cell(row, "occupancyPct")),
+    })
+
+    price = _int(_cell(row, "askingPrice"))
+    deal = _compact({
+        "askingPrice": price,
+        "capRate": _pct_to_fraction(_cell(row, "capRatePct")),
+        "noi": _int(_cell(row, "noi")),
+        "pricePerUnit": int(_round_half_up(price / units)) if price and units else None,
+        "pricePerSF": _round_half_up(price / building_sf, 2) if price and building_sf else None,
+        "noiType": noi_type,
+        "noiAsOfDate": noi_as_of or asserted_date,
+        "status": _cell(row, "status") or "active",
+    })
+
+    commencement = _date(_cell(row, "commencement"))
+    expiration = _date(_cell(row, "expiration"))
+    guarantor_name = _cell(row, "guarantor")
+    lease = _compact({
+        "tenantEntity": _cell(row, "tenant"),
+        "leaseTypeAsserted": _lease_type(_cell(row, "leaseType")),
+        "commencement": commencement,
+        "expiration": expiration,
+        "termMonths": _months_between(commencement, expiration),
+        "guarantor": {"name": guarantor_name, "type": "corporate"} if guarantor_name else None,
+    })
+
+    return _compact({
+        "@context": ["https://schema.org", NS],
+        "@type": "RealEstateListing",
+        "specVersion": "0.1",
+        "assertedBy": _compact(dict(asserted_by)),
+        "assertedDate": asserted_date,
+        "property": property_ or None,
+        "deal": deal or None,
+        "lease": lease or None,
+        "meta": {"supersedes": None},
+    })
+
+
+def template_csv() -> str:
+    """A blank template: the canonical header row + one worked example, so a broker knows exactly
+    what to fill in. Assertion identity (broker/brokerage/license/noiType) normally comes from the
+    command flags; the columns exist only for a catalog that spans brokers."""
+    buf = io.StringIO()
+    writer = csv.writer(buf, lineterminator="\n")  # csv.writer quotes cells containing commas
+    writer.writerow(CANONICAL_COLUMNS)
+    writer.writerow([_EXAMPLE_ROW.get(c, "") for c in CANONICAL_COLUMNS])
+    return buf.getvalue()

{openom_cli-0.1.2 → openom_cli-0.1.5}/src/openom_cli/main.py

@@ -35,7 +35,12 @@ from openom_core.embed import embed as _embed
 from openom_core.embed import input_encrypted as _input_encrypted
 from openom_core.embed import read as _read
 from openom_core.embed import reembed_warnings as _reembed_warnings
-from openom_core.errors import CanonicalizationError, PayloadTooLargeError, SignedEmbedError
+from openom_core.errors import (
+    CanonicalizationError,
+    EncryptedPdfError,
+    PayloadTooLargeError,
+    SignedEmbedError,
+)
 from openom_core.images import extract_images as _extract_images
 from openom_core.inspect import inspect as _inspect
 from openom_core.text import extract_text as _extract_text
@@ -90,7 +95,9 @@ _DATA_ERRORS = (
     CanonicalizationError,
     PayloadTooLargeError,
     SignedEmbedError,
+    EncryptedPdfError,  # password-protected PDF (OM-IO-011): clean refusal, never a traceback
     json.JSONDecodeError,
+    pikepdf.PasswordError,  # a password error also leaks a BytesIO repr; map it cleanly
     pikepdf.PdfError,
     FileNotFoundError,
     UnicodeDecodeError,
@@ -106,6 +113,14 @@ def _guard(fn: _F) -> _F:
             return fn(*args, **kwargs)
         except typer.Exit:
             raise
+        except (pikepdf.PdfError, pikepdf.PasswordError) as exc:
+            # pikepdf's message leaks the input BytesIO repr + memory address and carries no code;
+            # emit a stable OM-IO-010 (a password error is already mapped to OM-IO-011 above it).
+            pw = isinstance(exc, pikepdf.PasswordError)
+            pcode = "OM-IO-011" if pw else "OM-IO-010"
+            msg = "password-protected PDF" if pw else "malformed or unreadable PDF"
+            typer.echo(f"error: {pcode}: {msg}", err=True)
+            raise typer.Exit(3) from exc
         except _DATA_ERRORS as exc:
             code = getattr(exc, "code", None)
             typer.echo(f"error: {f'{code}: ' if code else ''}{exc}", err=True)
@@ -197,8 +212,17 @@ def _load_json(path: Path) -> dict[str, Any]:
     # parse_hardened enforces the same §J read invariants the embed/MCP paths do - reject duplicate
     # keys and over-deep nesting - degrading a pathological payload to a structured OM-IO error
     # (caught by _guard -> exit 3) instead of a RecursionError traceback.
-    text = sys.stdin.read() if str(path) == "-" else path.read_text(encoding="utf-8")
-    return cast("dict[str, Any]", _parse_hardened(text))
+    raw = sys.stdin.buffer.read() if str(path) == "-" else path.read_bytes()
+    if raw[:5].startswith(b"%PDF"):
+        # The natural first mistake: pointing `validate` (or another JSON verb) at an OM PDF. Give a
+        # plain hint toward the right verb instead of a cryptic UnicodeDecodeError on binary bytes.
+        typer.echo(
+            f"error: {path} looks like a PDF, not a JSON payload. To read the data embedded in an "
+            f"OM PDF use `om read {path}`; `validate` checks a deal.json (see `om init`).",
+            err=True,
+        )
+        raise typer.Exit(3)
+    return cast("dict[str, Any]", _parse_hardened(raw.decode("utf-8")))
 
 
 def _emit(obj: Any) -> None:
@@ -642,11 +666,15 @@ def buildout_manifest(
             "brokerage": row.get("brokerage", default_by["brokerage"]),
             "license": row.get("license", default_by["license"]),
         }
-        payload = listing_to_payload(
-            listing, asserted_by=asserted_by, asserted_date=asserted_date,
-            noi_type=row.get("noiType", noi_type),
-            noi_as_of=row.get("noiAsOfDate", noi_as_of),
-        )
+        try:
+            payload = listing_to_payload(
+                listing, asserted_by=asserted_by, asserted_date=asserted_date,
+                noi_type=row.get("noiType", noi_type),
+                noi_as_of=row.get("noiAsOfDate", noi_as_of),
+            )
+        except Exception as e:  # noqa: BLE001 - one malformed listing must not abort the whole batch
+            skipped.append({"id": stem, "reason": f"could not map listing: {e}"})
+            continue
         sidecar = out_dir / f"{stem}.om.json"
         sidecar.write_text(json.dumps(payload, indent=2, ensure_ascii=False), encoding="utf-8")
         manifest.append(
@@ -764,10 +792,14 @@ def csv_manifest(  # noqa: C901 - a linear map-each-row-then-report, read top-do
             continue
         ov = override_identity(row)
         asserted_by = {k: ov.get(k, default_by[k]) for k in ("broker", "brokerage", "license")}
-        payload = row_to_payload(
-            row, asserted_by=asserted_by, asserted_date=asserted_date,
-            noi_type=ov.get("noiType", noi_type), noi_as_of=ov.get("noiAsOfDate", noi_as_of),
-        )
+        try:
+            payload = row_to_payload(
+                row, asserted_by=asserted_by, asserted_date=asserted_date,
+                noi_type=ov.get("noiType", noi_type), noi_as_of=ov.get("noiAsOfDate", noi_as_of),
+            )
+        except Exception as e:  # noqa: BLE001 - one malformed row must never abort the whole batch
+            skipped.append({"id": stem, "reason": f"could not map row: {e}"})
+            continue
         sidecar = out_dir / f"{stem}.om.json"
         sidecar.write_text(json.dumps(payload, indent=2, ensure_ascii=False), encoding="utf-8")
         manifest.append(
@@ -930,6 +962,7 @@ def read(pdf: Annotated[Path, typer.Argument(help="PDF to read")]) -> None:
     _emit(
         {
             "present": result.present,
+            "encrypted": result.encrypted,  # password-protected PDF (couldn't be opened to read)
             "payload": result.payload,
             "payloadHash": result.payload_hash,  # content hash - matches hosted om_read
             "sourceDocHash": result.source_doc_hash,  # #5: provenance of the underlying source PDF

{openom_cli-0.1.2 → openom_cli-0.1.5}/tests/test_buildout_map.py

@@ -1,51 +1,71 @@
-"""Cover the Buildout->openOM mapper helper branches (pure, deterministic)."""
-
-from __future__ import annotations
-
-from openom_cli.buildout import (
-    _iso_date,
-    _lease_type,
-    _months_between,
-    _num,
-    _pct_to_fraction,
-    _state_code,
-)
-
-
-def test_num_and_pct() -> None:
-    assert _num("1,850,000") == 1850000.0
-    assert _num("nope") is None
-    assert _num(None) is None
-    assert _pct_to_fraction("6.25") == 0.0625
-    assert _pct_to_fraction(None) is None
-
-
-def test_iso_date_variants() -> None:
-    assert _iso_date("10/1/2026") == "2026-10-01"
-    assert _iso_date("") is None
-    assert _iso_date("2026-10-01") is None  # not M/D/Y
-    assert _iso_date("13/1/2026") is None  # bad month
-    assert _iso_date("a/b/c") is None
-
-
-def test_state_code() -> None:
-    assert _state_code("GA - Georgia") == "GA"
-    assert _state_code("GA") == "GA"
-    assert _state_code("Georgia") is None
-    assert _state_code(None) is None
-
-
-def test_lease_type() -> None:
-    assert _lease_type("Absolute NNN") == "NNN"
-    assert _lease_type("NN lease") == "NN"
-    assert _lease_type("Gross") == "gross"
-    assert _lease_type("Custom") == "Custom"
-    assert _lease_type(None) is None
-
-
-def test_months_between() -> None:
-    assert _months_between("2021-06-01", "2031-06-01") == 120
-    assert _months_between("2021-06-15", "2021-07-10") == 0  # partial trailing month
-    assert _months_between(None, "2031-06-01") is None
-    assert _months_between("bad", "2031-06-01") is None
-    assert _months_between("2031-06-01", "2021-06-01") is None  # negative
+"""Cover the Buildout->openOM mapper helper branches (pure, deterministic)."""
+
+from __future__ import annotations
+
+from openom_cli.buildout import (
+    _int,
+    _iso_date,
+    _lease_type,
+    _months_between,
+    _num,
+    _pct_to_fraction,
+    _state_code,
+)
+
+
+def test_num_drops_non_finite() -> None:
+    # A non-finite cell (1e400/inf/nan) must be omitted, not propagated - mirrors the JS connector's
+    # Number.isFinite guard and stops _int() raising OverflowError (which aborted the whole batch).
+    assert _num("1e400") is None
+    assert _num("inf") is None
+    assert _num("nan") is None
+    assert _int("1e400") is None
+
+
+def test_derived_rounding_is_half_up_matching_the_js_connector() -> None:
+    # Regression: Python round() is banker's (half-to-even), JS Math.round is half-up; a .5 tie
+    # forked the embedded pricePerUnit/pricePerSF. _round_half_up matches Math.round(x*m)/m.
+    from openom_cli.buildout import _round_half_up
+
+    assert int(_round_half_up(2500001 / 2)) == 1250001  # banker's round() would give 1250000
+    assert int(_round_half_up(2.5)) == 3 and int(_round_half_up(3.5)) == 4  # both up, not to-even
+    assert _pct_to_fraction("0.00005") == 1e-6  # round(5e-7,6)=0.0 under banker's; half-up = 1e-6
+
+
+def test_num_and_pct() -> None:
+    assert _num("1,850,000") == 1850000.0
+    assert _num("nope") is None
+    assert _num(None) is None
+    assert _pct_to_fraction("6.25") == 0.0625
+    assert _pct_to_fraction(None) is None
+
+
+def test_iso_date_variants() -> None:
+    assert _iso_date("10/1/2026") == "2026-10-01"
+    assert _iso_date("") is None
+    assert _iso_date("2026-10-01") is None  # not M/D/Y
+    assert _iso_date("13/1/2026") is None  # bad month
+    assert _iso_date("a/b/c") is None
+
+
+def test_state_code() -> None:
+    assert _state_code("GA - Georgia") == "GA"
+    assert _state_code("GA") == "GA"
+    assert _state_code("Georgia") is None
+    assert _state_code(None) is None
+
+
+def test_lease_type() -> None:
+    assert _lease_type("Absolute NNN") == "NNN"
+    assert _lease_type("NN lease") == "NN"
+    assert _lease_type("Gross") == "gross"
+    assert _lease_type("Custom") == "Custom"
+    assert _lease_type(None) is None
+
+
+def test_months_between() -> None:
+    assert _months_between("2021-06-01", "2031-06-01") == 120
+    assert _months_between("2021-06-15", "2021-07-10") == 0  # partial trailing month
+    assert _months_between(None, "2031-06-01") is None
+    assert _months_between("bad", "2031-06-01") is None
+    assert _months_between("2031-06-01", "2021-06-01") is None  # negative

{openom_cli-0.1.2 → openom_cli-0.1.5}/tests/test_cli.py

@@ -486,6 +486,47 @@ def test_validate_deeply_nested_json_degrades_cleanly(tmp_path: Path) -> None:
     assert "OM-IO-STRUCTURE" in r.output
 
 
+def test_validate_on_a_pdf_gives_a_useful_hint(tmp_path: Path) -> None:
+    # The natural first mistake - validate a PDF - must point at `om read`, not die on a raw
+    # UnicodeDecodeError decoding binary bytes.
+    pdf = _base_pdf(tmp_path / "deal.pdf")
+    r = runner.invoke(app, ["validate", str(pdf)])
+    assert r.exit_code == 3
+    assert "looks like a PDF" in r.output and "om read" in r.output
+
+
+def _password_pdf(path: Path) -> Path:
+    buf = io.BytesIO()
+    with pikepdf.open(SPEC / "assets" / "openom-sample.pdf") as p:
+        p.save(buf, encryption=pikepdf.Encryption(user="secret", owner="secret", R=6))
+    path.write_bytes(buf.getvalue())
+    return path
+
+
+def test_password_pdf_refuses_cleanly_not_a_traceback(tmp_path: Path) -> None:
+    # Round-3 blocker: a real password-protected PDF must not traceback. read reports encrypted;
+    # the pymupdf verbs exit 3 with OM-IO-011 and no stack trace.
+    pdf = _password_pdf(tmp_path / "pwd.pdf")
+    r = runner.invoke(app, ["read", str(pdf)])
+    assert r.exit_code == 0, r.output
+    assert json.loads(r.output)["encrypted"] is True
+    for verb in ("inspect", "extract-text"):
+        rr = runner.invoke(app, [verb, str(pdf)])
+        assert rr.exit_code == 3
+        assert "OM-IO-011" in rr.output and "Traceback" not in rr.output
+
+
+def test_corrupt_pdf_error_is_clean_no_bytesio_leak(tmp_path: Path) -> None:
+    # Round-3 friction: a corrupt/truncated PDF must give a stable OM-IO-010 with no leaked BytesIO
+    # repr or memory address, and no traceback.
+    bad = tmp_path / "bad.pdf"
+    bad.write_bytes(b"%PDF-1.7\ngarbage not a real pdf body")
+    r = runner.invoke(app, ["read", str(bad)])
+    assert r.exit_code == 3
+    assert "OM-IO-010" in r.output
+    assert "BytesIO" not in r.output and "0x" not in r.output and "Traceback" not in r.output
+
+
 def test_check_payload_json(tmp_path: Path) -> None:
     # Consistency tier only (no schema): the valid sample is internally consistent -> exit 0.
     r = runner.invoke(app, ["check", str(SPEC / "samples" / "valid-stnl.json")])

{openom_cli-0.1.2 → openom_cli-0.1.5}/tests/test_csv_map.py

@@ -114,6 +114,34 @@ def _blank_pdf(path: Path) -> None:
     path.write_bytes(buf.getvalue())
 
 
+def test_csv_manifest_one_bad_row_is_skipped_not_a_batch_abort(tmp_path: Path) -> None:
+    # A single pathological cell (1e400 -> non-finite) must skip that row with a reason, never abort
+    # the whole bulk-seed batch or traceback.
+    pdf_dir = tmp_path / "pdfs"
+    pdf_dir.mkdir()
+    _blank_pdf(pdf_dir / "good.pdf")
+    _blank_pdf(pdf_dir / "bad.pdf")
+    csv_file = tmp_path / "c.csv"
+    csv_file.write_text(
+        "id,askingPrice,noi\ngood,1850000,115625\nbad,1e400,1e400\n", encoding="utf-8"
+    )
+    out = tmp_path / "mapped"
+    r = _runner.invoke(
+        app,
+        ["csv-manifest", "--csv", str(csv_file), "--pdf-dir", str(pdf_dir), "--out-dir", str(out),
+         "--broker", "J", "--brokerage", "A", "--license", "L",
+         "--asserted-date", "2026-08-15", "--noi-type", "in-place"],
+    )
+    assert r.exit_code == 0, r.output
+    summary = json.loads(r.output[r.output.index("{"):])
+    # 'good' maps; 'bad' maps too but with the non-finite cells simply omitted (never a crash).
+    assert summary["mapped"] == 2
+    good = json.loads((out / "good.om.json").read_text(encoding="utf-8"))
+    assert good["deal"]["askingPrice"] == 1850000
+    bad = json.loads((out / "bad.om.json").read_text(encoding="utf-8"))
+    assert "askingPrice" not in bad.get("deal", {})  # the 1e400 cell was dropped, not embedded
+
+
 def test_csv_manifest_template_then_embed_batch_roundtrip(tmp_path: Path) -> None:
     # 1) --template writes a fillable CSV; a broker fills two rows.
     tmpl = tmp_path / "template.csv"