fix deep copy (#1353)

Author: cbellot000

src/ansys/dpf/core/common.py

@@ -99,6 +99,7 @@ class types(Enum):
     scopings_container = -2
     meshes_container = -3
     streams_container = -4
+    bytes = -5
 
 
 def types_enum_to_types():
@@ -131,6 +132,7 @@ def types_enum_to_types():
         types.int: int,
         types.double: float,
         types.bool: bool,
+        types.bytes: bytes,
         types.collection: collection.Collection,
         types.fields_container: fields_container.FieldsContainer,
         types.scopings_container: scopings_container.ScopingsContainer,

src/ansys/dpf/core/core.py

@@ -9,7 +9,7 @@
 
 from ansys.dpf.core import errors, misc
 from ansys.dpf.core import server as server_module
-from ansys.dpf.core.check_version import version_requires
+from ansys.dpf.core.check_version import version_requires, server_meet_version
 from ansys.dpf.core.runtime_config import (
     RuntimeClientConfig,
     RuntimeCoreConfig,
@@ -282,12 +282,19 @@ def _deep_copy(dpf_entity, server=None):
                                 core.Field, core.FieldsContainer, core.MeshedRegion...
     """
     from ansys.dpf.core.operators.serialization import serializer_to_string, string_deserializer
-    from ansys.dpf.core.common import types_enum_to_types
-
-    serializer = serializer_to_string(server=server)
+    from ansys.dpf.core.common import types_enum_to_types, types
+    entity_server = dpf_entity._server if hasattr(dpf_entity, "_server") else None
+    serializer = serializer_to_string(server=entity_server)
     serializer.connect(1, dpf_entity)
     deserializer = string_deserializer(server=server)
-    deserializer.connect(0, serializer, 0)
+    stream_type = 1 if server_meet_version("8.0", serializer._server) else 0
+    serializer.connect(-1, stream_type)
+    if stream_type == 1:
+        out = serializer.get_output(0, types.bytes)
+    else:
+        out = serializer.get_output(0, types.string)
+    deserializer.connect(-1, stream_type)
+    deserializer.connect(0, out)
     type_map = types_enum_to_types()
     output_type = list(type_map.keys())[list(type_map.values()).index(dpf_entity.__class__)]
     return deserializer.get_output(1, output_type)

src/ansys/dpf/core/dpf_operator.py

@@ -11,7 +11,7 @@
 import warnings
 
 from enum import Enum
-from ansys.dpf.core.check_version import version_requires, server_meet_version
+from ansys.dpf.core.check_version import version_requires, server_meet_version, server_meet_version_and_raise
 from ansys.dpf.core.config import Config
 from ansys.dpf.core.errors import DpfVersionNotSupported
 from ansys.dpf.core.inputs import Inputs
@@ -31,6 +31,7 @@
     collection_grpcapi,
     dpf_vector,
     object_handler,
+    integral_types
 )
 
 LOG = logging.getLogger(__name__)
@@ -280,6 +281,42 @@ def connect_operator_as_input(self, pin, op):
         """
         self._api.operator_connect_operator_as_input(self, pin, op)
 
+    @staticmethod
+    def _getoutput_string(self, pin):
+        out = Operator._getoutput_string_as_bytes(self, pin)
+        if out is not None and not isinstance(out, str):
+            return out.decode('utf-8')
+        return out
+
+    @staticmethod
+    def _connect_string(self, pin, str):
+        return Operator._connect_string_as_bytes(self, pin, str.encode('utf-8'))
+
+    @staticmethod
+    def _getoutput_string_as_bytes(self, pin):
+        if server_meet_version("8.0", self._server):
+            size = integral_types.MutableUInt64(0)
+            return self._api.operator_getoutput_string_with_size(self, pin, size)
+        else:
+            return self._api.operator_getoutput_string(self, pin)
+
+    @staticmethod
+    def _getoutput_bytes(self, pin):
+        server_meet_version_and_raise(
+            "8.0",
+            self._server,
+            "output of type bytes available with server's version starting at 8.0 (Ansys 2024R2)."
+        )
+        return Operator._getoutput_string_as_bytes(self, pin)
+
+    @staticmethod
+    def _connect_string_as_bytes(self, pin, str):
+        if server_meet_version("8.0", self._server):
+            size = integral_types.MutableUInt64(len(str))
+            return self._api.operator_connect_string_with_size(self, pin, str, size)
+        else:
+            return self._api.operator_connect_string(self, pin, str)
+
     @property
     def _type_to_output_method(self):
         from ansys.dpf.core import (
@@ -307,7 +344,8 @@ def _type_to_output_method(self):
         out = [
             (bool, self._api.operator_getoutput_bool),
             (int, self._api.operator_getoutput_int),
-            (str, self._api.operator_getoutput_string),
+            (str, self._getoutput_string),
+            (bytes, self._getoutput_bytes),
             (float, self._api.operator_getoutput_double),
             (field.Field, self._api.operator_getoutput_field, "field"),
             (
@@ -425,7 +463,8 @@ def _type_to_input_method(self):
         out = [
             (bool, self._api.operator_connect_bool),
             ((int, Enum), self._api.operator_connect_int),
-            (str, self._api.operator_connect_string),
+            (str, self._connect_string),
+            (bytes, self._connect_string_as_bytes),
             (float, self._api.operator_connect_double),
             (field.Field, self._api.operator_connect_field),
             (property_field.PropertyField, self._api.operator_connect_property_field),

src/ansys/dpf/core/workflow.py

@@ -11,7 +11,7 @@
 from enum import Enum
 from ansys import dpf
 from ansys.dpf.core import dpf_operator, inputs, outputs
-from ansys.dpf.core.check_version import server_meet_version, version_requires
+from ansys.dpf.core.check_version import server_meet_version, version_requires, server_meet_version_and_raise
 from ansys.dpf.core import server as server_module
 from ansys.dpf.gate import (
     workflow_abstract_api,
@@ -20,7 +20,7 @@
     data_processing_capi,
     data_processing_grpcapi,
     dpf_vector,
-    object_handler,
+    object_handler, integral_types,
 )
 
 LOG = logging.getLogger(__name__)
@@ -106,6 +106,42 @@ def progress_bar(self) -> bool:
     def progress_bar(self, value: bool) -> None:
         self._progress_bar = value
 
+    @staticmethod
+    def _getoutput_string(self, pin):
+        out = Workflow._getoutput_string_as_bytes(self, pin)
+        if out is not None and not isinstance(out, str):
+            return out.decode('utf-8')
+        return out
+
+    @staticmethod
+    def _connect_string(self, pin, str):
+        return Workflow._connect_string_as_bytes(self, pin, str.encode('utf-8'))
+
+    @staticmethod
+    def _getoutput_string_as_bytes(self, pin):
+        if server_meet_version("8.0", self._server):
+            size = integral_types.MutableUInt64(0)
+            return self._api.work_flow_getoutput_string_with_size(self, pin, size)
+        else:
+            return self._api.work_flow_getoutput_string(self, pin)
+
+    @staticmethod
+    def _getoutput_bytes(self, pin):
+        server_meet_version_and_raise(
+            "8.0",
+            self._server,
+            "output of type bytes available with server's version starting at 8.0 (Ansys 2024R2)."
+        )
+        return Workflow._getoutput_string_as_bytes(self, pin)
+
+    @staticmethod
+    def _connect_string_as_bytes(self, pin, str):
+        if server_meet_version("8.0", self._server):
+            size = integral_types.MutableUInt64(len(str))
+            return self._api.work_flow_connect_string_with_size(self, pin, str, size)
+        else:
+            return self._api.work_flow_connect_string(self, pin, str)
+
     def connect(self, pin_name, inpt, pin_out=0):
         """Connect an input on the workflow using a pin name.
 
@@ -199,7 +235,8 @@ def _type_to_input_method(self):
         out = [
             (bool, self._api.work_flow_connect_bool),
             ((int, Enum), self._api.work_flow_connect_int),
-            (str, self._api.work_flow_connect_string),
+            (str, self._connect_string),
+            (bytes, self._connect_string_as_bytes),
             (float, self._api.work_flow_connect_double),
             (field.Field, self._api.work_flow_connect_field),
             (property_field.PropertyField, self._api.work_flow_connect_property_field),
@@ -260,7 +297,8 @@ def _type_to_output_method(self):
         out = [
             (bool, self._api.work_flow_getoutput_bool),
             (int, self._api.work_flow_getoutput_int),
-            (str, self._api.work_flow_getoutput_string),
+            (str, self._getoutput_string),
+            (bytes, self._getoutput_bytes),
             (float, self._api.work_flow_getoutput_double),
             (field.Field, self._api.work_flow_getoutput_field, "field"),
             (

tests/test_field.py

@@ -8,7 +8,7 @@
 from ansys.dpf.core import FieldDefinition
 from ansys.dpf.core import operators as ops
 from ansys.dpf.core.common import locations, shell_layers
-from conftest import running_docker
+from conftest import running_docker, SERVERS_VERSION_GREATER_THAN_OR_EQUAL_TO_8_0
 
 
 @pytest.fixture()
@@ -1296,3 +1296,41 @@ def test_field_no_inprocess_localfield(server_in_process, allkindofcomplexity):
 
     with field.as_local_field() as local_field:
         assert field == local_field
+
+
+def test_deep_copy_2_field(server_type, server_in_process):
+    data = np.random.random(10)
+    field_a = dpf.core.field_from_array(data, server=server_type)
+    assert np.allclose(field_a.data, data)
+
+    out = dpf.core.core._deep_copy(field_a, server_in_process)
+    assert np.allclose(out.data, data)
+
+
+def test_deep_copy_2_field_remote(server_type, server_type_remote_process):
+    data = np.random.random(10)
+    field_a = dpf.core.field_from_array(data, server=server_type)
+    assert np.allclose(field_a.data, data)
+
+    out = dpf.core.core._deep_copy(field_a, server_type_remote_process)
+    assert np.allclose(out.data, data)
+
+
+@pytest.mark.skipif(not SERVERS_VERSION_GREATER_THAN_OR_EQUAL_TO_8_0, reason="Available for servers >=8.0")
+def test_deep_copy_big_field(server_type, server_in_process):
+    data = np.random.random(100000)
+    field_a = dpf.core.field_from_array(data, server=server_type)
+    assert np.allclose(field_a.data, data)
+
+    out = dpf.core.core._deep_copy(field_a, server_in_process)
+    assert np.allclose(out.data, data)
+
+
+@pytest.mark.skipif(not SERVERS_VERSION_GREATER_THAN_OR_EQUAL_TO_8_0, reason="Available for servers >=8.0")
+def test_deep_copy_big_field_remote(server_type, server_type_remote_process):
+    data = np.random.random(100000)
+    field_a = dpf.core.field_from_array(data, server=server_type)
+    assert np.allclose(field_a.data, data)
+
+    out = dpf.core.core._deep_copy(field_a, server_type_remote_process)
+    assert np.allclose(out.data, data)

tests/test_operator.py

@@ -1,6 +1,7 @@
 import gc
 import os
 import shutil
+import types
 import weakref
 
 import numpy as np
@@ -324,8 +325,8 @@ def test_inputs_outputs_1_operator(cyclic_lin_rst, cyclic_ds, tmpdir):
     coord = meshed_region.nodes.coordinates_field
     assert coord.shape == (meshed_region.nodes.n_nodes, 3)
     assert (
-        meshed_region.elements.connectivities_field.data.size
-        == meshed_region.elements.connectivities_field.size
+            meshed_region.elements.connectivities_field.data.size
+            == meshed_region.elements.connectivities_field.size
     )
 
 
@@ -1266,8 +1267,8 @@ def test_operator_config_specification_simple(server_type):
     conf_spec = spec.config_specification
     if server_type.os != "posix":
         assert (
-            "enum dataProcessing::EBinaryOperation"
-            or "binary_operation_enum" in conf_spec["binary_operation"].type_names
+                "enum dataProcessing::EBinaryOperation"
+                or "binary_operation_enum" in conf_spec["binary_operation"].type_names
         )
     elif SERVERS_VERSION_GREATER_THAN_OR_EQUAL_TO_6_2:
         assert "binary_operation_enum" in conf_spec["binary_operation"].type_names
@@ -1284,8 +1285,8 @@ def test_generated_operator_config_specification_simple(server_type):
     conf_spec = spec.config_specification
     if server_type.os != "posix":
         assert (
-            "enum dataProcessing::EBinaryOperation"
-            or "binary_operation_enum" in conf_spec["binary_operation"].type_names
+                "enum dataProcessing::EBinaryOperation"
+                or "binary_operation_enum" in conf_spec["binary_operation"].type_names
         )
     elif SERVERS_VERSION_GREATER_THAN_OR_EQUAL_TO_6_2:
         assert "binary_operation_enum" in conf_spec["binary_operation"].type_names
@@ -1325,3 +1326,40 @@ def test_delete_auto_operator(server_type):
     op = None
     gc.collect()
     assert op_ref() is None
+
+
+def deep_copy_using_operator(dpf_entity, server, stream_type=1):
+    from ansys.dpf.core.operators.serialization import serializer_to_string, string_deserializer
+    serializer = serializer_to_string(server=server)
+    serializer.connect(-1, stream_type)
+    serializer.connect(1, dpf_entity)
+    if stream_type == 1:
+        s_out = serializer.get_output(0, dpf.core.types.bytes)
+    else:
+        s_out = serializer.get_output(0, dpf.core.types.string)
+    deserializer = string_deserializer(server=server)
+    deserializer.connect(-1, stream_type)
+    deserializer.connect(0, s_out)
+    str_out = deserializer.get_output(1, dpf.core.types.string)
+    return str_out
+
+
+@conftest.raises_for_servers_version_under("8.0")
+def test_connect_get_non_ascii_string_bytes(server_type):
+    stream_type = 1
+    str = "\N{GREEK CAPITAL LETTER DELTA}"
+    str_out = deep_copy_using_operator(str, server_type, stream_type)
+    assert str == str_out
+
+
+def test_connect_get_non_ascii_string(server_type):
+    stream_type = 0
+    str = "\N{GREEK CAPITAL LETTER DELTA}"
+    str_out = deep_copy_using_operator(str, server_type, stream_type)
+    assert str == str_out
+
+
+def test_deep_copy_non_ascii_string(server_type):
+    str = "\N{GREEK CAPITAL LETTER DELTA}"
+    str_out = dpf.core.core._deep_copy(str, server_type)
+    assert str == str_out