openom-cli 0.1.0__py3-none-any.whl

openom_cli/profile.py

@@ -0,0 +1,79 @@
+# SPDX-License-Identifier: MIT
+"""A per-user broker profile so identity (name/brokerage/license) is set once, never retyped.
+
+Brokers asked for a settable profile on the CLI; this is it. Stored device-locally at
+``<app-dir>/profile.json`` (``%APPDATA%\\openom`` on Windows, ``~/.config/openom`` on Linux).
+``om init`` and ``om embed`` fill a payload's ``assertedBy`` from it - payload values always win,
+the profile only fills blanks, and a missing/corrupt file never breaks a command (it reads as {}).
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+import typer
+
+APP_NAME = "openom"
+_FIELDS = ("broker", "brokerage", "license")
+
+
+def config_dir() -> Path:
+    return Path(typer.get_app_dir(APP_NAME))
+
+
+def profile_path() -> Path:
+    return config_dir() / "profile.json"
+
+
+def load_profile() -> dict[str, Any]:
+    """The saved profile, or {} if absent/unreadable. Never raises (embed must not break on it)."""
+    try:
+        data = json.loads(profile_path().read_text(encoding="utf-8"))
+    except (OSError, ValueError):
+        return {}
+    return data if isinstance(data, dict) else {}
+
+
+def save_profile(
+    *, broker: str | None, brokerage: str | None, license: str | None
+) -> dict[str, Any]:
+    """Overlay the given (non-None) fields onto the stored profile's ``assertedBy`` and persist."""
+    prof = load_profile()
+    asserted = dict(prof.get("assertedBy") or {})
+    for key, value in {"broker": broker, "brokerage": brokerage, "license": license}.items():
+        if value is not None:
+            asserted[key] = value
+    prof["assertedBy"] = asserted
+    path = profile_path()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(prof, indent=2, ensure_ascii=False), encoding="utf-8")
+    return prof
+
+
+def profile_asserted_by() -> dict[str, str]:
+    """The saved ``assertedBy`` mapping (broker/brokerage/license), or {}."""
+    asserted = load_profile().get("assertedBy")
+    return asserted if isinstance(asserted, dict) else {}
+
+
+def merge_into(payload: dict[str, Any]) -> bool:
+    """Fill missing/blank ``assertedBy`` broker/brokerage/license from the saved profile.
+
+    Payload values always win; the profile only fills gaps. Returns True if anything was filled,
+    so the caller can tell the user it happened.
+    """
+    saved = profile_asserted_by()
+    if not saved:
+        return False
+    asserted = payload.get("assertedBy")
+    asserted = dict(asserted) if isinstance(asserted, dict) else {}
+    filled = False
+    for key in _FIELDS:
+        if saved.get(key) and not asserted.get(key):
+            asserted[key] = saved[key]
+            filled = True
+    if filled:
+        payload["assertedBy"] = asserted
+    return filled

openom_cli/scaffold.py

