ansys-fluent-core 0.28.dev0__py3-none-any.whl → 0.28.1__py3-none-any.whl

ansys/fluent/core/services/app_utilities.py

@@ -0,0 +1,408 @@
+"""Wrappers over AppUtilities gRPC service of Fluent."""
+
+from enum import Enum
+from typing import List, Tuple
+
+import grpc
+
+from ansys.api.fluent.v0 import app_utilities_pb2 as AppUtilitiesProtoModule
+from ansys.api.fluent.v0 import app_utilities_pb2_grpc as AppUtilitiesGrpcModule
+from ansys.fluent.core.services.interceptors import (
+    BatchInterceptor,
+    ErrorStateInterceptor,
+    GrpcErrorInterceptor,
+    TracingInterceptor,
+)
+from ansys.fluent.core.streaming_services.events_streaming import SolverEvent
+
+
+class AppUtilitiesService:
+    """AppUtilities Service."""
+
+    def __init__(
+        self, channel: grpc.Channel, metadata: List[Tuple[str, str]], fluent_error_state
+    ):
+        """__init__ method of AppUtilities class."""
+        intercept_channel = grpc.intercept_channel(
+            channel,
+            GrpcErrorInterceptor(),
+            ErrorStateInterceptor(fluent_error_state),
+            TracingInterceptor(),
+            BatchInterceptor(),
+        )
+        self._stub = AppUtilitiesGrpcModule.AppUtilitiesStub(intercept_channel)
+        self._metadata = metadata
+
+    def get_product_version(
+        self, request: AppUtilitiesProtoModule.GetProductVersionRequest
+    ) -> AppUtilitiesProtoModule.GetProductVersionResponse:
+        """Get product version RPC of AppUtilities service."""
+        return self._stub.GetProductVersion(request, metadata=self._metadata)
+
+    def get_build_info(
+        self, request: AppUtilitiesProtoModule.GetBuildInfoRequest
+    ) -> AppUtilitiesProtoModule.GetBuildInfoResponse:
+        """Get build info RPC of AppUtilities service."""
+        return self._stub.GetBuildInfo(request, metadata=self._metadata)
+
+    def get_controller_process_info(
+        self, request: AppUtilitiesProtoModule.GetControllerProcessInfoRequest
+    ) -> AppUtilitiesProtoModule.GetControllerProcessInfoResponse:
+        """Get controller process info RPC of AppUtilities service."""
+        return self._stub.GetControllerProcessInfo(request, metadata=self._metadata)
+
+    def get_solver_process_info(
+        self, request: AppUtilitiesProtoModule.GetSolverProcessInfoRequest
+    ) -> AppUtilitiesProtoModule.GetSolverProcessInfoResponse:
+        """Get solver process info RPC of AppUtilities service."""
+        return self._stub.GetSolverProcessInfo(request, metadata=self._metadata)
+
+    def get_app_mode(
+        self, request: AppUtilitiesProtoModule.GetAppModeRequest
+    ) -> AppUtilitiesProtoModule.GetAppModeResponse:
+        """Get app mode RPC of AppUtilities service."""
+        return self._stub.GetAppMode(request, metadata=self._metadata)
+
+    def start_python_journal(
+        self, request: AppUtilitiesProtoModule.StartPythonJournalRequest
+    ) -> AppUtilitiesProtoModule.StartPythonJournalResponse:
+        """Start python journal RPC of AppUtilities service."""
+        return self._stub.StartPythonJournal(request, metadata=self._metadata)
+
+    def stop_python_journal(
+        self, request: AppUtilitiesProtoModule.StopPythonJournalRequest
+    ) -> AppUtilitiesProtoModule.StopPythonJournalResponse:
+        """Stop python journal RPC of AppUtilities service."""
+        return self._stub.StopPythonJournal(request, metadata=self._metadata)
+
+    def is_beta_enabled(
+        self, request: AppUtilitiesProtoModule.IsBetaEnabledRequest
+    ) -> AppUtilitiesProtoModule.IsBetaEnabledResponse:
+        """Is beta enabled RPC of AppUtilities service."""
+        return self._stub.IsBetaEnabled(request, metadata=self._metadata)
+
+    def is_wildcard(
+        self, request: AppUtilitiesProtoModule.IsWildcardRequest
+    ) -> AppUtilitiesProtoModule.IsWildcardResponse:
+        """Is wildcard RPC of AppUtilities service."""
+        return self._stub.IsWildcard(request, metadata=self._metadata)
+
+    def is_solution_data_available(
+        self, request: AppUtilitiesProtoModule.IsSolutionDataAvailableRequest
+    ) -> AppUtilitiesProtoModule.IsSolutionDataAvailableResponse:
+        """Is solution data available RPC of AppUtilities service."""
+        return self._stub.IsSolutionDataAvailable(request, metadata=self._metadata)
+
+    def register_pause_on_solution_events(
+        self, request: AppUtilitiesProtoModule.RegisterPauseOnSolutionEventsRequest
+    ) -> AppUtilitiesProtoModule.RegisterPauseOnSolutionEventsResponse:
+        """Register on pause solution events RPC of AppUtilities service."""
+        return self._stub.RegisterPauseOnSolutionEvents(
+            request, metadata=self._metadata
+        )
+
+    def resume_on_solution_event(
+        self, request: AppUtilitiesProtoModule.ResumeOnSolutionEventRequest
+    ) -> AppUtilitiesProtoModule.ResumeOnSolutionEventResponse:
+        """Resume on solution event RPC of AppUtilities service."""
+        return self._stub.ResumeOnSolutionEvent(request, metadata=self._metadata)
+
+    def unregister_pause_on_solution_events(
+        self, request: AppUtilitiesProtoModule.UnregisterPauseOnSolutionEventsRequest
+    ) -> AppUtilitiesProtoModule.UnregisterPauseOnSolutionEventsResponse:
+        """Unregister on pause solution events RPC of AppUtilities service."""
+        return self._stub.UnregisterPauseOnSolutionEvents(
+            request, metadata=self._metadata
+        )
+
+    def exit(
+        self, request: AppUtilitiesProtoModule.ExitRequest
+    ) -> AppUtilitiesProtoModule.ExitResponse:
+        """Exit RPC of AppUtilities service."""
+        return self._stub.Exit(request, metadata=self._metadata)
+
+
+class AppUtilitiesOld:
+    """AppUtilitiesOld."""
+
+    def __init__(self, scheme_eval):
+        """__init__ method of AppUtilitiesOld class."""
+        self.scheme_eval = scheme_eval
+
+    def get_product_version(self) -> str:
+        """Get product version."""
+        return self.scheme_eval.version
+
+    def get_build_info(self) -> dict:
+        """Get build info."""
+        build_time = self.scheme_eval.scheme_eval("(inquire-build-time)")
+        build_id = self.scheme_eval.scheme_eval("(inquire-build-id)")
+        vcs_revision = self.scheme_eval.scheme_eval("(inquire-src-vcs-id)")
+        vcs_branch = self.scheme_eval.scheme_eval("(inquire-src-vcs-branch)")
+        return {
+            "build_time": build_time,
+            "build_id": build_id,
+            "vcs_revision": vcs_revision,
+            "vcs_branch": vcs_branch,
+        }
+
+    def get_controller_process_info(self) -> dict:
+        """Get controller process info."""
+        cortex_host = self.scheme_eval.scheme_eval("(cx-cortex-host)")
+        cortex_pid = self.scheme_eval.scheme_eval("(cx-cortex-id)")
+        cortex_pwd = self.scheme_eval.scheme_eval("(cortex-pwd)")
+        return {
+            "hostname": cortex_host,
+            "process_id": cortex_pid,
+            "working_directory": cortex_pwd,
+        }
+
+    def get_solver_process_info(self) -> dict:
+        """Get solver process info."""
+        fluent_host = self.scheme_eval.scheme_eval("(cx-client-host)")
+        fluent_pid = self.scheme_eval.scheme_eval("(cx-client-id)")
+        fluent_pwd = self.scheme_eval.scheme_eval("(cx-send '(cx-client-pwd))")
+        return {
+            "hostname": fluent_host,
+            "process_id": fluent_pid,
+            "working_directory": fluent_pwd,
+        }
+
+    def get_app_mode(self) -> Enum:
+        """Get app mode."""
+        from ansys.fluent.core import FluentMode
+
+        if self.scheme_eval.scheme_eval("(cx-solver-mode?)"):
+            mode_str = self.scheme_eval.scheme_eval('(getenv "PRJAPP_APP")')
+            if mode_str == "flaero_server":
+                return FluentMode.SOLVER_AERO
+            elif mode_str == "flicing":
+                return FluentMode.SOLVER_ICING
+            else:
+                return FluentMode.SOLVER
+        else:
+            return FluentMode.MESHING
+
+    def start_python_journal(self, journal_name: str | None = None) -> int:
+        """Start python journal."""
+        if journal_name:
+            self.scheme_eval.exec([f'(api-start-python-journal "{journal_name}")'])
+        else:
+            self.scheme_eval.scheme_eval(
+                "(define pyfluent-journal-str-port (open-output-string))"
+            )
+            self.scheme_eval.scheme_eval(
+                "(api-echo-python-port pyfluent-journal-str-port)"
+            )
+            return "1"
+
+    def stop_python_journal(self, journal_id: str | None = None) -> str:
+        """Stop python journal."""
+        if journal_id:
+            self.scheme_eval.scheme_eval(
+                "(api-unecho-python-port pyfluent-journal-str-port)"
+            )
+            journal_str = self.scheme_eval.scheme_eval(
+                "(close-output-port pyfluent-journal-str-port)"
+            )
+            return journal_str
+        else:
+            self.scheme_eval.exec(["(api-stop-python-journal)"])
+
+    def is_beta_enabled(self) -> bool:
+        """Is beta enabled."""
+        return self.scheme_eval.scheme_eval("(is-beta-feature-available?)")
+
+    def is_wildcard(self, input: str | None = None) -> bool:
+        """Is wildcard."""
+        return self.scheme_eval.scheme_eval(f'(has-fnmatch-wild-card? "{input}")')
+
+    def is_solution_data_available(self) -> bool:
+        """Is solution data available."""
+        return self.scheme_eval.scheme_eval("(data-valid?)")
+
+    def register_pause_on_solution_events(self, solution_event: SolverEvent) -> int:
+        """Register pause on solution events."""
+        unique_id: int = self.scheme_eval.scheme_eval(
+            f"""
+            (let
+                ((ids
+                    (let loop ((i 1))
+                        (define next-id (string->symbol (format #f "pyfluent-~d" i)))
+                        (if (check-monitor-existence next-id)
+                            (loop (1+ i))
+                            (list i next-id)
+                            )
+                        )
+                    ))
+                (register-solution-monitor
+                    (cadr ids)
+                    (lambda (niter time)
+                        (if (integer? niter)
+                            (begin
+                                (events/transmit 'auto-pause (cons (car ids) niter))
+                                (grpcserver/auto-pause (is-server-running?) (cadr ids))
+                                )
+                            )
+                        ()
+                        )
+                    {'#t' if solution_event == SolverEvent.TIMESTEP_ENDED else '#f'}
+                    )
+                (car ids)
+                )
+        """
+        )
+        return unique_id
+
+    def resume_on_solution_event(self, registration_id: int) -> None:
+        """Resume on solution event."""
+        self.scheme_eval.scheme_eval(
+            f"(grpcserver/auto-resume (is-server-running?) 'pyfluent-{registration_id})"
+        )
+
+    def unregister_pause_on_solution_events(self, registration_id: int) -> None:
+        """Unregister pause on solution events."""
+        self.scheme_eval.scheme_eval(
+            f"(cancel-solution-monitor 'pyfluent-{registration_id})"
+        )
+
+    def exit(self) -> None:
+        """Exit."""
+        self.scheme_eval.exec(("(exit-server)",))
+
+
+class AppUtilities:
+    """AppUtilities."""
+
+    def __init__(self, service: AppUtilitiesService):
+        """__init__ method of AppUtilities class."""
+        self.service = service
+
+    def get_product_version(self) -> str:
+        """Get product version."""
+        request = AppUtilitiesProtoModule.GetProductVersionRequest()
+        response = self.service.get_product_version(request)
+        return f"{response.major}.{response.minor}.{response.patch}"
+
+    def get_build_info(self) -> dict:
+        """Get build info."""
+        request = AppUtilitiesProtoModule.GetBuildInfoRequest()
+        response = self.service.get_build_info(request)
+        return {
+            "build_time": response.build_time,
+            "build_id": response.build_id,
+            "vcs_revision": response.vcs_revision,
+            "vcs_branch": response.vcs_branch,
+        }
+
+    def get_controller_process_info(self) -> dict:
+        """Get controller process info."""
+        request = AppUtilitiesProtoModule.GetControllerProcessInfoRequest()
+        response = self.service.get_controller_process_info(request)
+        return {
+            "hostname": response.hostname,
+            "process_id": response.process_id,
+            "working_directory": response.working_directory,
+        }
+
+    def get_solver_process_info(self) -> dict:
+        """Get solver process info."""
+        request = AppUtilitiesProtoModule.GetSolverProcessInfoRequest()
+        response = self.service.get_solver_process_info(request)
+        return {
+            "hostname": response.hostname,
+            "process_id": response.process_id,
+            "working_directory": response.working_directory,
+        }
+
+    def get_app_mode(self) -> Enum:
+        """Get app mode.
+
+        Raises
+        ------
+        ValueError
+            If app mode is unknown.
+        """
+        import ansys.fluent.core as pyfluent
+
+        request = AppUtilitiesProtoModule.GetAppModeRequest()
+        response = self.service.get_app_mode(request)
+        match response.app_mode:
+            case AppUtilitiesProtoModule.APP_MODE_UNKNOWN:
+                raise ValueError("Unknown app mode.")
+            case AppUtilitiesProtoModule.APP_MODE_MESHING:
+                return pyfluent.FluentMode.MESHING
+            case AppUtilitiesProtoModule.APP_MODE_SOLVER:
+                return pyfluent.FluentMode.SOLVER
+            case AppUtilitiesProtoModule.APP_MODE_SOLVER_ICING:
+                return pyfluent.FluentMode.SOLVER_ICING
+            case AppUtilitiesProtoModule.APP_MODE_SOLVER_AERO:
+                return pyfluent.FluentMode.SOLVER_AERO
+
+    def start_python_journal(self, journal_name: str | None = None) -> int:
+        """Start python journal."""
+        request = AppUtilitiesProtoModule.StartPythonJournalRequest()
+        if journal_name:
+            request.journal_name = journal_name
+        response = self.service.start_python_journal(request)
+        return response.journal_id
+
+    def stop_python_journal(self, journal_id: str | None = None) -> str:
+        """Stop python journal."""
+        request = AppUtilitiesProtoModule.StopPythonJournalRequest()
+        if journal_id:
+            request.journal_id = journal_id
+        response = self.service.stop_python_journal(request)
+        return response.journal_str
+
+    def is_beta_enabled(self) -> bool:
+        """Is beta enabled."""
+        request = AppUtilitiesProtoModule.IsBetaEnabledRequest()
+        response = self.service.is_beta_enabled(request)
+        return response.is_beta_enabled
+
+    def is_wildcard(self, input: str | None = None) -> bool:
+        """Is wildcard."""
+        request = AppUtilitiesProtoModule.IsWildcardRequest()
+        request.input = input
+        response = self.service.is_wildcard(request)
+        return response.is_wildcard
+
+    def is_solution_data_available(self) -> bool:
+        """Is solution data available."""
+        request = AppUtilitiesProtoModule.IsSolutionDataAvailableRequest()
+        response = self.service.is_solution_data_available(request)
+        return response.is_solution_data_available
+
+    def register_pause_on_solution_events(self, solution_event: SolverEvent) -> int:
+        """Register pause on solution events."""
+        request = AppUtilitiesProtoModule.RegisterPauseOnSolutionEventsRequest()
+        request.solution_event = AppUtilitiesProtoModule.SOLUTION_EVENT_UNKNOWN
+        match solution_event:
+            case SolverEvent.ITERATION_ENDED:
+                request.solution_event = (
+                    AppUtilitiesProtoModule.SOLUTION_EVENT_ITERATION
+                )
+            case SolverEvent.TIMESTEP_ENDED:
+                request.solution_event = (
+                    AppUtilitiesProtoModule.SOLUTION_EVENT_TIME_STEP
+                )
+        response = self.service.register_pause_on_solution_events(request)
+        return response.registration_id
+
+    def resume_on_solution_event(self, registration_id: int) -> None:
+        """Resume on solution event."""
+        request = AppUtilitiesProtoModule.ResumeOnSolutionEventRequest()
+        request.registration_id = registration_id
+        self.service.resume_on_solution_event(request)
+
+    def unregister_pause_on_solution_events(self, registration_id: int) -> None:
+        """Unregister pause on solution events."""
+        request = AppUtilitiesProtoModule.UnregisterPauseOnSolutionEventsRequest()
+        request.registration_id = registration_id
+        self.service.unregister_pause_on_solution_events(request)
+
+    def exit(self) -> None:
+        """Exit."""
+        request = AppUtilitiesProtoModule.ExitRequest()
+        self.service.exit(request)

