Merge/0.5.dev2 fix 2022R2 pipelines

.github/workflows/ci.yml

@@ -43,9 +43,10 @@ jobs:
           MODULE: ${{env.MODULE}}
           dpf-standalone-TOKEN: ${{secrets.DPF_PIPELINE}}
           install_extras: plotting
+          wheelhouse: "false"
 
       - name: "Test Package"
-        uses: pyansys/pydpf-actions/[email protected]
+        uses: pyansys/pydpf-actions/[email protected].dev0
         with:
           MODULE: ${{env.MODULE}}
           DEBUG: True
@@ -75,7 +76,7 @@ jobs:
           python-version: 3.8
 
       - id: install-dpf
-        uses: pyansys/pydpf-actions/install-dpf-server@v2.0
+        uses: pyansys/pydpf-actions/install-dpf-server@v2.2
         with:
           dpf-standalone-TOKEN: ${{secrets.DPF_PIPELINE}}
           ANSYS_VERSION : ${{env.ANSYS_VERSION}}
@@ -125,21 +126,18 @@ jobs:
         run: |
           pip install -r requirements/requirements_docs.txt
 
+      - name: "Kill all servers"
+        uses: pyansys/pydpf-actions/[email protected]
+
       - name: Build Documentation
         shell: cmd
         run: |
           cd .ci
           build_doc.bat > ..\docs\log.txt && type ..\docs\log.txt 2>&1
         timeout-minutes: 20
 
-      - name: Kill all servers
-        shell: cmd
-        run: |
-          tasklist /FI "IMAGENAME eq Ans.Dpf.Grpc.exe" 2>NUL | find /I /N "Ans.Dpf.Grpc.exe">NUL
-          ECHO %ERRORLEVEL%
-          if "%ERRORLEVEL%"=="0"(taskkill /f /im Ans.Dpf.Grpc.exe)
-        continue-on-error: true
-        if: always()
+      - name: "Kill all servers"
+        uses: pyansys/pydpf-actions/[email protected]
 
       - name: Publish Documentation artifact
         uses: actions/upload-artifact@v3

.github/workflows/retro.yml

@@ -28,16 +28,19 @@ jobs:
       - uses: actions/checkout@v3
 
       - name: "Build Package"
-        uses: pyansys/pydpf-actions/build_package@v2.1.1
+        uses: pyansys/pydpf-actions/build_package@v2.2
         with:
           python-version: ${{ matrix.python-version }}
           ANSYS_VERSION: ${{env.ANSYS_VERSION}}
           PACKAGE_NAME: ${{env.PACKAGE_NAME}}
           MODULE: ${{env.MODULE}}
           dpf-standalone-TOKEN: ${{secrets.DPF_PIPELINE}}
           install_extras: plotting
+          wheel: "false"
+          wheelhouse: "false"
 
       - name: "Test Package"
-        uses: pyansys/pydpf-actions/test_package@v2.1.1
+        uses: pyansys/pydpf-actions/test_package@v2.2.dev0
         with:
           MODULE: ${{env.MODULE}}
+          DOCTEST: "false"

ansys/dpf/core/_model_helpers.py

@@ -1,14 +1,49 @@
+import weakref
 
