ansys-fluent-core 0.27.dev1__py3-none-any.whl → 0.28.dev0__py3-none-any.whl

ansys/fluent/tests/test_datamodel_service.py

@@ -124,7 +124,7 @@ def test_add_on_deleted(new_meshing_session):
     meshing = new_meshing_session
     meshing.workflow.InitializeWorkflow(WorkflowType="Watertight Geometry")
     data = []
-    subscription = meshing.workflow.TaskObject["Import Geometry"].add_on_deleted(
+    _ = meshing.workflow.TaskObject["Import Geometry"].add_on_deleted(
         lambda obj: data.append(convert_path_to_se_path(obj.path))
     )
     assert data == []
@@ -166,7 +166,7 @@ def test_add_on_affected(new_meshing_session):
     wt = meshing.watertight()
     sleep(5)
     assert len(data) > 0
-    assert data[0] == True
+    assert data[0]
 
     calls = []
     subscription2 = meshing.workflow.add_on_affected(lambda obj: calls.append(True))
@@ -220,7 +220,7 @@ def test_add_on_affected_at_type_path(new_meshing_session):
     meshing.workflow.InitializeWorkflow(WorkflowType="Watertight Geometry")
     sleep(5)
     assert len(data) > 0
-    assert data[0] == True
+    assert data[0]
     data.clear()
     subscription.unsubscribe()
     meshing.workflow.InitializeWorkflow(WorkflowType="Fault-tolerant Meshing")
@@ -244,7 +244,7 @@ def test_add_on_command_executed(new_meshing_session):
     meshing.meshing.ImportGeometry(FileName=import_file_name)
     sleep(5)
     assert len(data) > 0
-    assert data[0] == True
+    assert data[0]
     data.clear()
     subscription.unsubscribe()
     meshing.meshing.ImportGeometry(FileName=import_file_name)
@@ -252,11 +252,6 @@ def test_add_on_command_executed(new_meshing_session):
     assert data == []
 
 
-@pytest.fixture
-def disable_datamodel_cache(monkeypatch: pytest.MonkeyPatch):
-    monkeypatch.setattr(pyfluent, "DATAMODEL_USE_STATE_CACHE", False)
-
-
 @pytest.mark.skip("https://github.com/ansys/pyfluent/issues/2999")
 @pytest.mark.fluent_version(">=23.2")
 @pytest.mark.codegen_required
@@ -591,7 +586,7 @@ def test_on_child_created_lifetime(new_solver_session):
     root = _create_datamodel_root(solver, test_rules)
     root.A["A1"] = {}
     data = []
-    h = root.A["A1"].add_on_child_created("B", lambda _: data.append(1))
+    _ = root.A["A1"].add_on_child_created("B", lambda _: data.append(1))
     root.A["A1"].add_on_child_created("B", lambda _: data.append(2))
     gc.collect()
     assert "/test/created/A:A1/B" in solver._se_service.subscriptions
@@ -609,7 +604,7 @@ def test_on_deleted_lifetime(new_solver_session):
     root = _create_datamodel_root(solver, test_rules)
     root.A["A1"] = {}
     data = []
-    h = root.A["A1"].add_on_deleted(lambda _: data.append(1))
+    _ = root.A["A1"].add_on_deleted(lambda _: data.append(1))
     root.A["A1"].add_on_deleted(lambda _: data.append(2))
     gc.collect()
     assert "/test/deleted/A:A1" in solver._se_service.subscriptions
@@ -630,7 +625,7 @@ def test_on_changed_lifetime(new_solver_session):
     root = _create_datamodel_root(solver, test_rules)
     root.A["A1"] = {}
     data = []
-    h = root.A["A1"].X.add_on_changed(lambda _: data.append(1))
+    _ = root.A["A1"].X.add_on_changed(lambda _: data.append(1))
     root.A["A1"].X.add_on_changed(lambda _: data.append(2))
     gc.collect()
     assert "/test/modified/A:A1/X" in solver._se_service.subscriptions
@@ -648,7 +643,7 @@ def test_on_affected_lifetime(new_solver_session):
     root = _create_datamodel_root(solver, test_rules)
     root.A["A1"] = {}
     data = []
-    h = root.A["A1"].add_on_affected(lambda _: data.append(1))
+    _ = root.A["A1"].add_on_affected(lambda _: data.append(1))
     root.A["A1"].add_on_affected(lambda _: data.append(2))
     gc.collect()
     assert "/test/affected/A:A1" in solver._se_service.subscriptions
@@ -666,7 +661,7 @@ def test_on_affected_at_type_path_lifetime(new_solver_session):
     root = _create_datamodel_root(solver, test_rules)
     root.A["A1"] = {}
     data = []
-    h = root.A["A1"].add_on_affected_at_type_path("B", lambda _: data.append(1))
+    _ = root.A["A1"].add_on_affected_at_type_path("B", lambda _: data.append(1))
     root.A["A1"].add_on_affected_at_type_path("B", lambda _: data.append(2))
     gc.collect()
     assert "/test/affected/A:A1/B" in solver._se_service.subscriptions
@@ -684,7 +679,7 @@ def test_on_command_executed_lifetime(new_solver_session):
     root = _create_datamodel_root(solver, test_rules)
     root.A["A1"] = {}
     data = []
-    h = root.A["A1"].add_on_command_executed("C", lambda *args: data.append(1))
+    _ = root.A["A1"].add_on_command_executed("C", lambda *args: data.append(1))
     root.A["A1"].add_on_command_executed("C", lambda *args: data.append(2))
     gc.collect()
     assert "/test/command_executed/A:A1/C" in solver._se_service.subscriptions
@@ -702,7 +697,7 @@ def test_on_attribute_changed_lifetime(new_solver_session):
     root = _create_datamodel_root(solver, test_rules)
     root.A["A1"] = {}
     data = []
-    h = root.A["A1"].add_on_attribute_changed("isABC", lambda _: data.append(1))
+    _ = root.A["A1"].add_on_attribute_changed("isABC", lambda _: data.append(1))
     root.A["A1"].add_on_attribute_changed("isABC", lambda _: data.append(2))
     gc.collect()
     assert "/test/attribute_changed/A:A1/isABC" in solver._se_service.subscriptions
@@ -722,7 +717,7 @@ def test_on_command_attribute_changed_lifetime(new_solver_session):
     root = _create_datamodel_root(solver, test_rules)
     root.A["A1"] = {}
     data = []
-    h = root.A["A1"].add_on_command_attribute_changed(
+    _ = root.A["A1"].add_on_command_attribute_changed(
         "C", "isABC", lambda _: data.append(1)
     )
     root.A["A1"].add_on_command_attribute_changed(
@@ -757,7 +752,7 @@ def test_on_affected_lifetime_with_delete_child_objects(new_solver_session):
     pyfluent.logging.enable()
     root.A["A1"] = {}
     data = []
-    h = root.A["A1"].add_on_affected(lambda _: data.append(1))
+    _ = root.A["A1"].add_on_affected(lambda _: data.append(1))
     root.A["A1"].add_on_affected(lambda _: data.append(2))
     gc.collect()
     assert "/test/affected/A:A1" in solver._se_service.subscriptions
@@ -776,7 +771,7 @@ def test_on_affected_lifetime_with_delete_all_child_objects(new_solver_session):
     pyfluent.logging.enable()
     root.A["A1"] = {}
     data = []
-    h = root.A["A1"].add_on_affected(lambda _: data.append(1))
+    _ = root.A["A1"].add_on_affected(lambda _: data.append(1))
     root.A["A1"].add_on_affected(lambda _: data.append(2))
     gc.collect()
     assert "/test/affected/A:A1" in solver._se_service.subscriptions

ansys/fluent/tests/test_field_data.py

@@ -191,48 +191,89 @@ def test_field_data_objects_3d(new_solver_session) -> None:
         field_name="absolute-pressure", surfaces=["cold-inlet"]
     )
 
-    assert abs_press_data.size == 241
-    assert abs_press_data[120].scalar_data == 101325.0
+    assert abs_press_data["cold-inlet"].shape == (241,)
+    assert abs_press_data["cold-inlet"][120] == 101325.0
 
     vertices_data = field_data.get_surface_data(
         data_types=[SurfaceDataType.Vertices], surfaces=["cold-inlet"]
     )
-    assert round(float(vertices_data[5].x), 2) == -0.2
-
-    faces_centroid_data = field_data.get_surface_data(
-        data_types=[SurfaceDataType.FacesCentroid], surfaces=["cold-inlet"]
+    assert vertices_data["cold-inlet"][SurfaceDataType.Vertices].shape == (241, 3)
+    assert (
+        round(float(vertices_data["cold-inlet"][SurfaceDataType.Vertices][5][0]), 2)
+        == -0.2
     )
-    assert round(float(faces_centroid_data[5].y), 2) == -0.18
 
-    faces_connectivity_data = field_data.get_surface_data(
-        data_types=[SurfaceDataType.FacesConnectivity], surfaces=["cold-inlet"]
+    vertices_and_faces_centroid_data = field_data.get_surface_data(
+        data_types=[SurfaceDataType.Vertices, SurfaceDataType.FacesCentroid],
+        surfaces=["hot-inlet", "cold-inlet"],
+    )
+    assert list(vertices_and_faces_centroid_data["cold-inlet"].keys()) == [
+        SurfaceDataType.Vertices,
+        SurfaceDataType.FacesCentroid,
+    ]
+    assert vertices_and_faces_centroid_data["hot-inlet"][
+        SurfaceDataType.Vertices
+    ].shape == (79, 3)
+    assert list(vertices_and_faces_centroid_data.keys()) == [
+        "hot-inlet",
+        "cold-inlet",
+    ]
+    assert (
+        round(
+            float(
+                vertices_and_faces_centroid_data["cold-inlet"][
+                    SurfaceDataType.FacesCentroid
+                ][5][1]
+            ),
+            2,
+        )
+        == -0.18
+    )
+    assert (
+        round(
+            float(
+                vertices_and_faces_centroid_data["hot-inlet"][
+                    SurfaceDataType.FacesCentroid
+                ][5][1]
+            ),
+            2,
+        )
+        == -0.23
     )
-    assert faces_connectivity_data[5].node_count == 4
-    assert (faces_connectivity_data[5].node_indices == [12, 13, 17, 16]).all()
 
     faces_normal_data = field_data.get_surface_data(
-        data_types=[SurfaceDataType.FacesNormal], surfaces=["cold-inlet"]
+        data_types=[SurfaceDataType.FacesNormal], surfaces=[3, 5]
+    )
+    assert faces_normal_data[3][SurfaceDataType.FacesNormal].shape == (152, 3)
+    assert faces_normal_data[5][SurfaceDataType.FacesNormal].shape == (2001, 3)
+
+    faces_connectivity_data = field_data.get_surface_data(
+        data_types=[SurfaceDataType.FacesConnectivity], surfaces=["cold-inlet"]
     )
-    assert faces_normal_data.size == 152
-    assert faces_normal_data.surface_id == 3
+    assert (
+        faces_connectivity_data["cold-inlet"][SurfaceDataType.FacesConnectivity][5]
+        == [12, 13, 17, 16]
+    ).all()
 
     velocity_vector_data = field_data.get_vector_field_data(
         field_name="velocity", surfaces=["cold-inlet"]
     )
 
-    assert velocity_vector_data.size == 152
-    assert velocity_vector_data.scale == 1.0
+    assert velocity_vector_data["cold-inlet"].shape == (152, 3)
 
     path_lines_data = field_data.get_pathlines_field_data(
-        field_name="velocity", surfaces=["cold-inlet"]
+        field_name="velocity", surfaces=["cold-inlet", "hot-inlet"]
     )
 
-    assert path_lines_data["vertices"].size == 76152
-    assert path_lines_data["lines"].size == 76000
-    assert path_lines_data["velocity"].size == 76152
+    assert path_lines_data["cold-inlet"]["vertices"].shape == (76152, 3)
+    assert len(path_lines_data["cold-inlet"]["lines"]) == 76000
+    assert path_lines_data["cold-inlet"]["velocity"].shape == (76152,)
+
+    assert path_lines_data["hot-inlet"]["vertices"].shape == (27555, 3)
+    assert len(path_lines_data["hot-inlet"]["lines"]) == 27500
+    assert path_lines_data["hot-inlet"]["velocity"].shape == (27555,)
 
-    assert path_lines_data["lines"][100].node_count == 2
-    assert all(path_lines_data["lines"][100].node_indices == [100, 101])
+    assert all(path_lines_data["cold-inlet"]["lines"][100] == [100, 101])
 
 
 @pytest.mark.fluent_version(">=23.2")
@@ -255,42 +296,49 @@ def test_field_data_objects_2d(disk_case_session) -> None:
         field_name="absolute-pressure", surfaces=["velocity-inlet-2"]
     )
 
-    assert abs_press_data.size == 11
-    assert abs_press_data[5].scalar_data == 101325.0
+    assert abs_press_data["velocity-inlet-2"].shape == (11,)
+    assert abs_press_data["velocity-inlet-2"][5] == 101325.0
 
     vertices_data = field_data.get_surface_data(
         data_types=[SurfaceDataType.Vertices], surfaces=["interior-4"]
     )
-    assert round(float(vertices_data[5].x), 2) == 0.0
+    assert round(vertices_data["interior-4"][SurfaceDataType.Vertices][5][0], 2) == 0.0
 
     faces_centroid_data = field_data.get_surface_data(
         data_types=[SurfaceDataType.FacesCentroid], surfaces=["velocity-inlet-2"]
     )
-    assert round(float(faces_centroid_data[5].y), 2) == 0.02
+    assert (
+        round(
+            float(
+                faces_centroid_data["velocity-inlet-2"][SurfaceDataType.FacesCentroid][
+                    5
+                ][1]
+            ),
+            2,
+        )
+        == 0.02
+    )
 
     faces_connectivity_data = field_data.get_surface_data(
         data_types=[SurfaceDataType.FacesConnectivity], surfaces=["velocity-inlet-2"]
-    )[5]
-    assert faces_connectivity_data.node_count == 2
-    assert (faces_connectivity_data.node_indices == [5, 6]).all()
+    )["velocity-inlet-2"][SurfaceDataType.FacesConnectivity][5]
+    assert (faces_connectivity_data == [5, 6]).all()
 
     velocity_vector_data = field_data.get_vector_field_data(
         field_name="velocity", surfaces=["velocity-inlet-2"]
     )
 
-    assert velocity_vector_data.size == 10
-    assert velocity_vector_data.scale == 1.0
+    assert velocity_vector_data["velocity-inlet-2"].shape == (10, 3)
 
     path_lines_data = field_data.get_pathlines_field_data(
         field_name="velocity", surfaces=["velocity-inlet-2"]
     )
 
-    assert path_lines_data["vertices"].size == 5010
-    assert path_lines_data["lines"].size == 5000
-    assert path_lines_data["velocity"].size == 5010
+    assert path_lines_data["velocity-inlet-2"]["vertices"].shape == (5010, 3)
+    assert len(path_lines_data["velocity-inlet-2"]["lines"]) == 5000
+    assert path_lines_data["velocity-inlet-2"]["velocity"].shape == (5010,)
 
-    assert path_lines_data["lines"][100].node_count == 2
-    assert all(path_lines_data["lines"][100].node_indices == [100, 101])
+    assert all(path_lines_data["velocity-inlet-2"]["lines"][100] == [100, 101])
 
 
 def test_field_data_errors(new_solver_session) -> None:
@@ -299,19 +347,19 @@ def test_field_data_errors(new_solver_session) -> None:
         "mixing_elbow.msh.h5", "pyfluent/mixing_elbow"
     )
 
-    with pytest.raises(DisallowedValuesError) as fne:
+    with pytest.raises(DisallowedValuesError):
         solver.fields.field_data.get_scalar_field_data(
             field_name="y-face-area", surfaces=[0]
         )
 
-    with pytest.raises(DisallowedValuesError) as fne:
+    with pytest.raises(DisallowedValuesError):
         solver.fields.field_data.get_scalar_field_data(
             field_name="partition-neighbors", surfaces=[0]
         )
 
     solver.file.read(file_type="case", file_name=import_file_name)
 
-    with pytest.raises(FieldUnavailable) as fnu:
+    with pytest.raises(FieldUnavailable):
         solver.fields.field_data.get_scalar_field_data(
             field_name="density", surfaces=[0]
         )
@@ -330,14 +378,14 @@ def test_field_data_errors(new_solver_session) -> None:
     solver.solution.initialization.hybrid_initialize()
 
     # Get field data object
-    field_data = solver.fields.field_data
+    assert solver.fields.field_data
 
-    with pytest.raises(DisallowedValuesError) as sne:
+    with pytest.raises(DisallowedValuesError):
         solver.fields.field_data.get_scalar_field_data(
             field_name="density", surfaces=["bob"]
         )
 
-    with pytest.raises(DisallowedValuesError) as fne:
+    with pytest.raises(DisallowedValuesError):
         solver.fields.field_data.get_scalar_field_data(
             field_name="xdensity", surfaces=[0]
         )
@@ -355,19 +403,19 @@ def test_field_info_validators(new_solver_session) -> None:
     vector_field_1 = solver.fields.field_info.validate_vector_fields("velocity")
     assert vector_field_1 is None
 
-    with pytest.raises(DisallowedValuesError) as vector_field_error:
+    with pytest.raises(DisallowedValuesError):
         solver.fields.field_info.validate_vector_fields("relative-vel")
 
     scalar_field_1 = solver.fields.field_info.validate_scalar_fields("z-velocity")
     assert scalar_field_1 is None
 
-    with pytest.raises(DisallowedValuesError) as scalar_field_error:
+    with pytest.raises(DisallowedValuesError):
         solver.fields.field_info.validate_scalar_fields("z-vel")
 
     surface = solver.fields.field_info.validate_surfaces(["cold-inlet"])
     assert surface is None
 
-    with pytest.raises(DisallowedValuesError) as surface_error:
+    with pytest.raises(DisallowedValuesError):
         solver.fields.field_info.validate_surfaces(["out"])
 
 

ansys/fluent/tests/test_file_session.py

@@ -42,20 +42,26 @@ def test_field_info_data_multi_phase():
     sv_density = file_session.fields.field_data.get_scalar_field_data(
         field_name="phase-2:SV_DENSITY", surfaces=[33]
     )
-    assert sv_density[33].size == 268
-    assert sv_density[33][130].scalar_data == 1.225
+    assert sv_density[33].shape == (268,)
+    assert sv_density[33][130] == 1.225
     assert (
         round(
             file_session.fields.field_data.get_scalar_field_data(
                 field_name="phase-2:SV_WALL_YPLUS", surfaces=[33]
-            )[33][130].scalar_data,
+            )[33][130],
             5,
         )
         == 0.00103
     )
     vector_data = file_session.fields.field_data.get_vector_field_data