ansys/fluent/core/services/datamodel_se.py

@@ -807,7 +807,7 @@ class DatamodelService(StreamingService):
         self.event_streaming.register_callback(subscription.tag, obj, cb)
         return subscription
 
-    def add_on_command_executed(
+    def add_on_command_executed_old(
         self, rules: str, path: str, command: str, obj, cb: Callable
     ) -> EventSubscription:
         """Add on command executed."""
@@ -826,6 +826,24 @@ class DatamodelService(StreamingService):
         self.event_streaming.register_callback(subscription.tag, obj, cb)
         return subscription
 
+    def add_on_command_executed(
+        self, rules: str, path: str, obj, cb: Callable
+    ) -> EventSubscription:
+        """Add on command executed."""
+        request_dict = {
+            "eventrequest": [
+                {
+                    "rules": rules,
+                    "commandExecutedEventRequest": {
+                        "path": path,
+                    },
+                }
+            ]
+        }
+        subscription = EventSubscription(self, path, request_dict)
+        self.event_streaming.register_callback(subscription.tag, obj, cb)
+        return subscription
+
     def add_on_attribute_changed(
         self, rules: str, path: str, attribute: str, obj, cb: Callable
     ) -> EventSubscription:
@@ -1326,13 +1344,15 @@ class PyMenu(PyStateContainer):
             self.rules, convert_path_to_se_path(self.path), child_type, self, cb
         )
 
