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

ansys/fluent/core/__init__.py

@@ -23,10 +23,14 @@
 """A package providing Fluent's Solver and Meshing capabilities in Python."""
 
 import os
-from pathlib import Path
 import pydoc
+import warnings
 
 # isort: off
+
+# config must be initialized before logging setup.
+from ansys.fluent.core.module_config import config
+
 # Logging has to be imported before importing other PyFluent modules
 from ansys.fluent.core.logger import set_console_logging_level  # noqa: F401
 
@@ -73,13 +77,13 @@ from ansys.fluent.core.session_utilities import (  # noqa: F401
     SolverIcing,
 )
 from ansys.fluent.core.streaming_services.events_streaming import *  # noqa: F401, F403
-from ansys.fluent.core.utils import fldoc, get_examples_download_dir
+from ansys.fluent.core.utils import fldoc
 from ansys.fluent.core.utils.fluent_version import FluentVersion  # noqa: F401
 from ansys.fluent.core.utils.setup_for_fluent import setup_for_fluent  # noqa: F401
 
-__version__ = "0.34.2"
+__version__ = "0.35.dev1"
 
-_VERSION_INFO = "Build date: August 14, 2025 01:33 UTC ShaID: d5ae1e6"
+_VERSION_INFO = "Build date: August 28, 2025 18:16 UTC ShaID: b1f9dbd"
 """
 Global variable indicating the version info of the PyFluent package.
 Build timestamp and commit hash are added to this variable during packaging.
@@ -108,86 +112,46 @@ def version_info() -> str:
     return _VERSION_INFO if _VERSION_INFO is not None else __version__
 
 
-# Latest released Fluent version
-FLUENT_RELEASE_VERSION = "25.2.0"
-
-# Current dev Fluent version
-FLUENT_DEV_VERSION = "26.1.0"
-
-# Path to the example input/data files are downloaded
-EXAMPLES_PATH = str(get_examples_download_dir())
-
-# Host path which is mounted to the container
-CONTAINER_MOUNT_SOURCE = None
-
-# Path inside the container where the host path is mounted
-CONTAINER_MOUNT_TARGET = "/home/container/workdir"
-
-# Set this to False to stop automatically inferring and setting REMOTING_SERVER_ADDRESS
-INFER_REMOTING_IP = True
-
-# Time in second to wait for response for each ip while inferring remoting ip
-INFER_REMOTING_IP_TIMEOUT_PER_IP = 2
-
 pydoc.text.docother = fldoc.docother.__get__(pydoc.text, pydoc.TextDoc)
 
-# Whether to use datamodel state caching
-DATAMODEL_USE_STATE_CACHE = True
-
-# Whether to use datamodel attribute caching
-DATAMODEL_USE_ATTR_CACHE = True
-
-# Whether to stream and cache commands state
-DATAMODEL_USE_NOCOMMANDS_DIFF_STATE = True
-
-# Whether to return the state changes on mutating datamodel rpcs
-DATAMODEL_RETURN_STATE_CHANGES = True
-
-# Whether to use remote gRPC file transfer service
-USE_FILE_TRANSFER_SERVICE = False
-
-# Directory where API files are written out during codegen
-CODEGEN_OUTDIR = os.getenv(
-    "PYFLUENT_CODEGEN_OUTDIR", (Path(__file__) / ".." / "generated").resolve()
-)
-
-# Whether to show mesh in Fluent after case read
-FLUENT_SHOW_MESH_AFTER_CASE_READ = False
-
-# Whether to write the automatic transcript in Fluent
-FLUENT_AUTOMATIC_TRANSCRIPT = os.getenv("PYFLUENT_FLUENT_AUTOMATIC_TRANSCRIPT") == "1"
-
-# Whether to interrupt Fluent solver from PyFluent
-SUPPORT_SOLVER_INTERRUPT = False
-
-# Whether to start watchdog
-START_WATCHDOG = None
-
-# Health check timeout in seconds
-CHECK_HEALTH_TIMEOUT = 60
-
-# Whether to skip health check
-CHECK_HEALTH = True
-
-# Whether to print search results
-PRINT_SEARCH_RESULTS = True
-
-# Whether to clear environment variables related to Fluent parallel mode
-CLEAR_FLUENT_PARA_ENVS = False
-
-# Set stdout of the launched Fluent process
-# Valid values are same as subprocess.Popen's stdout argument
-LAUNCH_FLUENT_STDOUT = None
-
-# Set stderr of the launched Fluent process
-# Valid values are same as subprocess.Popen's stderr argument
-LAUNCH_FLUENT_STDERR = None
-
-# Set the IP address of the Fluent server while launching Fluent
-LAUNCH_FLUENT_IP = None
-
-# Set the port of the Fluent server while launching Fluent
-LAUNCH_FLUENT_PORT = None
 
-# Skip password check during rpc execution when Fluent is launched from PyFluent
-LAUNCH_FLUENT_SKIP_PASSWORD_CHECK = False
+_config_by_deprecated_name = {
+    "FLUENT_RELEASE_VERSION": "fluent_release_version",
+    "FLUENT_DEV_VERSION": "fluent_dev_version",
+    "EXAMPLES_PATH": "examples_path",
+    "CONTAINER_MOUNT_SOURCE": "container_mount_source",
+    "CONTAINER_MOUNT_TARGET": "container_mount_target",
+    "INFER_REMOTING_IP": "infer_remoting_ip",
+    "INFER_REMOTING_IP_TIMEOUT_PER_IP": "infer_remoting_ip_timeout_per_ip",
+    "DATAMODEL_USE_STATE_CACHE": "datamodel_use_state_cache",
+    "DATAMODEL_USE_ATTR_CACHE": "datamodel_use_attr_cache",
+    "DATAMODEL_USE_NOCOMMANDS_DIFF_STATE": "datamodel_use_nocommands_diff_state",
+    "DATAMODEL_RETURN_STATE_CHANGES": "datamodel_return_state_changes",
+    "USE_FILE_TRANSFER_SERVICE": "use_file_transfer_service",
+    "CODEGEN_OUTDIR": "codegen_outdir",
+    "FLUENT_SHOW_MESH_AFTER_CASE_READ": "fluent_show_mesh_after_case_read",
+    "FLUENT_AUTOMATIC_TRANSCRIPT": "fluent_automatic_transcript",
+    "SUPPORT_SOLVER_INTERRUPT": "support_solver_interrupt",
+    "START_WATCHDOG": "start_watchdog",
+    "CHECK_HEALTH_TIMEOUT": "check_health_timeout",
+    "CHECK_HEALTH": "check_health",
+    "PRINT_SEARCH_RESULTS": "print_search_results",
+    "CLEAR_FLUENT_PARA_ENVS": "clear_fluent_para_envs",
+    "LAUNCH_FLUENT_STDOUT": "launch_fluent_stdout",
+    "LAUNCH_FLUENT_STDERR": "launch_fluent_stderr",
+    "LAUNCH_FLUENT_IP": "launch_fluent_ip",
+    "LAUNCH_FLUENT_PORT": "launch_fluent_port",
+    "LAUNCH_FLUENT_SKIP_PASSWORD_CHECK": "launch_fluent_skip_password_check",
+}
+
+
+def __getattr__(name: str) -> str:
+    """Get the value of a deprecated configuration variable."""
+    if name in _config_by_deprecated_name:
+        config_name = _config_by_deprecated_name[name]
+        warnings.warn(
+            f"'{name}' is deprecated, use 'config.{config_name}' instead.",
+            category=PyFluentDeprecationWarning,
+        )
+        return getattr(config, config_name)
+    raise AttributeError(f"module '{__name__}' has no attribute '{name}'")

ansys/fluent/core/codegen/allapigen.py

@@ -23,10 +23,10 @@
 """Module to generate Fluent API classes."""
 
 import argparse
-import os
 from pathlib import Path
 import pickle
 
+from ansys.fluent.core import config
 from ansys.fluent.core.codegen import (  # noqa: F401
     builtin_settingsgen,
     datamodelgen,
@@ -51,7 +51,7 @@ def generate(version: str, static_infos: dict, verbose: bool = False):
     Path(api_tree_file).parent.mkdir(parents=True, exist_ok=True)
     with open(api_tree_file, "wb") as f:
         pickle.dump(api_tree, f)
-    if os.getenv("PYFLUENT_CODEGEN_SKIP_BUILTIN_SETTINGS") != "1":
+    if not config.codegen_skip_builtin_settings:
         builtin_settingsgen.generate(version)
 
 

ansys/fluent/core/codegen/builtin_settingsgen.py

@@ -22,25 +22,38 @@
 
 """Generate builtin setting classes."""
 
-from ansys.fluent.core import CODEGEN_OUTDIR, FluentVersion
-from ansys.fluent.core.solver.flobject import CreatableNamedObjectMixin, NamedObject
+import re
+
+from ansys.fluent.core import FluentVersion, config
+from ansys.fluent.core.solver.flobject import (
+    CreatableNamedObjectMixin,
+    NamedObject,
+    _ChildNamedObjectAccessorMixin,
+)
 from ansys.fluent.core.solver.settings_builtin_data import DATA
 from ansys.fluent.core.utils.fluent_version import all_versions
 
-_PY_FILE = CODEGEN_OUTDIR / "solver" / "settings_builtin.py"
-_PYI_FILE = CODEGEN_OUTDIR / "solver" / "settings_builtin.pyi"
+_PY_FILE = config.codegen_outdir / "solver" / "settings_builtin.py"
+_PYI_FILE = config.codegen_outdir / "solver" / "settings_builtin.pyi"
 
 
 def _get_settings_root(version: str):
-    from ansys.fluent.core import CODEGEN_OUTDIR, utils
+    from ansys.fluent.core import config, utils
 
     settings = utils.load_module(
         f"settings_{version}",
-        CODEGEN_OUTDIR / "solver" / f"settings_{version}.py",
+        config.codegen_outdir / "solver" / f"settings_{version}.py",
     )
     return settings.root
 
 
+def _convert_camel_case_to_snake_case(name: str) -> str:
+    """Convert CamelCase to snake_case."""
+    # Replace uppercase letters with lowercase and prepend an underscore
+    name = re.sub(r"(?<!^)(?=[A-Z])", "_", name).lower()
+    return name
+
+
 def _get_named_objects_in_path(root, path, kind):
     named_objects = []
     cls = root
@@ -52,6 +65,8 @@ def _get_named_objects_in_path(root, path, kind):
             cls = cls.child_object_type
     final_type = ""
     if kind == "NamedObject":
+        if not issubclass(cls, (NamedObject, _ChildNamedObjectAccessorMixin)):
+            raise TypeError(f"{cls.__name__} is not NamedObject type.")
         if issubclass(cls, CreatableNamedObjectMixin):
             final_type = "Creatable"
         else:
@@ -62,7 +77,7 @@ def _get_named_objects_in_path(root, path, kind):
 def generate(version: str):
     """Generate builtin setting classes."""
     print("Generating builtin settings...")
-    CODEGEN_OUTDIR.mkdir(exist_ok=True)
+    config.codegen_outdir.mkdir(exist_ok=True)
     root = _get_settings_root(version)
     version = FluentVersion(version)
     with open(_PY_FILE, "w") as f:
@@ -72,23 +87,52 @@ def generate(version: str):
             "from ansys.fluent.core.solver.flobject import SettingsBase\n\n\n"
         )
         f.write("__all__ = [\n")
-        for name, _ in DATA.items():
+        for name, (kind, _) in DATA.items():
             f.write(f'    "{name}",\n')
+            if kind == "Command":
+                command_name = _convert_camel_case_to_snake_case(name)
+                f.write(f'    "{command_name}",\n')
         f.write("]\n\n")
         for name, v in DATA.items():
             kind, path = v
             if isinstance(path, dict):
+                version_supported = False
                 for version_set, p in path.items():
                     if version in version_set:
                         path = p
+                        version_supported = True
                         break
+                if not version_supported:
+                    continue
             named_objects, final_type = _get_named_objects_in_path(root, path, kind)
             if kind == "NamedObject":
                 kind = f"{final_type}NamedObject"
             f.write(f"class {name}(_{kind}Setting):\n")
-            doc_kind = "command" if kind == "Command" else "setting"
+            doc_kind = "command object" if kind == "Command" else "setting"
             f.write(f'    """{name} {doc_kind}."""\n\n')
+            f.write(f'    _db_name = "{name}"\n\n')
+            f.write("    def __init__(self")
+            for named_object in named_objects:
+                f.write(f", {named_object}: str")
+            f.write(", settings_source: SettingsBase | Solver | None = None")
+            if kind == "NonCreatableNamedObject":
+                f.write(", name: str = None")
+            elif kind == "CreatableNamedObject":
+                f.write(", name: str = None, new_instance_name: str = None")
+            f.write("):\n")
+            f.write("        super().__init__(settings_source=settings_source")
+            if kind == "NonCreatableNamedObject":
+                f.write(", name=name")
+            elif kind == "CreatableNamedObject":
+                f.write(", name=name, new_instance_name=new_instance_name")
+            for named_object in named_objects:
+                f.write(f", {named_object}={named_object}")
+            f.write(")\n\n")
             if kind == "Command":
+                command_name = _convert_camel_case_to_snake_case(name)
+                f.write(f"class {command_name}(_{kind}Setting):\n")
+                f.write(f'    """{command_name} command."""\n\n')
+                f.write(f'    _db_name = "{name}"\n\n')
                 f.write(
                     "    def __new__(cls, settings_source: SettingsBase | Solver | None = None, **kwargs):\n"
                 )
@@ -96,25 +140,7 @@ def generate(version: str):
                 f.write(
                     "       instance.__init__(settings_source=settings_source, **kwargs)\n"
                 )
-                f.write("       return instance(**kwargs")
-            else:
-                f.write("    def __init__(self")
-                for named_object in named_objects:
-                    f.write(f", {named_object}: str")
-                f.write(", settings_source: SettingsBase | Solver | None = None")
-                if kind == "NonCreatableNamedObject":
-                    f.write(", name: str = None")
-                elif kind == "CreatableNamedObject":
-                    f.write(", name: str = None, new_instance_name: str = None")
-                f.write("):\n")
-                f.write("        super().__init__(settings_source=settings_source")
-                if kind == "NonCreatableNamedObject":
-                    f.write(", name=name")
-                elif kind == "CreatableNamedObject":
-                    f.write(", name=name, new_instance_name=new_instance_name")
-                for named_object in named_objects:
-                    f.write(f", {named_object}={named_object}")
-            f.write(")\n\n")
+                f.write("       return instance(**kwargs)\n\n")
 
     with open(_PYI_FILE, "w") as f:
         for version in FluentVersion:

ansys/fluent/core/codegen/datamodelgen.py

@@ -210,7 +210,9 @@ class DataModelStaticInfo:
         self.static_info = None
         if rules_save_name == "":
             rules_save_name = rules
-        datamodel_dir = (pyfluent.CODEGEN_OUTDIR / f"datamodel_{version}").resolve()
+        datamodel_dir = (
+            pyfluent.config.codegen_outdir / f"datamodel_{version}"
+        ).resolve()
         datamodel_dir.mkdir(exist_ok=True)
         self.file_name = (
             datamodel_dir / f"{datamodel_file_name_map[rules_save_name]}.py"

ansys/fluent/core/codegen/print_fluent_version.py

@@ -22,14 +22,14 @@
 
 """Module to write Fluent version information."""
 
-from ansys.fluent.core import CODEGEN_OUTDIR, FluentVersion, launch_fluent
+from ansys.fluent.core import FluentVersion, config, launch_fluent
 
 
 def print_fluent_version(app_utilities):
     """Write Fluent version information to file."""
     version = FluentVersion(app_utilities.get_product_version()).number
     build_info = app_utilities.get_build_info()
-    version_file = (CODEGEN_OUTDIR / f"fluent_version_{version}.py").resolve()
+    version_file = (config.codegen_outdir / f"fluent_version_{version}.py").resolve()
     with open(version_file, "w", encoding="utf8") as f:
         f.write(f'FLUENT_VERSION = "{version}"\n')
         f.write(f'FLUENT_BUILD_TIME = "{build_info.build_time}"\n')

ansys/fluent/core/codegen/settingsgen.py

@@ -316,6 +316,9 @@ def _write_data(cls_name: str, python_name: str, data: dict, f: IO, f_stub: IO |
         s_stub.write(
             f"    {to_constant_name(allowed_value)}: Final[str] = {allowed_value!r}\n"
         )
+    if data["allowed_values"]:
+        s.write(f"    _allowed_values = {data['allowed_values']!r}\n")
+        s_stub.write("    _allowed_values: list[str]\n")
     s.write("\n")
     s_stub.write("\n")
     for name, (python_name, data, hash_, should_write_stub) in classes_to_write.items():
@@ -355,7 +358,7 @@ def generate(version: str, static_infos: dict, verbose: bool = False) -> None:
     shash = _gethash(sinfo)
     if not sinfo:
         return {"<solver_session>": api_tree}
-    output_dir = (pyfluent.CODEGEN_OUTDIR / "solver").resolve()
+    output_dir = (pyfluent.config.codegen_outdir / "solver").resolve()
     output_dir.mkdir(parents=True, exist_ok=True)
     output_file = output_dir / f"settings_{version}.py"
     output_stub_file = output_dir / f"settings_{version}.pyi"

ansys/fluent/core/codegen/tuigen.py

@@ -69,7 +69,7 @@ _ROOT_DIR = Path(__file__) / ".." / ".." / ".." / ".." / ".." / ".."
 
 
 def _get_tui_filepath(mode: str, version: str):
-    return (pyfluent.CODEGEN_OUTDIR / mode / f"tui_{version}.py").resolve()
+    return (pyfluent.config.codegen_outdir / mode / f"tui_{version}.py").resolve()
 
 
 _INDENT_STEP = 4
@@ -96,8 +96,8 @@ _XML_HELPSTRINGS = {}
 
 
 def _copy_tui_help_xml_file(version: str):
-    if os.getenv("PYFLUENT_LAUNCH_CONTAINER") == "1":
-        image_tag = os.getenv("FLUENT_IMAGE_TAG", "v25.1.0")
+    if pyfluent.config.launch_fluent_container:
+        image_tag = pyfluent.config.fluent_image_tag
         image_name = f"{get_ghcr_fluent_image_name(image_tag)}:{image_tag}"
         container_name = uuid.uuid4().hex
         is_linux = platform.system() == "Linux"
@@ -347,7 +347,7 @@ def generate(version, static_infos: dict, verbose: bool = False):
         api_tree["<solver_session>"] = TUIGenerator(
             "solver", version, static_infos, verbose
         ).generate()
-    if os.getenv("PYFLUENT_HIDE_LOG_SECRETS") != "1":
+    if not pyfluent.config.hide_log_secrets:
         logger.info(
             "XML help is available but not picked for the following %i paths: ",
             len(_XML_HELPSTRINGS),

ansys/fluent/core/data_model_cache.py

@@ -126,7 +126,7 @@ class _CacheImpl:
 
 def _is_dict_parameter_type(version: FluentVersion, rules: str, rules_path: str):
     """Check if a parameter is a dict type."""
-    from ansys.fluent.core import CODEGEN_OUTDIR
+    from ansys.fluent.core import config
     from ansys.fluent.core.services.datamodel_se import (
         PyDictionary,
         PyNamedObjectContainer,
@@ -136,7 +136,7 @@ def _is_dict_parameter_type(version: FluentVersion, rules: str, rules_path: str)
 
     try:
         module = load_module(
-            rules, CODEGEN_OUTDIR / f"datamodel_{version.number}" / f"{rules}.py"
+            rules, config.codegen_outdir / f"datamodel_{version.number}" / f"{rules}.py"
         )
     except FileNotFoundError:  # no codegen or during codegen
         return False

ansys/fluent/core/docker/docker_compose.py

@@ -22,7 +22,6 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 
-import os
 import subprocess
 import uuid
 
@@ -32,10 +31,13 @@ from .utils import get_ghcr_fluent_image_name
 class ComposeBasedLauncher:
     """Launch Fluent through docker or Podman compose."""
 
-    def __init__(self, *, container_dict):
+    def __init__(self, compose_config, container_dict):
+        from ansys.fluent.core import config
+
+        self._compose_config = compose_config
         self._compose_name = f"pyfluent_compose_{uuid.uuid4().hex}"
         self._container_dict = container_dict
-        image_tag = os.getenv("FLUENT_IMAGE_TAG")
+        image_tag = config.fluent_image_tag
         self._image_name = (
             container_dict.get("fluent_image")
             or f"{get_ghcr_fluent_image_name(image_tag)}:{image_tag}"
@@ -45,9 +47,6 @@ class ComposeBasedLauncher:
 
         self._compose_file = self._get_compose_file(container_dict)
 
-    def _is_podman_selected(self):
-        return os.getenv("PYFLUENT_USE_PODMAN_COMPOSE") == "1"
-
     def _get_compose_file(self, container_dict):
         """Generates compose file for the Docker Compose setup.
 
