canmet-btap 0.2.1__tar.gz

canmet_btap-0.2.1/PKG-INFO

@@ -0,0 +1,72 @@
+Metadata-Version: 2.4
+Name: canmet-btap
+Version: 0.2.1
+Summary: NECB 2020/2025 Part 8 performance-path compliance toolchain (Python port of the btap gem family)
+License: LGPL-3.0-or-later
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: openstudio~=3.11.0
+Requires-Dist: canmet-energyplus==25.2.0.2; sys_platform == "win32" or (sys_platform == "linux" and platform_machine == "x86_64")
+Provides-Extra: tbd
+Requires-Dist: canmet-tbd==3.5.2; extra == "tbd"
+
+# btap (Python)
+
+The Python port of the btap gem family — one distribution, five subpackages
+mirroring the gems (`btap.audit`, `btap.simulation`, `btap.modeling`,
+`btap.costing`, `btap.necb`), same one-way dependency direction (D-77).
+The port is COMPLETE (M0–M8, 2026-08-28; the record is `../PORT_STATUS.md`
+and D-79), verified three ways: every Ruby suite ported, the Leg-C oracle
+goldens consumed (frozen AND live), and the Leg-B corpus diff holding the
+Ruby and Python `btap-compliance` CLIs equivalent at the `none`, `sizing`
+and `annual --quick` tiers.
+
+Since R3 (D-81) **this implementation is primary and canonical**, and
+since the R4 handoff (D-82) it is the only one that changes: Ruby
+backports have stopped. Behaviour changes land here with a re-frozen
+scenario baseline in the same PR (`verification/scenarios/freeze.py`);
+the frozen suite — not a live Ruby comparison — is the regression net.
+
+```bash
+cd python && python3 -m unittest discover tests   # stdlib-only, no install needed (serial)
+cd python && .venv/bin/pytest -n auto tests/      # parallel (pytest-xdist worker
+                                                  # processes; ~10x on the E+ suites)
+```
+
+`btap/_compat.py` holds the cross-cutting Ruby-parity contracts (round-half-
+away rounding, SDK Optional unwrapping, the NullAudit, determinism-critical
+sorting, HTML escaping). New code uses those helpers, never the raw Python
+equivalents — the differences they paper over are exactly the silent
+Ruby-vs-Python drifts the census identified.
+
+## The CLI (M6)
+
+The umbrella pipeline and its command line are ported:
+
+```bash
+pip install .                      # installs the btap-compliance console script
+btap-compliance model.osm --epw weather.epw          # full 8.4.1.2 determination
+python3 -m btap.necb.cli model.osm --simulate none   # no-install equivalent
+```
+
+Same seven exit codes as the Ruby CLI (0 compliant, 1 not compliant, 2
+usage, 3 pre-flight, 4 simulation, 5 internal, 6 no determination), and the
+same refusal to call a `--quick` week a determination. The Leg-B corpus gate
+(`CLI_B=python bash verification/selftest.sh`) diffs this CLI's
+`audit.json`/`report.json` against the Ruby CLI's over the whole corpus —
+every pair equivalent at the `none`, `sizing`, and `annual` tiers.
+
+## Thermal bridging (M7)
+
+NECB 3.1.1.7 runs through **py-tbd** (native Python, no Ruby subprocess),
+pinned by commit SHA to its `tbd-3.5.2-compat` branch — the revision
+verified against the family's frozen Ruby TBD 3.5.2 / OSut 0.8.2 oracle
+baseline:
+
+```bash
+pip install '.[tbd]'
+```
+
+Without it the pipeline still works: `thermal_bridging=` degrades to the
+same loud audited 3.1.1.7-not-accounted warning the Ruby gem emits without
+its tbd gem — never a silent clear-field result.

canmet_btap-0.2.1/README.md