@@ -0,0 +1,141 @@
+# SPDX-License-Identifier: MIT
+"""Starter payloads for ``om init`` so a CLI user never hits the "no deal.json" dead-end.
+
+Each template mirrors a real, schema-valid committed sample (spec/samples/valid-*.json) so
+``om init`` -> ``om validate`` is clean out of the box; the user then swaps the EXAMPLE values for
+their deal's. Skeletons are inlined (not read from /spec) because the installed wheel may not ship
+the spec directory. The values are examples, called out as such in the guidance ``om init`` prints.
+"""
+
+from __future__ import annotations
+
+import copy
+from typing import Any
+
+TEMPLATES = ("stnl", "multifamily", "proforma")
+
+# stnl = single-tenant net lease (the most common net-lease OM); the default.
+_STNL: dict[str, Any] = {
+    "@context": ["https://schema.org", "https://openom.app/ns/0.1"],
+    "@type": "RealEstateListing",
+    "specVersion": "0.1",
+    "assertedBy": {
+        "broker": "Your Name", "brokerage": "Your Brokerage", "license": "Your license id",
+    },
+    "assertedDate": "REPLACED_WITH_TODAY",
+    "property": {
+        "address": {
+            "streetAddress": "1000 Example Rd", "addressLocality": "Sampleville",
+            "addressRegion": "MI", "postalCode": "48000", "addressCountry": "US",
+        },
+        "apn": "00-000-000-000", "buildingSF": 9100, "yearBuilt": 2019,
+    },
+    "deal": {
+        "askingPrice": 1850000, "capRate": 0.0625, "noi": 115625,
+        "noiType": "in-place", "noiAsOfDate": "REPLACED_WITH_TODAY", "status": "active",
+    },
+    "lease": {
+        "tenantEntity": "Example Retail Stores, LLC",
+        "guarantor": {"name": "Example Retail Corp.", "type": "corporate"},
+        "leaseTypeAsserted": "NNN",
+        "commencement": "2019-05-01", "expiration": "2034-04-30",
+        "rentSchedule": [
+            {"periodStart": "2024-05-01", "periodEnd": "2029-04-30", "annualRent": 115625,
+             "rentPSF": 12.70, "source": "asserted"},
+        ],
+    },
+    "meta": {"supersedes": None},
+}
+
+_MULTIFAMILY: dict[str, Any] = {
+    "@context": ["https://schema.org", "https://openom.app/ns/0.1"],
+    "@type": "RealEstateListing",
+    "specVersion": "0.1",
+    "assertedBy": {
+        "broker": "Your Name", "brokerage": "Your Brokerage", "license": "Your license id",
+    },
+    "assertedDate": "REPLACED_WITH_TODAY",
+    "property": {
+        "propertyType": "multifamily",
+        "address": {
+            "streetAddress": "200 Example Ave", "addressLocality": "Sampletown",
+            "addressRegion": "TX", "postalCode": "75000", "addressCountry": "US",
+        },
+        "yearBuilt": 1998, "units": 40, "occupancy": 0.95,
+    },
+    "deal": {
+        "askingPrice": 8000000, "capRate": 0.06, "noi": 480000, "noiType": "in-place",
+        "noiAsOfDate": "REPLACED_WITH_TODAY", "pricePerUnit": 200000, "status": "active",
+    },
+    "meta": {"supersedes": None},
+}
+
+_PROFORMA: dict[str, Any] = {
+    "@context": ["https://schema.org", "https://openom.app/ns/0.1"],
+    "@type": "RealEstateListing",
+    "specVersion": "0.1",
+    "assertedBy": {
+        "broker": "Your Name", "brokerage": "Your Brokerage", "license": "Your license id",
+    },
+    "assertedDate": "REPLACED_WITH_TODAY",
+    "currency": "USD",
+    "deal": {
+        "askingPrice": 5000000, "capRate": 0.07, "noi": 350000, "noiType": "pro-forma",
+        "noiAsOfDate": "REPLACED_WITH_TODAY", "status": "active",
+    },
+    "meta": {"supersedes": None},
+}
+
+_SKELETONS: dict[str, dict[str, Any]] = {
+    "stnl": _STNL, "multifamily": _MULTIFAMILY, "proforma": _PROFORMA,
+}
+
+
+def build_skeleton(
+    template: str, *, today: str, profile_asserted_by: dict[str, str] | None = None
+) -> dict[str, Any]:
+    """A fresh starter payload: today's date stamped in, ``assertedBy`` filled from the profile."""
+    if template not in _SKELETONS:
+        raise KeyError(template)
+    doc = copy.deepcopy(_SKELETONS[template])
+    doc["assertedDate"] = today
+    if isinstance(doc.get("deal"), dict) and "noiAsOfDate" in doc["deal"]:
+        doc["deal"]["noiAsOfDate"] = today
+    if profile_asserted_by:
+        for key in ("broker", "brokerage", "license"):
+            if profile_asserted_by.get(key):
+                doc["assertedBy"][key] = profile_asserted_by[key]
+    return doc
+
+
+def guidance_lines(template: str, out: str, *, has_profile: bool) -> list[str]:
+    """The plain-English "now edit these" coaching printed to stderr after writing the file."""
+    who = (
+        "  - assertedBy.broker / brokerage / license  <-  filled from your saved profile"
+        if has_profile
+        else "  - assertedBy.broker / brokerage / license  <-  who is asserting this "
+        "(or run `om profile set` once to auto-fill)"
+    )
+    return [
+        f"Wrote a starter payload -> {out} (template: {template})",
+        "",
+        "These are EXAMPLE values - replace them with your deal's, then embed. Key fields:",
+        "  - property.address, buildingSF, yearBuilt",
+        "  - deal.askingPrice (dollars, e.g. 1850000), deal.noi (dollars)",
+        "  - deal.capRate  <-  a DECIMAL fraction: 6.25% = 0.0625  (NOT 6.25)",
+        "  - deal.noiType  <-  'in-place' or 'pro-forma'  (required whenever you set an NOI)",
+        who,
+        "",
+        "Next:",
+        f"  om validate {out}          # plain-English check before you embed",
+        f"  om embed listing.pdf --payload {out} --out listing.openom.pdf "
+        f"--asserted-date {_stamp_hint()}",
+        "",
+        "Not a developer? You don't need any of this - embed in your browser (nothing leaves your "
+        "machine): https://openom.app/embed/",
+    ]
+
+
+def _stamp_hint() -> str:
+    # A literal placeholder in the printed example command (not a real date - keeps output stable).
+    return "<today>"

