update generated code

Author: PProfizi

doc/source/_static/dpf_operators.html

@@ -1,262 +1,212 @@
 """
 to_elemental_nodal_fc
 =====================
-Autogenerated DPF operator classes.
 """
-
-from warnings import warn
 from ansys.dpf.core.dpf_operator import Operator
 from ansys.dpf.core.inputs import Input, _Inputs
-from ansys.dpf.core.outputs import Output, _Outputs
+from ansys.dpf.core.outputs import Output, _Outputs, _modify_output_spec_with_one_type
 from ansys.dpf.core.operators.specification import PinSpecification, Specification
 
+"""Operators from "averaging" category
+"""
 
 class to_elemental_nodal_fc(Operator):
-    """Transforms fields into Elemental Nodal fields using an averaging
-    process. The result is computed on a given element's scoping.
-
-    Parameters
-    ----------
-    fields_container : FieldsContainer
-    mesh_scoping : Scoping, optional
-    mesh : MeshedRegion, optional
-
-
-    Examples
-    --------
-    >>> from ansys.dpf import core as dpf
-
-    >>> # Instantiate operator
-    >>> op = dpf.operators.averaging.to_elemental_nodal_fc()
-
-    >>> # Make input connections
-    >>> my_fields_container = dpf.FieldsContainer()
-    >>> op.inputs.fields_container.connect(my_fields_container)
-    >>> my_mesh_scoping = dpf.Scoping()
-    >>> op.inputs.mesh_scoping.connect(my_mesh_scoping)
-    >>> my_mesh = dpf.MeshedRegion()
-    >>> op.inputs.mesh.connect(my_mesh)
-
-    >>> # Instantiate operator and connect inputs in one line
-    >>> op = dpf.operators.averaging.to_elemental_nodal_fc(
-    ...     fields_container=my_fields_container,
-    ...     mesh_scoping=my_mesh_scoping,
-    ...     mesh=my_mesh,
-    ... )
-
-    >>> # Get output data
-    >>> result_fields_container = op.outputs.fields_container()
-    """
-
-    def __init__(
-        self,
-        fields_container=None,
-        mesh_scoping=None,
-        mesh=None,
-        config=None,
-        server=None,
-    ):
-        super().__init__(name="to_elemental_nodal_fc", config=config, server=server)
+    """Transforms fields into Elemental Nodal fields using an averaging process. The result is computed on a given element's scoping.
+
+      available inputs:
+        - fields_container (FieldsContainer)
+        - mesh_scoping (Scoping) (optional)
+        - mesh (MeshedRegion) (optional)
+
+      available outputs:
+        - fields_container (FieldsContainer)
+
+      Examples
+      --------
+      >>> from ansys.dpf import core as dpf
+
+      >>> # Instantiate operator
+      >>> op = dpf.operators.averaging.to_elemental_nodal_fc()
+
+      >>> # Make input connections
+      >>> my_fields_container = dpf.FieldsContainer()
+      >>> op.inputs.fields_container.connect(my_fields_container)
+      >>> my_mesh_scoping = dpf.Scoping()
+      >>> op.inputs.mesh_scoping.connect(my_mesh_scoping)
+      >>> my_mesh = dpf.MeshedRegion()
+      >>> op.inputs.mesh.connect(my_mesh)
+
+      >>> # Instantiate operator and connect inputs in one line
+      >>> op = dpf.operators.averaging.to_elemental_nodal_fc(fields_container=my_fields_container,mesh_scoping=my_mesh_scoping,mesh=my_mesh)
+
+      >>> # Get output data
+      >>> result_fields_container = op.outputs.fields_container()"""
+    def __init__(self, fields_container=None, mesh_scoping=None, mesh=None, config=None, server=None):
+        super().__init__(name="to_elemental_nodal_fc", config = config, server = server)
         self._inputs = InputsToElementalNodalFc(self)
         self._outputs = OutputsToElementalNodalFc(self)
-        if fields_container is not None:
+        if fields_container !=None:
             self.inputs.fields_container.connect(fields_container)
-        if mesh_scoping is not None:
+        if mesh_scoping !=None:
             self.inputs.mesh_scoping.connect(mesh_scoping)
-        if mesh is not None:
+        if mesh !=None:
             self.inputs.mesh.connect(mesh)
 
     @staticmethod
     def _spec():
