python-materialsdb 0.3.1__tar.gz → 0.3.2__tar.gz

{python_materialsdb-0.3.1 → python_materialsdb-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-materialsdb
-Version: 0.3.1
+Version: 0.3.2
 Summary: A library to work with materialsdb.org open standard for building materials.
 Author-email: Cyril Waechter <cyrwae@hotmail.com>
 License-Expression: GPL-3.0-or-later

{python_materialsdb-0.3.1 → python_materialsdb-0.3.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "python-materialsdb"
-version = "0.3.1"
+version = "0.3.2"
 description = "A library to work with materialsdb.org open standard for building materials."
 readme = "README.md"
 license = "GPL-3.0-or-later"

{python_materialsdb-0.3.1 → python_materialsdb-0.3.2}/src/materialsdb/gui/listener.py

@@ -5,7 +5,7 @@ MaterialBuilder would create (one entry per IfcMaterial); the Bonsai add-on
 maps the payload onto its open file without importing this library."""
 
 from materialsdb import config, utils
-from materialsdb.ifc.material_builder import PSETS, get_value
+from materialsdb.ifc.material_builder import PSETS, get_value, style_for
 
 
 def _resolved_psets(layer, country) -> dict:
@@ -50,6 +50,10 @@ def build_add_materials_payload(store_, items, country=None, lang=None):
         description = str(utils.get_material_description(material, lang))
         category = str(getattr(material.information, "group", "") or "")
         color = getattr(material.information, "color", None)
+        color = int(color) if color else None
+        # Resolve the surface style server-side: the add-on runs in Blender's
+        # interpreter without access to the materialsdb colour scheme.
+        style_name, style_rgb = style_for(color, category)
         entries = []
         for layer in utils.get_material_layers(material):
             if wanted is not None and str(layer.id) not in wanted:
@@ -63,7 +67,9 @@ def build_add_materials_payload(store_, items, country=None, lang=None):
                     "name": name,
                     "description": description,
                     "category": category,
-                    "color": int(color) if color else None,
+                    "color": color,
+                    "style_name": style_name,
+                    "style_color": [round(component, 6) for component in style_rgb],
                     "identity": {
                         "material_id": material_id,
                         "company_id": str(summary.company_id or ""),
@@ -120,6 +126,9 @@ def build_add_construction_payload(store_, body, country=None, lang=None):
             problems.append(f"unknown material id: {layer.material_id}")
             continue
         color = getattr(material.information, "color", None)
+        color = int(color) if color else None
+        category = str(getattr(material.information, "group", "") or "")
+        style_name, style_rgb = style_for(color, category)
         layers.append(
             {
                 "material_id": layer.material_id,
@@ -128,8 +137,10 @@ def build_add_construction_payload(store_, body, country=None, lang=None):
                     "source_id": layer.material_id,
                     "name": str(utils.get_material_name(material, lang)),
                     "description": str(utils.get_material_description(material, lang)),
-                    "category": str(getattr(material.information, "group", "") or ""),
-                    "color": int(color) if color else None,
+                    "category": category,
+                    "color": color,
+                    "style_name": style_name,
+                    "style_color": [round(component, 6) for component in style_rgb],
                     "identity": {
                         "material_id": layer.material_id,
                         "company_id": str(summary.company_id or ""),

{python_materialsdb-0.3.1 → python_materialsdb-0.3.2}/src/materialsdb/ifc/material_builder.py

@@ -2,12 +2,21 @@
 
 import json
 from pathlib import Path
+from typing import TypedDict
 
 from materialsdb import config, utils
 
 MATERIALSDB_PSET = "materialsdb"
 
-CATEGORIES = {
+
+class CategoryStyle(TypedDict):
+    """One palette entry. `hatch` is reserved for future pattern support."""
+
+    hatch: str
+    color: tuple[int, int, int]
+
+
+CATEGORIES: dict[str, CategoryStyle] = {
     "Others": {"hatch": "", "color": (255, 255, 255)},
     "Water_Proof": {"hatch": "", "color": (255, 255, 255)},
     "Vapour_Proof": {"hatch": "", "color": (0, 0, 0)},
@@ -27,6 +36,29 @@ CATEGORIES = {
     "Soil": {"hatch": "", "color": (142, 84, 52)},
 }
 
+# Named colour schemes: a category -> palette. Only the default ships today;
+# more schemes (and a GUI selector) are planned.
+SCHEMES: dict[str, dict[str, CategoryStyle]] = {"Lesosai": CATEGORIES}
+DEFAULT_SCHEME = "Lesosai"
+
+
+def _rgb_int_components(color: int) -> tuple[float, float, float]:
+    """Decimal 0xRRGGBB -> normalised (r, g, b) in 0..1 (IfcColourRgb units)."""
+    return (((color >> 16) & 255) / 255, ((color >> 8) & 255) / 255, (color & 255) / 255)
+
+
+def style_for(color, category, scheme=None):
+    """Resolve a material's (IfcSurfaceStyle.Name, (r, g, b) in 0..1).
+
+    The producer colour wins when present; otherwise the category colour from
+    the scheme (default 'Lesosai' = CATEGORIES). Unknown categories fall back
+    to 'Others'."""
+    if color:
+        return f"color {int(color)}", _rgb_int_components(int(color))
+    palette = SCHEMES.get(scheme or DEFAULT_SCHEME, CATEGORIES)
+    category = category if category in palette else "Others"
+    return f"category {category}", tuple(component / 255 for component in palette[category]["color"])
+
 
 def clean_psets(psets):
     new_dict = {}
@@ -71,6 +103,7 @@ class MaterialBuilder:
         name = utils.get_material_name(material, self.lang)
         description = utils.get_material_description(material, self.lang)
         category = str(material.information.group or "")
+        color = material.information.color
         if not with_layers:
             # reuse an already-present material instead of duplicating it;
             # its identity pset is already in place
@@ -79,15 +112,9 @@ class MaterialBuilder:
                 return [existing]
             ifc_material = self.file.createIfcMaterial(name, str(description), str(category))
             self._create_identity_pset(ifc_material, material, company_id, company, verxml)
+            self._add_style_chain(color, category)
             return [ifc_material]
-        color = material.information.color
-        surface_style = self.get_surface_style(color, category)
-        styled_item = self.file.createIfcStyledItem(Styles=[surface_style])
-        self.file.createIfcStyledRepresentation(
-            ContextOfItems=self._get_context(),
-            RepresentationIdentifier="Body",
-            Items=[styled_item],
-        )
+        self._add_style_chain(color, category)
         created = []
         wanted = {str(g) for g in layer_ids} if layer_ids is not None else None
         for layer in utils.get_material_layers(material):
@@ -191,29 +218,32 @@ class MaterialBuilder:
                 Material=ifc_material,
             )
 
-    def get_surface_style(self, color, category):
-        if color:
-            name = f"color {color}"
-        else:
-            if not category or category not in CATEGORIES:
-                category = "Others"
-            name = f"category {category}"
+    def _add_style_chain(self, color, category, scheme=None):
+        """Create the floating styled chain MaterialBuilder uses for a
+        material's colour (shared style + one styled item per build)."""
+        surface_style = self.get_surface_style(color, category, scheme=scheme)
+        styled_item = self.file.createIfcStyledItem(Styles=[surface_style])
+        self.file.createIfcStyledRepresentation(
+            ContextOfItems=self._get_context(),
+            RepresentationIdentifier="Body",
+            Items=[styled_item],
+        )
+
+    def get_surface_style(self, color, category, scheme=None):
+        name, rgb = style_for(color, category, scheme=scheme)
         if name in self._styles and self._styles[name] in self.file:
             return self._styles[name]
-        if color:
-            style = self.file.createIfcSurfaceStyleShading(SurfaceColour=self.color_xml_to_ifc(color))
-        else:
-            style = self.file.createIfcSurfaceStyleShading(
-                SurfaceColour=self.file.createIfcColourRgb(None, *CATEGORIES[category]["color"]),
-            )
-        surface_style = self.file.createIfcSurfaceStyle(Name=name, Side="BOTH", Styles=[style])
+        shading = self.file.createIfcSurfaceStyleShading(
+            SurfaceColour=self.file.createIfcColourRgb(None, *rgb),
+        )
+        surface_style = self.file.createIfcSurfaceStyle(Name=name, Side="BOTH", Styles=[shading])
         self._styles[name] = surface_style
         return surface_style
 
     def color_xml_to_ifc(self, color: int):
         """Color definition in xml is obscur. We assume that it is a decimal color.
         See: https://stackoverflow.com/a/2262152/4098083"""
-        return self.file.createIfcColourRgb(Blue=color & 255, Green=(color >> 8) & 255, Red=(color >> 16) & 255)
+        return self.file.createIfcColourRgb(None, *_rgb_int_components(int(color)))
 
 
 def _materials_of(pset):

{python_materialsdb-0.3.1 → python_materialsdb-0.3.2}/src/python_materialsdb.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-materialsdb
-Version: 0.3.1
+Version: 0.3.2
 Summary: A library to work with materialsdb.org open standard for building materials.
 Author-email: Cyril Waechter <cyrwae@hotmail.com>
 License-Expression: GPL-3.0-or-later

{python_materialsdb-0.3.1 → python_materialsdb-0.3.2}/tests/test_bonsai_insert.py

@@ -1,3 +1,4 @@
+import copy
 import sys
 from pathlib import Path
 
@@ -8,6 +9,7 @@ pytest.importorskip("ifcopenshell")
 import ifcopenshell
 import ifcopenshell.api
 import ifcopenshell.util.element
+import ifcopenshell.util.representation
 
 from materialsdb.gui.listener import build_add_materials_payload
 from materialsdb.store import MaterialStore
@@ -45,6 +47,31 @@ def _payload(store_):
     return payload
 
 
+def _file_with_body_context():
+    """A scratch IFC4 file carrying a Model/Body subcontext so _apply_style
+    proceeds (plain scratch files have no context and skip styling)."""
+    file = ifcopenshell.file(schema="IFC4")
+    model = file.create_entity(
+        "IfcGeometricRepresentationContext",
+        ContextIdentifier=None,
+        ContextType="Model",
+        CoordinateSpaceDimension=3,
+        Precision=1e-5,
+    )
+    file.create_entity(
+        "IfcGeometricRepresentationSubContext",
+        ContextIdentifier="Body",
+        ContextType="Model",
+        ParentContext=model,
+        TargetView="MODEL_VIEW",
+    )
+    return file
+
+
+def _shading_of(style):
+    return next(item for item in style.Styles if item.is_a("IfcSurfaceStyleShading"))
+
+
 def test_apply_creates_materials_psets_layers(store):
     file = ifcopenshell.file(schema="IFC4")
 
@@ -91,6 +118,178 @@ def test_apply_add_materials_creates_schema_valid_entities(store):
     assert len(identity) == 2
 
 
+def test_apply_add_materials_writes_valid_surface_style(store):
+    """Regression: style.add_style + add_surface_style left IfcSurfaceStyle
+    with Styles=$ when add_surface_style raised, and the malformed entity was
+    later reused via assign_material_style (crash on next model open). The
+    style must be built in one shot and land on the material."""
+    file = _file_with_body_context()
+
+    apply_add_materials(file, _payload(store))
+
+    styles = file.by_type("IfcSurfaceStyle")
+    assert styles, "the payload carries a colour, so a style must exist"
+    assert all(style.Styles for style in styles)  # IFC4 Styles is SET [1:?], never NULL/empty
+    assert _shading_of(styles[0]).SurfaceColour is not None
+
+    material = file.by_type("IfcMaterial")[0]
+    assert material.HasRepresentation, "the style must be assigned to the material"
+    styled_rep = material.HasRepresentation[0].Representations[0]
+    body = ifcopenshell.util.representation.get_context(file, "Model", "Body", "MODEL_VIEW")
+    assert styled_rep.ContextOfItems == body
+    styled_items = [item for item in styled_rep.Items if item.is_a("IfcStyledItem")]
+    assert any(styles[0] in item.Styles for item in styled_items)
+
+
+def test_apply_add_materials_shares_one_style_per_color(store):
+    file = _file_with_body_context()
+
+    apply_add_materials(file, _payload(store))  # both layers share colour 16711680
+
+    assert len(file.by_type("IfcSurfaceStyle")) == 1
+    assert len(file.by_type("IfcStyledItem")) == 2  # one assignment per material
+
+
+def test_apply_never_reuses_malformed_surface_style(store):
+    file = _file_with_body_context()
+    malformed = ifcopenshell.api.run("style.add_style", file, name="color 16711680")
+    assert not malformed.Styles
+
+    apply_add_materials(file, _payload(store))
+
+    assigned = [
+        item
+        for rep in file.by_type("IfcMaterialDefinitionRepresentation")
+        for representation in rep.Representations
+        for item in representation.Items
+        if item.is_a("IfcStyledItem")
+    ]
+    assert assigned, "a styled item must be created"
+    assert all(malformed not in item.Styles for item in assigned)
+    assert any(style.Styles and style.Name == "color 16711680" for style in file.by_type("IfcSurfaceStyle"))
+
+
+def _strip_representations(file):
+    for material in file.by_type("IfcMaterial"):
+        for representation in list(material.HasRepresentation or ()):
+            file.remove(representation)
+
+
+def test_apply_add_materials_styles_reused_material(store):
+    """A material already present (identity pset) but colourless -- e.g. pushed
+    by the pre-fix add-on -- must get its style on a later push."""
+    file = _file_with_body_context()
+    payload = _payload(store)
+    apply_add_materials(file, payload)
+    _strip_representations(file)
+    assert not file.by_type("IfcMaterialDefinitionRepresentation")
+
+    assert apply_add_materials(file, payload) == 0  # nothing re-created
+
+    for material in file.by_type("IfcMaterial"):
+        assert material.HasRepresentation
+    assert [style.Name for style in file.by_type("IfcSurfaceStyle")] == ["color 16711680"]
+    assert all(style.Styles for style in file.by_type("IfcSurfaceStyle"))
+
+
+def test_apply_add_construction_styles_reused_material(store):
+    file = _file_with_body_context()
+    apply_add_materials(file, _payload(store))  # Isolant A already in the model
+    _strip_representations(file)
+
+    summary = apply_add_construction(file, CONSTRUCTION_PAYLOAD)
+
+    assert summary["materials_created"] == 1  # Beton B only; Isolant A reused
+    isolant = next(material for material in file.by_type("IfcMaterial") if material.Name == "Isolant A")
+    assert isolant.HasRepresentation
+
+
+def test_apply_add_material_uses_category_scheme_colour(store):
+    from materialsdb.ifc.material_builder import CATEGORIES
+
+    file = _file_with_body_context()
+    payload, missing = build_add_materials_payload(store, [{"id": "00000000-0000-0000-0000-000000000002"}])
+    assert missing == []  # Beton B carries no producer colour
+
+    apply_add_materials(file, payload)
+
+    styles = file.by_type("IfcSurfaceStyle")
+    assert [style.Name for style in styles] == ["category Concrete"]
+    colour = _shading_of(styles[0]).SurfaceColour
+    expected = CATEGORIES["Concrete"]["color"]
+    assert (round(colour.Red * 255), round(colour.Green * 255), round(colour.Blue * 255)) == expected
+
+
+def test_apply_preserves_third_party_style_on_reused_material(store):
+    file = _file_with_body_context()
+    payload = _payload(store)
+    apply_add_materials(file, payload)
+    material = file.by_type("IfcMaterial")[0]
+    styled_item = next(
+        item
+        for representation in material.HasRepresentation
+        for styled in representation.Representations
+        for item in styled.Items
+        if item.is_a("IfcStyledItem")
+    )
+    custom = ifcopenshell.api.run("style.add_style", file, name="MyCustom")
+    ifcopenshell.api.run(
+        "style.add_surface_style",
+        file,
+        style=custom,
+        ifc_class="IfcSurfaceStyleShading",
+        attributes={"SurfaceColour": {"Name": None, "Red": 0.1, "Green": 0.2, "Blue": 0.3}},
+    )
+    styled_item.Styles = (custom,)
+
+    apply_add_materials(file, payload)  # existing key -> would re-style
+
+    assert styled_item.Styles[0].Name == "MyCustom"  # third-party style kept
+
+
+def test_apply_updates_our_style_on_colour_change(store):
+    file = _file_with_body_context()
+    payload = _payload(store)
+    apply_add_materials(file, payload)
+    material = file.by_type("IfcMaterial")[0]
+
+    changed = copy.deepcopy(payload)
+    for entry in changed["materials"]:
+        entry["color"] = 255
+        entry["style_name"] = "color 255"
+        entry["style_color"] = [0.0, 0.0, 1.0]
+    apply_add_materials(file, changed)
+
+    styled_item = next(
+        item
+        for representation in material.HasRepresentation
+        for styled in representation.Representations
+        for item in styled.Items
+        if item.is_a("IfcStyledItem")
+    )
+    assert styled_item.Styles[0].Name == "color 255"  # our style refreshed
+
+
+def test_apply_styling_idempotent(store):
+    file = _file_with_body_context()
+    payload = _payload(store)
+
+    apply_add_materials(file, payload)
+    counts = (
+        len(file.by_type("IfcSurfaceStyle")),
+        len(file.by_type("IfcStyledItem")),
+        len(file.by_type("IfcMaterialDefinitionRepresentation")),
+    )
+
+    apply_add_materials(file, payload)
+
+    assert (
+        len(file.by_type("IfcSurfaceStyle")),
+        len(file.by_type("IfcStyledItem")),
+        len(file.by_type("IfcMaterialDefinitionRepresentation")),
+    ) == counts
+
+
 def test_apply_is_idempotent(store):
     file = ifcopenshell.file(schema="IFC4")
     payload = _payload(store)

{python_materialsdb-0.3.1 → python_materialsdb-0.3.2}/tests/test_listener_payload.py

@@ -260,3 +260,29 @@ def test_construction_payload_no_u_values_when_lambda_unresolvable(store):
 
     assert payload is None
     assert problems == ["unknown material id: 00000000-0000-0000-0000-000000000004"]
+
+
+def test_payload_carries_resolved_producer_style(store):
+    payload, missing = build_add_materials_payload(store, [{"id": "00000000-0000-0000-0000-000000000001"}])
+
+    assert missing == []
+    first = payload["materials"][0]
+    assert first["style_name"] == "color 16711680"  # producer colour wins
+    assert first["style_color"] == [1.0, 0.0, 0.0]  # normalised 0xFF0000
+
+
+def test_construction_payload_carries_category_scheme_style(store):
+    from materialsdb.ifc.material_builder import CATEGORIES
+
+    payload, problems = build_add_construction_payload(
+        store,
+        body={
+            "name": "wall",
+            "layers": [{"material_id": "00000000-0000-0000-0000-000000000002", "thickness_m": 0.15}],
+        },
+    )
+
+    assert problems == []
+    material = payload["construction"]["layers"][0]["material"]
+    assert material["style_name"] == "category Concrete"  # no producer colour -> scheme
+    assert material["style_color"] == [round(component / 255, 6) for component in CATEGORIES["Concrete"]["color"]]

{python_materialsdb-0.3.1 → python_materialsdb-0.3.2}/tests/test_material_builder.py

@@ -303,3 +303,49 @@ def test_org_layer_pset_exposes_layer_id_and_thickness(mini_source):
         "00000000-0000-0000-0000-0000000000a1": 0.2,  # 200 mm -> meters
         "00000000-0000-0000-0000-0000000000a2": 0.1,
     }
+
+
+def test_style_for_prefers_producer_colour_and_normalises():
+    from materialsdb.ifc.material_builder import style_for
+
+    name, rgb = style_for(16711680, "Insulation")  # 0xFF0000
+
+    assert name == "color 16711680"
+    assert rgb == (1.0, 0.0, 0.0)  # IfcColourRgb components are normalised 0..1
+
+
+def test_style_for_falls_back_to_scheme_category_colour():
+    from materialsdb.ifc.material_builder import CATEGORIES, style_for
+
+    name, rgb = style_for(None, "Concrete")
+
+    assert name == "category Concrete"
+    assert rgb == tuple(component / 255 for component in CATEGORIES["Concrete"]["color"])
+
+
+def test_style_for_unknown_category_falls_back_to_others():
+    from materialsdb.ifc.material_builder import CATEGORIES, style_for
+
+    name, rgb = style_for(None, "Air")  # not a scheme category
+
+    assert name == "category Others"
+    assert rgb == tuple(component / 255 for component in CATEGORIES["Others"]["color"])
+
+
+def test_build_without_layers_styles_the_material(mini_source):
+    """The to_ifc_layer_set path builds materials with with_layers=False; they
+    must carry a colour too, or exported constructions show no style."""
+    file = ifcopenshell.file(schema="IFC4")
+    builder = MaterialBuilder(file)
+
+    created = builder.build(mini_source.material[0], company="Mini SA", with_layers=False)
+
+    assert len(created) == 1
+    assert not file.by_type("IfcMaterialLayer")  # still material-only
+    styles = file.by_type("IfcSurfaceStyle")
+    assert [style.Name for style in styles] == ["color 16711680"]  # producer colour wins
+    assert all(style.Styles for style in styles)
+    colour = styles[0].Styles[0].SurfaceColour
+    assert (colour.Red, colour.Green, colour.Blue) == (1.0, 0.0, 0.0)
+    assert len(file.by_type("IfcStyledItem")) == 1
+    assert len(file.by_type("IfcStyledRepresentation")) == 1