Merge branch 'v0.6.0' into GSoC#45-IDS-checking

src/ifcopenshell-python/ifcopenshell/api/aggregate/unassign_object.py

@@ -0,0 +1,25 @@
+import ifcopenshell
+import ifcopenshell.api
+
+
+class Usecase:
+    def __init__(self, file, **settings):
+        self.file = file
+        self.settings = {
+            "relating_object": None,
+            "product": None,
+        }
+        for key, value in settings.items():
+            self.settings[key] = value
+
+    def execute(self):
+        for rel in self.settings["product"].Decomposes or []:
+            if not rel.is_a("IfcRelAggregates") or rel.RelatingObject != self.settings["relating_object"]:
+                continue
+            if len(rel.RelatedObjects) == 1:
+                return self.file.remove(rel)
+            related_objects = list(rel.RelatedObjects)
+            related_objects.remove(self.settings["product"])
+            rel.RelatedObjects = related_objects
+            ifcopenshell.api.run("owner.update_owner_history", self.file, **{"element": rel})
+            return rel

src/ifcopenshell-python/ifcopenshell/api/control/assign_control.py

@@ -26,9 +26,9 @@ class Usecase:
             controls = self.settings["relating_control"].Controls[0]
 
         if controls:
-            related_objects = list(controls.RelatedObjects)
-            related_objects.append(self.settings["related_object"])
-            controls.RelatedObjects = related_objects
+            related_objects = set(controls.RelatedObjects)
+            related_objects.add(self.settings["related_object"])
+            controls.RelatedObjects = list(related_objects)
             ifcopenshell.api.run("owner.update_owner_history", self.file, **{"element": controls})
         else:
             controls = self.file.create_entity(

src/ifcopenshell-python/ifcopenshell/api/cost/add_cost_item_quantity.py

@@ -0,0 +1,22 @@
+import ifcopenshell.api
+
+
+class Usecase:
+    def __init__(self, file, **settings):
+        self.file = file
+        self.settings = {"cost_item": None, "ifc_class": "IfcQuantityCount"}
+        for key, value in settings.items():
+            self.settings[key] = value
+
+    def execute(self):
+        quantity = self.file.create_entity(self.settings["ifc_class"], Name="Unnamed")
+        quantity[3] = 0.0
+        # This is a bold assumption
+        # https://forums.buildingsmart.org/t/how-does-a-cost-item-know-that-it-is-counting-a-controlled-product/3564
+        if self.settings["ifc_class"] == "IfcQuantityCount" and self.settings["cost_item"].Controls:
+            for rel in self.settings["cost_item"].Controls:
+                quantity[3] += len(rel.RelatedObjects)
+        quantities = list(self.settings["cost_item"].CostQuantities or [])
+        quantities.append(quantity)
+        self.settings["cost_item"].CostQuantities = quantities
+        return quantity

src/ifcopenshell-python/ifcopenshell/api/cost/add_cost_item_value.py

@@ -0,0 +1,16 @@
+import ifcopenshell.api
+
+
+class Usecase:
+    def __init__(self, file, **settings):
+        self.file = file
+        self.settings = {"cost_item": None, "ifc_class": "IfcQuantityCount"}
+        for key, value in settings.items():
+            self.settings[key] = value
+
+    def execute(self):
+        value = self.file.create_entity("IfcCostValue")
+        values = list(self.settings["cost_item"].CostValues or [])
+        values.append(value)
+        self.settings["cost_item"].CostValues = values
+        return value

src/ifcopenshell-python/ifcopenshell/api/cost/assign_cost_item_product_quantities.py

@@ -0,0 +1,32 @@
+import ifcopenshell.api
+
+
+class Usecase:
+    def __init__(self, file, **settings):
+        self.file = file
+        self.settings = {"cost_item": None, "qto_name": "", "prop_name": ""}
+        for key, value in settings.items():
+            self.settings[key] = value
+
+    def execute(self):
+        self.quantities = set(self.settings["cost_item"].CostQuantities or [])
+        for control in self.settings["cost_item"].Controls or []:
+            for related_object in control.RelatedObjects:
+                self.add_quantity_from_related_object(related_object)
+        self.settings["cost_item"].CostQuantities = list(self.quantities)
+
+    def add_quantity_from_related_object(self, element):
+        if element.is_a("IfcTypeObject"):
+            for definition in element.HasPropertySets or []:
+                self.add_quantity_from_qto(definition)
+        else:
+            for relationship in element.IsDefinedBy:
+                if relationship.is_a("IfcRelDefinesByProperties"):
+                    self.add_quantity_from_qto(relationship.RelatingPropertyDefinition)
+
+    def add_quantity_from_qto(self, qto):
+        if not qto.is_a("IfcElementQuantity") or qto.Name.lower() != self.settings["qto_name"].lower():
+            return
+        for prop in qto.Quantities:
+            if prop.is_a("IfcPhysicalSimpleQuantity") and prop.Name.lower() == self.settings["prop_name"].lower():
+                self.quantities.add(prop)

src/ifcopenshell-python/ifcopenshell/api/cost/data.py

@@ -5,43 +5,133 @@ class Data:
     is_loaded = False
     cost_schedules = {}
     cost_items = {}
+    physical_quantities = {}
+    cost_values = {}
 
     @classmethod
     def purge(cls):
         cls.is_loaded = False
         cls.cost_schedules = {}
         cls.cost_items = {}
+        cls.physical_quantities = {}
+        cls.cost_values = {}
 
     @classmethod
     def load(cls, file):
+        cls.file = file
         cls.cost_schedules = {}
         cls.cost_items = {}
+        cls.physical_quantities = {}
+        cls.cost_values = {}
 
-        for cost_schedule in file.by_type("IfcCostSchedule"):
+        for cost_schedule in cls.file.by_type("IfcCostSchedule"):
             data = cost_schedule.get_info()
             del data["OwnerHistory"]
             if data["SubmittedOn"]:
                 data["SubmittedOn"] = ifcopenshell.util.date.ifc2datetime(data["SubmittedOn"])
             if data["UpdateDate"]:
                 data["UpdateDate"] = ifcopenshell.util.date.ifc2datetime(data["UpdateDate"])
-            data["RelatedObjects"] = []
+            data["Controls"] = []
             for rel in cost_schedule.Controls:
                 for related_object in rel.RelatedObjects:
                     if related_object.is_a("IfcCostItem"):
-                        data["RelatedObjects"].append(related_object.id())
-                        break # We are only allowed one summary cost item
+                        data["Controls"].append(related_object.id())
+                        break  # We are only allowed one summary cost item
             cls.cost_schedules[cost_schedule.id()] = data
 
-        for cost_item in file.by_type("IfcCostItem"):
+        for cost_item in cls.file.by_type("IfcCostItem"):
             data = cost_item.get_info()
             del data["OwnerHistory"]
             del data["CostValues"]
-            del data["CostQuantities"]
-            data["RelatedObjects"] = []
+            data["IsNestedBy"] = []
             data["Controls"] = []
             for rel in cost_item.IsNestedBy:
-                [data["RelatedObjects"].append(o.id()) for o in rel.RelatedObjects if o.is_a("IfcCostItem")]
+                [data["IsNestedBy"].append(o.id()) for o in rel.RelatedObjects if o.is_a("IfcCostItem")]
             for rel in cost_item.Controls:
                 [data["Controls"].append(o.id()) for o in rel.RelatedObjects or []]
             cls.cost_items[cost_item.id()] = data
-        cls.is_loaded=True
+            cls.load_cost_item_quantities(cost_item, data)
+            cls.load_cost_item_values(cost_item, data)
+        cls.is_loaded = True
+
+    @classmethod
+    def load_cost_item_quantities(cls, cost_item, data):
+        data["CostQuantities"] = []
+        data["TotalCostQuantity"] = cls.get_total_quantity(cost_item)
+        for quantity in cost_item.CostQuantities or []:
+            quantity_data = quantity.get_info()
+            del quantity_data["Unit"]
+            cls.physical_quantities[quantity.id()] = quantity_data
+            data["CostQuantities"].append(quantity.id())
+
+    @classmethod
+    def load_cost_item_values(cls, cost_item, data):
+        data["CostValues"] = []
+        data["TotalCostValue"] = 0.0
+        data["TotalAppliedValue"] = 0.0
+        for cost_value in cost_item.CostValues or []:
+            cls.load_cost_item_value(cost_item, cost_value)
+            data["CostValues"].append(cost_value.id())
+            data["TotalAppliedValue"] += cls.cost_values[cost_value.id()]["AppliedValue"]
+        data["TotalCostValue"] = data["TotalCostQuantity"] * data["TotalAppliedValue"]
+
+    @classmethod
+    def load_cost_item_value(cls, cost_item, cost_value):
+        value_data = cost_value.get_info()
+        del value_data["AppliedValue"]
+        del value_data["UnitBasis"]
+        if value_data["ApplicableDate"]:
+            value_data["ApplicableDate"] = ifcopenshell.util.date.ifc2datetime(value_data["ApplicableDate"])
+        if value_data["FixedUntilDate"]:
+            value_data["FixedUntilDate"] = ifcopenshell.util.date.ifc2datetime(value_data["FixedUntilDate"])
+        value_data["Components"] = [c.id() for c in value_data["Components"] or []]
+        value_data["AppliedValue"] = cls.calculate_applied_value(cost_item, cost_value)
+        cls.cost_values[cost_value.id()] = value_data
+
+    @classmethod
+    def calculate_applied_value(cls, cost_item, cost_value, category_filter=None):
+        result = 0
+        if cost_value.ArithmeticOperator and cost_value.Components:
+            pass  # TODO
+        if cost_value.Category is None:
+            return cls.get_primitive_applied_value(cost_value.AppliedValue)
+        elif cost_value.Category == "*":
+            if cost_item.IsNestedBy:
+                return cls.sum_child_cost_items(cost_item)
+            else:
+                return cls.get_primitive_applied_value(cost_value.AppliedValue)
+        elif cost_value.Category:
+            if cost_item.IsNestedBy:
+                return cls.sum_child_cost_items(cost_item, category_filter=cost_value.Category)
+            else:
+                return cls.get_primitive_applied_value(cost_value.AppliedValue)
+        return result
+
+    @classmethod
+    def sum_child_cost_items(cls, cost_item, category_filter=None):
+        result = 0
+        for rel in cost_item.IsNestedBy:
+            for child_cost_item in rel.RelatedObjects:
+                for child_cost_value in child_cost_item.CostValues or []:
+                    if category_filter and child_cost_value.Category != category_filter:
+                        continue
+                    child_applied_value = cls.calculate_applied_value(child_cost_item, child_cost_value)
+                    child_quantity = cls.get_total_quantity(child_cost_item)
+                    result += child_applied_value * child_quantity
+        return result
+
+    @classmethod
+    def get_total_quantity(cls, cost_item):
+        return sum([q[3] for q in cost_item.CostQuantities or []]) or 1.0
+
+    @classmethod
+    def get_primitive_applied_value(cls, applied_value):
+        if not applied_value:
+            return 0.0
+        elif isinstance(applied_value, float):
+            return applied_value
+        elif hasattr(applied_value, "wrappedValue") and isinstance(applied_value.wrappedValue, float):
+            return applied_value.wrappedValue
+        elif applied_value.is_a("IfcMeasureWithUnit"):
+            return applied_value.ValueComponent
+        assert False, "Applied value {applied_value} not implemented"

src/ifcopenshell-python/ifcopenshell/api/cost/edit_cost_item_quantity.py

@@ -0,0 +1,10 @@
+class Usecase:
+    def __init__(self, file, **settings):
+        self.file = file
+        self.settings = {"physical_quantity": None, "attributes": {}}
+        for key, value in settings.items():
+            self.settings[key] = value
+
+    def execute(self):
+        for name, value in self.settings["attributes"].items():
+            setattr(self.settings["physical_quantity"], name, value)

src/ifcopenshell-python/ifcopenshell/api/cost/edit_cost_item_value.py

@@ -0,0 +1,13 @@
+class Usecase:
+    def __init__(self, file, **settings):
+        self.file = file
+        self.settings = {"cost_value": None, "attributes": {}}
+        for key, value in settings.items():
+            self.settings[key] = value
+
+    def execute(self):
+        for name, value in self.settings["attributes"].items():
+            if name == "AppliedValue" and value is not None:
+                # TODO: support all applied value select types
+                value = self.file.createIfcReal(value)
+            setattr(self.settings["cost_value"], name, value)

src/ifcopenshell-python/ifcopenshell/api/cost/remove_cost_item_quantity.py

@@ -0,0 +1,14 @@
+class Usecase:
+    def __init__(self, file, **settings):
+        self.file = file
+        self.settings = {"cost_item": None, "physical_quantity": None}
+        for key, value in settings.items():
+            self.settings[key] = value
+
+    def execute(self):
+        if len(self.file.get_inverse(self.settings["physical_quantity"])) == 1:
+            self.file.remove(self.settings["physical_quantity"])
+            return
+        quantities = list(self.settings["cost_item"].CostQuantities or [])
+        quantities.remove(self.settings["physical_quantity"])
+        self.settings["cost_item"].CostQuantities = quantities

src/ifcopenshell-python/ifcopenshell/api/cost/remove_cost_item_value.py

@@ -0,0 +1,9 @@
+class Usecase:
+    def __init__(self, file, **settings):
+        self.file = file
+        self.settings = {"cost_value": None}
+        for key, value in settings.items():
+            self.settings[key] = value
+
+    def execute(self):
+        self.file.remove(self.settings["cost_value"])

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

@@ -1,5 +1,4 @@
 import ifcopenshell
-import blenderbim.bim.schema  # TODO: refactor
 
 
 class Usecase:

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

@@ -1,5 +1,4 @@
 import ifcopenshell
-import blenderbim.bim.schema  # TODO: refactor
 
 
 class Usecase:

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

@@ -1,6 +1,6 @@
 import ifcopenshell
 import ifcopenshell.util.attribute
-import blenderbim.bim.schema  # TODO: refactor elsewhere
+import ifcopenshell.util.pset
 
 
 class Data:
@@ -17,6 +17,7 @@ class Data:
     @classmethod
     def load(cls, file, product_id):
         cls._file = file
+        cls._psetqto = ifcopenshell.util.pset.get_template("IFC4")
         cls._schema = ifcopenshell.ifcopenshell_wrapper.schema_by_name(file.schema)
         if not file:
             return
@@ -150,7 +151,7 @@ class Data:
 
     @classmethod
     def get_properties_from_template(cls, name):
-        template = blenderbim.bim.schema.ifc.psetqto.get_by_name(name)
+        template = cls._psetqto.get_by_name(name)
         if not template:
             return
         properties = []

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

@@ -1,4 +1,4 @@
-import blenderbim.bim.schema  # TODO: refactor
+import ifcopenshell
 
 
 class Usecase:
@@ -20,7 +20,9 @@ class Usecase:
             self.settings["pset"].Name = self.settings["Name"]
 
     def load_pset_template(self):
-        self.pset_template = blenderbim.bim.schema.ifc.psetqto.get_by_name(self.settings["pset"].Name)
+        # TODO: add IFC2X3 PsetQto template support
+        self.psetqto = ifcopenshell.util.pset.get_template("IFC4")
+        self.pset_template = self.psetqto.get_by_name(self.settings["pset"].Name)
 
     def update_existing_properties(self):
         for prop in self.get_properties():

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

@@ -1,4 +1,4 @@
-import blenderbim.bim.schema  # TODO: refactor
+import ifcopenshell
 
 
 class Usecase:
@@ -20,7 +20,9 @@ class Usecase:
             self.settings["qto"].Name = self.settings["Name"]
 
     def load_qto_template(self):
-        self.qto_template = blenderbim.bim.schema.ifc.psetqto.get_by_name(self.settings["qto"].Name)
+        # TODO: add IFC2X3 PsetQto template support
+        self.psetqto = ifcopenshell.util.pset.get_template("IFC4")
+        self.qto_template = self.psetqto.get_by_name(self.settings["qto"].Name)
 
     def update_existing_properties(self):
         for prop in self.settings["qto"].Quantities or []:

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

@@ -1,6 +1,3 @@
-import blenderbim.bim.schema  # TODO: refactor
-
-
 class Usecase:
     def __init__(self, file, **settings):
         self.file = file

src/ifcopenshell-python/ifcopenshell/api/resource/add_resource.py

@@ -0,0 +1,35 @@
+import ifcopenshell.api
+
+
+class Usecase:
+    def __init__(self, file, **settings):
+        self.file = file
+        self.settings = {
+            "parent_resource": None,
+            "ifc_class": "IfcCrewResource",
+            "name": None,
+            "predefined_type": "NOTDEFINED",
+        }
+        for key, value in settings.items():
+            self.settings[key] = value
+
+    def execute(self):
+        resource = ifcopenshell.api.run(
+            "root.create_entity",
+            self.file,
+            ifc_class=self.settings["ifc_class"],
+            predefined_type=self.settings["predefined_type"],
+            name=self.settings["name"],
+        )
+        # TODO: this is an ambiguity by buildingSMART: Can we nest an IfcCrewResource under an IfcCrewResource ?
+        # https://forums.buildingsmart.org/t/what-are-allowed-to-be-root-level-construction-resources/3550
+        if self.settings["parent_resource"]:
+            ifcopenshell.api.run(
+                "nest.assign_object", self.file, related_object=resource, relating_object=self.settings["parent_resource"]
+            )
+        else:
+            context = self.file.by_type("IfcContext")[0]
+            ifcopenshell.api.run(
+                "project.assign_declaration", self.file, definition=resource, relating_context=context
+            )
+        return resource

src/ifcopenshell-python/ifcopenshell/api/resource/assign_resource.py

@@ -0,0 +1,43 @@
+import ifcopenshell
+import ifcopenshell.api
+
+
+class Usecase:
+    def __init__(self, file, **settings):
+        self.file = file
+        self.settings = {
+            "relating_resource": None,
+            "related_object": None,
+        }
+        for key, value in settings.items():
+            self.settings[key] = value
+
+    def execute(self):
+        if self.settings["related_object"].HasAssignments:
+            for assignment in self.settings["related_object"].HasAssignments:
+                if (
+                    assignment.is_a("IfclRelAssignsToResource")
+                    and assignment.RelatingResource == self.settings["relating_resource"]
+                ):
+                    return
+
+        resource_of = None
+        if self.settings["relating_resource"].ResourceOf:
+            resource_of = self.settings["relating_resource"].ResourceOf[0]
+
+        if resource_of:
+            related_objects = list(resource_of.RelatedObjects)
+            related_objects.append(self.settings["related_object"])
+            resource_of.RelatedObjects = related_objects
+            ifcopenshell.api.run("owner.update_owner_history", self.file, **{"element": resource_of})
+        else:
+            resource_of = self.file.create_entity(
+                "IfcRelAssignsToResource",
+                **{
+                    "GlobalId": ifcopenshell.guid.new(),
+                    "OwnerHistory": ifcopenshell.api.run("owner.create_owner_history", self.file),
+                    "RelatedObjects": [self.settings["related_object"]],
+                    "RelatingResource": self.settings["relating_resource"],
+                }
+            )
+        return resource_of

src/ifcopenshell-python/ifcopenshell/api/resource/data.py

@@ -0,0 +1,23 @@
+class Data:
+    is_loaded = False
+    resources = {}
+
+    @classmethod
+    def purge(cls):
+        cls.resources = {}
+
+    @classmethod
+    def load(cls, file):
+        cls.resources = {}
+        for resource in file.by_type("IfcResource"):
+            data = resource.get_info()
+            del data["OwnerHistory"]
+            data["IsNestedBy"] = []
+            for rel in resource.IsNestedBy:
+                [data["IsNestedBy"].append(o.id()) for o in rel.RelatedObjects]
+            data["ResourceOf"] = []
+            for rel in resource.ResourceOf:
+                [data["ResourceOf"].append(o.id()) for o in rel.RelatedObjects]
+            data["HasContext"] = resource.HasContext[0].RelatingContext.id() if resource.HasContext else None
+            cls.resources[resource.id()] = data
+        cls.is_loaded=True

src/ifcopenshell-python/ifcopenshell/api/resource/edit_resource.py

@@ -0,0 +1,10 @@
+class Usecase:
+    def __init__(self, file, **settings):
+        self.file = file
+        self.settings = {"resource": None, "attributes": {}}
+        for key, value in settings.items():
+            self.settings[key] = value
+
+    def execute(self):
+        for name, value in self.settings["attributes"].items():
+            setattr(self.settings["resource"], name, value)

src/ifcopenshell-python/ifcopenshell/api/resource/remove_resource.py

@@ -0,0 +1,10 @@
+class Usecase:
+    def __init__(self, file, **settings):
+        self.file = file
+        self.settings = {"resource": None}
+        for key, value in settings.items():
+            self.settings[key] = value
+
+    def execute(self):
+        # TODO: do a deep purge
+        self.file.remove(self.settings["resource"])

src/ifcopenshell-python/ifcopenshell/api/resource/unassign_resource.py

@@ -0,0 +1,24 @@
+import ifcopenshell.api
+
+
+class Usecase:
+    def __init__(self, file, **settings):
+        self.file = file
+        self.settings = {
+            "relating_resource": None,
+            "related_object": None,
+        }
+        for key, value in settings.items():
+            self.settings[key] = value
+
+    def execute(self):
+        for rel in self.settings["related_object"].HasAssignments or []:
+            if not rel.is_a("IfcRelAssignsToResource") or rel.RelatingResource != self.settings["relating_resource"]:
+                continue
+            if len(rel.RelatedObjects) == 1:
+                return self.file.remove(rel)
+            related_objects = list(rel.RelatedObjects)
+            related_objects.remove(self.settings["related_object"])
+            rel.RelatedObjects = related_objects
+            ifcopenshell.api.run("owner.update_owner_history", self.file, **{"element": rel})
+            return rel

src/ifcopenshell-python/ifcopenshell/api/sequence/add_time_period.py

@@ -0,0 +1,25 @@
+import ifcopenshell.api
+import ifcopenshell.util.date
+from datetime import datetime
+from datetime import timedelta
+
+
+class Usecase:
+    def __init__(self, file, **settings):
+        self.file = file
+        self.settings = {
+            "recurrence_pattern": None,
+            "start_time": None,
+            "end_time": None,
+        }
+        for key, value in settings.items():
+            self.settings[key] = value
+
+    def execute(self):
+        time_period = self.file.create_entity("IfcTimePeriod")
+        time_period.StartTime = ifcopenshell.util.date.datetime2ifc(self.settings["start_time"], "IfcTime")
+        time_period.EndTime = ifcopenshell.util.date.datetime2ifc(self.settings["end_time"], "IfcTime")
+        time_periods = list(self.settings["recurrence_pattern"].TimePeriods or [])
+        time_periods.append(time_period)
+        self.settings["recurrence_pattern"].TimePeriods = time_periods
+        return time_period

src/ifcopenshell-python/ifcopenshell/api/sequence/add_work_time.py

@@ -1,17 +1,17 @@
 class Usecase:
     def __init__(self, file, **settings):
         self.file = file
-        self.settings = {"work_calendar": None, "type": "WorkingTimes", "name": None}
+        self.settings = {"work_calendar": None, "time_type": None}
         for key, value in settings.items():
             self.settings[key] = value
 
     def execute(self):
-        work_time = self.file.create_entity("IfcWorkTime", **{"Name": self.settings["name"]})
-        if self.settings["type"] == "WorkingTimes":
+        work_time = self.file.create_entity("IfcWorkTime")
+        if self.settings["time_type"] == "WorkingTimes":
             working_times = list(self.settings["work_calendar"].WorkingTimes or [])
             working_times.append(work_time)
             self.settings["work_calendar"].WorkingTimes = working_times
-        elif self.settings["type"] == "ExceptionTimes":
+        elif self.settings["time_type"] == "ExceptionTimes":
             exception_times = list(self.settings["work_calendar"].ExceptionTimes or [])
             exception_times.append(work_time)
             self.settings["work_calendar"].ExceptionTimes = exception_times

src/ifcopenshell-python/ifcopenshell/api/sequence/assign_recurrence_pattern.py

@@ -8,8 +8,11 @@ class Usecase:
     def execute(self):
         recurrence = self.file.createIfcRecurrencePattern(self.settings["recurrence_type"])
 
-        if self.settings["parent"].is_a("IfcWorkTime") and self.settings["parent"].RecurrencePattern:
-            if len(self.file.get_inverse(self.settings["parent"].RecurrencePattern)) == 1:
+        if self.settings["parent"].is_a("IfcWorkTime"):
+            if (
+                self.settings["parent"].RecurrencePattern
+                and len(self.file.get_inverse(self.settings["parent"].RecurrencePattern)) == 1
+            ):
                 self.file.remove(self.settings["parent"].RecurrencePattern)
             self.settings["parent"].RecurrencePattern = recurrence
         elif self.settings["parent"].is_a("IfcTaskTimeRecurring"):

src/ifcopenshell-python/ifcopenshell/api/sequence/data.py

@@ -5,6 +5,10 @@ class Data:
     is_loaded = False
     work_plans = {}
     work_schedules = {}
+    work_calendars = {}
+    work_times = {}
+    recurrence_patterns = {}
+    time_periods = {}
     tasks = {}
     task_times = {}
 
@@ -14,6 +18,9 @@ class Data:
         cls.work_plans = {}
         cls.work_schedules = {}
         cls.work_calendars = {}
+        cls.work_times = {}
+        cls.recurrence_patterns = {}
+        cls.time_periods = {}
         cls.tasks = {}
         cls.task_times = {}
 
@@ -25,6 +32,9 @@ class Data:
         cls.load_work_plans()
         cls.load_work_schedules()
         cls.load_work_calendars()
+        cls.load_work_times()
+        cls.load_recurrence_patterns()
+        cls.load_time_periods()
         cls.load_tasks()
         cls.load_task_times()
         cls.is_loaded = True
@@ -41,6 +51,9 @@ class Data:
             data["StartTime"] = ifcopenshell.util.date.ifc2datetime(data["StartTime"])
             if data["FinishTime"]:
                 data["FinishTime"] = ifcopenshell.util.date.ifc2datetime(data["FinishTime"])
+            data["IsDecomposedBy"] = []
+            for rel in work_plan.IsDecomposedBy:
+                data["IsDecomposedBy"].extend([o.id() for o in rel.RelatedObjects])
             cls.work_plans[work_plan.id()] = data
 
     @classmethod
@@ -68,10 +81,37 @@ class Data:
         for work_calendar in cls._file.by_type("IfcWorkCalendar"):
             data = work_calendar.get_info()
             del data["OwnerHistory"]
-            del data["WorkingTimes"]
-            del data["ExceptionTimes"]
+            data["WorkingTimes"] = [t.id() for t in work_calendar.WorkingTimes or []]
+            data["ExceptionTimes"] = [t.id() for t in work_calendar.ExceptionTimes or []]
             cls.work_calendars[work_calendar.id()] = data
 
+    @classmethod
+    def load_work_times(cls):
+        cls.work_times = {}
+        for work_time in cls._file.by_type("IfcWorkTime"):
+            data = work_time.get_info()
+            data["Start"] = ifcopenshell.util.date.ifc2datetime(data["Start"]) if data["Start"] else None
+            data["Finish"] = ifcopenshell.util.date.ifc2datetime(data["Finish"]) if data["Finish"] else None
+            data["RecurrencePattern"] = work_time.RecurrencePattern.id() if work_time.RecurrencePattern else None
+            cls.work_times[work_time.id()] = data
+
+    @classmethod
+    def load_recurrence_patterns(cls):
+        cls.recurrence_patterns = {}
+        for recurrence_pattern in cls._file.by_type("IfcRecurrencePattern"):
+            data = recurrence_pattern.get_info()
+            data["TimePeriods"] = [t.id() for t in recurrence_pattern.TimePeriods or []]
+            cls.recurrence_patterns[recurrence_pattern.id()] = data
+
+    @classmethod
+    def load_time_periods(cls):
+        cls.time_periods = {}
+        for time_period in cls._file.by_type("IfcTimePeriod"):
+            cls.time_periods[time_period.id()] = {
+                "StartTime": ifcopenshell.util.date.ifc2datetime(time_period.StartTime),
+                "EndTime": ifcopenshell.util.date.ifc2datetime(time_period.EndTime),
+            }
+
     @classmethod
     def load_tasks(cls):
         cls.tasks = {}

src/ifcopenshell-python/ifcopenshell/api/sequence/edit_recurrence_pattern.py

@@ -13,9 +13,14 @@ class Usecase:
             if name == "TimePeriods" and value:
                 periods = []
                 for period in value:
-                    periods.append(self.file.create_entity("IfcTimePeriod", **{
-                        "StartTime": ifcopenshell.util.date.datetime2ifc(period[0]),
-                        "EndTime": ifcopenshell.util.date.datetime2ifc(period[1])
-                    }))
+                    periods.append(
+                        self.file.create_entity(
+                            "IfcTimePeriod",
+                            **{
+                                "StartTime": ifcopenshell.util.date.datetime2ifc(period[0]),
+                                "EndTime": ifcopenshell.util.date.datetime2ifc(period[1]),
+                            },
+                        )
+                    )
                 value = periods
             setattr(self.settings["recurrence_pattern"], name, value)

src/ifcopenshell-python/ifcopenshell/api/sequence/edit_work_time.py

@@ -10,6 +10,6 @@ class Usecase:
 
     def execute(self):
         for name, value in self.settings["attributes"].items():
-            if name in ["Start", "Finish"]:
+            if value and name in ["Start", "Finish"]:
                 value = ifcopenshell.util.date.datetime2ifc(value, "IfcDate")
             setattr(self.settings["work_time"], name, value)

src/ifcopenshell-python/ifcopenshell/api/sequence/remove_time_period.py

@@ -0,0 +1,12 @@
+import ifcopenshell.api
+
+
+class Usecase:
+    def __init__(self, file, **settings):
+        self.file = file
+        self.settings = {"time_period": None}
+        for key, value in settings.items():
+            self.settings[key] = value
+
+    def execute(self):
+        self.file.remove(self.settings["time_period"])

src/ifcopenshell-python/ifcopenshell/api/sequence/remove_work_calendar.py

@@ -1,3 +1,6 @@
+import ifcopenshell
+
+
 class Usecase:
     def __init__(self, file, **settings):
         self.file = file

src/ifcopenshell-python/ifcopenshell/api/sequence/remove_work_plan.py

@@ -1,3 +1,6 @@
+import ifcopenshell
+
+
 class Usecase:
     def __init__(self, file, **settings):
         self.file = file

src/ifcopenshell-python/ifcopenshell/api/sequence/remove_work_time.py

@@ -0,0 +1,9 @@
+class Usecase:
+    def __init__(self, file, **settings):
+        self.file = file
+        self.settings = {"work_time": None}
+        for key, value in settings.items():
+            self.settings[key] = value
+
+    def execute(self):
+        self.file.remove(self.settings["work_time"])

src/ifcopenshell-python/ifcopenshell/api/sequence/unassign_recurrence_pattern.py

@@ -0,0 +1,12 @@
+import ifcopenshell.api
+
+
+class Usecase:
+    def __init__(self, file, **settings):
+        self.file = file
+        self.settings = {"recurrence_pattern": None}
+        for key, value in settings.items():
+            self.settings[key] = value
+
+    def execute(self):
+        self.file.remove(self.settings["recurrence_pattern"])

src/ifcopenshell-python/ifcopenshell/geom/main.py

@@ -134,6 +134,9 @@ class tree(ifcopenshell_wrapper.tree):
 
     def add_file(self, file, settings):
         ifcopenshell_wrapper.tree.add_file(self, file.wrapped_data, settings)
+        
+    def add_iterator(self, iterator):
+        ifcopenshell_wrapper.tree.add_file(self, iterator)
 
     def select(self, value, **kwargs):
         def unwrap(value):

src/ifcopenshell-python/ifcopenshell/ids.py

@@ -79,6 +79,7 @@ class entity(facet):
     """
     The IDS entity facet currently *with* inheritance
     """
+
     parameters = ["name", "predefinedtype"]
     
     def __call__(self, inst, logger):

src/ifcopenshell-python/ifcopenshell/util/date.py

@@ -1,5 +1,5 @@
+import datetime
 from re import findall
-from datetime import datetime
 
 
 def duration2dict(duration):
@@ -12,12 +12,16 @@ def duration2dict(duration):
 def ifc2datetime(element):
     if isinstance(element, str) and element[0] == "P":  # IfcDuration
         return duration2dict(element)
-    elif isinstance(element, str):  # IfcDateTime, IfcDate
-        return datetime.fromisoformat(element)
+    elif isinstance(element, str) and element[2] == ":":  # IfcTime
+        return datetime.time.fromisoformat(element)
+    elif isinstance(element, str) and ":" in element:  # IfcDateTime
+        return datetime.datetime.fromisoformat(element)
+    elif isinstance(element, str):  # IfcDate
+        return datetime.date.fromisoformat(element)
     elif isinstance(element, int):  # IfcTimeStamp
-        return datetime.fromtimestamp(element)
+        return datetime.datetime.fromtimestamp(element)
     elif element.is_a("IfcDateAndTime"):
-        return datetime(
+        return datetime.datetime(
             element.DateComponent.YearComponent,
             element.DateComponent.MonthComponent,
             element.DateComponent.DayComponent,
@@ -27,7 +31,7 @@ def ifc2datetime(element):
             # TODO: implement TimeComponent timezone
         )
     elif element.is_a("IfcCalendarDate"):
-        return datetime(
+        return datetime.date(
             element.YearComponent,
             element.MonthComponent,
             element.DayComponent,
@@ -36,15 +40,24 @@ def ifc2datetime(element):
 
 def datetime2ifc(dt, ifc_type):
     if isinstance(dt, str):
-        dt = datetime.fromisoformat(dt)
+        dt = datetime.datetime.fromisoformat(dt)
     if ifc_type == "IfcTimeStamp":
         return int(dt.timestamp())
     elif ifc_type == "IfcDateTime":
-        return dt.isoformat()
+        if isinstance(dt, datetime.datetime):
+            return dt.isoformat()
+        elif isinstance(dt, datetime.date):
+            return datetime.datetime.combine(dt, datetime.datetime.min.time()).isoformat()
     elif ifc_type == "IfcDate":
-        return dt.date().isoformat()
+        if isinstance(dt, datetime.datetime):
+            return dt.date().isoformat()
+        elif isinstance(dt, datetime.date):
+            return dt.isoformat()
     elif ifc_type == "IfcTime":
-        return dt.time().isoformat()
+        if isinstance(dt, datetime.datetime):
+            return dt.time().isoformat()
+        elif isinstance(dt, datetime.time):
+            return dt.isoformat()
     elif ifc_type == "IfcCalendarDate":
         return {"DayComponent": dt.day, "MonthComponent": dt.month, "YearComponent": dt.year}
     elif ifc_type == "IfcLocalTime":

src/ifcopenshell-python/ifcopenshell/util/pset.py

@@ -6,6 +6,15 @@ from typing import List, Generator, Optional
 import ifcopenshell
 from ifcopenshell.entity_instance import entity_instance
 
+templates = {}
+
+
+def get_template(schema):
+    global templates
+    if schema not in templates:
+        templates[schema] = PsetQto(schema)
+    return templates[schema]
+
 
 class PsetQto:
     templates_path = {