unicad-kit 0.1.0__py3-none-any.whl

interchange/features/DistanceSpan.py

@@ -0,0 +1,46 @@
+# SPDX-License-Identifier: MIT
+# SPDX-FileCopyrightText: Copyright (c) 2026 Parashell, Odin Glynn-Martin, Stephen Harcourt
+
+from math import isfinite as IsFinite
+from sys import float_info as FloatInfo
+
+# shared side names keep reference roles and evaluated distances in agreement
+KDistModes = ("one_sided", "two_sided", "symmetric_full", "symmetric_half")
+
+
+# signed profile relative bounds retain the effect of offsets and reversed distances
+def GetDistSpan(
+    AlongMm: float, AgainstMm: float | None, OffsetMm: float, SideMode: str
+) -> tuple[float, float]:
+    Controls = (
+        (AlongMm, OffsetMm) if AgainstMm is None else (AlongMm, OffsetMm, AgainstMm)
+    )
+    if not all(
+        type(Value) in (float, int) and -FloatInfo.max <= Value <= FloatInfo.max
+        for Value in Controls
+    ):
+        raise ValueError("distance extrusion requires finite axial controls")
+    AlongMm, OffsetMm = float(AlongMm), float(OffsetMm)
+    AgainstMm = None if AgainstMm is None else float(AgainstMm)
+    if SideMode not in KDistModes:
+        raise ValueError("distance extrusion has an invalid side mode")
+    if (SideMode == "two_sided") != (AgainstMm is not None):
+        raise ValueError("distance extrusion side mode and against distance disagree")
+    if SideMode == "one_sided":
+        Lower = min(OffsetMm, OffsetMm + AlongMm)
+        Upper = max(OffsetMm, OffsetMm + AlongMm)
+    elif AlongMm <= 0.0 or (AgainstMm is not None and AgainstMm <= 0.0):
+        raise ValueError("two sided and symmetric extrusion distances must be positive")
+    elif AgainstMm is not None:
+        Lower, Upper = OffsetMm - AgainstMm, OffsetMm + AlongMm
+    else:
+        HalfSpan = AlongMm / 2.0 if SideMode == "symmetric_full" else AlongMm
+        Lower, Upper = OffsetMm - HalfSpan, OffsetMm + HalfSpan
+    if not (
+        IsFinite(Lower)
+        and IsFinite(Upper)
+        and Lower < Upper
+        and IsFinite(Upper - Lower)
+    ):
+        raise ValueError("distance extrusion requires finite distinct axial limits")
+    return Lower, Upper

interchange/features/DistanceValues.py

