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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-materialsdb
-Version: 0.3.0
+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.0 → python_materialsdb-0.3.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "python-materialsdb"
-version = "0.3.0"
+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.0 → python_materialsdb-0.3.2}/src/materialsdb/cache.py

@@ -2,6 +2,7 @@ import os
 import pathlib
 import urllib.request
 from collections import namedtuple
+from concurrent.futures import FIRST_COMPLETED, ThreadPoolExecutor, wait
 
 from lxml import etree
 
@@ -85,25 +86,77 @@ def _plan_index(index):
     return _IndexPlan(index, new_index, unchanged, todos)
 
 
-def update_producers_data(url_list=MATERIALSDBINDEXURLLIST, on_progress=None):
-    """on_progress(done, total, name) is called after each producer download
-    with a global running total; returning a truthy value stops the update
-    between two downloads (the partial Report is returned as-is)."""
+def update_producers_data(url_list=MATERIALSDBINDEXURLLIST, on_progress=None, max_workers: int = 8):
+    """Update the cached producer files from the index URLs.
+
+    Downloads run on a bounded thread pool (max_workers). on_progress(done,
+    total, name) is called once per completed download from the calling
+    thread with a monotonic running total; returning a truthy value stops
+    NEW submissions (queued jobs are abandoned, in-flight ones finish but
+    no longer count toward the partial Report). A download error stops the
+    run and the first exception is re-raised after the pool drains.
+    """
     plans = [_plan_index(index) for index in url_list]
-    total = sum(len(plan.todos) for plan in plans)
-    existing, updated, deleted = [], [], []
+    jobs = [
+        (plan, company, cached_producer, producer_path)
+        for plan in plans
+        for (company, cached_producer, producer_path) in plan.todos
+    ]
+    total = len(jobs)
+    workers = max(1, min(int(max_workers), total or 1))
+
+    existing: list = []
+    updated: list = []
+    deleted: list = []
     done = 0
+    cancel_requested = False
+    failure = None
+
+    def _download(job):
+        _, company, cached_producer, producer_path = job
+        deleted_path = None
+        if cached_producer is not None:
+            deleted_path = get_producers_dir() / pathlib.Path(cached_producer.get("href")).name
+            deleted_path.unlink(True)
+        urllib.request.urlretrieve(company.get("href"), producer_path)
+        return deleted_path
+
+    pool = ThreadPoolExecutor(max_workers=workers)
+    pending = list(jobs)  # pops from the FRONT, submission order preserved
+    futures: dict = {}
+    try:
+        while futures or pending:
+            while pending and len(futures) < workers:
+                job = pending.pop(0)
+                futures[pool.submit(_download, job)] = job
+            if not futures:
+                break
+            ready, _ = wait(set(futures), return_when=FIRST_COMPLETED)
+            for future in ready:
+                job = futures.pop(future)
+                try:
+                    deleted_path = future.result()
+                except Exception as err:  # noqa: BLE001 - re-raised below, caller decides
+                    if failure is None:
+                        failure = err
+                    break
+                if deleted_path is not None:
+                    deleted.append(deleted_path)
+                updated.append(job[3])
+                done += 1
+                if on_progress is not None and on_progress(done, total, pathlib.Path(job[3]).name):
+                    cancel_requested = True
+                    break
+            if cancel_requested or failure is not None:
+                break
+    finally:
+        pool.shutdown(wait=True, cancel_futures=True)
+
+    if failure is not None:
+        raise failure
+    if cancel_requested:
+        return Report(existing, updated, deleted)
     for plan in plans:
-        for company, cached_producer, producer_path in plan.todos:
-            if cached_producer is not None:
-                cached_path = get_producers_dir() / pathlib.Path(cached_producer.get("href")).name
-                deleted.append(cached_path)
-                cached_path.unlink(True)
-            urllib.request.urlretrieve(company.get("href"), producer_path)
-            updated.append(producer_path)
-            done += 1
-            if on_progress is not None and on_progress(done, total, pathlib.Path(company.get("href")).name):
-                return Report(existing, updated, deleted)
         if plan.todos:
             plan.new_index.write(str(get_cached_index_path(plan.index)))
         existing.extend(plan.unchanged)

