Revert changes to operators.mesh.meshes_provider due to an error server-side (#825)

Author: PProfizi

src/ansys/dpf/core/operators/mesh/meshes_provider.py

@@ -11,12 +11,22 @@
 
 
 class meshes_provider(Operator):
-    """Converts an Assembly Mesh into a DPF Meshes container
+    """Read meshes from result files. Meshes can be spatially or temporally
+    varying.
 
     Parameters
     ----------
-    assembly_mesh : AnsDispatchHolder or Struct Iansdispatch
-    unit : str, optional
+    time_scoping : Scoping or int, optional
+        Time/freq set ids required in output
+    streams_container : StreamsContainer, optional
+        Result file container allowed to be kept open
+        to cache data
+    data_sources : DataSources
+        Result file path container, used if no
+        streams are set
+    read_cyclic : int, optional
+        If 1 cyclic symmetry is ignored, if 2 cyclic
+        expansion is done (default is 1)
 
 
     Examples
@@ -27,54 +37,86 @@ class meshes_provider(Operator):
     >>> op = dpf.operators.mesh.meshes_provider()
 
     >>> # Make input connections
-    >>> my_assembly_mesh = dpf.AnsDispatchHolder()
-    >>> op.inputs.assembly_mesh.connect(my_assembly_mesh)
-    >>> my_unit = str()
-    >>> op.inputs.unit.connect(my_unit)
+    >>> my_time_scoping = dpf.Scoping()
+    >>> op.inputs.time_scoping.connect(my_time_scoping)
+    >>> my_streams_container = dpf.StreamsContainer()
+    >>> op.inputs.streams_container.connect(my_streams_container)
+    >>> my_data_sources = dpf.DataSources()
+    >>> op.inputs.data_sources.connect(my_data_sources)
+    >>> my_read_cyclic = int()
+    >>> op.inputs.read_cyclic.connect(my_read_cyclic)
 
     >>> # Instantiate operator and connect inputs in one line
     >>> op = dpf.operators.mesh.meshes_provider(
-    ...     assembly_mesh=my_assembly_mesh,
-    ...     unit=my_unit,
+    ...     time_scoping=my_time_scoping,
+    ...     streams_container=my_streams_container,
+    ...     data_sources=my_data_sources,
+    ...     read_cyclic=my_read_cyclic,
     ... )
 
     >>> # Get output data
-    >>> result_meshes_container = op.outputs.meshes_container()
+    >>> result_meshes = op.outputs.meshes()
     """
 
-    def __init__(self, assembly_mesh=None, unit=None, config=None, server=None):
-        super().__init__(
-            name="acmo::acmo_live::meshes_provider", config=config, server=server
-        )
+    def __init__(
+        self,
+        time_scoping=None,
+        streams_container=None,
+        data_sources=None,
+        read_cyclic=None,
+        config=None,
+        server=None,
+    ):
+        super().__init__(name="meshes_provider", config=config, server=server)
         self._inputs = InputsMeshesProvider(self)
         self._outputs = OutputsMeshesProvider(self)
-        if assembly_mesh is not None:
-            self.inputs.assembly_mesh.connect(assembly_mesh)
-        if unit is not None:
-            self.inputs.unit.connect(unit)
+        if time_scoping is not None:
+            self.inputs.time_scoping.connect(time_scoping)
+        if streams_container is not None:
+            self.inputs.streams_container.connect(streams_container)
+        if data_sources is not None:
+            self.inputs.data_sources.connect(data_sources)
+        if read_cyclic is not None:
+            self.inputs.read_cyclic.connect(read_cyclic)
 
     @staticmethod
     def _spec():
-        description = """Converts an Assembly Mesh into a DPF Meshes container"""
+        description = """Read meshes from result files. Meshes can be spatially or temporally
+            varying."""
         spec = Specification(
             description=description,
             map_input_pin_spec={
                 0: PinSpecification(
-                    name="assembly_mesh",
-                    type_names=["ans_dispatch_holder", "struct IAnsDispatch"],
+                    name="time_scoping",
+                    type_names=["scoping", "vector<int32>", "int32"],
+                    optional=True,
+                    document="""Time/freq set ids required in output""",
+                ),
+                3: PinSpecification(
+                    name="streams_container",
+                    type_names=["streams_container"],
+                    optional=True,
+                    document="""Result file container allowed to be kept open
+        to cache data""",
+                ),
+                4: PinSpecification(
+                    name="data_sources",
+                    type_names=["data_sources"],
                     optional=False,
-                    document="""""",
+                    document="""Result file path container, used if no
+        streams are set""",
                 ),
-                1: PinSpecification(
-                    name="unit",
-                    type_names=["string"],
+                14: PinSpecification(
+                    name="read_cyclic",
+                    type_names=["enum dataProcessing::ECyclicReading", "int32"],
                     optional=True,
-                    document="""""",
+                    document="""If 1 cyclic symmetry is ignored, if 2 cyclic
+        expansion is done (default is 1)""",
                 ),
             },
             map_output_pin_spec={
                 0: PinSpecification(
-                    name="meshes_container",
+                    name="meshes",
                     type_names=["meshes_container"],
                     optional=False,
                     document="""""",
@@ -97,9 +139,7 @@ def default_config(server=None):
             Server with channel connected to the remote or local instance. When
             ``None``, attempts to use the global server.
         """
-        return Operator.default_config(
-            name="acmo::acmo_live::meshes_provider", server=server
-        )
+        return Operator.default_config(name="meshes_provider", server=server)
 
     @property
     def inputs(self):
@@ -130,54 +170,109 @@ class InputsMeshesProvider(_Inputs):
     --------
     >>> from ansys.dpf import core as dpf
     >>> op = dpf.operators.mesh.meshes_provider()
-    >>> my_assembly_mesh = dpf.AnsDispatchHolder()
-    >>> op.inputs.assembly_mesh.connect(my_assembly_mesh)
-    >>> my_unit = str()
-    >>> op.inputs.unit.connect(my_unit)
+    >>> my_time_scoping = dpf.Scoping()
+    >>> op.inputs.time_scoping.connect(my_time_scoping)
+    >>> my_streams_container = dpf.StreamsContainer()
+    >>> op.inputs.streams_container.connect(my_streams_container)
+    >>> my_data_sources = dpf.DataSources()
+    >>> op.inputs.data_sources.connect(my_data_sources)
+    >>> my_read_cyclic = int()
+    >>> op.inputs.read_cyclic.connect(my_read_cyclic)
     """
 
     def __init__(self, op: Operator):
         super().__init__(meshes_provider._spec().inputs, op)
-        self._assembly_mesh = Input(meshes_provider._spec().input_pin(0), 0, op, -1)
-        self._inputs.append(self._assembly_mesh)
-        self._unit = Input(meshes_provider._spec().input_pin(1), 1, op, -1)
-        self._inputs.append(self._unit)
+        self._time_scoping = Input(meshes_provider._spec().input_pin(0), 0, op, -1)
+        self._inputs.append(self._time_scoping)
+        self._streams_container = Input(meshes_provider._spec().input_pin(3), 3, op, -1)
+        self._inputs.append(self._streams_container)
+        self._data_sources = Input(meshes_provider._spec().input_pin(4), 4, op, -1)
+        self._inputs.append(self._data_sources)
+        self._read_cyclic = Input(meshes_provider._spec().input_pin(14), 14, op, -1)
+        self._inputs.append(self._read_cyclic)
+
+    @property
+    def time_scoping(self):
+        """Allows to connect time_scoping input to the operator.
+
+        Time/freq set ids required in output
+
+        Parameters
+        ----------
+        my_time_scoping : Scoping or int
+
+        Examples
+        --------
+        >>> from ansys.dpf import core as dpf
+        >>> op = dpf.operators.mesh.meshes_provider()
+        >>> op.inputs.time_scoping.connect(my_time_scoping)
+        >>> # or
+        >>> op.inputs.time_scoping(my_time_scoping)
+        """
+        return self._time_scoping
+
+    @property
+    def streams_container(self):
+        """Allows to connect streams_container input to the operator.
+
+        Result file container allowed to be kept open
+        to cache data
+
+        Parameters
+        ----------
+        my_streams_container : StreamsContainer
+
+        Examples
+        --------
+        >>> from ansys.dpf import core as dpf
+        >>> op = dpf.operators.mesh.meshes_provider()
+        >>> op.inputs.streams_container.connect(my_streams_container)
+        >>> # or
+        >>> op.inputs.streams_container(my_streams_container)
+        """
+        return self._streams_container
 
     @property
-    def assembly_mesh(self):
-        """Allows to connect assembly_mesh input to the operator.
+    def data_sources(self):
+        """Allows to connect data_sources input to the operator.
+
+        Result file path container, used if no
+        streams are set
 
         Parameters
         ----------
-        my_assembly_mesh : AnsDispatchHolder or Struct Iansdispatch
+        my_data_sources : DataSources
 
         Examples
         --------
         >>> from ansys.dpf import core as dpf
         >>> op = dpf.operators.mesh.meshes_provider()
-        >>> op.inputs.assembly_mesh.connect(my_assembly_mesh)
+        >>> op.inputs.data_sources.connect(my_data_sources)
         >>> # or
-        >>> op.inputs.assembly_mesh(my_assembly_mesh)
+        >>> op.inputs.data_sources(my_data_sources)
         """
-        return self._assembly_mesh
+        return self._data_sources
 
     @property
-    def unit(self):
-        """Allows to connect unit input to the operator.
+    def read_cyclic(self):
+        """Allows to connect read_cyclic input to the operator.
+
+        If 1 cyclic symmetry is ignored, if 2 cyclic
+        expansion is done (default is 1)
 
         Parameters
         ----------
-        my_unit : str
+        my_read_cyclic : int
 
         Examples
         --------
         >>> from ansys.dpf import core as dpf
         >>> op = dpf.operators.mesh.meshes_provider()
-        >>> op.inputs.unit.connect(my_unit)
+        >>> op.inputs.read_cyclic.connect(my_read_cyclic)
         >>> # or
-        >>> op.inputs.unit(my_unit)
+        >>> op.inputs.read_cyclic(my_read_cyclic)
         """
-        return self._unit
+        return self._read_cyclic
 
 
 class OutputsMeshesProvider(_Outputs):
@@ -189,27 +284,27 @@ class OutputsMeshesProvider(_Outputs):
     >>> from ansys.dpf import core as dpf
     >>> op = dpf.operators.mesh.meshes_provider()
     >>> # Connect inputs : op.inputs. ...
-    >>> result_meshes_container = op.outputs.meshes_container()
+    >>> result_meshes = op.outputs.meshes()
     """
 
     def __init__(self, op: Operator):
         super().__init__(meshes_provider._spec().outputs, op)
-        self._meshes_container = Output(meshes_provider._spec().output_pin(0), 0, op)
-        self._outputs.append(self._meshes_container)
+        self._meshes = Output(meshes_provider._spec().output_pin(0), 0, op)
+        self._outputs.append(self._meshes)
 
     @property
-    def meshes_container(self):
-        """Allows to get meshes_container output of the operator
+    def meshes(self):
+        """Allows to get meshes output of the operator
 
         Returns
         ----------
-        my_meshes_container : MeshesContainer
+        my_meshes : MeshesContainer
 
         Examples
         --------
         >>> from ansys.dpf import core as dpf
         >>> op = dpf.operators.mesh.meshes_provider()
         >>> # Connect inputs : op.inputs. ...
-        >>> result_meshes_container = op.outputs.meshes_container()
+        >>> result_meshes = op.outputs.meshes()
         """  # noqa: E501
-        return self._meshes_container
+        return self._meshes