@@ -0,0 +1,63 @@
+# SPDX-License-Identifier: MIT
+# SPDX-FileCopyrightText: Copyright (c) 2026 Parashell, Odin Glynn-Martin, Stephen Harcourt
+
+from dataclasses import dataclass as MakeDataClass
+from math import pi as CirclePi
+from typing import Mapping as TypeMap
+
+from interchange.enums.EnumFeatures import BooleanOp, FeatureKind
+from interchange.enums.EnumValues import ValueKind
+from interchange.features.DistanceParam import GetDistParam
+from interchange.features.DistanceSpan import GetDistSpan
+from interchange.features.FeatureDistExt import DistanceExtrude
+from interchange.features.FeatureStep import FeatureStep
+from interchange.records.RecordParameter import Parameter
+
+
+# geometry builders need evaluated dimensions without replacing the editable definition
+@MakeDataClass(frozen=True, slots=True)
+class DistExtValues:
+    LowerMm: float
+    UpperMm: float
+    OffsetMm: float
+    TaperRadians: float
+    SecondTaperRadians: float | None
+
+
+# source readers and geometry builders share one checked evaluation of owned controls
+def GetDistValues(
+    StepValue: FeatureStep,
+    Definition: DistanceExtrude,
+    Parameters: TypeMap[str, Parameter],
+) -> DistExtValues:
+    if (
+        StepValue.kind != FeatureKind.KExtrusion
+        or StepValue.operation != BooleanOp.KCreate
+    ):
+        raise ValueError("distance extrusion requires a create extrusion feature")
+    Along = GetDistParam(
+        StepValue, Definition.AlongParameterId, Parameters, ValueKind.KLength
+    )
+    Against, Offset, Taper, SecondTaper = (
+        (
+            None
+            if Identity is None
+            else GetDistParam(StepValue, Identity, Parameters, KindValue)
+        )
+        for Identity, KindValue in (
+            (Definition.AgainstParameterId, ValueKind.KLength),
+            (Definition.StartOffsetId, ValueKind.KLength),
+            (Definition.TaperParameterId, ValueKind.KAngle),
+            (Definition.SecondTaperId, ValueKind.KAngle),
+        )
+    )
+    if any(
+        Value is not None and abs(Value) >= CirclePi / 2.0
+        for Value in (Taper, SecondTaper)
+    ):
+        raise ValueError("distance extrusion taper must be less than a right angle")
+    OffsetMm = 0.0 if Offset is None else Offset
+    LowerMm, UpperMm = GetDistSpan(Along, Against, OffsetMm, Definition.SideMode)
+    return DistExtValues(
+        LowerMm, UpperMm, OffsetMm, 0.0 if Taper is None else Taper, SecondTaper
+    )

interchange/features/ExtrudeSecond.py

@@ -0,0 +1,47 @@
+# SPDX-License-Identifier: MIT
+# SPDX-FileCopyrightText: Copyright (c) 2026 Parashell, Odin Glynn-Martin, Stephen Harcourt
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING as IsTypeCheck
+from typing import cast as CastValue
+
+from interchange.records.RecordParameter import ParameterValue
+
+if IsTypeCheck:
+    from interchange.features.FeatureExtrude import (
+        ExtrudeEnd,  # lgtm[py/unsafe-cyclic-import]
+    )
+
+
+# two sided extrusion consumers read secondary caps and offsets through one view
+class ExtrudeSecond:
+    __slots__: tuple[str, ...] = ()
+
+    # second length supports two sided extrudes without synthetic features
+    @property
+    def SecondLength(self) -> ParameterValue | None:
+        return CastValue(ParameterValue | None, getattr(self, "second_length"))
+
+    # second end condition keeps asymmetric caps expressible in one step
+    @property
+    def SecondEndCondition(self) -> "ExtrudeEnd | str | None":
+        return CastValue(
+            "ExtrudeEnd | str | None",
+            getattr(self, "second_end_condition"),
+        )
+
+    # second offset keeps two sided starts independently controllable
+    @property
+    def SecondOffset(self) -> ParameterValue | None:
+        return CastValue(ParameterValue | None, getattr(self, "second_offset"))
+
+    # second draft angle keeps tapered two sided walls expressible
+    @property
+    def SecondDraftAngle(self) -> ParameterValue | None:
+        return CastValue(ParameterValue | None, getattr(self, "second_draft_angle"))
+
+    # second target keeps two sided up to extrudes symmetric in capability
+    @property
+    def SecondUpToRef(self) -> str:
+        return CastValue(str, getattr(self, "second_up_to_reference"))

interchange/features/ExtrudeShape.py