{python_materialsdb-0.3.0 → 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.0 → 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.0 → python_materialsdb-0.3.2}/src/materialsdb/serialiser.py

@@ -25,9 +25,31 @@ def get_xml_schema() -> str:
     return str(Path(__file__).parent / "schema/materialsdb103.xsd")
 
 
+@cache
+def cached_type_hints(cls) -> dict:
+    return typing.get_type_hints(cls)
+
+
+@cache
+def _tag_local_name(tag: str) -> str:
+    m = re.search("{.*}(.*)", tag)
+    return m.group(1) if m else tag
+
+
 def get_element_name(element: objectify.ObjectifiedElement) -> str:
-    m = re.search("{.*}(.*)", element.tag)
-    return m.group(1) if m else element.tag
+    return _tag_local_name(element.tag)
+
+
+@cache
+def _is_optional(type_hint):
+    return typing.get_origin(type_hint) is typing.Union and typing.get_args(type_hint)[1] is type(None)
+
+
+@cache
+def _strip_optional(type_hint):
+    if _is_optional(type_hint):
+        return typing.get_args(type_hint)[0]
+    return type_hint
 
 
 def create_element_maker():
@@ -49,11 +71,6 @@ def get_valid_root(tree: objectify.ObjectifiedElement) -> objectify.ObjectifiedE
     return root
 
 
-@cache
-def cached_type_hints(cls) -> dict:
-    return typing.get_type_hints(cls)
-
-
 class XmlDeserialiser:
     def __init__(self):
         self.schema = etree.XMLSchema(file=get_xml_schema())
@@ -93,7 +110,7 @@ class XmlDeserialiser:
             value = element.get(attrib)
             if value is None:
                 continue
-            base_class = self.strip_optional(type_hints[attrib])
+            base_class = _strip_optional(type_hints[attrib])
 
             kwargs[attrib] = base_class(value)
         for child_name in getattr(element_class, "xml_elements", ()):
@@ -127,12 +144,10 @@ class XmlDeserialiser:
         return instance
 
     def strip_optional(self, type_hint):
-        if self.is_optional(type_hint):
-            return typing.get_args(type_hint)[0]
-        return type_hint
+        return _strip_optional(type_hint)
 
     def is_optional(self, type_hint):
-        return typing.get_origin(type_hint) is typing.Union and typing.get_args(type_hint)[1] is type(None)
+        return _is_optional(type_hint)
 
     def cls_name(self, name: str) -> str:
         return name if name[0].isupper() else name.title()

{python_materialsdb-0.3.0 → 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.0
+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.0 → 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.0 → python_materialsdb-0.3.2}/tests/test_build_bonsai_addon.py

@@ -1,3 +1,4 @@
+import re
 import sys
 import zipfile
 from pathlib import Path
@@ -8,13 +9,22 @@ sys.path.insert(0, str(ROOT / "dev_utils"))
 import build_bonsai_addon  # ty: ignore[unresolved-import] - dev_util on a side path
 
 
+def _manifest_version():
+    text = (ROOT / "bonsai_addon" / "blender_manifest.toml").read_text(encoding="utf-8")
+    match = re.search(r'(?m)^version = "([^"]+)"$', text)
+    assert match is not None
+    return match.group(1)
+
+
 def test_default_build_unchanged(tmp_path):
+    manifest_version = _manifest_version()
+
     out = build_bonsai_addon.build(out_dir=tmp_path)
 
     assert out.name == "materialsdb_listener.zip"
     with zipfile.ZipFile(out) as zf:
         assert "blender_manifest.toml" in zf.namelist()
-        assert 'version = "0.2.0"' in zf.read("blender_manifest.toml").decode("utf-8")
+        assert f'version = "{manifest_version}"' in zf.read("blender_manifest.toml").decode("utf-8")
         assert "blender_manifest.toml".replace(".", "/") not in zf.namelist()  # manifest at zip ROOT
 
 
@@ -30,8 +40,12 @@ def test_version_injected_into_manifest_and_name(tmp_path):
 def test_version_injection_is_literal_independent(tmp_path):
     """The injection must not depend on the manifest's current version
     literal (it changes on every release bump)."""
