python-materialsdb 0.3.1__py3-none-any.whl → 0.4.0__py3-none-any.whl

materialsdb/classes.py

@@ -93,7 +93,7 @@ class Guid(str):
 
 class Brackguid(str):
     xs_type: str = "simpleType"
-    xml_pattern:str = "\{[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}\}"
+    xml_pattern:str = "\\{[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}\\}"
     xml_name: str = "Brackguid"
 
 

materialsdb/config.py

@@ -50,6 +50,23 @@ def set_country(country: str):
     set_param("country", country)
 
 
+def get_scheme() -> str:
+    return str(get_base_config().get("scheme") or "")
+
+
+def set_scheme(name: str) -> None:
+    set_param("scheme", str(name))
+
+
+def get_ignore_producer_color() -> bool:
+    value = get_base_config().get("ignore_producer_color", "false")
+    return str(value).strip().lower() in ("true", "1", "yes", "on")
+
+
+def set_ignore_producer_color(value: bool) -> None:
+    set_param("ignore_producer_color", "true" if value else "false")
+
+
 def main():
     lang = get_lang()
     set_lang(lang)

materialsdb/gui/listener.py

@@ -5,7 +5,8 @@ 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
+from materialsdb.store import FINGERPRINT_SCHEME
 
 
 def _resolved_psets(layer, country) -> dict:
@@ -45,11 +46,21 @@ def build_add_materials_payload(store_, items, country=None, lang=None):
         if summary is None or material is None:
             missing.append(material_id)
             continue
+        fingerprint = store_.material_fingerprint(material_id)
         wanted = {str(g) for g in item.get("layer_ids") or []} or None
         name = str(utils.get_material_name(material, lang))
         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,
+            scheme=config.get_scheme(),
+            ignore_producer_color=config.get_ignore_producer_color(),
+        )
         entries = []
         for layer in utils.get_material_layers(material):
             if wanted is not None and str(layer.id) not in wanted:
@@ -63,12 +74,20 @@ 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 ""),
                         "company": str(summary.company or ""),
+                        "fingerprint": fingerprint,
+                        "fingerprint_scheme": FINGERPRINT_SCHEME,
                     },
+                    "mode": item.get("mode", "skip"),
+                    "replaces": item.get("replaces"),
+                    "update": item.get("update"),
+                    "force": bool(item.get("force")),
                     "psets": _resolved_psets(layer, country),
                     "layer": {"layer_id": str(layer.id), "thick_m": thick / 1000} if thick else None,
                 }
@@ -80,6 +99,55 @@ def build_add_materials_payload(store_, items, country=None, lang=None):
     return {"action": "add_materials", "materials": materials}, missing
 
 
