idfpy 25.2.2__tar.gz → 25.2.3__tar.gz

{idfpy-25.2.2 → idfpy-25.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: idfpy
-Version: 25.2.2
+Version: 25.2.3
 Summary: Type-safe Pydantic models for all EnergyPlus IDF objects
 Project-URL: Repository, https://github.com/ITOTI-Y/idfpy
 Project-URL: Issues, https://github.com/ITOTI-Y/idfpy/issues

idfpy-25.2.3/idfpy/ext/construction/__init__.py

@@ -0,0 +1,7 @@
+"""Construction extension — ordered layers and window/opaque classification."""
+
+from .mixins import ConstructionLayersMixin
+
+MIXIN_MAP: dict[str, type] = {
+    'Construction': ConstructionLayersMixin,
+}

idfpy-25.2.3/idfpy/ext/construction/functions.py

@@ -0,0 +1,78 @@
+"""Material classification and layer resolution for layered constructions."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Final
+
+from idfpy.models.constructions import (
+    WindowMaterialBlind,
+    WindowMaterialGas,
+    WindowMaterialGasMixture,
+    WindowMaterialGlazing,
+    WindowMaterialGlazingGroupThermochromic,
+    WindowMaterialGlazingRefractionExtinctionMethod,
+    WindowMaterialScreen,
+    WindowMaterialShade,
+    WindowMaterialSimpleGlazingSystem,
+)
+
+if TYPE_CHECKING:
+    from idfpy.models._base import IDFBaseModel
+    from idfpy.models.constructions import Construction
+
+# Window-material layer types accepted by ``Construction`` layer fields.
+WINDOW_MATERIAL_TYPES: Final = (
+    WindowMaterialBlind,
+    WindowMaterialGas,
+    WindowMaterialGasMixture,
+    WindowMaterialGlazing,
+    WindowMaterialGlazingGroupThermochromic,
+    WindowMaterialGlazingRefractionExtinctionMethod,
+    WindowMaterialScreen,
+    WindowMaterialShade,
+    WindowMaterialSimpleGlazingSystem,
+)
+
+
+def is_window_material(material: IDFBaseModel) -> bool:
+    """Whether ``material`` is a window-material layer (glazing, gas or shading)."""
+    return isinstance(material, WINDOW_MATERIAL_TYPES)
+
+
+def construction_layers(construction: Construction) -> list[IDFBaseModel]:
+    """Resolve the layers of a bound construction.
+
+    Args:
+        construction: Construction bound to an IDF container.
+
+    Returns:
+        Materials from outside to inside; repeated names yield repeated
+        entries and empty layer fields are skipped.
+
+    Raises:
+        RuntimeError: If the construction is not bound to an IDF.
+        LookupError: If a layer name does not resolve to any material.
+    """
+    c = construction
+    slots = (
+        (c.outside_layer, c.outside_layer_ref),
+        (c.layer_2, c.layer_2_ref),
+        (c.layer_3, c.layer_3_ref),
+        (c.layer_4, c.layer_4_ref),
+        (c.layer_5, c.layer_5_ref),
+        (c.layer_6, c.layer_6_ref),
+        (c.layer_7, c.layer_7_ref),
+        (c.layer_8, c.layer_8_ref),
+        (c.layer_9, c.layer_9_ref),
+        (c.layer_10, c.layer_10_ref),
+    )
+    layers: list[IDFBaseModel] = []
+    for name, material in slots:
+        if not name:
+            continue
+        if material is None:
+            raise LookupError(
+                f'Construction {c.name!r} references unknown material {name!r}'
+            )
+        layers.append(material)
+    return layers

idfpy-25.2.3/idfpy/ext/construction/mixins.py

@@ -0,0 +1,38 @@
+"""Layer access and classification mixin for ``Construction``."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from idfpy.models._base import IDFBaseModel
+    from idfpy.models.constructions import Construction
+
+# ``functions`` imports the window-material classes from
+# ``idfpy.models.constructions``, which itself imports this mixin; the
+# imports below are deferred to break that cycle.
+
+
+class ConstructionLayersMixin:
+    """Ordered layer access and window/opaque classification."""
+
+    @property
+    def layers(self: Construction) -> list[IDFBaseModel]:
+        """Materials from outside to inside (see ``construction_layers``)."""
+        from .functions import construction_layers
+
+        return construction_layers(self)
+
+    @property
+    def is_window_construction(self: Construction) -> bool:
+        """Whether every layer is a window material (glazing, gas or shading)."""
+        from .functions import construction_layers, is_window_material
+
+        return all(is_window_material(m) for m in construction_layers(self))
+
+    @property
+    def is_opaque_construction(self: Construction) -> bool:
+        """Whether no layer is a window material."""
+        from .functions import construction_layers, is_window_material
+
+        return not any(is_window_material(m) for m in construction_layers(self))

{idfpy-25.2.2 → idfpy-25.2.3}/idfpy/models/constructions.py

@@ -11,6 +11,8 @@ from typing import TYPE_CHECKING, Any, ClassVar, Literal  # noqa: F401
 
 from pydantic import Field
 
+from idfpy.ext.construction.mixins import ConstructionLayersMixin
+
 from ._base import IDFBaseModel
 from ._refs import (
     BivariateFunctionsRef,
@@ -107,7 +109,7 @@ class WindowMaterialGlazingGroupThermochromicTemperatureDataItem(IDFBaseModel):
         return idf._resolve_forward(v, ['GlazingMaterialName'])
 
 
-class Construction(IDFBaseModel):
+class Construction(ConstructionLayersMixin, IDFBaseModel):
     """Start with outside layer and work your way to the inside layer Up to 10
     layers total, 8 for windows Enter the material name for each layer"""
 

{idfpy-25.2.2 → idfpy-25.2.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "idfpy"
-version = "25.2.2"
+version = "25.2.3"
 description = "Type-safe Pydantic models for all EnergyPlus IDF objects"
 readme = "README.md"
 requires-python = ">=3.12"

idfpy-25.2.3/tests/test_ext_construction.py

@@ -0,0 +1,136 @@
+"""Tests for the construction ext plugin: layer resolution and classification."""
+
+from __future__ import annotations
+
+import pytest
+
+import idfpy.models as models
+from idfpy import IDF
+from idfpy.ext.construction.functions import is_window_material
+from idfpy.models._ref_meta import REF_PROVIDERS
+from idfpy.models.constructions import (
+    Construction,
+    Material,
+    WindowMaterialGas,
+    WindowMaterialGlazing,
+    WindowMaterialSimpleGlazingSystem,
+)
+
+OPAQUE_LAYER_TYPES = {
+    'Material',
+    'Material:AirGap',
+    'Material:InfraredTransparent',
+    'Material:NoMass',
+    'Material:RoofVegetation',
+}
+WINDOW_LAYER_TYPES = {
+    'WindowMaterial:Blind',
+    'WindowMaterial:Gas',
+    'WindowMaterial:GasMixture',
+    'WindowMaterial:Glazing',
+    'WindowMaterial:Glazing:RefractionExtinctionMethod',
+    'WindowMaterial:GlazingGroup:Thermochromic',
+    'WindowMaterial:Screen',
+    'WindowMaterial:Shade',
+    'WindowMaterial:SimpleGlazingSystem',
+}
+
+
+def _layer_material_classes() -> dict[str, type[models.IDFBaseModel]]:
+    layer_types = {
+        object_type
+        for object_type, fields in REF_PROVIDERS.items()
+        if any('MaterialName' in groups for _, groups in fields)
+    }
+    classes = (getattr(models, name) for name in models.__all__)
+    return {
+        cls.idf_object_type(): cls
+        for cls in classes
+        if isinstance(cls, type)
+        and issubclass(cls, models.IDFBaseModel)
+        and getattr(cls, '_idf_object_type', None) in layer_types
+    }
+
+
+@pytest.fixture
+def idf() -> IDF:
+    idf = IDF()
+    idf.add(
+        Material(
+            name='Brick',
+            roughness='Rough',
+            thickness=0.1,
+            conductivity=0.9,
+            density=1900.0,
+            specific_heat=800.0,
+        )
+    )
+    idf.add(
+        WindowMaterialGlazing(
+            name='Clear3mm', optical_data_type='SpectralAverage', thickness=0.003
+        )
+    )
+    idf.add(WindowMaterialGas(name='Air13mm', gas_type='Air', thickness=0.013))
+    idf.add(
+        WindowMaterialSimpleGlazingSystem(
+            name='SGS', u_factor=2.5, solar_heat_gain_coefficient=0.4
+        )
+    )
+    return idf
+
+
+def _add(idf: IDF, name: str, *layers: str) -> Construction:
+    fields = ['outside_layer', *(f'layer_{i}' for i in range(2, 11))]
+    construction = Construction(name=name, **dict(zip(fields, layers, strict=False)))
+    idf.add(construction)
+    return construction
+
+
+class TestIsWindowMaterial:
+    def test_partition_of_layer_material_types(self):
+        classes = _layer_material_classes()
+        assert set(classes) == OPAQUE_LAYER_TYPES | WINDOW_LAYER_TYPES
+
+        window = {
+            t for t, cls in classes.items() if is_window_material(cls.model_construct())
+        }
+        assert window == WINDOW_LAYER_TYPES
+
+
+class TestLayers:
+    def test_order_and_repeats(self, idf: IDF):
+        construction = _add(idf, 'Dbl', 'Clear3mm', 'Air13mm', 'Clear3mm')
+        glass = idf.get(WindowMaterialGlazing, 'Clear3mm')
+        gas = idf.get(WindowMaterialGas, 'Air13mm')
+        assert construction.layers == [glass, gas, glass]
+
+    def test_unknown_material_raises(self, idf: IDF):
+        construction = _add(idf, 'Broken', 'Brick', 'Missing')
+        with pytest.raises(
+            LookupError, match="'Broken' references unknown material 'Missing'"
+        ):
+            _ = construction.layers
+
+    def test_unbound_raises(self):
+        construction = Construction(name='Loose', outside_layer='Brick')
+        with pytest.raises(RuntimeError):
+            _ = construction.layers
+
+
+class TestClassification:
+    @pytest.mark.parametrize(
+        ('layers', 'is_window', 'is_opaque'),
+        [
+            (('Brick',), False, True),
+            (('SGS',), True, False),
+            (('Clear3mm', 'Air13mm', 'Clear3mm'), True, False),
+            (('Brick', 'Clear3mm'), False, False),
+            (('Clear3mm', 'Brick'), False, False),
+        ],
+    )
+    def test_window_and_opaque(
+        self, idf: IDF, layers: tuple[str, ...], is_window: bool, is_opaque: bool
+    ):
+        construction = _add(idf, 'C', *layers)
+        assert construction.is_window_construction is is_window
+        assert construction.is_opaque_construction is is_opaque