-    assert vector_data(field_name="phase-2:velocity", surfaces=[33])[33].size == 268
-    assert vector_data(field_name="phase-1:velocity", surfaces=[34])[34].size == 2168
+    assert vector_data(field_name="phase-2:velocity", surfaces=[33])[33].shape == (
+        268,
+        3,
+    )
+    assert vector_data(field_name="phase-1:velocity", surfaces=[34])[34].shape == (
+        2168,
+        3,
+    )
 
 
 def test_field_info_data_single_phase():
@@ -88,32 +94,31 @@ def test_field_info_data_single_phase():
     sv_t_wall = file_session.fields.field_data.get_scalar_field_data(
         "SV_T", surfaces=["wall"]
     )
-    assert sv_t_wall.size == 3630
-    assert round(sv_t_wall[1800].scalar_data, 4) == 313.15
+    assert sv_t_wall["wall"].shape == (3630,)
+    assert round(sv_t_wall["wall"][1800], 4) == 313.15
 
     surface_data = file_session.fields.field_data.get_surface_data
     surface_data_wall = surface_data(
-        data_types=[SurfaceDataType.Vertices], surfaces=["wall"]
+        data_types=[SurfaceDataType.Vertices], surfaces=[3]
     )
-    assert surface_data_wall.size == 3810
-    assert round(surface_data_wall[1500].x, 5) == 0.12406
-    assert round(surface_data_wall[1500].y, 5) == 0.09525
-    assert round(surface_data_wall[1500].z, 5) == 0.04216
+    assert surface_data_wall[3].shape == (3810, 3)
+    assert round(surface_data_wall[3][1500][0], 5) == 0.12406
+    assert round(surface_data_wall[3][1500][1], 5) == 0.09525
+    assert round(surface_data_wall[3][1500][2], 5) == 0.04216
 
     surface_data_symmetry = surface_data(
         data_types=[SurfaceDataType.FacesConnectivity], surfaces=["symmetry"]
     )
