ansys-fluent-core 0.27.dev1__py3-none-any.whl → 0.28.dev0__py3-none-any.whl

ansys/fluent/core/journaling.py

@@ -14,4 +14,4 @@ class Journal:
 
     def stop(self):
         """Stop writing the Fluent Python journal."""
-        self.scheme_eval.exec([f"(api-stop-python-journal)"])
+        self.scheme_eval.exec(["(api-stop-python-journal)"])

ansys/fluent/core/launcher/error_handler.py

@@ -9,6 +9,7 @@ class InvalidPassword(ValueError):
     """Raised when password is invalid."""
 
     def __init__(self):
+        """Initialize InvalidPassword."""
         super().__init__("Provide correct 'password'.")
 
 
@@ -16,6 +17,7 @@ class GPUSolverSupportError(ValueError):
     """Raised when an unsupported Fluent version is specified."""
 
     def __init__(self):
+        """Initialize GPUSolverSupportError."""
         super().__init__("Fluent GPU Solver is only supported for 3D.")
 
 
@@ -23,6 +25,7 @@ class IpPortNotProvided(ValueError):
     """Raised when IP address and port are not specified."""
 
     def __init__(self):
+        """Initialize IpPortNotProvided."""
         super().__init__("Provide either 'ip' and 'port' or 'server_info_file_name'.")
 
 

ansys/fluent/core/launcher/fluent_container.py

@@ -313,6 +313,11 @@ def configure_container_dict(
 
     container_dict["fluent_image"] = fluent_image
 
+    if not pyfluent.FLUENT_AUTOMATIC_TRANSCRIPT:
+        if "environment" not in container_dict:
+            container_dict["environment"] = {}
+        container_dict["environment"]["FLUENT_NO_AUTOMATIC_TRANSCRIPT"] = "1"
+
     fluent_commands = ["-gu", f"-sifile={container_server_info_file}"] + args
 
     container_dict_default = {}

ansys/fluent/core/launcher/launcher.py

@@ -7,7 +7,6 @@ with gRPC.
 import inspect
 import logging
 import os
-from pathlib import Path
 from typing import Any, Dict
 
 import ansys.fluent.core as pyfluent
@@ -102,7 +101,7 @@ def launch_fluent(
     journal_file_names: None | str | list[str] = None,
     start_timeout: int = None,
     additional_arguments: str | None = "",
-    env: Dict[str, Any] | Path | None = None,
+    env: Dict[str, Any] | None = None,
     start_container: bool | None = None,
     container_dict: dict | None = None,
     dry_run: bool = False,

ansys/fluent/core/launcher/launcher_utils.py

@@ -21,11 +21,17 @@ def is_windows():
 
 
 def _get_subprocess_kwargs_for_fluent(env: Dict[str, Any], argvals) -> Dict[str, Any]:
+    import ansys.fluent.core as pyfluent
+
     scheduler_options = argvals.get("scheduler_options")
     is_slurm = scheduler_options and scheduler_options["scheduler"] == "slurm"
     kwargs: Dict[str, Any] = {}
     if is_slurm:
         kwargs.update(stdout=subprocess.PIPE)
+    else:
+        kwargs.update(
+            stdout=pyfluent.LAUNCH_FLUENT_STDOUT, stderr=pyfluent.LAUNCH_FLUENT_STDERR
+        )
     if is_windows():
         kwargs.update(shell=True, creationflags=subprocess.CREATE_NEW_PROCESS_GROUP)
     else:
@@ -33,15 +39,19 @@ def _get_subprocess_kwargs_for_fluent(env: Dict[str, Any], argvals) -> Dict[str,
     fluent_env = os.environ.copy()
     fluent_env.update({k: str(v) for k, v in env.items()})
     fluent_env["REMOTING_THROW_LAST_TUI_ERROR"] = "1"
+    if pyfluent.CLEAR_FLUENT_PARA_ENVS:
+        del fluent_env["PARA_NPROCS"]
+        del fluent_env["PARA_MESH_NPROCS"]
 
     if not is_slurm:
-        from ansys.fluent.core import INFER_REMOTING_IP
-
-        if INFER_REMOTING_IP and not "REMOTING_SERVER_ADDRESS" in fluent_env:
+        if pyfluent.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:
+        fluent_env["FLUENT_NO_AUTOMATIC_TRANSCRIPT"] = "1"
+
     kwargs.update(env=fluent_env)
     return kwargs
 
@@ -82,12 +92,13 @@ def _build_journal_argument(
 ) -> str:
     """Build Fluent commandline journal argument."""
 
-    from beartype import BeartypeConf, beartype
-
-    @beartype(conf=BeartypeConf(violation_type=TypeError))
     def _impl(
         topy: None | bool | str, journal_file_names: None | str | list[str]
     ) -> str:
+        if journal_file_names and not isinstance(journal_file_names, (str, list)):
+            raise TypeError(
+                "Use 'journal_file_names' to specify and convert journal files."
+            )
         if topy and not journal_file_names:
             raise InvalidArgument(
                 "Use 'journal_file_names' to specify and convert journal files."

ansys/fluent/core/launcher/process_launch_string.py

@@ -108,14 +108,14 @@ 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.SHOW_MESH_AFTER_CASE_READ:
+    if not pyfluent.FLUENT_SHOW_MESH_AFTER_CASE_READ:
         launch_string += " -nm"
     return launch_string
 
 
 def get_fluent_exe_path(**launch_argvals) -> Path:
-    """Get the path for the Fluent executable file.
-    The search for the path is performed in this order:
+    """Get the path for the Fluent executable file. The search for the path is performed
+    in the following order.
 
     1. ``product_version`` parameter passed with the ``launch_fluent`` method.
     2. The latest Ansys version from ``AWP_ROOTnnn``` environment variables.

ansys/fluent/core/launcher/pyfluent_enums.py

@@ -42,7 +42,7 @@ class FluentEnum(Enum):
 
         def is_int():
             for m in cls:
-                return True if type(m.value) == int else False
+                return True if isinstance(m.value, int) else False
 
         msg = ", " if is_int() else "', '"
         msg = (

ansys/fluent/core/launcher/slurm_launcher.py

@@ -147,6 +147,7 @@ class SlurmFuture:
     """
 
     def __init__(self, future: Future, job_id: int):
+        """Initialize SlurmFuture."""
         self._future = future
         self._job_id = job_id
 
@@ -272,7 +273,7 @@ class SlurmLauncher:
         journal_file_names: None | str | list[str] = None,
         start_timeout: int = -1,
         additional_arguments: str | None = "",
-        env: Dict[str, Any] | Path | None = None,
+        env: Dict[str, Any] | None = None,
         cleanup_on_exit: bool = True,
         start_transcript: bool = True,
         case_file_name: str | None = None,

ansys/fluent/core/launcher/standalone_launcher.py

@@ -68,7 +68,7 @@ class StandaloneLauncher:
         journal_file_names: None | str | list[str] = None,
         start_timeout: int = 60,
         additional_arguments: str | None = "",
-        env: Dict[str, Any] | Path | None = None,
+        env: Dict[str, Any] | None = None,
         cleanup_on_exit: bool = True,
         dry_run: bool = False,
         start_transcript: bool = True,
@@ -177,6 +177,8 @@ class StandaloneLauncher:
         The allocated machines and core counts are queried from the scheduler environment and
         passed to Fluent.
         """
+        import ansys.fluent.core as pyfluent
+
         self.argvals, self.new_session = _get_argvals_and_session(locals().copy())
         self.file_transfer_service = file_transfer_service
         if os.getenv("PYFLUENT_SHOW_SERVER_GUI") == "1":
@@ -215,8 +217,11 @@ class StandaloneLauncher:
         )
 
         if is_windows():
-            # Using 'start.exe' is better; otherwise Fluent is more susceptible to bad termination attempts.
-            self._launch_cmd = 'start "" ' + self._launch_string
+            if pyfluent.LAUNCH_FLUENT_STDOUT or pyfluent.LAUNCH_FLUENT_STDERR:
+                self._launch_cmd = self._launch_string
+            else:
+                # Using 'start.exe' is better; otherwise Fluent is more susceptible to bad termination attempts.
+                self._launch_cmd = 'start "" ' + self._launch_string
         else:
             if self.argvals["ui_mode"] not in [UIMode.GUI, UIMode.HIDDEN_GUI]:
                 # Using nohup to hide Fluent output from the current terminal
@@ -231,7 +236,7 @@ class StandaloneLauncher:
         try:
             logger.debug(f"Launching Fluent with command: {self._launch_cmd}")
 
-            subprocess.Popen(self._launch_cmd, **self._kwargs)
+            process = subprocess.Popen(self._launch_cmd, **self._kwargs)
 
             try:
                 _await_fluent_launch(
@@ -247,7 +252,7 @@ class StandaloneLauncher:
                     logger.warning(
                         f"Retrying Fluent launch with less robust command: {launch_cmd}"
                     )
-                    subprocess.Popen(launch_cmd, **self._kwargs)
+                    process = subprocess.Popen(launch_cmd, **self._kwargs)
                     _await_fluent_launch(
                         self._server_info_file_name,
                         self.argvals["start_timeout"],
@@ -264,6 +269,7 @@ class StandaloneLauncher:
                 launcher_args=self.argvals,
                 inside_container=False,
             )
+            session._process = process
             start_watchdog = _confirm_watchdog_start(
                 self.argvals["start_watchdog"],
                 self.argvals["cleanup_on_exit"],

ansys/fluent/core/launcher/watchdog.py

@@ -157,7 +157,7 @@ def launch(
 
     subprocess.Popen(cmd_send, **kwargs)
 
-    logger.info(f"Waiting for Watchdog to initialize, then proceeding...")
+    logger.info("Waiting for Watchdog to initialize, then proceeding...")
     file_exists = timeout_loop(
         lambda: init_file.is_file() or watchdog_err.is_file(), 30.0
     )

ansys/fluent/core/launcher/watchdog_exec

@@ -12,11 +12,14 @@ if __name__ == "__main__":
         import sys
         import time
 
-        import psutil
         from watchdog import IDLE_PERIOD, WATCHDOG_INIT_FILE
 
         import ansys.fluent.core as pyfluent
-        from ansys.fluent.core.fluent_connection import FluentConnection, get_container
+        from ansys.fluent.core.fluent_connection import (
+            FluentConnection,
+            _pid_exists,
+            get_container,
+        )
         from ansys.fluent.core.utils.execution import timeout_exec, timeout_loop
 
         watchdog_id = sys.argv[5]
@@ -103,7 +106,7 @@ if __name__ == "__main__":
 
         def check_pid_down(pid, name):
             """Check whether pid is down or not."""
-            if not psutil.pid_exists(pid):
+            if not _pid_exists(pid):
                 logger.debug(name + " down")
                 down.append(name)
 

ansys/fluent/core/logging.py

@@ -1,7 +1,4 @@
-"""Module controlling PyFluent's logging functionality.
-
-For a basic user guide, see the :ref:`logging user guide <ref_logging_user_guide>`.
-"""
+"""Module controlling PyFluent's logging functionality."""
 
 import logging.config
 import os
@@ -228,7 +225,6 @@ def configure_env_var() -> None:
     ``PYFLUENT_LOGGING`` set to ``0`` or ``OFF`` is the same as if no environment variable was set.
     If logging debug output to file by default is desired, without having to use :func:`enable()` every time,
     set environment variable ``PYFLUENT_LOGGING`` to ``DEBUG``.
-    See also the :ref:`user guide environment variable subsection <ref_logging_env_var>`.
     """
     env_logging_level = os.getenv("PYFLUENT_LOGGING")
     if env_logging_level:

ansys/fluent/core/parametric.py

@@ -71,6 +71,7 @@ class LocalDesignPoint:
     """
 
     def __init__(self, design_point_name: str, base_design_point=None):
+        """Initialize LocalDesignPoint."""
         self.name = design_point_name
         if base_design_point:
             self.__inputs = base_design_point.input_parameters.copy()
@@ -119,6 +120,7 @@ class LocalDesignPointTable(list):
     """
 
     def __init__(self, base_design_point: LocalDesignPoint):
+        """Initialize LocalDesignPointTable."""
         super().__init__()
         self.append(base_design_point)
 
@@ -255,13 +257,13 @@ class LocalParametricStudy:
 
     Methods
     -------
-    add_design_point(design_point_name: str) -> LocalDesignPoint
+    add_design_point(design_point_name)
         Add a design point.
     design_point(idx_or_name)
         Get a design point, either by name (str) or an index
         indicating the position in the table (by order of insertion).
-    run_in_fluent
-    Run the study in Fluent
+    run_in_fluent()
+        Run the study in Fluent
 
     Raises
     ------
@@ -270,6 +272,7 @@ class LocalParametricStudy:
     """
 
     def __init__(self, case_filepath: str, base_design_point_name: str = "Base DP"):
+        """Initialize LocalParametricStudy."""
         from ansys.fluent.core.filereader.casereader import CaseReader
 
         self.case_filepath = case_filepath

ansys/fluent/core/post_objects/meta.py

@@ -98,7 +98,7 @@ class Command:
                                     )
 
                         elif attr == "range":
-                            if type(arg_value) != int and type(arg_value) != float:
+                            if not isinstance(arg_value, (int, float)):
                                 raise RuntimeError(
                                     f"{arg} value {arg_value} is not number."
                                 )
@@ -788,15 +788,6 @@ class PyLocalContainer(MutableMapping):
                     cls(self, api_helper, name),
                 )
 
-    @classmethod
-    def get_root(self, obj=None):
-        """Returns the top-most parent object."""
-        obj = self if obj is None else obj
-        parent = obj
-        if getattr(obj, "_parent", None):
-            parent = self.get_root(obj._parent)
-        return parent
-
     def update(self, value):
         """Updates this object with the provided dictionary."""
         for name, val in value.items():
@@ -842,35 +833,6 @@ class PyLocalContainer(MutableMapping):
         """Returns the session-handle object."""
         return self.get_session_handle()
 
-    def get_root(self, obj=None):
-        """Get root object."""
-        obj = self if obj is None else obj
-        parent = obj
-        if getattr(obj, "_parent", None):
-            parent = self.get_root(obj._parent)
-        return parent
-
-    def get_session(self, obj=None):
-        """Get session object."""
-        root = self.get_root(obj)
-        return root.session
-
-    def get_path(self):
-        """Get parent path."""
-        if getattr(self, "_parent", None):
-            return self._parent.get_path() + "/" + self._name
-        return self._name
-
-    @property
-    def path(self):
-        """Get path."""
-        return self.get_path()
-
-    @property
-    def session(self):
-        """Get session object."""
-        return self.get_session()
-
     def __iter__(self):
         return iter(self.__collection)
 

ansys/fluent/core/post_objects/post_helper.py

@@ -7,6 +7,7 @@ class IncompleteISOSurfaceDefinition(RuntimeError):
     """Raised when iso-surface definition is incomplete."""
 
     def __init__(self):
+        """Initialize IncompleteISOSurfaceDefinition."""
         super().__init__("Iso surface definition is incomplete.")
 
 
@@ -14,6 +15,7 @@ class SurfaceCreationError(RuntimeError):
     """Raised when surface creation is unsuccessful."""
 
     def __init__(self):
+        """Initialize SurfaceCreationError."""
         super().__init__("Surface creation is unsuccessful.")
 
 
@@ -125,15 +127,14 @@ class PostAPIHelper:
     # Following functions will be deprecated in future.
     def get_vector_fields(self):
         """Returns vector field."""
-        scheme_eval_str = "(map car (apply append (map client-inquire-cell-vector-functions (inquire-domain-for-cell-functions))))"  # noqa: E501
-        return self._scheme_str_to_py_list(scheme_eval_str)
+        return self.field_info.get_vector_fields_info()
 
     def get_field_unit(self, field):
         """Returns the unit of the field."""
         quantity = self._field_unit_quantity(field)
         if quantity == "*null*":
             return ""
-        scheme_eval_str = f"(units/get-pretty-wb-units-from-dimension (units/inquire-dimension '{quantity}))"  # noqa: E501
+        scheme_eval_str = f"(units/get-pretty-wb-units-from-dimension (units/inquire-dimension '{quantity}))"
         return " ".join(self._scheme_str_to_py_list(scheme_eval_str))
 
     def _field_unit_quantity(self, field):

ansys/fluent/core/post_objects/post_object_definitions.py

@@ -19,7 +19,7 @@ class BasePostObjectDefn:
 
     def _pre_display(self):
         local_surfaces_provider = self.get_root()._local_surfaces_provider()
-        for surf_name in self.surfaces_list():
+        for surf_name in self.surfaces():
             if surf_name in list(local_surfaces_provider):
                 surf_obj = local_surfaces_provider[surf_name]
                 surf_api = surf_obj._api_helper.surface_api
@@ -27,7 +27,7 @@ class BasePostObjectDefn:
 
     def _post_display(self):
         local_surfaces_provider = self.get_root()._local_surfaces_provider()
-        for surf_name in self.surfaces_list():
+        for surf_name in self.surfaces():
             if surf_name in list(local_surfaces_provider):
                 surf_obj = local_surfaces_provider[surf_name]
                 surf_api = surf_obj._api_helper.surface_api
@@ -128,7 +128,7 @@ class XYPlotDefn(PlotDefn):
             """X axis function allowed values."""
             return ["direction-vector"]
 
-    class surfaces_list(metaclass=PyLocalPropertyMeta):
+    class surfaces(metaclass=PyLocalPropertyMeta):
         """List of surfaces for plotting."""
 
         value: List[str] = []
@@ -146,7 +146,7 @@ class MeshDefn(GraphicsDefn):
 
     PLURAL = "Meshes"
 
-    class surfaces_list(metaclass=PyLocalPropertyMeta):
+    class surfaces(metaclass=PyLocalPropertyMeta):
         """List of surfaces for mesh graphics."""
 
         value: List[str] = []
@@ -189,7 +189,7 @@ class PathlinesDefn(GraphicsDefn):
             """Field allowed values."""
             return list(self._api_helper.field_info().get_scalar_fields_info())
 
-    class surfaces_list(metaclass=PyLocalPropertyMeta):
+    class surfaces(metaclass=PyLocalPropertyMeta):
         """List of surfaces for pathlines."""
 
         value: List[str] = []
@@ -207,6 +207,11 @@ class SurfaceDefn(GraphicsDefn):
 
     PLURAL = "Surfaces"
 
+    @property
+    def name(self) -> str:
+        """Return name of the surface."""
+        return self._name
+
     class show_edges(metaclass=PyLocalPropertyMeta):
         """Show edges for surface."""
 
@@ -376,7 +381,7 @@ class ContourDefn(GraphicsDefn):
             """Field allowed values."""
             return list(self._api_helper.field_info().get_scalar_fields_info())
 
-    class surfaces_list(metaclass=PyLocalPropertyMeta):
+    class surfaces(metaclass=PyLocalPropertyMeta):
         """Contour surfaces."""
 
         value: List[str] = []
@@ -557,7 +562,7 @@ class VectorDefn(GraphicsDefn):
             """Field allowed values."""
             return list(self._api_helper.field_info().get_scalar_fields_info())
 
-    class surfaces_list(metaclass=PyLocalPropertyMeta):
+    class surfaces(metaclass=PyLocalPropertyMeta):
         """List of surfaces for vector graphics."""
 
         value: List[str] = []

ansys/fluent/core/post_objects/post_objects_container.py

@@ -80,14 +80,51 @@ class Container:
         return state
 
     def _init_module(self, obj, mod, post_api_helper):
+        """
+        Dynamically initializes and attaches containers for classes in a module.
+
+        Args:
+            obj: The parent object to which containers are attached.
+            mod: The module containing class definitions to process.
+            post_api_helper: Helper object for post-processing API interactions.
+
+        This method identifies classes in the module that match certain criteria,
+        creates a container for managing instances of these classes, and attaches
+        the container to the parent object (`obj`). A `create()` method is also
+        dynamically added to each container for creating and initializing new objects.
+        """
+        # Iterate through all attributes in the module's dictionary
         for name, cls in mod.__dict__.items():
             if cls.__class__.__name__ in (
                 "PyLocalNamedObjectMetaAbstract",
             ) and not inspect.isabstract(cls):
+                cont = PyLocalContainer(self, cls, post_api_helper, cls.PLURAL)
+
+                # Define a method to add a "create" function to the container
+                def _add_create(py_cont):
+                    def _create(**kwargs):
+                        new_object = py_cont.__getitem__(
+                            py_cont._get_unique_chid_name()
+                        )
+                        # Validate that all kwargs are valid attributes for the object
+                        unexpected_args = set(kwargs) - set(new_object())
+                        if unexpected_args:
+                            raise TypeError(
+                                f"create() got an unexpected keyword argument '{next(iter(unexpected_args))}'."
+                            )
+                        for key, value in kwargs.items():
+                            setattr(new_object, key, value)
+                        return new_object
+
+                    return _create
+
+                # Attach the create method to the container
+                setattr(cont, "create", _add_create(cont))
+                # Attach the container to the parent object
                 setattr(
                     obj,
                     cls.PLURAL,
-                    PyLocalContainer(self, cls, post_api_helper, cls.PLURAL),
+                    cont,
                 )
 
 
@@ -179,7 +216,7 @@ class Graphics(Container):
         if meshes is not None:
             outline_mesh_id = "mesh-outline"
             outline_mesh = meshes[outline_mesh_id]
-            outline_mesh.surfaces_list = [
+            outline_mesh.surfaces = [
                 k
                 for k, v in outline_mesh._api_helper.field_info()
                 .get_surfaces_info()

ansys/fluent/core/rpvars.py

@@ -17,6 +17,7 @@ class RPVars:
     _allowed_values = None
 
     def __init__(self, eval_fn):
+        """Initialize RPVars."""
         self._eval_fn = eval_fn
 
     def __call__(self, var: str | None = None, val: Any | None = None) -> Any:
@@ -48,7 +49,7 @@ class RPVars:
         >>> solver.rp_vars("number-of-iterations")
         100
 
-        Getting dictionary with all rpvars available:
+        >>> # Get dictionary of all available rpvars:
 
         >>> solver.rp_vars()
         {'sg-swirl?': False, 'rp-seg?': True, 'rf-energy?': False, 'rp-inviscid?': False, ...

ansys/fluent/core/scheduler/machine_list.py

@@ -80,8 +80,10 @@ class Machine(object):
 class MachineList(object):
     """Provides an interface to list of machines allocated by a queue system."""
 
-    def __init__(self, machinesIn=[]):
+    def __init__(self, machinesIn=None):
         """Constructs and initializes an empty machine file object."""
+        if machinesIn is None:
+            machinesIn = []
         self._machines = []
         for machine in machinesIn:
             self._machines.append(machine)