Merge branch 'master' into feat/add_available_qualifiers_to_result_info_str

Author: PProfizi

src/ansys/dpf/core/any.py

@@ -11,6 +11,7 @@
 from ansys.dpf.core import server as server_module
 from ansys.dpf.core import errors
 from ansys.dpf.core.common import type_to_internal_object_keyword
+from ansys.dpf.gate import any_abstract_api
 
 
 class Any:
@@ -55,6 +56,7 @@ def _type_to_new_from_get_as_method(any_dpf):
             generic_data_container,
             string_field,
             scoping,
+            data_tree,
         )
 
         return [
@@ -97,6 +99,11 @@ def _type_to_new_from_get_as_method(any_dpf):
                 any_dpf._api.any_new_from_scoping,
                 any_dpf._api.any_get_as_scoping,
             ),
+            (
+                data_tree.DataTree,
+                any_dpf._api.any_new_from_data_tree,
+                any_dpf._api.any_get_as_data_tree,
+            ),
         ]
 
     @staticmethod
@@ -138,7 +145,7 @@ def new_from(obj, server=None):
         raise TypeError(f"{obj.__class__} is not currently supported by the Any class.")
 
     @property
-    def _api(self):
+    def _api(self) -> any_abstract_api.AnyAbstractAPI:
         from ansys.dpf.gate import any_capi, any_grpcapi
 
         if not self._api_instance:

src/ansys/dpf/core/data_tree.py

@@ -482,11 +482,108 @@ def get_as(self, name, type_to_return=types.string):
             out = DataTree(data_tree=obj, server=self._server)
         return out
 
+    def get_attribute_names(self):
+        """
+        Returns a list of defined attribute names.
+
+        Returns
+        -------
+        list[str]
+
+        Examples
+        --------
+        >>> from ansys.dpf import core as dpf
+        >>> data_tree = dpf.DataTree()
+        >>> data_tree.add(id=3, qualities=["nice", "funny"], name="George")
+        >>> data_tree.get_attribute_names()
+        ['id', 'name', 'qualities']
+        """
+        coll_obj = collection.StringCollection(
+            collection=self._api.dpf_data_tree_get_available_attributes_names_in_string_collection(
+                self
+            ),
+            server=self._server,
+        )
+
+        return coll_obj.get_integral_entries()
+
+    def get_sub_tree_names(self):
+        """
+        Returns a list of defined sub-tree names.
+
+        Returns
+        -------
+        list[str]
+
+        Examples
+        --------
+        >>> from ansys.dpf import core as dpf
+        >>> data_tree = dpf.DataTree()
+        >>> first_subtree = dpf.DataTree()
+        >>> second_subtree = dpf.DataTree()
+        >>> data_tree.add(first=first_subtree, second=second_subtree)
+        >>> data_tree.get_sub_tree_names()
+        ['first', 'second']
+        """
+        coll_obj = collection.StringCollection(
+            collection=self._api.dpf_data_tree_get_available_sub_tree_names_in_string_collection(
+                self
+            ),
+            server=self._server,
+        )
+
+        return coll_obj.get_integral_entries()
+
+    def __to_dict(self, dic):
+        for attribute_name in self.get_attribute_names():
+            dic[attribute_name] = self.get_as(attribute_name)
+
+        for sub_tree_name in self.get_sub_tree_names():
+            sub_tree = self.get_as(sub_tree_name, types.data_tree)
+            sub_dic = {}
+            sub_tree.__to_dict(sub_dic)
+            dic[sub_tree_name] = sub_dic
+
+    def to_dict(self):
+        """
+        Returns a dictionary representation of the DataTree
+
+        Returns
+        -------
+        dict
+
+        Examples
+        --------
+        >>> from ansys.dpf import core as dpf
+        >>> data_tree = dpf.DataTree()
+        >>> sub = dpf.DataTree()
+        >>> sub.add(str="hello world")
+        >>> data_tree.add(id=3, sub_tree=sub)
+        >>> data_tree.to_dict()
+        {'id': '3', 'sub_tree': {'str': 'hello world'}}
+        """
+        dic = {}
+        self.__to_dict(dic)
+
+        return dic
+
     def __setattr__(self, key, value):
         if key == "_common_keys" or key in self._common_keys:
             return super.__setattr__(self, key, value)
         self.add({key: value})
 
+    def __str__(self):
+        """Describe the entity.
+
+        Returns
+        -------
+        str
+            Description of the entity.
+        """
+        from ansys.dpf.core.core import _description
+
+        return _description(self._internal_obj, self._server)
+
     def __del__(self):
         try:
             # needs a proper deleter only when real datatree and not dict