-def __connect_op__(op, metadata, mesh_by_default=True):
-    """Connect the data sources or the streams to the operator."""
-    if metadata._stream_provider is not None and hasattr(op.inputs, "streams"):
-        op.inputs.streams.connect(metadata._stream_provider.outputs)
-    elif metadata._stream_provider is not None and hasattr(op.inputs, "streams_container"):
-        op.inputs.streams_container.connect(metadata._stream_provider.outputs)
-    elif metadata._data_sources is not None and hasattr(
-            op.inputs, "data_sources"
-    ):
-        op.inputs.data_sources.connect(metadata._data_sources)
-
-    if mesh_by_default and metadata.mesh_provider and hasattr(op.inputs, "mesh"):
-        op.inputs.mesh.connect(metadata.mesh_provider)
+
+class DataSourcesOrStreamsConnector:
+    def __init__(self, metadata):
+        self._metadata = weakref.ref(metadata)
+
+    @property
+    def streams_provider(self):
+        if self._metadata():
+            return self._metadata().streams_provider
+        return None
+
+    @property
+    def time_freq_support(self):
+        if self._metadata():
+            return self._metadata().time_freq_support
+        return None
+
+    @property
+    def mesh_provider(self):
+        if self._metadata():
+            return self._metadata()._mesh_provider_cached
+        return None
+
+    @property
+    def data_sources(self):
+        if self._metadata():
+            return self._metadata().data_sources
+        return None
+
+    def named_selection(self, name):
+        if self._metadata():
+            return self._metadata().named_selection(name)
+        return None
+
+    def __connect_op__(self, op, mesh_by_default=True):
+        """Connect the data sources or the streams to the operator."""
+        if self.streams_provider is not None and hasattr(op.inputs, "streams"):
+            op.inputs.streams.connect(self.streams_provider.outputs)
+        elif self.streams_provider is not None and hasattr(op.inputs, "streams_container"):
+            op.inputs.streams_container.connect(self.streams_provider.outputs)
+        elif self.data_sources is not None and hasattr(
+                op.inputs, "data_sources"
+        ):
+            op.inputs.data_sources.connect(self.data_sources)
+
+        if mesh_by_default and self.mesh_provider and hasattr(op.inputs, "mesh"):
+            op.inputs.mesh.connect(self.mesh_provider)

ansys/dpf/core/core.py

@@ -312,7 +312,7 @@ def __init__(self, server=None, load_operators=True, timeout=5):
             grpcapi=tmp_dir_grpcapi.TmpDirGRPCAPI
         )
 
-        # step3: init environement
+        # step3: init environment
         self._api.init_data_processing_environment(self)  # creates stub when gRPC
 
     def make_tmp_dir_server(self):

ansys/dpf/core/data_sources.py

@@ -52,7 +52,7 @@ def __init__(self, result_path=None, data_sources=None, server=None):
         self._api = self._server.get_api_for_type(capi=data_sources_capi.DataSourcesCAPI,
                                                   grpcapi=data_sources_grpcapi.DataSourcesGRPCAPI)
 
-        # step3: init environement
+        # step3: init environment
         self._api.init_data_sources_environment(self)  # creates stub when gRPC
 
         # step4: if object exists: take instance, else create it:

ansys/dpf/core/dpf_operator.py

@@ -5,7 +5,6 @@
 ========
 """
 
-import functools
 import logging
 import os
 import traceback
@@ -29,6 +28,24 @@
 LOG.setLevel("DEBUG")
 
 
+class _SubOperator:
+    def __init__(self, op_name, op_to_connect):
+        self.op_name = op_name
+        self.op = Operator(self.op_name, server=op_to_connect._server)
+        if op_to_connect.inputs is not None:
+            for key in op_to_connect.inputs._connected_inputs:
+                inpt = op_to_connect.inputs._connected_inputs[key]
+                if type(inpt).__name__ == "dict":
+                    for keyout in inpt:
+                        if inpt[keyout]() is not None:
+                            self.op.connect(key, inpt[keyout](), keyout)
+                else:
+                    self.op.connect(key, inpt())
+
+    def __call__(self):
+        return self.op
+
+
 class Operator:
     """Represents an operator, which is an elementary operation.
 
@@ -74,7 +91,6 @@ def __init__(self, name, config=None, server=None):
         self._internal_obj = None
         self._description = None
         self._inputs = None
-        self._outputs = None
 
         # step 1: get server
         self._server = server_module.get_or_create_server(server)
@@ -98,8 +114,6 @@ def __init__(self, name, config=None, server=None):
         # add dynamic inputs
         if len(self._spec.inputs) > 0 and self._inputs is None:
             self._inputs = Inputs(self._spec.inputs, self)
-        if len(self._spec.outputs) != 0 and self._outputs is None:
-            self._outputs = Outputs(self._spec.outputs, self)
 
         # step4: if object exists: take instance (config)
         if config:
@@ -138,9 +152,21 @@ def _add_sub_res_operators(self, sub_results):
         """
 
         for result_type in sub_results:
-            bound_method = self._sub_result_op.__get__(self, self.__class__)
-            method2 = functools.partial(bound_method, name=result_type["operator name"])
-            setattr(self, result_type["name"], method2)
+            try:
+                setattr(self, result_type["name"], _SubOperator(result_type["operator name"], self))
+            except KeyError:
+                pass
+
+    @property
+    def _outputs(self):
+        if self._spec and len(self._spec.outputs) != 0:
+            return Outputs(self._spec.outputs, self)
+
+    @_outputs.setter
+    def _outputs(self, value):
+        # the Operator should not hold a reference on its outputs because outputs hold a reference
+        # on the Operator
+        pass
 
     @property
     @version_requires("3.0")
@@ -189,7 +215,7 @@ def connect(self, pin, inpt, pin_out=0):
         elif isinstance(inpt, Operator):
             self._api.operator_connect_operator_output(self, pin, inpt, pin_out)
         elif isinstance(inpt, Output):
-            self._api.operator_connect_operator_output(self, pin, inpt._operator(), inpt._pin)
+            self._api.operator_connect_operator_output(self, pin, inpt._operator, inpt._pin)
         elif isinstance(inpt, list):
             from ansys.dpf.core import collection
             if server_meet_version("3.0", self._server):
@@ -538,18 +564,6 @@ def _find_outputs_corresponding_pins(
             elif python_name == "Any":
                 corresponding_pins.append(pin)
 
-    def _sub_result_op(self, name):
-        op = Operator(name)
-        if self.inputs is not None:
-            for key in self.inputs._connected_inputs:
-                inpt = self.inputs._connected_inputs[key]
-                if type(inpt).__name__ == "dict":
-                    for keyout in inpt:
-                        op.connect(key, inpt[keyout], keyout)
-                else:
-                    op.connect(key, inpt)
-        return op
-
     def __add__(self, fields_b):
         """Add two fields or two fields containers.
 

ansys/dpf/core/inputs.py

@@ -114,21 +114,22 @@ def connect(self, inpt):
         from ansys.dpf.core.results import Result
 
         if isinstance(inpt, _Outputs):
-            self._operator().connect(self._pin, inpt._operator(), corresponding_pins[0][1])
+            self._operator().connect(self._pin, inpt._operator, corresponding_pins[0][1])
             self._operator().inputs._connected_inputs[self._pin] = {
-                corresponding_pins[0][1]: inpt._operator()
+                corresponding_pins[0][1]: weakref.ref(inpt._operator)
             }
         elif isinstance(inpt, Output):
-            self._operator().connect(self._pin, inpt._operator(), inpt._pin)
-            self._operator().inputs._connected_inputs[self._pin] = {inpt._pin: inpt}
+            self._operator().connect(self._pin, inpt._operator, inpt._pin)
+            self._operator().inputs._connected_inputs[self._pin] = {inpt._pin: weakref.ref(inpt)}
         elif isinstance(inpt, Result):
             self._operator().connect(self._pin, inpt(), corresponding_pins[0][1])
             self._operator().inputs._connected_inputs[self._pin] = {
-                corresponding_pins[0][1]: inpt()
+                corresponding_pins[0][1]: weakref.ref(inpt)
                 }
         else:
             self._operator().connect(self._pin, inpt)
-            self._operator().inputs._connected_inputs[self._pin] = inpt
+            self._operator().inputs._connected_inputs[self._pin] = weakref.ref(inpt) \
+                if hasattr(inpt, "__weakref__") else inpt
 
         self.__inc_if_ellipsis()
 
@@ -242,25 +243,26 @@ def connect(self, inpt):
 
         from ansys.dpf.core.results import Result
         if isinstance(inpt, Output):