@@ -0,0 +1,60 @@
+# SPDX-License-Identifier: MIT
+# SPDX-FileCopyrightText: Copyright (c) 2026 Parashell, Odin Glynn-Martin, Stephen Harcourt
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING as IsTypeCheck
+from typing import cast as CastValue
+
+from interchange.geometry.models.VectorSpace import SpaceVector
+from interchange.records.RecordParameter import ParameterValue
+
+if IsTypeCheck:
+    from interchange.features.FeatureExtrude import (
+        ExtrudeEnd,  # lgtm[py/unsafe-cyclic-import]
+    )
+
+
+# single sided extrusion consumers read primary direction bounds through one view
+class ExtrudeShape:
+    __slots__: tuple[str, ...] = ()
+
+    # extrusion length defines prism height without evaluating geometry
+    @property
+    def Length(self) -> ParameterValue:
+        return CastValue(ParameterValue, getattr(self, "length"))
+
+    # end condition captures blind through all and up to semantics in one field
+    @property
+    def EndCondition(self) -> "ExtrudeEnd | str":
+        return CastValue("ExtrudeEnd | str", getattr(self, "end_condition"))
+
+    # orientation flag preserves which side of the topology is used
+    @property
+    def IsReversed(self) -> bool:
+        return CastValue(bool, getattr(self, "reversed"))
+
+    # symmetric mode doubles length automatically so writers need no second value
+    @property
+    def IsSymmetric(self) -> bool:
+        return CastValue(bool, getattr(self, "symmetric"))
+
+    # unit heading keeps linear geometry orientation explicit for writers
+    @property
+    def Direction(self) -> SpaceVector | None:
+        return CastValue(SpaceVector | None, getattr(self, "direction"))
+
+    # start offset lets extrudes begin away from the sketch plane
+    @property
+    def Offset(self) -> ParameterValue | None:
+        return CastValue(ParameterValue | None, getattr(self, "offset"))
+
+    # draft angle encodes mold pull so solids survive manufacturing review
+    @property
+    def DraftAngle(self) -> ParameterValue | None:
+        return CastValue(ParameterValue | None, getattr(self, "draft_angle"))
+
+    # target reference makes length follow existing geometry instead of magic numbers
+    @property
+    def UpToReference(self) -> str:
+        return CastValue(str, getattr(self, "up_to_reference"))

interchange/features/FeatureAngleRev.py

@@ -0,0 +1,46 @@
+# SPDX-License-Identifier: MIT
+# SPDX-FileCopyrightText: Copyright (c) 2026 Parashell, Odin Glynn-Martin, Stephen Harcourt
+
+from typing import cast as CastValue
+from dataclasses import dataclass as MakeDataClass
+
+from interchange.features.FeatureContract import FeatureDef
+from interchange.features.RevolveAxis import CheckRevAxis
+from interchange.features.RevolveSpan import KAngleModes
+from interchange.geometry.models.VectorSpace import SpaceVector
+
+
+# linked parameters preserve editable angular limits without keeping stale angle copies
+@MakeDataClass(frozen=True, slots=True)
+class AngularRevolve(FeatureDef):
+    """Axis origin is in millimetres. Owned angle parameters are in radians."""
+
+    AxisSelectionId: str
+    AlongParameterId: str
+    AxisOrigin: SpaceVector
+    AxisDirection: SpaceVector
+    SideMode: str = "one_sided"
+    AgainstParameterId: str | None = None
+
+    # explicit reference roles keep reevaluated sweeps tied to the selected side mode
+    def __post_init__(self) -> None:
+        CheckRevAxis(self.AxisOrigin, self.AxisDirection)
+        if self.SideMode not in KAngleModes:
+            raise ValueError("angular revolution has an invalid side mode")
+        Against = self.AgainstParameterId
+        if (self.SideMode == "one_sided") != (Against is None):
+            raise ValueError(
+                "angular revolution side mode and against parameter disagree"
+            )
+        Identities: tuple[str, ...] = (self.AxisSelectionId, self.AlongParameterId)
+        if Against is not None:
+            Identities += (Against,)
+        if not all(
+            isinstance(CastValue(object, Identity), str) and Identity.strip()
+            for Identity in Identities
+        ):
+            raise ValueError(
+                "angular revolution selection and parameter ids must be nonempty text"
+            )
+        if self.AlongParameterId == Against:
+            raise ValueError("angular revolution angle parameters must be distinct")

interchange/features/FeatureBody.py