@@ -0,0 +1,60 @@
+# btap (Python)
+
+The Python port of the btap gem family — one distribution, five subpackages
+mirroring the gems (`btap.audit`, `btap.simulation`, `btap.modeling`,
+`btap.costing`, `btap.necb`), same one-way dependency direction (D-77).
+The port is COMPLETE (M0–M8, 2026-08-28; the record is `../PORT_STATUS.md`
+and D-79), verified three ways: every Ruby suite ported, the Leg-C oracle
+goldens consumed (frozen AND live), and the Leg-B corpus diff holding the
+Ruby and Python `btap-compliance` CLIs equivalent at the `none`, `sizing`
+and `annual --quick` tiers.
+
+Since R3 (D-81) **this implementation is primary and canonical**, and
+since the R4 handoff (D-82) it is the only one that changes: Ruby
+backports have stopped. Behaviour changes land here with a re-frozen
+scenario baseline in the same PR (`verification/scenarios/freeze.py`);
+the frozen suite — not a live Ruby comparison — is the regression net.
+
+```bash
+cd python && python3 -m unittest discover tests   # stdlib-only, no install needed (serial)
+cd python && .venv/bin/pytest -n auto tests/      # parallel (pytest-xdist worker
+                                                  # processes; ~10x on the E+ suites)
+```
+
+`btap/_compat.py` holds the cross-cutting Ruby-parity contracts (round-half-
+away rounding, SDK Optional unwrapping, the NullAudit, determinism-critical
+sorting, HTML escaping). New code uses those helpers, never the raw Python
+equivalents — the differences they paper over are exactly the silent
+Ruby-vs-Python drifts the census identified.
+
+## The CLI (M6)
+
+The umbrella pipeline and its command line are ported:
+
+```bash
+pip install .                      # installs the btap-compliance console script
+btap-compliance model.osm --epw weather.epw          # full 8.4.1.2 determination
+python3 -m btap.necb.cli model.osm --simulate none   # no-install equivalent
+```
+
+Same seven exit codes as the Ruby CLI (0 compliant, 1 not compliant, 2
+usage, 3 pre-flight, 4 simulation, 5 internal, 6 no determination), and the
+same refusal to call a `--quick` week a determination. The Leg-B corpus gate
+(`CLI_B=python bash verification/selftest.sh`) diffs this CLI's
+`audit.json`/`report.json` against the Ruby CLI's over the whole corpus —
+every pair equivalent at the `none`, `sizing`, and `annual` tiers.
+
+## Thermal bridging (M7)
+
+NECB 3.1.1.7 runs through **py-tbd** (native Python, no Ruby subprocess),
+pinned by commit SHA to its `tbd-3.5.2-compat` branch — the revision
+verified against the family's frozen Ruby TBD 3.5.2 / OSut 0.8.2 oracle
+baseline:
+
+```bash
+pip install '.[tbd]'
+```
+
+Without it the pipeline still works: `thermal_bridging=` degrades to the
+same loud audited 3.1.1.7-not-accounted warning the Ruby gem emits without
+its tbd gem — never a silent clear-field result.

canmet_btap-0.2.1/btap/__init__.py

@@ -0,0 +1,9 @@
+"""btap — the NECB 2020/2025 Part 8 performance path, one distribution.
+
+Five subpackages mirror the Ruby gem family and keep its one-way dependency
+direction (D-77): necb -> costing -> modeling -> audit, simulation beside.
+Import subpackages directly (``from btap.audit import AuditLog``); this root
+deliberately imports none of them, so ``import btap`` never pulls the SDK.
+"""
+
+__version__ = "0.2.1"

canmet_btap-0.2.1/btap/_compat.py