-            self._operator().connect(corresponding_pins[0], inpt._operator(), inpt._pin)
-            self._connected_inputs[corresponding_pins[0]] = {inpt._pin: inpt._operator()}
+            self._operator().connect(corresponding_pins[0], inpt._operator, inpt._pin)
+            self._connected_inputs[corresponding_pins[0]] = {inpt._pin: weakref.ref(inpt._operator)}
         elif isinstance(inpt, _Outputs):
             self._operator().connect(
-                corresponding_pins[0][0], inpt._operator(), corresponding_pins[0][1]
+                corresponding_pins[0][0], inpt._operator, corresponding_pins[0][1]
             )
             self._connected_inputs[corresponding_pins[0][0]] = {
-                corresponding_pins[0][1]: inpt._operator()
+                corresponding_pins[0][1]: weakref.ref(inpt._operator)
             }
         elif isinstance(inpt, Result):
             self._operator().connect(
                 corresponding_pins[0][0], inpt(), corresponding_pins[0][1]
             )
             self._connected_inputs[corresponding_pins[0][0]] = {
-                corresponding_pins[0][1]: inpt()
+                corresponding_pins[0][1]: weakref.ref(inpt)
             }
         else:
             self._operator().connect(corresponding_pins[0], inpt)
-            self._connected_inputs[corresponding_pins[0]] = inpt
+            self._connected_inputs[corresponding_pins[0]] = weakref.ref(inpt) \
+                if hasattr(inpt, "__weakref__") else inpt
 
     def _add_input(self, pin, spec, count_ellipsis=-1):
         if spec is not None:

ansys/dpf/core/misc.py

@@ -3,6 +3,9 @@
 import glob
 import os
 from pkgutil import iter_modules
+from ansys.dpf.core._version import (
+    __ansys_version__
+)
 
 
 DEFAULT_FILE_CHUNK_SIZE = 524288
@@ -57,8 +60,46 @@ def is_ubuntu():
     return False
 
 
+def get_ansys_path(ansys_path=None):
+    """Give input path back if given, else look for ANSYS_DPF_PATH, then AWP_ROOT+__ansys_version__,
+    then calls for find_ansys as a last resort.
+
+    Parameters
+    ----------
+    ansys_path : str
+        Full path to an Ansys installation to use.
+
+    Returns
+    -------
+    ansys_path : str
+        Full path to an Ansys installation.
+
+    """
+    # If no custom path was given in input
+    # First check the environment variable for a custom path
+    if ansys_path is None:
+        ansys_path = os.environ.get("ANSYS_DPF_PATH")
+    # Then check for usual installation folders with AWP_ROOT and find_ansys
+    if ansys_path is None:
+        ansys_path = os.environ.get("AWP_ROOT" + __ansys_version__)
+    if ansys_path is None:
+        ansys_path = find_ansys()
+    # If still no install has been found, throw an exception
+    if ansys_path is None:
+        raise ValueError(
+            "Unable to locate any Ansys installation.\n"
+            f'Make sure the "AWP_ROOT{__ansys_version__}" environment variable '
+            f"is set if using ANSYS version {__ansys_version__}.\n"
+            "You can also manually define the path to the ANSYS installation root folder"
+            " of the version you want to use (vXXX folder):\n"
+            '- when starting the server with "start_local_server(ansys_path=*/vXXX)"\n'
+            '- or by setting it by default with the environment variable "ANSYS_DPF_PATH"')
+    return ansys_path
+
+
 def find_ansys():
-    """Search the standard installation location to find the path to the latest Ansys installation.
+    """Search for a standard ANSYS environment variable (AWP_ROOTXXX) or a standard installation
+    location to find the path to the latest Ansys installation.
 
     Returns
     -------
@@ -77,6 +118,17 @@ def find_ansys():
     >>> path = find_ansys()
 
     """
+    versions = [key[-3:] for key in os.environ.keys() if "AWP_ROOT" in key]
+    for version in sorted(versions, reverse=True):
+        if not version.isnumeric():
+            continue
+        if version == __ansys_version__:
+            continue
+        elif version < __ansys_version__:
+            ansys_path = os.environ.get("AWP_ROOT" + version)
+            if ansys_path:
+                return ansys_path
+
     base_path = None
     if os.name == "nt":
         base_path = os.path.join(os.environ["PROGRAMFILES"], "ANSYS INC")