Allow for passing IFC Schema attributes on API methods

src/ifcopenshell-python/ifcopenshell/api/__init__.py

@@ -17,8 +17,11 @@
 # along with IfcOpenShell.  If not, see <http://www.gnu.org/licenses/>.
 
 """High level user-oriented IFC authoring capabilities"""
-
-import json
+import os
+import inspect
+from pathlib import Path
+from collections import defaultdict
+from typing import DefaultDict
 import numpy
 import importlib
 import ifcopenshell
@@ -29,7 +32,7 @@
 post_listeners = {}
 
 
-def run(usecase_path, ifc_file=None, should_run_listeners=True, **settings):
+def run(usecase_path, ifc_file=None, on_static_version=None, should_run_listeners=True, **settings):
     if should_run_listeners:
         for listener in pre_listeners.get(usecase_path, {}).values():
             listener(usecase_path, ifc_file, settings)
@@ -58,9 +61,11 @@ def serialise_entity_instance(entity):
         # except:
         #    print(usecase_path, vcs_settings)
 
-    importlib.import_module(f"ifcopenshell.api.{usecase_path}")
+    api_path = f"api_{on_static_version}" if on_static_version else "api"
+    importlib.import_module(f"ifcopenshell.{api_path}")
+    importlib.import_module(f"ifcopenshell.{api_path}.{usecase_path}")
     module, usecase = usecase_path.split(".")
-    usecase_class = getattr(getattr(getattr(ifcopenshell.api, module), usecase), "Usecase")
+    usecase_class = getattr(getattr(getattr(getattr(ifcopenshell, api_path), module), usecase), "Usecase")
 
     if ifc_file:
         result = usecase_class(ifc_file, **settings).execute()
@@ -167,3 +172,17 @@ def extract_docs(module, usecase):
     node_data["description"] = description.strip()
     node_data["inputs"] = inputs
     return node_data
+
+
+def list_actions() -> DefaultDict[str, list[str]]:
+    actions_to_exclude: list[str] = ["__init__", "settings", "multischema"]
+    api_actions: DefaultDict[str, list[str]] = defaultdict(list)
+    ios_dir = Path(os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe()))))
+
+    for path in ios_dir.glob("*/*.py"):
+        if (action := path.stem) in actions_to_exclude:
+            continue
+        module = path.parent.name
+        api_actions[module].append(action)
+
+    return api_actions

src/ifcopenshell-python/ifcopenshell/api/material/add_layer.py

@@ -16,76 +16,80 @@
 # You should have received a copy of the GNU Lesser General Public License
 # along with IfcOpenShell.  If not, see <http://www.gnu.org/licenses/>.
 
+from __future__ import annotations
+from dataclasses import dataclass
+import ifcopenshell
+from ifcopenshell.util.schema import with_schema_attrs
 
+
+@with_schema_attrs(ifc_class="IfcMaterialLayer", defaults={"LayerThickness": 1.})
+@dataclass
 class Usecase:
-    def __init__(self, file, layer_set=None, material=None):
-        """Adds a new layer to a layer set
+    """Adds a new layer to a layer set
 
-        A layer represents a portion of material within a layered build up,
-        defined by a thickness. Typical layered construction includes walls and
-        slabs, where a wall might include a layer of finish, a layer of
-        structure, a layer of insulation, and so on. It is recommended to define
-        layered construction this way where it is unnecessary to define the
-        exact geometry of how the wall or slab will be built, and it will
-        instead be determined on site by a trade.
+    A layer represents a portion of material within a layered build up,
+    defined by a thickness. Typical layered construction includes walls and
+    slabs, where a wall might include a layer of finish, a layer of
+    structure, a layer of insulation, and so on. It is recommended to define
+    layered construction this way where it is unnecessary to define the
+    exact geometry of how the wall or slab will be built, and it will
+    instead be determined on site by a trade.
 
-        Layers are defined in a particular order and thickness, so that it is
-        clear which layer comes next.
+    Layers are defined in a particular order and thickness, so that it is
+    clear which layer comes next.
 
-        :param layer_set: The IfcMaterialLayerSet that the layer is part of. The
-            layer set represents a group of layers. See
-            ifcopenshell.api.material.add_material_set for more information on
-            how to add a layer set.
-        :type layer_set: ifcopenshell.entity_instance.entity_instance
-        :param material: The IfcMaterial that the layer is made out of.
-        :type material: ifcopenshell.entity_instance.entity_instance
-        :return: The newly created IfcMaterialLayer
-        :rtype: ifcopenshell.entity_instance.entity_instance
+    :param layer_set: The IfcMaterialLayerSet that the layer is part of. The
+        layer set represents a group of layers. See
+        ifcopenshell.api.material.add_material_set for more information on
+        how to add a layer set.
+    :type layer_set: ifcopenshell.entity_instance.entity_instance
+    :param material: The IfcMaterial that the layer is made out of.
+    :type material: ifcopenshell.entity_instance.entity_instance
+    :return: The newly created IfcMaterialLayer
+    :rtype: ifcopenshell.entity_instance.entity_instance
 
