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

ansys/fluent/core/solver/flobject.py

@@ -44,6 +44,7 @@ import collections
 from contextlib import contextmanager, nullcontext
 import fnmatch
 import hashlib
+import inspect
 import keyword
 import logging
 import os
@@ -54,6 +55,7 @@ import sys
 import types
 from typing import (
     Any,
+    Callable,
     Dict,
     ForwardRef,
     Generic,
@@ -88,6 +90,14 @@ from .settings_external import expand_api_file_argument
 settings_logger = logging.getLogger("pyfluent.settings_api")
 
 
+_static_class_attributes = [
+    "_version",
+    "_deprecated_version",
+    "_python_name",
+    "fluent_name",
+]
+
+
 class InactiveObjectError(RuntimeError):
     """Inactive object access."""
 
@@ -178,7 +188,7 @@ _ttable = str.maketrans(string.punctuation, "_" * len(string.punctuation), "?'")
 def to_python_name(fluent_name: str) -> str:
     """Convert a scheme string to a Python variable name.
 
-    This function replaces symbols with _. Any ``?`` symbols are
+    This function replaces symbols with _. ``'`` and ``?`` symbols are
     ignored.
     """
     if not fluent_name:
@@ -189,6 +199,22 @@ def to_python_name(fluent_name: str) -> str:
     return name
 
 
+def to_constant_name(fluent_name: str) -> str:
+    """Convert a scheme string to a Python constant name.
+
+    This function replaces symbols and spaces with _ and converts the name to uppercase.
+    ``'`` and ``?`` symbols are ignored.
+    """
+    fluent_name = fluent_name.replace(" ", "_")
+    name = fluent_name.translate(_ttable).upper()
+    if not name:
+        return "EMPTY_STRING"
+    if name[0].isdigit():
+        # If the first character is a digit, prepend "CASE_"
+        name = "CASE_" + name
+    return name
+
+
 _to_field_name_str = naming_strategy().to_string
 
 
@@ -236,9 +262,8 @@ def _is_deprecated(obj) -> bool | None:
         deprecated_version = (
             deprecated_version.get("deprecated-version") if deprecated_version else None
         )
-    return deprecated_version and (
-        FluentVersion(float(deprecated_version)) <= FluentVersion.v222
-        or FluentVersion(obj._version) >= FluentVersion(deprecated_version)
+    return deprecated_version and FluentVersion(obj._version) >= FluentVersion(
+        deprecated_version
     )
 
 
@@ -496,6 +521,39 @@ class Base:
             return False
         return self.flproxy == other.flproxy and self.path == other.path
 
+    def get_completer_info(self, prefix="", excluded=None) -> List[List[str]]:
+        """Get completer info of all children.
+
+        Returns
+        -------
+        List[List[str]]
+            Name, type and docstring of all children.
+        """
+        excluded = excluded or []
+        ret = []
+        for k, v in inspect.getmembers(self):
+            if not k.startswith("_") and k not in excluded and k.startswith(prefix):
+                if isinstance(v, Base):
+                    if not _is_deprecated(v):
+                        ret.append(
+                            [
+                                k,
+                                _get_type_for_completer_info(v.__class__),
+                                v.__doc__,
+                            ]
+                        )
+                elif inspect.ismethod(v):
+                    ret.append(
+                        [
+                            k,
+                            "Method",
+                            v.__doc__ or "",
+                        ]
+                    )
+                else:
+                    ret.append([k, "Data", ""])
+        return ret
+
 
 StateT = TypeVar("StateT")
 
@@ -946,20 +1004,6 @@ class BooleanList(SettingsBase[BoolListType], Property):
     _state_type = BoolListType
 
 
-def _command_query_name_filter(
-    parent, list_attr: str, prefix: str, excluded: List[str]
-) -> List:
-    """Auto completer info of commands and queries."""
-    ret = []
-    names = getattr(parent, list_attr)
-    for name in names:
-        if name not in excluded and name.startswith(prefix):
-            child = getattr(parent, name)
-            if child.is_active() and not _is_deprecated(child):
-                ret.append([name, child.__class__.__bases__[0].__name__, child.__doc__])
-    return ret
-
-
 def _get_type_for_completer_info(cls) -> str:
     if issubclass(cls, (FileName, _InputFile)):
         return "InputFilename"
@@ -1097,41 +1141,14 @@ class Group(SettingsBase[DictStateType]):
             [
                 child
                 for child in self.child_names + self.command_names + self.query_names
-                if getattr(self, child).is_active()
-                and _is_deprecated(getattr(self, child))
+                if _is_deprecated(getattr(self, child))
             ]
         )
 
-    def get_completer_info(self, prefix="", excluded=None) -> List[List[str]]:
-        """Get completer info of all children.
-
-        Returns
-        -------
-        List[List[str]]
-            Name, type and docstring of all children.
-        """
-        excluded = excluded or []
-        ret = []
-        for child_name in self.child_names:
-            if child_name not in excluded and child_name.startswith(prefix):
-                child = getattr(self, child_name)
-                if child.is_active() and not _is_deprecated(child):
-                    ret.append(
-                        [
-                            child_name,
-                            _get_type_for_completer_info(child.__class__),
-                            child.__doc__,
-                        ]
-                    )
-        command_info = _command_query_name_filter(
-            self, "command_names", prefix, excluded
-        )
-        query_info = _command_query_name_filter(self, "query_names", prefix, excluded)
-        for items in [command_info, query_info]:
-            ret.extend(items)
-        return ret
-
     def __getattribute__(self, name):
+        # Avoiding server queries for static attributes
+        if name in _static_class_attributes:
+            return super().__getattribute__(name)
         if (
             name in super().__getattribute__("child_names")
             and self.is_active() is False
@@ -1153,9 +1170,7 @@ class Group(SettingsBase[DictStateType]):
             error_msg = allowed_name_error_message(
                 trial_name=name,
                 message=ex.args[0],
-                allowed_values=sorted(
-                    set(self.get_active_child_names() + self.command_names)
-                ),
+                allowed_values=sorted(set(self.child_names + self.command_names)),
             )
             ex.args = (error_msg,)
             raise
@@ -1402,24 +1417,6 @@ class NamedObject(SettingsBase[DictStateType], Generic[ChildTypeT]):
         obj_names_list = obj_names if isinstance(obj_names, list) else list(obj_names)
         return obj_names_list
 
-    def get_completer_info(self, prefix="", excluded=None) -> List[List[str]]:
-        """Get completer info of all children.
-
-        Returns
-        -------
-        List[List[str]]
-            Name, type and docstring of all children.
-        """
-        excluded = excluded or []
-        ret = []
-        command_info = _command_query_name_filter(
-            self, "command_names", prefix, excluded
-        )
-        query_info = _command_query_name_filter(self, "query_names", prefix, excluded)
-        for items in [command_info, query_info]:
-            ret.extend(items)
-        return ret
-
     def __getitem__(self, name: str) -> ChildTypeT:
         if name not in self.get_object_names():
             if self.flproxy.has_wildcard(name):
@@ -1475,7 +1472,54 @@ class NamedObject(SettingsBase[DictStateType], Generic[ChildTypeT]):
                 )
             return alias_obj
         else:
-            return getattr(super(), name)
+            try:
+                return getattr(super(), name)
+            except AttributeError as ex:
+                raise AttributeError(
+                    f"'{self.__class__.__name__}' has no attribute '{name}'"
+                ) from ex
+
+    def __add__(self, other):
+        if not isinstance(other, NamedObject):
+            raise TypeError(
+                f"Can only add NamedObject to NamedObject, not {type(other).__name__}"
+            )
+        return CombinedNamedObject([self, other])
+
+
+class CombinedNamedObject:
+    """A ``CombinedNamedObject`` contains the concatenated named-objects."""
+
+    def __init__(self, objects: list[NamedObject]):
+        """__init__ of CombinedNamedObject."""
+        self.objects = []
+        self._items = []
+        for obj in objects:
+            if isinstance(obj, CombinedNamedObject):
+                self.objects.extend(obj.objects)
+            else:
+                self.objects.append(obj)
+        for obj in self.objects:
+            self._items.extend(obj.items())
+
+    def items(self):
+        """Return items like a dictionary."""
+        return self._items
+
+    def __iter__(self):
+        for obj in self.objects:
+            yield from obj
+
+    def __add__(self, other):
+        if not isinstance(other, NamedObject):
+            raise TypeError(f"Cannot add {type(self)} to NamedObject")
+        return CombinedNamedObject(self.objects + [other])
+
+    def __call__(self):
+        temp_dict = {}
+        for obj in self.objects:
+            temp_dict.update(obj())
+        return temp_dict
 
 
 def _rename(obj: NamedObject | _Alias, new: str, old: str):
@@ -1613,11 +1657,16 @@ def _get_new_keywords(obj, *args, **kwds):
             newkwds[argName] = arg
     if kwds:
         # Convert deprecated keywords through aliases
-        # We don't get arguments-aliases from static-info yet.
-        argument_aliases_scm = obj.get_attr("arguments-aliases") or {}
-        argument_aliases = {}
-        for k, v in argument_aliases_scm.items():
-            argument_aliases[to_python_name(k)] = to_python_name(v.removeprefix("'"))
+        if FluentVersion(obj._version) >= FluentVersion.v252:
+            argument_aliases = {k: v[0] for k, v in obj._child_aliases.items()}
+        else:
+            # Arguments-aliases was not statically available before v252.
+            argument_aliases_scm = obj.get_attr("arguments-aliases") or {}
+            argument_aliases = {}
+            for k, v in argument_aliases_scm.items():
+                argument_aliases[to_python_name(k)] = to_python_name(
+                    v.removeprefix("'")
+                )
         for k, v in kwds.items():
             alias = argument_aliases.get(k)
             if alias:
@@ -1657,34 +1706,10 @@ class Action(Base):
             [
                 child
                 for child in self.argument_names
-                if getattr(self, child).is_active()
-                and _is_deprecated(getattr(self, child))
+                if _is_deprecated(getattr(self, child))
             ]
         )
 
