ansys-fluent-core 0.20.dev7__py3-none-any.whl → 0.20.dev8__py3-none-any.whl

ansys/fluent/core/__init__.py

@@ -20,15 +20,21 @@ from ansys.fluent.core.launcher.launcher import (  # noqa: F401
     connect_to_fluent,
     launch_fluent,
 )
-from ansys.fluent.core.launcher.launcher_utils import FluentMode  # noqa: F401
+from ansys.fluent.core.launcher.pyfluent_enums import (  # noqa: F401
+    FluentLinuxGraphicsDriver,
+    FluentMode,
+    FluentUI,
+    FluentWindowsGraphicsDriver,
+)
 from ansys.fluent.core.services.batch_ops import BatchOps  # noqa: F401
 from ansys.fluent.core.session import BaseSession as Fluent  # noqa: F401
 from ansys.fluent.core.utils import fldoc
 from ansys.fluent.core.utils.fluent_version import FluentVersion  # noqa: F401
 from ansys.fluent.core.utils.search import search  # noqa: F401
 from ansys.fluent.core.utils.setup_for_fluent import setup_for_fluent  # noqa: F401
+from ansys.fluent.core.warnings import PyFluentDeprecationWarning  # noqa: F401
 
-_VERSION_INFO = "Build date: March 05, 2024 16:03 UTC ShaID: 752834c"
+_VERSION_INFO = "Build date: March 11, 2024 13:48 UTC ShaID: 5bf57a7"
 """Global variable indicating the version of the PyFluent package - Empty by default"""
 
 _THIS_DIRNAME = os.path.dirname(__file__)

ansys/fluent/core/_version.py