+def _layer_thick_m(layer, country) -> float | None:
+    """The layer's thickness in metres for `country`, or None when absent."""
+    thick = getattr(utils.get_by_country(layer.geometry or (), country), "thick", None)
+    return thick / 1000 if thick is not None else None
+
+
+def _resolve_construction_layer(material, design_thickness_m, country, lang) -> tuple[object | None, str | None]:
+    """Map a construction layer's design thickness onto a materialsdb Layer.
+
+    Exact thickness match wins; a single-layer material resolves to its only
+    layer whatever the design thickness; multi-layer mismatches fall back to
+    the first layer with a warning. Returns (layer_or_None, warning_or_None)."""
+    layers = list(utils.get_material_layers(material))
+    if not layers:
+        name = str(utils.get_material_name(material, lang))
+        return None, f"{name}: material has no layer"
+    for layer in layers:
+        thick_m = _layer_thick_m(layer, country)
+        if thick_m is not None and abs(thick_m - design_thickness_m) <= utils.THICKNESS_EPS_M:
+            return layer, None
+    if len(layers) == 1:
+        return layers[0], None
+    name = str(utils.get_material_name(material, lang))
+    return layers[0], f"{name}: design thickness {round(design_thickness_m * 1000)} mm matches no layer"
+
+
+def _raw_decision_layer(raw_layers, material_id, thickness_m) -> dict:
+    """The raw body layer carrying the decision for this validated layer.
+
+    ``validate_construction`` can drop or reorder malformed layers, so the
+    validated index does not address ``raw_layers``. Match on the pair
+    (material_id, thickness) instead; when no exact match is unambiguous the
+    decision fields are omitted, i.e. the layer is treated as ``skip`` rather
+    than inheriting another layer's mode/update/replaces."""
+    matches = []
+    for raw in raw_layers:
+        if not isinstance(raw, dict):
+            continue
+        if str(raw.get("material_id")) != str(material_id):
+            continue
+        try:
+            raw_thickness = float(raw.get("thickness_m"))
+        except (TypeError, ValueError):
+            continue
+        if abs(raw_thickness - thickness_m) <= utils.THICKNESS_EPS_M:
+            matches.append(raw)
+    return matches[0] if len(matches) == 1 else {}
+
+
 _DESIGN_USAGE_TO_TYPES = {
     "consDesignForWall": ["IfcWallType"],
     "consDesignForFloor": ["IfcSlabType"],
@@ -91,8 +159,9 @@ GENERIC_TYPES = ["IfcWallType", "IfcSlabType", "IfcRoofType"]
 def build_add_construction_payload(store_, body, country=None, lang=None):
     """Resolve a construction body into a self-sufficient add_construction
     payload (or (None, problems) when validation fails). Materials travel
-    minimal — identity/name/category/color, to_ifc_layer_set-style — and
-    find-or-create on the add-on side keys on the identity pset."""
+    resolved — identity/name/category/style plus their layer's materialsdb
+    psets — and find-or-create on the add-on side keys on
+    (material_id, org_layer layer_id)."""
     from materialsdb import construction as cm
 
     body = dict(body or {})
@@ -103,7 +172,11 @@ def build_add_construction_payload(store_, body, country=None, lang=None):
         return None, problems
     country = country or config.get_country()
     lang = lang or config.get_lang()
+    raw_layers: list = []
+    if isinstance(body.get("layers"), list):
+        raw_layers = body["layers"]
     layers = []
+    warnings = []
     for layer in construction.layers:
         if layer.placeholder is not None:
             layers.append(
@@ -119,23 +192,46 @@ def build_add_construction_payload(store_, body, country=None, lang=None):
         if summary is None or material is None:
             problems.append(f"unknown material id: {layer.material_id}")
             continue
+        resolved_layer, warning = _resolve_construction_layer(material, layer.thickness_m, country, lang)
+        if warning is not None:
+            warnings.append(warning)
+        raw_layer = _raw_decision_layer(raw_layers, layer.material_id, layer.thickness_m)
         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,
+            scheme=config.get_scheme(),
+            ignore_producer_color=config.get_ignore_producer_color(),
+        )
+        material_entry = {
+            "source_id": layer.material_id,
+            "name": str(utils.get_material_name(material, lang)),
+            "description": str(utils.get_material_description(material, lang)),
+            "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 ""),
+                "company": str(summary.company or ""),
+                "fingerprint": store_.material_fingerprint(layer.material_id),
+                "fingerprint_scheme": FINGERPRINT_SCHEME,
+            },
+            "mode": raw_layer.get("mode", "skip"),
+            "replaces": raw_layer.get("replaces"),
+            "update": raw_layer.get("update"),
+            "force": bool(raw_layer.get("force")),
+        }
+        if resolved_layer is not None:
+            material_entry["psets"] = _resolved_psets(resolved_layer, country)
         layers.append(
             {
                 "material_id": layer.material_id,
                 "thickness_m": layer.thickness_m,
-                "material": {
-                    "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,
-                    "identity": {
-                        "material_id": layer.material_id,
-                        "company_id": str(summary.company_id or ""),
-                        "company": str(summary.company or ""),
-                    },
-                },
+                "material": material_entry,
             }
         )
     if problems:
@@ -151,5 +247,6 @@ def build_add_construction_payload(store_, body, country=None, lang=None):
                 cls: u for cls, u in cm.u_values_by_type(construction, store_, types).items() if u is not None
             },
             "layers": layers,
+            "warnings": warnings,
         },
     }, []