-    def get_completer_info(self, prefix="", excluded=None) -> List[List[str]]:
-        """Get completer info of all arguments.
-
-        Returns
-        -------
-        List[List[str]]
-            Name, type and docstring of all arguments.
-        """
-        excluded = excluded or []
-        ret = []
-        for argument_name in self.argument_names:
-            if argument_name not in excluded and argument_name.startswith(prefix):
-                argument = getattr(self, argument_name)
-                if argument.is_active() and not _is_deprecated(argument):
-                    ret.append(
-                        [
-                            argument_name,
-                            _get_type_for_completer_info(argument.__class__),
-                            argument.__doc__,
-                        ]
-                    )
-        return ret
-
     def __getattr__(self, name: str):
         alias = self._child_aliases.get(name)
         if alias:
@@ -1721,12 +1746,16 @@ class BaseCommand(Action):
                         print("Please enter 'y[es]' or 'n[o]'.")
         with self._while_executing_command():
             ret = self.flproxy.execute_cmd(self._parent.path, self.obj_name, **kwds)
-            if os.getenv("PYFLUENT_NO_FIX_PARAMETER_LIST_RETURN") != "1":
-                if (self._parent.path, self.obj_name) in [
-                    ("parameters/input-parameters", "list"),
-                    ("parameters/output-parameters", "list"),
-                ]:
-                    ret = _fix_parameter_list_return(ret)
+            if (
+                os.getenv("PYFLUENT_NO_FIX_PARAMETER_LIST_RETURN") != "1"
+                and FluentVersion(self._version) <= FluentVersion.v252
+                and self.path
+                in [
+                    "parameters/input-parameters/list",
+                    "parameters/output-parameters/list",
+                ]
+            ):
+                ret = _fix_parameter_list_return(ret)
             return ret
 
     def execute_command(self, *args, **kwds):
