ansys-fluent-core 0.34.dev0__py3-none-any.whl → 0.35.dev0__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.dev0"
+__version__ = "0.35.dev0"
 
-_VERSION_INFO = "Build date: June 24, 2025 09:29 UTC ShaID: f235a41"
+_VERSION_INFO = "Build date: August 12, 2025 05:58 UTC ShaID: c65664b"
 """
 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 = False
-
-# 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,8 +87,11 @@ 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
@@ -86,8 +104,9 @@ def generate(version: str):
             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")
@@ -96,8 +115,6 @@ def generate(version: str):
                 f.write(", name: str = None")
             elif kind == "CreatableNamedObject":
                 f.write(", name: str = None, new_instance_name: str = None")
-            if kind == "Command":
-                f.write(", **kwargs")
             f.write("):\n")
             f.write("        super().__init__(settings_source=settings_source")
             if kind == "NonCreatableNamedObject":
@@ -106,9 +123,20 @@ def generate(version: str):
                 f.write(", name=name, new_instance_name=new_instance_name")
             for named_object in named_objects:
                 f.write(f", {named_object}={named_object}")
-            if kind == "Command":
-                f.write(", **kwargs")
             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"
+                )
+                f.write("       instance = super().__new__(cls)\n")
+                f.write(
+                    "       instance.__init__(settings_source=settings_source, **kwargs)\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

@@ -38,6 +38,7 @@ from ansys.fluent.core.solver.flobject import (
     ListObject,
     NamedObject,
     get_cls,
+    to_constant_name,
     to_python_name,
 )
 from ansys.fluent.core.utils.fix_doc import fix_settings_doc
@@ -107,10 +108,11 @@ def strip_parameters(docstring: str) -> str:
 
 
 def _populate_data(cls, api_tree: dict, version: str) -> dict:
-    data = {}
-    data["version"] = version
-    data["name"] = cls.__name__
-    data["bases"] = [base.__name__ for base in cls.__bases__]
+    data = {
+        "version": version,
+        "name": cls.__name__,
+        "bases": [base.__name__ for base in cls.__bases__],
+    }
     if "command" in cls.__doc__:
         data["doc"] = strip_parameters(cls.__doc__)
     else:
@@ -150,6 +152,7 @@ def _populate_data(cls, api_tree: dict, version: str) -> dict:
         data["child_object_type"]["doc"] = f"'child_object_type' of {cls.__name__}."
     else:
         data["child_object_type"] = None
+    data["allowed_values"] = getattr(cls, "_allowed_values", [])
     return data
 
 
@@ -306,7 +309,15 @@ def _write_data(cls_name: str, python_name: str, data: dict, f: IO, f_stub: IO |
     if return_type:
         s.write(f"    return_type = {return_type!r}\n")
         s_stub.write("    return_type: str\n")
+    for allowed_value in data["allowed_values"]:
+        s.write(
+            f"    {to_constant_name(allowed_value)} = _FlStringConstant({allowed_value!r})\n"
+        )
+        s_stub.write(
+            f"    {to_constant_name(allowed_value)}: Final[str] = {allowed_value!r}\n"
+        )
     s.write("\n")
+    s_stub.write("\n")
     for name, (python_name, data, hash_, should_write_stub) in classes_to_write.items():
         if name not in _CLASS_WRITTEN:
             _write_data(
@@ -344,7 +355,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"
@@ -370,10 +381,11 @@ def generate(version: str, static_infos: dict, verbose: bool = False) -> None:
         header.write("    _InputFile,\n")
         header.write("    _OutputFile,\n")
         header.write("    _InOutFile,\n")
+        header.write("    _FlStringConstant,\n")
         header.write(")\n\n")
         f.write(header.getvalue())
         f_stub.write(header.getvalue())
-        f_stub.write("from typing import Any\n\n")
+        f_stub.write("from typing import Any, Final\n\n")
         f.write(f'SHASH = "{shash}"\n\n')
         name = data["name"]
         _NAME_BY_HASH[_gethash(data)] = name

ansys/fluent/core/codegen/tuigen.py

@@ -52,6 +52,7 @@ import ansys.fluent.core as pyfluent
 from ansys.fluent.core import FluentMode, launch_fluent
 from ansys.fluent.core.codegen import StaticInfoType
 from ansys.fluent.core.codegen.data.fluent_gui_help_patch import XML_HELP_PATCH
+from ansys.fluent.core.docker.utils import get_ghcr_fluent_image_name
 from ansys.fluent.core.services.datamodel_tui import (
     convert_path_to_grpc_path,
     convert_tui_menu_to_func_name,
@@ -68,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
@@ -95,9 +96,9 @@ _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")
-        image_name = f"ghcr.io/ansys/pyfluent:{image_tag}"
+    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"
         subprocess.run(
@@ -346,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,29 +22,31 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 
-import os
 import subprocess
 import uuid
 
+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 = config.fluent_image_tag
         self._image_name = (
             container_dict.get("fluent_image")
-            or f"ghcr.io/ansys/pyfluent:{os.getenv('FLUENT_IMAGE_TAG')}"
+            or f"{get_ghcr_fluent_image_name(image_tag)}:{image_tag}"
         )
         self._container_source = self._set_compose_cmds()
         self._container_source.remove("compose")
 
         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.
 
@@ -129,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.")
@@ -148,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

@@ -0,0 +1,35 @@
+# Copyright (C) 2021 - 2025 ANSYS, Inc. and/or its affiliates.
+# SPDX-License-Identifier: MIT
+#
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+"""
+Utility functions for working with Fluent Docker images.
+"""
+
+
+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.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/exceptions.py

@@ -34,7 +34,7 @@ class DisallowedValuesError(ValueError):
         context: str | None = None,
         name: Any | None = None,
         allowed_values: Iterable[Any] | None = None,
-    ):
+    ) -> None:
         """Initialize DisallowedValuesError."""
         super().__init__(
             allowed_name_error_message(
@@ -50,3 +50,15 @@ class InvalidArgument(ValueError):
     """Raised when an argument value is inappropriate."""
 
     pass
+
+
+class BetaFeaturesNotEnabled(RuntimeError):
+    """Raised when a beta feature is accessed without enabling beta features."""
+
+    def __init__(self, feature_name: str | None = None) -> None:
+        message = (
+            f"The feature '{feature_name}' is not available until 'enable_beta_features()' has been called."
+            if feature_name
+            else "This feature is not available until 'enable_beta_features()' has been called."
+        )
+        super().__init__(message)