Use argparse subcommands

Author: aothms

README.md

@@ -126,13 +126,37 @@ initialize a geometry backend or require a spreadsheet dependency.
 Inspect a document:
 
 ```console
-python -m ifcopenshell.mvd mvd_examples/wall_extraction.mvdxml
+python -m ifcopenshell.mvd inspect mvd_examples/wall_extraction.mvdxml
+```
+
+Validate an IFC file against an mvdXML document:
+
+```console
+python -m ifcopenshell.mvd validate model.mvdxml model.ifc
 ```
 
 Generate and execute SPARQL against an IFC-OWL Turtle file:
 
 ```console
-python -m ifcopenshell.mvd model.mvdxml model.ttl
+python -m ifcopenshell.mvd convert model.mvdxml model.ttl
 ```
 
+Extract a ConceptTemplate, ConceptRoot, or Concept within a ConceptRoot:
+
+```console
+python -m ifcopenshell.mvd extract source.mvdxml "Project Context" project-context.mvdxml
+python -m ifcopenshell.mvd extract source.mvdxml IfcZone zone.mvdxml
+python -m ifcopenshell.mvd extract source.mvdxml "IfcZone/Property Sets for Objects" zone-psets.mvdxml
+```
+
+Combine two or more documents (the final argument is the output path):
+
+```console
+python -m ifcopenshell.mvd combine first.mvdxml second.mvdxml combined.mvdxml
+```
+
+Both commands operate on the immutable objects returned by `parse()`, then pass
+the selected or concatenated objects to `serialize()`. Output contains one
+flattened definition per ConceptTemplate UUID.
+
 Use `python -m ifcopenshell.mvd --help` for argument details.

__init__.py

@@ -1,4 +1,13 @@
-from .model import concept_or_applicability, concept_root, rule, template
+from .model import concept_or_applicability, concept_root, filter, rule, template
 from .parser import parse
+from .serializer import serialize
 
-__all__ = ["concept_or_applicability", "concept_root", "parse", "rule", "template"]
+__all__ = [
+    "concept_or_applicability",
+    "concept_root",
+    "filter",
+    "parse",
+    "rule",
+    "serialize",
+    "template",
+]

__main__.py

@@ -3,21 +3,60 @@
 import argparse
 from collections.abc import Sequence
 
+from . import filter as filter_mvd
+from . import serialize
 from .model import concept_root, template
 from .parser import parse
 
 
 def build_parser() -> argparse.ArgumentParser:
     parser = argparse.ArgumentParser(
         prog="python -m ifcopenshell.mvd",
-        description="Inspect mvdXML or execute its generated SPARQL against an IFC-OWL file.",
+        description="Inspect, validate, extract, combine, or convert mvdXML documents.",
     )
