Feature: express rules (#2662)

* temp reasonable state, missing rule_head contents

* better state, with init() and rule_id, but some missing parameters

* performance; embed root in dict; fix lookup

* Add ast_utils

* Fixes related to listnode and typo

* First steps with code gen

* Finalize first steps towards working code generation

* Backwards compat

* Rule execution, error formatting, test cases

* Where rule: support indexing, more expressions, test plane angle measure

* positive length measure test cases

* Venture into entity rules, test actor role

* Fixed for not unary op and address test cases

* Test group qualifier and air terminal type

* typeof() implementation and test annotation curve occ

* Flexible handling of expression, type set intersection, IfcAnnotationSurface test cases

* Functions, derived attrs, fix branch order, allow to terminate branches, apply -1 to index

* Implement express query(), test cases for 2x3 bspline curve

* Function args, if-else, repeat, entity instance construction, cshape test cases

* Multiple function call arguments and other small but influential changes. IfcDotProject() almost working except for variable case

* Make lowercase and fix assignment to qualified lhs

* Entity instance schema without file, aggregate assignment workaround, range fix, lowercase instance locals, extruded area direction test cases

* Enumeration item handling, query() robustness, arbitrary profile test cases

* Empty aggregate_initializer, xor and instance equality, nested expression fix in IfcCrossProduct, axis2-3d test cases

* Numeric stable sort with indices greater then 10, get ast node parent, redeclared derived support, nested expression robustness, define entity functions, case statements, xor, mod, bool literals, nvl, unknown, conversion based unit test cases

* Safeguard for schema name case norm, case norm query variable_id

* free instance comparison, supertype serialization fix, include inherited attributes in locals, proper elif-else in case stmt, loindex, shape rep test cases

* Union operator on set, retain general_aggr_types in parse tree, test cases for property set

* Escape stmt, rule locals and statements

* Return calculated values for redeclared derived attributes

* fix for rules without stmt, add derived and inverse attributes to locals, filter unused locals, wrap exists() arg with lambda to catch indexerror, support repeated aggr init element, typeof() none check, enum namespace uppercase

* Regen 2x3 rules

* Rule test filter only on basename

* Update fixtures for compliance with full body of rules

* Add rule support to ifcopenshell.validate

* Implement usedin() function, test cases for IfcWallSC MLS

* blength

* Run code generation on all schemas

* Try to eliminate runtime pyparsing dep

* Try to eliminate runtime pyparsing dep

src/ifcopenshell-python/ifcopenshell/entity_instance.py

@@ -22,6 +22,7 @@ from __future__ import division
 from __future__ import print_function
 
 import functools
+import importlib
 import numbers
 import itertools
 
@@ -33,7 +34,7 @@ except ImportError as e:
     logging = type("logger", (object,), {"exception": staticmethod(lambda s: print(s))})
 
 
-def set_derived_atribute(*args):
+def set_derived_attribute(*args):
     raise TypeError("Unable to set derived attribute")
 
 
@@ -73,7 +74,7 @@ def register_schema_attributes(schema):
 
             # resolve to actual functions in wrapper
             functions = [
-                set_derived_atribute
+                set_derived_attribute
                 if mname == "setArgumentAsDerived"
                 else getattr(ifcopenshell_wrapper.entity_instance, mname)
                 for mname in fn_names
@@ -123,17 +124,30 @@ class entity_instance(object):
         INVALID, FORWARD, INVERSE = range(3)
         attr_cat = self.wrapped_data.get_attribute_category(name)
         if attr_cat == FORWARD:
-            return entity_instance.wrap_value(
-                self.wrapped_data.get_argument(
-                    self.wrapped_data.get_argument_index(name)
-                ),
-                self.wrapped_data.file,
-            )
+            idx = self.wrapped_data.get_argument_index(name)
+            if _method_dict[self.is_a(True)][idx] != set_derived_attribute:
+                # A bit ugly, but we fall through to derived attribute handling below
+                return entity_instance.wrap_value(
+                    self.wrapped_data.get_argument(idx), self.wrapped_data.file
+                )
         elif attr_cat == INVERSE:
-            return entity_instance.wrap_value(
-                self.wrapped_data.get_inverse(name), self.wrapped_data.file
-            )
-        else:
+            return entity_instance.wrap_value(self.wrapped_data.get_inverse(name), self.wrapped_data.file)
+        
+        # derived attribute perhaps?
+        schema_name = self.wrapped_data.is_a(True).split('.')[0]
+        rules = importlib.import_module(f"ifcopenshell.express.rules.{schema_name}")
+        def yield_supertypes():
+            decl = ifcopenshell_wrapper.schema_by_name(schema_name).declaration_by_name(self.is_a())
+            while decl:
+                yield decl.name()
+                decl = decl.supertype()
+
+        for sty in yield_supertypes():
+            fn = getattr(rules, f"calc_{sty}_{name}", None)
+            if fn:
+                return fn(self)
+
+        if attr_cat != FORWARD:
             raise AttributeError(
                 "entity instance of type '%s' has no attribute '%s'"
                 % (self.wrapped_data.is_a(True), name)
@@ -218,7 +232,7 @@ class entity_instance(object):
         method = self.method_list[idx]
 
         if value is None:
-            if method is not set_derived_atribute:
+            if method is not set_derived_attribute:
                 self.wrapped_data.setArgumentAsNull(idx)
         else:
             self.method_list[idx](
@@ -275,17 +289,22 @@ class entity_instance(object):
     def __eq__(self, other):
         if not isinstance(self, type(other)):
             return False
-        # Proper entity instances have a stable identity by means of the numeric
-        # step id. Selected type instances (such as IfcPropertySingleValue.NominalValue
-        # always have id=0, so we compare <type, value, file pointer>
-        if self.id():
-            return self.wrapped_data == other.wrapped_data
+        elif None in (self.wrapped_data.file, other.wrapped_data.file):
+            # when not added to a file, we can only compare attribute values
+            # and we need this for where rule evaluation
+            return self.get_info(recursive=True, include_identifier=False) == other.get_info(recursive=True, include_identifier=False)
         else:
-            return (self.is_a(), self[0], self.wrapped_data.file_pointer()) == (
-                other.is_a(),
-                other[0],
-                other.wrapped_data.file_pointer(),
-            )
+            # Proper entity instances have a stable identity by means of the numeric
+            # step id. Selected type instances (such as IfcPropertySingleValue.NominalValue
+            # always have id=0, so we compare <type, value, file pointer>
+            if self.id():
+                return self.wrapped_data == other.wrapped_data
+            else:
+                return (self.is_a(), self[0], self.wrapped_data.file_pointer()) == (
+                    other.is_a(),
+                    other[0],
+                    other.wrapped_data.file_pointer(),
+                )
 
     def __hash__(self):
         # Proper entity instances have a stable identity by means of the numeric