src/ansys/dpf/core/generic_data_container.py

@@ -6,6 +6,7 @@
 """
 import traceback
 import warnings
+import builtins
 
 from ansys.dpf.core import server as server_module
 from ansys.dpf.core import errors
@@ -110,31 +111,14 @@ def get_property(self, property_name):
         """
         any_ptr = self._api.generic_data_container_get_property_any(self, property_name)
         any_dpf = Any(any_ptr, self._server)
-        output_type = self._type_to_output_method[self.get_property_description()[property_name]]
-        return any_dpf.cast(output_type)
+        output_type = self.get_property_description()[property_name]
+        class_ = getattr(builtins, output_type, None)
+        if class_ is None:
+            from ansys.dpf import core
 
-    @property
-    def _type_to_output_method(self):
-        # Only the types in any.py need to be casted
-        from ansys.dpf.core import (
-            field,
-            property_field,
-            string_field,
-            scoping,
-        )
+            class_ = getattr(core, output_type)
 
-        out = {
-            "bool": bool,
-            "int": int,
-            "str": str,
-            "float": float,
-            "Field": field.Field,
-            "PropertyField": property_field.PropertyField,
-            "StringField": string_field.StringField,
-            "Scoping": scoping.Scoping,
-            "GenericDataContainer": GenericDataContainer,
-        }
-        return out
+        return any_dpf.cast(class_)
 
     def get_property_description(self):
         """Get a dictionary description of properties by name and data type

src/ansys/dpf/core/mesh_info.py

@@ -131,7 +131,7 @@ def set_property(self, property_name, prop):
         return self.generic_data_container.set_property(property_name, prop)
 
     @property
-    def get_number_nodes(self):
+    def number_nodes(self):
         """
         Returns
         -------
@@ -142,7 +142,7 @@ def get_number_nodes(self):
         return self.generic_data_container.get_property("num_nodes")
 
     @property
-    def get_number_elements(self):
+    def number_elements(self):
         """
         Returns
         -------
@@ -153,7 +153,7 @@ def get_number_elements(self):
         return self.generic_data_container.get_property("num_elements")
 
     @property
-    def get_splittable_by(self):
+    def splittable_by(self):
         """
         Returns
         -------
@@ -164,7 +164,7 @@ def get_splittable_by(self):
         return self.generic_data_container.get_property("splittable_by")
 
     @property
