ansys-fluent-core 0.34.dev0__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,15 +223,21 @@ 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._args,
+                self.argvals["container_dict"],
+                self.argvals["start_timeout"],
+                compose_config=self._compose_config,
             )
 
             _, _, password = _get_server_info_from_container(config_dict=config_dict)
         else:
             port, password, container = start_fluent_container(
-                self._args, self.argvals["container_dict"]
+                self._args,
+                self.argvals["container_dict"],
+                self.argvals["start_timeout"],
+                compose_config=self._compose_config,
             )
 
         fluent_connection = FluentConnection(
@@ -233,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/error_handler.py

@@ -70,7 +70,7 @@ class LaunchFluentError(Exception):
 
     def __init__(self, launch_string):
         """__init__ method of LaunchFluentError class."""
-        details = "\n" + "Fluent Launch string: " + launch_string
+        details = "\n" + "Fluent Launch command: " + launch_string
         super().__init__(details)
 
 

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'],
@@ -77,10 +77,16 @@ from pathlib import Path, PurePosixPath
 from pprint import pformat
 import tempfile
 from typing import Any, List
+import warnings
 
 import ansys.fluent.core as pyfluent
 from ansys.fluent.core.docker.docker_compose import ComposeBasedLauncher
-from ansys.fluent.core.launcher.launcher_utils import is_compose
+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 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
 from ansys.fluent.core.utils.execution import timeout_loop
@@ -125,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)
@@ -155,7 +161,7 @@ def configure_container_dict(
     args: List[str],
     mount_source: str | Path | None = None,
     mount_target: str | Path | None = None,
-    timeout: int = 60,
+    timeout: int | None = None,
     port: int | None = None,
     license_server: str | None = None,
     container_server_info_file: str | Path | None = None,
@@ -164,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.
@@ -180,7 +187,7 @@ def configure_container_dict(
         Path inside the container where ``mount_source`` will be mounted. This will be the working directory path
         visible to the Fluent process running inside the container.
     timeout : int, optional
-        Time limit  for the Fluent container to start, in seconds. By default, 30 seconds.
+        Time limit for the Fluent container to start, in seconds.
     port : int, optional
         Port for Fluent container to use.
     license_server : str, optional
@@ -198,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.
@@ -231,24 +240,28 @@ 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.",
+            PyFluentDeprecationWarning,
+        )
+
     logger.debug(f"container_dict before processing:\n{dict_to_str(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:
@@ -274,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
@@ -293,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}"])
@@ -314,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()
@@ -338,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},
         )
@@ -387,13 +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 = (
+                pyfluent.config.fluent_image_name
+                or get_ghcr_fluent_image_name(image_tag)
             )
-        if not image_name:
-            image_name = os.getenv("FLUENT_IMAGE_NAME", "ghcr.io/ansys/pyfluent")
         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}"
@@ -404,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"
@@ -438,13 +447,13 @@ 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
 
     logger.debug(
-        f"Fluent container timeout: {timeout}, container_grpc_port: {container_grpc_port}, "
+        f"Fluent container container_grpc_port: {container_grpc_port}, "
         f"host_server_info_file: '{host_server_info_file}', "
         f"remove_server_info_file: {remove_server_info_file}"
     )
@@ -460,7 +469,10 @@ def configure_container_dict(
 
 
 def start_fluent_container(
-    args: List[str], container_dict: dict | None = None
+    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.
 
@@ -470,6 +482,11 @@ def start_fluent_container(
         List of Fluent launch arguments.
     container_dict : dict, optional
         Dictionary with Docker container configuration.
+    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
     -------
@@ -491,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,
@@ -503,12 +526,23 @@ def start_fluent_container(
         host_server_info_file,
         remove_server_info_file,
     ) = container_vars
+    launch_string = " ".join(config_dict["command"])
+
+    if timeout:
+        logger.warning(
+            "launch_fluent(start_timeout) overridden by configure_container_dict(timeout) value."
+        )
+        start_timeout = timeout
+        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(
@@ -536,18 +570,36 @@ def start_fluent_container(
                 config_dict.pop("fluent_image"), **config_dict
             )
 
+            logger.debug(
+                f"Waiting for Fluent container for up to {start_timeout} seconds..."
+            )
+
             success = timeout_loop(
-                lambda: host_server_info_file.stat().st_mtime > last_mtime, timeout
+                lambda: host_server_info_file.stat().st_mtime > last_mtime,
+                start_timeout,
             )
 
             if not success:
-                raise TimeoutError(
-                    "Fluent container launch has timed out, stop container manually."
-                )
+                try:
+                    container.stop()
+                except Exception as stop_ex:
+                    logger.error(f"Failed to stop container: {stop_ex}")
+                    raise TimeoutError(
+                        f"Fluent container launch has timed out after {start_timeout} seconds. "
+                        f"Additionally, stopping the container failed: {stop_ex}"
+                    ) from stop_ex
+                else:
+                    raise TimeoutError(
+                        f"Fluent container launch has timed out after {start_timeout} seconds."
+                        " The container was stopped."
+                    )
             else:
                 _, _, password = _parse_server_info_file(str(host_server_info_file))
 
                 return port, password, container
+    except Exception as ex:
+        logger.error(f"Exception caught - {type(ex).__name__}: {ex}")
+        raise LaunchFluentError(launch_string) from ex
     finally:
         if remove_server_info_file and host_server_info_file.exists():
             host_server_info_file.unlink()

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,6 +330,14 @@ 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 = pyfluent.config.launch_fluent_timeout
+
     def _mode_to_launcher_type(fluent_launch_mode: LaunchMode):
         launcher_mode_type = {
             LaunchMode.CONTAINER: DockerLauncher,
@@ -346,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)