-        Example:
+    Example:
 
-        .. code:: python
+    .. code:: python
 
-            # Let's imagine we have a wall type that has two layers of
-            # gypsum with steel studs inside. Notice we are assigning to
-            # the type only, as all occurrences of that type will automatically
-            # inherit the material.
-            wall_type = ifcopenshell.api.run("root.create_entity", model, ifc_class="IfcWallType", name="WAL01")
+        # Let's imagine we have a wall type that has two layers of
+        # gypsum with steel studs inside. Notice we are assigning to
+        # the type only, as all occurrences of that type will automatically
+        # inherit the material.
+        wall_type = ifcopenshell.api.run("root.create_entity", model, ifc_class="IfcWallType", name="WAL01")
 
-            # First, let's create a material set. This will later be assigned
-            # to our wall type element.
-            material_set = ifcopenshell.api.run("material.add_material_set", model,
-                name="GYP-ST-GYP", set_type="IfcMaterialLayerSet")
+        # First, let's create a material set. This will later be assigned
+        # to our wall type element.
+        material_set = ifcopenshell.api.run("material.add_material_set", model,
+            name="GYP-ST-GYP", set_type="IfcMaterialLayerSet")
 
-            # Let's create a few materials, it's important to also give them
-            # categories. This makes it easy for model recipients to do things
-            # like "show me everything made out of aluminium / concrete / steel
-            # / glass / etc". The IFC specification states a list of categories
-            # you can use.
-            gypsum = ifcopenshell.api.run("material.add_material", model, name="PB01", category="gypsum")
-            steel = ifcopenshell.api.run("material.add_material", model, name="ST01", category="steel")
+        # Let's create a few materials, it's important to also give them
+        # categories. This makes it easy for model recipients to do things
+        # like "show me everything made out of aluminium / concrete / steel
+        # / glass / etc". The IFC specification states a list of categories
+        # you can use.
+        gypsum = ifcopenshell.api.run("material.add_material", model, name="PB01", category="gypsum")
+        steel = ifcopenshell.api.run("material.add_material", model, name="ST01", category="steel")
 
-            # Now let's use those materials as three layers in our set, such
-            # that the steel studs are sandwiched by the gypsum. Let's imagine
-            # we're setting the layer thickness in millimeters.
-            layer = ifcopenshell.api.run("material.add_layer", model, layer_set=material_set, material=gypsum)
-            ifcopenshell.api.run("material.edit_layer", model, layer=layer, attributes={"LayerThickness": 13})
-            layer = ifcopenshell.api.run("material.add_layer", model, layer_set=material_set, material=steel)
-            ifcopenshell.api.run("material.edit_layer", model, layer=layer, attributes={"LayerThickness": 92})
-            layer = ifcopenshell.api.run("material.add_layer", model, layer_set=material_set, material=gypsum)
-            ifcopenshell.api.run("material.edit_layer", model, layer=layer, attributes={"LayerThickness": 13})
+        # Now let's use those materials as three layers in our set, such
+        # that the steel studs are sandwiched by the gypsum. Let's imagine
+        # we're setting the layer thickness in millimeters.
+        layer = ifcopenshell.api.run("material.add_layer", model, layer_set=material_set, material=gypsum)
+        ifcopenshell.api.run("material.edit_layer", model, layer=layer, attributes={"LayerThickness": 13})
+        layer = ifcopenshell.api.run("material.add_layer", model, layer_set=material_set, material=steel)
+        ifcopenshell.api.run("material.edit_layer", model, layer=layer, attributes={"LayerThickness": 92})
+        layer = ifcopenshell.api.run("material.add_layer", model, layer_set=material_set, material=gypsum)
+        ifcopenshell.api.run("material.edit_layer", model, layer=layer, attributes={"LayerThickness": 13})
 
-            # Great! Let's assign our material set to our wall type.
-            ifcopenshell.api.run("material.assign_material", model, product=wall_type, material=material_set)
-        """
-        self.file = file
-        self.settings = {"layer_set": layer_set, "material": material}
+        # Great! Let's assign our material set to our wall type.
+        ifcopenshell.api.run("material.assign_material", model, product=wall_type, material=material_set)
+    """
+    file: ifcopenshell.file
+    layer_set: ifcopenshell.entity_instance
 
-    def execute(self):
-        layers = list(self.settings["layer_set"].MaterialLayers or [])
-        layer = self.file.create_entity(
-            "IfcMaterialLayer", **{"Material": self.settings["material"], "LayerThickness": 1.0}
-        )
+    def execute(self) -> ifcopenshell.entity_instance:
+        layers = list(self.layer_set.MaterialLayers or [])
+        layer = self.file.create_entity("IfcMaterialLayer", **self.schema_attrs())
         layers.append(layer)
-        self.settings["layer_set"].MaterialLayers = layers
+        self.layer_set.MaterialLayers = layers
         return layer