ansys-fluent-core 0.34.2__py3-none-any.whl → 0.35.dev1__py3-none-any.whl

ansys/fluent/core/search.py

@@ -41,16 +41,16 @@ from ansys.fluent.core.utils.fluent_version import (
 
 def _get_api_tree_data_file_path():
     """Get API tree data file."""
-    from ansys.fluent.core import CODEGEN_OUTDIR
+    from ansys.fluent.core import config
 
-    return (CODEGEN_OUTDIR / "api_tree" / "api_objects.json").resolve()
+    return (config.codegen_outdir / "api_tree" / "api_objects.json").resolve()
 
 
 def get_api_tree_file_name(version: str) -> Path:
     """Get API tree file name."""
-    from ansys.fluent.core import CODEGEN_OUTDIR
+    from ansys.fluent.core import config
 
-    return (CODEGEN_OUTDIR / f"api_tree_{version}.pickle").resolve()
+    return (config.codegen_outdir / f"api_tree_{version}.pickle").resolve()
 
 
 def _remove_suffix(input: str, suffix):
@@ -77,6 +77,7 @@ def _generate_api_data(
     """
     api_objects = set()
     api_tui_objects = set()
+    api_object_name_map = {"meshing_session": set(), "solver_session": set()}
     api_object_names = set()
     if version:
         version = get_version_for_file_name(version)
@@ -104,6 +105,10 @@ def _generate_api_data(
                     next_path = f"{path}.{k}"
                 type_ = "Object" if isinstance(v, Mapping) else v
                 api_object_names.add(k)
+                if "meshing_session" in next_path:
+                    api_object_name_map["meshing_session"].add(k)
+                if "solver_session" in next_path:
+                    api_object_name_map["solver_session"].add(k)
                 next_path = (
                     next_path.replace("MeshingUtilities", "meshing_utilities")
                     if "MeshingUtilities" in next_path
@@ -122,14 +127,21 @@ def _generate_api_data(
     api_tree_data["api_objects"] = sorted(list(api_objects))
     api_tree_data["api_tui_objects"] = sorted(list(api_tui_objects))
     api_tree_data["all_api_object_names"] = sorted(list(api_object_names))
+    api_object_name_map["meshing_session"] = sorted(
+        list(api_object_name_map["meshing_session"])
+    )
+    api_object_name_map["solver_session"] = sorted(
+        list(api_object_name_map["solver_session"])
+    )
+    api_tree_data["api_object_name_map"] = api_object_name_map
 
     def _write_api_tree_file(api_tree_data: dict, api_object_names: list):
         from nltk.corpus import wordnet as wn
 
         _download_nltk_data()
-        from ansys.fluent.core import CODEGEN_OUTDIR
+        from ansys.fluent.core import config
 
-        json_file_folder = Path(os.path.join(CODEGEN_OUTDIR, "api_tree"))
+        json_file_folder = Path(os.path.join(config.codegen_outdir, "api_tree"))
         json_file_folder.mkdir(parents=True, exist_ok=True)
 
         all_api_object_name_synsets = dict()
@@ -164,7 +176,10 @@ def _get_api_tree_data():
 
 
 def _print_search_results(
-    queries: list, api_tree_data: dict | None = None, api_path: str | None = None
+    queries: list,
+    api_tree_data: dict | None = None,
+    api_path: str | None = None,
+    match_whole_word: bool | None = None,
 ):
     """
     Print search results.
@@ -178,6 +193,9 @@ def _print_search_results(
         If None, it is retrieved using _get_api_tree_data().
     api_path : str, optional
         Specific path to restrict the search to. If None, searches the entire object hierarchy.
+    match_whole_word : bool, optional
+        If True, only exact matches are returned. If False, semantic search is performed.
+        The default is None, which means semantic search is performed.
     """
     api_tree_data = api_tree_data or _get_api_tree_data()
     api_sources = [api_tree_data["api_objects"], api_tree_data["api_tui_objects"]]
@@ -207,18 +225,22 @@ def _print_search_results(
             for query in queries:
                 if isinstance(query, tuple):
                     name, score = query
+                    if (
+                        name in first_token
+                        and has_query(name, substrings)
+                        and name in substrings[-1]
+                    ):
+                        if score is not None:
+                            results.add((api_object, round(score, 2)))
                 else:
                     name = query
                     score = None
 
-                if (
-                    name in first_token
-                    and has_query(name, substrings)
-                    and name in substrings[-1]
-                ):
-                    if score is not None:
-                        results.add((api_object, round(score, 2)))
-                    else:
+                    if match_whole_word and (
+                        first_token == name or first_token.endswith(f".{name}")
+                    ):
+                        results.add(api_object)
+                    elif not match_whole_word and name in first_token:
                         results.add(api_object)
 
         return sorted(results)
@@ -235,7 +257,7 @@ def _print_search_results(
         )
 
     results = final_results or all_results
-    if pyfluent.PRINT_SEARCH_RESULTS:
+    if pyfluent.config.print_search_results:
         for result in results:
             print(result)
     elif results:
@@ -324,7 +346,7 @@ def _get_exact_match_for_word_from_names(
     -------
         List of exact match.
     """
-    return list({name for name in names if word == name or word in name})
+    return list({name for name in names if word == name})
 
 
 def _get_capitalize_match_for_word_from_names(
@@ -461,7 +483,10 @@ def _search_whole_word(
             )
     if queries:
         return _print_search_results(
-            queries, api_tree_data=api_tree_data, api_path=api_path
+            queries,
+            api_tree_data=api_tree_data,
+            api_path=api_path,
+            match_whole_word=match_whole_word,
         )
 
 

ansys/fluent/core/services/api_upgrade.py

@@ -22,7 +22,6 @@
 
 """Provides a module for the API upgrade advisor."""
 
-import os
 from typing import TypeVar
 
 from ansys.fluent.core.services.app_utilities import AppUtilities
@@ -47,8 +46,10 @@ class ApiUpgradeAdvisor:
         self._id = None
 
     def _can_advise(self) -> bool:
+        from ansys.fluent.core import config
+
         return (
-            not os.getenv("PYFLUENT_SKIP_API_UPGRADE_ADVICE")
+            not config.skip_api_upgrade_advice
             and FluentVersion(self._version) >= FluentVersion.v231
             and self._mode == "solver"
         )

ansys/fluent/core/services/datamodel_se.py

@@ -514,7 +514,9 @@ class DatamodelService(StreamingService):
         self.event_streaming = None
         self.subscriptions = SubscriptionList()
         self.file_transfer_service = file_transfer_service
-        self.cache = DataModelCache() if pyfluent.DATAMODEL_USE_STATE_CACHE else None
+        self.cache = (
+            DataModelCache() if pyfluent.config.datamodel_use_state_cache else None
+        )
         self.version = version
 
     def get_attribute_value(self, rules: str, path: str, attribute: str) -> ValueT:
@@ -1096,7 +1098,7 @@ class PyStateContainer(PyCallableStateObject):
         Any
             Value of the attribute.
         """
-        if pyfluent.DATAMODEL_USE_ATTR_CACHE:
+        if pyfluent.config.datamodel_use_attr_cache:
             return self._get_cached_attr(attrib)
         return self._get_remote_attr(attrib)
 

ansys/fluent/core/services/health_check.py

@@ -80,7 +80,9 @@ class HealthCheckService:
         """
         request = HealthCheckModule.HealthCheckRequest()
         response = self._stub.Check(
-            request, metadata=self._metadata, timeout=pyfluent.CHECK_HEALTH_TIMEOUT
+            request,
+            metadata=self._metadata,
+            timeout=pyfluent.config.check_health_timeout,
         )
         return HealthCheckService.Status(response.status)
 

ansys/fluent/core/services/interceptors.py

@@ -24,7 +24,6 @@
 
 import builtins
 import logging
-import os
 from typing import Any
 
 from google.protobuf.json_format import MessageToDict
@@ -34,8 +33,6 @@ import grpc
 from ansys.fluent.core.services.batch_ops import BatchOps
 
 network_logger: logging.Logger = logging.getLogger("pyfluent.networking")
-log_bytes_limit: int = int(os.getenv("PYFLUENT_GRPC_LOG_BYTES_LIMIT", 1000))
-truncate_len: int = log_bytes_limit // 5
 
 
 def _upper_snake_case_to_camel_case(name: str) -> str:
@@ -43,14 +40,17 @@ def _upper_snake_case_to_camel_case(name: str) -> str:
 
 
 def _truncate_grpc_str(message: Message) -> str:
+    from ansys.fluent.core import config
+
+    truncate_len = config.grpc_log_bytes_limit // 5
     message_bytes = message.ByteSize()
     message_str = str(MessageToDict(message))
-    if not log_bytes_limit or message_bytes < log_bytes_limit:
+    if not config.grpc_log_bytes_limit or message_bytes < config.grpc_log_bytes_limit:
         return message_str
     else:
         network_logger.debug(
             f"GRPC_TRACE: message partially hidden, {message_bytes} bytes > "
-            f"{log_bytes_limit} bytes limit. To see the full message, set PYFLUENT_GRPC_LOG_BYTES_LIMIT to 0."
+            f"{config.grpc_log_bytes_limit} bytes limit. To see the full message, set PYFLUENT_GRPC_LOG_BYTES_LIMIT to 0."
         )
         return f"{message_str[:truncate_len]} < ... > {message_str[-truncate_len:]}"
 
@@ -68,6 +68,8 @@ class TracingInterceptor(grpc.UnaryUnaryClientInterceptor):
         client_call_details: grpc.ClientCallDetails,
         request: Any,
     ) -> Any:
+        from ansys.fluent.core import config
+
         network_logger.debug(
             f"GRPC_TRACE: RPC = {client_call_details.method}, request = {_truncate_grpc_str(request)}"
         )
@@ -75,7 +77,7 @@ class TracingInterceptor(grpc.UnaryUnaryClientInterceptor):
         if not response.exception():
             # call _truncate_grpc_str early to get the size warning even when hiding secrets
             response_str = _truncate_grpc_str(response.result())
-            if os.getenv("PYFLUENT_HIDE_LOG_SECRETS") != "1":
+            if not config.hide_log_secrets:
                 network_logger.debug(f"GRPC_TRACE: response = {response_str}")
         return response
 

ansys/fluent/core/session.py

@@ -33,7 +33,6 @@ from deprecated.sphinx import deprecated
 
 from ansys.fluent.core.fluent_connection import FluentConnection
 from ansys.fluent.core.journaling import Journal
-from ansys.fluent.core.launcher.launcher_utils import is_compose
 from ansys.fluent.core.pyfluent_warnings import (
     PyFluentDeprecationWarning,
     PyFluentUserWarning,
@@ -151,6 +150,7 @@ class BaseSession:
             file_transfer_service,
             event_type,
             get_zones_info,
+            launcher_args,
         )
         self.register_finalizer_callback = fluent_connection.register_finalizer_cb
 
@@ -161,10 +161,14 @@ class BaseSession:
         file_transfer_service: Any | None = None,
         event_type=None,
         get_zones_info: weakref.WeakMethod[Callable[[], list[ZoneInfo]]] | None = None,
+        launcher_args: Dict[str, Any] | None = None,
     ):
         """Build a BaseSession object from fluent_connection object."""
         self._fluent_connection = fluent_connection
+        # Stores the backup of the fluent connection for later reference.
+        self._fluent_connection_backup = self._fluent_connection
         self._file_transfer_service = file_transfer_service
+        self._launcher_args = launcher_args
         self._error_state = fluent_connection._error_state
         self.scheme = scheme_eval
         self.rp_vars = RPVars(self.scheme.string_eval)
@@ -354,8 +358,32 @@ class BaseSession:
         return FluentVersion(self.scheme.version)
 
     def _exit_compose_service(self):
-        if self._fluent_connection._container and is_compose():
-            self._fluent_connection._container.stop()
+        args = self._launcher_args or {}
+        compose_config = args.get("compose_config", None)
+
+        container = self._fluent_connection._container
+        if compose_config and compose_config.is_compose:
+            container.stop()
+
+    def wait_process_finished(self, wait: float | int | bool = 60):
+        """Returns ``True`` if local Fluent processes have finished, ``False`` if they
+        are still running when wait limit (default 60 seconds) is reached. Immediately
+        cancels and returns ``None`` if ``wait`` is set to ``False``.
+
+        Parameters
+        ----------
+        wait : float, int or bool, optional
+            How long to wait for processes to finish before returning, by default 60 seconds.
+            Can also be set to ``True``, which will result in waiting indefinitely.
+
+        Raises
+        ------
+        UnsupportedRemoteFluentInstance
+            If current Fluent instance is running remotely.
+        WaitTypeError
+            If ``wait`` is specified improperly.
+        """
+        return self._fluent_connection_backup.wait_process_finished()
 
     def exit(self, **kwargs) -> None:
         """Exit session."""

ansys/fluent/core/session_pure_meshing.py

@@ -120,7 +120,7 @@ class PureMeshing(BaseSession):
                 self.datamodel_streams[rules] = stream
                 stream.start(
                     rules=rules,
-                    no_commands_diff_state=pyfluent.DATAMODEL_USE_NOCOMMANDS_DIFF_STATE,
+                    no_commands_diff_state=pyfluent.config.datamodel_use_nocommands_diff_state,
                 )
                 self._fluent_connection.register_finalizer_cb(stream.stop)
 

ansys/fluent/core/session_shared.py

@@ -47,11 +47,11 @@ tui_logger = logging.getLogger("pyfluent.tui")
 
 def _make_tui_module(session, module_name):
     try:
-        from ansys.fluent.core import CODEGEN_OUTDIR
+        from ansys.fluent.core import config
 
         tui_module = pyfluent.utils.load_module(
             f"{module_name}_tui_{session._version}",
-            CODEGEN_OUTDIR / module_name / f"tui_{session._version}.py",
+            config.codegen_outdir / module_name / f"tui_{session._version}.py",
         )
         warning_for_fluent_dev_version(session._version)
         return tui_module.main_menu(
@@ -64,13 +64,13 @@ def _make_tui_module(session, module_name):
 
 def _make_datamodel_module(session, module_name):
     try:
-        from ansys.fluent.core import CODEGEN_OUTDIR
+        from ansys.fluent.core import config
         from ansys.fluent.core.codegen.datamodelgen import datamodel_file_name_map
 
         file_name = datamodel_file_name_map[module_name]
         module = pyfluent.utils.load_module(
             f"{module_name}_{session._version}",
-            CODEGEN_OUTDIR / f"datamodel_{session._version}" / f"{file_name}.py",
+            config.codegen_outdir / f"datamodel_{session._version}" / f"{file_name}.py",
         )
         warning_for_fluent_dev_version(session._version)
         return module.Root(session._se_service, module_name, [])

ansys/fluent/core/session_solver.py

@@ -119,13 +119,16 @@ class Solver(BaseSession):
             get_zones_info=weakref.WeakMethod(self._get_zones_info),
         )
         self._settings = None
-        self._build_from_fluent_connection(fluent_connection, scheme_eval)
+        self._build_from_fluent_connection(
+            fluent_connection, scheme_eval, launcher_args=launcher_args
+        )
 
     def _build_from_fluent_connection(
         self,
         fluent_connection,
         scheme_eval: SchemeEval,
         file_transfer_service: Any | None = None,
+        launcher_args: Dict[str, Any] | None = None,
     ):
         self._tui_service = self._datamodel_service_tui
         self._se_service = self._datamodel_service_se
@@ -134,6 +137,7 @@ class Solver(BaseSession):
         self._system_coupling = None
         self._fluent_version = None
         self._bg_session_threads = []
+        self._launcher_args = launcher_args
         self._solution_variable_service = service_creator("svar").create(
             fluent_connection._channel, fluent_connection._metadata
         )
@@ -156,10 +160,11 @@ class Solver(BaseSession):
         )
         #: Manage Fluent's solution monitors.
         self.monitors = MonitorsManager(fluent_connection._id, monitors_service)
-        self.events.register_callback(
-            (SolverEvent.SOLUTION_INITIALIZED, SolverEvent.DATA_LOADED),
-            self.monitors.refresh,
-        )
+        if not pyfluent.config.disable_monitor_refresh_on_init:
+            self.events.register_callback(
+                (SolverEvent.SOLUTION_INITIALIZED, SolverEvent.DATA_LOADED),
+                self.monitors.refresh,
+            )
 
         fluent_connection.register_finalizer_cb(self.monitors.stop)
 
@@ -267,7 +272,7 @@ class Solver(BaseSession):
             "solution/run-calculation/calculate",
             "solution/run-calculation/dual-time-iterate",
         ]