-        description = """Transforms fields into Elemental Nodal fields using an averaging
-            process. The result is computed on a given element's
-            scoping."""
-        spec = Specification(
-            description=description,
-            map_input_pin_spec={
-                0: PinSpecification(
-                    name="fields_container",
-                    type_names=["fields_container"],
-                    optional=False,
-                    document="""""",
-                ),
-                1: PinSpecification(
-                    name="mesh_scoping",
-                    type_names=["scoping"],
-                    optional=True,
-                    document="""""",
-                ),
-                7: PinSpecification(
-                    name="mesh",
-                    type_names=["abstract_meshed_region"],
-                    optional=True,
-                    document="""""",
-                ),
-            },
-            map_output_pin_spec={
-                0: PinSpecification(
-                    name="fields_container",
-                    type_names=["fields_container"],
-                    optional=False,
-                    document="""""",
-                ),
-            },
-        )
+        spec = Specification(description="""Transforms fields into Elemental Nodal fields using an averaging process. The result is computed on a given element's scoping.""",
+                             map_input_pin_spec={
+                                 0 : PinSpecification(name = "fields_container", type_names=["fields_container"], optional=False, document=""""""), 
+                                 1 : PinSpecification(name = "mesh_scoping", type_names=["scoping"], optional=True, document=""""""), 
+                                 7 : PinSpecification(name = "mesh", type_names=["abstract_meshed_region"], optional=True, document="""""")},
+                             map_output_pin_spec={
+                                 0 : PinSpecification(name = "fields_container", type_names=["fields_container"], optional=False, document="""""")})
         return spec
 
-    @staticmethod
-    def default_config(server=None):
-        """Returns the default config of the operator.
-
-        This config can then be changed to the user needs and be used to
-        instantiate the operator. The Configuration allows to customize
-        how the operation will be processed by the operator.
 
-        Parameters
-        ----------
-        server : server.DPFServer, optional
-            Server with channel connected to the remote or local instance. When
-            ``None``, attempts to use the global server.
-        """
-        return Operator.default_config(name="to_elemental_nodal_fc", server=server)
+    @staticmethod
+    def default_config():
+        return Operator.default_config(name = "to_elemental_nodal_fc")
 
     @property
     def inputs(self):
-        """Enables to connect inputs to the operator
+        """Enables to connect inputs to the operator.
 
         Returns
         --------
-        inputs : InputsToElementalNodalFc
+        inputs : InputsToElementalNodalFc 
         """
         return super().inputs
 
+
     @property
     def outputs(self):
-        """Enables to get outputs of the operator by evaluating it
+        """Enables to get outputs of the operator by evaluating it.
 
         Returns
         --------
-        outputs : OutputsToElementalNodalFc
+        outputs : OutputsToElementalNodalFc 
         """
         return super().outputs
 
 
+#internal name: to_elemental_nodal_fc
+#scripting name: to_elemental_nodal_fc
 class InputsToElementalNodalFc(_Inputs):
-    """Intermediate class used to connect user inputs to
-    to_elemental_nodal_fc operator.
-
-    Examples
-    --------
-    >>> from ansys.dpf import core as dpf
-    >>> op = dpf.operators.averaging.to_elemental_nodal_fc()
-    >>> my_fields_container = dpf.FieldsContainer()
-    >>> op.inputs.fields_container.connect(my_fields_container)
-    >>> my_mesh_scoping = dpf.Scoping()
-    >>> op.inputs.mesh_scoping.connect(my_mesh_scoping)
-    >>> my_mesh = dpf.MeshedRegion()
-    >>> op.inputs.mesh.connect(my_mesh)
+    """Intermediate class used to connect user inputs to to_elemental_nodal_fc operator
+
+      Examples
+      --------
+      >>> from ansys.dpf import core as dpf
+
+      >>> op = dpf.operators.averaging.to_elemental_nodal_fc()
+      >>> my_fields_container = dpf.FieldsContainer()
+      >>> op.inputs.fields_container.connect(my_fields_container)
+      >>> my_mesh_scoping = dpf.Scoping()
+      >>> op.inputs.mesh_scoping.connect(my_mesh_scoping)
+      >>> my_mesh = dpf.MeshedRegion()
+      >>> op.inputs.mesh.connect(my_mesh)
     """
-
     def __init__(self, op: Operator):
         super().__init__(to_elemental_nodal_fc._spec().inputs, op)
-        self._fields_container = Input(
-            to_elemental_nodal_fc._spec().input_pin(0), 0, op, -1
-        )
+        self._fields_container = Input(to_elemental_nodal_fc._spec().input_pin(0), 0, op, -1) 
         self._inputs.append(self._fields_container)
-        self._mesh_scoping = Input(
-            to_elemental_nodal_fc._spec().input_pin(1), 1, op, -1
-        )
+        self._mesh_scoping = Input(to_elemental_nodal_fc._spec().input_pin(1), 1, op, -1) 
         self._inputs.append(self._mesh_scoping)
-        self._mesh = Input(to_elemental_nodal_fc._spec().input_pin(7), 7, op, -1)
+        self._mesh = Input(to_elemental_nodal_fc._spec().input_pin(7), 7, op, -1) 
         self._inputs.append(self._mesh)
 
     @property
     def fields_container(self):
-        """Allows to connect fields_container input to the operator.
+        """Allows to connect fields_container input to the operator
 
         Parameters
         ----------
-        my_fields_container : FieldsContainer
+        my_fields_container : FieldsContainer, 
 
         Examples
         --------
         >>> from ansys.dpf import core as dpf
+
         >>> op = dpf.operators.averaging.to_elemental_nodal_fc()
         >>> op.inputs.fields_container.connect(my_fields_container)
-        >>> # or
+        >>> #or
         >>> op.inputs.fields_container(my_fields_container)
+
         """
         return self._fields_container
 
     @property
     def mesh_scoping(self):
