ansys-fluent-core 0.34.dev0__py3-none-any.whl → 0.35.dev0__py3-none-any.whl

ansys/fluent/core/launcher/pim_launcher.py

@@ -40,13 +40,14 @@ import logging
 import os
 from typing import Any, Dict
 
-from ansys.fluent.core.fluent_connection import FluentConnection
+from ansys.fluent.core.fluent_connection import FluentConnection, _get_max_c_int_limit
 from ansys.fluent.core.launcher.launch_options import (
     Dimension,
     FluentLinuxGraphicsDriver,
     FluentMode,
     FluentWindowsGraphicsDriver,
     Precision,
+    UIMode,
     _get_argvals_and_session,
 )
 from ansys.fluent.core.session_meshing import Meshing
@@ -68,6 +69,7 @@ class PIMLauncher:
     def __init__(
         self,
         mode: FluentMode | str | None = None,
+        ui_mode: UIMode | str | None = None,
         graphics_driver: (
             FluentWindowsGraphicsDriver | FluentLinuxGraphicsDriver | str | None
         ) = None,
@@ -78,6 +80,7 @@ class PIMLauncher:
         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,
@@ -90,6 +93,8 @@ class PIMLauncher:
         ----------
         mode : FluentMode
             Specifies the launch mode of Fluent for targeting a specific session type.
+        ui_mode : UIMode
+            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).
@@ -115,6 +120,8 @@ class PIMLauncher:
         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, returns a configuration dictionary instead of starting a Fluent session.
         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.
@@ -170,7 +177,9 @@ class PIMLauncher:
                 FluentVersion(self.argvals["product_version"]).number
             )
         else:
-            fluent_product_version = None
+            fluent_product_version = str(
+                FluentVersion(FluentVersion.current_release()).number
+            )
 
         return launch_remote_fluent(
             session_cls=self.new_session,
@@ -236,7 +245,12 @@ def launch_remote_fluent(
 
     instance.wait_for_ready()
 
-    channel = instance.build_grpc_channel()
+    channel = instance.build_grpc_channel(
+        options=[
+            ("grpc.max_send_message_length", _get_max_c_int_limit()),
+            ("grpc.max_receive_message_length", _get_max_c_int_limit()),
+        ],
+    )
 
     fluent_connection = create_fluent_connection(
         channel=channel,

ansys/fluent/core/launcher/process_launch_string.py

@@ -132,7 +132,7 @@ def _generate_launch_string(
     if " " in server_info_file_name:
         server_info_file_name = '"' + server_info_file_name + '"'
     launch_string += f" -sifile={server_info_file_name}"
-    if not pyfluent.FLUENT_SHOW_MESH_AFTER_CASE_READ:
+    if not pyfluent.config.fluent_show_mesh_after_case_read:
         launch_string += " -nm"
     return launch_string
 
@@ -149,6 +149,7 @@ def get_fluent_exe_path(**launch_argvals) -> Path:
     Path
         Fluent executable path
     """
+    from ansys.fluent.core import config
 
     def get_exe_path(fluent_root: Path) -> Path:
         if launcher_utils.is_windows():
@@ -170,7 +171,7 @@ def get_fluent_exe_path(**launch_argvals) -> Path:
         return FluentVersion(product_version).get_fluent_exe_path()
 
     # (DEV) "PYFLUENT_FLUENT_ROOT" environment variable
-    fluent_root = os.getenv("PYFLUENT_FLUENT_ROOT")
+    fluent_root = config.fluent_root
     if fluent_root:
         return get_exe_path(Path(fluent_root))
 

ansys/fluent/core/launcher/server_info.py

@@ -53,7 +53,9 @@ def _get_server_info_file_names(use_tmpdir=True) -> tuple[str, str]:
     temporary directory if ``use_tmpdir`` is True, otherwise it is created in the current working
     directory.
     """
-    server_info_dir = os.getenv("SERVER_INFO_DIR")
+    from ansys.fluent.core import config
+
+    server_info_dir = config.fluent_server_info_dir
     dir_ = (
         Path(server_info_dir)
         if server_info_dir
@@ -95,6 +97,8 @@ def _get_server_info(
     password: str | None = None,
 ):
     """Get server connection information of an already running session."""
+    from ansys.fluent.core import config
+
     if not (ip and port) and not server_info_file_name:
         raise IpPortNotProvided()
     if (ip or port) and server_info_file_name:
@@ -105,8 +109,8 @@ def _get_server_info(
     else:
         if server_info_file_name:
             ip, port, password = _parse_server_info_file(server_info_file_name)
-        ip = ip or os.getenv("PYFLUENT_FLUENT_IP", "127.0.0.1")
-        port = port or os.getenv("PYFLUENT_FLUENT_PORT")
+        ip = ip or config.launch_fluent_ip or "127.0.0.1"
+        port = port or config.launch_fluent_port
 
     _check_ip_port(ip=ip, port=port)
 

ansys/fluent/core/launcher/slurm_launcher.py

@@ -64,7 +64,6 @@ are optional and should be specified in a similar manner to Fluent's scheduler o
 from concurrent.futures import Future, ThreadPoolExecutor
 import inspect
 import logging
-import os
 from pathlib import Path
 import shutil
 import subprocess
@@ -414,6 +413,8 @@ class SlurmLauncher:
         The allocated machines and core counts are queried from the scheduler environment and
         passed to Fluent.
         """
+        from ansys.fluent.core import config
+
         if not _SlurmWrapper.is_available():
             raise RuntimeError("Slurm is not available.")
         locals_ = locals().copy()
@@ -423,7 +424,7 @@ class SlurmLauncher:
         }
         self._argvals, self._new_session = _get_argvals_and_session(argvals)
         self.file_transfer_service = file_transfer_service
-        if os.getenv("PYFLUENT_SHOW_SERVER_GUI") == "1":
+        if config.show_fluent_gui:
             ui_mode = UIMode.GUI
         self._argvals["ui_mode"] = UIMode(ui_mode)
         if self._argvals["start_timeout"] is None:
@@ -459,6 +460,7 @@ class SlurmLauncher:
         launch_cmd += _build_journal_argument(
             self._argvals["topy"], self._argvals["journal_file_names"]
         )
+        launch_cmd += ' --setenv="FLUENT_ALLOW_REMOTE_GRPC_CONNECTION=1"'
 
         logger.debug(f"Launching Fluent with command: {launch_cmd}")
         proc = subprocess.Popen(launch_cmd, **kwargs)

ansys/fluent/core/launcher/standalone_launcher.py

@@ -193,7 +193,7 @@ class StandaloneLauncher:
         }
         self.argvals, self.new_session = _get_argvals_and_session(argvals)
         self.file_transfer_service = file_transfer_service
-        if os.getenv("PYFLUENT_SHOW_SERVER_GUI") == "1":
+        if pyfluent.config.show_fluent_gui:
             ui_mode = UIMode.GUI
         self.argvals["ui_mode"] = UIMode(ui_mode)
         if self.argvals["start_timeout"] is None:
@@ -211,7 +211,7 @@ class StandaloneLauncher:
         ):
             self.argvals["py"] = True
 
-        if os.getenv("PYFLUENT_FLUENT_DEBUG") == "1":
+        if pyfluent.config.fluent_debug:
             self.argvals["fluent_debug"] = True
 
         server_info_file_name_for_server, server_info_file_name_for_client = (
@@ -234,7 +234,10 @@ class StandaloneLauncher:
         )
 
         if is_windows():
-            if pyfluent.LAUNCH_FLUENT_STDOUT or pyfluent.LAUNCH_FLUENT_STDERR:
+            if (
+                pyfluent.config.launch_fluent_stdout
+                or pyfluent.config.launch_fluent_stderr
+            ):
                 self._launch_cmd = self._launch_string
             else:
                 # Using 'start.exe' is better; otherwise Fluent is more susceptible to bad termination attempts.

ansys/fluent/core/launcher/watchdog.py

@@ -76,8 +76,8 @@ def launch(
         )
     )
 
-    env_watchdog_debug = os.getenv("PYFLUENT_WATCHDOG_DEBUG", "off").upper()
-    if env_watchdog_debug in ("1", "ON"):
+    debug_watchdog = pyfluent.config.watchdog_debug
+    if debug_watchdog:
         logger.debug(
             f"PYFLUENT_WATCHDOG_DEBUG environment variable found, "
             f"enabling debugging for watchdog ID {watchdog_id}..."
@@ -131,7 +131,7 @@ def launch(
         watchdog_id,
     ]
 
-    if env_watchdog_debug in ("1", "ON"):
+    if debug_watchdog:
         logger.debug(f"Starting Watchdog logging to directory {os.getcwd()}")
 
     kwargs = {"env": watchdog_env, "stdin": subprocess.DEVNULL, "close_fds": True}
@@ -151,7 +151,7 @@ def launch(
     if os.name == "posix":
         kwargs.update(start_new_session=True)
 
-    if env_watchdog_debug in ("1", "ON") and os.name != "nt":
+    if debug_watchdog and os.name != "nt":
         kwargs.update(
             stdout=open(f"pyfluent_watchdog_out_{watchdog_id}.log", mode="w"),
             stderr=open(f"pyfluent_watchdog_err_{watchdog_id}.log", mode="w"),
@@ -194,13 +194,13 @@ def launch(
                 err_content = "Watchdog - %s" % f.read().replace("\n", "")
             watchdog_err.unlink()
             logger.error(err_content)
-            if os.getenv("PYFLUENT_WATCHDOG_EXCEPTION_ON_ERROR"):
+            if pyfluent.config.watchdog_exception_on_error:
                 raise UnsuccessfulWatchdogLaunch(err_content)
 
         logger.warning(
             "PyFluent Watchdog did not initialize correctly, proceeding without it..."
         )
-        if os.getenv("PYFLUENT_WATCHDOG_EXCEPTION_ON_ERROR"):
+        if pyfluent.config.watchdog_exception_on_error:
             raise UnsuccessfulWatchdogLaunch(
                 "PyFluent Watchdog did not initialize correctly."
             )

ansys/fluent/core/launcher/watchdog_exec

@@ -34,7 +34,7 @@ if __name__ == "__main__":
 
         logger = pyfluent.logger.get_logger("pyfluent.watchdog")
 
-        if os.getenv("PYFLUENT_WATCHDOG_DEBUG", "OFF").upper() in ("1", "ON"):
+        if pyfluent.config.watchdog_debug:
             pyfluent.logger.enable(custom_config=log_config)
             logger.setLevel("DEBUG")
             logger.handlers = pyfluent.logger.get_logger(

ansys/fluent/core/logger.py

@@ -25,6 +25,8 @@
 import logging.config
 import os
 
+from ansys.fluent.core import config
+
 _logging_file_enabled = False
 
 
@@ -250,7 +252,7 @@ def configure_env_var() -> None:
     If logging debug output to file by default is desired, without having to use :func:`enable()` every time,
     set environment variable ``PYFLUENT_LOGGING`` to ``DEBUG``.
     """
-    env_logging_level = os.getenv("PYFLUENT_LOGGING")
+    env_logging_level = config.logging_level_default
     if env_logging_level:
         if env_logging_level.isdigit():
             env_logging_level = int(env_logging_level)

ansys/fluent/core/module_config.py

@@ -0,0 +1,358 @@
+# 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.
+"""Configuration variables for PyFluent."""
+import inspect
+import os
+from pathlib import Path
+from typing import Any, Callable, Generic, TypeVar
+import warnings
+
+TConfig = TypeVar("TConfig", bound="Config")
+
+
+class _ConfigDescriptor(Generic[TConfig]):
+    """Descriptor for managing configuration attributes."""
+
+    def __init__(
+        self, default_fn: Callable[[TConfig], Any], deprecated_var: str | None = None
+    ):
+        self._default_fn = default_fn
+        self._deprecated_var = deprecated_var
+
+    def _get_config(self, instance: TConfig) -> Any:
+        if not hasattr(instance, self._backing_field):
+            setattr(instance, self._backing_field, self._default_fn(instance))
+        return getattr(instance, self._backing_field)
+
+    def _set_config(self, instance: TConfig, value: Any):
+        setattr(instance, self._backing_field, value)
+
+    def __set_name__(self, owner: type[TConfig], name: str):
+        self._backing_field = "_" + name
+
+    def __get__(self, instance: TConfig, owner: type[TConfig]) -> Any:
+        import ansys.fluent.core as pyfluent
+
+        if self._deprecated_var is not None and self._deprecated_var in vars(pyfluent):
+            return getattr(pyfluent, self._deprecated_var)
+        return self._get_config(instance)
+
+    def __set__(self, instance: TConfig, value: Any):
+        import ansys.fluent.core as pyfluent
+
+        if self._deprecated_var is not None and self._deprecated_var in vars(pyfluent):
+            warnings.warn(
+                f"Deleting deprecated module-level variable '{self._deprecated_var}' which was previously set."
+            )
+            delattr(pyfluent, self._deprecated_var)
+        self._set_config(instance, value)
+
+
+def _get_default_examples_path(instance: "Config") -> str:
+    """Get the default examples path."""
+    parent_path = Path.home() / "Downloads"
+    parent_path.mkdir(exist_ok=True)
+    return str(parent_path / "ansys_fluent_core_examples")
+
+
+class Config:
+    """Set the global configuration variables for PyFluent."""
+
+    #: Directory where example files are downloaded.
+    examples_path = _ConfigDescriptor["Config"](
+        _get_default_examples_path, "EXAMPLES_PATH"
+    )
+
+    #: Host path which is mounted to the container, defaults to the value of ``PYFLUENT_CONTAINER_MOUNT_SOURCE`` environment variable.
+    container_mount_source = _ConfigDescriptor["Config"](
+        lambda instance: instance._env.get("PYFLUENT_CONTAINER_MOUNT_SOURCE"),
+        "CONTAINER_MOUNT_SOURCE",
+    )
+
+    #: Path inside the container where the host path is mounted, defaults to "/home/container/workdir".
+    container_mount_target = _ConfigDescriptor["Config"](
+        lambda instance: "/home/container/workdir", "CONTAINER_MOUNT_TARGET"
+    )
+
+    #: Set this to False to stop automatically inferring and setting REMOTING_SERVER_ADDRESS, defaults to True.
+    infer_remoting_ip = _ConfigDescriptor["Config"](
+        lambda instance: True, "INFER_REMOTING_IP"
+    )
+
+    # Time in seconds to wait for response for each ip while inferring remoting ip, defaults to 2.
+    infer_remoting_ip_timeout_per_ip = _ConfigDescriptor["Config"](
+        lambda instance: 2, "INFER_REMOTING_IP_TIMEOUT_PER_IP"
+    )
+
+    #: Whether to use datamodel state caching, defaults to True.
+    datamodel_use_state_cache = _ConfigDescriptor["Config"](
+        lambda instance: True, "DATAMODEL_USE_STATE_CACHE"
+    )
+
+    #: Whether to use datamodel attribute caching, defaults to True.
+    datamodel_use_attr_cache = _ConfigDescriptor["Config"](
+        lambda instance: True, "DATAMODEL_USE_ATTR_CACHE"
+    )
+
+    #: Whether to stream and cache commands state, defaults to True.
+    datamodel_use_nocommands_diff_state = _ConfigDescriptor["Config"](
+        lambda instance: True, "DATAMODEL_USE_NOCOMMANDS_DIFF_STATE"
+    )
+
+    #: Whether to return the state changes on mutating datamodel RPCs, defaults to True.
+    datamodel_return_state_changes = _ConfigDescriptor["Config"](
+        lambda instance: True, "DATAMODEL_RETURN_STATE_CHANGES"
+    )
+
+    #: Whether to use remote gRPC file transfer service, defaults to False.
+    use_file_transfer_service = _ConfigDescriptor["Config"](
+        lambda instance: False, "USE_FILE_TRANSFER_SERVICE"
+    )
+
+    #: Directory where API files are written out during codegen.
+    codegen_outdir = _ConfigDescriptor["Config"](
+        lambda instance: instance._env.get(
+            "PYFLUENT_CODEGEN_OUTDIR", (Path(__file__) / ".." / "generated").resolve()
+        ),
+        "CODEGEN_OUTDIR",
+    )
+
+    #: Whether to show mesh in Fluent after case read, defaults to False.
+    fluent_show_mesh_after_case_read = _ConfigDescriptor["Config"](
+        lambda instance: False, "FLUENT_SHOW_MESH_AFTER_CASE_READ"
+    )
+
+    #: Whether to write the automatic transcript in Fluent, defaults to the value of ``PYFLUENT_FLUENT_AUTOMATIC_TRANSCRIPT`` environment variable.
+    fluent_automatic_transcript = _ConfigDescriptor["Config"](
+        lambda instance: instance._env.get("PYFLUENT_FLUENT_AUTOMATIC_TRANSCRIPT")
+        == "1",
+        "FLUENT_AUTOMATIC_TRANSCRIPT",
+    )
+
+    #: Whether to interrupt Fluent solver from PyFluent, defaults to False.
+    support_solver_interrupt = _ConfigDescriptor["Config"](
+        lambda instance: False, "SUPPORT_SOLVER_INTERRUPT"
+    )
+
+    #: Whether to start watchdog.
+    start_watchdog = _ConfigDescriptor["Config"](
+        lambda instance: None, "START_WATCHDOG"
+    )
+
+    #: Whether to enable debug logging for the watchdog, defaults to the value of ``PYFLUENT_WATCHDOG_DEBUG`` environment variable.
+    watchdog_debug = _ConfigDescriptor["Config"](
+        lambda instance: instance._env.get("PYFLUENT_WATCHDOG_DEBUG") == "1",
+        "WATCHDOG_DEBUG",
+    )
+
+    #: Whether to raise an exception when the watchdog encounters an error, defaults to the value of ``PYFLUENT_WATCHDOG_EXCEPTION_ON_ERROR`` environment variable.
+    watchdog_exception_on_error = _ConfigDescriptor["Config"](
+        lambda instance: instance._env.get("PYFLUENT_WATCHDOG_EXCEPTION_ON_ERROR")
+        == "1",
+        "WATCHDOG_EXCEPTION_ON_ERROR",
+    )
+
+    #: Health check timeout in seconds, defaults to 60 seconds.
+    check_health_timeout = _ConfigDescriptor["Config"](
+        lambda instance: 60, "CHECK_HEALTH_TIMEOUT"
+    )
+
+    #: Whether to skip health check, defaults to True.
+    check_health = _ConfigDescriptor["Config"](lambda instance: True, "CHECK_HEALTH")
+
+    #: Whether to print search results, defaults to True.
+    print_search_results = _ConfigDescriptor["Config"](
+        lambda instance: True, "PRINT_SEARCH_RESULTS"
+    )
+
+    #: Whether to clear environment variables related to Fluent parallel mode, defaults to False.
+    clear_fluent_para_envs = _ConfigDescriptor["Config"](
+        lambda instance: False, "CLEAR_FLUENT_PARA_ENVS"
+    )
+
+    #: Set stdout of the launched Fluent process.
+    #: Valid values are the same as subprocess.Popen's stdout argument.
+    launch_fluent_stdout = _ConfigDescriptor["Config"](
+        lambda instance: None, "LAUNCH_FLUENT_STDOUT"
+    )
+
+    #: Set stderr of the launched Fluent process.
+    #: Valid values are the same as subprocess.Popen's stderr argument.
+    launch_fluent_stderr = _ConfigDescriptor["Config"](
+        lambda instance: None, "LAUNCH_FLUENT_STDERR"
+    )
+
+    #: Set the IP address of the Fluent server while launching Fluent, defaults to the value of ``PYFLUENT_FLUENT_IP`` environment variable.
+    launch_fluent_ip = _ConfigDescriptor["Config"](
+        lambda instance: instance._env.get("PYFLUENT_FLUENT_IP"), "LAUNCH_FLUENT_IP"
+    )
+
+    #: Set the port of the Fluent server while launching Fluent, defaults to the value of ``PYFLUENT_FLUENT_PORT`` environment variable.
+    launch_fluent_port = _ConfigDescriptor["Config"](
+        lambda instance: instance._env.get("PYFLUENT_FLUENT_PORT"), "LAUNCH_FLUENT_PORT"
+    )
+
+    #: Skip password check during RPC execution when Fluent is launched from PyFluent, defaults to False.
+    launch_fluent_skip_password_check = _ConfigDescriptor["Config"](
+        lambda instance: False, "LAUNCH_FLUENT_SKIP_PASSWORD_CHECK"
+    )
+
+    #: The timeout in seconds to wait for Fluent to exit, defaults to the value of ``PYFLUENT_FORCE_EXIT_TIMEOUT`` environment variable.
+    force_exit_timeout = _ConfigDescriptor["Config"](
+        lambda instance: instance._env.get("PYFLUENT_FORCE_EXIT_TIMEOUT")
+    )
+
+    #: Whether to skip code generation of built-in settings, defaults to the value of ``PYFLUENT_CODEGEN_SKIP_BUILTIN_SETTINGS`` environment variable.
+    codegen_skip_builtin_settings = _ConfigDescriptor["Config"](
+        lambda instance: instance._env.get("PYFLUENT_CODEGEN_SKIP_BUILTIN_SETTINGS")
+        == "1"
+    )
+
+    #: Whether to launch Fluent in a container, defaults to the value of ``PYFLUENT_LAUNCH_CONTAINER`` environment variable.
+    launch_fluent_container = _ConfigDescriptor["Config"](
+        lambda instance: instance._env.get("PYFLUENT_LAUNCH_CONTAINER") == "1"
+    )
+
+    #: The tag of the Fluent image to use when launching in a container, defaults to the value of ``FLUENT_IMAGE_TAG`` environment variable or the latest release version of Fluent.
+    fluent_image_tag = _ConfigDescriptor["Config"](
+        lambda instance: instance._env.get(
+            "FLUENT_IMAGE_TAG", f"v{instance.fluent_release_version}"
+        )
+    )
+
+    #: The name of the Fluent image to use when launching in a container, defaults to the value of ``FLUENT_IMAGE_NAME`` environment variable.
+    fluent_image_name = _ConfigDescriptor["Config"](
+        lambda instance: instance._env.get("FLUENT_IMAGE_NAME")
+    )
+
+    #: The name of the Fluent container to use when launching in a container, defaults to the value of ``FLUENT_CONTAINER_NAME`` environment variable.
+    fluent_container_name = _ConfigDescriptor["Config"](
+        lambda instance: instance._env.get("FLUENT_CONTAINER_NAME")
+    )
+
+    #: Whether to use Docker Compose for launching Fluent in a container, defaults to the value of ``PYFLUENT_USE_DOCKER_COMPOSE`` environment variable.
+    use_docker_compose = _ConfigDescriptor["Config"](
+        lambda instance: instance._env.get("PYFLUENT_USE_DOCKER_COMPOSE") == "1"
+    )
+
+    #: Whether to use Podman Compose for launching Fluent in a container, defaults to the value of ``PYFLUENT_USE_PODMAN_COMPOSE`` environment variable.
+    use_podman_compose = _ConfigDescriptor["Config"](
+        lambda instance: instance._env.get("PYFLUENT_USE_PODMAN_COMPOSE") == "1"
+    )
+
+    #: The timeout in seconds to wait for Fluent to launch, defaults to the value of ``PYFLUENT_LAUNCH_FLUENT_TIMEOUT`` environment variable or 60 seconds.
+    launch_fluent_timeout = _ConfigDescriptor["Config"](
+        lambda instance: int(instance._env.get("PYFLUENT_LAUNCH_FLUENT_TIMEOUT", 60))
+    )
+
+    #: Whether to show the Fluent GUI when launching the server, defaults to the value of ``PYFLUENT_SHOW_SERVER_GUI`` environment variable.
+    show_fluent_gui = _ConfigDescriptor["Config"](
+        lambda instance: instance._env.get("PYFLUENT_SHOW_SERVER_GUI") == "1"
+    )
+
+    #: Whether to launch Fluent in debug mode, defaults to the value of ``PYFLUENT_FLUENT_DEBUG`` environment variable.
+    fluent_debug = _ConfigDescriptor["Config"](
+        lambda instance: instance._env.get("PYFLUENT_FLUENT_DEBUG") == "1"
+    )
+
+    #: Whether to skip API upgrade advice, defaults to the value of ``PYFLUENT_SKIP_API_UPGRADE_ADVICE`` environment variable.
+    skip_api_upgrade_advice = _ConfigDescriptor["Config"](
+        lambda instance: instance._env.get("PYFLUENT_SKIP_API_UPGRADE_ADVICE") == "1"
+    )
+
+    #: The maximum number of bytes to log in gRPC logs, defaults to the value of ``PYFLUENT_GRPC_LOG_BYTES_LIMIT`` environment variable or 1000 bytes.
+    grpc_log_bytes_limit = _ConfigDescriptor["Config"](
+        lambda instance: int(instance._env.get("PYFLUENT_GRPC_LOG_BYTES_LIMIT", 1000))
+    )
+
+    #: Whether to disable the fix for returning parameter lists via settings API, defaults to the value of ``PYFLUENT_NO_FIX_PARAMETER_LIST_RETURN`` environment variable.
+    disable_parameter_list_return_fix = _ConfigDescriptor["Config"](
+        lambda instance: instance._env.get("PYFLUENT_NO_FIX_PARAMETER_LIST_RETURN")
+        == "1"
+    )
+
+    #: Whether to use runtime Python classes for settings, defaults to the value of ``PYFLUENT_USE_RUNTIME_PYTHON_CLASSES`` environment variable.
+    use_runtime_python_classes = _ConfigDescriptor["Config"](
+        lambda instance: instance._env.get("PYFLUENT_USE_RUNTIME_PYTHON_CLASSES") == "1"
+    )
+
+    #: Whether to hide sensitive information in logs, defaults to the value of ``PYFLUENT_HIDE_LOG_SECRETS`` environment variable.
+    hide_log_secrets = _ConfigDescriptor["Config"](
+        lambda instance: instance._env.get("PYFLUENT_HIDE_LOG_SECRETS") == "1"
+    )
+
+    #: The Fluent root directory to be used for PyFluent, defaults to the value of ``PYFLUENT_FLUENT_ROOT`` environment variable.
+    fluent_root = _ConfigDescriptor["Config"](
+        lambda instance: instance._env.get("PYFLUENT_FLUENT_ROOT")
+    )
+
+    #: The remoting server address to be used in Fluent, defaults to the value of ``REMOTING_SERVER_ADDRESS`` environment variable.
+    remoting_server_address = _ConfigDescriptor["Config"](
+        lambda instance: instance._env.get("REMOTING_SERVER_ADDRESS")
+    )
+
+    #: The directory where server info will be written from Fluent, defaults to the value of ``SERVER_INFO_DIR`` environment variable.
+    fluent_server_info_dir = _ConfigDescriptor["Config"](
+        lambda instance: instance._env.get("SERVER_INFO_DIR")
+    )
+
+    #: Current unit test name, defaults to the value of ``PYFLUENT_TEST_NAME`` environment variable.
+    test_name = _ConfigDescriptor["Config"](
+        lambda instance: instance._env.get("PYFLUENT_TEST_NAME")
+    )
+
+    #: The default logging level for PyFluent, defaults to the value of ``PYFLUENT_LOGGING`` environment variable.
+    logging_level_default = _ConfigDescriptor["Config"](
+        lambda instance: instance._env.get("PYFLUENT_LOGGING")
+    )
+
+    def __init__(self):
+        """__init__ method of Config class."""
+        # Read the environment variable once when pyfluent is imported
+        # and reuse it throughout process lifetime.
+        self._env = os.environ.copy()
+
+    @property
+    def fluent_release_version(self) -> str:
+        """The latest released version of Fluent."""
+        return "25.2.0"
+
+    @property
+    def fluent_dev_version(self) -> str:
+        """The latest development version of Fluent."""
+        return "26.1.0"
+
+    def print(self):
+        """Print all configuration variables."""
+        config_dict = {}
+        for k, v in inspect.getmembers_static(self):
+            if isinstance(v, (_ConfigDescriptor, property)):
+                config_dict[k] = v.__get__(self, self.__class__)
+        max_key_length = max(len(k) for k in config_dict)
+        print("PyFluent Configuration:")
+        print("-" * (max_key_length + 20))
+        for k, v in config_dict.items():
+            print(f"{k.ljust(max_key_length)} : {v}")
+
+
+#: Global configuration object for PyFluent
+config = Config()

ansys/fluent/core/pyfluent_warnings.py

@@ -38,16 +38,22 @@ class PyFluentUserWarning(UserWarning):
     pass
 
 
+class FluentDevVersionWarning(PyFluentUserWarning):
+    """Warning raised when a released PyFluent version is used with a development version of Fluent."""
+
+    pass
+
+
 def warning_for_fluent_dev_version(version):
     """Provides warning if Fluent develop branch is used."""
-    from ansys.fluent.core import FLUENT_RELEASE_VERSION, FluentVersion
+    from ansys.fluent.core import FluentVersion, config
 
-    if FluentVersion(version) > FluentVersion(FLUENT_RELEASE_VERSION):
+    if FluentVersion(version) > FluentVersion(config.fluent_release_version):
         warnings.warn(
             "⚠️ Warning: You are using PyFluent with an unreleased or development version of Fluent.\n"
             "Compatibility is not guaranteed, and unexpected behavior may occur. Please use a released "
             "version of Fluent that is officially supported by this version of PyFluent.",
-            PyFluentUserWarning,
+            FluentDevVersionWarning,
         )
 
 

ansys/fluent/core/report.py

@@ -44,6 +44,8 @@ ANSYS_ENV_VARS = [
     "PYFLUENT_FLUENT_IP",
     "PYFLUENT_FLUENT_PORT",
     "PYFLUENT_FLUENT_ROOT",
+    "PYFLUENT_FLUENT_LAUNCH_TIMEOUT",
+    "PYFLUENT_FLUENT_AUTOMATIC_TRANSCRIPT",
     "PYFLUENT_GRPC_LOG_BYTES_LIMIT",
     "PYFLUENT_LAUNCH_CONTAINER",
     "PYFLUENT_LOGGING",
@@ -56,8 +58,6 @@ ANSYS_ENV_VARS = [
     "REMOTING_PORTS",
     "REMOTING_SERVER_ADDRESS",
     "SERVER_INFO_DIR",
-    "PYFLUENT_USE_DOCKER_COMPOSE",
-    "PYFLUENT_USE_PODMAN_COMPOSE",
 ]