@@ -0,0 +1,195 @@
+"""Cross-cutting Ruby-parity contracts for the btap port (D-79).
+
+Every helper here papers over ONE specific Ruby-vs-Python semantic difference
+the port-hazard census identified as a silent-drift hazard. Ported code MUST
+use these instead of the raw Python equivalents:
+
+- ``ruby_round``   — Ruby ``Float#round`` (half AWAY from zero, on the
+  shortest decimal representation); Python's ``round()`` is banker's.
+- ``ruby_div``     — Ruby FLOAT division, which never raises: x/0.0 is
+  ±Infinity and 0.0/0.0 is NaN, where Python raises ZeroDivisionError.
+- ``opt``/``opt_or`` — SDK ``Optional`` unwrapping; routes every call through
+  one greppable site and retires the missing-``()`` truthy-bound-method bug.
+- ``NullAudit``    — null-object stand-in for AuditLog, replacing Ruby's 235
+  ``audit&.warn`` safe-navigation sites with plain ``audit.warn``.
+- ``sorted_by_name`` — the determinism-critical ``sort_by(&:nameString)``.
+- ``esc``/``Raw``  — the report's HTML escaping (exactly Ruby's four
+  substitutions; ``html.escape`` also escapes ``'`` and would diff).
+- ``ruby_str``     — Ruby string interpolation of scalars (``true``/``false``/
+  ``nil``→empty, Ruby float rendering) for byte-parity narrative text.
+
+Stdlib only. This module must never import openstudio.
+"""
+
+from __future__ import annotations
+
+import math
+from contextlib import contextmanager
+from dataclasses import dataclass
+from decimal import ROUND_HALF_UP, Decimal
+
+
+def ruby_round(x, ndigits: int = 0):
+    """Ruby ``Float#round(ndigits)``: half away from zero on the value's
+    shortest decimal representation (so ``ruby_round(2.675, 2) == 2.68`` even
+    though the double is 2.67499...). Returns int for ``ndigits <= 0`` and
+    float otherwise, exactly as Ruby returns Integer/Float.
+
+    Non-finite input follows Ruby exactly: with ndigits > 0 the value comes
+    back unchanged (``Infinity.round(2) == Infinity``, ``NaN.round(4) ==
+    NaN``), while ndigits <= 0 must produce an Integer and so raises, as
+    Ruby's FloatDomainError does. This matters because Ruby float division
+    never raises — see ``ruby_div`` — so NaN/Infinity reach rounding on
+    perfectly ordinary code paths."""
+    if isinstance(x, int) and ndigits >= 0:
+        return x
+    value = float(x)
+    if math.isnan(value) or math.isinf(value):
+        if ndigits > 0:
+            return value
+        raise ValueError(f"cannot round {value} to an integer (Ruby: FloatDomainError)")
+    quantum = Decimal(1).scaleb(-ndigits)
+    d = Decimal(repr(value)).quantize(quantum, rounding=ROUND_HALF_UP)
+    return int(d) if ndigits <= 0 else float(d)
+
+
+def ruby_div(numerator, denominator) -> float:
+    """Ruby FLOAT division, which never raises: ``x/0.0`` is ±Infinity and
+    ``0.0/0.0`` is NaN, where Python raises ZeroDivisionError.
+
+    This is a family-wide porting hazard, not a curiosity. Ruby code
+    routinely divides by a possibly-zero area or count and then relies on the
+    result comparing false (``NaN <= 0.006`` is false), which is how several
+    NECB criteria skip an inapplicable half. Transliterating such a division
+    turns a silent skip into a crash, so every ported float division whose
+    denominator can be zero goes through here."""
+    n, d = float(numerator), float(denominator)
+    if d != 0.0:
+        return n / d
+    if n == 0.0 or math.isnan(n):
+        return math.nan
+    return math.inf if (n > 0) == (not math.copysign(1.0, d) < 0) else -math.inf
+
+
+def opt(optional):
+    """Unwrap an SDK Optional: the value, or None when empty (Ruby's
+    ``x.is_initialized ? x.get : nil``). None passes through.
+
+    ALWAYS route through this rather than calling ``.get()`` directly. The
+    Python bindings do not fail the way Ruby does: ``OptionalModel.get()`` on
+    an EMPTY optional RETURNS AN EMPTY MODEL instead of raising (so a failed
+    ``Model.load`` flows onward silently), while ``OptionalDouble``/
+    ``OptionalString`` raise ``SystemError`` and leave the C-level error
+    indicator set, which can segfault the interpreter on a later unrelated
+    call. Ruby raises cleanly in all of these. See D-79.
+    """
+    if optional is None:
+        return None
+    return optional.get() if optional.is_initialized() else None
+
+
+def opt_or(optional, default):
+    """Unwrap an SDK Optional with a default (Ruby's ``.empty? ? d : .get``)."""
+    value = opt(optional)
+    return default if value is None else value
+
+
+def sorted_by_name(objects):
+    """``sort_by(&:nameString)`` — THE determinism idiom: every iteration whose
+    order reaches an output must pass through here (reference models, audit
+    entries, costing line items are reproducible because of it)."""
+    return sorted(objects, key=lambda o: o.nameString())
+
+
+class NullAudit:
+    """Null-object AuditLog: absorbs every write, so callers take
+    ``audit=NullAudit()`` instead of Ruby's ``audit&.`` at 235 sites.
+    API-compatible with btap.audit.AuditLog; never import that here
+    (audit imports _compat, not the reverse)."""
+
+    building = None
+    entries: list = []  # always empty; writes are discarded, not stored
+
+    def decision(self, *args, **kwargs):
+        return self
+
+    def info(self, *args, **kwargs):
+        return self
+
+    def warn(self, *args, **kwargs):
+        return self
+
+    @property
+    def warnings(self):
+        return []
+
+    @contextmanager
+    def with_building(self, name):
+        yield
+
+
+@dataclass(frozen=True)
+class Raw:
+    """Marks a pre-built HTML fragment as safe to embed unescaped
+    (Ruby's ``Html::Raw`` struct)."""
+
+    html: str
+
+
+def esc(value) -> str:
+    """HTML-escape any value — exactly Ruby ``Html.esc``'s four gsubs, in
+    order. Deliberately NOT ``html.escape``: that escapes ``'`` too and the
+    report goldens would diff."""
+    return (
+        ruby_str(value)
+        .replace("&", "&amp;")
+        .replace("<", "&lt;")
+        .replace(">", "&gt;")
+        .replace('"', "&quot;")
+    )
+
+
+def ruby_str(value) -> str:
+    """Ruby string interpolation (``"#{value}"``) for the scalar types the
+    audit narrative and report text actually carry: None→'' (nil), booleans
+    lowercase, Ruby float rendering (``1.0e+16``, not ``1e+16``), lists in
+    Ruby ``Array#to_s`` style. Best-effort beyond those — audit.txt is
+    narrative, only audit.json/report.json are Leg-B-gated."""
+    if value is None:
+        return ""
+    if value is True:
+        return "true"
+    if value is False:
+        return "false"
+    if isinstance(value, float):
+        return ruby_float_str(value)
+    if isinstance(value, list):
+        return "[" + ", ".join(_ruby_inspect(v) for v in value) + "]"
+    return str(value)
+
+
+def ruby_float_str(x: float) -> str:
+    """Ruby ``Float#to_s``: same shortest-repr digits and sci-notation
+    thresholds as Python's repr, but the mantissa always carries a decimal
+    point (Ruby ``1.0e+16`` vs Python ``1e+16``)."""
+    s = repr(x)
+    if "e" in s:
+        mantissa, exponent = s.split("e")
+        if "." not in mantissa:
+            mantissa += ".0"
+        return f"{mantissa}e{exponent}"
+    return s
+
+
+def _ruby_inspect(value) -> str:
+    """Ruby ``#inspect`` for array elements: strings quoted, nil literal."""
+    if value is None:
+        return "nil"
+    if isinstance(value, str):
+        return '"' + value.replace("\\", "\\\\").replace('"', '\\"') + '"'
+    return ruby_str(value)
+
+
+# NOTE: SDK-touching helpers (ensure_sdk_hashable) live in btap._sdk — this
+# module stays stdlib-only so btap.audit can depend on it and still run on a
+# runner with no OpenStudio. The import-linter contract enforces that.

