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

ansys/fluent/core/session_pure_meshing.py

@@ -14,6 +14,7 @@ from ansys.fluent.core.session import BaseSession
 from ansys.fluent.core.session_base_meshing import BaseMeshing
 from ansys.fluent.core.streaming_services.datamodel_streaming import DatamodelStream
 from ansys.fluent.core.utils.data_transfer import transfer_case
+from ansys.fluent.core.utils.fluent_version import FluentVersion
 
 
 class PureMeshing(BaseSession):
@@ -26,17 +27,6 @@ class PureMeshing(BaseSession):
     in this mode.
     """
 
-    rules = [
-        "workflow",
-        "meshing",
-        "MeshingUtilities",
-        "PartManagement",
-        "PMFileManagement",
-    ]
-
-    for r in rules:
-        DataModelCache.set_config(r, "name_key", NameKey.INTERNAL)
-
     def __init__(
         self,
         fluent_connection: FluentConnection,
@@ -55,26 +45,26 @@ class PureMeshing(BaseSession):
         self._base_meshing = BaseMeshing(
             self.execute_tui,
             fluent_connection,
-            self.get_fluent_version(),
+            self.get_fluent_version().value,
             self.datamodel_service_tui,
             self.datamodel_service_se,
         )
 
         self.meshing_queries_service = fluent_connection.create_grpc_service(
-            MeshingQueriesService, self.error_state
+            MeshingQueriesService, self._error_state
         )
 
         datamodel_service_se = self.datamodel_service_se
         self.datamodel_streams = {}
         if pyfluent.DATAMODEL_USE_STATE_CACHE:
-            for rules in self.__class__.rules:
+            for _rules in rules:
                 stream = DatamodelStream(datamodel_service_se)
                 stream.register_callback(
-                    functools.partial(DataModelCache.update_cache, rules=rules)
+                    functools.partial(DataModelCache.update_cache, rules=_rules)
                 )
-                self.datamodel_streams[rules] = stream
+                self.datamodel_streams[_rules] = stream
                 stream.start(
-                    rules=rules,
+                    rules=_rules,
                     no_commands_diff_state=pyfluent.DATAMODEL_USE_NOCOMMANDS_DIFF_STATE,
                 )
                 self.fluent_connection.register_finalizer_cb(stream.stop)
@@ -93,13 +83,13 @@ class PureMeshing(BaseSession):
     @property
     def meshing_queries(self):
         """Datamodel root of meshing_queries."""
-        if float(self.get_fluent_version()[:-2]) >= 23.2:
+        if self.get_fluent_version() >= FluentVersion.v232:
             return MeshingQueries(self.meshing_queries_service)
 
     @property
     def meshing_utilities(self):
         """Datamodel root of meshing_utilities."""
-        if self.get_fluent_version() >= "24.2.0":
+        if self.get_fluent_version() >= FluentVersion.v242:
             return self._base_meshing.meshing_utilities
 
     @property
@@ -172,3 +162,15 @@ class PureMeshing(BaseSession):
             clean_up_mesh_file,
             overwrite_previous,
         )
+
+
+rules = [
+    "workflow",
+    "meshing",
+    "MeshingUtilities",
+    "PartManagement",
+    "PMFileManagement",
+]
+
+for r in rules:
+    DataModelCache.set_config(r, "name_key", NameKey.INTERNAL)

ansys/fluent/core/session_shared.py

@@ -1,3 +1,5 @@
+"""Provides a module for codegen messages."""
+
 _CODEGEN_MSG_DATAMODEL = (
     "Currently calling the datamodel API in a generic manner. "
     "Please run `python codegen/allapigen.py` from the top-level pyfluent "

ansys/fluent/core/session_solver.py

@@ -93,7 +93,7 @@ class Solver(BaseSession):
     def _build_from_fluent_connection(self, fluent_connection):
         self._tui_service = self.datamodel_service_tui
         self._se_service = self.datamodel_service_se
-        self._settings_service = self.settings_service
+        self._settings_service = self._settings_service
         self._tui = None
         self._workflow = None
         self._system_coupling = None
@@ -103,49 +103,58 @@ class Solver(BaseSession):
         self._solution_variable_service = service_creator("svar").create(
             fluent_connection._channel, fluent_connection._metadata
         )
-        self.solution_variable_info = SolutionVariableInfo(
+        self.fields.solution_variable_info = SolutionVariableInfo(
             self._solution_variable_service
         )
         self._reduction_service = self.fluent_connection.create_grpc_service(
-            ReductionService, self.error_state
+            ReductionService, self._error_state
         )
         if FluentVersion(self._version) >= FluentVersion.v241:
-            self.reduction = service_creator("reduction").create(
+            self.fields.reduction = service_creator("reduction").create(
                 self._reduction_service, self
             )
         else:
-            self.reduction = reduction_old
+            self.fields.reduction = reduction_old
         self._settings_api_root = None
+        self.fields.solution_variable_data = self._solution_variable_data()
 
     def build_from_fluent_connection(self, fluent_connection):
         """Build a solver session object from fluent_connection object."""
         super(Solver, self).build_from_fluent_connection(fluent_connection)
         self._build_from_fluent_connection(fluent_connection)
 
-    @property
-    def solution_variable_data(self) -> SolutionVariableData:
+    def _solution_variable_data(self) -> SolutionVariableData:
         """Return the SolutionVariableData handle."""
         return service_creator("svar_data").create(
-            self._solution_variable_service, self.solution_variable_info
+            self._solution_variable_service, self.fields.solution_variable_info
         )
 
     @property
     def svar_data(self):
-        """Return the SolutionVariableData handle."""
+        """``SolutionVariableData`` handle."""
         warnings.warn(
-            "svar_data is deprecated, use solution_variable_data instead",
+            "svar_data is deprecated. Use fields.solution_variable_data instead.",
             DeprecationWarning,
         )
-        return self.solution_variable_data
+        return self.fields.solution_variable_data
 
     @property
     def svar_info(self):
-        """Return the SolutionVariableInfo handle."""
+        """``SolutionVariableInfo`` handle."""
         warnings.warn(
-            "svar_info is deprecated, use solution_variable_info instead",
+            "svar_info is deprecated. Use fields.solution_variable_info instead.",
             DeprecationWarning,
         )
-        return self.solution_variable_info
+        return self.fields.solution_variable_info
+
+    @property
+    def reduction(self):
+        """``Reduction`` handle."""
+        warnings.warn(
+            "reduction is deprecated. Use fields.reduction instead.",
+            DeprecationWarning,
+        )
+        return self.fields.reduction
 
     @property
     def _version(self):
@@ -192,7 +201,7 @@ class Solver(BaseSession):
         return self._workflow
 
     @property
-    def _root(self):
+    def settings(self):
         """Root settings object."""
         if self._settings_root is None:
             self._settings_root = flobject.get_root(
@@ -205,6 +214,7 @@ class Solver(BaseSession):
 
     @property
     def system_coupling(self):
+        """System coupling object."""
         if self._system_coupling is None:
             self._system_coupling = SystemCoupling(self)
         return self._system_coupling
@@ -222,10 +232,10 @@ class Solver(BaseSession):
                 fut_session = fut.result()
             except Exception as ex:
                 raise RuntimeError("Unable to read mesh") from ex
-            state = self._root.get_state()
+            state = self.settings.get_state()
             self.build_from_fluent_connection(fut_session.fluent_connection)
             # TODO temporary fix till set_state at settings root is fixed
-            _set_state_safe(self._root, state)
+            _set_state_safe(self.settings, state)
 
     def read_case_lightweight(self, file_name: str):
         """Read a case file using light IO mode.