-    assert surface_data_symmetry.size == 2018
-    assert surface_data_symmetry[1000].node_count == 4
-    assert list(surface_data_symmetry[1000].node_indices) == [1259, 1260, 1227, 1226]
+    assert len(surface_data_symmetry["symmetry"]) == 2018
+    assert list(surface_data_symmetry["symmetry"][1000]) == [1259, 1260, 1227, 1226]
 
     vector_data = file_session.fields.field_data.get_vector_field_data
-    assert vector_data("velocity", surfaces=["wall"]).size == 3630
+    assert vector_data("velocity", surfaces=["wall"])["wall"].shape == (3630, 3)
 
-    vector_data_symmetry = vector_data("velocity", surfaces=["symmetry"])
-    assert vector_data_symmetry.size == 2018
-    assert round(vector_data_symmetry[1009].x, 5) == 0.0023
-    assert round(vector_data_symmetry[1009].y, 5) == 1.22311
+    vector_data_symmetry = vector_data("velocity", surfaces=["symmetry"])["symmetry"]
+    assert vector_data_symmetry.shape == (2018, 3)
+    assert round(vector_data_symmetry[1009][0], 5) == 0.0023
+    assert round(vector_data_symmetry[1009][1], 5) == 1.22311
 
 
 def test_data_reader_single_phase():