canmet_btap-0.2.1/btap/_sdk.py

@@ -0,0 +1,56 @@
+"""SDK-touching cross-cutting helpers.
+
+Separate from ``_compat`` on purpose: ``_compat`` is stdlib-only so that
+``btap.audit`` — which the family contract keeps SDK-free, and which CI
+exercises on a bare runner with no OpenStudio — can depend on it. Anything
+that needs ``import openstudio`` lives here instead, and the import-linter
+contract enforces the split.
+"""
+
+from __future__ import annotations
+
+_sdk_hash_patched = False
+
+
+def ensure_sdk_hashable() -> None:
+    """Make SDK model objects usable as dict keys (idempotent).
+
+    The openstudio wheel's ModelObject/IdfObject define __eq__ (handle
+    equality) WITHOUT __hash__, so Python marks them unhashable — but the
+    ported code keys dicts by SpaceType/BuildingStory/ThermalZone exactly as
+    the Ruby did. This patches a handle-based __hash__ consistent with the
+    wheel's __eq__. Call it at the top of any module that keys a dict or set
+    by SDK objects.
+    """
+    global _sdk_hash_patched
+    if _sdk_hash_patched:
+        return
+    import openstudio
+
+    def _handle_hash(self):
+        return hash(str(self.handle()))
+
+    openstudio.model.ModelObject.__hash__ = _handle_hash
+    openstudio.IdfObject.__hash__ = _handle_hash
+    _sdk_hash_patched = True
+
+
+def load_model(path):
+    """Load an .osm, refusing an unreadable path LOUDLY.
+
+    THE reason this exists: ``OptionalModel.get()`` on an EMPTY optional
+    RETURNS AN EMPTY MODEL rather than raising (Ruby raises), so an
+    unreadable path flows onward as a model with no spaces and no zones and
+    surfaces later as dozens of meaningless downstream failures. Other empty
+    Optionals raise ``SystemError`` and leave the C-level error indicator
+    set, which can segfault the interpreter on a later unrelated call.
+
+    Never write ``Model.load(...).get()``. Use this. The invariant is
+    enforced by tests/test_sdk_invariants.py, not just documented (D-79).
+    """
+    import openstudio
+
+    loaded = openstudio.model.Model.load(openstudio.path(str(path)))
+    if not loaded.is_initialized():
+        raise ValueError(f"could not read an OpenStudio model at: {path}")
+    return loaded.get()

