mvd.validate_data() function to apply template rules to extracted data

aothms · aothms · commit 81b2b552d302 · 2022-04-13T22:04:27.000+02:00
diff --git a/__init__.py b/__init__.py
@@ -13,7 +13,7 @@ def __init__(self, tag, attribute, nodes, bind=None, optional=False):
 
     def to_string(self, indent=0):
         # return "%s%s%s[%s](%s%s)%s" % ("\n" if indent else "", " "*indent, self.tag, self.attribute, "".join(n.to_string(indent+2) for n in self.nodes), ("\n" + " "*indent) if len(self.nodes) else "", (" -> %s" % self.bind) if self.bind else "")
-        return "<Rule %s %s>" % (self.tag, self.attribute)
+        return "<%s %s%s>" % (self.tag, f"{self.bind}=" if self.bind else "", self.attribute)
 
     def __repr__(self):
         return self.to_string()
@@ -23,8 +23,8 @@ class template(object):
     Representation of an mvdXML template
     """
 
-    def __init__(self, concept, root, constraints=None, rules=None):
-        self.concept, self.root, self.constraints = concept, root, (constraints or [])
+    def __init__(self, concept, root, constraints=None, rules=None, parent=None):
+        self.concept, self.root, self.constraints, self.parent = concept, root, (constraints or []), parent
         self.rules = rules or []
         self.entity = str(root.attributes['applicableEntity'].value)
         try:
@@ -58,7 +58,7 @@ def visit(n, p=root, ps=[root]):
             visit(r)
 
     def parse_rule(self, root, visited=None):
-        def visit(node, prefix="", visited=None):
+        def visit(node, prefix="", visited=None, parent=None):
             r = None
             n = node
             nm = None
@@ -112,7 +112,10 @@ def _(n):
                     for x in visit(subnode, p, visited=visited): yield x
 
             if r:
-                yield rule(node.localName, r, list(_(n)), (p + nm) if nm else nm, optional=optional)
+                R = rule(node.localName, r, list(_(n)), (p + nm) if nm else nm, optional=optional)
+                for rr in R.nodes:
+                    rr.parent = R
+                yield R
             else:
                 for subnode in n.childNodes:
                     if not isinstance(subnode, Element): continue
diff --git a/mvd.py b/mvd.py
@@ -418,5 +418,72 @@ def visualize(file, not_respecting_entities):
     ifcopenshell.geom.utils.main_loop()
 
 
+def validate_data(concept, data):
+    import io
+    import ast
+    import operator
+    from functools import reduce, partial
+
+    rules = [x[0] for x in concept.rules() if not isinstance(x, str)]
+    
+    def transform_data(d):
+        """
+        Transform dictionary keys from tree nodes to rule ids
+        """
+        
+        return {(k.parent if k.bind is None and k.parent.bind is not None else k).bind: v for k, v in d.items()}
+
+    
+    def parse_mvdxml_token(v):
+        # @todo make more permissive and tolerant
+        return ast.literal_eval(v)
+
+
+    data = list(map(transform_data, data))
+    
+    output = io.StringIO()
+        
+    # https://stackoverflow.com/a/70227259
+    def operation_reduce(x, y):
+        """
+        Takes alternating value and function as input and
+        reduces while applying function
+        """
+        
+        if callable(x):
+            return x(y)
+        else:
+            return partial(y, x)
+            
+            
+    def apply_rules():
+    
+        for r in rules:
+        
+            def apply_data():
+            
+                for d in data:
+                                
+                    def translate(v):
+                        if isinstance(v, str):
+                            return getattr(operator, v.lower() + "_")
+                        else:
+                            if v.b == "Value":
+                                return d[v.a] == parse_mvdxml_token(v.c)
+                            elif v.b == "Type":
+                                return d[v.a].is_a(parse_mvdxml_token(v.c))
+                            
+                    r2 = list(map(translate, r))
+                    yield reduce(operation_reduce, r2)
+                
+            v = any(list(apply_data()))
+            print(("Met:" if v else "Not met:"), r, file=output)
+            yield v
+
+
+    valid = all(list(apply_rules()))
+    return valid, output.getvalue()
+
+
 if __name__ == '__main__':
     print('functions to parse MVD rules and extract IFC data/filter IFC entities from them')