@@ -6,7 +6,7 @@ version_info = 0, 1, 'dev0'
 """
 
 # major, minor, patch
-version_info = 0, 20, "dev7"
+version_info = 0, 20, "dev8"
 
 # Nice string for the version
 __version__ = ".".join(map(str, version_info))

ansys/fluent/core/docs/.gitignore

@@ -0,0 +1 @@
+README.rst

ansys/fluent/core/launcher/container_launcher.py

@@ -1,18 +1,36 @@
-"""Provides a module for launching Fluent in container mode."""
+"""Provides a module for launching Fluent in container mode.
+
+Examples
+--------
+
+>>> from ansys.fluent.core.launcher.launcher import create_launcher
+>>> from ansys.fluent.core.launcher.pyfluent_enums import LaunchMode
+
+>>> container_meshing_launcher = create_launcher(LaunchMode.CONTAINER, mode="meshing")
+>>> container_meshing_session = container_meshing_launcher()
+
+>>> container_solver_launcher = create_launcher(LaunchMode.CONTAINER)
+>>> container_solver_session = container_solver_launcher()
+"""
 
 import logging
 import os
 from typing import Any, Dict, Optional, Union
 
 from ansys.fluent.core.fluent_connection import FluentConnection
+from ansys.fluent.core.launcher.error_handler import _process_invalid_args
 from ansys.fluent.core.launcher.fluent_container import (
     configure_container_dict,
     start_fluent_container,
 )
-from ansys.fluent.core.launcher.launcher_utils import (
-    FluentMode,
+from ansys.fluent.core.launcher.process_launch_string import (
     _build_fluent_launch_args_string,
-    _process_invalid_args,
+)
+from ansys.fluent.core.launcher.pyfluent_enums import (
+    FluentLinuxGraphicsDriver,
+    FluentMode,
+    FluentUI,
+    FluentWindowsGraphicsDriver,
 )
 import ansys.fluent.core.launcher.watchdog as watchdog
 from ansys.fluent.core.utils.file_transfer_service import PimFileTransferService
@@ -28,6 +46,8 @@ class DockerLauncher:
     def __init__(
         self,
         mode: FluentMode,
+        ui: FluentUI,
+        graphics_driver: Union[FluentWindowsGraphicsDriver, FluentLinuxGraphicsDriver],
         product_version: Optional[str] = None,
         version: Optional[str] = None,
         precision: Optional[str] = None,
@@ -41,7 +61,6 @@ class DockerLauncher:
         dry_run: bool = False,
         cleanup_on_exit: bool = True,
         start_transcript: bool = True,
-        show_gui: Optional[bool] = None,
         case_file_name: Optional[str] = None,
         case_data_file_name: Optional[str] = None,
         lightweight_mode: Optional[bool] = None,
@@ -59,9 +78,15 @@ class DockerLauncher:
         ----------
         mode : FluentMode
             Launch mode of Fluent to point to a specific session type.
+        ui : FluentUI
+            Fluent user interface mode. Options are the values of the ``FluentUI`` enum.
+        graphics_driver : FluentWindowsGraphicsDriver or FluentLinuxGraphicsDriver
+            Graphics driver of Fluent. Options are the values of the
+            ``FluentWindowsGraphicsDriver`` enum in Windows or the values of the
+            ``FluentLinuxGraphicsDriver`` enum in Linux.
         product_version : str, optional
-            Select an installed version of ANSYS. The string must be in a format like
-            ``"23.2.0"`` (for 2023 R2) matching the documented version format in the
+            Version of Ansys Fluent to launch. The string must be in a format like
+            ``"23.2.0"`` (for 2023 R2), matching the documented version format in the
             FluentVersion class. The default is ``None``, in which case the newest installed
             version is used.
         version : str, optional
@@ -107,11 +132,6 @@ class DockerLauncher:
             default is ``True``. You can stop and start the streaming of the
             Fluent transcript subsequently via the method calls, ``transcript.start()``
             and ``transcript.stop()`` on the session object.
-        show_gui : bool, optional
-            Whether to display the Fluent GUI. The default is ``None``, which does not
-            cause the GUI to be shown. If a value of ``False`` is
-            not explicitly provided, the GUI will also be shown if
-            the environment variable ``PYFLUENT_SHOW_SERVER_GUI`` is set to 1.
         case_file_name : str, optional
             If provided, the case file at ``case_file_name`` is read into the Fluent session.
         case_data_file_name : str, optional

ansys/fluent/core/launcher/error_handler.py

@@ -0,0 +1,126 @@
+from ansys.fluent.core.exceptions import InvalidArgument
+from ansys.fluent.core.launcher import launcher_utils
+from ansys.fluent.core.launcher.pyfluent_enums import FluentUI, LaunchMode
+from ansys.fluent.core.utils.fluent_version import FluentVersion
+
+
+class InvalidPassword(ValueError):
+    """Raised when password is invalid."""
+
+    def __init__(self):
+        super().__init__("Provide correct 'password'.")
+
+
+class GPUSolverSupportError(ValueError):
+    """Raised when an unsupported Fluent version is specified."""
+
+    def __init__(self):
+        super().__init__("Fluent GPU Solver is only supported for 3D.")
+
+
+class IpPortNotProvided(ValueError):
+    """Raised when IP address and port are not specified."""
+
+    def __init__(self):
+        super().__init__("Provide either 'ip' and 'port' or 'server_info_file_name'.")
+
+
+class UnexpectedKeywordArgument(TypeError):
+    """Raised when a valid keyword argument is not specified."""
+
+    pass
+
+
+class DockerContainerLaunchNotSupported(SystemError):
+    """Raised when Docker container launch is not supported."""
+
+    def __init__(self):
+        super().__init__("Python Docker SDK is unsupported on this system.")
+
+
+# pylint: disable=missing-raises-doc
+class LaunchFluentError(Exception):
+    """Exception class representing launch errors."""
+
+    def __init__(self, launch_string):
+        """__init__ method of LaunchFluentError class."""
+        details = "\n" + "Fluent Launch string: " + launch_string
+        super().__init__(details)
+
+
+def _raise_non_gui_exception_in_windows(
+    ui: FluentUI, product_version: FluentVersion
+) -> None:
+    """Fluent user interface mode lower than ``FluentUI.HIDDEN_GUI`` is not supported in
+    Windows in Fluent versions earlier than 2024 R1."""
+    if (
+        launcher_utils.is_windows()
+        and ui < FluentUI.HIDDEN_GUI
+        and product_version < FluentVersion.v241
+    ):
+        raise InvalidArgument(
+            f"'{ui}' supported in Windows only for Fluent version 24.1 or later."
+        )
+
+
+def _process_kwargs(kwargs):
+    """Verify whether keyword arguments are valid or not.
+
+    Parameters
+    ----------
+    kwargs: Any
+        Keyword arguments.
+
+    Raises
+    ------
+    UnexpectedKeywordArgument
+        If an unexpected keyword argument is provided.
+    """
+    if kwargs:
+        if "meshing_mode" in kwargs:
+            raise UnexpectedKeywordArgument(
+                "Use 'launch_fluent(mode='meshing')' to launch Fluent in meshing mode."
+            )
+        else:
+            raise UnexpectedKeywordArgument(
+                f"launch_fluent() got an unexpected keyword argument {next(iter(kwargs))}"
+            )
+
+
+def _process_invalid_args(dry_run, fluent_launch_mode, argvals):
+    """Get invalid arguments.
+
+    Parameters
+    ----------
+    dry_run: bool
+        Whether to dry run a container start.
+         If ``True``, the ``launch_fluent()`` will return the configured ``container_dict``.
+    fluent_launch_mode: LaunchMode
+        Fluent launch mode.
+    argvals: dict
+        Local arguments.
+    """
+    if dry_run and fluent_launch_mode != LaunchMode.CONTAINER:
+        launcher_utils.logger.warning(
+            "'dry_run' argument for 'launch_fluent' currently is only "
+            "supported when starting containers."
+        )
+    if fluent_launch_mode != LaunchMode.STANDALONE:
+        arg_names = [
+            "env",
+            "cwd",
+            "topy",
+            "case_file_name",
+            "lightweight_mode",
+            "journal_file_names",
+            "case_data_file_name",
+        ]
+        invalid_arg_names = list(
+            filter(lambda arg_name: argvals[arg_name] is not None, arg_names)
+        )
+        if len(invalid_arg_names) != 0:
+            invalid_str_names = ", ".join(invalid_arg_names)
+            launcher_utils.logger.warning(
+                f"These specified arguments are only supported when starting "
+                f"local standalone Fluent clients: {invalid_str_names}."
+            )

ansys/fluent/core/launcher/launcher.py

@@ -7,22 +7,32 @@ with gRPC.
 import logging
 import os
 from typing import Any, Dict, Optional, Union
+import warnings
 
 from ansys.fluent.core.exceptions import DisallowedValuesError
 from ansys.fluent.core.fluent_connection import FluentConnection
 from ansys.fluent.core.launcher.container_launcher import DockerLauncher
-from ansys.fluent.core.launcher.launcher_utils import (
-    FluentMode,
+from ansys.fluent.core.launcher.error_handler import (
     GPUSolverSupportError,
+    _process_invalid_args,
+    _process_kwargs,
+)
+from ansys.fluent.core.launcher.launcher_utils import (
     _confirm_watchdog_start,
+    is_windows,
+)
+from ansys.fluent.core.launcher.pim_launcher import PIMLauncher
+from ansys.fluent.core.launcher.pyfluent_enums import (
+    FluentLinuxGraphicsDriver,
+    FluentMode,
+    FluentUI,
+    FluentWindowsGraphicsDriver,
+    LaunchMode,
     _get_fluent_launch_mode,
     _get_mode,
     _get_running_session_mode,
-    _get_server_info,
-    _process_invalid_args,
-    _process_kwargs,
 )
-from ansys.fluent.core.launcher.pim_launcher import PIMLauncher
+from ansys.fluent.core.launcher.server_info import _get_server_info
 from ansys.fluent.core.launcher.slurm_launcher import SlurmFuture, SlurmLauncher
 from ansys.fluent.core.launcher.standalone_launcher import StandaloneLauncher
 import ansys.fluent.core.launcher.watchdog as watchdog
@@ -30,48 +40,47 @@ 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
 from ansys.fluent.core.session_solver_icing import SolverIcing
+from ansys.fluent.core.warnings import PyFluentDeprecationWarning
 
 _THIS_DIR = os.path.dirname(__file__)
 _OPTIONS_FILE = os.path.join(_THIS_DIR, "fluent_launcher_options.json")
 logger = logging.getLogger("pyfluent.launcher")
 
 
-def create_launcher(fluent_launch_mode: str = None, **kwargs):
+def create_launcher(fluent_launch_mode: LaunchMode = None, **kwargs):
     """Factory function to create launcher for supported launch modes.
 
     Parameters
     ----------
