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

ansys/fluent/core/launcher/container_launcher.py

@@ -56,7 +56,7 @@ from ansys.fluent.core.launcher.launch_options import (
     UIMode,
     _get_argvals_and_session,
 )
-from ansys.fluent.core.launcher.launcher_utils import is_compose
+from ansys.fluent.core.launcher.launcher_utils import ComposeConfig
 from ansys.fluent.core.launcher.process_launch_string import (
     _build_fluent_launch_args_string,
 )
@@ -108,6 +108,8 @@ class DockerLauncher:
         gpu: bool | None = None,
         start_watchdog: bool | None = None,
         file_transfer_service: Any | None = None,
+        use_docker_compose: bool | None = None,
+        use_podman_compose: bool | None = None,
     ):
         """
         Launch a Fluent session in container mode.
@@ -161,6 +163,10 @@ class DockerLauncher:
             GUI-less Fluent sessions started by PyFluent are properly closed when the current Python process ends.
         file_transfer_service : Any, optional
             Service for uploading/downloading files to/from the server.
+        use_docker_compose: bool
+            Whether to use Docker Compose to launch Fluent.
+        use_podman_compose: bool
+            Whether to use Podman Compose to launch Fluent.
 
         Returns
         -------
@@ -198,12 +204,15 @@ class DockerLauncher:
         self._args = _build_fluent_launch_args_string(**self.argvals).split()
         if FluentMode.is_meshing(self.argvals["mode"]):
             self._args.append(" -meshing")
+        self._compose_config = ComposeConfig(use_docker_compose, use_podman_compose)
 
     def __call__(self):
 
         if self.argvals["dry_run"]:
             config_dict, *_ = configure_container_dict(
-                self._args, **self.argvals["container_dict"]
+                self._args,
+                compose_config=self._compose_config,
+                **self.argvals["container_dict"],
             )
             dict_str = dict_to_str(config_dict)
             print("\nDocker container run configuration:\n")
@@ -214,11 +223,12 @@ class DockerLauncher:
         logger.debug(f"Fluent container launcher args: {self._args}")
         logger.debug(f"Fluent container launcher argvals:\n{dict_to_str(self.argvals)}")
 
-        if is_compose():
+        if self._compose_config.is_compose:
             port, config_dict, container = start_fluent_container(
                 self._args,
                 self.argvals["container_dict"],
                 self.argvals["start_timeout"],
+                compose_config=self._compose_config,
             )
 
             _, _, password = _get_server_info_from_container(config_dict=config_dict)
@@ -227,6 +237,7 @@ class DockerLauncher:
                 self._args,
                 self.argvals["container_dict"],
                 self.argvals["start_timeout"],
+                compose_config=self._compose_config,
             )
 
         fluent_connection = FluentConnection(
@@ -237,18 +248,22 @@ class DockerLauncher:
             slurm_job_id=self.argvals and self.argvals.get("slurm_job_id"),
             inside_container=True,
             container=container,
+            compose_config=self._compose_config,
         )
 
+        self.argvals["compose_config"] = self._compose_config
+
         session = self.new_session(
             fluent_connection=fluent_connection,
             scheme_eval=fluent_connection._connection_interface.scheme_eval,
             file_transfer_service=self.file_transfer_service,
             start_transcript=self.argvals["start_transcript"],
+            launcher_args=self.argvals,
         )
 
         session._container = container
 
-        if not is_compose():
+        if not self._compose_config.is_compose:
             if (
                 self.argvals["start_watchdog"] is None
                 and self.argvals["cleanup_on_exit"]

ansys/fluent/core/launcher/fluent_container.py

@@ -62,7 +62,7 @@ config_dict =
  'detach': True,
  'environment': {'ANSYSLMD_LICENSE_FILE': '2048@licenseserver.com',
                  'REMOTING_PORTS': '54000/portspan=2'},
- 'fluent_image': 'ghcr.io/ansys/pyfluent:v23.2.0',
+ 'fluent_image': '<image registry>:v23.2.0',
  'labels': {'test_name': 'none'},
  'ports': {'54000': 54000},
  'volumes': ['/home/user/.local/share/ansys_fluent_core/examples:/mnt/pyfluent'],
@@ -85,7 +85,7 @@ from ansys.fluent.core.docker.utils import get_ghcr_fluent_image_name
 from ansys.fluent.core.launcher.error_handler import (
     LaunchFluentError,
 )
-from ansys.fluent.core.launcher.launcher_utils import is_compose
+from ansys.fluent.core.launcher.launcher_utils import ComposeConfig
 from ansys.fluent.core.pyfluent_warnings import PyFluentDeprecationWarning
 from ansys.fluent.core.session import _parse_server_info_file
 from ansys.fluent.core.utils.deprecate import all_deprecators
@@ -131,7 +131,7 @@ def dict_to_str(dict: dict) -> str:
     This is useful for logging purposes, to avoid printing sensitive information such as license server details.
     """
 