-    def add_on_command_executed(self, command: str, cb: Callable) -> EventSubscription:
+    def add_on_command_executed_old(
+        self, command: str, cb: Callable
+    ) -> EventSubscription:
         """Register a callback for when a command is executed.
 
         Parameters
         ----------
         command : str
-            command name
+            Command name
         cb : Callable
             Callback function
 
@@ -1341,10 +1361,27 @@ class PyMenu(PyStateContainer):
         EventSubscription
             EventSubscription instance which can be used to unregister the callback
         """
-        return self.service.add_on_command_executed(
+        return self.service.add_on_command_executed_old(
             self.rules, convert_path_to_se_path(self.path), command, self, cb
         )
 
+    def add_on_command_executed(self, cb: Callable) -> EventSubscription:
+        """Register a callback for when a command is executed.
+
+        Parameters
+        ----------
+        cb : Callable
+            Callback function
+
+        Returns
+        -------
+        EventSubscription
+            EventSubscription instance which can be used to unregister the callback
+        """
+        return self.service.add_on_command_executed(
+            self.rules, convert_path_to_se_path(self.path), self, cb
+        )
+
 
 class PyParameter(PyStateContainer):
     """Object class using StateEngine based DatamodelService as backend.
@@ -1577,7 +1614,7 @@ class PyNamedObjectContainer:
             # On-deleted subscription objects are unsubscribed after the datamodel
             # object is deleted.
             self[key].add_on_deleted(
-                lambda _: self.service.subscriptions.unsubscribe_while_deleting(
+                lambda: self.service.subscriptions.unsubscribe_while_deleting(
                     self.rules, se_path, "after"
                 )
             )

ansys/fluent/core/services/datamodel_tui.py

@@ -125,10 +125,12 @@ class DatamodelService:
         channel: grpc.Channel,
         metadata: list[tuple[str, str]],
         fluent_error_state,
+        app_utilities,
         scheme_eval,
     ) -> None:
         """__init__ method of DatamodelService class."""
         self._impl = DatamodelServiceImpl(channel, metadata, fluent_error_state)
+        self._app_utilities = app_utilities
         self._scheme_eval = scheme_eval
 
     def get_attribute_value(
@@ -170,7 +172,8 @@ class DatamodelService:
         request = DataModelProtoModule.GetStaticInfoRequest()
         request.path = path
         response = self._impl.get_static_info(request)
-        return MessageToDict(response.info, including_default_value_fields=True)
+        # Note: MessageToDict's parameter names are different in different protobuf versions
+        return MessageToDict(response.info, True)
 
 
 class PyMenu:
@@ -233,7 +236,7 @@ class PyMenu:
             Query result (any Python datatype)
         """
         with ApiUpgradeAdvisor(
-            self._service._scheme_eval,
+            self._service._app_utilities,
             self._version,
             self._mode,
         ):

ansys/fluent/core/services/field_data.py

@@ -153,6 +153,7 @@ class FieldInfo:
                 "display_name": field_info.displayName,
                 "section": field_info.section,
                 "domain": field_info.domain,
+                "quantity_name": field_info.quantity_name,
             }
             for field_info in response.fieldInfo
         }