@@ -246,18 +256,18 @@ class Solver(BaseSession):
 
     def get_state(self) -> StateT:
         """Get the state of the object."""
-        return self._root.get_state()
+        return self.settings.get_state()
 
     def set_state(self, state: Optional[StateT] = None, **kwargs):
         """Set the state of the object."""
-        self._root.set_state(state, **kwargs)
+        self.settings.set_state(state, **kwargs)
 
     def __call__(self):
         return self.get_state()
 
     def _populate_settings_api_root(self):
         if not self._settings_api_root:
-            self._settings_api_root = _import_settings_root(self._root)
+            self._settings_api_root = _import_settings_root(self.settings)
 
     def __getattr__(self, attr):
         self._populate_settings_api_root()
@@ -265,10 +275,14 @@ class Solver(BaseSession):
 
     def __dir__(self):
         self._populate_settings_api_root()
-        return sorted(
-            set(
-                list(self.__dict__.keys())
-                + dir(type(self))
-                + dir(self._settings_api_root)
-            )
-        )
+        dir_list = set(
+            list(self.__dict__.keys()) + dir(type(self)) + dir(self._settings_api_root)
+        ) - {
+            "svar_data",
+            "svar_info",
+            "reduction",
+            "field_data",
+            "field_info",
+            "field_data_streaming",
+        }
+        return sorted(dir_list)

ansys/fluent/core/solver/error_message.py