-    fluent_launch_mode: str
-        Supported Fluent launch modes. Options are ``"container"``,
-        ``"pim"``, ``"slurm"``, and ``"standalone"``.
-
+    fluent_launch_mode: LaunchMode
+        Supported Fluent launch modes. Options are ``"LaunchMode.CONTAINER"``,
+        ``"LaunchMode.PIM"``, ``"LaunchMode.SLURM"``, and ``"LaunchMode.STANDALONE"``.
     Returns
     -------
     launcher: Union[DockerLauncher, PimLauncher, StandaloneLauncher]
         Session launcher.
-
     Raises
     ------
     DisallowedValuesError
         If an unknown Fluent launch mode is passed.
     """
-    allowed_options = ["container", "pim", "standalone", "slurm"]
+    allowed_options = [mode for mode in LaunchMode]
     if (
-        not isinstance(fluent_launch_mode, str)
-        or str(fluent_launch_mode) not in allowed_options
+        not isinstance(fluent_launch_mode, LaunchMode)
+        or fluent_launch_mode not in allowed_options
     ):
         raise DisallowedValuesError(
             "fluent_launch_mode",
             fluent_launch_mode,
             allowed_values=allowed_options,
         )
-    if fluent_launch_mode == "standalone":
+    if fluent_launch_mode == LaunchMode.STANDALONE:
         return StandaloneLauncher(**kwargs)
-    elif fluent_launch_mode == "container":
+    elif fluent_launch_mode == LaunchMode.CONTAINER:
         return DockerLauncher(**kwargs)
-    elif fluent_launch_mode == "pim":
+    elif fluent_launch_mode == LaunchMode.PIM:
         return PIMLauncher(**kwargs)
-    elif fluent_launch_mode == "slurm":
+    elif fluent_launch_mode == LaunchMode.SLURM:
         return SlurmLauncher(**kwargs)
 
 
@@ -90,6 +99,10 @@ def launch_fluent(
     dry_run: bool = False,
     cleanup_on_exit: bool = True,
     start_transcript: bool = True,
+    ui: Union[FluentUI, str, None] = None,
+    graphics_driver: Union[
+        FluentWindowsGraphicsDriver, FluentLinuxGraphicsDriver, str, None
+    ] = None,
     show_gui: Optional[bool] = None,
     case_file_name: Optional[str] = None,
     case_data_file_name: Optional[str] = None,
@@ -110,8 +123,8 @@ def launch_fluent(
     Parameters
     ----------
     product_version : str, optional
-        Select an installed version of ANSYS. The string must be in a format like
-        ``"23.2.0"`` (for 2023 R2) matching the documented version format in the
+        Version of Ansys Fluent to launch. The string must be in a format like
+        ``"23.2.0"`` (for 2023 R2), matching the documented version format in the
         FluentVersion class. The default is ``None``, in which case the newest installed
         version is used.
     version : str, optional
@@ -158,6 +171,21 @@ def launch_fluent(
         default is ``True``. You can stop and start the streaming of the
         Fluent transcript subsequently via the method calls, ``transcript.start()``
         and ``transcript.stop()`` on the session object.
+    ui : FluentUI or str, optional
+        Fluent user interface mode. Options are either the values of the ``FluentUI``
+        enum or any of ``"no_gui_or_graphics"``, ``"no_gui"``, ``"hidden_gui"``,
+        ``"no_graphics"`` or ``"gui"``. The default is ``FluentUI.HIDDEN_GUI`` in
+        Windows and ``FluentUI.NO_GUI`` in Linux. ``"no_gui_or_graphics"`` and
+        ``"no_gui"`` user interface modes are supported in Windows starting from Fluent
+        version 2024 R1.
+    graphics_driver : FluentWindowsGraphicsDriver or FluentLinuxGraphicsDriver or str, optional
+        Graphics driver of Fluent. In Windows, options are either the values of the
+        ``FluentWindowsGraphicsDriver`` enum or any of ``"null"``, ``"msw"``,
+        ``"dx11"``, ``"opengl2"``, ``"opengl"`` or ``"auto"``. In Linux, options are
+        either the values of the ``FluentLinuxGraphicsDriver`` enum or any of
+       ``"null"``, ``"x11"``, ``"opengl2"``, ``"opengl"`` or ``"auto"``. The default is
+       ``FluentWindowsGraphicsDriver.AUTO`` in Windows and
+       ``FluentLinuxGraphicsDriver.AUTO`` in Linux.
     show_gui : bool, optional
         Whether to display the Fluent GUI. The default is ``None``, which does not
         cause the GUI to be shown. If a value of ``False`` is
@@ -234,6 +262,28 @@ def launch_fluent(
         raise GPUSolverSupportError()
     _process_kwargs(kwargs)
     del kwargs
+    if show_gui is not None:
+        warnings.warn(
+            "'show_gui' is deprecated, use 'ui' instead",
+            PyFluentDeprecationWarning,
+        )
+    if show_gui or os.getenv("PYFLUENT_SHOW_SERVER_GUI") == 1:
+        ui = FluentUI.GUI
+    del show_gui
+    if ui is None:
+        # Not using NO_GUI in windows as it opens a new cmd or
+        # shows Fluent output in the current cmd if start <launch_string> is not used
+        ui = FluentUI.HIDDEN_GUI if is_windows() else FluentUI.NO_GUI
+    if isinstance(ui, str):
+        ui = FluentUI(ui)
+    if graphics_driver is None:
+        graphics_driver = "auto"
+    graphics_driver = str(graphics_driver)
+    graphics_driver = (
+        FluentWindowsGraphicsDriver(graphics_driver)
+        if is_windows()
+        else FluentLinuxGraphicsDriver(graphics_driver)
+    )
     fluent_launch_mode = _get_fluent_launch_mode(
         start_container=start_container,
         container_dict=container_dict,