bruce-models 0.3.0__tar.gz → 0.3.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bruce-models
-Version: 0.3.0
+Version: 0.3.2
 Summary: This is a library which defines data-models for the Nextspace API and provides functions for communicating with the endpoints.
 Author: Matvey Lavrinovich
 Author-email: matveylavrinovich@gmail.com

{bruce_models-0.3.0 → bruce_models-0.3.2}/bruce_models/__init__.py

@@ -62,7 +62,7 @@ from .util.path_utils import PathUtils
 
 # The one place the version is written. setup.py reads it from here without importing the package,
 # and pypi-release.sh reads this same file, so a source checkout and a wheel can never disagree.
-__version__ = "0.3.0"
+__version__ = "0.3.2"
 
 __all__ = [
     "__version__",

{bruce_models-0.3.0 → bruce_models-0.3.2}/bruce_models/change/change_set.py

@@ -188,6 +188,14 @@ class ChangeSet:
     def status_of(response: Any) -> Optional[str]:
         return (response or {}).get("Status")
 
+    @staticmethod
+    def action_id_of(response: Any) -> Optional[int]:
+        """
+        The Pending Action a commit started, from the record the route answers with.
+        """
+        response = response or {}
+        return response.get("PendingActionID") or response.get("PendingAction.ID")
+
     @staticmethod
     def is_uncommitted(response: Any) -> bool:
         """

{bruce_models-0.3.0 → bruce_models-0.3.2}/bruce_models/change/change_set_builder.py

@@ -5,6 +5,7 @@ from bruce_models.util.required import required
 from bruce_models.change.change_set import ChangeSet
 from bruce_models.change.edit_store import EditStore
 from bruce_models.entity.entity import Entity
+from bruce_models.server.pending_action import PendingAction
 
 MAX_REPORTED = 1000
 
@@ -381,14 +382,24 @@ class ChangeSetBuilder:
         self._record = ChangeSet.get(self.api, self.change_id)
         return self._record
 
-    def commit(self) -> Any:
+    # A commit is a job, so the record still reads Uncommitted for a moment after the route answers.
+    COMMIT_POLL_SECONDS = 1.0
+
+    def commit(self, wait: bool = False, timeout: Optional[float] = None) -> Any:
         """
         Applies the set. Anything queued locally is saved first, so nothing is left behind.
         """
         self._refuse_repeats("be committed")
         if len(self) or not self.change_id:
             self.save()
-        return ChangeSet.commit(self.api, required(self.change_id, "change set ID"))
+        response = ChangeSet.commit(self.api, required(self.change_id, "change set ID"))
+        if wait:
+            action_id = ChangeSet.action_id_of(response)
+            if action_id:
+                PendingAction.on_completion(self.api, action_id,
+                                            interval=self.COMMIT_POLL_SECONDS, timeout=timeout)
+            self.refresh()
+        return response
 
     def reject(self) -> Any:
         """

{bruce_models-0.3.0 → bruce_models-0.3.2}/bruce_models/cli/run_change_set.py

@@ -16,6 +16,10 @@ from bruce_models.cli import seed_change_set
 from bruce_models.cli import seed_datalab
 from bruce_models.cli.runner import (ImportFailed, Result, Timer, _finish, _own_type, _report_step)
 
+# A commit of this size is seconds of work, so anything approaching this is a stuck job rather than
+# a slow one.
+COMMIT_TIMEOUT = 120
+
 
 def run_change_set(api: BruceApi, rows: int = 0, on_progress=None, on_message=None,
                    cleanup: bool = True) -> Result:
@@ -174,8 +178,7 @@ def _check_commit(api: BruceApi, result: Result, type_id: str, entity_ids: List[
         try:
             if builder is None:
                 raise ImportFailed("nothing was staged to commit")
-            builder.commit()
-            time.sleep(2)
+            builder.commit(wait=True, timeout=COMMIT_TIMEOUT)
             problems = []
             changed = _count_at(api, type_id, entity_ids, seed_change_set.AFTER)
             if changed != step.expected:
@@ -186,7 +189,7 @@ def _check_commit(api: BruceApi, result: Result, type_id: str, entity_ids: List[
             step.ok = not problems
             step.detail = (", ".join(problems) if problems
                            else f"{changed} applied, {ChangeSet.COMMITTED}")
-        except (ApiError, ImportFailed, ValueError) as e:
+        except (ApiError, ImportFailed, TimeoutError, ValueError) as e:
             step.detail = str(e)
     _report_step(report, step)
 

bruce_models-0.3.2/bruce_models/cli/run_import_ifc.py

@@ -0,0 +1,255 @@
+"""
+IFC imports: whether a generated document converts, and whether each representation shape survives.
+"""
+
+import time
+from typing import List, Optional
+
+from bruce_models.api.bruce_api import BruceApi
+from bruce_models.api.errors import ApiError
+from bruce_models.client_file.client_file import ClientFile
+from bruce_models.entity.entity import Entity
+from bruce_models.entity.entity_type import EntityType
+from bruce_models.format_assembly.assembly_import import AssemblyImport
+from bruce_models.server.pending_action import EStatus
+from bruce_models.cli import seed_bench
+from bruce_models.cli import seed_ifc
+from bruce_models.cli.runner import (ImportFailed, Result, Timer, _finish, _job_outcome,
+                                     _message_relay, _report_step)
+
+
+# How deep the walk over an imported tree is allowed to go before it gives up.
+# The documents here are a handful of nodes, so anything approaching this is a cycle rather than a deep model.
+MAX_DEPTH = 12
+
+
+def _import_document(api: BruceApi, result: Result, document: seed_ifc.Document,
+                     suffix: str, on_message=None) -> dict:
+    """
+    Uploads one generated IFC and runs both phases of the import against it.
+    """
+    name = f"ifc-{document.key}-{suffix}"
+    file_name = f"{name}.ifc"
+    try:
+        uploaded = ClientFile.upload_temp_bytes(api, document.data, file_name)
+    except ValueError as e:
+        raise ImportFailed(f"{document.key}: {e}") from None
+
+    # The upload registers a Client File alongside the temp file, and teardown has to know about it.
+    client_file_id = uploaded.get("ClientFile.ID")
+    if client_file_id:
+        result.client_file_ids.append(client_file_id)
+
+    parent_type_id = EntityType.create(api, f"bruce test {name}")
+    result.assembly_type_ids.append(parent_type_id)
+
+    outcome = AssemblyImport.run(api, assembly_name=file_name,
+                                 parent_type_name=f"bruce test {name}",
+                                 temp_file_id=uploaded["TempFile.ID"],
+                                 temp_file_name=file_name,
+                                 parent_type_id=parent_type_id,
+                                 on_message=_message_relay(on_message))
+    assembly_id = (outcome.get("result") or {}).get("Assembly.ID")
+    if assembly_id:
+        result.assembly_ids.append(assembly_id)
+    result.entity_ids.append(outcome["root_entity_id"])
+    return outcome
+
+
+def _node_count(api: BruceApi, root_entity_id: str) -> int:
+    """
+    How many Entities the imported tree holds, root included.
+    """
+    seen = set()
+    pending = [(root_entity_id, 0)]
+    while pending:
+        entity_id, depth = pending.pop()
+        if not entity_id or entity_id in seen or depth > MAX_DEPTH:
+            continue
+        seen.add(entity_id)
+        for child in Entity.get_children(api, entity_id):
+            pending.append((Entity.child_id(child), depth + 1))
+    return len(seen)
+
+
+def _leaf_ids(api: BruceApi, root_entity_id: str) -> List[str]:
+    """
+    The Entities in the tree with nothing under them, which is where element properties land.
+    """
+    leaves = []
+    pending = [(root_entity_id, 0)]
+    seen = set()
+    while pending:
+        entity_id, depth = pending.pop()
+        if not entity_id or entity_id in seen or depth > MAX_DEPTH:
+            continue
+        seen.add(entity_id)
+        children = Entity.get_children(api, entity_id)
+        if not children:
+            leaves.append(entity_id)
+        for child in children:
+            pending.append((Entity.child_id(child), depth + 1))
+    return leaves
+
+
+def _find_property(api: BruceApi, leaf_ids: List[str]) -> Optional[str]:
+    """
+    The first value the generated property set put on any leaf, or None when none carried one.
+
+    Which leaf carries it is not asserted: an importer is free to arrange the tree how it likes, and
+    the question here is whether the properties crossed the conversion at all.
+    """
+    for entity_id in leaf_ids:
+        try:
+            entity = Entity.get(api, entity_id)
+        except (ApiError, ValueError):
+            continue
+        # Segments rather than a dotted string: a Nextspace path quotes its parts, so
+        # "Pset_BruceTest.Label" parses as one segment naming an attribute nothing answers to.
+        for path in ([seed_ifc.PSET_NAME, seed_ifc.PSET_LABEL], [seed_ifc.PSET_LABEL]):
+            value = Entity.get_value(entity, path)
+            if value:
+                return str(value)
+    return None
+
+
+def run_import_ifc(
+    api: BruceApi,
+    rows: int = 0,
+    on_progress=None,
+    on_message=None,
+    cleanup: bool = True
+) -> Result:
+    """
+    Imports one generated IFC and checks the tree and the properties it produced.
+    """
+    def report(message):
+        if on_progress:
+            on_progress(message)
+
+    result = Result()
+    started = time.monotonic()
+    document = seed_ifc.simple()
+    expected_nodes = seed_ifc.SPATIAL_LEVELS + document.element_count
+
+    step = result.step("Generate IFC")
+    with Timer(step):
+        step.ok = True
+        step.detail = (f"{document.element_count} elements, {document.size_bytes / 1024:.1f} KB "
+                       f"(no file fixture)")
+    _report_step(report, step)
+
+    step = result.step("Import IFC")
+    imported = None
+    with Timer(step):
+        try:
+            imported = _import_document(api, result, document, seed_bench.new_suffix(),
+                                        on_message)
+            step.ok = True
+            step.detail = _job_outcome(EStatus.COMPLETE, imported["dispatch"])
+        except (ApiError, ImportFailed, ValueError, TimeoutError) as e:
+            step.detail = str(e)
+    _report_step(report, step)
+
+    if imported:
+        _check_tree(api, result, document, imported["root_entity_id"], expected_nodes, report)
+        _check_properties(api, result, imported["root_entity_id"], report)
+
+    return _finish(api, result, started, cleanup, report)
+
+
+def _check_tree(api: BruceApi, result: Result, document: seed_ifc.Document,
+                root_entity_id: str, expected_nodes: int, report) -> None:
+    """
+    The converted tree must carry a node for every element plus the spatial levels above them.
+    """
+    step = result.step("Check hierarchy")
+    step.expected = expected_nodes
+    with Timer(step):
+        try:
+            found = _node_count(api, root_entity_id)
+            step.actual = found
+            if found != expected_nodes:
+                step.detail = (f"expected {expected_nodes} Entities for "
+                               f"{document.element_count} elements, found {found}")
+            else:
+                step.ok = True
+                step.detail = f"{found} Entities, {document.element_count} elements"
+        except (ApiError, ValueError) as e:
+            step.detail = str(e)
+    _report_step(report, step)
+
+
+def _check_properties(api: BruceApi, result: Result, root_entity_id: str, report) -> None:
+    """
+    An IFC property set has to survive the conversion, or the import carries geometry and nothing else.
+    """
+    step = result.step("Check properties")
+    with Timer(step):
+        try:
+            leaves = _leaf_ids(api, root_entity_id)
+            found = _find_property(api, leaves)
+            if not found:
+                step.detail = (f"no '{seed_ifc.PSET_NAME}.{seed_ifc.PSET_LABEL}' on any of "
+                               f"{len(leaves)} leaf Entities")
+            else:
+                step.ok = True
+                step.detail = f"{seed_ifc.PSET_NAME} read back on a leaf"
+        except (ApiError, ValueError) as e:
+            step.detail = str(e)
+    _report_step(report, step)
+
+
+def run_ifc_variants(
+    api: BruceApi,
+    rows: int = 0,
+    on_progress=None,
+    on_message=None,
+    cleanup: bool = True
+) -> Result:
+    """
+    Imports one IFC per representation shape, so a converter regression names the shape that broke.
+    """
+    def report(message):
+        if on_progress:
+            on_progress(message)
+
+    result = Result()
+    started = time.monotonic()
+    documents = seed_ifc.variants()
+    suffix = seed_bench.new_suffix()
+
+    step = result.step("Generate variants")
+    with Timer(step):
+        total = sum(document.size_bytes for document in documents)
+        step.ok = True
+        step.detail = f"{len(documents)} documents, {total / 1024:.1f} KB total"
+    _report_step(report, step)
+
+    for document in documents:
+        _run_variant(api, result, document, suffix, on_message, report)
+
+    return _finish(api, result, started, cleanup, report)
+
+
+def _run_variant(api: BruceApi, result: Result, document: seed_ifc.Document, suffix: str,
+                 on_message, report) -> None:
+    """
+    One representation shape: import it, then check every element reached the tree.
+    """
+    expected_nodes = seed_ifc.SPATIAL_LEVELS + document.element_count
+    step = result.step(f"Import {document.key}")
+    step.expected = expected_nodes
+    with Timer(step):
+        try:
+            imported = _import_document(api, result, document, suffix, on_message)
+            found = _node_count(api, imported["root_entity_id"])
+            step.actual = found
+            if found != expected_nodes:
+                step.detail = f"expected {expected_nodes} Entities, found {found}"
+            else:
+                step.ok = True
+                step.detail = f"{found} Entities, {document.description}"
+        except (ApiError, ImportFailed, ValueError, TimeoutError) as e:
+            step.detail = f"{document.description}: {e}"
+    _report_step(report, step)