Merge remote-tracking branch 'pr-8598/fix-4047-bounded-property-support' into Frankenstein_build-0.9.0-alpha2610050136

Author: bonsaiPR automation

src/bonsai/bonsai/bim/module/pset/__init__.py

@@ -39,6 +39,7 @@
     operator.BIM_OT_add_edit_custom_property,
     operator.BIM_OT_bulk_remove_psets,
     prop.IfcPropertyEnumeratedValue,
+    prop.IfcPropertyBoundedValue,
     prop.IfcProperty,
     prop.PsetProperties,
     prop.RenamePropertyEntry,

src/bonsai/bonsai/bim/module/pset/operator.py

@@ -164,6 +164,9 @@ def _execute(self, context):
                 elif prop.value_type == "IfcPropertyEnumeratedValue":
                     value_name = metadata.get_value_name()
                     value = [e[value_name] for e in prop.enumerated_value.enumerated_values if e.is_selected]
+                elif prop.value_type == "IfcPropertyBoundedValue":
+                    properties[metadata.name] = tool.Pset.get_bounded_value_dict(prop) or None
+                    continue
                 else:
                     continue
                 # None (a purge/skip-creation signal, handled by edit_pset/edit_qto before any
@@ -320,6 +323,8 @@ def _execute(self, context):
         elif prop.value_type == "IfcPropertyEnumeratedValue":
             value_name = prop.metadata.get_value_name()
             prop_value = [e[value_name] for e in prop.enumerated_value.enumerated_values if e.is_selected]
+        elif prop.value_type == "IfcPropertyBoundedValue":
+            prop_value = tool.Pset.get_bounded_value_dict(prop) or None
         else:
             self.report({"ERROR"}, f"Unsupport value type: '{prop.value_type}'.")
             return {"CANCELLED"}

src/bonsai/bonsai/bim/module/pset/prop.py

@@ -268,18 +268,39 @@ class IfcPropertyEnumeratedValue(PropertyGroup):
         enumerated_values: bpy.types.bpy_prop_collection_idprop[Attribute]
 
 
-IfcPropertyValueType = Literal["IfcPropertySingleValue", "IfcPropertyEnumeratedValue"]
+class IfcPropertyBoundedValue(PropertyGroup):
+    lower_bound_value: PointerProperty(type=Attribute)
+    upper_bound_value: PointerProperty(type=Attribute)
+    set_point_value: PointerProperty(type=Attribute)
+
+    if TYPE_CHECKING:
+        lower_bound_value: Attribute
+        upper_bound_value: Attribute
+        set_point_value: Attribute
+
+
+#: Maps IfcPropertyBoundedValue Blender attribute names to the IFC attribute they represent.
+BOUNDED_VALUE_ATTRS: tuple[tuple[str, str], ...] = (
+    ("lower_bound_value", "LowerBoundValue"),
+    ("upper_bound_value", "UpperBoundValue"),
+    ("set_point_value", "SetPointValue"),
+)
+
+
+IfcPropertyValueType = Literal["IfcPropertySingleValue", "IfcPropertyEnumeratedValue", "IfcPropertyBoundedValue"]
 
 
 class IfcProperty(PropertyGroup):
     metadata: PointerProperty(type=Attribute)
     value_type: EnumProperty(items=[(v, v, v) for v in get_args(IfcPropertyValueType)], name="Value Type")
     enumerated_value: PointerProperty(type=IfcPropertyEnumeratedValue)
+    bounded_value: PointerProperty(type=IfcPropertyBoundedValue)
 
     if TYPE_CHECKING:
         metadata: Attribute
         value_type: IfcPropertyValueType
         enumerated_value: IfcPropertyEnumeratedValue
+        bounded_value: IfcPropertyBoundedValue
 
 
 class PsetProperties(PropertyGroup):

src/bonsai/bonsai/bim/module/pset/ui.py

