feat: updated script and operators

Author: moe-ad

src/ansys/dpf/core/operators/averaging/elemental_difference.py

@@ -14,6 +14,12 @@
 from ansys.dpf.core.config import Config
 from ansys.dpf.core.server_types import AnyServerType
 
+# For type checking
+from ansys.dpf.core.fields_container import FieldsContainer
+from ansys.dpf.core.scoping import Scoping
+from ansys.dpf.core.field import Field
+from ansys.dpf.core.meshed_region import MeshedRegion
+
 
 class elemental_difference(Operator):
     r"""Transforms an Elemental Nodal or Nodal field into an Elemental field.
@@ -199,19 +205,25 @@ class InputsElementalDifference(_Inputs):
 
     def __init__(self, op: Operator):
         super().__init__(elemental_difference._spec().inputs, op)
-        self._field = Input(elemental_difference._spec().input_pin(0), 0, op, -1)
+        self._field: Input[Field | FieldsContainer] = Input(
+            elemental_difference._spec().input_pin(0), 0, op, -1
+        )
         self._inputs.append(self._field)
-        self._mesh_scoping = Input(elemental_difference._spec().input_pin(1), 1, op, -1)
+        self._mesh_scoping: Input[Scoping] = Input(
+            elemental_difference._spec().input_pin(1), 1, op, -1
+        )
         self._inputs.append(self._mesh_scoping)
-        self._mesh = Input(elemental_difference._spec().input_pin(7), 7, op, -1)
+        self._mesh: Input[MeshedRegion] = Input(
+            elemental_difference._spec().input_pin(7), 7, op, -1
+        )
         self._inputs.append(self._mesh)
-        self._through_layers = Input(
+        self._through_layers: Input[bool] = Input(
             elemental_difference._spec().input_pin(10), 10, op, -1
         )
         self._inputs.append(self._through_layers)
 
     @property
-    def field(self) -> Input:
+    def field(self) -> Input[Field | FieldsContainer]:
         r"""Allows to connect field input to the operator.
 
         field or fields container with only one field is expected
@@ -232,7 +244,7 @@ def field(self) -> Input:
         return self._field
 
     @property
-    def mesh_scoping(self) -> Input:
+    def mesh_scoping(self) -> Input[Scoping]:
         r"""Allows to connect mesh_scoping input to the operator.
 
         average only on these entities
@@ -253,7 +265,7 @@ def mesh_scoping(self) -> Input:
         return self._mesh_scoping
 
     @property
-    def mesh(self) -> Input:
+    def mesh(self) -> Input[MeshedRegion]:
         r"""Allows to connect mesh input to the operator.
 
         Returns
@@ -272,7 +284,7 @@ def mesh(self) -> Input:
         return self._mesh
 
     @property
-    def through_layers(self) -> Input:
+    def through_layers(self) -> Input[bool]:
         r"""Allows to connect through_layers input to the operator.
 
         The maximum elemental difference is taken through the different shell layers if true (default is false).
@@ -307,11 +319,13 @@ class OutputsElementalDifference(_Outputs):
 
     def __init__(self, op: Operator):
         super().__init__(elemental_difference._spec().outputs, op)
-        self._field = Output(elemental_difference._spec().output_pin(0), 0, op)
+        self._field: Output[Field] = Output(
+            elemental_difference._spec().output_pin(0), 0, op
+        )
         self._outputs.append(self._field)
 
     @property
-    def field(self) -> Output:
+    def field(self) -> Output[Field]:
         r"""Allows to get field output of the operator
 
         Returns

src/ansys/dpf/core/operators/averaging/elemental_difference_fc.py

@@ -14,6 +14,13 @@
 from ansys.dpf.core.config import Config
 from ansys.dpf.core.server_types import AnyServerType
 
+# For type checking
+from ansys.dpf.core.fields_container import FieldsContainer
+from ansys.dpf.core.scoping import Scoping
+from ansys.dpf.core.scopings_container import ScopingsContainer
+from ansys.dpf.core.meshes_container import MeshesContainer
+from ansys.dpf.core.meshed_region import MeshedRegion
+
 
 class elemental_difference_fc(Operator):
     r"""Transforms an Elemental Nodal or Nodal field into an Elemental field.
@@ -205,21 +212,25 @@ class InputsElementalDifferenceFc(_Inputs):
 
     def __init__(self, op: Operator):
         super().__init__(elemental_difference_fc._spec().inputs, op)
-        self._fields_container = Input(
+        self._fields_container: Input[FieldsContainer] = Input(
             elemental_difference_fc._spec().input_pin(0), 0, op, -1
         )
         self._inputs.append(self._fields_container)
-        self._mesh = Input(elemental_difference_fc._spec().input_pin(1), 1, op, -1)
+        self._mesh: Input[MeshedRegion | MeshesContainer] = Input(
+            elemental_difference_fc._spec().input_pin(1), 1, op, -1
+        )
         self._inputs.append(self._mesh)
-        self._scoping = Input(elemental_difference_fc._spec().input_pin(3), 3, op, -1)
+        self._scoping: Input[Scoping | ScopingsContainer] = Input(
+            elemental_difference_fc._spec().input_pin(3), 3, op, -1
+        )
         self._inputs.append(self._scoping)
-        self._collapse_shell_layers = Input(
+        self._collapse_shell_layers: Input[bool] = Input(
             elemental_difference_fc._spec().input_pin(10), 10, op, -1
         )
         self._inputs.append(self._collapse_shell_layers)
 
     @property
-    def fields_container(self) -> Input:
+    def fields_container(self) -> Input[FieldsContainer]:
         r"""Allows to connect fields_container input to the operator.
 
         Returns