@@ -315,10 +320,10 @@ def test_error_handling_single_phase():
 
     transaction_1 = field_data.new_transaction()
 
-    with pytest.raises(NotImplementedError) as msg:
+    with pytest.raises(NotImplementedError):
         transaction_1.add_pathlines_fields_request("SV_T", surfaces=[3, 5])
 
-    with pytest.raises(NotImplementedError) as msg:
+    with pytest.raises(NotImplementedError):
         field_data.get_pathlines_field_data("SV_T", surfaces=[3, 5])
 
 
@@ -340,13 +345,11 @@ def test_error_handling_multi_phase():
     field_data = file_session.fields.field_data
 
     transaction_1 = field_data.new_transaction()
-    with pytest.raises(InvalidMultiPhaseFieldName) as msg:
+    with pytest.raises(InvalidMultiPhaseFieldName):
         transaction_1.add_scalar_fields_request("SV_WALL_YPLUS", surfaces=[29, 30])
 
-    with pytest.raises(InvalidMultiPhaseFieldName) as msg:
-        d_size = field_data.get_vector_field_data("velocity", surfaces=[34])[34].size
+    with pytest.raises(InvalidMultiPhaseFieldName):
+        field_data.get_vector_field_data("velocity", surfaces=[34])[34].size
 
-    with pytest.raises(InvalidFieldName) as msg:
-        d_size = field_data.get_vector_field_data("phase-1:temperature", surfaces=[34])[
-            34
-        ].size
+    with pytest.raises(InvalidFieldName):
+        field_data.get_vector_field_data("phase-1:temperature", surfaces=[34])[34].size