@@ -50,6 +50,8 @@ def draw_property(prop: IfcProperty, layout: bpy.types.UILayout, copy_operator:
         draw_single_property(prop, layout, copy_operator)
     elif prop.value_type == "IfcPropertyEnumeratedValue":
         draw_enumerated_property(prop, layout, copy_operator)
+    elif prop.value_type == "IfcPropertyBoundedValue":
+        draw_bounded_property(prop, layout, copy_operator)
     else:
         assert_never(prop.value_type)
 
@@ -95,6 +97,24 @@ def draw_enumerated_property(
         op.name = prop.metadata.name
 
 
+def draw_bounded_property(prop: IfcProperty, layout: bpy.types.UILayout, copy_operator: Optional[str] = None) -> None:
+    layout.label(text=prop.metadata.name)
+    grid = layout.column_flow(columns=3)
+    for attr, label in (
+        (prop.bounded_value.lower_bound_value, "Lower"),
+        (prop.bounded_value.upper_bound_value, "Upper"),
+        (prop.bounded_value.set_point_value, "Set Point"),
+    ):
+        if not (value_name := attr.get_value_name(display_only=True)):
+            continue
+        row = grid.row(align=True)
+        row.prop(attr, value_name, text=label)
+        row.prop(attr, "is_null", icon="RADIOBUT_OFF" if attr.is_null else "RADIOBUT_ON", text="")
+    if copy_operator:
+        op = layout.operator(f"{copy_operator}", text="", icon="COPYDOWN")
+        op.name = prop.metadata.name
+
+
 def get_active_pset_obj_name(context: bpy.types.Context, obj_type: tool.Ifc.OBJECT_TYPE) -> str:
     if obj_type in ("Object", "MaterialSetItem"):
         return context.active_object.name

src/bonsai/bonsai/tool/pset.py

@@ -38,6 +38,7 @@
         AddEditPropertyEntry,
         DeletePsetEntry,
         GlobalPsetProperties,
+        IfcProperty,
         PsetProperties,
         RenamePropertyEntry,
     )
@@ -49,6 +50,14 @@ class Pset(bonsai.core.tool.Pset):
     BulkOperationType = Literal["ADD_EDIT", "RENAME", "DELETE"]
     BULK_OPERATION_TYPES = ("ADD_EDIT", "RENAME", "DELETE")
 
+    #: Bounded value Blender attribute -> IFC attribute. Duplicates `pset.prop.BOUNDED_VALUE_ATTRS` to avoid a
+    #: circular import.
+    BOUNDED_VALUE_ATTRS: tuple[tuple[str, str], ...] = (
+        ("lower_bound_value", "LowerBoundValue"),
+        ("upper_bound_value", "UpperBoundValue"),
+        ("set_point_value", "SetPointValue"),
+    )
+
     @classmethod
     def get_global_pset_props(cls) -> GlobalPsetProperties:
         return bpy.context.scene.GlobalPsetProperties
@@ -385,6 +394,16 @@ def process_prop_description(metadata: Attribute) -> None:
                     new = simple_prop.enumerated_value.enumerated_values.add()
                     setattr(new, data_type, enum)
                     new.is_selected = enum in selected_enum_items
+            elif prop.is_a("IfcPropertyBoundedValue"):
+                bounded_prop = props.properties.add()
+                bounded_prop.name = prop.Name
+                bounded_prop.value_type = "IfcPropertyBoundedValue"
+                metadata = bounded_prop.metadata
+                metadata.name = prop.Name
+                metadata.is_null = True
+                metadata.is_optional = True
+                process_prop_description(metadata)
+                cls.set_bounded_value_attributes(bounded_prop, prop)
             else:
                 if prop.is_a("IfcPropertySingleValue"):
                     value = prop.NominalValue.wrappedValue if prop.NominalValue else None
@@ -425,6 +444,69 @@ def process_prop_description(metadata: Attribute) -> None:
                     if str_value is not None:
                         metadata.enum_value = str_value
 
+    @classmethod
+    def get_bounded_value_dict(cls, prop: IfcProperty) -> dict[str, Any]:
+        """Builds the dict expected by ``ifcopenshell.api.pset.edit_pset`` for a bounded value
+        property row, containing only the sub-fields the user hasn't marked as null."""
+        return {
+            ifc_attribute: attr.get_value()
+            for attr_name, ifc_attribute in cls.BOUNDED_VALUE_ATTRS
+            if not (attr := getattr(prop.bounded_value, attr_name)).is_null
+        }
+
+    @classmethod
+    def set_bounded_value_attributes(
+        cls,
+        bounded_prop: IfcProperty,
+        prop: Union[ifcopenshell.entity_instance, None] = None,
+        data_type: Union[str, None] = None,
+    ) -> None:
+        """Populates the Lower/Upper/SetPoint Attribute sub-fields of a bounded value property row.
+
+        :param prop: An existing ``IfcPropertyBoundedValue`` to read values from, if any.
+        :param data_type: Fallback Blender data type (e.g. ``"float"``) used for sub-fields that
+            have no existing value yet, e.g. when proposing a still-empty property from a template.
+        """
+        resolved_data_type = data_type
+        if prop is not None and resolved_data_type is None:
+            for _, ifc_attribute in cls.BOUNDED_VALUE_ATTRS:
+                if (value := getattr(prop, ifc_attribute, None)) is not None:
+                    resolved_data_type = ifcopenshell.util.attribute.get_primitive_type(
+                        tool.Ifc.schema().declaration_by_name(value.is_a())
+                    )
+                    break
+        resolved_data_type = resolved_data_type or "float"
+
+        for attr_name, ifc_attribute in cls.BOUNDED_VALUE_ATTRS:
+            attr = getattr(bounded_prop.bounded_value, attr_name)
+            attr.name = ifc_attribute
+            attr.is_optional = True
+            value = getattr(prop, ifc_attribute, None) if prop is not None else None
+            if value is not None:
+                attr.set_value(value.wrappedValue)
+                attr.is_null = False
+            else:
+                attr.data_type = resolved_data_type
+                attr.is_null = True
+
+    @classmethod
+    def import_bounded_value_from_template(
+        cls,
+        pset_template: ifcopenshell.entity_instance,
+        prop_template: ifcopenshell.entity_instance,
+        props: PsetProperties,
+    ) -> None:
+        prop = props.properties.add()
+        prop.name = prop_template.Name
+        prop.value_type = "IfcPropertyBoundedValue"
+        metadata = prop.metadata
+        metadata.name = prop_template.Name
+        metadata.is_null = True
+        metadata.is_optional = True
+        metadata.ifc_class = pset_template.Name
+        bonsai.bim.helper.add_attribute_description(metadata, prop_template)
+        cls.set_bounded_value_attributes(prop, data_type=cls.get_prop_template_primitive_type(prop_template))
+
     @classmethod
     def get_prop_template_primitive_type(cls, prop_template: ifcopenshell.entity_instance) -> str:
         if prop_template.TemplateType in ["Q_LENGTH", "Q_AREA", "Q_VOLUME", "Q_WEIGHT", "Q_TIME"]:
@@ -557,9 +639,15 @@ def import_pset_from_template(
                     continue
                 cls.import_enumerated_value_from_template(prop_template, simplified_data, props)
 
+            elif prop_template.TemplateType == "P_BOUNDEDVALUE":
+                if prop_data:
+                    # Existing property (of any class) will be added by import_pset_from_existing,
+                    # which can read all of LowerBoundValue/UpperBoundValue/SetPointValue directly.
+                    continue
+                cls.import_bounded_value_from_template(pset_template, prop_template, props)
+
             else:
                 # NOTE: currently unsupported types:
-                # - P_BOUNDEDVALUE
                 # - P_LISTVALUE
                 # - P_REFERENCEVALUE
                 # - P_TABLEVALUE

src/ifcopenshell-python/ifcopenshell/api/pset/edit_pset.py

@@ -23,6 +23,8 @@
 import ifcopenshell.util.element
 import ifcopenshell.util.pset
 
+#: A dict value containing any of these keys describes an ``IfcPropertyBoundedValue``.
+BOUNDED_VALUE_KEYS = ("LowerBoundValue", "UpperBoundValue", "SetPointValue")
 # Sentinel distinguishing "no Unit dict was passed at all" from "a Unit dict was passed
 # with Unit explicitly set to None" (i.e. explicitly clear an existing override).
 _NO_UNIT = object()
@@ -77,6 +79,11 @@ def edit_pset(
         become IfcBoolean, and integers will become IfcInteger. If more
         control is desired, you may explicitly specify IFC data objects
         directly. Note that provided `properties` might be mutated in the process.
+        An ``IfcPropertyBoundedValue`` may be added or edited by providing a
+        dictionary containing any of the keys ``LowerBoundValue``,
+        ``UpperBoundValue``, or ``SetPointValue`` (at least one is required).
+        Values may be plain Python types (cast using the property set
+        template, if available) or explicit IFC data objects.
     :param pset_template: If a property set template is provided, this will
         be used to determine data types. If no user-defined template is
         provided, the built-in buildingSMART templates will be loaded.
@@ -154,6 +161,14 @@ def edit_pset(
         # Editing existing properties will retain their current data types
         # if possible. So this will still be a length measure.
         ifcopenshell.api.pset.edit_pset(model, pset=pset, properties={"ExplicitLength": 12.3})
+
+        # Bounded values (IfcPropertyBoundedValue) are described using a
+        # dictionary with LowerBoundValue / UpperBoundValue / SetPointValue keys.
+        # Any subset of these keys may be provided, and existing values are
+        # retained unless a new dictionary is passed.
+        pset = ifcopenshell.api.pset.add_pset(model, product=wall_type, name="Pset_ElectricalDeviceCommon")
+        ifcopenshell.api.pset.edit_pset(model, pset=pset,
+            properties={"RatedCurrent": {"LowerBoundValue": 1.0, "UpperBoundValue": 2.0}})
     """
     usecase = Usecase()
     usecase.file = file
@@ -226,6 +241,10 @@ def update_existing_properties(self) -> list[ifcopenshell.entity_instance]:
                 prop = self.update_existing_prop_enum(prop)
                 if prop:
                     existing_props.append(prop)
+            elif prop.is_a("IfcPropertyBoundedValue"):
+                prop = self.update_existing_prop_bounded_value(prop)
+                if prop:
+                    existing_props.append(prop)
             elif prop.is_a("IfcPropertySingleValue"):
                 prop = self.update_existing_prop_single_value(prop)
                 if prop:
@@ -298,6 +317,56 @@ def update_existing_prop_enum(
         del self.settings["properties"][prop.Name]
         return prop
 
+    def update_existing_prop_bounded_value(
+        self, prop: ifcopenshell.entity_instance
+    ) -> Union[ifcopenshell.entity_instance, None]:
+        """
+        NOTE: Assumes the prop exists
+        """
+        value = self.settings["properties"][prop.Name]
+
+        if value is None:
+            if self._try_purge(prop):
+                return
+            for ifc_attribute in BOUNDED_VALUE_KEYS:
+                setattr(prop, ifc_attribute, None)
+        elif isinstance(value, dict) and any(k in value for k in BOUNDED_VALUE_KEYS):
+            primary_measure_type = None
+            for ifc_attribute in BOUNDED_VALUE_KEYS:
+                if existing_value := getattr(prop, ifc_attribute):
+                    primary_measure_type = existing_value.is_a()
+                    break
+
+            for ifc_attribute in BOUNDED_VALUE_KEYS:
+                if ifc_attribute not in value:
+                    continue
+                new_value = value[ifc_attribute]
+                if new_value is None:
+                    setattr(prop, ifc_attribute, None)
+                    continue
+                if not isinstance(new_value, ifcopenshell.entity_instance):
+                    measure_type = primary_measure_type or self.get_primary_measure_type(prop.Name)
+                    assert measure_type, f"Couldn't find primary measure type for the prop value: '{prop.Name}'."
+                    new_value = self.file.create_entity(
+                        measure_type, self.cast_value_to_primary_measure_type(new_value, measure_type)
+                    )
+                setattr(prop, ifc_attribute, new_value)
+
+            if all(getattr(prop, k) is None for k in BOUNDED_VALUE_KEYS):
+                if self._try_purge(prop):
+                    return
+
+            if unit := value.get("Unit"):
+                prop.Unit = unit
+        else:
+            raise ValueError(
+                f'Value "{value}" is not a valid value for bounded property {prop.Name}. '
+                f"Expected None or a dict with any of {BOUNDED_VALUE_KEYS} keys."
+            )
+
+        del self.settings["properties"][prop.Name]
+        return prop
+
     def update_existing_prop_single_value(
         self, prop: ifcopenshell.entity_instance
     ) -> Union[ifcopenshell.entity_instance, None]:
@@ -370,6 +439,9 @@ def add_new_properties(self) -> list[ifcopenshell.entity_instance]:
         for name, value in self.settings["properties"].items():
             if value is None and self.settings["should_purge"]:
                 continue
+            if isinstance(value, dict) and any(k in value for k in BOUNDED_VALUE_KEYS):
+                properties.append(self.create_bounded_value_prop(name, value))
+                continue
             unit, value = self.unpack_unit_value(value)
 
             if isinstance(value, ifcopenshell.entity_instance):
@@ -445,6 +517,34 @@ def add_new_properties(self) -> list[ifcopenshell.entity_instance]:
                 properties.append(self.file.create_entity("IfcPropertySingleValue", **args))
         return properties
 
+    def create_bounded_value_prop(self, name: str, value: dict[str, Any]) -> ifcopenshell.entity_instance:
+        """Creates a new IfcPropertyBoundedValue from a dict of LowerBoundValue /
+        UpperBoundValue / SetPointValue (and optionally Unit).
+        """
+        primary_measure_type = None
+        for ifc_attribute in BOUNDED_VALUE_KEYS:
+            existing_value = value.get(ifc_attribute)
+            if isinstance(existing_value, ifcopenshell.entity_instance):
+                primary_measure_type = existing_value.is_a()
+                break
+
+        kwargs: dict[str, Any] = {"Name": name}
+        for ifc_attribute in BOUNDED_VALUE_KEYS:
+            if (bound_value := value.get(ifc_attribute)) is None:
+                continue
+            if not isinstance(bound_value, ifcopenshell.entity_instance):
+                measure_type = primary_measure_type or self.get_primary_measure_type(name)
+                assert measure_type, f"Couldn't find primary measure type for the prop value: '{name}'."
+                bound_value = self.file.create_entity(
+                    measure_type, self.cast_value_to_primary_measure_type(bound_value, measure_type)
+                )
+            kwargs[ifc_attribute] = bound_value
+
+        if unit := value.get("Unit"):
+            kwargs["Unit"] = unit
+
+        return self.file.create_entity("IfcPropertyBoundedValue", **kwargs)
+
     def assign_new_properties(self, props: list[ifcopenshell.entity_instance]) -> None:
         if hasattr(self.settings["pset"], "HasProperties"):
             self.settings["pset"].HasProperties = props