@@ -1764,13 +1793,6 @@ class BaseCommand(Action):
                 assert_type(ret, base_t._state_type)
             return ret
 
-    def __call__(self, *args, **kwds):
-        try:
-            return self.execute_command(*args, **kwds)
-        except KeyboardInterrupt:
-            self._root._on_interrupt(self)
-            raise KeyboardInterrupt
-
 
 # TODO: Remove this after parameter list() method is fixed from Fluent side
 def _fix_parameter_list_return(val):
@@ -1807,6 +1829,8 @@ class Command(BaseCommand):
 
     def __call__(self, **kwds):
         """Call a command with the specified keyword arguments."""
+        if not self.is_active():
+            raise InactiveObjectError(self.python_path)
         try:
             return self.execute_command(**kwds)
         except KeyboardInterrupt:
@@ -1819,6 +1843,8 @@ class CommandWithPositionalArgs(BaseCommand):
 
     def __call__(self, *args, **kwds):
         """Call a command with the specified positional and keyword arguments."""
+        if not self.is_active():
+            raise InactiveObjectError(self.python_path)
         try:
             return self.execute_command(*args, **kwds)
         except KeyboardInterrupt:
@@ -1831,6 +1857,8 @@ class Query(Action):
 
     def __call__(self, **kwds):
         """Call a query with the specified keyword arguments."""
