refactor: session

src/ansys/fluent/core/fluent_connection.py

@@ -120,13 +120,13 @@ class ErrorState:
     --------
     >>> import ansys.fluent.core as pyfluent
     >>> session = pyfluent.launch_fluent()
-    >>> session.fluent_connection.error_state.set("test", "test details")
-    >>> session.fluent_connection.error_state.name
+    >>> session.fluent_connection._error_state.set("test", "test details")
+    >>> session.fluent_connection._error_state.name
     'test'
-    >>> session.fluent_connection.error_state.details
+    >>> session.fluent_connection._error_state.details
     'test details'
-    >>> session.fluent_connection.error_state.clear()
-    >>> session.fluent_connection.error_state.name
+    >>> session.fluent_connection._error_state.clear()
+    >>> session.fluent_connection._error_state.name
     ''
     """
 
@@ -269,7 +269,7 @@ def __init__(
         PortNotProvided
             If port is not provided.
         """
-        self.error_state = ErrorState()
+        self._error_state = ErrorState()
         self._data_valid = False
         self._channel_str = None
         self._slurm_job_id = None
@@ -298,7 +298,7 @@ def __init__(
         )
 
         self.health_check_service = service_creator("health_check").create(
-            self._channel, self._metadata, self.error_state
+            self._channel, self._metadata, self._error_state
         )
         # At this point, the server must be running. If the following check_health()
         # throws, we should not proceed.