ansys/fluent/tests/test_flobject.py

@@ -11,7 +11,6 @@ from ansys.fluent.core.examples import download_file
 from ansys.fluent.core.solver import flobject
 from ansys.fluent.core.solver.flobject import (
     InactiveObjectError,
-    _combine_set_states,
     _gethash,
     find_children,
 )
@@ -230,13 +229,12 @@ class ListObject(Setting):
     def size(self):
         return len(self._objs)
 
-    def resize(self, l):
-        if l > len(self._objs):
-            # pylint: disable=unused-variable
-            for i in range(len(self._objs), l):
+    def resize(self, new_size):
+        if new_size > len(self._objs):
+            for _ in range(len(self._objs), new_size):
                 self._objs.append(self.child_object_type(self))
-        elif l < len(self._objs):
-            self._objs = self._objs[:l]
+        elif new_size < len(self._objs):
+            self._objs = self._objs[:new_size]
 
     def get_child(self, c):
         return self._objs[int(c)]
@@ -271,6 +269,11 @@ class Command(Setting):
     # arguments = None
     # cb = None
 
+    def __init__(self, parent):
+        self.attrs = super().attrs.copy()
+        self.attrs["arguments-aliases"] = lambda self: {}
+        super().__init__(parent)
+
     def __call__(self, **kwds):
         args = []
         for k, v in self.arguments.items():