openom_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,96 @@
+Metadata-Version: 2.5
+Name: openom-cli
+Version: 0.1.0
+Summary: openOM CLI - the `om` command over openom-core. Zero inference.
+Project-URL: Homepage, https://openom.app
+Project-URL: Documentation, https://openom.app/docs/
+Project-URL: Repository, https://github.com/Vervelio-Labs/OpenOM
+License-Expression: MIT
+Keywords: cli,commercial-real-estate,cre,data-standard,json-ld,json-schema,offering-memorandum,open-standard,openom,pdf,proptech,real-estate
+Requires-Python: >=3.11
+Requires-Dist: openom-core[render]<0.2,>=0.1
+Requires-Dist: typer>=0.12
+Provides-Extra: dev
+Requires-Dist: mypy>=1.10; extra == 'dev'
+Requires-Dist: pytest-cov>=5; extra == 'dev'
+Requires-Dist: pytest>=8; extra == 'dev'
+Requires-Dist: ruff>=0.5; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# openom-cli
+
+The `om` command over [`openom-core`](../core) - no UI, no inference; also the server-side path.
+
+```sh
+# From a clone (not yet on PyPI): install core first, then cli.
+pip install -e core && pip install -e cli   # add [dev] to either only to contribute
+# Once published:  pip install openom-cli
+
+om inspect  offering.pdf
+om embed    offering.pdf --payload deal.json --out out.pdf --asserted-date 2026-08-16 --validate
+om read     out.pdf
+om validate deal.json
+om check    out.pdf               # consistency only
+om --version
+```
+
+## Conformance (CI integrity gate)
+
+`om conformance` reproduces the pinned spec vectors + samples with your installed openOM - run it in
+CI so an environment/version change can't silently drift from the standard. It reads the repo's
+`spec/` tree (pass `--spec-dir <path>/spec` from outside a checkout):
+
+```sh
+om --quiet conformance                       # exit 0 = conformant, 1 = a check failed
+om conformance --impl-dir ./my-output        # certify a THIRD-PARTY implementation's output
+```
+
+## Bulk / back-catalog embed
+
+Embed openOM data into many OMs in one run - the adoption path (seed supply at the source):
+
+```sh
+# a folder of *.pdf, each paired with a sibling <name>.om.json payload:
+om embed-batch --dir ./catalog --out-dir ./embedded --asserted-date 2026-08-22 \
+   --schema ../spec/om-0.1.schema.json
+#   --dry-run        preview (validate + report, write nothing)
+#   --skip-existing  resume a large run;  --force  overwrite;  --jobs 4  parallel
+
+# or a JSON manifest of {pdf, payload, out?, assertedDate?} items:
+om embed-batch --manifest ./manifest.json --out-dir ./embedded --schema ../spec/om-0.1.schema.json
+```
+
+Deterministic, non-destructive, idempotent (re-embed replaces + records `supersedes`); schema errors
+skip that item (never embedded); emits a JSON summary (per-status counts) and `--report FILE`.
+
+### From Buildout (connector -> manifest)
+
+Turn fetched Buildout listings into an `embed-batch` manifest. Save each `buildout_get_listing` JSON
+as `<id>.json` and its OM PDF as `<id>.pdf`, then:
+
+```sh
+om buildout-manifest --listings-dir ./listings --pdf-dir ./oms --out-dir ./staged \
+   --broker "Jane Broker" --brokerage "Acme NNN" --license "MI 000" \
+   --asserted-date 2026-08-22 --noi-type in-place
+om embed-batch --manifest ./staged/manifest.json --out-dir ./embedded --schema ../spec/om-0.1.schema.json
+```
+
+The map is deterministic (names/units normalized, absent fields omitted, `cap_rate_derived` used);
+the assertion identity is yours (flags), never inferred. Review the staged payloads before embedding.
+
+## Watch-folder (server-side automation)
+
+Drop `<name>.pdf` + `<name>.json` pairs into a folder and get embedded OMs out - no UI:
+
+```sh
+om watch ./inbox --out ./outbox --asserted-date 2026-08-18 \
+   --schema ../spec/om-0.1.schema.json      # a payload with schema errors is skipped, not embedded
+
+om watch ./inbox --out ./outbox --asserted-date 2026-08-18 --once   # drain the backlog + exit (cron/CI)
+```
+
+Deterministic, zero inference. A pair is re-embedded when its pdf/json changes; `--once` processes
+the current backlog and exits (otherwise it polls every `--interval` seconds until Ctrl-C).
+
+Reads stdin / writes stdout with `--format`/`--quiet`; exit codes follow the §I contract.
+Tests: `pytest cli -q`.

