Pin aliases

src/ansys/dpf/core/dpf_operator.py

@@ -680,7 +680,7 @@ def id(self) -> int:
         return self._id
 
     @property
-    def inputs(self):
+    def inputs(self) -> Inputs:
         """Inputs connected to the operator.
 
         Returns
@@ -702,7 +702,7 @@ def inputs(self):
         return self._inputs
 
     @property
-    def outputs(self):
+    def outputs(self) -> Outputs:
         """Outputs from the operator's evaluation.
 
         Returns

src/ansys/dpf/core/inputs.py

@@ -63,6 +63,7 @@
                 self._python_expected_types.append(map_types_to_python[cpp_type])
         if len(self._spec.type_names) == 0:
             self._python_expected_types.append("Any")
+        self.aliases = self._spec.aliases
         docstr = self.__str__()
         self.name = self._spec.name
         if self._count_ellipsis != -1:
@@ -187,6 +188,8 @@
             docstr += "\n".join(wrap(self._spec.document.capitalize())) + "\n"
         if self._count_ellipsis >= 0:
             docstr += "is ellipsis\n"
+        if self.aliases:
+            docstr += f"aliases: {self.aliases}\n"
         return docstr
 
     def __inc_if_ellipsis(self):
@@ -317,6 +320,9 @@
     def __call__(self, inpt):
         self.connect(inpt)
 
+    def __getitem__(self, item) -> Input:
+        return self._inputs[item]
+
 
 # Dynamic class Inputs
 class Inputs(_Inputs):

src/ansys/dpf/core/operator_specification.py

@@ -78,6 +78,7 @@ class PinSpecification:
     optional: bool
     ellipsis: bool
     name_derived_class = str
+    aliases: list[str]
 
     def __init__(
         self,
@@ -87,13 +88,15 @@ def __init__(
         optional=False,
         ellipsis=False,
         name_derived_class="",
+        aliases=[],
     ):
         self.name = name
         self.type_names = type_names
         self.optional = optional
         self.document = document
         self.ellipsis = ellipsis
         self.name_derived_class = name_derived_class
+        self.aliases = aliases
 
     @property
     def type_names(self) -> list[str]:
@@ -140,6 +143,7 @@ def _get_copy(other, changed_types) -> PinSpecification:
             other.optional,
             other.ellipsis,
             other.name_derived_class,
+            other.aliases,
         )
 
     def __repr__(self):
@@ -367,7 +371,7 @@ def description(self) -> str:
         return ""
 
     @property
-    def inputs(self) -> dict:
+    def inputs(self) -> dict[int, PinSpecification]:
         """Returns a dictionary mapping the input pin numbers to their ``PinSpecification``.
 
         Returns
@@ -382,15 +386,15 @@ def inputs(self) -> dict:
         True
         >>> operator.specification.inputs[4]
         PinSpecification(name='data_sources', _type_names=['data_sources'], ...set', ellipsis=False,
-         name_derived_class='')
+         name_derived_class='', aliases=[...])
         """
         if self._map_input_pin_spec is None:
             self._map_input_pin_spec = {}
             self._fill_pins(True, self._map_input_pin_spec)
         return self._map_input_pin_spec
 
     @property
-    def outputs(self) -> dict:
+    def outputs(self) -> dict[int, PinSpecification]:
         """Returns a dictionary mapping the output pin numbers to their ``PinSpecification``.
 
         Returns
@@ -403,7 +407,7 @@ def outputs(self) -> dict:
         >>> operator = dpf.operators.mesh.mesh_provider()
         >>> operator.specification.outputs
         {0: PinSpecification(name='mesh', _type_names=['abstract_meshed_region'], ...=False,
-         name_derived_class='')}
+         name_derived_class='', aliases=[...])}
         """
         if self._map_output_pin_spec is None:
             self._map_output_pin_spec = {}
@@ -429,7 +433,18 @@ def _fill_pins(self, binput, to_fill):
                     self._api.operator_specification_get_pin_type_name(self, binput, i_pin, i_type)
                     for i_type in range(n_types)
                 ]
-
+                pin_aliases = []
+                if server_meet_version("10.0", self._server) and hasattr(
+                    self._api, "operator_specification_get_pin_num_aliases"
+                ):
+                    for i_alias in range(
+                        self._api.operator_specification_get_pin_num_aliases(self, binput, i_pin)
+                    ):
+                        pin_aliases.append(
+                            self._api.operator_specification_get_pin_alias(
+                                self, binput, i_pin, i_alias
+                            )
+                        )
                 pin_derived_class_type_name = ""
                 if server_meet_version("7.0", self._server) and hasattr(
                     self._api, "operator_specification_get_pin_derived_class_type_name"
@@ -448,6 +463,7 @@ def _fill_pins(self, binput, to_fill):
                     pin_opt,
                     pin_ell,
                     pin_derived_class_type_name,
+                    pin_aliases,
                 )
 
     @property

src/ansys/dpf/core/operators/build.py

@@ -101,6 +101,9 @@ def build_pin_data(pins, output=False):
             "document": document,
             "document_pin_docstring": document_pin_docstring,
             "ellipsis": 0 if specification.ellipsis else -1,
+            "has_aliases": len(specification.aliases) > 0,
+            "aliases_list": [dict([("alias", alias)]) for alias in specification.aliases],
+            "aliases": str(specification.aliases),
         }
 
         if specification.ellipsis:
@@ -127,11 +130,13 @@ def build_operator(
     input_pins = []
     if specification.inputs:
         input_pins = build_pin_data(specification.inputs)
+    has_input_aliases = any(len(pin["aliases_list"]) > 0 for pin in input_pins)
 
     output_pins = []
     if specification.outputs:
         output_pins = build_pin_data(specification.outputs, output=True)
     multiple_output_types = any(pin["multiple_types"] for pin in output_pins)
+    has_output_aliases = any(len(pin["aliases_list"]) > 0 for pin in output_pins)
 
     docstring = build_docstring(specification_description)
 
@@ -150,6 +155,8 @@ def build_operator(
         "multiple_output_types": multiple_output_types,
         "category": category,
         "date_and_time": date_and_time,
+        "has_input_aliases": has_input_aliases,
+        "has_output_aliases": has_output_aliases,
     }
 
     this_path = os.path.dirname(os.path.abspath(__file__))
@@ -164,7 +171,7 @@ def build_operator(
 
 
 def build_operators():
-    print(f"Generating operators for server {dpf.SERVER.version}")
+    print(f"Generating operators for server {dpf.SERVER.version} ({dpf.SERVER.ansys_path})")
     time_0 = time.time()
 
     this_path = os.path.dirname(os.path.abspath(__file__))
@@ -228,6 +235,7 @@ def build_operators():
         # Write to operator file
         operator_file = os.path.join(category_path, scripting_name + ".py")
         with open(operator_file, "wb") as f:
+            operator_str = scripting_name
             try:
                 operator_str = build_operator(
                     specification,

src/ansys/dpf/core/operators/math/accumulate.py

@@ -61,7 +61,13 @@ class accumulate(Operator):
     """
 
     def __init__(
-        self, fieldA=None, weights=None, time_scoping=None, config=None, server=None
+        self,
+        fieldA=None,
+        weights=None,
+        time_scoping=None,
+        config=None,
+        server=None,
+        ponderation=None,
     ):
         super().__init__(name="accumulate", config=config, server=server)
         self._inputs = InputsAccumulate(self)
@@ -70,6 +76,13 @@ def __init__(
             self.inputs.fieldA.connect(fieldA)
         if weights is not None:
             self.inputs.weights.connect(weights)
+        elif ponderation is not None:
+            warn(
+                DeprecationWarning(
+                    f'Operator accumulate: Input name "ponderation" is deprecated in favor of "weights".'
+                )
+            )
+            self.inputs.weights.connect(ponderation)
         if time_scoping is not None:
             self.inputs.time_scoping.connect(time_scoping)
 
@@ -92,6 +105,7 @@ def _spec() -> Specification:
                     type_names=["field"],
                     optional=True,
                     document=r"""Field containing weights, one weight per entity""",
+                    aliases=["ponderation"],
                 ),
                 2: PinSpecification(
                     name="time_scoping",
@@ -243,6 +257,18 @@ def time_scoping(self) -> Input:
         """
         return self._time_scoping
 
+    def __getattr__(self, name):
+        if name in ["ponderation"]:
+            warn(
+                DeprecationWarning(
+                    f'Operator accumulate: Input name "{name}" is deprecated in favor of "weights".'
+                )
+            )
+            return self.weights
+        raise AttributeError(
+            f"'{self.__class__.__name__}' object has no attribute '{name}'."
+        )
+
 
 class OutputsAccumulate(_Outputs):
     """Intermediate class used to get outputs from

src/ansys/dpf/core/operators/math/accumulate_fc.py

@@ -67,6 +67,7 @@ def __init__(
         time_scoping=None,
         config=None,
         server=None,
+        ponderation=None,
     ):
         super().__init__(name="accumulate_fc", config=config, server=server)
         self._inputs = InputsAccumulateFc(self)
@@ -75,6 +76,13 @@ def __init__(
             self.inputs.fields_container.connect(fields_container)
         if weights is not None:
             self.inputs.weights.connect(weights)
+        elif ponderation is not None:
+            warn(
+                DeprecationWarning(
+                    f'Operator accumulate_fc: Input name "ponderation" is deprecated in favor of "weights".'
+                )
+            )
+            self.inputs.weights.connect(ponderation)
         if time_scoping is not None:
             self.inputs.time_scoping.connect(time_scoping)
 
@@ -97,6 +105,7 @@ def _spec() -> Specification:
                     type_names=["field"],
                     optional=True,
                     document=r"""Field containing weights, one weight per entity""",
+                    aliases=["ponderation"],
                 ),
                 2: PinSpecification(
                     name="time_scoping",
@@ -248,6 +257,18 @@ def time_scoping(self) -> Input:
         """
         return self._time_scoping
 
+    def __getattr__(self, name):
+        if name in ["ponderation"]:
+            warn(
+                DeprecationWarning(
+                    f'Operator accumulate_fc: Input name "{name}" is deprecated in favor of "weights".'
+                )
+            )
+            return self.weights
+        raise AttributeError(
+            f"'{self.__class__.__name__}' object has no attribute '{name}'."
+        )
+
 
 class OutputsAccumulateFc(_Outputs):
     """Intermediate class used to get outputs from

src/ansys/dpf/core/operators/math/add_constant.py

@@ -53,14 +53,28 @@ class add_constant(Operator):
     >>> result_field = op.outputs.field()
     """
 
-    def __init__(self, field=None, weights=None, config=None, server=None):
+    def __init__(
+        self,
+        field=None,
+        weights=None,
+        config=None,
+        server=None,
+        ponderation=None,
+    ):
         super().__init__(name="add_constant", config=config, server=server)
         self._inputs = InputsAddConstant(self)
         self._outputs = OutputsAddConstant(self)
         if field is not None:
             self.inputs.field.connect(field)
         if weights is not None:
             self.inputs.weights.connect(weights)
+        elif ponderation is not None:
+            warn(
+                DeprecationWarning(
+                    f'Operator add_constant: Input name "ponderation" is deprecated in favor of "weights".'
+                )
+            )
+            self.inputs.weights.connect(ponderation)
 
     @staticmethod
     def _spec() -> Specification:
@@ -80,6 +94,7 @@ def _spec() -> Specification:
                     type_names=["double", "vector<double>"],
                     optional=False,
                     document=r"""double or vector of double""",
+                    aliases=["ponderation"],
                 ),
             },
             map_output_pin_spec={
@@ -200,6 +215,18 @@ def weights(self) -> Input:
         """
         return self._weights
 
+    def __getattr__(self, name):
+        if name in ["ponderation"]:
+            warn(
+                DeprecationWarning(
+                    f'Operator add_constant: Input name "{name}" is deprecated in favor of "weights".'
+                )
+            )
+            return self.weights
+        raise AttributeError(
+            f"'{self.__class__.__name__}' object has no attribute '{name}'."
+        )
+
 
 class OutputsAddConstant(_Outputs):
     """Intermediate class used to get outputs from