@@ -357,10 +360,6 @@ class Root(Group):
     }
 
 
-class _SchemeEval:
-    version = "25.1.0"
-
-
 class Proxy:
     """Proxy class."""
 
@@ -368,7 +367,6 @@ class Proxy:
 
     def __init__(self):
         self.r = self.root(None)
-        self._scheme_eval = _SchemeEval()
 
     def get_obj(self, path):
         if not path:
@@ -515,13 +513,14 @@ def test_command():
 
 
 def test_attrs():
-    r = flobject.get_root(Proxy(), version="251")
+    r = flobject.get_root(Proxy())
+    r._setattr("version", "251")
     assert r.g_1.s_4.get_attr("active?")
     assert r.g_1.s_4.get_attr("allowed-values") == ["foo", "bar"]
     r.g_1.b_3 = True
     assert not r.g_1.s_4.get_attr("active?")
-    with pytest.raises(InactiveObjectError) as einfo:
-        r.g_1.s_4.get_attr("allowed-values") == ["foo", "bar"]
+    with pytest.raises(InactiveObjectError):
+        r.g_1.s_4.get_attr("allowed-values")
 
 
 # The following test is commented out as codegen module is not packaged in the
@@ -916,7 +915,6 @@ def test_accessor_methods_on_settings_objects(new_solver_session):
         "Real",
         "Integer",
         "RealList",
