ansys-fluent-core 0.34.2__py3-none-any.whl → 0.35.0__py3-none-any.whl

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/field_data.py

@@ -623,6 +623,18 @@ class BatchFieldData(BaseFieldData, BaseFieldDataSource):
         return self.data
 
 
+class TransactionFieldData(BatchFieldData):
+    """TransactionFieldData class - deprecated."""
+
+    def __init__(self, *args, **kwargs):
+        warnings.warn(
+            "'TransactionFieldData' is deprecated, use 'BatchFieldData' instead.",
+            PyFluentDeprecationWarning,
+            stacklevel=2,
+        )
+        super().__init__(*args, **kwargs)
+
+
 class Batch(FieldBatch):
     """Populates Fluent field data on surfaces."""
 
@@ -1011,6 +1023,18 @@ class Batch(FieldBatch):
         self.get_response()
 
 
+class Transaction(Batch):
+    """Transaction class - deprecated."""
+
+    def __init__(self, *args, **kwargs):
+        warnings.warn(
+            "'Transaction' is deprecated, use 'Batch' instead.",
+            PyFluentDeprecationWarning,
+            stacklevel=2,
+        )
+        super().__init__(*args, **kwargs)
+
+
 class _FieldDataConstants:
     """Defines constants for Fluent field data."""
 

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/services/settings.py

@@ -335,7 +335,7 @@ class SettingsService:
         """
         request = SettingsModule.GetStaticInfoRequest()
         request.root = "fluent"
-        request.optional_attrs.append("allowed-values")
+        request.optional_attrs.extend(["allowed-values", "has-migration-adapter?"])
         response = self._service_impl.get_static_info(request)
         # The RPC calls no longer raise an exception. Force an exception if
         # type is empty

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,
@@ -46,7 +45,6 @@ from ansys.fluent.core.streaming_services.datamodel_event_streaming import (
     DatamodelEvents,
 )
 from ansys.fluent.core.streaming_services.events_streaming import EventsManager
-from ansys.fluent.core.streaming_services.field_data_streaming import FieldDataStreaming
 from ansys.fluent.core.streaming_services.transcript_streaming import Transcript
 from ansys.fluent.core.utils.fluent_version import FluentVersion
 
@@ -151,6 +149,7 @@ class BaseSession:
             file_transfer_service,
             event_type,
             get_zones_info,
+            launcher_args,
         )
         self.register_finalizer_callback = fluent_connection.register_finalizer_cb
 
@@ -161,10 +160,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 +357,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."""
@@ -488,7 +515,7 @@ class Fields:
             _session.scheme,
             get_zones_info,
         )
-        self.field_data_streaming = FieldDataStreaming(
+        self.field_data_streaming = service_creator("field_data_streaming").create(
             _session._fluent_connection._id, _session._field_data_service
         )
         self.field_data_old = service_creator("field_data_old").create(

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 [
@@ -2280,6 +2282,10 @@ def get_cls(name, info, parent=None, version=None, parent_taboo=None):
                 )
             cls._allowed_values = allowed_values
 
+        has_migration_adapter = info.get("has-migration-adapter?", False)
+        if has_migration_adapter:
+            cls._has_migration_adapter = True
+
     except Exception:
         print(
             f"Unable to construct class for '{name}' of "
@@ -2326,16 +2332,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":

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)