@@ -1,3 +1,5 @@
+"""Provides a module to customize exception messages."""
+
 import difflib
 from functools import partial
 from typing import Any, List, Optional
@@ -35,6 +37,7 @@ def allowed_name_error_message(
 def allowed_values_error(
     context: str, trial_name: str, allowed_values: List[str]
 ) -> ValueError:
+    """Provide an error message for disallowed values."""
     return ValueError(
         allowed_name_error_message(
             context=context, trial_name=trial_name, allowed_values=allowed_values

ansys/fluent/core/solver/flobject.py

@@ -1,5 +1,3 @@
-from __future__ import annotations
-
 """Module for accessing and modifying hierarchy of Fluent settings.
 
 The only useful method is '`get_root``, which returns the root object for
@@ -18,6 +16,8 @@ Example
 >>> r.boundary_conditions.velocity_inlet['inlet'].vmag.constant = 20
 """
 
+from __future__ import annotations
+
 import collections
 from contextlib import contextmanager, nullcontext
 import fnmatch
@@ -69,6 +69,7 @@ class InactiveObjectError(RuntimeError):
 
 class _InlineConstants:
     is_active = "active?"
+    is_stable = "webui-release-active?"
     is_read_only = "read-only?"
     default_value = "default"
     min = "min"
@@ -101,6 +102,7 @@ StateType = Union[PrimitiveStateType, DictStateType, ListStateType]
 
 
 def check_type(val, tp):
+    """Check type of object."""
     if hasattr(tp, "__supertype__"):
         return check_type(val, tp.__supertype__)
     if isinstance(tp, ForwardRef):
@@ -131,6 +133,13 @@ def check_type(val, tp):
 
 
 def assert_type(val, tp):
+    """Assert type.
+
+    Raises
+    ------
+    TypeError
+        If the given value is not of the given type.
+    """
     if not check_type(val, tp):
         raise TypeError(f"{val} is not of type {tp}.")
 
@@ -181,7 +190,7 @@ class Base:
         """Set flproxy object."""
         self._setattr("_flproxy", flproxy)
 
-    def set_file_transfer_service(self, file_transfer_service):
+    def _set_file_transfer_service(self, file_transfer_service):
         """Set file_transfer_service."""
         self._setattr("_file_transfer_service", file_transfer_service)
 
@@ -319,6 +328,21 @@ class Base:
         attr = self.get_attr(_InlineConstants.is_active)
         return False if attr is False else True
 
+    def _is_stable(self) -> bool:
+        """Whether the object is stable."""
+        if self.is_active():
+            attr = self.get_attr(_InlineConstants.is_stable)
+        else:
+            attr = True
+        attr = False if attr is False else True
+        if attr is False:
+            warnings.warn(
+                f"The API feature at {self.path} is not stable. "
+                f"It is not guaranteed that it is fully validated and "
+                f"there is no commitment to its backwards compatibility."
+            )
+        return attr
+
     def is_read_only(self) -> bool:
         """Whether the object is read-only."""
         attr = self.get_attr(_InlineConstants.is_read_only)
@@ -333,6 +357,7 @@ class Base:
         super().__setattr__(name, value)
 
     def find_object(self, relative_path):
+        """Find object."""
         obj = self
         for comp in relative_path.split("/"):
             if comp == "..":
@@ -342,29 +367,37 @@ class Base:
         return obj
 
     def before_execute(self, value):
+        """Executes before command execution."""
         if hasattr(self, "_do_before_execute"):
             self._do_before_execute(value)
 
     def after_execute(self, value):
+        """Executes after command execution."""
         if hasattr(self, "_do_after_execute"):
             self._do_after_execute(value)
 
-    def while_setting_state(self):
+    def _while_setting_state(self):
+        """Avoid additional processing while setting the state."""
         return nullcontext()
 
-    def while_renaming(self):
+    def _while_renaming(self):
+        """Avoid additional processing while renaming."""
         return nullcontext()
 
-    def while_deleting(self):
+    def _while_deleting(self):
+        """Avoid additional processing while deleting."""
         return nullcontext()
 
-    def while_creating(self):
+    def _while_creating(self):
+        """Avoid additional processing while creating."""
         return nullcontext()
 
-    def while_resizing(self):
+    def _while_resizing(self):
+        """Avoid additional processing while resizing."""
         return nullcontext()
 
-    def while_executing_command(self):
+    def _while_executing_command(self):
+        """Avoid additional processing while executing a command."""
         return nullcontext()
 
 
@@ -437,6 +470,8 @@ class RealNumerical(Numerical):
         state
             The type of state can be float, str (representing either
             an expression or a value with units), or an ansys.units.Quantity.
+        kwargs : Any
+            Keyword arguments.
 
         Raises
         ------
@@ -478,7 +513,9 @@ class Textual(Property):
     """Exposes attribute accessor on settings object - specific to string objects."""
 
 
-class DeprecatedSettingWarning(DeprecationWarning):
+class DeprecatedSettingWarning(FutureWarning):
+    """Provides deprecated settings warning."""
+
     pass
 
 
@@ -493,7 +530,6 @@ def _show_warning(message, category, *args, **kwargs):
 
 
 warnings.showwarning = _show_warning
-warnings.simplefilter("default", category=DeprecatedSettingWarning)
 
 
 class _Alias:
@@ -528,22 +564,22 @@ class _Alias:
                     )
                     _Alias.once = True
 
-    def while_setting_state(self):
+    def _while_setting_state(self):
         return self._print_newer_api()
 
-    def while_renaming(self):
+    def _while_renaming(self):
         return self._print_newer_api()
 
-    def while_deleting(self):
+    def _while_deleting(self):
         return self._print_newer_api()
 
-    def while_creating(self):
+    def _while_creating(self):
         return self._print_newer_api()
 
-    def while_resizing(self):
+    def _while_resizing(self):
         return self._print_newer_api()
 
-    def while_executing_command(self):
+    def _while_executing_command(self):
         return self._print_newer_api()
 
 
@@ -597,7 +633,14 @@ class SettingsBase(Base, Generic[StateT]):
         return self.to_python_keys(self.flproxy.get_var(self.path))
 
     @classmethod
-    def unalias(cls, value):
+    def _unalias(cls, value):
+        """Unalias the given value.
+
+        Raises
+        ------
+        NotImplementedError
+            If '..' is present in the alias path.
+        """
         if isinstance(value, collections.abc.Mapping):
             ret = {}
             for k, v in value.items():
@@ -615,29 +658,29 @@ class SettingsBase(Base, Generic[StateT]):
                     for i, comp in enumerate(comps):
                         cls = cls._child_classes[comp]
                         if i == len(comps) - 1:
-                            ret_alias[comp] = cls.unalias(v)
+                            ret_alias[comp] = cls._unalias(v)
                         else:
                             ret_alias[comp] = {}
                             ret_alias = ret_alias[comp]
                 else:
                     if issubclass(cls, Group):
                         ccls = cls._child_classes[k]
-                        ret[k] = ccls.unalias(v)
+                        ret[k] = ccls._unalias(v)
                     else:
-                        ret[k] = cls.unalias(v)
+                        ret[k] = cls._unalias(v)
             return ret
         else:
             return value
 
     def set_state(self, state: Optional[StateT] = None, **kwargs):
         """Set the state of the object."""
-        with self.while_setting_state():
+        with self._while_setting_state():
             if isinstance(state, (tuple, ansys_units.Quantity)) and hasattr(
                 self, "value"
             ):
                 self.value.set_state(state, **kwargs)
             else:
-                state = self.unalias(kwargs or state)
+                state = self._unalias(kwargs or state)
                 return self.flproxy.set_var(self.path, self.to_scheme_keys(state))
 
     @staticmethod
@@ -738,6 +781,8 @@ class FilenameList(SettingsBase[StringListType], Textual):
 
 
 class FileName(Base):
+    """Resolves MRO for child classes."""
+
     pass
 
 
@@ -851,10 +896,15 @@ class Group(SettingsBase[DictStateType]):
         else:
             return self.get_state()
 
-    # pylint: disable=missing-raises-doc
     @classmethod
     def to_scheme_keys(cls, value):
-        """Convert value to have keys with scheme names."""
+        """Convert value to have keys with scheme names.
+
+        Raises
+        ------
+        RuntimeError
+            If key is invalid.
+        """
         if isinstance(value, collections.abc.Mapping):
             ret = {}
             for k, v in value.items():
@@ -1122,6 +1172,13 @@ class NamedObject(SettingsBase[DictStateType], Generic[ChildTypeT]):
         for query in self.query_names:
             cls = self.__class__._child_classes[query]
             self._setattr(query, _create_child(cls, None, self))
+        if not hasattr(
+            self, "rename"
+        ):  # if rename command is not available from settings API
+            self._setattr(
+                "rename",
+                types.MethodType(lambda obj, new, old: _rename(obj, new, old), self),
+            )
 
     @classmethod
     def to_scheme_keys(cls, value):
@@ -1172,7 +1229,7 @@ class NamedObject(SettingsBase[DictStateType], Generic[ChildTypeT]):
                 self._create_child_object(name)
 
     def __delitem__(self, name: str):
-        with self.while_deleting():
+        with self._while_deleting():
             self.flproxy.delete(self.path, name)
         if name in self._objects:
             del self._objects[name]
@@ -1282,7 +1339,7 @@ def _rename(obj: Union[NamedObject, _Alias], new: str, old: str):
     old : str
         Current name.
     """
-    with obj.while_renaming():
+    with obj._while_renaming():
         obj.flproxy.rename(obj.path, new, old)
     if old in obj._objects:
         del obj._objects[old]
@@ -1468,7 +1525,10 @@ class Action(Base):
 
 
 class BaseCommand(Action):
+    """Executes command."""
+
     def execute_command(self, *args, **kwds):
+        """Execute command."""
         for arg, value in kwds.items():
             argument = getattr(self, arg)
             argument.before_execute(value)
@@ -1506,7 +1566,7 @@ class Command(BaseCommand):
                         print("Enter y[es]/n[o]")
                 if response in ["n", "N", "no"]:
                     return
-        with self.while_executing_command():
+        with self._while_executing_command():
             return self.flproxy.execute_cmd(self._parent.path, self.obj_name, **newkwds)
 
     def __call__(self, **kwds):
@@ -1533,7 +1593,7 @@ class CommandWithPositionalArgs(BaseCommand):
                         print("Enter y[es]/n[o]")
                 if response in ["n", "N", "no"]:
                     return
-        with self.while_executing_command():
+        with self._while_executing_command():
             return self.flproxy.execute_cmd(self._parent.path, self.obj_name, **newkwds)
 
     def __call__(self, *args, **kwds):
@@ -1653,13 +1713,13 @@ class _CreatableNamedObjectMixin(collections.abc.MutableMapping, Generic[ChildTy
         Object
             Object that has been created.
         """
-        with self.while_creating():
+        with self._while_creating():
             self.flproxy.create(self.path, name)
         return self._create_child_object(name)
 
     def __setitem__(self, name: str, value):
         if name not in self.get_object_names():
-            with self.while_creating():
+            with self._while_creating():
                 self.flproxy.create(self.path, name)
         child = self._objects.get(name)
         if not child:
@@ -1869,7 +1929,6 @@ def _gethash(obj_info):
     return dhash.hexdigest()
 
 
-# pylint: disable=missing-raises-doc
 def get_root(
     flproxy,
     version: str = "",
@@ -1882,6 +1941,17 @@ def get_root(
     ----------
     flproxy: Proxy
         Object that interfaces with the Fluent backend.
+    file_transfer_service : optional
+        File transfer service. Uploads/downloads files to/from the server.
+    scheme_eval : Any
+        A gRPC service to execute Scheme code.
+    version : str
+        Fluent version.
+
+    Raises
+    ------
+    RuntimeError
+        If hash values are inconsistent.
 
     Returns
     -------
@@ -1905,7 +1975,7 @@ def get_root(
         cls, _ = get_cls("", obj_info, version=version)
     root = cls()
     root.set_flproxy(flproxy)
-    root.set_file_transfer_service(file_transfer_service)
+    root._set_file_transfer_service(file_transfer_service)
     _Alias.scheme_eval = scheme_eval
     root._setattr("_static_info", obj_info)
     root._setattr("_file_transfer_service", file_transfer_service)

ansys/fluent/core/solver/flunits.py

@@ -1,5 +1,3 @@
-from __future__ import annotations
-
 """Module for accessing Fluent units labels per quantity type.
 
 Example
@@ -103,6 +101,8 @@ Unhandled:
  'wave-length': 'Angstrom'}
 """
 
+from __future__ import annotations
+
 from typing import Optional
 
 _fl_unit_table = {
@@ -219,6 +219,8 @@ _fl_unit_table = {
 
 
 class InvalidQuantityType(TypeError):
+    """Raised on an attempt to get a Quantity with invalid type."""
+
     def __init__(
         self,
         quantity,
@@ -229,6 +231,8 @@ class InvalidQuantityType(TypeError):
 
 
 class UnitsNotDefinedForQuantity(ValueError):
+    """Raised on an attempt to get undefined units for the specified Quantity."""
+
     def __init__(
         self,
         quantity: str,
@@ -239,6 +243,8 @@ class UnitsNotDefinedForQuantity(ValueError):
 
 
 class UnhandledQuantity(RuntimeError):
+    """Raised on an attempt to get an unhandled Quantity."""
+
     def __init__(
         self,
         path: str,