@@ -238,7 +249,7 @@ def fields_container(self) -> Input:
         return self._fields_container
 
     @property
-    def mesh(self) -> Input:
+    def mesh(self) -> Input[MeshedRegion | MeshesContainer]:
         r"""Allows to connect mesh input to the operator.
 
         The mesh region in this pin is used to perform the averaging, used if there is no fields support.
@@ -259,7 +270,7 @@ def mesh(self) -> Input:
         return self._mesh
 
     @property
-    def scoping(self) -> Input:
+    def scoping(self) -> Input[Scoping | ScopingsContainer]:
         r"""Allows to connect scoping input to the operator.
 
         Average only on these elements. If it is scoping container, the label must correspond to the one of the fields container.
@@ -280,7 +291,7 @@ def scoping(self) -> Input:
         return self._scoping
 
     @property
-    def collapse_shell_layers(self) -> Input:
+    def collapse_shell_layers(self) -> Input[bool]:
         r"""Allows to connect collapse_shell_layers input to the operator.
 
         If true, the data across different shell layers is averaged as well (default is false).
@@ -315,13 +326,13 @@ class OutputsElementalDifferenceFc(_Outputs):
 
     def __init__(self, op: Operator):
         super().__init__(elemental_difference_fc._spec().outputs, op)
-        self._fields_container = Output(
+        self._fields_container: Output[FieldsContainer] = Output(
             elemental_difference_fc._spec().output_pin(0), 0, op
         )
         self._outputs.append(self._fields_container)
 
     @property
-    def fields_container(self) -> Output:
+    def fields_container(self) -> Output[FieldsContainer]:
         r"""Allows to get fields_container output of the operator
 
         Returns

src/ansys/dpf/core/operators/averaging/elemental_fraction_fc.py

@@ -14,6 +14,11 @@
 from ansys.dpf.core.config import Config
 from ansys.dpf.core.server_types import AnyServerType
 
+# For type checking
+from ansys.dpf.core.fields_container import FieldsContainer
+from ansys.dpf.core.scoping import Scoping
+from ansys.dpf.core.meshed_region import MeshedRegion
+
 
 class elemental_fraction_fc(Operator):
     r"""Transforms Elemental Nodal fields into Elemental fields. Each elemental
@@ -213,23 +218,29 @@ class InputsElementalFractionFc(_Inputs):
 
     def __init__(self, op: Operator):
         super().__init__(elemental_fraction_fc._spec().inputs, op)
-        self._fields_container = Input(
+        self._fields_container: Input[FieldsContainer] = Input(
             elemental_fraction_fc._spec().input_pin(0), 0, op, -1
         )
         self._inputs.append(self._fields_container)
-        self._mesh = Input(elemental_fraction_fc._spec().input_pin(1), 1, op, -1)
+        self._mesh: Input[MeshedRegion] = Input(
+            elemental_fraction_fc._spec().input_pin(1), 1, op, -1
+        )
         self._inputs.append(self._mesh)
-        self._scoping = Input(elemental_fraction_fc._spec().input_pin(3), 3, op, -1)
+        self._scoping: Input[Scoping] = Input(
+            elemental_fraction_fc._spec().input_pin(3), 3, op, -1
+        )
         self._inputs.append(self._scoping)
-        self._denominator = Input(elemental_fraction_fc._spec().input_pin(6), 6, op, -1)
+        self._denominator: Input[FieldsContainer] = Input(
+            elemental_fraction_fc._spec().input_pin(6), 6, op, -1
+        )
         self._inputs.append(self._denominator)
-        self._collapse_shell_layers = Input(
+        self._collapse_shell_layers: Input[bool] = Input(
             elemental_fraction_fc._spec().input_pin(10), 10, op, -1
         )
         self._inputs.append(self._collapse_shell_layers)
 
     @property
-    def fields_container(self) -> Input:
+    def fields_container(self) -> Input[FieldsContainer]:
         r"""Allows to connect fields_container input to the operator.
 
         Returns
@@ -248,7 +259,7 @@ def fields_container(self) -> Input:
         return self._fields_container
 
     @property
