ansys-fluent-core 0.32.2__py3-none-any.whl → 0.33.0__py3-none-any.whl

ansys/fluent/core/launcher/fluent_container.py

@@ -74,6 +74,7 @@ config_dict =
 import logging
 import os
 from pathlib import Path, PurePosixPath
+from pprint import pformat
 import tempfile
 from typing import Any, List
 
@@ -118,6 +119,20 @@ class LicenseServerNotSpecified(KeyError):
         )
 
 
+def dict_to_str(dict: dict) -> str:
+    """Converts the dict to string while hiding the 'environment' argument from the dictionary,
+    if the environment variable 'PYFLUENT_HIDE_LOG_SECRETS' is '1'.
+    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":
+        modified_dict = dict.copy()
+        modified_dict.pop("environment")
+        return pformat(modified_dict)
+    else:
+        return pformat(dict)
+
+
 @all_deprecators(
     deprecate_arg_mappings=[
         {
@@ -158,9 +173,12 @@ def configure_container_dict(
     args : List[str]
         List of Fluent launch arguments.
     mount_source : str | Path, optional
-        Existing path in the host operating system that will be mounted to ``mount_target``.
+        Path on the host system to mount into the container. This directory will serve as the working directory
+        for the Fluent process inside the container. If not specified, PyFluent's current working directory will
+        be used.
     mount_target : str | Path, optional
-        Path inside the container where ``mount_source`` will be mounted to.
+        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.
     port : int, optional
@@ -213,17 +231,15 @@ def configure_container_dict(
     See also :func:`start_fluent_container`.
     """
 
-    if (
-        container_dict
-        and "environment" in container_dict
-        and os.getenv("PYFLUENT_HIDE_LOG_SECRETS") == "1"
-    ):
-        container_dict_h = container_dict.copy()
-        container_dict_h.pop("environment")
-        logger.debug(f"container_dict before processing: {container_dict_h}")
-        del container_dict_h
-    else:
-        logger.debug(f"container_dict before processing: {container_dict}")
+    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.
 
     if not mount_source:
         if file_transfer_service:
@@ -231,53 +247,69 @@ def configure_container_dict(
         else:
             mount_source = os.getenv(
                 "PYFLUENT_CONTAINER_MOUNT_SOURCE",
-                pyfluent.CONTAINER_MOUNT_SOURCE or os.getcwd(),
+                pyfluent.CONTAINER_MOUNT_SOURCE,
             )
 
-    elif "volumes" in container_dict:
-        logger.warning(
-            "'volumes' keyword specified in 'container_dict', but "
-            "it is going to be overwritten by specified 'mount_source'."
-        )
-        container_dict.pop("volumes")
+    if "volumes" in container_dict:
+        if len(container_dict["volumes"]) != 1:
+            logger.warning(
+                "Multiple volumes being mounted in the Docker container, "
+                "Assuming the first mount is the working directory for Fluent."
+            )
+        volumes_string = container_dict["volumes"][0]
+        if mount_source:
+            logger.warning(
+                "'volumes' keyword specified in 'container_dict', but "
+                "it is going to be overwritten by specified 'mount_source'."
+            )
+        else:
+            mount_source = volumes_string.split(":")[0]
+            logger.debug(f"mount_source: {mount_source}")
+        inferred_mount_target = volumes_string.split(":")[1]
+        logger.debug(f"inferred_mount_target: {inferred_mount_target}")
+
+    if not mount_source:
+        logger.debug("No container 'mount_source' specified, using default value.")
+        mount_source = os.getcwd()
 
-    if not os.path.exists(mount_source):
-        os.makedirs(mount_source)
+    # 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.
 
     if not mount_target:
-        mount_target = os.getenv(
-            "PYFLUENT_CONTAINER_MOUNT_TARGET", pyfluent.CONTAINER_MOUNT_TARGET
-        )
-    elif "volumes" in container_dict:
-        logger.warning(
-            "'volumes' keyword specified in 'container_dict', but "
-            "it is going to be overwritten by specified 'mount_target'."
-        )
-        container_dict.pop("volumes")
+        if "working_dir" in container_dict:
+            mount_target = container_dict["working_dir"]
+        else:
+            mount_target = os.getenv("PYFLUENT_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
+        container_dict.pop("working_dir")
+
+    if not mount_target and "volumes" in container_dict:
+        mount_target = inferred_mount_target
+
+    if not mount_target:
+        logger.debug("No container 'mount_target' specified, using default value.")
+        mount_target = pyfluent.CONTAINER_MOUNT_TARGET
 
     if "volumes" not in container_dict:
         container_dict.update(volumes=[f"{mount_source}:{mount_target}"])
     else:
-        logger.debug(f"container_dict['volumes']: {container_dict['volumes']}")
-        if len(container_dict["volumes"]) != 1:
-            logger.warning(
-                "Multiple volumes being mounted in the Docker container, "
-                "using the first mount as the working directory for Fluent."
-            )
-        volumes_string = container_dict["volumes"][0]
-        mount_target = ""
-        for c in reversed(volumes_string):
-            if c == ":":
-                break
-            else:
-                mount_target += c
-        mount_target = mount_target[::-1]
-        mount_source = volumes_string.replace(":" + mount_target, "")
-        logger.debug(f"mount_source: {mount_source}")
-        logger.debug(f"mount_target: {mount_target}")
+        container_dict["volumes"][0] = f"{mount_source}:{mount_target}"
+
     logger.warning(
-        f"Starting Fluent container mounted to {mount_source}, with this path available as {mount_target} for the Fluent session running inside the container."
+        f"Configuring Fluent container to mount to {mount_source}, "
+        f"with this path available as {mount_target} for the Fluent session running inside the container."
     )
+
+    if "working_dir" not in container_dict:
+        container_dict.update(
+            working_dir=mount_target,
+        )
+
     port_mapping = {port: port} if port else {}
     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
@@ -315,11 +347,7 @@ def configure_container_dict(
             labels={"test_name": test_name},
         )
 
-    if "working_dir" not in container_dict:
-        container_dict.update(
-            working_dir=mount_target,
-        )
-
+    # Find the server info file name from the command line arguments
     if "command" in container_dict:
         for v in container_dict["command"]:
             if v.startswith("-sifile="):
@@ -343,6 +371,20 @@ def configure_container_dict(
         os.close(fd)
         container_server_info_file = PurePosixPath(mount_target) / Path(sifile).name
 
+    logger.debug(
+        f"Using server info file '{container_server_info_file}' for Fluent container."
+    )
+
+    # If the 'command' had already been specified in the 'container_dict',
+    # maintain other 'command' arguments but update the '-sifile' argument,
+    # as the 'mount_target' or 'working_dir' may have changed.
+    if "command" in container_dict:
+        for i, item in enumerate(container_dict["command"]):
+            if item.startswith("-sifile="):
+                container_dict["command"][i] = f"-sifile={container_server_info_file}"
+    else:
+        container_dict["command"] = args + [f"-sifile={container_server_info_file}"]
+
     if not fluent_image:
         if not image_tag:
             image_tag = os.getenv(
@@ -384,16 +426,13 @@ def configure_container_dict(
             container_dict["environment"] = {}
         container_dict["environment"]["FLUENT_LAUNCHED_FROM_PYFLUENT"] = "1"
 
-    fluent_commands = [f"-sifile={container_server_info_file}"] + args
-
-    container_dict_default = {}
-    container_dict_default.update(
-        command=fluent_commands,
+    container_dict_base = {}
+    container_dict_base.update(
         detach=True,
         auto_remove=True,
     )
 
-    for k, v in container_dict_default.items():
+    for k, v in container_dict_base.items():
         if k not in container_dict:
             container_dict[k] = v
 
@@ -404,6 +443,13 @@ def configure_container_dict(
         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"host_server_info_file: '{host_server_info_file}', "
+        f"remove_server_info_file: {remove_server_info_file}"
+    )
+    logger.debug(f"container_dict after processing:\n{dict_to_str(container_dict)}")
+
     return (
         container_dict,
         timeout,
@@ -458,21 +504,6 @@ def start_fluent_container(
         remove_server_info_file,
     ) = container_vars
 
-    if os.getenv("PYFLUENT_HIDE_LOG_SECRETS") != "1":
-        logger.debug(f"container_vars: {container_vars}")
-    else:
-        config_dict_h = config_dict.copy()
-        config_dict_h.pop("environment")
-        container_vars_tmp = (
-            config_dict_h,
-            timeout,
-            port,
-            host_server_info_file,
-            remove_server_info_file,
-        )
-        logger.debug(f"container_vars: {container_vars_tmp}")
-        del container_vars_tmp
-
     try:
         if is_compose():
             config_dict["fluent_port"] = port

ansys/fluent/core/launcher/launch_options.py

@@ -24,11 +24,13 @@
 
 from enum import Enum
 import os
+import warnings
 
 from ansys.fluent.core.exceptions import DisallowedValuesError
 from ansys.fluent.core.fluent_connection import FluentConnection
 import ansys.fluent.core.launcher.error_handler as exceptions
 from ansys.fluent.core.launcher.launcher_utils import is_windows
+from ansys.fluent.core.pyfluent_warnings import PyFluentUserWarning
 from ansys.fluent.core.session_meshing import Meshing
 from ansys.fluent.core.session_pure_meshing import PureMeshing
 from ansys.fluent.core.session_solver import Solver
@@ -280,11 +282,22 @@ def _get_fluent_launch_mode(start_container, container_dict, scheduler_options):
     return fluent_launch_mode
 
 
+def _should_add_driver_null(ui_mode: UIMode | None = None) -> bool:
+    return ui_mode not in {UIMode.GUI, UIMode.HIDDEN_GUI}
+
+
 def _get_graphics_driver(
     graphics_driver: (
         FluentWindowsGraphicsDriver | FluentLinuxGraphicsDriver | str | None
     ) = None,
+    ui_mode: UIMode | None = None,
 ):
+    ui_mode_ = UIMode(ui_mode)
+    if graphics_driver is not None and ui_mode_ not in {UIMode.GUI, UIMode.HIDDEN_GUI}:
+        warnings.warn(
+            "User-specified value for graphics driver is ignored while launching Fluent without GUI or without graphics.",
+            PyFluentUserWarning,
+        )
     if isinstance(
         graphics_driver, (FluentWindowsGraphicsDriver, FluentLinuxGraphicsDriver)
     ):
@@ -294,6 +307,12 @@ def _get_graphics_driver(
         if is_windows()
         else FluentLinuxGraphicsDriver(graphics_driver)
     )
+    if _should_add_driver_null(ui_mode_):
+        return (
+            FluentWindowsGraphicsDriver.NULL
+            if is_windows()
+            else FluentLinuxGraphicsDriver.NULL
+        )
     return graphics_driver
 
 
@@ -361,7 +380,9 @@ def _validate_gpu(gpu: bool | list, dimension: int):
 
 def _get_argvals_and_session(argvals):
     _validate_gpu(argvals["gpu"], argvals["dimension"])
-    argvals["graphics_driver"] = _get_graphics_driver(argvals["graphics_driver"])
+    argvals["graphics_driver"] = _get_graphics_driver(
+        argvals["graphics_driver"], argvals["ui_mode"]
+    )
     argvals["mode"] = FluentMode(argvals["mode"])
     del argvals["self"]
     new_session = argvals["mode"].get_fluent_value()

ansys/fluent/core/launcher/launcher.py

@@ -263,10 +263,11 @@ def launch_fluent(
         made by the user in the current Fluent solver session have been applied in the background Fluent
         solver session. This is all orchestrated by PyFluent and requires no special usage.
         This parameter is used only when ``case_file_name`` is provided. The default is ``False``.
-    mode : str, optional
-        Launch mode of Fluent to point to a specific session type.
-        The default value is ``None``. Options are ``"meshing"``,
-        ``"pure-meshing"`` and ``"solver"``.
+    mode : FluentMode or str or None, optional
+        Launch mode of Fluent to point to a specific session type. Can be a
+        ``FluentMode`` enum member or a string. The default value is ``None``.
+        Valid string options include ``"meshing"``, ``"pure-meshing"``, and
+        ``"solver"``.
     py : bool, optional
         If True, Fluent will run in Python mode. Default is None.
     gpu : bool or list, optional

ansys/fluent/core/pyfluent_warnings.py

@@ -38,6 +38,19 @@ class PyFluentUserWarning(UserWarning):
     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
+
+    if FluentVersion(version) > FluentVersion(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,
+        )
+
+
 class WarningControl:
     """Class to control warnings in PyFluent."""