-    if "environment" in dict and os.getenv("PYFLUENT_HIDE_LOG_SECRETS") == "1":
+    if "environment" in dict and pyfluent.config.hide_log_secrets:
         modified_dict = dict.copy()
         modified_dict.pop("environment")
         return pformat(modified_dict)
@@ -170,6 +170,7 @@ def configure_container_dict(
     image_name: str | None = None,
     image_tag: str | None = None,
     file_transfer_service: Any | None = None,
+    compose_config: ComposeConfig | None = None,
     **container_dict,
 ) -> (dict, int, int, Path, bool):
     """Parses the parameters listed below, and sets up the container configuration file.
@@ -204,6 +205,8 @@ def configure_container_dict(
         Ignored if ``fluent_image`` has been specified.
     file_transfer_service : optional
         Supports file upload and download.
+    compose_config : ComposeConfig, optional
+        Configuration for Docker Compose, if using Docker Compose to launch the container.
     **container_dict
         Additional keyword arguments can be specified, they will be treated as Docker container run options
         to be passed directly to the Docker run execution. See examples below and `Docker run`_ documentation.
@@ -237,6 +240,8 @@ def configure_container_dict(
     See also :func:`start_fluent_container`.
     """
 
+    compose_config = compose_config if compose_config else ComposeConfig()
+
     if timeout is not None:
         warnings.warn(
             "configure_container_dict(timeout) is deprecated, use launch_fluent(start_timeout) instead.",
@@ -248,19 +253,15 @@ def configure_container_dict(
     # Starting with 'mount_source' because it is not tied to the 'working_dir'.
     # The intended 'mount_source' logic is as follows, if it is not directly specified:
     # 1. If 'file_transfer_service' is provided, use its 'mount_source'.
-    # 2. Try to use the environment variable 'PYFLUENT_CONTAINER_MOUNT_SOURCE', if it is set.
-    # 3. Use the value from 'pyfluent.CONTAINER_MOUNT_SOURCE', if it is set.
-    # 4. If 'volumes' is specified in 'container_dict', try to infer the value from it.
-    # 5. Finally, use the current working directory, which is always available.
+    # 2. Use the value from 'pyfluent.config.container_mount_source', if it is set.
+    # 3. If 'volumes' is specified in 'container_dict', try to infer the value from it.
+    # 4. Finally, use the current working directory, which is always available.
 
     if not mount_source:
         if file_transfer_service:
             mount_source = file_transfer_service.mount_source
         else:
-            mount_source = os.getenv(
-                "PYFLUENT_CONTAINER_MOUNT_SOURCE",
-                pyfluent.CONTAINER_MOUNT_SOURCE,
-            )
+            mount_source = pyfluent.config.container_mount_source
 
     if "volumes" in container_dict:
         if len(container_dict["volumes"]) != 1:
@@ -286,15 +287,14 @@ def configure_container_dict(
 
     # The intended 'mount_target' logic is as follows, if it is not directly specified:
     # 1. If 'working_dir' is specified in 'container_dict', use it as 'mount_target'.
-    # 2. Use the environment variable 'PYFLUENT_CONTAINER_MOUNT_TARGET', if it is set.
-    # 3. Try to infer the value from the 'volumes' keyword in 'container_dict', if available.
-    # 4. Finally, use the value from 'pyfluent.CONTAINER_MOUNT_TARGET', which is always set.
+    # 2. Try to infer the value from the 'volumes' keyword in 'container_dict', if available.
+    # 3. Finally, use the value from 'pyfluent.config.container_mount_target', which is always set.
 
     if not mount_target:
         if "working_dir" in container_dict:
             mount_target = container_dict["working_dir"]
         else:
-            mount_target = os.getenv("PYFLUENT_CONTAINER_MOUNT_TARGET")
+            mount_target = pyfluent.config.container_mount_target
 
     if "working_dir" in container_dict and mount_target:
         # working_dir will be set later to the final value of mount_target
@@ -305,7 +305,7 @@ def configure_container_dict(
 
     if not mount_target:
         logger.debug("No container 'mount_target' specified, using default value.")
-        mount_target = pyfluent.CONTAINER_MOUNT_TARGET
+        mount_target = pyfluent.config.container_mount_target
 
     if "volumes" not in container_dict:
         container_dict.update(volumes=[f"{mount_source}:{mount_target}"])
@@ -326,8 +326,8 @@ def configure_container_dict(
     if not port_mapping and "ports" in container_dict:
         # take the specified 'port', OR the first port value from the specified 'ports', for Fluent to use
         port_mapping = container_dict["ports"]
-    if not port_mapping and pyfluent.LAUNCH_FLUENT_PORT:
-        port = pyfluent.LAUNCH_FLUENT_PORT
+    if not port_mapping and pyfluent.config.launch_fluent_port:
+        port = pyfluent.config.launch_fluent_port
         port_mapping = {port: port}
     if not port_mapping:
         port = get_free_port()
@@ -350,11 +350,12 @@ def configure_container_dict(
             environment={
                 "ANSYSLMD_LICENSE_FILE": license_server,
                 "REMOTING_PORTS": f"{container_grpc_port}/portspan=2",
+                "FLUENT_ALLOW_REMOTE_GRPC_CONNECTION": "1",
             }
         )
 
     if "labels" not in container_dict:
-        test_name = os.getenv("PYFLUENT_TEST_NAME", "none")
+        test_name = pyfluent.config.test_name
         container_dict.update(
             labels={"test_name": test_name},
         )
@@ -399,15 +400,14 @@ def configure_container_dict(
 
     if not fluent_image:
         if not image_tag:
-            image_tag = os.getenv(
-                "FLUENT_IMAGE_TAG", f"v{pyfluent.FLUENT_RELEASE_VERSION}"
-            )
+            image_tag = pyfluent.config.fluent_image_tag
         if not image_name and image_tag:
-            image_name = os.getenv(
-                "FLUENT_IMAGE_NAME", get_ghcr_fluent_image_name(image_tag)
+            image_name = (
+                pyfluent.config.fluent_image_name
+                or get_ghcr_fluent_image_name(image_tag)
             )
         if not image_tag or not image_name:
-            fluent_image = os.getenv("FLUENT_CONTAINER_IMAGE", None)
+            fluent_image = pyfluent.config.fluent_container_name
         elif image_tag and image_name:
             if image_tag.startswith("sha"):
                 fluent_image = f"{image_name}@{image_tag}"
@@ -418,24 +418,19 @@ def configure_container_dict(
 
     container_dict["fluent_image"] = fluent_image
 
-    if not pyfluent.FLUENT_AUTOMATIC_TRANSCRIPT:
+    if not pyfluent.config.fluent_automatic_transcript:
         if "environment" not in container_dict:
             container_dict["environment"] = {}
         container_dict["environment"]["FLUENT_NO_AUTOMATIC_TRANSCRIPT"] = "1"
 
-    if os.getenv("REMOTING_NEW_DM_API") == "1":
-        if "environment" not in container_dict:
-            container_dict["environment"] = {}
-        container_dict["environment"]["REMOTING_NEW_DM_API"] = "1"
-
-    if pyfluent.LAUNCH_FLUENT_IP or os.getenv("REMOTING_SERVER_ADDRESS"):
+    if pyfluent.config.launch_fluent_ip or pyfluent.config.remoting_server_address:
         if "environment" not in container_dict:
             container_dict["environment"] = {}
         container_dict["environment"]["REMOTING_SERVER_ADDRESS"] = (
-            pyfluent.LAUNCH_FLUENT_IP or os.getenv("REMOTING_SERVER_ADDRESS")
+            pyfluent.config.launch_fluent_ip or pyfluent.config.remoting_server_address
         )
 
-    if pyfluent.LAUNCH_FLUENT_SKIP_PASSWORD_CHECK:
+    if pyfluent.config.launch_fluent_skip_password_check:
         if "environment" not in container_dict:
             container_dict["environment"] = {}
         container_dict["environment"]["FLUENT_LAUNCHED_FROM_PYFLUENT"] = "1"
@@ -452,7 +447,7 @@ def configure_container_dict(
 
     host_server_info_file = Path(mount_source) / container_server_info_file.name
 
-    if is_compose():
+    if compose_config.is_compose:
         container_dict["host_server_info_file"] = host_server_info_file
         container_dict["mount_source"] = mount_source
         container_dict["mount_target"] = mount_target
@@ -474,7 +469,10 @@ def configure_container_dict(
 
 
 def start_fluent_container(
-    args: List[str], container_dict: dict | None = None, start_timeout: int = 60
+    args: List[str],
+    container_dict: dict | None = None,
+    start_timeout: int = 60,
+    compose_config: ComposeConfig | None = None,
 ) -> tuple[int, str, Any]:
     """Start a Fluent container.
 
@@ -487,6 +485,8 @@ def start_fluent_container(
     start_timeout : int, optional
         Timeout in seconds for the container to start. If not specified, it defaults to 60
         seconds.
+    compose_config : ComposeConfig, optional
+        Configuration for Docker Compose, if using Docker Compose to launch the container.
 
     Returns
     -------
@@ -508,10 +508,16 @@ def start_fluent_container(
     :func:`~ansys.fluent.core.launcher.launcher.launch_fluent()`.
     """
 
+    compose_config = compose_config if compose_config else ComposeConfig()
+
     if container_dict is None:
         container_dict = {}
 
-    container_vars = configure_container_dict(args, **container_dict)
+    container_vars = configure_container_dict(
+        args,
+        compose_config=compose_config,
+        **container_dict,
+    )
 
     (
         config_dict,
@@ -530,10 +536,13 @@ def start_fluent_container(
         del timeout
 
     try:
-        if is_compose():
+        if compose_config.is_compose:
             config_dict["fluent_port"] = port
 
-            compose_container = ComposeBasedLauncher(container_dict=config_dict)
+            compose_container = ComposeBasedLauncher(
+                compose_config=compose_config,
+                container_dict=config_dict,
+            )
 
             if not compose_container.check_image_exists():
                 logger.debug(

ansys/fluent/core/launcher/launch_options.py

@@ -23,7 +23,6 @@
 """Provides a module for enums used in the PyFluent."""
 
 from enum import Enum
-import os
 import warnings
 
 from ansys.fluent.core.exceptions import DisallowedValuesError
@@ -267,11 +266,12 @@ def _get_fluent_launch_mode(start_container, container_dict, scheduler_options):
     fluent_launch_mode: LaunchMode
         Fluent launch mode.
     """
+    from ansys.fluent.core import config
+
     if pypim.is_configured():
         fluent_launch_mode = LaunchMode.PIM
     elif start_container is True or (
-        start_container is None
-        and (container_dict or os.getenv("PYFLUENT_LAUNCH_CONTAINER") == "1")
+        start_container is None and (container_dict or config.launch_fluent_container)
     ):
         fluent_launch_mode = LaunchMode.CONTAINER
     # Currently, only Slurm scheduler is supported and within SlurmLauncher we check the value of the scheduler
@@ -344,6 +344,7 @@ def _get_standalone_launch_fluent_version(argvals) -> FluentVersion | None:
     FluentVersion, optional
         Fluent version or ``None``
     """
+    from ansys.fluent.core import config
 
     # Look for Fluent version in the following order:
     # 1. product_version parameter passed with launch_fluent
@@ -357,7 +358,7 @@ def _get_standalone_launch_fluent_version(argvals) -> FluentVersion | None:
 
     # (DEV) if "PYFLUENT_FLUENT_ROOT" environment variable is defined, we cannot
     # determine the Fluent version, so returning None.
-    if os.getenv("PYFLUENT_FLUENT_ROOT"):
+    if config.fluent_root:
         return None
 
     # 2. the latest ANSYS version from AWP_ROOT environment variables

ansys/fluent/core/launcher/launcher.py

@@ -103,7 +103,7 @@ def _show_gui_to_ui_mode(old_arg_val, **kwds):
             return UIMode.NO_GUI
         elif container_dict:
             return UIMode.NO_GUI
-        elif os.getenv("PYFLUENT_LAUNCH_CONTAINER") == "1":
+        elif pyfluent.config.launch_fluent_container:
             return UIMode.NO_GUI
         else:
             return UIMode.GUI
@@ -174,6 +174,8 @@ def launch_fluent(
     start_watchdog: bool | None = None,
     scheduler_options: dict | None = None,
     file_transfer_service: Any | None = None,
+    use_docker_compose: bool | None = None,
+    use_podman_compose: bool | None = None,
 ) -> Meshing | PureMeshing | Solver | SolverIcing | SlurmFuture | dict:
     """Launch Fluent locally in server mode or connect to a running Fluent server
     instance.
@@ -299,6 +301,10 @@ def launch_fluent(
         specified in a similar manner to Fluent's scheduler options.
     file_transfer_service : optional
         File transfer service. Uploads/downloads files to/from the server.
+    use_docker_compose: bool
+        Whether to use Docker Compose to launch Fluent.
+    use_podman_compose: bool
+        Whether to use Podman Compose to launch Fluent.
 
     Returns
     -------
@@ -312,6 +318,8 @@ def launch_fluent(
     ------
     UnexpectedKeywordArgument
         If an unexpected keyword argument is provided.
+    ValueError
+        If both ``use_docker_compose`` and ``use_podman_compose`` are set to ``True``.
 
     Notes
     -----
@@ -322,8 +330,13 @@ def launch_fluent(
     if env is None:
         env = {}
 
+    if use_docker_compose and use_podman_compose:
+        raise ValueError(
+            "Cannot use both 'use_docker_compose' and 'use_podman_compose' at the same time."
+        )
+
     if start_timeout is None:
-        start_timeout = int(os.getenv("PYFLUENT_FLUENT_LAUNCH_TIMEOUT", "60"))
+        start_timeout = pyfluent.config.launch_fluent_timeout
 
     def _mode_to_launcher_type(fluent_launch_mode: LaunchMode):
         launcher_mode_type = {
@@ -349,7 +362,7 @@ def launch_fluent(
     )
     common_args = launch_fluent_args.intersection(launcher_type_args)
     launcher_argvals = {arg: val for arg, val in argvals.items() if arg in common_args}
-    if pyfluent.START_WATCHDOG is False:
+    if pyfluent.config.start_watchdog is False:
         launcher_argvals["start_watchdog"] = False
     launcher = launcher_type(**launcher_argvals)
     return launcher()

ansys/fluent/core/launcher/launcher_utils.py

@@ -30,19 +30,61 @@ import socket
 import subprocess
 import time
 from typing import Any, Dict
+import warnings
 
 from ansys.fluent.core.exceptions import InvalidArgument
+from ansys.fluent.core.pyfluent_warnings import PyFluentDeprecationWarning
 from ansys.fluent.core.utils.networking import find_remoting_ip
 
 logger = logging.getLogger("pyfluent.launcher")
 
 
-def is_compose() -> bool:
-    """Check if the Fluent launch is through compose."""
-    return (
-        os.getenv("PYFLUENT_USE_DOCKER_COMPOSE") == "1"
-        or os.getenv("PYFLUENT_USE_PODMAN_COMPOSE") == "1"
-    )
+class ComposeConfig:
+    """Configuration for Docker or Podman Compose usage in PyFluent."""
+
+    def __init__(
+        self,
+        use_docker_compose: bool | None = None,
+        use_podman_compose: bool | None = None,
+    ):
+        from ansys.fluent.core import config
+
+        self._env_docker = config.use_docker_compose
+        self._env_podman = config.use_podman_compose
+
+        self._use_docker = use_docker_compose
+        self._use_podman = use_podman_compose
+
+        if use_docker_compose is None and self._env_docker:
+            self._warn_env_deprecated()
+        if use_podman_compose is None and self._env_podman:
+            self._warn_env_deprecated()
+
+    def _warn_env_deprecated(self):
+        warnings.warn(
+            (
+                "The environment variables 'PYFLUENT_USE_DOCKER_COMPOSE' and "
+                "'PYFLUENT_USE_PODMAN_COMPOSE' are deprecated. "
+                "Use the 'use_docker_compose' and 'use_podman_compose' parameters instead."
+            ),
+            category=PyFluentDeprecationWarning,
+            stacklevel=3,
+        )
+
+    @property
+    def use_docker_compose(self) -> bool:
+        """Check if Docker Compose is configured to be used."""
+        return self._use_docker if self._use_docker is not None else self._env_docker
+
+    @property
+    def use_podman_compose(self) -> bool:
+        """Check if Podman Compose is configured to be used."""
+        return self._use_podman if self._use_podman is not None else self._env_podman
+
+    @property
+    def is_compose(self) -> bool:
+        """Check if either Docker Compose or Podman Compose is configured to be used."""
+        return self.use_docker_compose or self.use_podman_compose
 
 
 def is_windows():
@@ -60,7 +102,8 @@ def _get_subprocess_kwargs_for_fluent(env: Dict[str, Any], argvals) -> Dict[str,
         kwargs.update(stdout=subprocess.PIPE)
     else:
         kwargs.update(
-            stdout=pyfluent.LAUNCH_FLUENT_STDOUT, stderr=pyfluent.LAUNCH_FLUENT_STDERR
+            stdout=pyfluent.config.launch_fluent_stdout,
+            stderr=pyfluent.config.launch_fluent_stderr,
         )
     if is_windows():
         kwargs.update(shell=True, creationflags=subprocess.CREATE_NEW_PROCESS_GROUP)
@@ -70,26 +113,31 @@ def _get_subprocess_kwargs_for_fluent(env: Dict[str, Any], argvals) -> Dict[str,
     fluent_env.update({k: str(v) for k, v in env.items()})
     fluent_env["REMOTING_THROW_LAST_TUI_ERROR"] = "1"
     fluent_env["REMOTING_THROW_LAST_SETTINGS_ERROR"] = "1"
-    if pyfluent.CLEAR_FLUENT_PARA_ENVS:
+    if pyfluent.config.clear_fluent_para_envs:
         fluent_env.pop("PARA_NPROCS", None)
         fluent_env.pop("PARA_MESH_NPROCS", None)
 
-    if pyfluent.LAUNCH_FLUENT_IP:
-        fluent_env["REMOTING_SERVER_ADDRESS"] = pyfluent.LAUNCH_FLUENT_IP
+    if pyfluent.config.launch_fluent_ip:
+        fluent_env["REMOTING_SERVER_ADDRESS"] = pyfluent.config.launch_fluent_ip
 
-    if pyfluent.LAUNCH_FLUENT_PORT:
-        fluent_env["REMOTING_PORTS"] = f"{pyfluent.LAUNCH_FLUENT_PORT}/portspan=2"
+    if pyfluent.config.launch_fluent_port:
+        fluent_env["REMOTING_PORTS"] = (
+            f"{pyfluent.config.launch_fluent_port}/portspan=2"
+        )
 
-    if pyfluent.LAUNCH_FLUENT_SKIP_PASSWORD_CHECK:
+    if pyfluent.config.launch_fluent_skip_password_check:
         fluent_env["FLUENT_LAUNCHED_FROM_PYFLUENT"] = "1"
 
     if not is_slurm:
-        if pyfluent.INFER_REMOTING_IP and "REMOTING_SERVER_ADDRESS" not in fluent_env:
+        if (
+            pyfluent.config.infer_remoting_ip
+            and "REMOTING_SERVER_ADDRESS" not in fluent_env
+        ):
             remoting_ip = find_remoting_ip()
             if remoting_ip:
                 fluent_env["REMOTING_SERVER_ADDRESS"] = remoting_ip
 
-    if not pyfluent.FLUENT_AUTOMATIC_TRANSCRIPT:
+    if not pyfluent.config.fluent_automatic_transcript:
         fluent_env["FLUENT_NO_AUTOMATIC_TRANSCRIPT"] = "1"
 
     kwargs.update(env=fluent_env)

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))