-        if pyfluent.SUPPORT_SOLVER_INTERRUPT:
+        if pyfluent.config.support_solver_interrupt:
             if command.path in interruptible_commands:
                 command._root.solution.run_calculation.interrupt()
 
@@ -296,10 +301,12 @@ class Solver(BaseSession):
             bg_session._fluent_connection,
             bg_session._fluent_connection._connection_interface.scheme_eval,
             event_type=SolverEvent,
+            launcher_args=launcher_args,
         )
         self._build_from_fluent_connection(
             bg_session._fluent_connection,
             bg_session._fluent_connection._connection_interface.scheme_eval,
+            launcher_args=launcher_args,
         )
         # TODO temporary fix till set_state at settings root is fixed
         _set_state_safe(self.settings, state)

ansys/fluent/core/session_utilities.py

@@ -264,6 +264,7 @@ class SessionBase:
     @classmethod
     def from_pim(
         cls,
+        ui_mode: UIMode | str | None = None,
         graphics_driver: (
             FluentWindowsGraphicsDriver | FluentLinuxGraphicsDriver | str | None
         ) = None,
@@ -274,6 +275,7 @@ class SessionBase:
         start_timeout: int = 60,
         additional_arguments: str = "",
         cleanup_on_exit: bool = True,
+        dry_run: bool | None = None,
         start_transcript: bool = True,
         gpu: bool | None = None,
         start_watchdog: bool | None = None,
@@ -284,6 +286,8 @@ class SessionBase:
 
         Parameters
         ----------
+        ui_mode : UIMode or str, optional
+            Defines the user interface mode for Fluent. Options correspond to values in the ``UIMode`` enum.
         graphics_driver : FluentWindowsGraphicsDriver or FluentLinuxGraphicsDriver
             Specifies the graphics driver for Fluent. Options are from the ``FluentWindowsGraphicsDriver`` enum
             (for Windows) or the ``FluentLinuxGraphicsDriver`` enum (for Linux).
@@ -309,6 +313,9 @@ class SessionBase:
         cleanup_on_exit : bool
             Determines whether to shut down the connected Fluent session upon exit or when calling
             the session's `exit()` method. Defaults to True.
+        dry_run : bool, optional
+            If True, does not launch Fluent but prints configuration information instead. If dry running a
+            PIM start, this method will return a configuration dictionary. Defaults to False.
         start_transcript : bool
             Indicates whether to start streaming the Fluent transcript in the client. Defaults to True;
             streaming can be controlled via `transcript.start()` and `transcript.stop()` methods on the session object.

ansys/fluent/core/solver/flobject.py

@@ -1730,6 +1730,8 @@ class BaseCommand(Action):
 
     def _execute_command(self, *args, **kwds):
         """Execute a command with the specified positional and keyword arguments."""
+        from ansys.fluent.core import config
+
         if self.flproxy.is_interactive_mode():
             prompt = self.flproxy.get_command_confirmation_prompt(
                 self._parent.path, self.obj_name, **kwds
@@ -1747,7 +1749,7 @@ class BaseCommand(Action):
         with self._while_executing_command():
             ret = self.flproxy.execute_cmd(self._parent.path, self.obj_name, **kwds)
             if (
-                os.getenv("PYFLUENT_NO_FIX_PARAMETER_LIST_RETURN") != "1"
+                not config.disable_parameter_list_return_fix
                 and FluentVersion(self._version) <= FluentVersion.v252
                 and self.path
                 in [
@@ -2326,16 +2328,16 @@ def get_root(
     RuntimeError
         If hash values are inconsistent.
     """
-    from ansys.fluent.core import CODEGEN_OUTDIR, utils
+    from ansys.fluent.core import config, utils
 
-    if os.getenv("PYFLUENT_USE_RUNTIME_PYTHON_CLASSES") == "1":
+    if config.use_runtime_python_classes:
         obj_info = flproxy.get_static_info()
         root_cls, _ = get_cls("", obj_info, version=version)
     else:
         try:
             settings = utils.load_module(
                 f"settings_{version}",
-                CODEGEN_OUTDIR / "solver" / f"settings_{version}.py",
+                config.codegen_outdir / "solver" / f"settings_{version}.py",
             )
             root_cls = settings.root
             warning_for_fluent_dev_version(version)

ansys/fluent/core/solver/flunits.py

@@ -298,6 +298,8 @@ def get_si_unit_for_fluent_quantity(
     # attribute only for dimensionless variables
     if quantity is None:
         return ""
+    if isinstance(quantity, list):  # real vector
+        quantity = quantity[0]
     if not isinstance(quantity, str):
         raise InvalidQuantityType(quantity)
     try:

ansys/fluent/core/solver/settings_builtin_bases.py

@@ -52,9 +52,9 @@ def _get_settings_root(settings_source: SettingsBase | Solver):
 
 
 def _get_settings_obj(settings_root, builtin_settings_obj):
-    builtin_cls_name = builtin_settings_obj.__class__.__name__
+    builtin_cls_db_name = builtin_settings_obj.__class__._db_name
     obj = settings_root
-    path = DATA[builtin_cls_name][1]
+    path = DATA[builtin_cls_db_name][1]
     found_path = None
     if isinstance(path, dict):
         version = FluentVersion(obj._version)
@@ -63,7 +63,7 @@ def _get_settings_obj(settings_root, builtin_settings_obj):
                 found_path = p
                 break
         if found_path is None:
-            raise RuntimeError(f"{builtin_cls_name} is not supported in {version}.")
+            raise RuntimeError(f"{builtin_cls_db_name} is not supported in {version}.")
     elif isinstance(path, str):
         found_path = path
     comps = found_path.split(".")

ansys/fluent/core/solver/settings_builtin_data.py

@@ -225,26 +225,14 @@ DATA = {
     "VelocityInlet": ("NamedObject", "setup.boundary_conditions.velocity_inlet"),
     "WallBoundaries": ("Singleton", "setup.boundary_conditions.wall"),
     "WallBoundary": ("NamedObject", "setup.boundary_conditions.wall"),
-    "NonReflectingBoundaries": (
-        "Singleton",
-        {
-            since(FluentVersion.v241): "setup.boundary_conditions.non_reflecting_bc",
-        },
-    ),
     "NonReflectingBoundary": (
-        "NamedObject",
-        {
-            since(FluentVersion.v241): "setup.boundary_conditions.non_reflecting_bc",
-        },
-    ),
-    "PerforatedWallBoundaries": (
         "Singleton",
         {
-            since(FluentVersion.v241): "setup.boundary_conditions.perforated_wall",
+            since(FluentVersion.v241): "setup.boundary_conditions.non_reflecting_bc",
         },
     ),
     "PerforatedWallBoundary": (
-        "NamedObject",
+        "Singleton",
         {
             since(FluentVersion.v241): "setup.boundary_conditions.perforated_wall",
         },

ansys/fluent/core/streaming_services/datamodel_event_streaming.py

@@ -23,7 +23,6 @@
 """Provides a module for datamodel event streaming."""
 
 import logging
-import os
 import threading
 from typing import Callable
 
@@ -62,6 +61,8 @@ class DatamodelEvents(StreamingService):
 
     def _process_streaming(self, id, stream_begin_method, started_evt, *args, **kwargs):
         """Processes datamodel events."""
+        from ansys.fluent.core import config
+
         request = DataModelProtoModule.EventRequest(*args, **kwargs)
         responses = self._streaming_service.begin_streaming(
             request, started_evt, id=id, stream_begin_method=stream_begin_method
@@ -69,7 +70,7 @@ class DatamodelEvents(StreamingService):
         while True:
             try:
                 response: DataModelProtoModule.EventResponse = next(responses)
-                if os.getenv("PYFLUENT_HIDE_LOG_SECRETS") != "1":
+                if not config.hide_log_secrets:
                     network_logger.debug(
                         f"GRPC_TRACE: RPC = /grpcRemoting.DataModel/BeginEventStreaming, response = {MessageToDict(response)}"
                     )

ansys/fluent/core/streaming_services/datamodel_streaming.py

@@ -57,7 +57,9 @@ class DatamodelStream(StreamingService):
         """Processes datamodel events."""
         data_model_request = datamodel_se_pb2.DataModelRequest(*args, **kwargs)
         data_model_request.rules = rules
-        data_model_request.returnstatechanges = pyfluent.DATAMODEL_RETURN_STATE_CHANGES
+        data_model_request.returnstatechanges = (
+            pyfluent.config.datamodel_return_state_changes
+        )
         if no_commands_diff_state:
             data_model_request.diffstate = datamodel_se_pb2.DIFFSTATE_NOCOMMANDS
         responses = self._streaming_service.begin_streaming(

ansys/fluent/core/streaming_services/events_streaming.py

@@ -281,30 +281,14 @@ class SolutionInitializedEventInfo(
 class ReportDefinitionUpdatedEventInfo(
     EventInfoBase, event=SolverEvent.REPORT_DEFINITION_UPDATED
 ):
-    """Information about the event triggered when a report definition is updated.
-
-    Attributes
-    ----------
-    report_name : str
-        Report name.
-    """
-
-    report_name: str = field(metadata=dict(deprecated_name="reportdefinitionname"))
+    """Information about the event triggered when a report definition is updated."""
 
 
 @dataclass
 class ReportPlotSetUpdatedEventInfo(
     EventInfoBase, event=SolverEvent.REPORT_PLOT_SET_UPDATED
 ):
-    """Information about the event triggered when a report plot set is updated.
-
-    Attributes
-    ----------
-    plot_set_name : str
-        Plot set name.
-    """
-
-    plot_set_name: str = field(metadata=dict(deprecated_name="plotsetname"))
+    """Information about the event triggered when a report plot set is updated."""
 
 
 class ResidualPlotUpdatedEventInfo(

ansys/fluent/core/system_coupling.py

@@ -252,7 +252,9 @@ class SystemCoupling:
                 # the local Fluent container working directory will correspond to
                 # pyfluent.EXAMPLES_PATH in the host, so that is where the SCP file
                 # will be written.
-                examples_path_scp = os.path.join(pyfluent.EXAMPLES_PATH, scp_file_name)
+                examples_path_scp = os.path.join(
+                    pyfluent.config.examples_path, scp_file_name
+                )
                 if os.path.exists(examples_path_scp):
                     scp_file_name = examples_path_scp
 

ansys/fluent/core/utils/__init__.py

@@ -42,13 +42,6 @@ def load_module(module_name, file_path):
     return module
 
 
-def get_examples_download_dir():
-    """Return the path to the examples download directory."""
-    parent_path = Path.home() / "Downloads"
-    parent_path.mkdir(exist_ok=True)
-    return parent_path / "ansys_fluent_core_examples"
-
-
 def get_user_data_dir():
     """Return the path to the user data directory."""
     if sys.platform == "win32":