@@ -315,7 +315,7 @@ def __init__(
         # Move this service later.
         # Currently, required by launcher to connect to a running session.
         self._scheme_eval_service = self.create_grpc_service(
-            SchemeEvalService, self.error_state
+            SchemeEvalService, self._error_state
         )
         self.scheme_eval = service_creator("scheme_eval").create(
             self._scheme_eval_service

src/ansys/fluent/core/launcher/slurm_launcher.py

@@ -235,7 +235,7 @@ def _launch(self, slurm_job_id) -> Union[Meshing, PureMeshing, Solver, SolverIci
         _await_fluent_launch(
             self._server_info_file_name, self._start_timeout, self._sifile_last_mtime
         )
-        session = self._new_session.create_from_server_info_file(
+        session = self._new_session._create_from_server_info_file(
             server_info_file_name=self._server_info_file_name,
             file_transfer_service=None,
             cleanup_on_exit=self._cleanup_on_exit,

src/ansys/fluent/core/launcher/standalone_launcher.py

@@ -263,7 +263,7 @@ def __call__(self):
                 else:
                     raise ex
 
-            session = self.new_session.create_from_server_info_file(
+            session = self.new_session._create_from_server_info_file(
                 server_info_file_name=server_info_file_name,
                 file_transfer_service=self.file_transfer_service,
                 cleanup_on_exit=self.cleanup_on_exit,

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

@@ -59,7 +59,7 @@ class SolutionVariableInfo:
 
     .. code-block:: python
 
-        >>> solution_variable_info = solver_session.solution_variable_info
+        >>> solution_variable_info = solver_session.fields.solution_variable_info
         >>>
         >>> wall_fluid_info = solution_variable_info.get_variables_info(zone_names=['wall' , "fluid"], domain_name="mixture")
         >>> wall_fluid_info.solution_variables
@@ -460,9 +460,9 @@ class SolutionVariableData:
     -------
     .. code-block:: python
         >>>
-        >>> solution_variable_data = solver_session.solution_variable_data
+        >>> solution_variable_data = solver_session.fields.solution_variable_data
         >>>
-        >>> sv_t_wall_fluid=solver_session.solution_variable_data.get_data(solution_variable_name="SV_T", domain_name="mixture", zone_names=["fluid", "wall"])
+        >>> sv_t_wall_fluid=solver_session.fields.solution_variable_data.get_data(solution_variable_name="SV_T", domain_name="mixture", zone_names=["fluid", "wall"])
         >>>
         >>> sv_t_wall_fluid.domain
         >>> 'mixture'

src/ansys/fluent/core/session.py

@@ -112,7 +112,7 @@ def build_from_fluent_connection(
         """Build a BaseSession object from fluent_connection object."""
         self.fluent_connection = fluent_connection
         self._file_transfer_service = file_transfer_service
-        self.error_state = self.fluent_connection.error_state
+        self._error_state = self.fluent_connection._error_state
         self.scheme_eval = self.fluent_connection.scheme_eval
         self.rp_vars = RPVars(self.scheme_eval.string_eval)
         self._preferences = None
@@ -128,14 +128,14 @@ def build_from_fluent_connection(
         self.datamodel_service_tui = service_creator("tui").create(
             fluent_connection._channel,
             fluent_connection._metadata,
-            self.error_state,
+            self._error_state,
             self.scheme_eval,
         )
 
         self.datamodel_service_se = service_creator("datamodel").create(
             fluent_connection._channel,
             fluent_connection._metadata,
-            self.error_state,
+            self._error_state,
             self._file_transfer_service,
         )
 
@@ -145,15 +145,15 @@ def build_from_fluent_connection(
         self._batch_ops_service = service_creator("batch_ops").create(
             fluent_connection._channel, fluent_connection._metadata
         )
-        self.events_service = service_creator("events").create(
+        self._events_service = service_creator("events").create(
             fluent_connection._channel, fluent_connection._metadata
         )
         self.events_manager = EventsManager(
-            self.events_service, self.error_state, self.fluent_connection._id
+            self._events_service, self._error_state, self.fluent_connection._id
         )
 
         self._monitors_service = service_creator("monitors").create(
-            fluent_connection._channel, fluent_connection._metadata, self.error_state
+            fluent_connection._channel, fluent_connection._metadata, self._error_state
         )
         self.monitors_manager = MonitorsManager(
             self.fluent_connection._id, self._monitors_service
@@ -169,26 +169,34 @@ def build_from_fluent_connection(
         self.events_manager.start()
 
         self._field_data_service = self.fluent_connection.create_grpc_service(
-            FieldDataService, self.error_state
-        )
-        self.field_info = service_creator("field_info").create(
-            self._field_data_service, _IsDataValid(self.scheme_eval)
-        )
-        self.field_data = service_creator("field_data").create(
-            self._field_data_service,
-            self.field_info,
-            _IsDataValid(self.scheme_eval),
-            self.scheme_eval,
-        )
-        self.field_data_streaming = FieldDataStreaming(
-            self.fluent_connection._id, self._field_data_service
+            FieldDataService, self._error_state
         )
 
-        self.settings_service = service_creator("settings").create(
+        class Fields:
+            """Container for field and solution variables."""
+
+            def __init__(self, _session):
+                """Initialize Fields."""
+                self.field_info = service_creator("field_info").create(
+                    _session._field_data_service, _IsDataValid(_session.scheme_eval)
+                )
+                self.field_data = service_creator("field_data").create(
+                    _session._field_data_service,
+                    self.field_info,
+                    _IsDataValid(_session.scheme_eval),
+                    _session.scheme_eval,
+                )
+                self.field_data_streaming = FieldDataStreaming(
+                    _session.fluent_connection._id, _session._field_data_service
+                )
+
+        self.fields = Fields(self)
+
+        self._settings_service = service_creator("settings").create(
             fluent_connection._channel,
             fluent_connection._metadata,
             self.scheme_eval,
-            self.error_state,
+            self._error_state,
         )
 
         self.health_check_service = fluent_connection.health_check_service
@@ -205,6 +213,33 @@ def build_from_fluent_connection(
         ):
             self.fluent_connection.register_finalizer_cb(obj.stop)
 
+    @property
+    def field_info(self):
+        """Provides access to Fluent field information."""
+        warnings.warn(
+            "field_info is deprecated. Use fields.field_info instead.",
+            DeprecationWarning,
+        )
+        return self.fields.field_info
+
+    @property
+    def field_data(self):
+        """Fluent field data on surfaces."""
+        warnings.warn(
+            "field_data is deprecated. Use fields.field_data instead.",
+            DeprecationWarning,
+        )
+        return self.fields.field_data
+
+    @property
+    def field_data_streaming(self):
+        """Field gRPC streaming service of Fluent."""
+        warnings.warn(
+            "field_data_streaming is deprecated. Use fields.field_data_streaming instead.",
+            DeprecationWarning,
+        )
+        return self.fields.field_data_streaming
+
     @property
     def id(self) -> str:
         """Return the session ID."""
@@ -221,7 +256,7 @@ def stop_journal(self):
         self.journal.stop()
 
     @classmethod
-    def create_from_server_info_file(
+    def _create_from_server_info_file(
         cls,
         server_info_file_name: str,
         file_transfer_service: Optional[Any] = None,
@@ -304,3 +339,11 @@ def __exit__(self, exc_type: Any, exc_val: Any, exc_tb: Any):
         """Close the Fluent connection and exit Fluent."""
         logger.debug("session.__exit__() called")
         self.exit()
+
+    def __dir__(self):
+        dir_list = set(list(self.__dict__.keys()) + dir(type(self))) - {
+            "field_data",
+            "field_info",
+            "field_data_streaming",
+        }
+        return sorted(dir_list)

src/ansys/fluent/core/session_pure_meshing.py

@@ -51,7 +51,7 @@ def __init__(
         )
 
         self.meshing_queries_service = fluent_connection.create_grpc_service(
-            MeshingQueriesService, self.error_state
+            MeshingQueriesService, self._error_state
         )
 
         datamodel_service_se = self.datamodel_service_se

src/ansys/fluent/core/session_solver.py

@@ -93,7 +93,7 @@ def __init__(
     def _build_from_fluent_connection(self, fluent_connection):
         self._tui_service = self.datamodel_service_tui
         self._se_service = self.datamodel_service_se
-        self._settings_service = self.settings_service
+        self._settings_service = self._settings_service
         self._tui = None
         self._workflow = None
         self._system_coupling = None
@@ -103,49 +103,58 @@ def _build_from_fluent_connection(self, fluent_connection):
         self._solution_variable_service = service_creator("svar").create(
             fluent_connection._channel, fluent_connection._metadata
         )
-        self.solution_variable_info = SolutionVariableInfo(
+        self.fields.solution_variable_info = SolutionVariableInfo(
             self._solution_variable_service
         )
         self._reduction_service = self.fluent_connection.create_grpc_service(
-            ReductionService, self.error_state
+            ReductionService, self._error_state
         )
         if FluentVersion(self._version) >= FluentVersion.v241:
-            self.reduction = service_creator("reduction").create(
+            self.fields.reduction = service_creator("reduction").create(
                 self._reduction_service, self
             )
         else:
-            self.reduction = reduction_old
+            self.fields.reduction = reduction_old
         self._settings_api_root = None
+        self.fields.solution_variable_data = self._solution_variable_data()
 
     def build_from_fluent_connection(self, fluent_connection):
         """Build a solver session object from fluent_connection object."""
         super(Solver, self).build_from_fluent_connection(fluent_connection)
         self._build_from_fluent_connection(fluent_connection)
 
-    @property
-    def solution_variable_data(self) -> SolutionVariableData:
+    def _solution_variable_data(self) -> SolutionVariableData:
         """Return the SolutionVariableData handle."""
         return service_creator("svar_data").create(
-            self._solution_variable_service, self.solution_variable_info
+            self._solution_variable_service, self.fields.solution_variable_info
         )
 
     @property
     def svar_data(self):
-        """Return the SolutionVariableData handle."""
+        """``SolutionVariableData`` handle."""
         warnings.warn(
-            "svar_data is deprecated, use solution_variable_data instead",
+            "svar_data is deprecated. Use fields.solution_variable_data instead.",
             DeprecationWarning,
         )
-        return self.solution_variable_data
+        return self.fields.solution_variable_data
 
     @property
     def svar_info(self):
-        """Return the SolutionVariableInfo handle."""
+        """``SolutionVariableInfo`` handle."""
         warnings.warn(
-            "svar_info is deprecated, use solution_variable_info instead",
+            "svar_info is deprecated. Use fields.solution_variable_info instead.",
             DeprecationWarning,
         )
-        return self.solution_variable_info
+        return self.fields.solution_variable_info
+
+    @property
+    def reduction(self):
+        """``Reduction`` handle."""
+        warnings.warn(
+            "reduction is deprecated. Use fields.reduction instead.",
+            DeprecationWarning,
+        )
+        return self.fields.reduction
 
     @property
     def _version(self):
@@ -192,7 +201,7 @@ def workflow(self):
         return self._workflow
 
     @property
-    def _root(self):
+    def settings(self):
         """Root settings object."""
         if self._settings_root is None:
             self._settings_root = flobject.get_root(
@@ -223,10 +232,10 @@ def _sync_from_future(self, fut: Future):
                 fut_session = fut.result()
             except Exception as ex:
                 raise RuntimeError("Unable to read mesh") from ex
-            state = self._root.get_state()
+            state = self.settings.get_state()
             self.build_from_fluent_connection(fut_session.fluent_connection)
             # TODO temporary fix till set_state at settings root is fixed
-            _set_state_safe(self._root, state)
+            _set_state_safe(self.settings, state)
 
     def read_case_lightweight(self, file_name: str):
         """Read a case file using light IO mode.
@@ -247,29 +256,33 @@ def read_case_lightweight(self, file_name: str):
 
     def get_state(self) -> StateT:
         """Get the state of the object."""
-        return self._root.get_state()
+        return self.settings.get_state()
 
     def set_state(self, state: Optional[StateT] = None, **kwargs):
         """Set the state of the object."""
-        self._root.set_state(state, **kwargs)
+        self.settings.set_state(state, **kwargs)
 
     def __call__(self):
         return self.get_state()
 
     def _populate_settings_api_root(self):
         if not self._settings_api_root:
-            self._settings_api_root = _import_settings_root(self._root)
+            self._settings_api_root = _import_settings_root(self.settings)
 
     def __getattr__(self, attr):
         self._populate_settings_api_root()
         return getattr(self._settings_api_root, attr)
 
     def __dir__(self):
         self._populate_settings_api_root()
-        return sorted(
-            set(
-                list(self.__dict__.keys())
-                + dir(type(self))
-                + dir(self._settings_api_root)
-            )
-        )
+        dir_list = set(
+            list(self.__dict__.keys()) + dir(type(self)) + dir(self._settings_api_root)
+        ) - {
+            "svar_data",
+            "svar_info",
+            "reduction",
+            "field_data",
+            "field_info",
+            "field_data_streaming",
+        }
+        return sorted(dir_list)