-    def mesh(self) -> Input:
+    def mesh(self) -> Input[MeshedRegion]:
         r"""Allows to connect mesh input to the operator.
 
         The mesh region in this pin is used to perform the averaging. It is used if there is no fields support.
@@ -269,7 +280,7 @@ def mesh(self) -> Input:
         return self._mesh
 
     @property
-    def scoping(self) -> Input:
+    def scoping(self) -> Input[Scoping]:
         r"""Allows to connect scoping input to the operator.
 
         Average only on these elements. If it is a scoping container, the label must correspond to the one of the fields containers.
@@ -290,7 +301,7 @@ def scoping(self) -> Input:
         return self._scoping
 
     @property
-    def denominator(self) -> Input:
+    def denominator(self) -> Input[FieldsContainer]:
         r"""Allows to connect denominator input to the operator.
 
         If a fields container is set in this pin, it is used as the denominator of the fraction instead of entity_average_fc.
@@ -311,7 +322,7 @@ def denominator(self) -> Input:
         return self._denominator
 
     @property
-    def collapse_shell_layers(self) -> Input:
+    def collapse_shell_layers(self) -> Input[bool]:
         r"""Allows to connect collapse_shell_layers input to the operator.
 
         If true, the data across different shell layers is averaged as well (default is false).
@@ -346,13 +357,13 @@ class OutputsElementalFractionFc(_Outputs):
 
     def __init__(self, op: Operator):
         super().__init__(elemental_fraction_fc._spec().outputs, op)
-        self._fields_container = Output(
+        self._fields_container: Output[FieldsContainer] = Output(
             elemental_fraction_fc._spec().output_pin(0), 0, op
         )
         self._outputs.append(self._fields_container)
 
     @property
-    def fields_container(self) -> Output:
+    def fields_container(self) -> Output[FieldsContainer]:
         r"""Allows to get fields_container output of the operator
 
         Returns

src/ansys/dpf/core/operators/averaging/elemental_mean.py

@@ -14,6 +14,10 @@
 from ansys.dpf.core.config import Config
 from ansys.dpf.core.server_types import AnyServerType
 
+# For type checking
+from ansys.dpf.core.field import Field
+from ansys.dpf.core.scoping import Scoping
+
 
 class elemental_mean(Operator):
     r"""Computes the average of a multi-entity field, (ElementalNodal ->
@@ -195,19 +199,25 @@ class InputsElementalMean(_Inputs):
 
     def __init__(self, op: Operator):
         super().__init__(elemental_mean._spec().inputs, op)
-        self._field = Input(elemental_mean._spec().input_pin(0), 0, op, -1)
+        self._field: Input[Field] = Input(
+            elemental_mean._spec().input_pin(0), 0, op, -1
+        )
         self._inputs.append(self._field)
-        self._collapse_shell_layers = Input(
+        self._collapse_shell_layers: Input[bool] = Input(
             elemental_mean._spec().input_pin(1), 1, op, -1
         )
         self._inputs.append(self._collapse_shell_layers)
-        self._force_averaging = Input(elemental_mean._spec().input_pin(2), 2, op, -1)
+        self._force_averaging: Input[bool] = Input(
+            elemental_mean._spec().input_pin(2), 2, op, -1
+        )
         self._inputs.append(self._force_averaging)
-        self._scoping = Input(elemental_mean._spec().input_pin(3), 3, op, -1)
+        self._scoping: Input[Scoping] = Input(
+            elemental_mean._spec().input_pin(3), 3, op, -1
+        )
         self._inputs.append(self._scoping)
 
     @property
-    def field(self) -> Input:
+    def field(self) -> Input[Field]:
         r"""Allows to connect field input to the operator.
 
         Returns
@@ -226,7 +236,7 @@ def field(self) -> Input:
         return self._field
 
     @property
-    def collapse_shell_layers(self) -> Input:
+    def collapse_shell_layers(self) -> Input[bool]:
         r"""Allows to connect collapse_shell_layers input to the operator.
 
         If true, shell layers are averaged as well (default is false).
@@ -247,7 +257,7 @@ def collapse_shell_layers(self) -> Input:
         return self._collapse_shell_layers
 
     @property
-    def force_averaging(self) -> Input:
+    def force_averaging(self) -> Input[bool]:
         r"""Allows to connect force_averaging input to the operator.
 
         If true you average, if false you just sum.
@@ -268,7 +278,7 @@ def force_averaging(self) -> Input:
         return self._force_averaging
 
     @property
-    def scoping(self) -> Input:
+    def scoping(self) -> Input[Scoping]:
         r"""Allows to connect scoping input to the operator.
 
         Average only on these elements. If it is a scoping container, the label must correspond to the one of the fields containers.
@@ -303,11 +313,11 @@ class OutputsElementalMean(_Outputs):
 
     def __init__(self, op: Operator):
         super().__init__(elemental_mean._spec().outputs, op)
-        self._field = Output(elemental_mean._spec().output_pin(0), 0, op)
+        self._field: Output[Field] = Output(elemental_mean._spec().output_pin(0), 0, op)
         self._outputs.append(self._field)
 
     @property
-    def field(self) -> Output:
+    def field(self) -> Output[Field]:
         r"""Allows to get field output of the operator
 
         Returns