canmet_btap-0.2.1/btap/audit/__init__.py

@@ -0,0 +1,11 @@
+"""btap.audit — the family's shared audit machinery (port of btap-audit).
+
+One AuditLog class (entry schema, building stamping, article:/ruling:
+citation axes, JSON + narrative rendering) and one article-coverage emitter.
+No domain knowledge, no SDK — the bottom of the family.
+"""
+
+from btap.audit.coverage import emit_coverage
+from btap.audit.log import AuditLog
+
+__all__ = ["AuditLog", "emit_coverage"]

canmet_btap-0.2.1/btap/audit/coverage.py

@@ -0,0 +1,73 @@
+"""Article-coverage emission (port of btap-audit's coverage.rb): the ONE
+implementation of the completeness accounting every family module performs at
+the end of its happy path.
+
+Each domain owns an `article_coverage` manifest (implemented / partial /
+not_implemented / satisfied_by_clone / host_scope) and resolves it its own
+way; what every domain then does with it is identical and lives here: every
+declared article lands in the audit with its status and how many decisions
+cited it this run, so a missed requirement is visible in every log rather
+than discovered by review.
+
+partial/not_implemented WARN — except entries flagged `gap_owner: "modeller"`,
+whose remaining gaps are wholly the modeller's responsibility: those emit as
+info scope notes instead (project decision D-09).
+"""
+
+from __future__ import annotations
+
+import re
+from collections import Counter
+
+_ARTICLE_RE = re.compile(r"\d+\.\d+(?:\.\d+)*\.")
+# Strip ' (slice label)' / '(N)' suffixes, but KEEP the trailing dot: the scan
+# above only ever yields keys ending in '.', so the dot is what stops
+# '8.4.4.1.' from prefix-matching '8.4.4.14.' and claiming its citations.
+# (report/checklist.rb#covered? guards the same collision the same way.)
+_SLICE_SUFFIX_RE = re.compile(r"\s*\(.*\Z")
+
+_INFO_STATUSES = ("implemented", "satisfied_by_clone", "host_scope")
+
+
+def emit_coverage(coverage, audit):
+    """`coverage` is the resolved article_coverage block — a dict with an
+    'articles' list of {article, title, status, how, gaps, gap_owner, code}
+    records. None is a deliberate no-op (a ruleset with no manifest emits
+    nothing). Entries append to `audit`; their `article:` tags are what the
+    citation count reads."""
+    if coverage is None:
+        return
+
+    cited = Counter()
+    for e in audit.entries:
+        cited.update(_ARTICLE_RE.findall(str(e.get("article") or "")))
+    for art in coverage["articles"]:
+        prefix = _SLICE_SUFFIX_RE.sub("", str(art["article"]))
+        applied = sum(n for a, n in cited.items() if a.startswith(prefix))
+        inputs = {"status": art["status"], "decisions_citing": applied}
+        if art.get("gap_owner") is not None:
+            inputs["gap_owner"] = art["gap_owner"]
+        # "Where is this dealt with" — path#method refs, carried into the
+        # audit so the AHJ trail answers the question without the repo.
+        if art.get("code") is not None:
+            inputs["code"] = art["code"]
+        status_text = art["status"].replace("_", " ")
+        how = art.get("how")
+        gaps = art.get("gaps")
+        if art["status"] in _INFO_STATUSES:
+            audit.info("coverage",
+                       f"{art['title']} — {status_text}{': ' + how if how else ''}",
+                       inputs=inputs, article=art["article"])
+        elif art.get("gap_owner") == "modeller":  # scope note, not a warning (D-09)
+            action = f"{art['title']} — {status_text}, modeller scope"
+            if how:
+                action += f". Applied: {how}"
+            if gaps:
+                action += f". Modeller's responsibility: {gaps}"
+            audit.info("coverage", action, inputs=inputs, article=art["article"])
+        else:  # partial / not_implemented
+            audit.warn("coverage",
+                       f"{art['title']} — {status_text}"
+                       f"{'. Applied: ' + how if how else ''}"
+                       f"{'. Gaps: ' + gaps if gaps else ''}",
+                       inputs=inputs, article=art["article"])