@@ -0,0 +1,60 @@
+# SPDX-License-Identifier: MIT
+# SPDX-FileCopyrightText: Copyright (c) 2026 Parashell, Odin Glynn-Martin, Stephen Harcourt
+
+from __future__ import annotations
+
+from dataclasses import dataclass as MakeDataClass
+from dataclasses import field as MakeDataField
+from typing import Mapping as TypeMap
+
+from interchange.core.Common import FreezeMapping
+from interchange.core.ModelBase import ModelBase
+from interchange.records.RecordProvenance import Provenance
+from interchange.records.RecordTopology import TopologyCounts
+
+
+# design bodies connect feature results with topology material and source evidence
+@MakeDataClass(frozen=True, slots=True)
+class DesignBody(ModelBase):
+    id: str
+    name: str
+    final_feature_id: str
+    topology: TopologyCounts = TopologyCounts()
+    material_id: str | None = None
+    provenance: Provenance | None = None
+    attributes: TypeMap[str, object] = MakeDataField(default_factory=FreezeMapping)
+
+    # stable identity lets records reference each other without holding full objects
+    @property
+    def EntityId(self) -> str:
+        return self.id
+
+    # human readable label keeps diagnostics and diffs meaningful for reviewers
+    @property
+    def EntityName(self) -> str:
+        return self.name
+
+    # resolved feature id keeps downstream steps referencing stable results
+    @property
+    def FinalFeatureId(self) -> str:
+        return self.final_feature_id
+
+    # counted topology keeps mass property claims checkable quickly
+    @property
+    def Topology(self) -> TopologyCounts:
+        return self.topology
+
+    # optional material link keeps appearance data joinable later
+    @property
+    def MaterialId(self) -> str | None:
+        return self.material_id
+
+    # origin details stay optional so synthesized records can omit source facts safely
+    @property
+    def Provenance(self) -> Provenance | None:
+        return self.provenance
+
+    # open attribute bag preserves vendor extras that typed fields cannot express yet
+    @property
+    def Attributes(self) -> TypeMap[str, object]:
+        return self.attributes

interchange/features/FeatureBoundPlane.py

@@ -0,0 +1,49 @@
+# SPDX-License-Identifier: MIT
+# SPDX-FileCopyrightText: Copyright (c) 2026 Parashell, Odin Glynn-Martin, Stephen Harcourt
+
+
+from typing import cast as CastValue
+from dataclasses import dataclass as MakeDataClass
+
+from interchange.features.FeatureContract import FeatureDef
+from interchange.features.PlaneExtFrame import GetExtFrame
+from interchange.geometry.models.Transform import Transform
+
+
+# a construction datum retains the two owned controls and the zero pose
+@MakeDataClass(frozen=True, slots=True)
+class BoundDatum(FeatureDef):
+    SupportPlaneId: str
+    ScalarParameterId: str
+    OffsetParameterId: str
+    Method: str
+    ReferenceFrame: Transform
+
+    # disjoint bindings keep the active control and inactive offset independently typed
+    def __post_init__(self) -> None:
+        if self.Method not in ("offset", "angle"):
+            raise ValueError("unsupported construction plane method")
+        if (
+            not all(
+                isinstance(CastValue(object, Value), str) and Value.strip()
+                for Value in (
+                    self.SupportPlaneId,
+                    self.ScalarParameterId,
+                    self.OffsetParameterId,
+                )
+            )
+            or self.ScalarParameterId == self.OffsetParameterId
+        ):
+            raise ValueError("construction plane requires distinct parameter bindings")
+        try:
+            _ = GetExtFrame(self.ReferenceFrame)
+        except ValueError as ErrorInfo:
+            raise ValueError(
+                "construction plane reference frame is invalid"
+            ) from ErrorInfo
+
+
+# the original model name remains stable for serialization and public imports
+BoundConstructionPlane = BoundDatum
+setattr(BoundDatum, "__name__", "BoundConstructionPlane")
+setattr(BoundDatum, "__qualname__", "BoundConstructionPlane")

interchange/features/FeatureBoundScale.py