-    def get_available_elem_types(self):
+    def available_elem_types(self):
         """
         Returns
         -------
@@ -174,22 +174,26 @@ def get_available_elem_types(self):
 
         return self.generic_data_container.get_property("avalaible_elem_type")
 
-    def set_number_nodes(self, number_of_nodes):
+    @number_nodes.setter
+    def number_nodes(self, value):
         """Set the number of nodes in the mesh"""
 
-        return self.generic_data_container.set_property("num_nodes", number_of_nodes)
+        self.generic_data_container.set_property("num_nodes", value)
 
-    def set_number_elements(self, number_of_elements):
+    @number_elements.setter
+    def number_elements(self, value):
         """Set the number of elements in the mesh"""
 
-        return self.generic_data_container.set_property("num_elements", number_of_elements)
+        self.generic_data_container.set_property("num_elements", value)
 
-    def set_splittable_by(self, split):
+    @splittable_by.setter
+    def splittable_by(self, value):
         """Set name of the properties according to which the mesh can be split by"""
 
-        return self.generic_data_container.set_property("splittable_by", split)
+        self.generic_data_container.set_property("splittable_by", value)
 
-    def set_available_elem_types(self, available_elem_types):
+    @available_elem_types.setter
+    def available_elem_types(self, value):
         """Set the available element types"""
 
-        return self.generic_data_container.set_property("avalaible_elem_type", available_elem_types)
+        self.generic_data_container.set_property("avalaible_elem_type", value)

src/ansys/dpf/core/operator_specification.py

@@ -383,7 +383,9 @@ def _fill_pins(self, binput, to_fill):
                 ]
 
                 pin_derived_class_type_name = ""
-                if server_meet_version("7.0", self._server):
+                if server_meet_version("7.0", self._server) and hasattr(
+                    self._api, "operator_specification_get_pin_derived_class_type_name"
+                ):
                     pin_derived_class_type_name = (
                         self._api.operator_specification_get_pin_derived_class_type_name(
                             self, binput, i_pin
@@ -614,7 +616,9 @@ def inputs(self) -> dict:
     def inputs(self, val: dict):
         for key, value in val.items():
             list_types = integral_types.MutableListString(value.type_names)
-            if server_meet_version("7.0", self._server):
+            if server_meet_version("7.0", self._server) and hasattr(
+                self._api, "operator_specification_set_pin_derived_class"
+            ):
                 self._api.operator_specification_set_pin_derived_class(
                     self,
                     True,
@@ -655,7 +659,9 @@ def outputs(self) -> dict:
     def outputs(self, val: dict):
         for key, value in val.items():
             list_types = integral_types.MutableListString(value.type_names)
-            if server_meet_version("7.0", self._server):
+            if server_meet_version("7.0", self._server) and hasattr(
+                self._api, "operator_specification_set_pin_derived_class"
+            ):
                 self._api.operator_specification_set_pin_derived_class(
                     self,
                     False,

tests/test_data_tree.py

@@ -235,6 +235,19 @@ def test_read_from_txt_data_tree(server_type):
     assert data_tree.has("list_string")
 
 
+@conftest.raises_for_servers_version_under("4.0")
+def test_print_data_tree(server_type):
+    data_tree = dpf.DataTree(server=server_type)
+    with data_tree.to_fill() as to_fill:
+        to_fill.int = 1
+        to_fill.double = 1.0
+        to_fill.string = "hello"
+        to_fill.list_int = [1, 2]
+        to_fill.list_double = [1.5, 2.5]
+        to_fill.add(list_string=["hello", "bye"])
+    assert str(data_tree) != ""
+
+
 @conftest.raises_for_servers_version_under("4.0")
 def test_sub_data_tree():
     data_tree = dpf.DataTree()
@@ -316,3 +329,48 @@ def test_unsupported_types_data_tree(server_type):
         data_tree.add(data1=[[1]])
     with pytest.raises(TypeError):
         data_tree.add(data1=(1, 2))
+
+
+@pytest.mark.skipif(
+    not conftest.SERVERS_VERSION_GREATER_THAN_OR_EQUAL_TO_7_0, reason="Available for servers >=7.0"
+)
+def test_list_attributes_data_tree(server_type):
+    data_tree = dpf.DataTree(server=server_type)
+    with data_tree.to_fill() as to_fill:
+        to_fill.int = 1
+        to_fill.double = 1.0
+        to_fill.string = "hello"
+        to_fill.list_int = [1, 2]
+        to_fill.list_double = [1.5, 2.5]
+        to_fill.add(list_string=["hello", "bye"])
+
+    attributes = data_tree.get_attribute_names()
+
+    assert ["double", "int", "list_double", "list_int", "list_string", "string"] == attributes
+
+
+@pytest.mark.skipif(
+    not conftest.SERVERS_VERSION_GREATER_THAN_OR_EQUAL_TO_7_0, reason="Available for servers >=7.0"
+)
+def test_list_attributes_recursive_data_tree(server_type):
+    data_tree = dpf.DataTree(server=server_type)
+    with data_tree.to_fill() as to_fill:
+        to_fill.attribute01 = 1
+        sub_tree01 = dpf.DataTree(server=server_type)
+        with sub_tree01.to_fill() as to_fill01:
+            to_fill01.attribute02 = 2
+        to_fill.sub_tree01 = sub_tree01
+        sub_tree02 = dpf.DataTree(server=server_type)
+        to_fill.sub_tree02 = sub_tree02
+
+    attributes = data_tree.get_attribute_names()
+    sub_trees = data_tree.get_sub_tree_names()
+
+    assert attributes == ["attribute01"]
+    assert sub_trees == ["sub_tree01", "sub_tree02"]
+
+    dic = data_tree.to_dict()
+
+    assert ["attribute01", "sub_tree01", "sub_tree02"] == list(dic.keys())
+    assert {"attribute02": "2"} == dic["sub_tree01"]
+    assert {} == dic["sub_tree02"]

tests/test_generic_data_container.py

@@ -24,6 +24,18 @@ def test_set_get_property_generic_data_container(server_type):
     assert entity.location == new_entity.location
 
 
+@pytest.mark.skipif(
+    not SERVERS_VERSION_GREATER_THAN_OR_EQUAL_TO_7_0, reason="Available for servers >=7.0"
+)
+def test_set_get_data_tree_generic_data_container(server_type):
+    gdc = dpf.GenericDataContainer(server=server_type)
+    entity = dpf.DataTree(server=server_type)
+    entity.add(name="john")
+    gdc.set_property("persons", entity)
+    new_entity = gdc.get_property("persons")
+    assert new_entity.get_as("name") == "john"
+
+
 @pytest.mark.skipif(
     not SERVERS_VERSION_GREATER_THAN_OR_EQUAL_TO_7_0, reason="Available for servers >=7.0"
 )