-        "IntegerList",
         "ListObject",
     ]
     type_list = expected_type_list.copy()
@@ -989,7 +987,7 @@ def test_strings_with_allowed_values(static_mixer_settings_session):
     solver = static_mixer_settings_session
 
     with pytest.raises(AttributeError) as e:
-        string_without_allowed_values = solver.file.auto_save.root_name.allowed_values()
+        solver.file.auto_save.root_name.allowed_values()
     assert e.value.args[0] == "'root_name' object has no attribute 'allowed_values'"
 
     string_with_allowed_values = solver.setup.general.solver.type.allowed_values()
@@ -1029,7 +1027,7 @@ def test_ansys_units_integration(mixing_elbow_settings_session):
     hydraulic_diameter = turbulence.hydraulic_diameter
     hydraulic_diameter.set_state("1 [in]")
     assert hydraulic_diameter() == "1 [in]"
-    assert hydraulic_diameter.as_quantity() == None
+    assert hydraulic_diameter.as_quantity() is None
     assert hydraulic_diameter.state_with_units() == ("1 [in]", "m")
     assert hydraulic_diameter.units() == "m"
     turbulent_intensity = turbulence.turbulent_intensity
@@ -1077,9 +1075,6 @@ def test_ansys_units_integration(mixing_elbow_settings_session):
     _check_vector_units(
         solver.setup.general.operating_conditions.reference_pressure_location, "m"
     )
