python-materialsdb 0.0.2__py3-none-any.whl → 0.2.0__py3-none-any.whl

materialsdb/ifc/project_library.py

@@ -1,63 +1,33 @@
 import uuid
-import datetime
-import json
-from pathlib import Path
+
 import ifcopenshell
 import ifcopenshell.api
 
-from materialsdb.serialiser import XmlDeserialiser
 from materialsdb import config, utils
 from materialsdb.classes import (
     Materials,
-    Material,
 )
+from materialsdb.ifc.material_builder import (
+    CATEGORIES,
+    MATERIALSDB_PSET,
+    PSETS,
+    MaterialBuilder,
+    clean_psets,
+    get_value,
+)
+from materialsdb.serialiser import XmlDeserialiser
 
-CATEGORIES = {
-    "Others": {"hatch": "", "color": (255, 255, 255)},
-    "Water_Proof": {"hatch": "", "color": (255, 255, 255)},
-    "Vapour_Proof": {"hatch": "", "color": (0, 0, 0)},
-    "Concrete": {"hatch": "", "color": (0, 255, 0)},
-    "Wood_Timberproducts": {"hatch": "", "color": (91, 60, 17)},
-    "Insulation": {"hatch": "", "color": (253, 108, 158)},
-    "Masonry": {"hatch": "", "color": (253, 70, 38)},
-    "Metal": {"hatch": "", "color": (119, 181, 254)},
-    "Mortar": {"hatch": "", "color": (102, 0, 153)},
-    "Plastics": {"hatch": "", "color": (96, 96, 96)},
-    "Stone": {"hatch": "", "color": (0, 0, 255)},
-    "Composite": {"hatch": "", "color": (112, 141, 35)},
-    "Films": {"hatch": "", "color": (0, 0, 0)},
-    "Render": {"hatch": "", "color": (0, 0, 0)},
-    "Covering": {"hatch": "", "color": (0, 0, 0)},
-    "Glas": {"hatch": "", "color": (27, 79, 8)},
-    "Soil": {"hatch": "", "color": (142, 84, 52)},
-}
-
-
-def clean_psets(psets):
-    new_dict = {}
-    for pset_name, props in psets.items():
-        pset_dict = {}
-        for prop_name, definition in props.items():
-            if definition["path"]:
-                pset_dict[prop_name] = definition
-        if pset_dict:
-            new_dict[pset_name] = pset_dict
-    return new_dict
-
-
-PSETS = json.loads(Path(__file__).with_name("material_psets.json").read_text("utf-8"))
-PSETS = clean_psets(PSETS)
-
-
-def get_value(layer, definition, country=None):
-    value = layer
-    for attrib in definition["path"]:
-        value = getattr(value, attrib)
-        if isinstance(value, list):
-            value = utils.get_by_country(value, country)
-            if not value:
-                return None
-    return value
+# Re-exports: external code may import these from project_library (historical API).
+__all__ = [
+    "CATEGORIES",
+    "MATERIALSDB_PSET",
+    "PSETS",
+    "MaterialBuilder",
+    "ProjectLibrary",
+    "clean_psets",
+    "create_project_library_from_xml",
+    "get_value",
+]
 
 
 class ProjectLibrary:
@@ -68,6 +38,7 @@ class ProjectLibrary:
         self.lang = config.get_lang()
         self.country = config.get_country()
         self.owner_history = None
+        self.builder = MaterialBuilder(self.file, country=self.country, lang=self.lang)
 
     def create_application(self):
         file = self.file
@@ -94,198 +65,92 @@ class ProjectLibrary:
             ApplicationIdentifier="ifcopenshell",
         )
 
-    def create_project_library(self, source: Materials, role: str = "MANUFACTURER"):
+    def create_project_library(self, company: str, companyid: str, ver: int, crd, role: str = "MANUFACTURER"):
         file = self.file
 