-    parser.add_argument("mvdxml", help="Path to an mvdXML document")
-    parser.add_argument(
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    inspect_parser = subparsers.add_parser("inspect", help="Inspect an mvdXML document")
+    inspect_parser.add_argument("mvdxml", help="Path to an mvdXML document")
+
+    validate_parser = subparsers.add_parser(
+        "validate",
+        help="Validate an IFC file against an mvdXML document",
+    )
+    validate_parser.add_argument("mvdxml", help="Path to an mvdXML document")
+    validate_parser.add_argument("ifc", help="Path to an IFC file")
+
+    convert_parser = subparsers.add_parser(
+        "convert",
+        help="Generate and execute SPARQL against an IFC-OWL Turtle file",
+    )
+    convert_parser.add_argument("mvdxml", help="Path to an mvdXML document")
+    convert_parser.add_argument(
         "ifcowl",
-        nargs="?",
-        help="Optional path to an IFC-OWL Turtle file; omit it to inspect the mvdXML",
+        help="Path to an IFC-OWL Turtle file",
     )
+
+    extract_parser = subparsers.add_parser(
+        "extract",
+        help="Extract a ConceptTemplate, ConceptRoot, or Concept into a new mvdXML document",
+    )
+    extract_parser.add_argument("mvdxml", help="Path to the source mvdXML document")
+    extract_parser.add_argument(
+        "selection",
+        help="ConceptTemplate, ConceptRoot, or ConceptRoot/Concept name",
+    )
+    extract_parser.add_argument("output", help="Path to the output mvdXML document")
+
+    combine_parser = subparsers.add_parser(
+        "combine",
+        help="Combine mvdXML documents",
+    )
+    combine_parser.add_argument(
+        "mvdxml",
+        nargs="+",
+        help="Paths to the source mvdXML documents",
+    )
+    combine_parser.add_argument("output", help="Path to the output mvdXML document")
     return parser
 
 
@@ -52,16 +91,78 @@ def execute_sparql(parsed_root: concept_root, mvdxml: str, ifcowl: str) -> None:
     print(sparql.executor.run(parsed_root, mvdxml, inferred_ifcowl), end="")
 
 
+def _parse_roots(mvdxml: str) -> list[concept_root]:
+    roots = [item for item in parse(mvdxml) if isinstance(item, concept_root)]
+    if not roots:
+        raise ValueError(f"mvdXML document {mvdxml!r} contains no ConceptRoot")
+    return roots
+
+
+def validate_mvd(mvdxml: str, ifc: str) -> bool:
+    import ifcopenshell
+
+    ifc_file = ifcopenshell.open(ifc)
+    all_valid = True
+
+    for root in _parse_roots(mvdxml):
+        entities = list(ifc_file.by_type(root.entity))
+        applicability = root.parsed_applicability
+        if applicability is not None:
+            entities = [
+                entity
+                for entity in entities
+                if applicability.validate(applicability.template().extract(entity))[0]
+            ]
+
+        verification = {entity.GlobalId: {} for entity in entities}
+        for entity in entities:
+            for concept in root.concepts():
+                valid, _ = concept.validate(concept.template().extract(entity))
+                verification[entity.GlobalId][concept.name] = int(not valid)
+
+        non_respecting = root.get_non_respecting_entities(ifc_file, verification)
+        all_valid = all_valid and not non_respecting
+        print(
+            f"{root.name}: {len(non_respecting)} of "
+            f"{len(entities)} applicable entities failed"
+        )
+        for entity in non_respecting:
+            failed_concepts = [
+                name for name, failed in verification[entity.GlobalId].items() if failed
+            ]
+            print(f"  {entity.GlobalId}: {', '.join(failed_concepts)}")
+
+    return all_valid
+
+
 def main(argv: Sequence[str] | None = None) -> int:
     args = build_parser().parse_args(argv)
-    if args.ifcowl is None:
+    if args.command == "inspect":
         inspect_mvd(args.mvdxml)
         return 0
+    if args.command == "validate":
+        return int(not validate_mvd(args.mvdxml, args.ifc))
+    if args.command == "extract":
+        serialize(
+            filter_mvd(
+                parse(args.mvdxml, include_templates=True),
+                args.selection,
+            ),
+            args.output,
+        )
+        return 0
+    if args.command == "combine":
+        serialize(
+            (
+                item
+                for filename in args.mvdxml
+                for item in parse(filename, include_templates=True)
+            ),
+            args.output,
+        )
+        return 0
 
-    roots = [item for item in parse(args.mvdxml) if isinstance(item, concept_root)]
-    if not roots:
-        raise ValueError(f"mvdXML document {args.mvdxml!r} contains no ConceptRoot")
-    for root in roots:
+    for root in _parse_roots(args.mvdxml):
         execute_sparql(root, args.mvdxml, args.ifcowl)
     return 0
 

model.py

@@ -6,7 +6,7 @@
 import io
 import itertools
 import operator
-from dataclasses import dataclass
+from dataclasses import dataclass, replace
 from functools import partial, reduce
 from typing import Any, Callable, Iterable, Iterator, Mapping
 
@@ -132,15 +132,22 @@ def extract(self, ifc_data: ifcopenshell.entity_instance | Any) -> extracted_dat
             try:
                 values_from_attribute = getattr(ifc_data, self.attribute)
             except (AttributeError, TypeError):
-                return [{self: "Invalid attribute rule"}]
+                return []
 
-            if values_from_attribute is None:
-                return [{self: "Nonexistent value"}]
+            if values_from_attribute is None or (
+                isinstance(values_from_attribute, (list, tuple))
+                and len(values_from_attribute) == 0
+            ):
+                return []
 
             if isinstance(values_from_attribute, (list, tuple)):
-                if not values_from_attribute:
-                    return [{self: "empty data structure"}]
-                values = values_from_attribute
+                if any(isinstance(v, (list, tuple)) for v in values_from_attribute):
+                    # currently untested: nested lists (bspline surface points)
+                    values = type(values_from_attribute)(
+                        itertools.chain.from_iterable(values_from_attribute)
+                    )
+                else:
+                    values = values_from_attribute
             else:
                 values = (values_from_attribute,)
 
@@ -186,6 +193,7 @@ class template:
     name: str | None
     rules: tuple[rule, ...] = ()
     constraints: tuple[Any, ...] = ()
+    uuid: str | None = None
 
     def __post_init__(self) -> None:
         object.__setattr__(self, "rules", tuple(self.rules))
@@ -230,7 +238,7 @@ def visit(
 
     def root_rule(self) -> rule:
         if not self.rules:
-            raise ValueError(f"Template {self.name or self.entity!r} contains no rules")
+            return rule("EntityRule", self.entity)
         if len(self.rules) == 1:
             return self.rules[0]
         return rule("EntityRule", self.entity, self.rules)
@@ -405,3 +413,54 @@ def get_respecting_entities(
             for global_id, values in verification.items()
             if sum(values.values()) == 0
         ]
+
+
+mvd_item = concept_root | template
+
+
+def _without_empty_applicability(root: concept_root) -> concept_root:
+    applicability = root.parsed_applicability
+    if applicability is not None and not applicability.template().rules:
+        return replace(root, parsed_applicability=None)
+    return root
+
+
+def filter(items: Iterable[mvd_item], selector: str) -> tuple[mvd_item, ...]:
+    """Select a template, root, or ``root/concept`` from parsed mvdXML items."""
+
+    parsed = tuple(items)
+    if "/" in selector:
+        root_name, concept_name = selector.split("/", 1)
+        roots = [
+            item
+            for item in parsed
+            if isinstance(item, concept_root) and item.name == root_name
+        ]
+        matches = [
+            (root, concept)
+            for root in roots
+            for concept in root.concepts()
+            if concept.name == concept_name
+        ]
+        if len(matches) != 1:
+            raise ValueError(
+                f"Expected one Concept named {selector!r}, found {len(matches)}"
+            )
+        root, concept = matches[0]
+        return (
+            replace(_without_empty_applicability(root), parsed_concepts=(concept,)),
+        )
+
+    templates: dict[str | int, template] = {}
+    for item in parsed:
+        if isinstance(item, template) and item.name == selector:
+            templates.setdefault(item.uuid.casefold() if item.uuid else id(item), item)
+    roots = [
+        _without_empty_applicability(item)
+        for item in parsed
+        if isinstance(item, concept_root) and item.name == selector
+    ]
+    matches: list[mvd_item] = [*templates.values(), *roots]
+    if len(matches) != 1:
+        raise ValueError(f"Expected one item named {selector!r}, found {len(matches)}")
+    return (matches[0],)