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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bruce-models
-Version: 0.3.2
+Version: 0.3.4
 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.2 → bruce_models-0.3.4}/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.2"
+__version__ = "0.3.4"
 
 __all__ = [
     "__version__",

{bruce_models-0.3.2 → bruce_models-0.3.4}/bruce_models/cli/cmd_run.py

@@ -18,6 +18,7 @@ from bruce_models.cli import config as cfg
 from bruce_models.cli import identity
 from bruce_models.cli import live
 from bruce_models.cli import report
+from bruce_models.cli import runner
 from bruce_models.cli import seed as seed_default
 from bruce_models.cli import suites
 from bruce_models.cli.config import ASK
@@ -894,6 +895,7 @@ def _run_one(suite, api, args, style):
         default_page = getattr(suite, "default_page_rows", None)
         if default_page:
             extra["page_rows"] = getattr(args, "page_rows", None) or default_page
+        runner.set_concurrency(getattr(args, "concurrency", None))
         return suite.run(api, rows=rows, on_progress=progress,
                          on_message=status.add_message, cleanup=cleanup, **extra)
     finally:

{bruce_models-0.3.2 → bruce_models-0.3.4}/bruce_models/cli/main.py

@@ -15,6 +15,7 @@ from bruce_models.api.errors import ApiError
 from bruce_models.cli import cmd_accounts, cmd_audit, cmd_auth, cmd_indexes, cmd_run, cmd_status
 from bruce_models.cli import exits
 from bruce_models.cli.config import ASK
+from bruce_models.cli import runner
 from bruce_models.cli import seed
 from bruce_models.cli import seed_bench
 from bruce_models.cli import seed_scale
@@ -61,6 +62,11 @@ def _add_run_options(parser):
                         help="Write the run as JSON, for trending it over time.")
     parser.add_argument("--fail-fast", dest="fail_fast", action="store_true",
                         help="Stop at the first failure instead of running the rest.")
+    parser.add_argument("--concurrency", type=int, metavar="N",
+                        help="How many independent operations a suite may run at once. "
+                             f"Default {runner.DEFAULT_CONCURRENCY}, 1 or 0 runs one at a time. "
+                             "Only steps whose work is genuinely independent fan out; a step that "
+                             "depends on the one before it always waits.")
     parser.add_argument("--timeout", type=int, metavar="SECONDS",
                         help="Give up after this long. Whatever the run created is left behind, "
                              "so prefer a generous value over a tight one.")

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

@@ -14,7 +14,8 @@ from bruce_models.entity.entity import Entity
 from bruce_models.entity.entity_type import EntityType
 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)
+from bruce_models.cli.runner import (ImportFailed, Result, Timer, _finish, _own_type,
+                                     _report_step, _save_entities)
 
 # A commit of this size is seconds of work, so anything approaching this is a stuck job rather than
 # a slow one.