-    if solver.get_fluent_version() >= FluentVersion.v251:
-        # https://github.com/ansys/pyfluent/issues/3134
-        return
     _check_vector_units(
         solver.setup.reference_frames[
             "global"
@@ -1218,7 +1213,6 @@ def test_default_argument_names_for_commands(static_mixer_settings_session):
             "list_properties",
             "make_a_copy",
             "display",
-            "copy",
             "add_to_graphics",
             "clear_history",
         }
@@ -1239,39 +1233,3 @@ def test_default_argument_names_for_commands(static_mixer_settings_session):
     assert solver.results.graphics.contour.delete.argument_names == ["name_list"]
     # The following is the default behavior when no arguments are associated with the command.
     assert solver.results.graphics.contour.list.argument_names == []
-
-
-def test_combine_set_states():
-    assert _combine_set_states(
-        [
-            ("A/B/C", 1),
-        ]
-    ) == ("A/B/C", 1)
-
-    assert _combine_set_states(
-        [
-            ("A/B/C", 1),
-            ("A/B/C", 2),
-        ]
-    ) == ("A/B/C", 2)
-
-    assert _combine_set_states(
-        [
-            ("A/B/C", 1),
-            ("A/B/C", {"X": 2}),
-        ]
-    ) == ("A/B/C", {"X": 2})
-
-    assert _combine_set_states(
-        [
-            ("A/B/C", 1),
-            ("A/B/D", 2),
-        ]
-    ) == ("A/B", {"C": 1, "D": 2})
-
-    assert _combine_set_states(
-        [
-            ("A/B/C", {"X": 1}),
-            ("A/B/D/E", 2),
-        ]
-    ) == ("A/B", {"C": {"X": 1}, "D": {"E": 2}})

ansys/fluent/tests/test_fluent_fixes.py

@@ -31,7 +31,7 @@ def test_allowed_values_on_report_definitions_1364(new_solver_session):
 
     assert report_def.zone_names.allowed_values() == ["fluid"]
 
-    assert report_def.expr_list.allowed_values() == None
+    assert report_def.expr_list.allowed_values() is None
 
 
 @pytest.mark.fluent_version(">=23.2")
@@ -42,7 +42,7 @@ def test_monitors_list_set_data_637_974_1744_2188(new_solver_session):
         file_name="exhaust_system.cas.h5", directory="pyfluent/exhaust_system"
     )
 
-    import_data = examples.download_file(
+    examples.download_file(
         file_name="exhaust_system.dat.h5", directory="pyfluent/exhaust_system"
     )
 
@@ -99,8 +99,8 @@ def test_empty_vector_field_data_2339(new_solver_session):
     solver.file.read_data(file_name=import_data)
 
     assert [
-        a.x
+        a[0]
         for a in solver.fields.field_data.get_vector_field_data(
-            field_name="velocity", surface_ids=[1]
-        )[1].data
+            field_name="velocity", surfaces=[1]
+        )[1]
     ][:5]