ansys-fluent-core 0.34.1__py3-none-any.whl → 0.35.0__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.1"
+__version__ = "0.35.0"
 
-_VERSION_INFO = "Build date: August 05, 2025 03:19 UTC ShaID: ffa3845"
+_VERSION_INFO = "Build date: September 09, 2025 06:25 UTC ShaID: 1d655a9"
 """
 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

@@ -153,6 +153,7 @@ def _populate_data(cls, api_tree: dict, version: str) -> dict:
     else:
         data["child_object_type"] = None
     data["allowed_values"] = getattr(cls, "_allowed_values", [])
+    data["has_migration_adapter"] = getattr(cls, "_has_migration_adapter", False)
     return data
 
 
@@ -316,6 +317,12 @@ 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")
+    if data["has_migration_adapter"]:
+        s.write("    _has_migration_adapter = True\n")
+        s_stub.write("    _has_migration_adapter: bool\n")
     s.write("\n")
     s_stub.write("\n")
     for name, (python_name, data, hash_, should_write_stub) in classes_to_write.items():
@@ -355,7 +362,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":
+    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)
@@ -140,7 +137,7 @@ def download_file(
     save_path : str, optional
         Path to download the specified file to.
     return_without_path : bool, optional
-        When unspecified, defaults to False, unless the PYFLUENT_LAUNCH_CONTAINER=1 environment variable is specified,
+        When unspecified, defaults to False, unless the launch_fluent_container config is set to True,
         in which case defaults to True.
         Relevant when using Fluent Docker container images, as the full path for the imported file from
         the host side is not necessarily going to be the same as the one for Fluent inside the container.
@@ -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: