ansys-fluent-core 0.31.dev1__py3-none-any.whl → 0.31.1__py3-none-any.whl

ansys/fluent/core/__init__.py

@@ -57,14 +57,22 @@ from ansys.fluent.core.pyfluent_warnings import (  # noqa: F401
 from ansys.fluent.core.search import search  # noqa: F401
 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.session_utilities import (  # noqa: F401
+    Meshing,
+    PrePost,
+    PureMeshing,
+    Solver,
+    SolverAero,
+    SolverIcing,
+)
 from ansys.fluent.core.streaming_services.events_streaming import *  # noqa: F401, F403
 from ansys.fluent.core.utils import fldoc, get_examples_download_dir
 from ansys.fluent.core.utils.fluent_version import FluentVersion  # noqa: F401
 from ansys.fluent.core.utils.setup_for_fluent import setup_for_fluent  # noqa: F401
 
-__version__ = "0.31.dev1"
+__version__ = "0.31.1"
 
-_VERSION_INFO = "Build date: April 29, 2025 11:50 UTC ShaID: 41afeb4"
+_VERSION_INFO = "Build date: August 15, 2025 03:41 UTC ShaID: e30f89c"
 """
 Global variable indicating the version info of the PyFluent package.
 Build timestamp and commit hash are added to this variable during packaging.
@@ -106,7 +114,7 @@ EXAMPLES_PATH = str(get_examples_download_dir())
 CONTAINER_MOUNT_SOURCE = None
 
 # Path inside the container where the host path is mounted
-CONTAINER_MOUNT_TARGET = "/mnt/pyfluent"
+CONTAINER_MOUNT_TARGET = "/home/container/workdir"
 
 # Set this to False to stop automatically inferring and setting REMOTING_SERVER_ADDRESS
 INFER_REMOTING_IP = True

ansys/fluent/core/codegen/settingsgen.py

@@ -124,6 +124,7 @@ def _populate_data(cls, api_tree: dict, version: str) -> dict:
     data["argument_names"] = getattr(cls, "argument_names", [])
     data["child_aliases"] = getattr(cls, "_child_aliases", {})
     data["return_type"] = getattr(cls, "return_type", None)
+    data["deprecated_version"] = getattr(cls, "_deprecated_version", None)
     child_classes = data.setdefault("child_classes", {})
     for k, v in cls._child_classes.items():
         if k in command_names:
@@ -227,6 +228,11 @@ def _write_data(cls_name: str, python_name: str, data: dict, f: IO, f_stub: IO |
     s.write(f"    {doc}\n")
     s.write('    """\n')
     s.write(f"    _version = {data['version']!r}\n")
+    deprecated = data["deprecated_version"]
+    if deprecated:
+        release_version = "20" + data["deprecated_version"].replace(".", "R")
+        s.write(f"    _deprecated_version = {release_version!r}\n")
+        s_stub.write("    _deprecated_version: str\n")
     s.write(f"    fluent_name = {data['fluent_name']!r}\n")
     # _python_name preserves the original non-suffixed name of the class.
     s.write(f"    _python_name = {python_name!r}\n")

ansys/fluent/core/codegen/tuigen.py

@@ -58,7 +58,6 @@ from ansys.fluent.core.services.datamodel_tui import (
 )
 from ansys.fluent.core.utils.fix_doc import escape_wildcards
 from ansys.fluent.core.utils.fluent_version import (
-    AnsysVersionNotFound,
     FluentVersion,
     get_version_for_file_name,
 )
@@ -130,7 +129,7 @@ def _copy_tui_help_xml_file(version: str):
                 shutil.copy(str(xml_source), _XML_HELP_FILE)
             else:
                 logger.warning("fluent_gui_help.xml is not found.")
-        except AnsysVersionNotFound:
+        except FileNotFoundError:
             logger.warning("fluent_gui_help.xml is not found.")
 
 

ansys/fluent/core/docker/docker_compose.py

@@ -0,0 +1,243 @@
+"""Launch Fluent through docker compose."""
+
+# 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.
+
+import os
+import subprocess
+import uuid
+
+
+class ComposeBasedLauncher:
+    """Launch Fluent through docker or Podman compose."""
+
+    def __init__(self, *, container_dict):
+        self._compose_name = f"pyfluent_compose_{uuid.uuid4().hex}"
+        self._container_dict = container_dict
+        self._image_name = (
+            container_dict.get("fluent_image")
+            or f"ghcr.io/ansys/pyfluent:{os.getenv('FLUENT_IMAGE_TAG')}"
+        )
+        self._container_source = self._set_compose_cmds()
+        self._container_source.remove("compose")
+
+        self._compose_file = self._get_compose_file(container_dict)
+
+    def _is_podman_selected(self):
+        return os.getenv("PYFLUENT_USE_PODMAN_COMPOSE") == "1"
+
+    def _get_compose_file(self, container_dict):
+        """Generates compose file for the Docker Compose setup.
+
+        Parameters
+        ----------
+        container_dict: dict
+            A dictionary containing container configuration.
+        """
+
+        indent = "  "
+
+        if container_dict.get("ports"):
+            ports = list(container_dict.get("ports").values())
+        else:
+            ports = [container_dict.get("fluent_port", "")]
+
+        compose_file = f"""
+        services:
+          fluent:
+            image: {container_dict.get("fluent_image")}
+            command: {" ".join(container_dict["command"])}
+            working_dir: {container_dict.get("mount_target")}
+            volumes:
+            {indent}- {container_dict.get("mount_source")}:{container_dict.get("mount_target")}
+            ports:
+        """
+
+        for port in ports:
+            if len(ports) == 1:
+                compose_file += f"{indent * 3}- {port}:{port}"
+            else:
+                if port == ports[0]:
+                    compose_file += f"{indent * 3}- {port}:{port}\n"
+                elif port == ports[-1]:
+                    compose_file += f"{indent * 7}- {port}:{port}"
+                else:
+                    compose_file += f"{indent * 7}- {port}:{port}\n"
+
+        compose_file_env = f"""
+        {indent * 2}environment:
+        """
+
+        for key, value in container_dict["environment"].items():
+            if key == "ANSYSLMD_LICENSE_FILE":
+                compose_file_env += f"""{indent * 3}- {key}={value}\n"""
+            else:
+                compose_file_env += f"""{indent * 7}- {key}={value}\n"""
+
+        compose_file += compose_file_env
+
+        return compose_file
+
+    def _extract_ports(self, port_string):
+        """
+        Extracts ports from a string containing port mappings.
+
+        Parameters
+        ----------
+        port_string: str
+            A string containing port mappings.
+
+        Returns
+        -------
+        ports: list
+            A list of extracted ports.
+        """
+        ports = []
+        for line in port_string.split("\n"):
+            if line:
+                _, target = line.split("->")
+                port = target.split(":")[1]
+                ports.append(port)
+        return [port for port in ports if port.isdigit()]
+
+    def _set_compose_cmds(self):
+        """Sets the compose commands based on available tools and permissions.
+
+        Raises
+        ------
+        RuntimeError
+            If neither Docker nor Podman is specified.
+        """
+
+        # Determine the compose command
+        if os.getenv("PYFLUENT_USE_PODMAN_COMPOSE") == "1":
+            self._compose_cmds = (
+                ["sudo", "podman", "compose"]
+                if hasattr(self, "_container_source")
+                and "sudo" in self._container_source
+                else ["podman", "compose"]
+            )
+        elif os.getenv("PYFLUENT_USE_DOCKER_COMPOSE") == "1":
+            self._compose_cmds = ["docker", "compose"]
+        else:
+            raise RuntimeError("Neither Docker nor Podman is specified.")
+
+        return self._compose_cmds
+
+    def check_image_exists(self) -> bool:
+        """Check if the image exists locally."""
+        try:
+            cmd = self._container_source + ["images", "-q", self._image_name]
+            # Podman users do not always configure rootless mode in /etc/subuids and /etc/subgids
+            if self._is_podman_selected():
+                sudo_cmd = ["sudo"] + cmd
+                output_1 = subprocess.check_output(cmd)
+                output_2 = subprocess.check_output(sudo_cmd)
+                output_1_result = output_1.decode("utf-8").strip() != ""
+                output_2_result = output_2.decode("utf-8").strip() != ""
+                if output_2_result and not output_1_result:
+                    self._container_source.insert(0, "sudo")
+                return output_1_result or output_2_result
+            else:
+                output = subprocess.check_output(cmd)
+                return output.decode("utf-8").strip() != ""
+        except subprocess.CalledProcessError as e:  # noqa: F841
+            return False
+
+    def pull_image(self) -> None:
+        """Pull a Docker image if it does not exist locally."""
+
+        cmd = self._container_source + ["pull", self._image_name]
+
+        subprocess.check_call(cmd)
+
+    def _start_stop_helper(
+        self, compose_cmd: list[str], cmd: list[str], timeout: float
+    ) -> None:
+        """Helper function to start or stop the services.
+        Parameters
+        ----------
+        compose_cmd: list[str]
+            The command to run.
+        cmd: list[str]
+            The command to run.
+        timeout: float
+            The timeout for the command.
+        """
+        process = subprocess.Popen(
+            compose_cmd + cmd,
+            stdin=subprocess.PIPE,
+            text=True,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+        )
+        process.communicate(input=self._compose_file, timeout=timeout)
+        return_code = process.wait(timeout=timeout)
+
+        if return_code != 0:
+            raise subprocess.CalledProcessError(return_code, compose_cmd + cmd)
+
+    def start(self) -> None:
+        """Start the services.
+
+        Raises
+        ------
+        subprocess.CalledProcessError
+            If the command fails.
+        """
+
+        cmd = [
+            "-f",
+            "-",
+            "--project-name",
+            self._compose_name,
+            "up",
+            "--detach",
+        ]
+
+        self._start_stop_helper(self._set_compose_cmds(), cmd, 60)
+
+    def stop(self) -> None:
+        """Stop the services.
+
+        Raises
+        ------
+        subprocess.CalledProcessError
+            If the command fails.
+        """
+        cmd = [
+            "-f",
+            "-",
+            "--project-name",
+            self._compose_name,
+            "down",
+        ]
+
+        self._start_stop_helper(self._set_compose_cmds(), cmd, 30)
+
+    @property
+    def ports(self) -> list[str]:
+        """Return the ports of the launched services."""
+        output = subprocess.check_output(
+            self._container_source + ["port", f"{self._compose_name}-fluent-1"],
+        )
+        return self._extract_ports(output.decode("utf-8").strip())

ansys/fluent/core/field_data_interfaces.py

@@ -30,6 +30,11 @@ import numpy as np
 import numpy.typing as npt
 
 from ansys.fluent.core.exceptions import DisallowedValuesError
+from ansys.fluent.core.variable_strategies import (
+    FluentFieldDataNamingStrategy as naming_strategy,
+)
+
+_to_field_name_str = naming_strategy().to_string if naming_strategy else lambda s: s
 
 
 class SurfaceDataType(Enum):
@@ -311,6 +316,7 @@ class _AllowedFieldNames(_AllowedNames):
 
     def valid_name(self, field_name):
         """Returns valid names."""
+        field_name = _to_field_name_str(field_name)
         if validate_inputs:
             names = self
             if not names.is_valid(field_name, respect_data_valid=False):