fix: Some issues <session>.is_active +1385523

doc/changelog.d/4763.fixed.md

@@ -0,0 +1 @@
+Some issues <session>.is_active +1385523

doc/deprecated_pyfluent_apis.py

@@ -21,7 +21,12 @@
     (
         ":py:meth:`ansys.fluent.core.session.BaseSession.health_check <ansys.fluent.core.session.BaseSession.health_check>`",
         "0.32",
+        ":py:meth:`ansys.fluent.core.session.BaseSession.is_active <ansys.fluent.core.session.BaseSession.is_active>`",
+    ),
+    (
         ":py:meth:`ansys.fluent.core.session.BaseSession.is_server_healthy <ansys.fluent.core.session.BaseSession.is_server_healthy>`",
+        "0.38",
+        ":py:meth:`ansys.fluent.core.session.BaseSession.is_active <ansys.fluent.core.session.BaseSession.is_active>`",
     ),
     (
         ":py:meth:`ansys.fluent.core.file_session.Transaction.add_surfaces_request <ansys.fluent.core.file_session.Transaction.add_surfaces_request>`",

src/ansys/fluent/core/services/datamodel_se.py

@@ -1925,14 +1925,16 @@ def __call__(self, *args, **kwds) -> Any:
         Any
             Return value.
         """
+        processed = []
         for arg, value in kwds.items():
             if self._get_file_purpose(arg):
                 kwds[arg] = self.before_execute(value)
-        result = super().__call__(*args, **kwds)
-        for arg, value in kwds.items():
-            if self._get_file_purpose(arg):
+                processed.append(kwds[arg])
+        try:
+            return super().__call__(*args, **kwds)
+        finally:
+            for value in processed:
                 self.after_execute(value)
-        return result
 
 
 class _InputFile:

src/ansys/fluent/core/session.py

@@ -51,6 +51,7 @@
 from ansys.fluent.core.utils.fluent_version import FluentVersion
 
 from .rpvars import RPVars
+from .utils.deprecate import deprecate_function
 
 try:
     from ansys.fluent.core.solver.settings import root
@@ -251,13 +252,18 @@ def _build_from_fluent_connection(
         for obj in filter(None, (self._datamodel_events, self.transcript, self.events)):
             self._fluent_connection.register_finalizer_cb(obj.stop)
 
+    @deprecate_function(version="v0.38.0", new_func="is_active")
     def is_server_healthy(self) -> bool:
-        """Whether the current session is healthy (i.e. The server is 'SERVING')."""
+        """Whether the current session is healthy (i.e. the server is 'SERVING')."""
+        return self._is_server_healthy()
+
+    def _is_server_healthy(self) -> bool:
+        """Whether the current session is healthy (i.e. the server is 'SERVING')."""
         return self._health_check.is_serving
 
     def is_active(self) -> bool:
         """Whether the current session is active."""
-        return True if self._fluent_connection else False
+        return self._fluent_connection is not None and self._is_server_healthy()
 
     @property
     @deprecated(version="0.32", reason="Use ``session.scheme``.")

tests/integration/test_optislang/test_optislang_integration.py

@@ -55,7 +55,7 @@ def test_simple_solve(mixing_elbow_param_case_data_session):
     """
     # Step 1: Launch fluent session and read case file with and without data file
     solver_session = mixing_elbow_param_case_data_session
-    assert solver_session.is_server_healthy()
+    assert solver_session.is_active()
     if not solver_session.connection_properties.inside_container:
         solver_session.chdir(pyfluent.config.examples_path)
     case_name = "elbow_param.cas.h5"
@@ -225,7 +225,7 @@ def test_generate_read_mesh(mixing_elbow_geometry_filename):
     meshing_session = pyfluent.launch_fluent(
         mode="meshing", precision="double", processor_count=2, **grpc_kwds
     )
-    assert meshing_session.is_server_healthy()
+    assert meshing_session.is_active()
     if not meshing_session.connection_properties.inside_container:
         meshing_session.chdir(pyfluent.config.examples_path)
     temporary_resource_path = (

tests/test_fluent_session.py

@@ -166,16 +166,16 @@ def test_does_not_exit_fluent_by_default_when_connected_to_running_fluent(
         port=session1.connection_properties.port,
         password=session1.connection_properties.password,
     )
-    assert session2.is_server_healthy()
+    assert session2.is_active()
     session2.exit()
 
     timeout_loop(
-        session1.is_server_healthy(),
+        session1.is_active(),
         5.0,
         expected="truthy",
     )
 
-    assert session1.is_server_healthy()
+    assert session1.is_active()
     session1.exit()
 
 
@@ -193,12 +193,12 @@ def test_exit_fluent_when_connected_to_running_fluent(
     session2.exit()
 
     timeout_loop(
-        session1.is_server_healthy(),
+        session1.is_active(),
         5.0,
         expected="falsy",
     )
 
-    assert not session1.is_server_healthy()
+    assert not session1.is_active()
 
 
 def test_fluent_connection_properties(

tests/test_launcher.py

@@ -141,7 +141,7 @@ def test_container_launcher():
 
     # test run with configuration dict
     session = pyfluent.launch_fluent(container_dict=container_dict, **grpc_kwds)
-    assert session.is_server_healthy()
+    assert session.is_active()
 
 
 def test_container_working_dir():
@@ -200,7 +200,7 @@ def test_container_working_dir():
 
     # after all these 'working_dir' changes, the container should still launch
     session = pyfluent.launch_fluent(container_dict=container_dict3, **grpc_kwds)
-    assert session.is_server_healthy()
+    assert session.is_active()
 
 
 @pytest.mark.standalone
@@ -549,7 +549,7 @@ def test_container_mount_source_target(caplog):
     }
     grpc_kwds = get_grpc_launcher_args_for_gh_runs()
     session = pyfluent.launch_fluent(container_dict=container_dict, **grpc_kwds)
-    assert session.is_server_healthy()
+    assert session.is_active()
     assert container_dict["mount_source"] in caplog.text
     assert container_dict["mount_target"] in caplog.text
 

tests/test_meshing_workflow.py

@@ -447,7 +447,7 @@ def test_inaccessible_meshing_attributes_after_switching_to_solver(
 ):
     meshing = new_meshing_session_wo_exit
     assert meshing.is_active() is True
-    assert meshing.is_server_healthy()
+    assert meshing._is_server_healthy()
     solver = meshing.switch_to_solver()
     assert solver.is_active() is True
     assert meshing.is_active() is False

tests/test_meshingmode/test_meshing_launch.py

@@ -33,7 +33,7 @@
 @pytest.mark.codegen_required
 def test_launch_pure_meshing(mixing_elbow_watertight_pure_meshing_session):
     pure_meshing_session = mixing_elbow_watertight_pure_meshing_session
-    assert pure_meshing_session.is_server_healthy()
+    assert pure_meshing_session.is_active()
     file_name = "launch_pure_meshing_journal.py"
     pure_meshing_session.journal.start(file_name)
     session_dir = dir(pure_meshing_session)
@@ -104,7 +104,7 @@ def test_launch_pure_meshing(mixing_elbow_watertight_pure_meshing_session):
 @pytest.mark.codegen_required
 def test_launch_meshing_and_switch(new_meshing_session_wo_exit, capsys):
     meshing = new_meshing_session_wo_exit
-    assert meshing.is_server_healthy()
+    assert meshing._is_server_healthy()
     assert meshing.is_active() is True
     capsys.readouterr()
     help(meshing)

tests/test_session.py

@@ -153,10 +153,10 @@ def test_create_mock_session_by_passing_ip_port_password() -> None:
         fluent_connection=fluent_connection,
         scheme_eval=fluent_connection._connection_interface.scheme_eval,
     )
-    assert session.is_server_healthy()
+    assert session.is_active()
     server.stop(None)
     session.exit()
-    assert not session.is_server_healthy()
+    assert not session.is_active()
 
 
 def test_create_mock_session_by_setting_ip_port_env_var(
@@ -178,10 +178,10 @@ def test_create_mock_session_by_setting_ip_port_env_var(
         fluent_connection=fluent_connection,
         scheme_eval=fluent_connection._connection_interface.scheme_eval,
     )
-    assert session.is_server_healthy()
+    assert session.is_active()
     server.stop(None)
     session.exit()
-    assert not session.is_server_healthy()
+    assert not session.is_active()
 
 
 def test_create_mock_session_by_passing_grpc_channel() -> None:
@@ -202,10 +202,10 @@ def test_create_mock_session_by_passing_grpc_channel() -> None:
         fluent_connection=fluent_connection,
         scheme_eval=fluent_connection._connection_interface.scheme_eval,
     )
-    assert session.is_server_healthy()
+    assert session.is_active()
     server.stop(None)
     session.exit()
-    assert not session.is_server_healthy()
+    assert not session.is_active()
 
 
 def test_create_mock_session_from_server_info_file(tmp_path: Path) -> None:
@@ -223,10 +223,10 @@ def test_create_mock_session_from_server_info_file(tmp_path: Path) -> None:
     session = BaseSession._create_from_server_info_file(
         server_info_file_name=str(server_info_file), cleanup_on_exit=False
     )
-    assert session.is_server_healthy()
+    assert session.is_active()
     server.stop(None)
     session.exit()
-    assert not session.is_server_healthy()
+    assert not session.is_active()
 
 
 def test_create_mock_session_from_server_info_file_with_wrong_password(
@@ -275,7 +275,7 @@ def test_create_mock_session_from_launch_fluent_by_passing_ip_port_password() ->
     fields_dir = dir(session.fields)
     for attr in ("field_data", "field_info"):
         assert attr in fields_dir
-    assert session.is_server_healthy()
+    assert session.is_active()
     server.stop(None)
     session.exit()
     assert not session.is_active()
@@ -303,7 +303,7 @@ def test_create_mock_session_from_launch_fluent_by_setting_ip_port_env_var(
     fields_dir = dir(session.fields)
     for attr in ("field_data", "field_info"):
         assert attr in fields_dir
-    assert session.is_server_healthy()
+    assert session.is_active()
     server.stop(None)
     session.exit()
     assert not session.is_active()
@@ -448,8 +448,8 @@ def new_solver_session2(new_solver_session):
 def test_build_from_fluent_connection(new_solver_session, new_solver_session2):
     solver1 = new_solver_session
     solver2 = new_solver_session2
-    assert solver1.is_server_healthy()
-    assert solver2.is_server_healthy()
+    assert solver1.is_active()
+    assert solver2.is_active()
     health_check_service1 = solver1._health_check
     cortex_pid2 = solver2._fluent_connection.connection_properties.cortex_pid
     # The below hack is performed to check the base class method
@@ -459,8 +459,8 @@ def test_build_from_fluent_connection(new_solver_session, new_solver_session2):
         fluent_connection=solver2._fluent_connection,
         scheme_eval=solver2._fluent_connection._connection_interface.scheme_eval,
     )
-    assert solver1.is_server_healthy()
-    assert solver2.is_server_healthy()
+    assert solver1.is_active()
+    assert solver2.is_active()
     timeout_loop(
         not health_check_service1.is_serving,
         timeout=60,
@@ -654,7 +654,7 @@ def test_new_launch_fluent_api_standalone():
 
     solver = pyfluent.Solver.from_install()
     assert solver._health_check.check_health() == solver._health_check.Status.SERVING
-    assert solver.is_server_healthy()
+    assert solver.is_active()
 
     ip = solver.connection_properties.ip
     password = solver.connection_properties.password
@@ -667,13 +667,13 @@ def test_new_launch_fluent_api_standalone():
         solver_connected._health_check.check_health()
         == solver._health_check.Status.SERVING
     )
-    assert solver.is_server_healthy()
+    assert solver.is_active()
 
     solver.exit()
     solver_connected.exit()
 
     solver_aero = pyfluent.SolverAero.from_install()
-    assert solver_aero.is_server_healthy()
+    assert solver_aero.is_active()
 
     ip = solver_aero.connection_properties.ip
     port = solver_aero.connection_properties.port
@@ -682,13 +682,13 @@ def test_new_launch_fluent_api_standalone():
     solver_aero_connected = pyfluent.SolverAero.from_connection(
         ip=ip, port=port, password=password
     )
-    assert solver_aero_connected.is_server_healthy()
+    assert solver_aero_connected.is_active()
 
     solver_aero.exit()
     solver_aero_connected.exit()
 
     meshing = pyfluent.Meshing.from_install()
-    assert meshing.is_server_healthy()
+    assert meshing.is_active()
 
     ip = meshing.connection_properties.ip
     port = meshing.connection_properties.port
@@ -697,7 +697,7 @@ def test_new_launch_fluent_api_standalone():
     meshing_connected = pyfluent.Meshing.from_connection(
         ip=ip, port=port, password=password
     )
-    assert meshing_connected.is_server_healthy()
+    assert meshing_connected.is_active()
 
     meshing.exit()
     meshing_connected.exit()
@@ -726,7 +726,7 @@ def test_new_launch_fluent_api_from_container():
     grpc_kwds = get_grpc_launcher_args_for_gh_runs()
     solver = pyfluent.Solver.from_container(container_dict=container_dict, **grpc_kwds)
     assert solver._health_check.check_health() == solver._health_check.Status.SERVING
-    assert solver.is_server_healthy()
+    assert solver.is_active()
     solver.exit()
 
 
@@ -735,7 +735,7 @@ def test_new_launch_fluent_api_from_connection():
 
     solver = pyfluent.Solver.from_container(insecure_mode=True)
     assert solver._health_check.check_health() == solver._health_check.Status.SERVING
-    assert solver.is_server_healthy()
+    assert solver.is_active()
     ip = solver.connection_properties.ip
     port = solver.connection_properties.port
     password = solver.connection_properties.password
@@ -873,3 +873,22 @@ def test_dir_for_session(new_meshing_session_wo_exit):
 
     assert dir(solver) == ["is_active", "wait_process_finished"]
     assert len(dir(meshing_new)) > 1
+
+
+@pytest.mark.standalone
+def test_session_is_active(new_solver_session_wo_exit):
+    session_1 = new_solver_session_wo_exit
+    ip = session_1.connection_properties.ip
+    password = session_1.connection_properties.password
+    port = session_1.connection_properties.port
+
+    assert session_1.is_active()
+
+    session_2 = pyfluent.Solver.from_connection(ip=ip, password=password, port=port)
+
+    assert session_2.is_active()
+
+    session_1.exit()
+
+    assert not session_1.is_active()
+    assert not session_2.is_active()

tests/test_solvermode/test_general.py

@@ -33,7 +33,7 @@
 def test_solver_import_mixingelbow(mixing_elbow_settings_session):
     solver_session = mixing_elbow_settings_session
     assert solver_session.settings.is_active()
-    assert solver_session.is_server_healthy()
+    assert solver_session.is_active()
     file_name = Path(pyfluent.config.examples_path) / "jou_test_general.py"
     solver_session.journal.start(file_name.as_posix())
     ###
@@ -108,7 +108,7 @@ def test_solver_import_mixingelbow(mixing_elbow_settings_session):
 def test_disk_2d_setup(disk_settings_session):
     session = disk_settings_session
     assert session.settings.is_active()
-    assert session.is_server_healthy()
+    assert session.is_active()
     ###
     assert not session.setup.models.energy.enabled()
     assert session.scheme.eval("(case-valid?)")