update generated code (#2129)

Co-authored-by: PProfizi <[email protected]>

Author: pyansys-ci-bot

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,8 @@ def __init__(
             self.inputs.fieldA.connect(fieldA)
         if weights is not None:
             self.inputs.weights.connect(weights)
+        elif ponderation is not None:
+            self.inputs.weights.connect(ponderation)
         if time_scoping is not None:
             self.inputs.time_scoping.connect(time_scoping)
 
@@ -92,6 +100,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 +252,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,8 @@ def __init__(
             self.inputs.fields_container.connect(fields_container)
         if weights is not None:
             self.inputs.weights.connect(weights)
+        elif ponderation is not None:
+            self.inputs.weights.connect(ponderation)
         if time_scoping is not None:
             self.inputs.time_scoping.connect(time_scoping)
 
@@ -97,6 +100,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 +252,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,23 @@ 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:
+            self.inputs.weights.connect(ponderation)
 
     @staticmethod
     def _spec() -> Specification:
@@ -80,6 +89,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 +210,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

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

@@ -53,14 +53,23 @@ class add_constant_fc(Operator):
     >>> result_fields_container = op.outputs.fields_container()
     """
 
-    def __init__(self, fields_container=None, weights=None, config=None, server=None):
+    def __init__(
+        self,
+        fields_container=None,
+        weights=None,
+        config=None,
+        server=None,
+        ponderation=None,
+    ):
         super().__init__(name="add_constant_fc", config=config, server=server)
         self._inputs = InputsAddConstantFc(self)
         self._outputs = OutputsAddConstantFc(self)
         if fields_container is not None:
             self.inputs.fields_container.connect(fields_container)
         if weights is not None:
             self.inputs.weights.connect(weights)
+        elif ponderation is not None:
+            self.inputs.weights.connect(ponderation)
 
     @staticmethod
     def _spec() -> Specification:
@@ -80,6 +89,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 +210,18 @@ def weights(self) -> Input:
         """
         return self._weights
 
+    def __getattr__(self, name):
+        if name in ["ponderation"]:
+            warn(
+                DeprecationWarning(
+                    f'Operator add_constant_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 OutputsAddConstantFc(_Outputs):
     """Intermediate class used to get outputs from

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

@@ -77,6 +77,7 @@ def __init__(
         absoluteValue=None,
         config=None,
         server=None,
+        ponderation=None,
     ):
         super().__init__(name="correlation", config=config, server=server)
         self._inputs = InputsCorrelation(self)
@@ -87,6 +88,8 @@ def __init__(
             self.inputs.fieldB.connect(fieldB)
         if weights is not None:
             self.inputs.weights.connect(weights)
+        elif ponderation is not None:
+            self.inputs.weights.connect(ponderation)
         if absoluteValue is not None:
             self.inputs.absoluteValue.connect(absoluteValue)
 
@@ -116,6 +119,7 @@ def _spec() -> Specification:
                     type_names=["field", "fields_container"],
                     optional=False,
                     document=r"""Field M, optional weighting for correlation computation.""",
+                    aliases=["ponderation"],
                 ),
                 3: PinSpecification(
                     name="absoluteValue",
@@ -298,6 +302,18 @@ def absoluteValue(self) -> Input:
         """
         return self._absoluteValue
 
+    def __getattr__(self, name):
+        if name in ["ponderation"]:
+            warn(
+                DeprecationWarning(
+                    f'Operator correlation: Input name "{name}" is deprecated in favor of "weights".'
+                )
+            )
+            return self.weights
+        raise AttributeError(
+            f"'{self.__class__.__name__}' object has no attribute '{name}'."
+        )
+
 
 class OutputsCorrelation(_Outputs):
     """Intermediate class used to get outputs from

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

@@ -69,6 +69,7 @@ def __init__(
         weights=None,
         config=None,
         server=None,
+        ponderation=None,
     ):
         super().__init__(name="mac", config=config, server=server)
         self._inputs = InputsMac(self)
@@ -79,6 +80,8 @@ def __init__(
             self.inputs.fields_containerB.connect(fields_containerB)
         if weights is not None:
             self.inputs.weights.connect(weights)
+        elif ponderation is not None:
+            self.inputs.weights.connect(ponderation)
 
     @staticmethod
     def _spec() -> Specification:
@@ -107,6 +110,7 @@ def _spec() -> Specification:
                     type_names=["field"],
                     optional=False,
                     document=r"""Field M, optional weighting for MAC Matrix computation.""",
+                    aliases=["ponderation"],
                 ),
             },
             map_output_pin_spec={
@@ -252,6 +256,18 @@ def weights(self) -> Input:
         """
         return self._weights
 
+    def __getattr__(self, name):
+        if name in ["ponderation"]:
+            warn(
+                DeprecationWarning(
+                    f'Operator mac: Input name "{name}" is deprecated in favor of "weights".'
+                )
+            )
+            return self.weights
+        raise AttributeError(
+            f"'{self.__class__.__name__}' object has no attribute '{name}'."
+        )
+
 
 class OutputsMac(_Outputs):
     """Intermediate class used to get outputs from

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

@@ -74,6 +74,7 @@ def __init__(
         algorithm=None,
         config=None,
         server=None,
+        ponderation=None,
     ):
         super().__init__(name="scale", config=config, server=server)
         self._inputs = InputsScale(self)
@@ -82,6 +83,8 @@ def __init__(
             self.inputs.field.connect(field)
         if weights is not None:
             self.inputs.weights.connect(weights)
+        elif ponderation is not None:
+            self.inputs.weights.connect(ponderation)
         if boolean is not None:
             self.inputs.boolean.connect(boolean)
         if algorithm is not None:
@@ -108,6 +111,7 @@ def _spec() -> Specification:
                     type_names=["double", "field", "vector<double>"],
                     optional=False,
                     document=r"""Double/Field/Vector of doubles. When scoped on overall, same value(s) applied on all the data, when scoped elsewhere, corresponding values will be multiplied due to the scoping""",
+                    aliases=["ponderation"],
                 ),
                 2: PinSpecification(
                     name="boolean",
@@ -290,6 +294,18 @@ def algorithm(self) -> Input:
         """
         return self._algorithm
 
+    def __getattr__(self, name):
+        if name in ["ponderation"]:
+            warn(
+                DeprecationWarning(
+                    f'Operator scale: Input name "{name}" is deprecated in favor of "weights".'
+                )
+            )
+            return self.weights
+        raise AttributeError(
+            f"'{self.__class__.__name__}' object has no attribute '{name}'."
+        )
+
 
 class OutputsScale(_Outputs):
     """Intermediate class used to get outputs from

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

@@ -74,6 +74,7 @@ def __init__(
         algorithm=None,
         config=None,
         server=None,
+        ponderation=None,
     ):
         super().__init__(name="scale_fc", config=config, server=server)
         self._inputs = InputsScaleFc(self)
@@ -82,6 +83,8 @@ def __init__(
             self.inputs.fields_container.connect(fields_container)
         if weights is not None:
             self.inputs.weights.connect(weights)
+        elif ponderation is not None:
+            self.inputs.weights.connect(ponderation)
         if boolean is not None:
             self.inputs.boolean.connect(boolean)
         if algorithm is not None:
@@ -113,6 +116,7 @@ def _spec() -> Specification:
                     ],
                     optional=False,
                     document=r"""Double/Vector of doubles/Field/FieldsContainer. When scoped on overall, same value(s) applied on all the data, when scoped elsewhere, corresponding values will be multiplied due to the scoping""",
+                    aliases=["ponderation"],
                 ),
                 2: PinSpecification(
                     name="boolean",
@@ -295,6 +299,18 @@ def algorithm(self) -> Input:
         """
         return self._algorithm
 
+    def __getattr__(self, name):
+        if name in ["ponderation"]:
+            warn(
+                DeprecationWarning(
+                    f'Operator scale_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 OutputsScaleFc(_Outputs):
     """Intermediate class used to get outputs from