ansys/fluent/core/services/reduction.py

@@ -263,6 +263,8 @@ class Reduction:
             raise ValueError(f"Invalid location input: '{loc}'")
 
     def _get_location_string(self, locations, ctxt) -> List[str]:
+        if locations == []:
+            return []
         for loc in locations:
             if isinstance(loc, str):
                 self._validate_str_location(loc)

ansys/fluent/core/services/settings.py

@@ -136,9 +136,12 @@ def _get_request_instance_for_path(request_class, path: str) -> Any:
 class SettingsService:
     """Service for accessing and modifying Fluent settings."""
 
-    def __init__(self, channel, metadata, scheme_eval, fluent_error_state) -> None:
+    def __init__(
+        self, channel, metadata, app_utilities, scheme_eval, fluent_error_state
+    ) -> None:
         """__init__ method of SettingsService class."""
         self._service_impl = _SettingsServiceImpl(channel, metadata, fluent_error_state)
+        self._app_utilities = app_utilities
         self._scheme_eval = scheme_eval
 
     @_trace
@@ -369,7 +372,7 @@ class SettingsService:
         """Checks whether a name has a wildcard pattern."""
         return self._scheme_eval.is_defined(
             "has-fnmatch-wild-card?"
-        ) and self._scheme_eval.scheme_eval(f'(has-fnmatch-wild-card? "{name}")')
+        ) and self._app_utilities.is_wildcard(name)
 
     @_trace
     def is_interactive_mode(self) -> bool:

ansys/fluent/core/session.py

@@ -10,6 +10,7 @@ import weakref
 from ansys.fluent.core.fluent_connection import FluentConnection
 from ansys.fluent.core.journaling import Journal
 from ansys.fluent.core.services import service_creator
+from ansys.fluent.core.services.app_utilities import AppUtilitiesOld
 from ansys.fluent.core.services.field_data import FieldDataService
 from ansys.fluent.core.services.scheme_eval import SchemeEval
 from ansys.fluent.core.streaming_services.datamodel_event_streaming import (
@@ -52,6 +53,17 @@ class _IsDataValid:
         return self._scheme_eval.scheme_eval("(data-valid?)")
 
 
+class _AppUtilitiesFactory:
+    """AppUtilities factory."""
+
+    @staticmethod
+    def _create_app_utilities(scheme_eval, fluent_connection):
+        if FluentVersion(scheme_eval.version) < FluentVersion.v252:
+            return AppUtilitiesOld(scheme_eval)
+        else:
+            return fluent_connection._connection_interface._app_utilities
+
+
 class BaseSession:
     """Encapsulates a Fluent session.
 
@@ -124,7 +136,6 @@ class BaseSession:
         self.scheme_eval = scheme_eval
         self.rp_vars = RPVars(self.scheme_eval.string_eval)
         self._preferences = None
-        self.journal = Journal(self.scheme_eval)
 
         self._transcript_service = service_creator("transcript").create(
             fluent_connection._channel, fluent_connection._metadata
@@ -133,10 +144,17 @@ class BaseSession:
         if self._start_transcript:
             self.transcript.start()
 
+        self._app_utilities = _AppUtilitiesFactory._create_app_utilities(
+            self.scheme_eval, self._fluent_connection
+        )
+
+        self.journal = Journal(self._app_utilities)
+
         self._datamodel_service_tui = service_creator("tui").create(
             fluent_connection._channel,
             fluent_connection._metadata,
             self._error_state,
+            self._app_utilities,
             self.scheme_eval,
         )
 
@@ -175,13 +193,17 @@ class BaseSession:
 
             def __init__(self, _session):
                 """Initialize Fields."""
+                self._is_solution_data_valid = (
+                    _session._app_utilities.is_solution_data_available
+                )
                 self.field_info = service_creator("field_info").create(
-                    _session._field_data_service, _IsDataValid(_session.scheme_eval)
+                    _session._field_data_service,
+                    self._is_solution_data_valid,
                 )
                 self.field_data = service_creator("field_data").create(
                     _session._field_data_service,
                     self.field_info,
-                    _IsDataValid(_session.scheme_eval),
+                    self._is_solution_data_valid,
                     _session.scheme_eval,
                 )
                 self.field_data_streaming = FieldDataStreaming(
@@ -190,7 +212,7 @@ class BaseSession:
                 self.field_data_old = service_creator("field_data_old").create(
                     _session._field_data_service,
                     self.field_info,
-                    _IsDataValid(_session.scheme_eval),
+                    self._is_solution_data_valid,
                     _session.scheme_eval,
                 )
 
@@ -199,6 +221,7 @@ class BaseSession:
         self._settings_service = service_creator("settings").create(
             fluent_connection._channel,
             fluent_connection._metadata,
+            self._app_utilities,
             self.scheme_eval,
             self._error_state,
         )

ansys/fluent/core/session_pure_meshing.py

@@ -156,7 +156,7 @@ class PureMeshing(BaseSession):
         RuntimeError
             If beta features are not enabled in Fluent.
         """
-        if not self.scheme_eval.scheme_eval("(is-beta-feature-available?)"):
+        if not self._app_utilities.is_beta_enabled():
             raise RuntimeError("Topology-based Meshing is a beta feature in Fluent.")
         self._base_meshing.topology_based_meshing_workflow.initialize()
         return self._base_meshing.topology_based_meshing_workflow

ansys/fluent/core/session_solver.py

@@ -117,7 +117,6 @@ class Solver(BaseSession):
     ):
         self._tui_service = self._datamodel_service_tui
         self._se_service = self._datamodel_service_se
-        self._settings_service = self._settings_service
         self._tui = None
         self._workflow = None
         self._system_coupling = None