canmet_btap-0.2.1/btap/audit/log.py

@@ -0,0 +1,123 @@
+"""The family-wide decision/audit trail (port of btap-audit's log.rb).
+
+Every consequential step records WHAT was decided, the INPUTS it was decided
+from, the model EVIDENCE behind it, and (where applicable) the NECB ARTICLE or
+data-table citation that mandates it — so QAQC can answer "why did zone X get
+System 6?" from the log instead of diffing models.
+
+Entry schema (all optional except step/action/level):
+    {step, target, action, inputs, value, article, ruling, evidence,
+     building, level}     level: 'decision' | 'info' | 'warning'
+
+ruling: WHICH adjudicated project decision(s) govern this code path — the D-XX
+ids of the family's decision record. Where `article` cites the CODE that
+mandates a value, `ruling` cites OUR judgement call about how that code was
+read. Multiple ids are ONE space-separated string ('D-19 D-21'); consumers
+scan r'\\bD-\\d{2}\\b'.
+
+building: WHICH model the entry is about ('input model', 'proposed building',
+'reference building'), stamped from the current building context a pipeline
+sets at phase boundaries. None = cross-building comparison or verdict.
+
+Port notes (D-79): entries are str-keyed dicts throughout — Ruby's
+symbol-keys-in-memory / string-keys-in-JSON dualism collapses to str, which
+leaves the serialized audit.json IDENTICAL (the Leg-B contract). None-valued
+fields are dropped at insert (Ruby's `.compact`): consumers use
+``e.get('article')`` truthiness, never key presence with a None fallback
+difference. Contract: warnings are never silent.
+"""
+
+from __future__ import annotations
+
+import json
+from contextlib import contextmanager
+
+from btap._compat import ruby_str
+
+
+class AuditLog:
+    def __init__(self):
+        self.entries: list[dict] = []
+        self.building: str | None = None
+
+    @contextmanager
+    def with_building(self, name):
+        """Stamp every entry recorded inside the block with the given building
+        context; restores the previous context afterwards (nestable)."""
+        previous = self.building
+        self.building = name
+        try:
+            yield self
+        finally:
+            self.building = previous
+
+    def decision(self, step, action, *, target=None, inputs=None, value=None,
+                 article=None, ruling=None, evidence=None):
+        return self._add("decision", step, action, target, inputs, value,
+                         article, ruling, evidence)
+
+    def info(self, step, action, *, target=None, inputs=None, value=None,
+             article=None, ruling=None, evidence=None):
+        return self._add("info", step, action, target, inputs, value,
+                         article, ruling, evidence)
+
+    def warn(self, step, action, *, target=None, inputs=None, value=None,
+             article=None, ruling=None, evidence=None):
+        return self._add("warning", step, action, target, inputs, value,
+                         article, ruling, evidence)
+
+    @property
+    def warnings(self):
+        """Warning entries only. The recorded level is 'warning', not 'warn'."""
+        return [e for e in self.entries if e["level"] == "warning"]
+
+    def to_json(self) -> str:
+        return json.dumps(self.entries, indent=2, ensure_ascii=False)
+
+    def __str__(self):
+        """Human-readable narrative, one line per entry — same fixed-width
+        shape as Ruby's to_s (the umbrella's checklist classifier parses the
+        action text case-SENSITIVELY: violations SHOUTED, passes lowercase)."""
+        lines = []
+        for e in self.entries:
+            line = "[%-8s] %-13s %s" % (e["level"], e["step"], e["action"])
+            # Segment gates are RUBY truthiness (only nil/false falsy — '' and
+            # 0 print), not Python truthiness.
+            if _truthy(e.get("building")):
+                line += f" | building: {e['building']}"
+            if _truthy(e.get("target")):
+                line += f" | target: {e['target']}"
+            if _truthy(e.get("inputs")):
+                line += f" | inputs: {_compact_hash(e['inputs'])}"
+            if _truthy(e.get("value")):
+                line += f" | value: {ruby_str(e['value'])}"
+            if _truthy(e.get("evidence")):
+                line += f" | evidence: {e['evidence']}"
+            if _truthy(e.get("article")):
+                line += f" | per {e['article']}"
+            if _truthy(e.get("ruling")):
+                line += f" | ruling {e['ruling']}"
+            lines.append(line)
+        return "\n".join(lines)
+
+    def _add(self, level, step, action, target, inputs, value, article,
+             ruling, evidence):
+        entry = {"step": step, "target": target, "action": action,
+                 "inputs": inputs, "value": value, "article": article,
+                 "ruling": ruling, "evidence": evidence,
+                 "building": self.building, "level": level}
+        self.entries.append({k: v for k, v in entry.items() if v is not None})
+        return self
+
+
+def _truthy(value) -> bool:
+    """Ruby truthiness: everything except nil and false."""
+    return value is not None and value is not False
+
+
+def _compact_hash(inputs: dict) -> str:
+    """Ruby's inputs rendering: 'k=v, k=v', arrays joined with '/'."""
+    return ", ".join(
+        f"{k}={'/'.join(ruby_str(x) for x in v) if isinstance(v, list) else ruby_str(v)}"
+        for k, v in inputs.items()
+    )

canmet_btap-0.2.1/btap/costing/__init__.py

@@ -0,0 +1,14 @@
+"""btap.costing — pricing of model objects (port of the btap-costing gem).
+
+HVAC equipment BOMs, envelope assemblies, lighting fixtures, and SHW — one
+package owning the whole licensed-data seam. The vendored CSVs under
+``data/`` are PLACEHOLDER schema copies; real RS-Means values are injected
+at runtime (costs_csv=/local_factors_csv= kwargs, or BTAP_COSTING_DIR /
+OPENSTUDIO_COSTING_DIR) and are never committed or redistributed.
+
+Dependency direction is the design (D-77): costing imports btap.modeling
+and btap.audit, NEVER btap.necb. Where a costing rule needs NECB-owned
+geometry (the daylighted-area sensors), the NECB layer passes a provider in.
+Sub-namespaced (hvac/envelope/lighting + shw) because Database/Report exist
+per domain; import the domain modules directly.
+"""