typehaus 0.1.0a0__py3-none-any.whl

typehaus/__init__.py

@@ -0,0 +1,15 @@
+"""Type:Haus engine — typed declarative residential house modeling.
+
+The public authoring surface (everything the plan dialect may import) is re-exported
+here from ``typehaus.model``. Plan files import from ``typehaus`` and ``library``.
+"""
+
+from __future__ import annotations
+
+from typehaus._meta import PROJECT_NAME, engine_version
+from typehaus.model import *  # noqa: F401,F403 — re-export the authoring surface
+from typehaus.model import __all__ as _model_all
+
+__version__ = engine_version()
+
+__all__ = ["PROJECT_NAME", "engine_version", "__version__", *_model_all]

typehaus/_meta.py

@@ -0,0 +1,28 @@
+"""Brand-name and build-identity constants, centralized for cheap rename (→ 01 §Naming).
+
+A rename touches only this file, the ``pyproject.toml`` ``name``, the ``src/typehaus``
+directory, and the UI ``branding.ts`` — see ``docs/RENAME.md``.
+"""
+
+from __future__ import annotations
+
+from importlib.metadata import PackageNotFoundError, version
+
+PROJECT_NAME = "Type:Haus"
+PROJECT_SLUG = "typehaus"
+PROJECT_URL = "https://type-haus.com"
+CLI_NAME = "haus"
+
+# IFC header application name and pset prefix. The prefix is kept short and
+# brand-agnostic so the emitted IFC does not churn on a rename (→ 01 §Naming).
+IFC_APP_NAME = "Type:Haus"
+PSET_PREFIX = "Pset_TH"
+PSET_SOURCE = f"{PSET_PREFIX}_Source"
+
+
+def engine_version() -> str:
+    """Installed engine version, or a dev sentinel when running from a source tree."""
+    try:
+        return version(PROJECT_SLUG)
+    except PackageNotFoundError:
+        return "0.0.0+dev"

typehaus/analysis.py