@@ -132,14 +131,14 @@ class ComposeBasedLauncher:
         """
 
         # Determine the compose command
-        if os.getenv("PYFLUENT_USE_PODMAN_COMPOSE") == "1":
+        if self._compose_config.use_podman_compose:
             self._compose_cmds = (
                 ["sudo", "podman", "compose"]
                 if hasattr(self, "_container_source")
                 and "sudo" in self._container_source
                 else ["podman", "compose"]
             )
-        elif os.getenv("PYFLUENT_USE_DOCKER_COMPOSE") == "1":
+        elif self._compose_config.use_docker_compose:
             self._compose_cmds = ["docker", "compose"]
         else:
             raise RuntimeError("Neither Docker nor Podman is specified.")
@@ -151,7 +150,7 @@ class ComposeBasedLauncher:
         try:
             cmd = self._container_source + ["images", "-q", self._image_name]
             # Podman users do not always configure rootless mode in /etc/subuids and /etc/subgids
-            if self._is_podman_selected():
+            if self._compose_config.use_podman_compose:
                 sudo_cmd = ["sudo"] + cmd
                 output_1 = subprocess.check_output(cmd)
                 output_2 = subprocess.check_output(sudo_cmd)

ansys/fluent/core/docker/utils.py

@@ -29,7 +29,7 @@ def get_ghcr_fluent_image_name(image_tag: str):
     """
     Get the Fluent image name from GitHub registry based on the image tag.
     """
-    if image_tag >= "v26.1":
-        return "ghcr.io/ansys/pyfluent"
+    if image_tag.startswith("sha256:") or image_tag >= "v26.1":
+        return "ghcr.io/ansys/fluent"
     else:
         return "ghcr.io/ansys/pyfluent"

ansys/fluent/core/examples/downloads.py

@@ -49,16 +49,16 @@ def delete_downloads():
 
     Notes
     -----
-    The default examples path is given by ``pyfluent.EXAMPLES_PATH``.
+    The default examples path is given by ``pyfluent.config.examples_path``.
     """