+        if not self.is_active():
+            raise InactiveObjectError(self.python_path)
         kwds = _get_new_keywords(self, **kwds)
         scmKwds = {}
         for arg, value in kwds.items():
@@ -2027,6 +2055,33 @@ class AllowedValuesMixin:
             return []
 
 
+class _MaybeActiveString(str):
+    """A string class with an is_active() method."""
+
+    def __new__(cls, value, is_active: Callable[[], bool]):
+        return super().__new__(cls, value)
+
+    def __init__(self, value, is_active: Callable[[], bool]):
+        super().__init__()
+        self.is_active = is_active
+
+
+class _FlStringConstant:
+    """A descriptor class to hold a constant string value."""
+
+    def __init__(self, value):
+        self._value = value
+
+    def __get__(self, instance, owner):
+        def is_active():
+            return self._value in instance.allowed_values()
+
+        return _MaybeActiveString(self._value, is_active=is_active)
+
+    def __set__(self, instance, value):
+        raise AttributeError("Cannot set a constant value.")
+
+
 _bases_by_class = {}
 
 
@@ -2111,8 +2166,11 @@ def get_cls(name, info, parent=None, version=None, parent_taboo=None):
         dct["_child_classes"] = {}
         cls = type(pname, bases, dct)
 
-        deprecated_version = info.get("deprecated_version", "")
-        cls._deprecated_version = deprecated_version
+        deprecated_version = info.get("deprecated_version", None)
+        if deprecated_version and float(deprecated_version) >= 22.2:
+            cls._deprecated_version = deprecated_version
+        else:
+            cls._deprecated_version = ""
 
         taboo = set(dir(cls))
         taboo |= set(
@@ -2156,7 +2214,6 @@ def get_cls(name, info, parent=None, version=None, parent_taboo=None):
         commands = info.get("commands")
         if commands:
             commands.pop("exit", None)
-            commands.pop("switch-to-meshing-mode", None)
         if commands and not user_creatable:
             commands.pop("create", None)
         if commands:
@@ -2195,14 +2252,14 @@ def get_cls(name, info, parent=None, version=None, parent_taboo=None):
         child_aliases = info.get("child-aliases") or info.get("child_aliases", {})
         command_aliases = info.get("command-aliases") or info.get("command_aliases", {})
         query_aliases = info.get("query-aliases") or info.get("query_aliases", {})
-        argument_aliases = info.get("arguments-aliases") or info.get(
+        arguments_aliases = info.get("arguments-aliases") or info.get(
             "arguments_aliases", {}
         )
-        if child_aliases or command_aliases or query_aliases or argument_aliases:
+        if child_aliases or command_aliases or query_aliases or arguments_aliases:
             cls._child_aliases = {}
             # No need to differentiate in the Python implementation
             for k, v in (
-                child_aliases | command_aliases | query_aliases | argument_aliases
+                child_aliases | command_aliases | query_aliases | arguments_aliases
             ).items():
                 # Storing the original name as we don't have any other way
                 # to recover it at runtime.
@@ -2213,6 +2270,16 @@ def get_cls(name, info, parent=None, version=None, parent_taboo=None):
                     k,
                 )
 
+        allowed_values = info.get("allowed-values") or info.get("allowed_values", [])
+        if allowed_values:
+            for allowed_value in allowed_values:
+                setattr(
+                    cls,
+                    to_constant_name(allowed_value),
+                    _FlStringConstant(allowed_value),
+                )
+            cls._allowed_values = allowed_values
+
     except Exception:
         print(
             f"Unable to construct class for '{name}' of "

ansys/fluent/core/solver/function/reduction.py

@@ -74,16 +74,35 @@ Examples
 >>> vsquared.definition = "VelocityMagnitude ** 2"
 >>> reduction.minimum(
 ...     expr = vsquared,
-...     locations = [
-...         solver1.setup.boundary_conditions.pressure_outlet,
-...         solver2.setup.boundary_conditions.pressure_outlet
-...     ])
+...     locations = solver1.setup.boundary_conditions.pressure_outlet
+...     + solver2.setup.boundary_conditions.pressure_outlet
+...     )
 19.28151
 """
+from collections.abc import Iterable
+from enum import Enum
 
 import numpy as np
 from numpy import array
 
+from ansys.fluent.core.exceptions import DisallowedValuesError
+from ansys.fluent.core.variable_strategies import (
+    FluentExprNamingStrategy as naming_strategy,
+)
+
+
+class Weight(Enum):
+    """Weight for sum."""
+
+    AREA = "Area"
+    VOLUME = "Volume"
+    MASS = "Mass"
+    MASS_FLOW_RATE = "MassFlowRate"
+    ABS_MASS_FLOW_RATE = "AbsMassFlowRate"
+
+    def __str__(self):
+        return self.value
+
 
 class BadReductionRequest(Exception):
     """Raised on an attempt to make a bad reduction request."""
@@ -117,7 +136,12 @@ def _locn_name_and_obj(locn, locns):
 def _locn_names_and_objs(locns):
     if _is_iterable(locns):
         names_and_objs = []
+        if locns.__class__.__name__ == "CombinedNamedObject":
+            return locns.items()
+
         for locn in locns:
+            if isinstance(locn, Iterable) and not isinstance(locn, (str, bytes)):
+                raise DisallowedValuesError("location", locn, list(locn))
             name_and_obj = _locn_name_and_obj(locn, locns)
             if _is_iterable(name_and_obj):
                 if isinstance(name_and_obj[0], str):
@@ -187,7 +211,7 @@ def _eval_reduction(
         weight = "Weight=" + str(weight)
         locations = str(locations) + ", " + weight
 
-    expr_str = _expr_to_expr_str(expr)
+    expr_str = _expr_to_expr_str(naming_strategy().to_string(expr))
     if condition:
         expr_str = expr_str + ", " + condition
     return _eval_expr(
@@ -291,6 +315,10 @@ def _limit(limit, expr, locations, ctxt):
     return limit_val
 
 
+# Weight for sum
+weight = Weight
+
+
 def area_average(expression, locations, ctxt=None):
     """Compute the area averaged value of the specified expression over the specified
     locations.
@@ -579,14 +607,14 @@ def mass_flow(locations, ctxt=None):
     return _extent("MassFlow", locations, ctxt)
 
 
-def sum(expression, locations, weight, ctxt=None):
+def sum(expression, locations, weight: str | Weight, ctxt=None):
     """Compute the sum of the specified expression over the specified locations.
 
     Parameters
     ----------
     expression : Any
     locations : Any
-    weight: str
+    weight: str | Weight
     ctxt : Any, optional
     Returns
     -------
@@ -595,7 +623,7 @@ def sum(expression, locations, weight, ctxt=None):
     return _extent_expression("Sum", "Sum", expression, locations, ctxt, weight=weight)
 
 
-def sum_if(expression, condition, locations, weight, ctxt=None):
+def sum_if(expression, condition, locations, weight: str | Weight, ctxt=None):
     """Compute the sum of the specified expression over the specified locations if a
     condition is satisfied.
 
@@ -604,7 +632,7 @@ def sum_if(expression, condition, locations, weight, ctxt=None):
     expression : Any
     condition: str
     locations : Any
-    weight: str
+    weight: str | Weight
     ctxt : Any, optional
     Returns
     -------

ansys/fluent/core/solver/settings_builtin_data.py

@@ -729,23 +729,25 @@ DATA = {
     "ReadData": ("Command", "file.read_data"),
     "ReadCaseData": ("Command", "file.read_case_data"),
     "WriteCase": (
-        "Singleton",
+        "Command",
         {
             since(FluentVersion.v241): "file.write_case",
         },
     ),
     "WriteData": (
-        "Singleton",
+        "Command",
         {
             since(FluentVersion.v241): "file.write_data",
         },
     ),
     "WriteCaseData": (
-        "Singleton",
+        "Command",
         {
             since(FluentVersion.v241): "file.write_case_data",
         },
     ),
     "Initialize": ("Command", "solution.initialization.initialize"),
     "Calculate": ("Command", "solution.run_calculation.calculate"),
+    "Iterate": ("Command", "solution.run_calculation.iterate"),
+    "DualTimeIterate": ("Command", "solution.run_calculation.dual_time_iterate"),
 }

ansys/fluent/core/utils/fluent_version.py

@@ -201,9 +201,7 @@ class FluentVersion(Enum):
 
     def __str__(self) -> str:
         """String output for the Fluent version."""
-        return (
-            f"Fluent version 20{self.value.split('.')[0]} R{self.value.split('.')[1]}"
-        )
+        return f"Ansys Fluent 20{self.value.split('.')[0]} R{self.value.split('.')[1]}"
 
 
 class FluentVersionSet(Set[FluentVersion]):

ansys/fluent/core/utils/networking.py

@@ -81,14 +81,24 @@ def find_remoting_ip() -> str:
     """
     from ansys.fluent.core import INFER_REMOTING_IP_TIMEOUT_PER_IP
 
-    for addrinfo in socket.getaddrinfo(
-        "localhost",
-        0,
-        family=socket.AF_INET,
-        type=socket.SOCK_STREAM,
-        flags=socket.AI_PASSIVE,
-    ):
-        ip = addrinfo[-1][0]
+    all_ips = [
+        addrinfo[-1][0]
+        for addrinfo in socket.getaddrinfo(
+            "localhost",
+            0,
+            family=socket.AF_INET,
+            type=socket.SOCK_STREAM,
+            flags=socket.AI_PASSIVE,
+        )
+    ]
+    # Check if we can establish a gRPC connection using localhost first
+    # before trying other IPs. It has been observed that in some systems,
+    # although we can establish a test gRPC connection using one of the
+    # resolved IP addresses in addrinfo, PyFluent fails to connect to Fluent
+    # using that IP address. Using localhost usually helps in such cases.
+    all_ips.insert(0, "localhost")
+
+    for ip in all_ips:
         port = get_free_port()
         address = f"{ip}:{port}"
         with _GrpcServer(address):