@@ -0,0 +1,149 @@
+"""Model-level analysis helpers shared by the card and the checks (R-value, etc.).
+
+Tri-state honest (#32): a computation missing an input reports UNKNOWN with the material
+named, never a silent zero or a fabricated pass.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from typehaus.model.assembly import Assembly
+from typehaus.model.enums import LayerFunction
+from typehaus.model.plan import Library
+from typehaus.quantities import RValue, rsi
+
+
+@dataclass(frozen=True)
+class RValueResult:
+    value: RValue | None  # None => UNKNOWN
+    unknown_materials: tuple[str, ...]  # layer/material names lacking r_per_inch
+
+    @property
+    def known(self) -> bool:
+        return self.value is not None
+
+    def fmt(self) -> str:
+        if self.value is None:
+            missing = ", ".join(self.unknown_materials)
+            return f"UNKNOWN (missing r_per_inch: {missing})"
+        return self.value.fmt()
+
+
+# Still-air surface film resistances (RSI), interior + exterior, ASHRAE nominal.
+_FILM_RSI = 0.12 + 0.03
+
+
+def _layer_rsi(layer, library: Library, unknown: list[str]) -> float:
+    """Series RSI of one layer, parallel-pathed across its cavity fill if it has one.
+
+    A batt between studs is *not* in series with the studs — it is the other path through
+    the same depth. Summing both (which a sibling batt layer used to do) overstates a 2x6
+    wall by roughly the full cavity R. Area-weighted U per ASHRAE parallel-path:
+    ``U = ff*U_framing + (1-ff)*U_fill``.
+    """
+    from typehaus.quantities import r_us
+
+    mat = library.material(layer.material_ref)
+    if mat is None or mat.r_per_inch is None:
+        unknown.append(f"{layer.name}({layer.material_ref})")
+        return 0.0
+    framing_rsi = r_us(mat.r_per_inch * layer.thickness.inches).rsi
+
+    fill = getattr(layer, "cavity", None)
+    if fill is None:
+        return framing_rsi
+
+    fill_mat = library.material(fill.material_ref)
+    if fill_mat is None or fill_mat.r_per_inch is None:
+        unknown.append(f"{layer.name}-cavity({fill.material_ref})")
+        return 0.0
+    fill_thickness = fill.thickness if fill.thickness is not None else layer.thickness
+    fill_rsi = r_us(fill_mat.r_per_inch * fill_thickness.inches).rsi
+    # A shallower fill leaves still air in the rest of the bay; count only the fill so the
+    # result stays conservative rather than crediting an unsealed void.
+    if framing_rsi <= 0.0 or fill_rsi <= 0.0:
+        return max(framing_rsi, 0.0)
+    ff = min(max(fill.framing_factor, 0.0), 1.0)
+    u_eff = ff / framing_rsi + (1.0 - ff) / fill_rsi
+    return 1.0 / u_eff if u_eff > 0.0 else framing_rsi
+
+
+def assembly_r_value(asm: Assembly, library: Library, include_lining: bool = True,
+                     include_films: bool = True) -> RValueResult:
+    """Compute core (+ default_lining) R-value from material r_per_inch (#34)."""
+    total_rsi = _FILM_RSI if include_films else 0.0
+    unknown: list[str] = []
+    layers = list(asm.layers)
+    if include_lining:
+        layers = list(asm.default_lining) + layers
+    for layer in layers:
+        total_rsi += _layer_rsi(layer, library, unknown)
+    if unknown:
+        return RValueResult(value=None, unknown_materials=tuple(unknown))
+    return RValueResult(value=rsi(total_rsi), unknown_materials=())
+
+
+# The framing solver's o.c. default when a STRUCTURE layer's FramingSpec leaves it open;
+# reported so the delta compare never shows a blank spacing for an authored-by-omission wall.
+DEFAULT_FRAMING_SPACING_IN = 16.0
+
+
+@dataclass(frozen=True)
+class AssemblyMetrics:
+    """The comparable facts of one assembly — the delta-compare row's data (#53, → 21b).
+
+    Model-free like the section card itself: everything here reads off the authored
+    ``Assembly``, so two candidate assemblies can be weighed against each other before
+    either is placed on a wall. ``stc`` stays None unless the assembly carries a lab test
+    (#50) — an acoustic number is never computed.
+    """
+
+    tag: str
+    r_value: RValueResult
+    thickness_in: float
+    layer_count: int
+    structure_member: str | None       # nominal lumber size of the STRUCTURE layer, e.g. "2x6"
+    framing_spacing_in: float | None   # o.c. of that layer's framing
+    stc: int | None
+    variant_of: str | None
+
+    def as_dict(self) -> dict:
+        return {
+            "tag": self.tag,
+            "r_value": (round(self.r_value.value.r_us, 3)
+                        if self.r_value.value is not None else None),
+            "r_value_unknown_materials": list(self.r_value.unknown_materials),
+            "thickness_in": round(self.thickness_in, 4),
+            "layer_count": self.layer_count,
+            "structure_member": self.structure_member,
+            "framing_spacing_in": self.framing_spacing_in,
+            "stc": self.stc,
+            "variant_of": self.variant_of,
+        }
+
+
+def assembly_metrics(asm: Assembly, library: Library) -> AssemblyMetrics:
+    """Roll one assembly up to the numbers a designer compares alternatives on.
+
+    Thickness sums the whole built stack (default lining + core) because that is what the
+    hallway loses; cavity fill is deliberately excluded — it lives *inside* its host layer's
+    depth (→ :class:`CavityFill`) and adding it would double-count the wall.
+    """
+    stack = list(asm.default_lining) + list(asm.layers)
+    structure = next((ly for ly in stack if ly.function is LayerFunction.STRUCTURE), None)
+    spec = structure.framing if structure is not None else None
+    spacing_in = None
+    if spec is not None:
+        spacing_in = (spec.spacing.inches if spec.spacing is not None
+                      else DEFAULT_FRAMING_SPACING_IN)
+    return AssemblyMetrics(
+        tag=asm.tag,
+        r_value=assembly_r_value(asm, library),
+        thickness_in=sum(layer.thickness.inches for layer in stack),
+        layer_count=len(stack),
+        structure_member=spec.member if spec is not None else None,
+        framing_spacing_in=spacing_in,
+        stc=asm.stc,
+        variant_of=asm.variant_of,
+    )

typehaus/checks/__init__.py

@@ -0,0 +1,30 @@
+"""Checks framework — one registry, two invokers (pytest + `haus check`) (→ 12).
+
+Importing this package imports every tier module, registering all checks.
+"""
+
+from __future__ import annotations
+
+from typehaus.checks import advisory, building_science, integrity, mep, structural  # noqa: F401 - register
+from typehaus.checks.code import mn_energy, mn_residential, site  # noqa: F401 - register
+from typehaus.checks.registry import (
+    CheckContext,
+    CheckReport,
+    FramingPreferences,
+    PlumbingPreferences,
+    ReferenceUnderlay,
+    JurisdictionProfile,
+    Preferences,
+    Tier,
+    check,
+    registered,
+    run_checks,
+)
+from typehaus.checks.run import build_context, load_preferences, run, run_from_model
+from typehaus.checks.permit import PermitChecklist, PermitChecklistItem, evaluate_permit_checklist
+
+__all__ = [
+    "run", "run_from_model", "build_context", "load_preferences", "run_checks", "registered", "check",
+    "CheckContext", "CheckReport", "Preferences", "FramingPreferences", "PlumbingPreferences", "ReferenceUnderlay", "JurisdictionProfile", "Tier",
+    "PermitChecklist", "PermitChecklistItem", "evaluate_permit_checklist",
+]

typehaus/checks/advisory/__init__.py

@@ -0,0 +1,3 @@
+from __future__ import annotations
+
+from typehaus.checks.advisory import checks  # noqa: F401 - registers checks

typehaus/checks/advisory/checks.py

@@ -0,0 +1,297 @@
+"""Advisory checks — design intelligence, warn-only, reasoning shown (→ 12 §checks/advisory).
+
+Opinions with arithmetic behind them, never authority. Each finding states *why* and is
+individually suppressible in preferences.toml.
+"""
+
+from __future__ import annotations
+
+from typehaus.checks.registry import CheckContext, Tier, check
+from typehaus.findings import Finding, Result, Severity
+
+
+def _warn(cid: str, msg: str, tags: tuple[str, ...] = ()) -> Finding:
+    return Finding(severity=Severity.WARN, check_id=cid, message=msg, element_tags=tags,
+                   result=Result.FAIL)
+
+
+@check(Tier.ADVISORY, "advisory.habitable_window")
+def habitable_room_window(ctx: CheckContext) -> list[Finding]:
+    """Habitable rooms should have an exterior window (natural light, R303)."""
+    from typehaus.model.enums import Occupancy
+
+    habitable = {Occupancy.BEDROOM, Occupancy.LIVING, Occupancy.KITCHEN,
+                 Occupancy.DINING, Occupancy.OFFICE}
+    out: list[Finding] = []
+    has_window = any(not op.is_door for op in ctx.model.openings)
+    for room in (e for e in ctx.plan.all_elements() if e.element_kind == "Room"):
+        if room.occupancy in habitable and not has_window:
+            out.append(_warn("advisory.habitable_window",
+                             f"habitable room {room.tag} appears to have no window — "
+                             "consider natural light/ventilation", (room.tag,)))
+    return out
+
+
+@check(Tier.ADVISORY, "advisory.window_size_variety")
+def window_size_variety(ctx: CheckContext) -> list[Finding]:
+    """Fewer unique window sizes = cheaper ordering (reported as a fact with a histogram)."""
+    sizes: dict[tuple[float, float], int] = {}
+    for op in ctx.model.openings:
+        if not op.is_door:
+            key = (round(op.width_m, 3), round(op.height_m, 3))
+            sizes[key] = sizes.get(key, 0) + 1
+    if len(sizes) <= 1:
+        return []
+    hist = ", ".join(f"{w*39.37:.0f}x{h*39.37:.0f}\"×{n}" for (w, h), n in sizes.items())
+    return [_warn("advisory.window_size_variety",
+                  f"{len(sizes)} unique window sizes — fewer eases ordering ({hist})")]
+
+
+@check(Tier.ADVISORY, "advisory.control_continuity")
+def control_layer_continuity(ctx: CheckContext) -> list[Finding]:
+    """Warn where a tagged control layer dead-ends at a condition whose transition does
+    not declare continuity (walks junctions and stack edges, → 11b)."""
+    out: list[Finding] = []
+    transitions = ctx.plan.library.transitions
+    for cond in ctx.model.conditions:
+        if cond.kind.value not in ("storey_stack", "assembly_change"):
+            continue
+        declared = any(
+            _matches(t.condition_pattern, cond.key) and t.continuity for t in transitions
+        )
+        if not declared:
+            out.append(_warn("advisory.control_continuity",
+                             f"control-layer continuity not declared across {cond.key}",
+                             cond.element_tags))
+    return out
+
+
+@check(Tier.ADVISORY, "advisory.wet_wall_depth")
+def wet_wall_depth(ctx: CheckContext) -> list[Finding]:
+    """Drain fixtures need a real service chase, not an assumed 2x4-wall stack."""
+    from typehaus.model.enums import Service
+
+    types = {item.tag: item for item in ctx.plan.library.fixture_types}
+    required = ctx.preferences.plumbing.drain_stack_required_structure_in * 0.0254
+    out: list[Finding] = []
+    for fixture in (element for element in ctx.plan.all_elements()
+                    if element.element_kind == "Fixture"):
+        fixture_type = types.get(fixture.type_ref)
+        if fixture_type is None or Service.DRAIN not in fixture_type.needs:
+            continue
+        if fixture.wall_ref is None:
+            out.append(_warn("advisory.wet_wall_depth",
+                             f"drain fixture {fixture.tag} has no wall_ref for a service chase",
+                             (fixture.tag,)))
+            continue
+        wall = ctx.model.wall(fixture.wall_ref)
+        if wall is None:
+            out.append(_warn("advisory.wet_wall_depth",
+                             f"drain fixture {fixture.tag} references missing wall {fixture.wall_ref}",
+                             (fixture.tag, fixture.wall_ref)))
+            continue
+        structure = next((layer for layer in wall.layers if layer.function == "structure"), None)
+        if structure is None or structure.thickness_m + 1e-9 < required:
+            actual = structure.thickness_m / 0.0254 if structure is not None else 0.0
+            out.append(_warn(
+                "advisory.wet_wall_depth",
+                f"drain fixture {fixture.tag} uses {fixture.wall_ref} with {actual:.1f}\" structure; "
+                f"planning allowance requires {required / 0.0254:.1f}\" for its drain stack",
+                (fixture.tag, fixture.wall_ref),
+            ))
+    return out
+
+
+@check(Tier.ADVISORY, "advisory.fixture_room_unassigned")
+def fixture_room_unassigned(ctx: CheckContext) -> list[Finding]:
+    """A permit fixture schedule lists a room per fixture, so an unassignable one is worth
+    saying out loud.  This is the finding that replaced ``Fixture.room`` being a required
+    string: a drag that lands a fixture outside every resolvable room stays loadable and
+    keeps its authored position, and the gap is reported here instead of at import time."""
+    return [_warn("advisory.fixture_room_unassigned",
+                  f"fixture {obj.tag} is in no room — the fixture schedule needs one; move it "
+                  "inside a room or extend the room boundary", (obj.tag,))
+            for obj in ctx.model.canvas_objects
+            if obj.kind == "Fixture" and obj.room is None]
+
+
+@check(Tier.ADVISORY, "advisory.floor_heat_fixture_keepout")
+def floor_heat_fixture_keepout(ctx: CheckContext) -> list[Finding]:
+    """Radiant wire zones must not run beneath a fixture's authored footprint."""
+    from shapely.geometry import Polygon, box
+
+    types = {item.tag: item for item in ctx.plan.library.fixture_types}
+    fixtures = [
+        (storey.tag, element)
+        for storey in ctx.plan.storeys
+        for element in ctx.plan.storey_elements(storey.tag)
+        if element.element_kind == "Fixture"
+    ]
+    out: list[Finding] = []
+    for zone in ctx.model.floor_heat:
+        zone_polygon = Polygon(zone.zone)
+        for storey, fixture in fixtures:
+            if storey != zone.storey or fixture.type_ref not in types:
+                continue
+            width, depth = (value.meters for value in types[fixture.type_ref].footprint)
+            x, y = fixture.position.xy_m
+            footprint = box(x - width / 2, y - depth / 2, x + width / 2, y + depth / 2)
+            if zone_polygon.intersects(footprint):
+                out.append(_warn(
+                    "advisory.floor_heat_fixture_keepout",
+                    f"floor-heat zone {zone.tag} overlaps fixture {fixture.tag}; "
+                    "exclude the fixture footprint from the heating loop",
+                    (zone.tag, fixture.tag),
+                ))
+    return out
+
+
+@check(Tier.ADVISORY, "advisory.clearance_overlap")
+def clearance_overlap(ctx: CheckContext) -> list[Finding]:
+    """Surface authored fixture/furniture use-zone conflicts in both CLI and canvas.
+
+    Clearances are intentionally a planning envelope, not a code-compliance calculation:
+    rotations and wall-side semantics remain authored decisions.  A bounding envelope catches
+    the high-value case—another placed object occupies a declared use zone—without quietly
+    asserting that every item has a universal code clearance.
+    """
+    from shapely.geometry import box
+
+    fixtures = {item.tag: item for item in ctx.plan.library.fixture_types}
+    furniture = {item.tag: item for item in ctx.plan.library.furniture_types}
+    placed: list[tuple[str, object, tuple[float, float], tuple[float, float, float, float] | None]] = []
+    for storey in ctx.plan.storeys:
+        for element in ctx.plan.storey_elements(storey.tag):
+            if element.element_kind == "Fixture":
+                item = fixtures.get(element.type_ref)
+            elif element.element_kind == "Furniture":
+                item = furniture.get(element.type_ref)
+            else:
+                continue
+            if item is None:
+                continue
+            footprint = tuple(value.meters for value in item.footprint)
+            clearance = (tuple(value.meters for value in item.clearance)
+                         if item.clearance is not None else None)
+            placed.append((storey.tag, element, footprint, clearance))
+
+    out: list[Finding] = []
+    reported: set[tuple[str, str]] = set()
+    for storey, source, footprint, clearance in placed:
+        if clearance is None:
+            continue
+        front, back, left, right = clearance
+        x, y = source.position.xy_m
+        zone = box(x - footprint[0] / 2 - left, y - footprint[1] / 2 - back,
+                   x + footprint[0] / 2 + right, y + footprint[1] / 2 + front)
+        for other_storey, other, other_footprint, _ in placed:
+            if other_storey != storey or other.uid == source.uid:
+                continue
+            ox, oy = other.position.xy_m
+            other_box = box(ox - other_footprint[0] / 2, oy - other_footprint[1] / 2,
+                            ox + other_footprint[0] / 2, oy + other_footprint[1] / 2)
+            key = tuple(sorted((source.tag, other.tag)))
+            if zone.intersects(other_box) and key not in reported:
+                reported.add(key)
+                out.append(_warn(
+                    "advisory.clearance_overlap",
+                    f"declared clearance for {source.tag} overlaps {other.tag}; review the use zone",
+                    key,
+                ))
+    return out
+
+
+def _polygon_centroid(polygon) -> tuple[float, float] | None:
+    """Vertex mean — enough to locate a layer's thin rectangle relative to its neighbours."""
+    if not polygon:
+        return None
+    return (sum(p[0] for p in polygon) / len(polygon),
+            sum(p[1] for p in polygon) / len(polygon))
+
+
+def _cladding_offset(wall) -> tuple[float, float] | None:
+    """Innermost layer → cladding layer, i.e. the direction this wall calls "outdoors".
+
+    ``None`` for walls with nothing to orient: a single-layer or uncladded assembly is
+    symmetric, so no winding can put it on backwards.
+    """
+    layers = wall.depth_layers()
+    cladding = next((layer for layer in reversed(layers) if layer.function == "cladding"), None)
+    if cladding is None or len(layers) < 2 or cladding is layers[0]:
+        return None
+    inner = _polygon_centroid(layers[0].polygon)
+    outer = _polygon_centroid(cladding.polygon)
+    if inner is None or outer is None:
+        return None
+    return (outer[0] - inner[0], outer[1] - inner[1])
+
+
+@check(Tier.ADVISORY, "advisory.cladding_side_mismatch")
+def cladding_side_mismatch(ctx: CheckContext) -> list[Finding]:
+    """Adjacent clad walls must put their cladding on the same side of the run they form.
+
+    A wall's layers are laid out interior→exterior along its authored start→end direction
+    (times the storey's outward sign, → resolve/orientation), so authoring one wall of a run
+    backwards silently turns its stack inside out — face brick pointing at the porch, stucco
+    at the weather. Nothing downstream notices, because each wall is individually well-formed
+    and the storey still has a single outward sign. Comparing neighbours across a shared node
+    catches it without having to decide which side of the run is outdoors: walk node ``a→n``
+    then ``n→b`` and the cladding must sit on the same hand of both legs.
+    """
+    import math
+
+    out: list[Finding] = []
+    for storey in ctx.plan.storeys:
+        elements = ctx.plan.storey_elements(storey.tag)
+        positions = {e.tag: e.position.xy_m for e in elements if e.element_kind == "Node"}
+        # node tag -> [(wall tag, far-end node tag, cladding offset)]
+        incident: dict[str, list[tuple[str, str, tuple[float, float]]]] = {}
+        for element in elements:
+            if element.element_kind not in ("Wall", "FoundationWall"):
+                continue
+            resolved = ctx.model.wall(element.tag)
+            if resolved is None:
+                continue
+            offset = _cladding_offset(resolved)
+            if offset is None:
+                continue
+            a, b = element.start_node, element.end_node
+            if a not in positions or b not in positions or a == b:
+                continue
+            incident.setdefault(a, []).append((element.tag, b, offset))
+            incident.setdefault(b, []).append((element.tag, a, offset))
+
+        for node, legs in sorted(incident.items()):
+            # Only an unambiguous two-wall corner/joint has one traversal; at a branch the
+            # "same side" question has no single answer, so say nothing rather than guess.
+            if len(legs) != 2:
+                continue
+            (tag_a, far_a, offset_a), (tag_b, far_b, offset_b) = legs
+            here = positions[node]
+            # Traverse the run far_a -> node -> far_b, then take each leg's cladding hand.
+            hands = []
+            for (far, offset, incoming) in ((far_a, offset_a, True), (far_b, offset_b, False)):
+                direction = ((here[0] - positions[far][0], here[1] - positions[far][1])
+                             if incoming
+                             else (positions[far][0] - here[0], positions[far][1] - here[1]))
+                length = math.hypot(*direction)
+                if length < 1e-9:
+                    break
+                hands.append((direction[0] * offset[1] - direction[1] * offset[0]) / length)
+            if len(hands) != 2 or min(abs(h) for h in hands) < 1e-9:
+                continue
+            if hands[0] * hands[1] < 0.0:
+                out.append(_warn(
+                    "advisory.cladding_side_mismatch",
+                    f"{tag_a} and {tag_b} meet at {node} but their cladding faces opposite "
+                    "sides of the run — one of them is authored end-to-start, so its layer "
+                    "stack is inside out; swap that wall's start_node/end_node",
+                    (tag_a, tag_b, node),
+                ))
+    return out
+
+
+def _matches(pattern: str, key: str) -> bool:
+    import fnmatch
+
+    return fnmatch.fnmatch(key, pattern)

typehaus/checks/building_science/__init__.py

@@ -0,0 +1,5 @@
+from __future__ import annotations
+
+"""Building-science checks — advisory physics analyses introduced in M5."""
+
+from typehaus.checks.building_science import condensation, wwr  # noqa: F401 - register