@@ -0,0 +1,32 @@
+# SPDX-License-Identifier: MIT
+# SPDX-FileCopyrightText: Copyright (c) 2026 Parashell, Odin Glynn-Martin, Stephen Harcourt
+
+from typing import cast as CastValue
+from dataclasses import dataclass as MakeDataClass
+
+from interchange.features.FeatureContract import FeatureDef
+
+
+# editable scale inputs retain scalar bindings and independently selected operands
+@MakeDataClass(frozen=True, slots=True)
+class BoundScale(FeatureDef):
+    FactorParameterIds: tuple[str, ...]
+    CenterSelectionId: str
+    BodySelectionIds: tuple[str, ...]
+
+    # one uniform or three axis bindings can drive one or more distinct body inputs
+    def __post_init__(self) -> None:
+        Picks = (self.CenterSelectionId, *self.BodySelectionIds)
+        if not all(
+            isinstance(CastValue(object, Value), str) and Value.strip()
+            for Value in (*self.FactorParameterIds, *Picks)
+        ):
+            raise ValueError("scale input identities must be nonempty text")
+        if len(self.FactorParameterIds) not in (1, 3) or len(
+            set(self.FactorParameterIds)
+        ) != len(self.FactorParameterIds):
+            raise ValueError(
+                "scale requires one uniform or three distinct axis parameters"
+            )
+        if not self.BodySelectionIds or len(set(Picks)) != len(Picks):
+            raise ValueError("scale requires a center and distinct body selections")

interchange/features/FeatureContract.py

@@ -0,0 +1,9 @@
+# SPDX-License-Identifier: MIT
+# SPDX-FileCopyrightText: Copyright (c) 2026 Parashell, Odin Glynn-Martin, Stephen Harcourt
+
+from interchange.core.ModelBase import ModelBase
+
+
+# feature definitions share one runtime contract so future kinds remain extensible
+class FeatureDef(ModelBase):
+    locals()["__slots__"] = ()

interchange/features/FeatureDistExt.py

@@ -0,0 +1,69 @@
+# SPDX-License-Identifier: MIT
+# SPDX-FileCopyrightText: Copyright (c) 2026 Parashell, Odin Glynn-Martin, Stephen Harcourt
+
+from dataclasses import dataclass as MakeDataClass
+from math import hypot as Hypot
+from math import isclose as IsClose
+from sys import float_info as FloatInfo
+from typing import cast as CastValue
+
+from interchange.features.DistanceSpan import KDistModes
+from interchange.features.FeatureContract import FeatureDef
+from interchange.geometry.models.VectorSpace import SpaceVector
+
+
+# owned distance controls preserve edit intent without stale copies of parameter values
+@MakeDataClass(frozen=True, slots=True)
+class DistanceExtrude(FeatureDef):
+    """Distance extrusion along a unit vector in the profile component frame."""
+
+    AlongParameterId: str
+    Direction: SpaceVector
+    SideMode: str = "one_sided"
+    AgainstParameterId: str | None = None
+    StartOffsetId: str | None = None
+    TaperParameterId: str | None = None
+    SecondTaperId: str | None = None
+
+    # distinct roles prevent a parameter from changing unrelated extrusion controls
+    def __post_init__(self) -> None:
+        if not isinstance(CastValue(object, self.Direction), SpaceVector):
+            raise ValueError("distance extrusion requires a spatial direction")
+        Vector = (self.Direction.x, self.Direction.y, self.Direction.z)
+        if not all(
+            type(Value) in (float, int) and -FloatInfo.max <= Value <= FloatInfo.max
+            for Value in Vector
+        ) or not IsClose(Hypot(*Vector), 1.0, abs_tol=1e-9, rel_tol=0.0):
+            raise ValueError(
+                "distance extrusion direction must be a finite unit vector"
+            )
+        if self.SideMode not in KDistModes:
+            raise ValueError("distance extrusion has an invalid side mode")
+        if (self.SideMode == "two_sided") != (self.AgainstParameterId is not None):
+            raise ValueError(
+                "distance extrusion side mode and against parameter disagree"
+            )
+        if self.SecondTaperId is not None and (
+            self.SideMode == "one_sided"
+            or (
+                self.SideMode != "two_sided"
+                and self.SecondTaperId != self.TaperParameterId
+            )
+        ):
+            raise ValueError("distance extrusion side mode and second taper disagree")
+        Extra = (
+            self.AgainstParameterId,
+            self.StartOffsetId,
+            self.TaperParameterId,
+            self.SecondTaperId if self.SideMode == "two_sided" else None,
+        )
+        Identities = (self.AlongParameterId,) + tuple(
+            Identity for Identity in Extra if Identity is not None
+        )
+        if not all(
+            isinstance(CastValue(object, Identity), str) and Identity.strip()
+            for Identity in Identities
+        ):
+            raise ValueError("distance extrusion parameter ids must be nonempty text")
+        if len(set(Identities)) != len(Identities):
+            raise ValueError("distance extrusion parameter roles must be distinct")

