ansys-fluent-core 0.34.1__py3-none-any.whl → 0.35.dev0__py3-none-any.whl

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
         )
@@ -267,7 +271,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 +300,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/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":

ansys/fluent/core/utils/data_transfer.py

@@ -114,7 +114,7 @@ def transfer_case(
     """
     inside_container = source_instance.connection_properties.inside_container
     if not workdir:
-        workdir = Path(pyfluent.EXAMPLES_PATH)
+        workdir = Path(pyfluent.config.examples_path)
     else:
         workdir = Path(workdir)
     if inside_container:
@@ -122,9 +122,9 @@ def transfer_case(
             network_logger.warning(
                 "Fluent is running inside a container, and no 'container_workdir' was specified for "
                 "'transfer_case'. Assuming that the default container mount path "
-                f"'{pyfluent.CONTAINER_MOUNT_TARGET}' is being used. "
+                f"'{pyfluent.config.container_mount_target}' is being used. "
             )
-            container_workdir = PurePosixPath(pyfluent.CONTAINER_MOUNT_TARGET)
+            container_workdir = PurePosixPath(pyfluent.config.container_mount_target)
             network_logger.debug(f"container_workdir: {container_workdir}")
         else:
             container_workdir = PurePosixPath(container_workdir)

ansys/fluent/core/utils/file_transfer_service.py

@@ -537,6 +537,9 @@ class PimFileTransferService:
                 )
             except ModuleNotFoundError:
                 pass
+        self.cwd = os.getcwd()
+        self.instance_name = self.pim_instance.name.replace("instances/", "")
+        self.instance_dir = os.path.join(self.cwd, self.instance_name)
 
     def file_exists_on_remote(self, file_name: str) -> bool:
         """Check if remote file exists.
@@ -604,16 +607,18 @@ class PimFileTransferService:
         if self.is_configured():
             for file in files:
                 if os.path.isfile(file):
-                    if not self.file_service.file_exist(os.path.basename(file)):
-                        self.upload_file(
-                            file_name=file, remote_file_name=remote_file_name
-                        )
-                        print(f"\n{os.path.basename(file_name)} uploaded.\n")
+                    if os.path.exists(self.instance_dir):
+                        shutil.copy2(file, self.instance_dir)
                     else:
-                        warnings.warn(
-                            f"\n{file} with the same name exists at the remote location.\n",
-                            PyFluentUserWarning,
-                        )
+                        if not self.file_service.file_exist(os.path.basename(file)):
+                            self.upload_file(
+                                file_name=file, remote_file_name=remote_file_name
+                            )
+                        else:
+                            warnings.warn(
+                                f"\n{file} with the same name exists at the remote location.\n",
+                                PyFluentUserWarning,
+                            )
                 elif not self.file_service.file_exist(os.path.basename(file)):
                     raise FileNotFoundError(f"{file} does not exist.")
 
@@ -642,7 +647,7 @@ class PimFileTransferService:
             else:
                 raise FileNotFoundError("Remote file does not exist.")
 
-    def download(self, file_name: list[str] | str, local_directory: str | None = "."):
+    def download(self, file_name: list[str] | str, local_directory: str | None = None):
         """Download a file from the server.
 
         Parameters
@@ -652,6 +657,7 @@ class PimFileTransferService:
         local_directory : str, optional
             Local directory. The default is the current working directory.
         """
+        download_directory = local_directory if local_directory else self.cwd
         files = [file_name] if isinstance(file_name, str) else file_name
         if self.is_configured():
             for file in files:
@@ -661,11 +667,14 @@ class PimFileTransferService:
                         PyFluentUserWarning,
                     )
                 else:
-                    self.download_file(
-                        file_name=os.path.basename(file),
-                        local_directory=local_directory,
-                    )
-                    print(f"\n{os.path.basename(file_name)} downloaded.\n")
+                    download_file_name = os.path.join(self.instance_dir, file)
+                    if os.path.exists(download_file_name):
+                        shutil.copy2(download_file_name, download_directory)
+                    else:
+                        self.download_file(
+                            file_name=os.path.basename(file),
+                            local_directory=download_directory,
+                        )
 
     def __call__(self, pim_instance: Any | None = None):
         self.pim_instance = pim_instance

ansys/fluent/core/utils/fluent_version.py

@@ -162,7 +162,7 @@ class FluentVersion(Enum):
         FluentVersion
             FluentVersion member corresponding to the latest release.
         """
-        return cls(pyfluent.FLUENT_RELEASE_VERSION)
+        return cls(pyfluent.config.fluent_release_version)
 
     @classmethod
     def current_dev(cls):
@@ -173,7 +173,7 @@ class FluentVersion(Enum):
         FluentVersion
             FluentVersion member corresponding to the latest development version.
         """
-        return cls(pyfluent.FLUENT_DEV_VERSION)
+        return cls(pyfluent.config.fluent_dev_version)
 
     @property
     def awp_var(self):
@@ -188,7 +188,7 @@ class FluentVersion(Enum):
     @property
     def docker_image_tag(self):
         """Get the Fluent version as a Docker image tag."""
-        return f"v{self.value}"
+        return f"v{self.value.rsplit('.', 1)[0]}.latest"
 
     def __lt__(self, other):
         if isinstance(other, FluentVersion):

ansys/fluent/core/utils/networking.py

@@ -79,7 +79,7 @@ def find_remoting_ip() -> str:
     str
         remoting ip address
     """
-    from ansys.fluent.core import INFER_REMOTING_IP_TIMEOUT_PER_IP
+    from ansys.fluent.core import config
 
     all_ips = [
         addrinfo[-1][0]
@@ -108,7 +108,7 @@ def find_remoting_ip() -> str:
                     if (
                         stub.Check(
                             health_pb2.HealthCheckRequest(),
-                            timeout=INFER_REMOTING_IP_TIMEOUT_PER_IP,
+                            timeout=config.infer_remoting_ip_timeout_per_ip,
                         ).status
                         == health_pb2.HealthCheckResponse.ServingStatus.SERVING
                     ):

{ansys_fluent_core-0.34.1.dist-info → ansys_fluent_core-0.35.dev0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: ansys-fluent-core
-Version: 0.34.1
+Version: 0.35.dev0
 Summary: PyFluent provides Pythonic access to Ansys Fluent.
 Author-email: "ANSYS, Inc." <pyansys.core@ansys.com>
 Maintainer-email: "ANSYS, Inc." <pyansys.core@ansys.com>