-        # https://standards.buildingsmart.org/IFC/RELEASE/IFC4/ADD2_TC1/HTML/link/ifcroleenum.htm
-        role = file.createIfcActorRole(role)
-
-        # https://standards.buildingsmart.org/IFC/RELEASE/IFC4/ADD2_TC1/HTML/link/ifcperson.htm
+        role_entity = file.createIfcActorRole(role)
         person = file.createIfcPerson(
             Identification=str(uuid.uuid4()),
             FamilyName="Unknown",
             GivenName="Unknown",
-            Roles=[role],
-        )
-
-        # https://standards.buildingsmart.org/IFC/RELEASE/IFC4/ADD2_TC1/HTML/link/ifcorganization.htm
-        organisation = file.createIfcOrganization(
-            Identification=source.companyid, Name=source.company, Roles=[role]
-        )
-
-        # https://standards.buildingsmart.org/IFC/RELEASE/IFC4/ADD2_TC1/HTML/link/ifcpersonandorganization.htm
-        person_and_organisation = file.createIfcPersonAndOrganization(
-            person, organisation, Roles=[role]
+            Roles=[role_entity],
         )
-
-        # https://standards.buildingsmart.org/IFC/RELEASE/IFC4/ADD2_TC1/HTML/link/ifcownerhistory.htm
+        organisation = file.createIfcOrganization(Identification=str(companyid), Name=str(company), Roles=[role_entity])
+        person_and_organisation = file.createIfcPersonAndOrganization(person, organisation, Roles=[role_entity])
         owner_history = file.createIfcOwnerHistory(
             OwningUser=person_and_organisation,
             OwningApplication=self.application,
-            CreationDate=max(int(utils.date_from_xml(source.crd).timestamp()),-2147483648),
+            CreationDate=max(int(utils.date_from_xml(crd).timestamp()), -2147483648),
         )
         self.owner_history = owner_history
-
-        # https://standards.buildingsmart.org/IFC/RELEASE/IFC4/ADD2_TC1/HTML/link/ifcprojectlibrary.htm
         file.createIfcProjectLibrary(
             GlobalId=ifcopenshell.guid.new(),
             OwnerHistory=owner_history,
-            Name=source.company,
-            Description=f"Material library converted from materialsdb xml for company {source.company}",
+            Name=str(company),
+            Description=f"Material library converted from materialsdb xml for company {company}",
             ObjectType="MaterialLibrary",
-            LongName=f"{source.company} version {source.ver}",
+            LongName=f"{company} version {ver}",
         )
 
     def create_materials(self, source: Materials):
-        file = self.file
-        context = file.createIfcRepresentationContext()
         for material in utils.get_materials(source, self.country):
+            created = self.builder.build(material)
+            if not created:
+                continue
             name = utils.get_material_name(material, self.lang)