interchange/features/FeatureExtrude.py

@@ -0,0 +1,61 @@
+# SPDX-License-Identifier: MIT
+# SPDX-FileCopyrightText: Copyright (c) 2026 Parashell, Odin Glynn-Martin, Stephen Harcourt
+
+from __future__ import annotations
+
+from dataclasses import dataclass as MakeDataClass
+
+from interchange.enums.EnumBase import WireEnum
+from interchange.features.ExtrudeSecond import (
+    ExtrudeSecond,  # lgtm[py/unsafe-cyclic-import]
+)
+from interchange.features.FeatureContract import FeatureDef
+from interchange.features.ExtrudeShape import (
+    ExtrudeShape,  # lgtm[py/unsafe-cyclic-import]
+)
+from interchange.records.RecordParameter import ParameterValue
+from interchange.geometry.models.VectorSpace import SpaceVector
+
+
+# extrusion bounds preserve editable termination intent instead of only distance
+class ExtrudeEnd(WireEnum):
+    BLIND = "blind"
+    THROUGH_ALL = "through_all"
+    UP_TO_FIRST = "up_to_first"
+    UP_TO_LAST = "up_to_last"
+    UP_TO_FACE = "up_to_face"
+    UP_TO_SHAPE = "up_to_shape"
+    UP_TO_VERTEX = "up_to_vertex"
+    TWO_LENGTHS = "two_lengths"
+    MID_PLANE = "mid_plane"
+    OFFSET_FROM_SURFACE = "offset_from_surface"
+    NATIVE = "native"
+    KBlind = "blind"
+    KThroughAll = "through_all"
+    KUpToFirst = "up_to_first"
+    KUpToLast = "up_to_last"
+    KUpToFace = "up_to_face"
+    KUpToShape = "up_to_shape"
+    KUpToVertex = "up_to_vertex"
+    KTwoLengths = "two_lengths"
+    KMidPlane = "mid_plane"
+    KOffsetSurface = "offset_from_surface"
+    KNative = "native"
+
+
+# extrusions retain directional and termination choices needed for reconstruction
+@MakeDataClass(frozen=True, slots=True)
+class ExtrudeFeature(ExtrudeShape, ExtrudeSecond, FeatureDef):
+    length: ParameterValue
+    end_condition: ExtrudeEnd | str = ExtrudeEnd.KBlind
+    reversed: bool = False
+    symmetric: bool = False
+    direction: SpaceVector | None = None
+    second_length: ParameterValue | None = None
+    second_end_condition: ExtrudeEnd | str | None = None
+    offset: ParameterValue | None = None
+    second_offset: ParameterValue | None = None
+    draft_angle: ParameterValue | None = None
+    second_draft_angle: ParameterValue | None = None
+    up_to_reference: str = ""
+    second_up_to_reference: str = ""