openom_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+openom_cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+openom_cli/buildout.py,sha256=Lm7BToLf1v0SMV6ZDQA9UgTD8kIrK43WGPNhW-5ZCAs,7940
+openom_cli/buildout_pull.py,sha256=B4OyCA0XzVOqwXM0dqudTix_VFp9FVMuYoNpEqfHUmY,9225
+openom_cli/humanize.py,sha256=Av3TYHEtCbwAiK3uMPXbUnp4GVrLjRM-LlwmliNZGEU,2192
+openom_cli/main.py,sha256=HnGLCcKqRrUofJE85LNRppu-g2DDLNNYWTP-ncHYRUE,44955
+openom_cli/profile.py,sha256=2yOGMazpjrQKzSkrA4cdaE0rBltw9mkRzh7rjG82YnA,2751
+openom_cli/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+openom_cli/scaffold.py,sha256=9Q6NE5oClFlseTrsMYhuoPnAST68Q8a-xL1CAezOthQ,5720
+openom_cli-0.1.0.dist-info/METADATA,sha256=606bb22CXgrG2Gt6IRZDa-QzyL-Fm8YE0aJKA5NJ7mw,4089
+openom_cli-0.1.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+openom_cli-0.1.0.dist-info/entry_points.txt,sha256=yZGVpdzQKBW2Hk7MfwGKlKucdseoQe1nqG8l95yaXHQ,43
+openom_cli-0.1.0.dist-info/RECORD,,

openom_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.0
+Root-Is-Purelib: true
+Tag: py3-none-any

openom_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+om = openom_cli.main:app