-    shutil.rmtree(pyfluent.EXAMPLES_PATH)
-    os.makedirs(pyfluent.EXAMPLES_PATH)
+    shutil.rmtree(pyfluent.config.examples_path)
+    os.makedirs(pyfluent.config.examples_path)
 
 
 def _decompress(file_name: str) -> None:
     """Decompress zipped file."""
     zip_ref = zipfile.ZipFile(file_name, "r")
-    zip_ref.extractall(pyfluent.EXAMPLES_PATH)
+    zip_ref.extractall(pyfluent.config.examples_path)
     return zip_ref.close()
 
 
@@ -81,10 +81,7 @@ def _retrieve_file(
     """Download specified file from specified URL."""
     file_name = os.path.basename(file_name)
     if save_path is None:
-        save_path = os.getenv(
-            "PYFLUENT_CONTAINER_MOUNT_SOURCE",
-            pyfluent.CONTAINER_MOUNT_SOURCE or os.getcwd(),
-        )
+        save_path = pyfluent.config.container_mount_source or os.getcwd()
     else:
         save_path = os.path.abspath(save_path)
     local_path = os.path.join(save_path, file_name)
@@ -180,8 +177,8 @@ def download_file(
     'bracket.iges'
     """
     if return_without_path is None:
-        if os.getenv("PYFLUENT_LAUNCH_CONTAINER") == "1":
-            if pyfluent.USE_FILE_TRANSFER_SERVICE:
+        if pyfluent.config.launch_fluent_container:
+            if pyfluent.config.use_file_transfer_service:
                 return_without_path = False
             else:
                 return_without_path = True
@@ -212,7 +209,7 @@ def path(file_name: str):
     """
     if os.path.isabs(file_name):
         return file_name
-    file_path = Path(pyfluent.EXAMPLES_PATH) / file_name
+    file_path = Path(pyfluent.config.examples_path) / file_name
     if file_path.is_file():
         return str(file_path)
     else:

ansys/fluent/core/fluent_connection.py

@@ -42,7 +42,7 @@ from deprecated.sphinx import deprecated
 import grpc
 
 import ansys.fluent.core as pyfluent
-from ansys.fluent.core.launcher.launcher_utils import is_compose
+from ansys.fluent.core.launcher.launcher_utils import ComposeConfig
 from ansys.fluent.core.services import service_creator
 from ansys.fluent.core.services.app_utilities import (
     AppUtilitiesOld,
@@ -252,9 +252,9 @@ class FluentConnectionProperties:
 
 def _get_ip_and_port(ip: str | None = None, port: int | None = None) -> (str, int):
     if not ip:
-        ip = os.getenv("PYFLUENT_FLUENT_IP", "127.0.0.1")
+        ip = pyfluent.config.launch_fluent_ip or "127.0.0.1"
     if not port:
-        port = os.getenv("PYFLUENT_FLUENT_PORT")
+        port = pyfluent.config.launch_fluent_port
     if not port:
         raise PortNotProvided()
     return ip, port
@@ -381,6 +381,7 @@ class FluentConnection:
         slurm_job_id: str | None = None,
         inside_container: bool | None = None,
         container: ContainerT | None = None,
+        compose_config: ComposeConfig | None = None,
     ):
         """Initialize a Session.
 
@@ -420,12 +421,15 @@ class FluentConnection:
         container: ContainerT, optional
             The container instance if the Fluent session is running inside
             a container.
+        compose_config: ComposeConfig, optional
+            Configuration for Docker Compose or Podman Compose.
 
         Raises
         ------
         PortNotProvided
             If port is not provided.
         """
+        self._compose_config = compose_config if compose_config else ComposeConfig()
         self._error_state = ErrorState()
         self._data_valid = False
         self._channel_str = None
@@ -447,7 +451,7 @@ class FluentConnection:
         # At this point, the server must be running. If the following check_health()
         # throws, we should not proceed.
         # TODO: Show user-friendly error message.
-        if pyfluent.CHECK_HEALTH:
+        if pyfluent.config.check_health:
             self._health_check.check_health()
 
         self._slurm_job_id = slurm_job_id
@@ -472,7 +476,7 @@ class FluentConnection:
             and cortex_host is not None
         ):
             logger.info("Checking if Fluent is running inside a container.")
-            if not is_compose():
+            if not self._compose_config.is_compose:
                 inside_container = get_container(cortex_host)
                 logger.debug(f"get_container({cortex_host}): {inside_container}")
             if inside_container is False:
@@ -549,7 +553,10 @@ class FluentConnection:
         >>> session = pyfluent.launch_fluent()
         >>> session.force_exit()
         """
-        if self.connection_properties.inside_container or is_compose():
+        if (
+            self.connection_properties.inside_container
+            or self._compose_config.is_compose
+        ):
             self._force_exit_container()
         elif self._remote_instance is not None:
             logger.error("Cannot execute cleanup script, Fluent running remotely.")
@@ -601,7 +608,7 @@ class FluentConnection:
     def _force_exit_container(self):
         """Immediately terminates the Fluent client running inside a container, losing
         unsaved progress and data."""
-        if is_compose() and self._container:
+        if self._compose_config.is_compose and self._container:
             self._container.stop()
         else:
             container = self.connection_properties.inside_container
@@ -679,7 +686,10 @@ class FluentConnection:
         else:
             raise WaitTypeError()
 
-        if self.connection_properties.inside_container and not is_compose():
+        if (
+            self.connection_properties.inside_container
+            and not self._compose_config.is_compose
+        ):
             _response = timeout_loop(
                 get_container,
                 wait,
@@ -748,17 +758,15 @@ class FluentConnection:
             )
 
         if timeout is None:
-            env_timeout = os.getenv("PYFLUENT_TIMEOUT_FORCE_EXIT")
-            if env_timeout is not None:
-                logger.debug(
-                    f"Found PYFLUENT_TIMEOUT_FORCE_EXIT env var: '{env_timeout}'"
-                )
+            config_timeout = pyfluent.config.force_exit_timeout
+            if config_timeout is not None:
+                logger.debug(f"Found force_exit_timeout config: '{config_timeout}'")
                 try:
-                    timeout = float(env_timeout)
+                    timeout = float(config_timeout)
                     logger.debug(f"Setting TIMEOUT_FORCE_EXIT to {timeout}")
                 except ValueError:
                     logger.debug(
-                        "Invalid PYFLUENT_TIMEOUT_FORCE_EXIT. Must be a float or int. "
+                        "Invalid force_exit_timeout config. Must be a float or int. "
                         "Timeout forced exit is disabled."
                     )