+
+    current = _manifest_version()
+    stale = "0.0.1" if current != "0.0.1" else "0.0.2"
+
     out = build_bonsai_addon.build(version="3.2.1", out_dir=tmp_path)
 
     with zipfile.ZipFile(out) as zf:
         assert 'version = "3.2.1"' in zf.read("blender_manifest.toml").decode("utf-8")
-        assert 'version = "0.2.0"' not in zf.read("blender_manifest.toml").decode("utf-8")
+        assert f'version = "{stale}"' not in zf.read("blender_manifest.toml").decode("utf-8")

{python_materialsdb-0.3.0 → python_materialsdb-0.3.2}/tests/test_cache.py

@@ -33,7 +33,7 @@ def cache_env(tmp_path, monkeypatch):
     # defaults are bound at def time, so patch __defaults__ too
     single = [cache.MATERIALSDBINDEXURLLIST[0]]
     monkeypatch.setattr(cache, "MATERIALSDBINDEXURLLIST", single)
-    monkeypatch.setattr(cache.update_producers_data, "__defaults__", (single, None))
+    monkeypatch.setattr(cache.update_producers_data, "__defaults__", (single, None, 8))
     monkeypatch.setattr(cache.updates_available, "__defaults__", (single,))
     recorded: _Recorded = {"urls": [], "dests": [], "index": INDEX_XML}
 
@@ -57,9 +57,11 @@ def test_first_refresh_downloads_all_with_global_total(cache_env):
         on_progress=lambda done, total, name: progress.append((done, total, name)) or False
     )
 
-    assert recorded["urls"] == ["https://x.org/a.xml", "https://x.org/b.xml"]
-    assert progress == [(1, 2, "a.xml"), (2, 2, "b.xml")]
-    assert [p.name for p in report.updated] == ["a.xml", "b.xml"]
+    assert set(recorded["urls"]) == {"https://x.org/a.xml", "https://x.org/b.xml"}
+    assert [p[0] for p in progress] == [1, 2]  # monotonic done
+    assert {p[1] for p in progress} == {2}  # global total reached before any download finished
+    assert {p[2] for p in progress} == {"a.xml", "b.xml"}
+    assert {p.name for p in report.updated} == {"a.xml", "b.xml"}
     assert report.existing == []
     assert (cache_dir / "Producers" / "a.xml").exists()  # downloads land in Producers dir
     assert (cache_dir / "ProducerIndex.xml").exists()  # new index persisted
@@ -68,7 +70,7 @@ def test_first_refresh_downloads_all_with_global_total(cache_env):
 def test_second_refresh_uses_existing_files(cache_env):
     cache, _, recorded = cache_env
     report = cache.update_producers_data()
-    assert [p.name for p in report.updated] == ["a.xml", "b.xml"]
+    assert {p.name for p in report.updated} == {"a.xml", "b.xml"}
     recorded["urls"].clear()
 
     progress = []
@@ -100,9 +102,9 @@ def test_outdated_single_producer_updates_with_total_one(cache_env):
         on_progress=lambda done, total, name: progress.append((done, total, name)) or False
     )
 
-    assert recorded["urls"] == ["https://x.org/a.xml"]
+    assert recorded["urls"] == ["https://x.org/a.xml"]  # single job — deterministic
     assert progress == [(1, 1, "a.xml")]
-    assert [p.name for p in record.updated] == ["a.xml"]
+    assert {p.name for p in record.updated} == {"a.xml"}
     assert [p.name for p in record.deleted] == ["a.xml"]  # stale file removed before re-download
     assert [p.name for p in record.existing] == ["b.xml"]
 
@@ -128,7 +130,8 @@ def test_cancel_stops_between_downloads(cache_env):
     def cancel_after_first(done, total, name):
         return done >= 1  # truthy → abort
 
-    report = cache.update_producers_data(on_progress=cancel_after_first)
+    # single worker: b.html cannot start before the callback runs
+    report = cache.update_producers_data(on_progress=cancel_after_first, max_workers=1)
 
     assert recorded["urls"] == ["https://x.org/a.xml"]  # second download never starts
     assert [p.name for p in report.updated] == ["a.xml"]

{python_materialsdb-0.3.0 → 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.0 → 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