-        """Allows to connect mesh_scoping input to the operator.
+        """Allows to connect mesh_scoping input to the operator
 
         Parameters
         ----------
-        my_mesh_scoping : Scoping
+        my_mesh_scoping : Scoping, 
 
         Examples
         --------
         >>> from ansys.dpf import core as dpf
+
         >>> op = dpf.operators.averaging.to_elemental_nodal_fc()
         >>> op.inputs.mesh_scoping.connect(my_mesh_scoping)
-        >>> # or
+        >>> #or
         >>> op.inputs.mesh_scoping(my_mesh_scoping)
+
         """
         return self._mesh_scoping
 
     @property
     def mesh(self):
-        """Allows to connect mesh input to the operator.
+        """Allows to connect mesh input to the operator
 
         Parameters
         ----------
-        my_mesh : MeshedRegion
+        my_mesh : MeshedRegion, 
 
         Examples
         --------
         >>> from ansys.dpf import core as dpf
+
         >>> op = dpf.operators.averaging.to_elemental_nodal_fc()
         >>> op.inputs.mesh.connect(my_mesh)
-        >>> # or
+        >>> #or
         >>> op.inputs.mesh(my_mesh)
+
         """
         return self._mesh
 
-
 class OutputsToElementalNodalFc(_Outputs):
-    """Intermediate class used to get outputs from
-    to_elemental_nodal_fc operator.
-
-    Examples
-    --------
-    >>> from ansys.dpf import core as dpf
-    >>> op = dpf.operators.averaging.to_elemental_nodal_fc()
-    >>> # Connect inputs : op.inputs. ...
-    >>> result_fields_container = op.outputs.fields_container()
+    """Intermediate class used to get outputs from to_elemental_nodal_fc operator
+      Examples
+      --------
+      >>> from ansys.dpf import core as dpf
+
+      >>> op = dpf.operators.averaging.to_elemental_nodal_fc()
+      >>> # Connect inputs : op.inputs. ...
+      >>> result_fields_container = op.outputs.fields_container()
     """
-
     def __init__(self, op: Operator):
         super().__init__(to_elemental_nodal_fc._spec().outputs, op)
-        self._fields_container = Output(
-            to_elemental_nodal_fc._spec().output_pin(0), 0, op
-        )
+        self._fields_container = Output(to_elemental_nodal_fc._spec().output_pin(0), 0, op) 
         self._outputs.append(self._fields_container)
 
     @property
     def fields_container(self):
         """Allows to get fields_container output of the operator
 
+
         Returns
         ----------
-        my_fields_container : FieldsContainer
+        my_fields_container : FieldsContainer, 
 
         Examples
         --------
         >>> from ansys.dpf import core as dpf
+
         >>> op = dpf.operators.averaging.to_elemental_nodal_fc()
         >>> # Connect inputs : op.inputs. ...
-        >>> result_fields_container = op.outputs.fields_container()
-        """  # noqa: E501
+        >>> result_fields_container = op.outputs.fields_container() 
+        """
         return self._fields_container
+