ansys-fluent-core 0.34.1__py3-none-any.whl → 0.35.dev0__py3-none-any.whl

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,7 +76,7 @@ def launch(
         )
     )
 
-    debug_watchdog = os.getenv("PYFLUENT_WATCHDOG_DEBUG") == "1"
+    debug_watchdog = pyfluent.config.watchdog_debug
     if debug_watchdog:
         logger.debug(
             f"PYFLUENT_WATCHDOG_DEBUG environment variable found, "
@@ -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") == "1":
+            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") == "1":
+        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") == "1":
+        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

@@ -46,9 +46,9 @@ class FluentDevVersionWarning(PyFluentUserWarning):
 
 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 "

ansys/fluent/core/report.py

@@ -58,8 +58,6 @@ ANSYS_ENV_VARS = [
     "REMOTING_PORTS",
     "REMOTING_SERVER_ADDRESS",
     "SERVER_INFO_DIR",
-    "PYFLUENT_USE_DOCKER_COMPOSE",
-    "PYFLUENT_USE_PODMAN_COMPOSE",
 ]
 
 

ansys/fluent/core/search.py

@@ -41,16 +41,16 @@ from ansys.fluent.core.utils.fluent_version import (
 
 def _get_api_tree_data_file_path():
     """Get API tree data file."""
-    from ansys.fluent.core import CODEGEN_OUTDIR
+    from ansys.fluent.core import config
 
-    return (CODEGEN_OUTDIR / "api_tree" / "api_objects.json").resolve()
+    return (config.codegen_outdir / "api_tree" / "api_objects.json").resolve()
 
 
 def get_api_tree_file_name(version: str) -> Path:
     """Get API tree file name."""
-    from ansys.fluent.core import CODEGEN_OUTDIR
+    from ansys.fluent.core import config
 
-    return (CODEGEN_OUTDIR / f"api_tree_{version}.pickle").resolve()
+    return (config.codegen_outdir / f"api_tree_{version}.pickle").resolve()
 
 
 def _remove_suffix(input: str, suffix):
@@ -127,9 +127,9 @@ def _generate_api_data(
         from nltk.corpus import wordnet as wn
 
         _download_nltk_data()
-        from ansys.fluent.core import CODEGEN_OUTDIR
+        from ansys.fluent.core import config
 
-        json_file_folder = Path(os.path.join(CODEGEN_OUTDIR, "api_tree"))
+        json_file_folder = Path(os.path.join(config.codegen_outdir, "api_tree"))
         json_file_folder.mkdir(parents=True, exist_ok=True)
 
         all_api_object_name_synsets = dict()
@@ -164,7 +164,10 @@ def _get_api_tree_data():
 
 
 def _print_search_results(
-    queries: list, api_tree_data: dict | None = None, api_path: str | None = None
+    queries: list,
+    api_tree_data: dict | None = None,
+    api_path: str | None = None,
+    match_whole_word: bool | None = None,
 ):
     """
     Print search results.
@@ -178,6 +181,9 @@ def _print_search_results(
         If None, it is retrieved using _get_api_tree_data().
     api_path : str, optional
         Specific path to restrict the search to. If None, searches the entire object hierarchy.
+    match_whole_word : bool, optional
+        If True, only exact matches are returned. If False, semantic search is performed.
+        The default is None, which means semantic search is performed.
     """
     api_tree_data = api_tree_data or _get_api_tree_data()
     api_sources = [api_tree_data["api_objects"], api_tree_data["api_tui_objects"]]
@@ -207,18 +213,22 @@ def _print_search_results(
             for query in queries:
                 if isinstance(query, tuple):
                     name, score = query
+                    if (
+                        name in first_token
+                        and has_query(name, substrings)
+                        and name in substrings[-1]
+                    ):
+                        if score is not None:
+                            results.add((api_object, round(score, 2)))
                 else:
                     name = query
                     score = None
 
-                if (
-                    name in first_token
-                    and has_query(name, substrings)
-                    and name in substrings[-1]
-                ):
-                    if score is not None:
-                        results.add((api_object, round(score, 2)))
-                    else:
+                    if match_whole_word and (
+                        first_token == name or first_token.endswith(f".{name}")
+                    ):
+                        results.add(api_object)
+                    elif not match_whole_word and name in first_token:
                         results.add(api_object)
 
         return sorted(results)
@@ -235,7 +245,7 @@ def _print_search_results(
         )
 
     results = final_results or all_results
-    if pyfluent.PRINT_SEARCH_RESULTS:
+    if pyfluent.config.print_search_results:
         for result in results:
             print(result)
     elif results:
@@ -324,7 +334,7 @@ def _get_exact_match_for_word_from_names(
     -------
         List of exact match.
     """
-    return list({name for name in names if word == name or word in name})
+    return list({name for name in names if word == name})
 
 
 def _get_capitalize_match_for_word_from_names(
@@ -461,7 +471,10 @@ def _search_whole_word(
             )
     if queries:
         return _print_search_results(
-            queries, api_tree_data=api_tree_data, api_path=api_path
+            queries,
+            api_tree_data=api_tree_data,
+            api_path=api_path,
+            match_whole_word=match_whole_word,
         )
 
 

ansys/fluent/core/services/api_upgrade.py

@@ -22,7 +22,6 @@
 
 """Provides a module for the API upgrade advisor."""
 
-import os
 from typing import TypeVar
 
 from ansys.fluent.core.services.app_utilities import AppUtilities
@@ -47,8 +46,10 @@ class ApiUpgradeAdvisor:
         self._id = None
 
     def _can_advise(self) -> bool:
+        from ansys.fluent.core import config
+
         return (
-            not os.getenv("PYFLUENT_SKIP_API_UPGRADE_ADVICE")
+            not config.skip_api_upgrade_advice
             and FluentVersion(self._version) >= FluentVersion.v231
             and self._mode == "solver"
         )