python-materialsdb 0.0.2__tar.gz → 0.1.0__tar.gz

{python-materialsdb-0.0.2/src/python_materialsdb.egg-info → python_materialsdb-0.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: python-materialsdb
-Version: 0.0.2
+Version: 0.1.0
 Summary: A library to work with materialsdb.org open standard for building materials.
 Home-page: https://github.com/CyrilWaechter/python-materialsdb
 Author: Cyril Waechter
@@ -15,8 +15,13 @@ Classifier: Operating System :: OS Independent
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: Scientific/Engineering
 Description-Content-Type: text/markdown
-Provides-Extra: ifc
 License-File: LICENSE.md
+Requires-Dist: lxml
+Provides-Extra: ifc
+Requires-Dist: ifcopenshell; extra == "ifc"
+Provides-Extra: dev
+Requires-Dist: pytest-benchmark; extra == "dev"
+Dynamic: license-file
 
 python-materialsdb is an unofficial python library for [materialsdb.org][1] an open format and database for building materials.
 
@@ -45,9 +50,21 @@ Note: in materialsdb standard languages are [ISO 639-1](https://en.wikipedia.org
 
 # Usage examples :
 Check out some [examples](examples):
-* [Convert lastest materials data to ifc](examples/generate_ifc_project_libraries.py)
+* [Convert latest materials data to ifc](examples/generate_ifc_project_libraries.py)
 * [Create your own materialsdb.org compliant XML](examples/create_layers.py)
 
+# Querying materials :
+The library keeps an sqlite index of the cached materials data for fast
+filtering and single-material access:
+
+```python
+from materialsdb import query
+
+query.refresh()                                   # incremental update from cached xml
+rows = query.search("isolant", sort="lambda")     # filtered, sorted summaries
+material = query.get_material(rows[0].id)         # full material dataclass
+```
+
 # How to install
 ## Using pip
 ```bash
@@ -55,8 +72,8 @@ pip install python-materialsdb
 ```
 
 # Dependencies
-* [lxml][2] (BSD) : xml parser
-* [ifcopenshell][3] (LGPL) : ifc read/write
+* [lxml][2] (BSD) : xml parser (tested with version 6.1.1)
+* [ifcopenshell][3] (LGPL) : ifc read/write (tested with version 0.8.5)
 
 # Third parties :
 * [materialsdb.org][1] (GPL) : materials schema

{python-materialsdb-0.0.2 → python_materialsdb-0.1.0}/README.md

@@ -25,9 +25,21 @@ Note: in materialsdb standard languages are [ISO 639-1](https://en.wikipedia.org
 
 # Usage examples :
 Check out some [examples](examples):
-* [Convert lastest materials data to ifc](examples/generate_ifc_project_libraries.py)
+* [Convert latest materials data to ifc](examples/generate_ifc_project_libraries.py)
 * [Create your own materialsdb.org compliant XML](examples/create_layers.py)
 
+# Querying materials :
+The library keeps an sqlite index of the cached materials data for fast
+filtering and single-material access:
+
+```python
+from materialsdb import query
+
+query.refresh()                                   # incremental update from cached xml
+rows = query.search("isolant", sort="lambda")     # filtered, sorted summaries
+material = query.get_material(rows[0].id)         # full material dataclass
+```
+
 # How to install
 ## Using pip
 ```bash
@@ -35,8 +47,8 @@ pip install python-materialsdb
 ```
 
 # Dependencies
-* [lxml][2] (BSD) : xml parser
-* [ifcopenshell][3] (LGPL) : ifc read/write
+* [lxml][2] (BSD) : xml parser (tested with version 6.1.1)
+* [ifcopenshell][3] (LGPL) : ifc read/write (tested with version 0.8.5)
 
 # Third parties :
 * [materialsdb.org][1] (GPL) : materials schema

{python-materialsdb-0.0.2 → python_materialsdb-0.1.0}/pyproject.toml

@@ -7,4 +7,8 @@ build-backend = "setuptools.build_meta"
 [tool.pytest.ini_options]
 testpaths = [
     "tests",
-]
+]
+markers = [
+    "benchmark: performance benchmarks (deselected by default)",
+]
+addopts = "-m 'not benchmark'"

{python-materialsdb-0.0.2 → python_materialsdb-0.1.0}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = python-materialsdb
-version = 0.0.2
+version = 0.1.0
 author = Cyril Waechter
 author_email = cyrwae@hotmail.com
 description = A library to work with materialsdb.org open standard for building materials.
@@ -35,6 +35,7 @@ where = src
 
 [options.extras_require]
 ifc = ifcopenshell
+dev = pytest-benchmark
 
 [egg_info]
 tag_build = 

{python-materialsdb-0.0.2 → python_materialsdb-0.1.0}/src/materialsdb/cache.py

@@ -75,7 +75,8 @@ def update_producers_data(url_list=MATERIALSDBINDEXURLLIST):
 def update_producers_from_index(index):
     cached_index = parse_cached_index(index)
     cached_root = cached_index.getroot()
-    new_index = etree.parse(index)
+    with urllib.request.urlopen(index) as response:
+        new_index = etree.parse(response)
     new_root = new_index.getroot()
     producers_dir = get_producers_dir()
     has_index_update = False

{python-materialsdb-0.0.2 → python_materialsdb-0.1.0}/src/materialsdb/ifc/project_library.py

@@ -209,7 +209,7 @@ class ProjectLibrary:
                     ifcopenshell.api.run(
                         "material.assign_material",
                         file,
-                        product=wall,
+                        products=[wall],
                         material=assigned_material,
                     )
                 if material.information.roof:
@@ -221,7 +221,7 @@ class ProjectLibrary:
                     ifcopenshell.api.run(
                         "material.assign_material",
                         file,
-                        product=roof,
+                        products=[roof],
                         material=assigned_material,
                     )
                 if material.information.floor:
@@ -233,7 +233,7 @@ class ProjectLibrary:
                     ifcopenshell.api.run(
                         "material.assign_material",
                         file,
-                        product=slab,
+                        products=[slab],
                         material=assigned_material,
                     )
                 if material.information.door:
@@ -245,7 +245,7 @@ class ProjectLibrary:
                     ifcopenshell.api.run(
                         "material.assign_material",
                         file,
-                        product=door,
+                        products=[door],
                         material=assigned_material,
                     )
 

python_materialsdb-0.1.0/src/materialsdb/query.py

@@ -0,0 +1,24 @@
+"""Convenience facade over the SQLite material store."""
+from functools import lru_cache
+from typing import List, Optional
+
+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) -> Optional[Material]:
+    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)

{python-materialsdb-0.0.2 → python_materialsdb-0.1.0}/src/materialsdb/serialiser.py

@@ -9,6 +9,8 @@ See the LICENSE.md file for more details.
 Author : Cyril Waechter
 """
 import re
+from concurrent.futures import ThreadPoolExecutor
+from functools import lru_cache
 from pathlib import Path
 import typing
 from typing import Protocol, Tuple, Dict, Type, Optional, Any, Union
@@ -50,6 +52,11 @@ def get_valid_root(tree: objectify.ObjectifiedElement) -> str:
     return root
 
 
+@lru_cache(maxsize=None)
+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())
@@ -62,13 +69,29 @@ class XmlDeserialiser:
             tree = objectify.parse(xml_path)
         return self.from_element(get_valid_root(tree))
 
+    def from_xml_files(self, paths, max_workers=None):
+        """Parse multiple producer XML files concurrently.
+
+        Yields (path, Materials) per successfully parsed file and
+        (path, None) for files that could not be parsed."""
+
+        def load(path):
+            try:
+                return Path(path), self.from_xml(str(path))
+            except Exception as err:
+                print(f"{Path(path).name}: could not parse file:\n\t{err}")
+                return Path(path), None
+
+        with ThreadPoolExecutor(max_workers=max_workers) as executor:
+            yield from executor.map(load, paths)
+
     def from_element(self, element=None, base_class=None):
         element_name = get_element_name(element)
         element_class = base_class or getattr(classes, self.cls_name(element_name))
         kwargs: Dict[str, Any] = {}
         if element_class.xs_type != "element":
             kwargs["object"] = element.text or ""
-        type_hints = typing.get_type_hints(element_class)
+        type_hints = cached_type_hints(element_class)
         for attrib in getattr(element_class, "xml_attributes", ()):
             value = element.get(attrib)
             if value is None:

python_materialsdb-0.1.0/src/materialsdb/store.py

@@ -0,0 +1,290 @@
+import datetime
+import hashlib
+import json
+import sqlite3
+from collections import namedtuple
+from pathlib import Path
+from typing import List, Optional
+
+from lxml import etree, objectify
+
+from materialsdb import cache, config
+from materialsdb.classes import Material
+from materialsdb.serialiser import XmlDeserialiser, get_valid_root
+from materialsdb.summary import MaterialSummary, summarize_material
+
+Report = namedtuple("Report", ["existing", "updated", "deleted", "skipped"])
+
+SCHEMA_VERSION = "1"
+
+_SCHEMA = """
+CREATE TABLE IF NOT EXISTS materials (
+    id TEXT PRIMARY KEY, company_id TEXT, company TEXT, category TEXT,
+    names TEXT, descriptions TEXT,
+    lambda_min REAL, lambda_max REAL, thick_min REAL, thick_max REAL,
+    usage TEXT, source_file TEXT, xml BLOB);
+CREATE INDEX IF NOT EXISTS idx_company ON materials(company);
+CREATE INDEX IF NOT EXISTS idx_category ON materials(category);
+CREATE INDEX IF NOT EXISTS idx_lambda ON materials(lambda_min);
+CREATE TABLE IF NOT EXISTS producer_files (
+    path TEXT PRIMARY KEY, sha256 TEXT, built_at REAL);
+CREATE TABLE IF NOT EXISTS meta (key TEXT PRIMARY KEY, value TEXT);
+"""
+
+_MATERIAL_COLUMNS = (
+    "id",
+    "company_id",
+    "company",
+    "category",
+    "names",
+    "descriptions",
+    "lambda_min",
+    "lambda_max",
+    "thick_min",
+    "thick_max",
+    "usage",
+    "source_file",
+    "xml",
+)
+_COLUMN_LIST = ", ".join(_MATERIAL_COLUMNS)
+
+_NUMERIC_SORTS = {"lambda": "lambda_min", "thick": "thick_min"}
+_STRING_SORTS = {"company": "company", "category": "category"}
+
+
+def _sha256(path: Path) -> str:
+    return hashlib.sha256(path.read_bytes()).hexdigest()
+
+
+class MaterialStore:
+    SCHEMA_VERSION = SCHEMA_VERSION
+
+    def __init__(self, db_path: Optional[Path] = None):
+        self.db_path = (
+            Path(db_path) if db_path else cache.get_cache_folder() / "materials.db"
+        )
+        self.db_path.parent.mkdir(parents=True, exist_ok=True)
+        self.connection = sqlite3.connect(str(self.db_path))
+        self.connection.execute("PRAGMA journal_mode=WAL")
+        self.connection.executescript(_SCHEMA)
+        self._ensure_schema_version()
+
+    # ---------- meta / lifecycle ----------
+
+    def _ensure_schema_version(self):
+        row = self.connection.execute(
+            "SELECT value FROM meta WHERE key='schema_version'"
+        ).fetchone()
+        stored = row[0] if row else None
+        if stored != SCHEMA_VERSION:
+            self.connection.execute("DROP TABLE IF EXISTS materials")
+            self.connection.execute("DROP TABLE IF EXISTS producer_files")
+            self.connection.executescript(_SCHEMA)
+            self.connection.execute(
+                "INSERT INTO meta(key, value) VALUES ('schema_version', ?) "
+                "ON CONFLICT(key) DO UPDATE SET value=excluded.value",
+                (SCHEMA_VERSION,),
+            )
+            self.connection.commit()
+
+    def close(self):
+        self.connection.close()
+
+    # ---------- build / refresh ----------
+
+    def refresh(self, force=False, paths=None) -> Report:
+        if paths is None:
+            paths = list(cache.producers())
+        else:
+            paths = [Path(p) for p in paths]
+
+        kept = {str(p) for p in paths}
+        deleted = []
+        for (stored_path,) in self.connection.execute(
+            "SELECT path FROM producer_files"
+        ).fetchall():
+            if stored_path not in kept:
+                self.connection.execute(
+                    "DELETE FROM materials WHERE source_file=?", (stored_path,)
+                )
+                self.connection.execute(
+                    "DELETE FROM producer_files WHERE path=?", (stored_path,)
+                )
+                deleted.append(Path(stored_path))
+
+        existing, updated, skipped = [], [], []
+        deserialiser = XmlDeserialiser()
+        for path in paths:
+            row = self.connection.execute(
+                "SELECT sha256 FROM producer_files WHERE path=?", (str(path),)
+            ).fetchone()
+            try:
+                digest = _sha256(path)
+                if not force and row and row[0] == digest:
+                    existing.append(path)
+                    continue
+                self._upsert_file(deserialiser, path)
+            except Exception as err:
+                print(f"{path.name}: skipped during store refresh:\n\t{err}")
+                skipped.append(path)
+                continue
+            self.connection.execute(
+                "INSERT INTO producer_files(path, sha256, built_at) VALUES (?, ?, ?) "
+                "ON CONFLICT(path) DO UPDATE SET sha256=excluded.sha256, "
+                "built_at=excluded.built_at",
+                (str(path), digest, datetime.datetime.now().timestamp()),
+            )
+            updated.append(path)
+
+        self.connection.commit()
+        return Report(existing, updated, deleted, skipped)
+
+    def _upsert_file(self, deserialiser: XmlDeserialiser, path: Path):
+        tree = objectify.parse(str(path))
+        root = get_valid_root(tree)
+        source = deserialiser.from_element(root)
+        self.connection.execute(
+            "DELETE FROM materials WHERE source_file=?", (str(path),)
+        )
+        for element in root.material:
+            material = deserialiser.from_element(element)
+            summary = summarize_material(
+                material, company_id=str(source.companyid), company=source.company
+            )
+            self.connection.execute(
+                f"INSERT INTO materials ({_COLUMN_LIST}) "
+                "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
+                (
+                    summary.id,
+                    summary.company_id,
+                    summary.company,
+                    summary.category,
+                    json.dumps(summary.names),
+                    json.dumps(summary.descriptions),
+                    summary.lambda_min,
+                    summary.lambda_max,
+                    summary.thick_min,
+                    summary.thick_max,
+                    json.dumps(summary.usage),
+                    str(path),
+                    sqlite3.Binary(etree.tostring(element)),
+                ),
+            )
+
+    # ---------- queries ----------
+
+    def summaries(
+        self,
+        company=None,
+        category=None,
+        min_lambda=None,
+        max_lambda=None,
+        min_thick=None,
+        max_thick=None,
+        usage=None,
+        text=None,
+        sort="company",
+        ascending=True,
+        lang=None,
+    ) -> List[MaterialSummary]:
+        where, params = [], []
+
+        def add(condition, value):
+            where.append(condition)
+            params.append(value)
+
+        if company:
+            add("company=?", company)
+        if category:
+            add("category=?", category)
+        if min_lambda is not None:
+            add("lambda_max>=?", min_lambda)
+        if max_lambda is not None:
+            add("lambda_min<=?", max_lambda)
+        if min_thick is not None:
+            add("thick_max>=?", min_thick)
+        if max_thick is not None:
+            add("thick_min<=?", max_thick)
+
+        query = f"SELECT {_COLUMN_LIST} FROM materials"
+        if where:
+            query += " WHERE " + " AND ".join(where)
+        rows = self.connection.execute(query, params).fetchall()
+
+        lang = lang or config.get_lang()
+        results = [self._row_to_summary(row) for row in rows]
+
+        if usage:
+            results = [r for r in results if r.usage.get(usage)]
+        if text:
+            needle = text.lower()
+            results = [
+                r
+                for r in results
+                if needle in (r.names.get(lang) or r.names.get("") or "").lower()
+            ]
+        return self._sorted(results, sort, ascending)
+
+    @staticmethod
+    def _sorted(
+        results: List[MaterialSummary], sort: str, ascending: bool
+    ) -> List[MaterialSummary]:
+        reverse = not ascending
+        if sort == "name":
+            return sorted(
+                results,
+                key=lambda r: r.names.get("") or "",
+                reverse=reverse,
+            )
+        if sort in _NUMERIC_SORTS:
+            attr = _NUMERIC_SORTS[sort]
+            return sorted(
+                results,
+                key=lambda r: (
+                    (getattr(r, attr) is None) != reverse,
+                    getattr(r, attr) if getattr(r, attr) is not None else 0,
+                ),
+                reverse=reverse,
+            )
+        attr = _STRING_SORTS.get(sort, "company")
+        return sorted(results, key=lambda r: str(getattr(r, attr)), reverse=reverse)
+
+    @staticmethod
+    def _row_to_summary(row) -> MaterialSummary:
+        (
+            id_,
+            company_id,
+            company,
+            category,
+            names,
+            descriptions,
+            lambda_min,
+            lambda_max,
+            thick_min,
+            thick_max,
+            usage,
+            _source_file,
+            _xml,
+        ) = row
+        return MaterialSummary(
+            id=id_,
+            company_id=company_id,
+            company=company,
+            category=category,
+            names=json.loads(names),
+            descriptions=json.loads(descriptions),
+            lambda_min=lambda_min,
+            lambda_max=lambda_max,
+            thick_min=thick_min,
+            thick_max=thick_max,
+            usage=json.loads(usage),
+        )
+
+    def get(self, material_id: str) -> Optional[Material]:
+        row = self.connection.execute(
+            "SELECT xml FROM materials WHERE id=?", (material_id,)
+        ).fetchone()
+        if row is None:
+            return None
+        element = objectify.fromstring(bytes(row[0]))
+        return XmlDeserialiser().from_element(element)

python_materialsdb-0.1.0/src/materialsdb/summary.py

@@ -0,0 +1,75 @@
+from dataclasses import dataclass
+from typing import Dict, Optional, Tuple
+
+from materialsdb import config, utils
+from materialsdb.classes import Material
+
+USAGE_FLAGS = ("wall", "roof", "floor", "door")
+
+
+@dataclass
+class MaterialSummary:
+    id: str
+    company_id: str
+    company: str
+    category: str
+    names: Dict[str, str]
+    descriptions: Dict[str, str]
+    lambda_min: Optional[float]
+    lambda_max: Optional[float]
+    thick_min: Optional[float]
+    thick_max: Optional[float]
+    usage: Dict[str, bool]
+
+
+def _localized_dict(items) -> Dict[str, str]:
+    result: Dict[str, str] = {}
+    for item in items or ():
+        result[str(item.lang or "")] = str(item)
+    return result
+
+
+def _min_max(values) -> Tuple[Optional[float], Optional[float]]:
+    values = [v for v in values if v is not None]
+    if not values:
+        return None, None
+    return min(values), max(values)
+
+
+def summarize_material(
+    material: Material,
+    company_id: str = "",
+    company: str = "",
+    country: Optional[str] = None,
+) -> MaterialSummary:
+    country = country or config.get_country()
+    information = material.information
+
+    lambdas = []
+    thicks = []
+    for layer in utils.get_material_layers(material):
+        thermal = utils.get_by_country(layer.thermal or (), country)
+        geometry = utils.get_by_country(layer.geometry or (), country)
+        if thermal is not None:
+            lambdas.append(thermal.lambda_value)
+        if geometry is not None:
+            thicks.append(geometry.thick)
+
+    lambda_min, lambda_max = _min_max(lambdas)
+    thick_min, thick_max = _min_max(thicks)
+
+    return MaterialSummary(
+        id=str(material.id),
+        company_id=str(company_id),
+        company=str(company),
+        category=str(information.group or ""),
+        names=_localized_dict(getattr(information.names, "name", ())),
+        descriptions=_localized_dict(
+            getattr(getattr(information, "explanations", None), "explanation", ())
+        ),
+        lambda_min=lambda_min,
+        lambda_max=lambda_max,
+        thick_min=thick_min,
+        thick_max=thick_max,
+        usage={flag: str(getattr(information, flag)) == "1" for flag in USAGE_FLAGS},
+    )

{python-materialsdb-0.0.2 → python_materialsdb-0.1.0/src/python_materialsdb.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: python-materialsdb
-Version: 0.0.2
+Version: 0.1.0
 Summary: A library to work with materialsdb.org open standard for building materials.
 Home-page: https://github.com/CyrilWaechter/python-materialsdb
 Author: Cyril Waechter
@@ -15,8 +15,13 @@ Classifier: Operating System :: OS Independent
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: Scientific/Engineering
 Description-Content-Type: text/markdown
-Provides-Extra: ifc
 License-File: LICENSE.md
+Requires-Dist: lxml
+Provides-Extra: ifc
+Requires-Dist: ifcopenshell; extra == "ifc"
+Provides-Extra: dev
+Requires-Dist: pytest-benchmark; extra == "dev"
+Dynamic: license-file
 
 python-materialsdb is an unofficial python library for [materialsdb.org][1] an open format and database for building materials.
 
@@ -45,9 +50,21 @@ Note: in materialsdb standard languages are [ISO 639-1](https://en.wikipedia.org
 
 # Usage examples :
 Check out some [examples](examples):
-* [Convert lastest materials data to ifc](examples/generate_ifc_project_libraries.py)
+* [Convert latest materials data to ifc](examples/generate_ifc_project_libraries.py)
 * [Create your own materialsdb.org compliant XML](examples/create_layers.py)
 
+# Querying materials :
+The library keeps an sqlite index of the cached materials data for fast
+filtering and single-material access:
+
+```python
+from materialsdb import query
+
+query.refresh()                                   # incremental update from cached xml
+rows = query.search("isolant", sort="lambda")     # filtered, sorted summaries
+material = query.get_material(rows[0].id)         # full material dataclass
+```
+
 # How to install
 ## Using pip
 ```bash
@@ -55,8 +72,8 @@ pip install python-materialsdb
 ```
 
 # Dependencies
-* [lxml][2] (BSD) : xml parser
-* [ifcopenshell][3] (LGPL) : ifc read/write
+* [lxml][2] (BSD) : xml parser (tested with version 6.1.1)
+* [ifcopenshell][3] (LGPL) : ifc read/write (tested with version 0.8.5)
 
 # Third parties :
 * [materialsdb.org][1] (GPL) : materials schema

{python-materialsdb-0.0.2 → python_materialsdb-0.1.0}/src/python_materialsdb.egg-info/SOURCES.txt

@@ -6,7 +6,10 @@ src/materialsdb/__init__.py
 src/materialsdb/cache.py
 src/materialsdb/classes.py
 src/materialsdb/config.py
+src/materialsdb/query.py
 src/materialsdb/serialiser.py
+src/materialsdb/store.py
+src/materialsdb/summary.py
 src/materialsdb/utils.py
 src/materialsdb/ifc/__init__.py
 src/materialsdb/ifc/material_psets.json
@@ -17,4 +20,7 @@ src/python_materialsdb.egg-info/dependency_links.txt
 src/python_materialsdb.egg-info/requires.txt
 src/python_materialsdb.egg-info/top_level.txt
 tests/test_project_library.py
-tests/test_serialiser.py
+tests/test_query.py
+tests/test_serialiser.py
+tests/test_store.py
+tests/test_summary.py

{python-materialsdb-0.0.2 → python_materialsdb-0.1.0}/src/python_materialsdb.egg-info/requires.txt

@@ -1,4 +1,7 @@
 lxml
 
+[dev]
+pytest-benchmark
+
 [ifc]
 ifcopenshell

{python-materialsdb-0.0.2 → python_materialsdb-0.1.0}/tests/test_project_library.py

@@ -1,6 +1,14 @@
+from pathlib import Path
+
+import pytest
+
 from materialsdb.ifc import project_library
 
 
+@pytest.mark.skipif(
+    not Path("example_v103.xml").exists(),
+    reason="example_v103.xml not present locally",
+)
 def test_create_project_library():
     file = project_library.create_project_library_from_xml("example_v103.xml")
     file.write("example_v103.ifc")

python_materialsdb-0.1.0/tests/test_query.py

@@ -0,0 +1,34 @@
+import pytest
+
+from materialsdb import query
+from materialsdb.store import MaterialStore
+
+
+@pytest.fixture(autouse=True)
+def pinned_fr_ch_config(monkeypatch):
+    monkeypatch.setattr("materialsdb.config.get_lang", lambda: "fr")
+    monkeypatch.setattr("materialsdb.config.get_country", lambda: "CH")
+
+
+@pytest.fixture
+def isolated_store(tmp_path, monkeypatch, mini_xml):
+    query.get_store.cache_clear()
+    monkeypatch.setattr(
+        "materialsdb.query.MaterialStore",
+        lambda: MaterialStore(db_path=tmp_path / "q.db"),
+    )
+    store = query.get_store()
+    store.refresh(paths=[mini_xml])
+    yield store
+    store.close()
+    query.get_store.cache_clear()
+
+
+def test_get_material(isolated_store):
+    material = query.get_material("00000000-0000-0000-0000-000000000002")
+    assert material.information.group == "Concrete"
+
+
+def test_search(isolated_store):
+    rows = query.search("beton")
+    assert len(rows) == 1

python_materialsdb-0.1.0/tests/test_serialiser.py

@@ -0,0 +1,65 @@
+import sys
+from pathlib import Path
+
+sys.path.append(str(Path(__file__).parent.parent / "src"))
+import pytest
+
+from materialsdb.serialiser import XmlDeserialiser, XmlSerialiser
+
+
+@pytest.mark.skipif(
+    not Path("example_v103.xml").exists(),
+    reason="example_v103.xml not present locally",
+)
+def test_deserialise_and_serialise():
+    xml_path = "example_v103.xml"
+    deserialiser = XmlDeserialiser()
+    source = deserialiser.from_xml(xml_path)
+    serialiser = XmlSerialiser()
+    serialiser.to_xml(source, xml_path="test.xml")
+
+
+def test_mini_fixture_roundtrip(tmp_path, mini_source):
+    assert len(mini_source.material) == 3
+    assert mini_source.company == "Mini SA"
+    out = tmp_path / "roundtrip.xml"
+    XmlSerialiser().to_xml(mini_source, xml_path=str(out))
+    reparsed = XmlDeserialiser().from_xml(str(out))
+    assert len(reparsed.material) == 3
+
+
+@pytest.mark.skipif(
+    not Path("example_v103.xml").exists(),
+    reason="example_v103.xml not present locally",
+)
+def test_type_hints_are_cached():
+    from materialsdb import serialiser
+
+    serialiser.cached_type_hints.cache_clear()
+    deserialiser = XmlDeserialiser()
+    deserialiser.from_xml("example_v103.xml")
+    hits_after_first = serialiser.cached_type_hints.cache_info().hits
+    deserialiser.from_xml("example_v103.xml")
+    assert serialiser.cached_type_hints.cache_info().hits > hits_after_first
+
+
+import shutil
+
+
+def test_from_xml_files_reports_corrupt_and_parses_rest(tmp_path, mini_xml):
+    good_a = tmp_path / "a.xml"
+    good_b = tmp_path / "b.xml"
+    bad = tmp_path / "bad.xml"
+    shutil.copy(mini_xml, good_a)
+    shutil.copy(mini_xml, good_b)
+    bad.write_text("<materials><unclosed>", encoding="utf-8")
+
+    results = {
+        path.name: source
+        for path, source in XmlDeserialiser().from_xml_files([good_a, good_b, bad])
+    }
+
+    assert results["a.xml"] is not None
+    assert len(results["a.xml"].material) == 3
+    assert results["b.xml"] is not None
+    assert results["bad.xml"] is None

python_materialsdb-0.1.0/tests/test_store.py

@@ -0,0 +1,109 @@
+import pytest
+
+from materialsdb.store import MaterialStore
+
+
+@pytest.fixture(autouse=True)
+def pinned_fr_ch_config(monkeypatch):
+    monkeypatch.setattr("materialsdb.config.get_lang", lambda: "fr")
+    monkeypatch.setattr("materialsdb.config.get_country", lambda: "CH")
+
+
+@pytest.fixture
+def store(tmp_path, mini_xml):
+    s = MaterialStore(db_path=tmp_path / "test.db")
+    s.refresh(paths=[mini_xml])
+    yield s
+    s.close()
+
+
+def test_refresh_populates_all_materials(store):
+    assert len(store.summaries()) == 3
+
+
+def test_get_returns_full_material_equivalent_to_direct_parse(store, mini_source):
+    material = store.get("00000000-0000-0000-0000-000000000001")
+    original = mini_source.material[0]
+    assert str(material.information.names.name[0]) == str(
+        original.information.names.name[0]
+    )
+    assert material.information.group == "Insulation"
+    assert material.layers.layer[0].thermal[0].lambda_value == 0.036
+
+
+def test_get_unknown_id_returns_none(store):
+    assert store.get("nope") is None
+
+
+def test_filters(store):
+    insulation = store.summaries(category="Insulation")
+    assert len(insulation) == 1
+    assert insulation[0].id.endswith("001")
+
+    assert len(store.summaries(company="Mini SA")) == 3
+
+    low_lambda = store.summaries(max_lambda=0.1)
+    assert {s.id[-3:] for s in low_lambda} == {"001"}
+
+    walls = store.summaries(usage="wall")
+    assert len(walls) == 1
+
+
+def test_sort_order_and_nulls_last(store):
+    rows = store.summaries(sort="lambda")
+    assert [r.lambda_min for r in rows] == [0.036, 0.21, None]
+
+    rows = store.summaries(sort="lambda", ascending=False)
+    assert [r.lambda_min for r in rows] == [0.21, 0.036, None]
+
+    rows = store.summaries(sort="thick", ascending=False)
+    assert [r.thick_min for r in rows] == [150, 100, None]
+
+
+def test_text_filter_uses_configured_lang(monkeypatch, store):
+    monkeypatch.setattr("materialsdb.config.get_lang", lambda: "fr")
+    rows = store.summaries(text="isol")
+    assert len(rows) == 1
+    assert rows[0].id.endswith("001")
+
+
+def test_refresh_is_incremental(store, mini_xml):
+    report = store.refresh(paths=[mini_xml])
+    assert report.updated == []
+    assert len(report.existing) == 1
+
+
+def test_refresh_rebuilds_changed_file(store, mini_xml, tmp_path):
+    copy = tmp_path / "changed.xml"
+    copy.write_text(
+        mini_xml.read_text(encoding="utf-8").replace("0.036", "0.03"),
+        encoding="utf-8",
+    )
+
+    report = store.refresh(paths=[copy])
+    assert copy in report.updated
+    rows = store.summaries(min_lambda=0.03, max_lambda=0.1)
+    assert len(rows) == 1
+    assert rows[0].lambda_min == 0.03
+
+
+def test_deleted_producer_rows_are_removed(store):
+    store.refresh(paths=[])  # declare current file set empty
+    assert store.summaries() == []
+
+
+def test_corrupt_producer_is_skipped(store, tmp_path, mini_xml):
+    bad = tmp_path / "bad.xml"
+    bad.write_text("<materials>", encoding="utf-8")
+    report = store.refresh(force=True, paths=[mini_xml, bad])
+    assert len(report.existing) + len(report.updated) == 1
+    assert report.skipped == [bad]
+    assert len(store.summaries()) == 3
+
+
+def test_nonexistent_producer_is_skipped_without_raising(store, tmp_path, mini_xml):
+    ghost = tmp_path / "ghost.xml"
+    report = store.refresh(paths=[mini_xml, ghost])
+    assert report.existing == [mini_xml]
+    assert report.updated == []
+    assert len(store.summaries()) == 3

python_materialsdb-0.1.0/tests/test_summary.py

@@ -0,0 +1,41 @@
+from materialsdb.summary import summarize_material
+
+
+def test_insulation_material_summary_ch(mini_source):
+    material = mini_source.material[0]
+    s = summarize_material(material, country="CH")
+
+    assert s.id == "00000000-0000-0000-0000-000000000001"
+    assert s.category == "Insulation"
+    assert s.names == {"fr": "Isolant A", "de": "Daemmstoff A", "": "Material A"}
+    assert s.descriptions == {"fr": "Panneau isolant", "de": "Daemmplatte"}
+    assert s.usage["wall"] is True
+    assert s.usage["roof"] is False
+    assert s.thick_min == 100
+    assert s.thick_max == 200
+    assert s.lambda_min == 0.036
+    assert s.lambda_max == 0.05
+
+
+def test_french_country_picks_fr_values(mini_source):
+    s = summarize_material(mini_source.material[0], country="FR")
+    assert s.lambda_min == 0.04
+    assert s.lambda_max == 0.05
+    assert s.thick_min == 100
+    assert s.thick_max == 240
+
+
+def test_concrete_single_layer(mini_source):
+    s = summarize_material(mini_source.material[1], country="CH")
+    assert s.category == "Concrete"
+    assert s.names == {"fr": "Beton B"}
+    assert s.descriptions == {}
+    assert s.lambda_min == s.lambda_max == 0.21
+    assert s.thick_min == s.thick_max == 150
+
+
+def test_material_without_layers_has_none_metrics(mini_source):
+    s = summarize_material(mini_source.material[2])
+    assert s.lambda_min is None
+    assert s.thick_max is None
+    assert s.usage == {"wall": False, "roof": False, "floor": False, "door": False}

python-materialsdb-0.0.2/tests/test_serialiser.py

@@ -1,13 +0,0 @@
-import sys
-from pathlib import Path
-
-sys.path.append(str(Path(__file__).parent.parent / "src"))
-from materialsdb.serialiser import XmlDeserialiser, XmlSerialiser
-
-
-def test_deserialise_and_serialise():
-    xml_path = "example_v103.xml"
-    deserialiser = XmlDeserialiser()
-    source = deserialiser.from_xml(xml_path)
-    serialiser = XmlSerialiser()
-    serialiser.to_xml(source, xml_path="test.xml")