-            description = utils.get_material_description(material, self.lang)
-            webinfo = utils.get_material_webinfo(material, self.lang)
-            category = material.information.group
-            labels = material.information.labels
-            color = material.information.color
-            brushstyle = material.information.BrushStyle
-            surface_style = self.get_surface_style(color, category)
-            styled_item = file.createIfcStyledItem(Styles=[surface_style])
-            # TODO: hatch_item = file.createIfcFillAreaStyleHatching()
-            representation = file.createIfcStyledRepresentation(
-                ContextOfItems=context,
-                RepresentationIdentifier="Body",
-                Items=[styled_item],
-            )
-            for layer in getattr(getattr(material, "layers", ()), "layer", ()):
-                ifc_material = file.createIfcMaterial(name, description, category)
-                for pset_name, props in PSETS.items():
-                    properties = list()
-                    for prop_name, definition in props.items():
-                        primary_measure_type = definition["primary_measure_type"]
-                        if not primary_measure_type:
-                            continue
-                        value = get_value(layer, definition, self.country)
-                        if value:
-                            unit_factor = definition.get("unit_factor", None) or 1
-                            properties.append(
-                                file.create_entity(
-                                    "IfcPropertySingleValue",
-                                    Name=prop_name,
-                                    NominalValue=file.create_entity(
-                                        primary_measure_type, value * unit_factor
-                                    ),
-                                )
-                            )
-                    if not properties:
-                        continue
-                    pset = file.create_entity(
-                        "IfcMaterialProperties",
-                        Name=pset_name,
-                        Properties=properties,
-                        Material=ifc_material,
-                    )
-                geometry = utils.get_by_country(layer.geometry, self.country)
-                if getattr(geometry, "thick", None):
-                    element_name = f"{name} | {geometry.thick}mm"
-                    ifc_layer = file.create_entity(
-                        "IfcMaterialLayer",
-                        Material=ifc_material,
-                        LayerThickness=geometry.thick / 1000,
-                        Name=element_name,
-                    )
-                    assigned_material = file.create_entity(
-                        "IfcMaterialLayerSet",
-                        MaterialLayers=[ifc_layer],
-                        LayerSetName=element_name,
-                    )
-                else:
-                    element_name = name
-                    assigned_material = ifc_material
-                if material.information.wall:
-                    wall = file.create_entity(
-                        "IfcWallType",
-                        GlobalId=ifcopenshell.guid.new(),
-                        Name=element_name,
-                    )
-                    ifcopenshell.api.run(
-                        "material.assign_material",
-                        file,
-                        product=wall,
-                        material=assigned_material,
-                    )
-                if material.information.roof:
-                    roof = file.create_entity(
-                        "IfcRoofType",
-                        GlobalId=ifcopenshell.guid.new(),
-                        Name=element_name,
-                    )
-                    ifcopenshell.api.run(
-                        "material.assign_material",
-                        file,
-                        product=roof,
-                        material=assigned_material,
-                    )
-                if material.information.floor:
-                    slab = file.create_entity(
-                        "IfcRoofType",
-                        GlobalId=ifcopenshell.guid.new(),
-                        Name=element_name,
-                    )
-                    ifcopenshell.api.run(
-                        "material.assign_material",
-                        file,
-                        product=slab,
-                        material=assigned_material,
-                    )
-                if material.information.door:
-                    door = file.create_entity(
-                        "IfcDoorType",
-                        GlobalId=ifcopenshell.guid.new(),
-                        Name=element_name,
-                    )
-                    ifcopenshell.api.run(
-                        "material.assign_material",
-                        file,
-                        product=door,
-                        material=assigned_material,
-                    )
+            for layer, ifc_material in zip(utils.get_material_layers(material), created):
+                geometry = utils.get_by_country(layer.geometry or (), self.country)
+                thick = getattr(geometry, "thick", None)
+                element_name = f"{name} | {thick}mm" if thick else name
+                assigned_material = self._assigned_material(ifc_material, thick, element_name, name)
+                self._create_usage_types(material, assigned_material, element_name)
+
+    def _assigned_material(self, ifc_material, thick, element_name, name):
+        if not thick:
+            return ifc_material
+        # MaterialBuilder.build already created the layer + layer set for this
+        # layer; reuse them so batch export does not duplicate entities.
+        for rel in self.file.get_inverse(ifc_material):
+            if rel.is_a("IfcMaterialLayer"):
+                for layer_set in rel.ToMaterialLayerSet or ():
+                    return layer_set
+        ifc_layer = self.file.create_entity(
+            "IfcMaterialLayer",
+            Material=ifc_material,
+            LayerThickness=thick / 1000,
+            Name=str(element_name),
+        )
+        return self.file.create_entity(
+            "IfcMaterialLayerSet",
+            MaterialLayers=[ifc_layer],
+            LayerSetName=str(element_name),
+        )
 
-    def get_surface_style(self, color, category):
+    def _create_usage_types(self, material, assigned_material, element_name):
         file = self.file
-        if color:
-            name = f"color {color}"
-            style = file.createIfcSurfaceStyleShading(
-                SurfaceColour=self.color_xml_to_ifc(color)
-            )
-        else:
-            if not category:
-                category = "Others"
-            name = f"category {category}"
-            for style in file.by_type("IfcSurfaceStyle"):
-                if style.Name == name:
-                    return style
-            style = file.createIfcSurfaceStyleShading(
-                SurfaceColour=self.file.createIfcColourRgb(
-                    None, *CATEGORIES[category]["color"]
-                ),
-            )
-        for surface_style in file.by_type("IfcSurfaceStyle"):
-            if surface_style.Name == name:
-                return surface_style
-        return file.createIfcSurfaceStyle(Name=name, Side="BOTH", Styles=[style])
+        kind_map = (("wall", "IfcWallType"), ("roof", "IfcRoofType"), ("floor", "IfcRoofType"), ("door", "IfcDoorType"))
+        for flag, entity_type in kind_map:
+            if getattr(material.information, flag, None):
+                product = file.create_entity(entity_type, GlobalId=ifcopenshell.guid.new(), Name=str(element_name))
+                ifcopenshell.api.run(
+                    "material.assign_material",
+                    file,
+                    products=[product],
+                    material=assigned_material,
+                )
+
+    def get_surface_style(self, color, category):
+        return self.builder.get_surface_style(color, category)
 
     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.builder.color_xml_to_ifc(color)
 
 
 def create_project_library_from_xml(xml_path):
     library = ProjectLibrary()
     deserialiser = XmlDeserialiser()
     source = deserialiser.from_xml(str(xml_path))
-    library.create_project_library(source)
+    library.create_project_library(company=source.company, companyid=source.companyid, ver=source.ver, crd=source.crd)
     library.create_materials(source)
     return library.file
 

materialsdb/query.py

@@ -0,0 +1,24 @@
+"""Convenience facade over the SQLite material store."""
+
+from functools import lru_cache
+
+from materialsdb.classes import Material
+from materialsdb.store import MaterialStore, Report
+from materialsdb.summary import MaterialSummary
+
+
+@lru_cache(maxsize=1)
+def get_store() -> MaterialStore:
+    return MaterialStore()
+
+
+def get_material(material_id: str) -> Material | None:
+    return get_store().get(material_id)
+
+
+def search(text: str, **filters) -> list[MaterialSummary]:
+    return get_store().summaries(text=text, **filters)
+
+
+def refresh(force: bool = False) -> Report:
+    return get_store().refresh(force=force)

materialsdb/schema/MaterialsDBIndex100.xsd

@@ -0,0 +1,60 @@
+<?xml version="1.0" encoding="iso-8859-1" standalone="no"?>
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
+  targetNamespace="http://www.materialsDB.org"
+  xmlns="http://www.materialsDB.org" elementFormDefault="qualified" version="1.00">
+<!--
+   An XML XSD for Open Materials database (OMaterialsDB 1.00)
+      DOCTYPE MaterialsDBIndex
+      SYSTEM http://www.materialsdb.org/schemas/MaterialsDBIndex100.xsd
+   See the documentation and examples at http://www.materialsdb.org/
+   (c) 2007-2013 E4tech Software SA, Edouard Westphal
+   released under the GNU Public License (GPL)
+-->
+<!--
+  1.00 : 2013.04.17 first version
+-->
+  <xs:simpleType name="TDateTime">
+    <xs:annotation>
+      <xs:documentation>
+  The integral part of a TDateTime value is the number of days that have passed since 12/30/1899.
+  The fractional part of the TDateTime value is fraction of a 24 hour day that has elapsed.
+  </xs:documentation>
+    </xs:annotation>
+    <xs:restriction base="xs:float"/>
+  </xs:simpleType>
+  <xs:simpleType name="guid">
+    <xs:restriction base="xs:string">
+      <xs:pattern value="[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}"/>
+    </xs:restriction>
+  </xs:simpleType>
+  <xs:element name='MaterialsDBIndex'>
+    <xs:complexType>
+      <xs:sequence>
+        <xs:element ref="company" maxOccurs="unbounded"/>
+      </xs:sequence>
+      <xs:attribute name="verXML" type="xs:unsignedInt" use="required"/>
+    </xs:complexType>
+  </xs:element>
+  <xs:element name="company">
+    <xs:complexType>
+      <xs:simpleContent>
+        <xs:extension base="xs:string">
+          <xs:attribute name="id" type="guid" use="required"/>
+          <xs:attribute name="name" type="xs:string" use="required"/>
+          <xs:attribute name="href" type="xs:anyURI" use="required"/>
+          <xs:attribute name="LastKnownDate" type="TDateTime" use="required"/>
+          <xs:attribute name="KnownVersion" type="xs:unsignedInt" use="required"/>
+          <xs:attribute name="KnownCRD" type="TDateTime" use="required"/>
+        </xs:extension>
+      </xs:simpleContent>
+    </xs:complexType>
+  </xs:element>
+</xs:schema>
+
+
+
+
+
+
+
+