@@ -78,14 +79,8 @@ def _create_entities(api: BruceApi, result: Result, type_id: str,
     with Timer(step):
         try:
             for mode in seed_change_set.MODES:
-                ids = []
-                for values in seed_change_set.rows(mode):
-                    saved = Entity.update(api, {"Bruce": {"EntityType.ID": type_id}, **values})
-                    entity_id = (saved.get("Bruce") or {}).get("ID")
-                    if not entity_id:
-                        raise ImportFailed(f"{values} was saved without an ID")
-                    ids.append(entity_id)
-                created[mode] = ids
+                created[mode] = _save_entities(api, seed_change_set.rows(mode),
+                                               entity_type_id=type_id)
             step.ok = True
             step.detail = f"{len(seed_change_set.MODES)} batches of {seed_change_set.ENTITY_COUNT}"
         except (ApiError, ImportFailed, ValueError) as e:

{bruce_models-0.3.2 → bruce_models-0.3.4}/bruce_models/cli/run_data_transform.py

@@ -13,7 +13,8 @@ from bruce_models.entity.entity import Entity
 from bruce_models.entity.entity_type import EntityType
 from bruce_models.cli import seed_data_transform
 from bruce_models.cli import seed_datalab
-from bruce_models.cli.runner import (ImportFailed, Result, Timer, _finish, _own_type, _report_step)
+from bruce_models.cli.runner import (ImportFailed, Result, Timer, _finish, _own_type,
+                                     _report_step, _save_entities)
 from bruce_models.cli.run_datalab import _await_action, _datalab_for
 
 # High enough that no Transform this suite or its Account creates can carry it.
@@ -73,8 +74,7 @@ def _create_entities(api: BruceApi, result: Result, type_id: str, report) -> boo
     step.expected = seed_data_transform.ENTITY_COUNT
     with Timer(step):
         try:
-            for values in seed_data_transform.rows():
-                Entity.update(api, {"Bruce": {"EntityType.ID": type_id}, **values})
+            _save_entities(api, seed_data_transform.rows(), entity_type_id=type_id)
             step.ok = True
             step.detail = f"{step.expected} Entities, no {seed_data_transform.TARGET_ATTRIBUTE} yet"
         except (ApiError, ValueError) as e:

{bruce_models-0.3.2 → bruce_models-0.3.4}/bruce_models/cli/run_datalab.py

@@ -3,19 +3,19 @@ DataLab selections: reading them back, writing to them, and moving Entity Types.
 """
 
 import time
-from typing import Dict, Optional, Tuple, cast
+from typing import Dict, Optional, Tuple
 from bruce_models.util.required import required
 from bruce_models.api.bruce_api import BruceApi
 from bruce_models.api.errors import ApiError
-from bruce_models.entity.entity import Entity
 from bruce_models.data_lab.data_lab_builder import DataLabBuilder
 from bruce_models.data_mapping.data_mapping_builder import DataMappingBuilder
 from bruce_models.entity.entity_type import EntityType
 from bruce_models.server.api_version import ApiVersion
 from bruce_models.server.pending_action import PendingAction, EStatus
 from bruce_models.cli import seed_datalab
-from bruce_models.cli.runner import (ImportFailed, Result, Timer, _finish, _message_relay,
-                                     _own_type, _report_step)
+from bruce_models.cli.runner import (ImportFailed, Result, Step, Timer, _finish,
+                                     _in_parallel, _message_relay, _own_type,
+                                     _report_step, _save_entities)
 
 
 # An action is queued and runs server side, so every one of them is waited on.
@@ -30,9 +30,6 @@ SORT_BY_ATTRIBUTE_MIN_VERSION = "1.0.6645"
 def _supported(api: BruceApi, minimum: str) -> Tuple[bool, str]:
     """
     Whether an installation is new enough for a feature, and the version it reported.
-
-    A version that cannot be read answers yes, matching Suite.supported_by: refusing to run because
-    the version was unavailable would turn a transient failure into a silently skipped check.
     """
     try:
         version = ApiVersion.of(ApiVersion.get(api))
@@ -46,9 +43,6 @@ def _supported(api: BruceApi, minimum: str) -> Tuple[bool, str]:
 def _datalab_start(api: BruceApi, result: Result, report) -> Optional[str]:
     """
     A parent Entity Type to hang the run off, and the source Type the suites select over.
-
-    The parent is what makes teardown one delete and makes the Types these actions create by name
-    safe: they land underneath it, so a name the server chooses for us (ITEM) is still this run's.
     """
     token = seed_datalab.new_token()
     result.seed = token
@@ -89,14 +83,8 @@ def _create_datalab_entities(api: BruceApi, result: Result, source_type_id: str,
     created = 0
     with Timer(step):
         try:
-            for values in seed_datalab.rows(label):
-                saved = Entity.update(api, cast("Entity.JEntity", {
-                    "Bruce": {"EntityType.ID": source_type_id},
-                    **values,
-                }))
-                if not (saved.get("Bruce") or {}).get("ID"):
-                    raise ImportFailed(f"{values['code']} was saved without an ID: {saved}")
-                created += 1
+            created = len(_save_entities(api, seed_datalab.rows(label),
+                                        entity_type_id=source_type_id))
             step.ok = created == seed_datalab.ENTITY_COUNT
             step.detail = f"{created} Entities across {len(seed_datalab.CATEGORIES)} values"
         except (ApiError, ImportFailed, ValueError) as e:
@@ -138,9 +126,6 @@ def _await_action(api: BruceApi, response, on_message=None) -> dict:
 def _types_under(api: BruceApi, parent_type_id: str) -> Dict[str, str]:
     """
     The Entity Types beneath one parent, by name, for finding the ones an action created.
-
-    Scoped to the parent because the names these actions choose are ordinary words, and an account
-    is free to have its own Type called PIPE somewhere else.
     """
     listing = (EntityType.get_list(api) or {}).get("Items") or []
     found = {}
@@ -355,20 +340,28 @@ def run_datalab_transfer_types(api: BruceApi, rows: int = 0, on_progress=None, o
         if not _create_datalab_entities(api, result, source_type_id, label, report):
             return _finish(api, result, started, cleanup, report, "test")
 
-    _check_transfer_to_type(api, result, source_type_id, report)
-    _check_transfer_by_attribute(api, result, source_type_id, report)
-    _check_map_by_attribute(api, result, source_type_id, report)
-    _check_transfer_with_mapping(api, result, source_type_id, report)
-    _check_transfer_without_parent(api, result, source_type_id, report)
+    checks = [
+        (result.step("Move to a fixed Type"), _check_transfer_to_type),
+        (result.step("Sort into Types by Attribute"), _check_transfer_by_attribute),
+        (result.step("Map by a value table"), _check_map_by_attribute),
+        (result.step("Move with a Data Mapping"), _check_transfer_with_mapping),
+        (result.step("Move to a parentless Type"), _check_transfer_without_parent),
+    ]
+    failures = _in_parallel(checks,
+                            lambda pair, _index: pair[1](api, result, source_type_id, pair[0]))
+    for (step, _), failure in zip(checks, failures):
+        if isinstance(failure, Exception) and not step.detail:
+            step.detail = str(failure)
+        _report_step(report, step)
 
     return _finish(api, result, started, cleanup, report, "test")
 
 
-def _check_transfer_to_type(api: BruceApi, result: Result, source_type_id: str, report) -> None:
+def _check_transfer_to_type(api: BruceApi, result: Result, source_type_id: str,
+                            step: Step) -> None:
     """
     Variant one: every matching Entity moves to one named Entity Type.
     """
-    step = result.step("Move to a fixed Type")
     step.expected = seed_datalab.ENTITY_COUNT
     prefix = seed_datalab.code_prefix("fixed")
     with Timer(step):
@@ -384,18 +377,16 @@ def _check_transfer_to_type(api: BruceApi, result: Result, source_type_id: str,
             step.detail = f"{moved} moved, {left} left behind"
         except (ApiError, ImportFailed, ValueError) as e:
             step.detail = str(e)
-    _report_step(report, step)
 
 
 def _check_transfer_by_attribute(api: BruceApi, result: Result, source_type_id: str,
-                                 report) -> None:
+                                 step: Step) -> None:
     """
     Variant two: Entity Types are created per Attribute value, named after it.
 
     The source Type has a parent, so the action looks a name up under it before creating one. That
     is a different path from a parentless source, which only ever creates.
     """
-    step = result.step("Sort into Types by Attribute")
     expected = seed_datalab.expected_sorted_types()
     step.expected = seed_datalab.ENTITY_COUNT
     prefix = seed_datalab.code_prefix("sort")
@@ -405,7 +396,6 @@ def _check_transfer_by_attribute(api: BruceApi, result: Result, source_type_id:
     if not supported:
         step.warned = True
         step.detail = f"needs {SORT_BY_ATTRIBUTE_MIN_VERSION}, has {version}"
-        _report_step(report, step)
         return
 
     with Timer(step):
@@ -434,14 +424,13 @@ def _check_transfer_by_attribute(api: BruceApi, result: Result, source_type_id:
                            else f"{landed} into {len(expected)} Types under a parent")
         except (ApiError, ImportFailed, ValueError) as e:
             step.detail = str(e)
-    _report_step(report, step)
 
 
-def _check_map_by_attribute(api: BruceApi, result: Result, source_type_id: str, report) -> None:
+def _check_map_by_attribute(api: BruceApi, result: Result, source_type_id: str,
+                            step: Step) -> None:
     """
     Variant three: an explicit table of Attribute value to Entity Type.
     """
-    step = result.step("Map by a value table")
     counts = seed_datalab.counts_by_category()
     step.expected = seed_datalab.ENTITY_COUNT - seed_datalab.expected_unmapped_count()
     prefix = seed_datalab.code_prefix("table")
@@ -482,15 +471,13 @@ def _check_map_by_attribute(api: BruceApi, result: Result, source_type_id: str,
                            else f"{step.expected} mapped, {left} left in place")
         except (ApiError, ImportFailed, ValueError) as e:
             step.detail = str(e)
-    _report_step(report, step)
 
 
 def _check_transfer_with_mapping(api: BruceApi, result: Result, source_type_id: str,
-                                 report) -> None:
+                                 step: Step) -> None:
     """
     The same action, told where values land rather than carrying them across as they are.
     """
-    step = result.step("Move with a Data Mapping")
     counts = seed_datalab.counts_by_category()
     step.expected = seed_datalab.ENTITY_COUNT
     prefix = seed_datalab.code_prefix("mapped")
@@ -530,19 +517,13 @@ def _check_transfer_with_mapping(api: BruceApi, result: Result, source_type_id:
                            else f"{moved} moved, {landed} values mapped")
         except (ApiError, ImportFailed, ValueError) as e:
             step.detail = str(e)
-    _report_step(report, step)
 
 
 def _check_transfer_without_parent(api: BruceApi, result: Result, source_type_id: str,
-                                   report) -> None:
+                                   step: Step) -> None:
     """
     That the action still works when the Type it moves to sits at the top level.
-
-    Every other check here runs under a parent, which is what keeps teardown to one delete. This one
-    holds the parentless case open, since nothing cascades to a top level Type and an account's own
-    Types live there too.
     """
-    step = result.step("Move to a parentless Type")
     step.expected = seed_datalab.ENTITY_COUNT
     prefix = seed_datalab.code_prefix("orphan")
     with Timer(step):
@@ -559,4 +540,3 @@ def _check_transfer_without_parent(api: BruceApi, result: Result, source_type_id
             step.detail = f"{moved} moved to a parentless Type"
         except (ApiError, ImportFailed, ValueError) as e:
             step.detail = str(e)
-    _report_step(report, step)

{bruce_models-0.3.2 → bruce_models-0.3.4}/bruce_models/cli/run_gis.py

@@ -15,7 +15,8 @@ from bruce_models.entity.entity import Entity
 from bruce_models.entity.entity_type import EntityType
 from bruce_models.cli import seed_datalab
 from bruce_models.cli import seed_gis
-from bruce_models.cli.runner import (ImportFailed, Result, Timer, _finish, _own_type, _report_step)
+from bruce_models.cli.runner import (ImportFailed, Result, Timer, _finish, _own_type,
+                                     _report_step, _save_entities)
 
 
 def run_gis(api: BruceApi, rows: int = 0, on_progress=None, on_message=None,
@@ -85,15 +86,10 @@ def _create_entities(api: BruceApi, result: Result, type_id: str, report) -> Dic
     created: Dict[str, str] = {}
     with Timer(step):
         try:
-            for kind in seed_gis.KINDS:
-                saved = Entity.update(api, cast("Entity.JEntity", {
-                    "Bruce": seed_gis.bruce_block(kind, type_id),
-                    "code": seed_gis.code(kind),
-                }))
-                entity_id = (saved.get("Bruce") or {}).get("ID")
-                if not entity_id:
-                    raise ImportFailed(f"{kind} was saved without an ID: {saved}")
-                created[kind] = entity_id
+            saved = _save_entities(api, [{"Bruce": seed_gis.bruce_block(kind, type_id),
+                                          "code": seed_gis.code(kind)}
+                                         for kind in seed_gis.KINDS])
+            created = dict(zip(seed_gis.KINDS, saved))
             step.ok = len(created) == step.expected
             step.detail = ", ".join(seed_gis.KINDS)
         except (ApiError, ImportFailed, ValueError) as e:

{bruce_models-0.3.2 → bruce_models-0.3.4}/bruce_models/cli/run_historic.py

@@ -3,7 +3,6 @@ Historic snapshots read back at points in time, then overlaid by a Scenario.
 """
 
 import time
-from typing import cast
 from bruce_models.util.required import required
 from bruce_models.api.bruce_api import BruceApi
 from bruce_models.api.errors import ApiError
@@ -13,7 +12,8 @@ from bruce_models.entity.entity_historic_data import EntityHistoricData
 from bruce_models.entity.entity_type import EntityType
 from bruce_models.scenario.scenario import Scenario
 from bruce_models.cli import seed_historic
-from bruce_models.cli.runner import ImportFailed, Result, Timer, _finish, _own_type, _report_step
+from bruce_models.cli.runner import (ImportFailed, Result, Timer, _finish, _own_type,
+                                     _report_step, _save_entities)
 
 
 def run_historic_scenario(api: BruceApi, rows: int = 0, on_progress=None, on_message=None,
@@ -76,16 +76,11 @@ def _create_historic_entities(api: BruceApi, result: Result, report) -> list:
     entity_ids = []
     with Timer(step):
         try:
-            for code in seed_historic.entity_codes():
-                saved = Entity.update(api, cast("Entity.JEntity", {
-                    "Bruce": {"EntityType.ID": required(result.entity_type_id, "Entity Type ID")},
-                    **seed_historic.live_values(code),
-                }))
-                entity_id = (saved.get("Bruce") or {}).get("ID")
-                if not entity_id:
-                    raise ImportFailed(f"{code} was saved without an ID: {saved}")
-                entity_ids.append(entity_id)
-                result.entity_ids.append(entity_id)
+            entity_ids = _save_entities(
+                api,
+                [seed_historic.live_values(code) for code in seed_historic.entity_codes()],
+                entity_type_id=required(result.entity_type_id, "Entity Type ID"))
+            result.entity_ids.extend(entity_ids)
             step.ok = True
             step.detail = f"{len(entity_ids)} Entities at their live values"
         except (ApiError, ImportFailed, ValueError) as e:
@@ -195,11 +190,27 @@ def _check_scenario(api: BruceApi, result: Result, entity_ids, stamp: int, repor
                 raise ImportFailed(f"Scenario was registered without an ID: {scenario}")
             result.scenario_ids.append(scenario_id)
 
-            EntityHistoricData.update(api, [EntityHistoricData.build_record(
+            written = EntityHistoricData.update(api, [EntityHistoricData.build_record(
                 entity_id, seed_historic.DRIVER_PATH, seed_historic.SCENARIO_DATETIME,
                 {"temperature": seed_historic.SCENARIO_TEMPERATURE,
                  "status": seed_historic.SCENARIO_STATUS},
                 scenario=scenario_id)])
+            # Per-record problems arrive as warnings inside a successful response, so an unchecked
+            # write reads back as live values later and looks like the Scenario was ignored.
+            write_warnings = warnings_in(written)
+            if write_warnings:
+                step.detail = f"writing the Scenario record: {write_warnings}"
+                _report_step(report, step)
+                return
+
+            # A Scenario read falls back to live values both when the Scenario is ignored and when
+            # it holds no record for the point, and those need telling apart to be actionable.
+            stored = EntityHistoricData.get_list(
+                api, entity_ids=[entity_id], attr_key=seed_historic.DRIVER_PATH,
+                scenario=scenario_id)
+            if not (stored.get("Items") or []):
+                raise ImportFailed("the Scenario record was accepted without warnings and did not "
+                                   "read back, so nothing was stored against the Scenario")
 
             point = seed_historic.SCENARIO_POINT
             in_scenario = Entity.get(api, entity_id, historic_point=point, scenario=scenario_id)
@@ -207,8 +218,9 @@ def _check_scenario(api: BruceApi, result: Result, entity_ids, stamp: int, repor
 
             problems = []
             if in_scenario.get("status") != seed_historic.SCENARIO_STATUS:
-                problems.append(f"in the Scenario read {in_scenario.get('status')}, "
-                                f"expected {seed_historic.SCENARIO_STATUS}")
+                problems.append(f"in the Scenario at {point} read {in_scenario.get('status')}, "
+                                f"expected {seed_historic.SCENARIO_STATUS} from the record at "
+                                f"{seed_historic.SCENARIO_DATETIME}")
             # The point of a Scenario is that it changes nothing outside itself.
             if base.get("status") != seed_historic.SCENARIO_BASE_STATUS:
                 problems.append(f"outside it read {base.get('status')}, "

{bruce_models-0.3.2 → bruce_models-0.3.4}/bruce_models/cli/run_import_brz.py

@@ -16,8 +16,8 @@ from bruce_models.tileset.tileset import Tileset
 from bruce_models.cli import humanize
 from bruce_models.cli import seed_brz
 from bruce_models.cli import seed_bench
-from bruce_models.cli.runner import (ImportFailed, Result, Step, Timer, _cleanup, _job_outcome,
-                                     _message_relay, _report_step)
+from bruce_models.cli.runner import (ImportFailed, Result, Step, Timer, _cleanup,
+                                     _in_parallel, _job_outcome, _message_relay, _report_step)
 
 
 # Root offsets are pure subtraction so they stay tight; leaf coordinates pass through the importer unchanged.
@@ -237,14 +237,17 @@ def run_align_brz(
     step = result.step("Import 3 assemblies")
     with Timer(step):
         try:
-            for index, seed in enumerate(assemblies):
-                name = f"align-{'abc'[index]}"
-                outcome = _import_assembly(api, result, seed.data, name, suffix,
-                                           on_message)
+            outcomes = _in_parallel(
+                assemblies,
+                lambda seed, index: _import_assembly(api, result, seed.data,
+                                                     f"align-{'abc'[index]}", suffix, on_message))
+            for index, outcome in enumerate(outcomes):
+                if isinstance(outcome, Exception):
+                    raise outcome
                 result.entity_ids.append(outcome["root_entity_id"])
                 result.client_file_ids.append(outcome["client_file_id"])
                 imported.append(outcome)
-                report(f"  {name} imported")
+                report(f"  align-{'abc'[index]} imported")
             step.ok = True
             step.detail = (f"{len(imported)} roots, "
                            + _job_outcome(EStatus.COMPLETE, imported[0]["dispatch"]))
@@ -320,6 +323,17 @@ def _check_alignment(result: Result, assemblies, offsets, report) -> None:
     _report_step(report, step)
 
 
+def _build_tileset(api: BruceApi, result: Result, outcome, index: int):
+    """
+    Builds one assembly's tileset and reads back where its root box sits.
+    """
+    tileset_id, load_url = Tileset.build(api, f"align-{'abc'[index]}",
+                                         outcome["root_entity_id"],
+                                         on_message=_message_relay(None))
+    result.tileset_ids.append(tileset_id)
+    return Tileset.root_box_centre(Tileset.fetch_document(api, load_url))
+
+
 def _check_tilesets(api: BruceApi, result: Result, assemblies, imported, offsets, report) -> None:
     """
     Each generated tileset must be written in the shared frame rather than re-centred on its own pivot.
@@ -329,13 +343,13 @@ def _check_tilesets(api: BruceApi, result: Result, assemblies, imported, offsets
         try:
             discriminating = []
             problems = []
-            for index, (seed, outcome, offset) in enumerate(zip(assemblies, imported, offsets)):
+            built = _in_parallel(imported,
+                                 lambda outcome, index: _build_tileset(api, result, outcome, index))
+            for index, (seed, offset) in enumerate(zip(assemblies, offsets)):
                 label = "abc"[index]
-                tileset_id, load_url = Tileset.build(api, f"align-{label}",
-                                                    outcome["root_entity_id"],
-                                                    on_message=_message_relay(None))
-                result.tileset_ids.append(tileset_id)
-                centre = Tileset.root_box_centre(Tileset.fetch_document(api, load_url))
+                if isinstance(built[index], Exception):
+                    raise built[index]
+                centre = built[index]
 
                 shifted = _axis_range(seed.leaves, offset, TILESET_BOX_MARGIN)
                 local = _axis_range(seed.leaves, (0.0, 0.0, 0.0), TILESET_BOX_MARGIN)

{bruce_models-0.3.2 → bruce_models-0.3.4}/bruce_models/cli/run_import_ifc.py

@@ -14,8 +14,8 @@ 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)
+from bruce_models.cli.runner import (ImportFailed, Result, Timer, _finish, _in_parallel,
+                                     _job_outcome, _message_relay, _report_step)
 
 
 # How deep the walk over an imported tree is allowed to go before it gives up.
@@ -226,30 +226,46 @@ def run_ifc_variants(
         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)
+    # Each shape is its own upload, conversion, import and Entity Type, so no two of them can see each other.
+    outcomes = _in_parallel(documents,
+                            lambda document, _index: _import_variant(api, result, document,
+                                                                     suffix, on_message))
+    for document, outcome in zip(documents, outcomes):
+        _report_variant(result, document, outcome, 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:
+def _import_variant(api: BruceApi, result: Result, document: seed_ifc.Document, suffix: str,
+                    on_message) -> tuple:
     """
-    One representation shape: import it, then check every element reached the tree.
+    One representation shape, imported and counted, timed on its own wall clock.
+    """
+    started = time.monotonic()
+    imported = _import_document(api, result, document, suffix, on_message)
+    found = _node_count(api, imported["root_entity_id"])
+    return found, time.monotonic() - started
+
+
+def _report_variant(result: Result, document: seed_ifc.Document, outcome, report) -> None:
+    """
+    Turns one shape's outcome into its step, in the order the documents were listed.
+
+    Reported after the work rather than during it, so the rows read the same whatever order they
+    finished in and one run can be diffed against another.
     """
     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}"
+    if isinstance(outcome, Exception):
+        step.detail = f"{document.description}: {outcome}"
+    else:
+        found, seconds = outcome
+        step.seconds = seconds
+        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}"
     _report_step(report, step)

{bruce_models-0.3.2 → bruce_models-0.3.4}/bruce_models/cli/run_merge.py

@@ -13,7 +13,8 @@ from bruce_models.entity.entity import Entity
 from bruce_models.entity.entity_type import EntityType
 from bruce_models.cli import seed_datalab
 from bruce_models.cli import seed_merge
-from bruce_models.cli.runner import (ImportFailed, Result, Timer, _finish, _own_type, _report_step)
+from bruce_models.cli.runner import (ImportFailed, Result, Timer, _finish, _own_type,
+                                     _report_step, _save_entities)
 from bruce_models.cli.run_datalab import _await_action, _datalab_for
 
 
@@ -80,8 +81,8 @@ def _create_entities(api: BruceApi, result: Result, type_id: str, report) -> boo
     step.expected = seed_merge.GROUP_COUNT * 2
     with Timer(step):
         try:
-            for values in seed_merge.primaries() + seed_merge.secondaries():
-                Entity.update(api, {"Bruce": {"EntityType.ID": type_id}, **values})
+            _save_entities(api, seed_merge.primaries() + seed_merge.secondaries(),
+                           entity_type_id=type_id)
             step.ok = True
             step.detail = f"{seed_merge.GROUP_COUNT} primaries, {seed_merge.GROUP_COUNT} secondaries"
         except (ApiError, ValueError) as e:

{bruce_models-0.3.2 → bruce_models-0.3.4}/bruce_models/cli/run_relation.py

@@ -8,14 +8,14 @@ from typing import Dict, Optional
 from bruce_models.util.required import required
 from bruce_models.api.bruce_api import BruceApi
 from bruce_models.api.errors import ApiError
-from bruce_models.entity.entity import Entity
 from bruce_models.entity.entity_link import EntityLink
 from bruce_models.entity.entity_type import EntityType
 from bruce_models.relation.entity_relation import EntityRelation
 from bruce_models.relation.entity_relation_type import EntityRelationType
 from bruce_models.cli import seed_datalab
 from bruce_models.cli import seed_relation
-from bruce_models.cli.runner import (ImportFailed, Result, Timer, _finish, _own_type, _report_step)
+from bruce_models.cli.runner import (ImportFailed, Result, Timer, _finish, _own_type,
+                                     _report_step, _save_entities)
 
 
 def run_relation(api: BruceApi, rows: int = 0, on_progress=None, on_message=None,
@@ -103,15 +103,10 @@ def _create_entities(api: BruceApi, result: Result, type_id: str, report) -> Dic
     created: Dict[str, object] = {}
     with Timer(step):
         try:
-            def save(values):
-                saved = Entity.update(api, {"Bruce": {"EntityType.ID": type_id}, **values})
-                entity_id = (saved.get("Bruce") or {}).get("ID")
-                if not entity_id:
-                    raise ImportFailed(f"{values} was saved without an ID")
-                return entity_id
-
-            created["principal"] = save(seed_relation.principal())
-            created["related"] = [save(values) for values in seed_relation.related()]
+            saved = _save_entities(api, [seed_relation.principal()] + list(seed_relation.related()),
+                                   entity_type_id=type_id)
+            created["principal"] = saved[0]
+            created["related"] = saved[1:]
             step.ok = True
             step.detail = f"one principal, {seed_relation.RELATED_COUNT} related"
         except (ApiError, ImportFailed, ValueError) as e: