ansys-fluent-core 0.30.dev1__py3-none-any.whl → 0.30.dev3__py3-none-any.whl

ansys/fluent/core/services/datamodel_se.py

@@ -1016,7 +1016,7 @@ class PyStateContainer(PyCallableStateObject):
                 service=service,
                 rules=rules,
                 path=[] if path is None else path,
-                cached_attrs={},
+                _cached_attrs={},
             )
         )
 
@@ -1071,15 +1071,15 @@ class PyStateContainer(PyCallableStateObject):
         )
 
     def _get_cached_attr(self, attrib: str) -> Any:
-        cached_val = self.cached_attrs.get(attrib)
+        cached_val = self._cached_attrs.get(attrib)
         if cached_val is None:
             cached_val = self._get_remote_attr(attrib)
             try:  # will fail for Fluent 23.1 or before
                 self.add_on_attribute_changed(
                     attrib,
-                    functools.partial(dict.__setitem__, self.cached_attrs, attrib),
+                    functools.partial(dict.__setitem__, self._cached_attrs, attrib),
                 )
-                self.cached_attrs[attrib] = cached_val
+                self._cached_attrs[attrib] = cached_val
             except Exception:
                 pass
         return cached_val
@@ -1885,42 +1885,47 @@ class PyCommand:
         else:
             self.path = path
         self._static_info = None  # command's static info
+        self.file_behavior = None
+
+    def _update_file_behavior(self, file_purpose):
+        purpose_to_class = {
+            "input": _InputFile,
+            "output": _OutputFile,
+            "inout": _InOutFile,
+        }
+
+        if file_purpose:
+            if file_purpose in purpose_to_class:
+                file_class = purpose_to_class[file_purpose]
+                self.file_behavior = file_class()
+                setattr(self.file_behavior, "service", self.service)
+            else:
+                raise DisallowedFilePurpose(
+                    "File purpose", file_purpose, ["input", "output", "inout"]
+                )
 
     def _get_file_purpose(self, arg):
         try:
             cmd_instance = self.create_instance()
             arg_instance = getattr(cmd_instance, arg)
             file_purpose = arg_instance.get_attr("filePurpose")
-            if file_purpose:
-                if file_purpose == "input":
-                    if _InputFile not in self.__class__.__bases__:
-                        self.__class__.__bases__ += (_InputFile,)
-                elif file_purpose == "output":
-                    if _OutputFile not in self.__class__.__bases__:
-                        self.__class__.__bases__ += (_OutputFile,)
-                elif file_purpose == "inout":
-                    if _InOutFile not in self.__class__.__bases__:
-                        self.__class__.__bases__ += (_InOutFile,)
-                else:
-                    raise DisallowedFilePurpose(
-                        "File purpose", file_purpose, ["input", "output", "inout"]
-                    )
             del cmd_instance, arg_instance
+            self._update_file_behavior(file_purpose)
             return file_purpose if file_purpose else None
         except AttributeError:
             pass
 
     def before_execute(self, value):
         """Executes before command execution."""
-        if hasattr(self, "_do_before_execute"):
-            return self._do_before_execute(value)
+        if hasattr(self.file_behavior, "_do_before_execute"):
+            return self.file_behavior._do_before_execute(value)
         else:
             return value
 
     def after_execute(self, value):
         """Executes after command execution."""
-        if hasattr(self, "_do_after_execute"):
-            self._do_after_execute(value)
+        if hasattr(self.file_behavior, "_do_after_execute"):
+            self.file_behavior._do_after_execute(value)
 
     def __call__(self, *args, **kwds) -> Any:
         """Execute the command.
@@ -2302,7 +2307,7 @@ class DataModelType(Enum):
 class PyMenuGeneric(PyMenu):
     """Generic PyMenu class for when generated API code is not available."""
 
-    attrs = ("service", "rules", "path", "cached_attrs")
+    attrs = ("service", "rules", "path", "_cached_attrs")
 
     def _get_child_names(self) -> tuple[list, list, list, list]:
         response = self.service.get_specs(

ansys/fluent/core/services/field_data.py

@@ -334,11 +334,19 @@ class _AllowedSurfaceNames(_AllowedNames):
 
         Raises
         ------
+        RuntimeError
+            If issue in retrieving surface list.
         DisallowedValuesError
             If surface name is invalid.
         """
-        if validate_inputs and not self.is_valid(surface_name):
-            raise DisallowedValuesError("surface", surface_name, self())
+        try:
+            valid_names = self()  # Fetch once, upfront
+        except Exception as e:
+            raise RuntimeError("Failed to retrieve valid surface names.") from e
+
+        if validate_inputs and surface_name not in valid_names:
+            raise DisallowedValuesError("surface", surface_name, valid_names)
+
         return surface_name
 
 
@@ -726,7 +734,7 @@ class FieldTransaction:
             [
                 FieldDataProtoModule.PathlinesFieldRequest(
                     surfaceId=surface_id,
-                    field=field_name,
+                    field=self._allowed_scalar_field_names.valid_name(field_name),
                     additionalField=additional_field_name,
                     provideParticleTimeField=provide_particle_time_field,
                     dataLocation=(
@@ -818,7 +826,11 @@ def _get_surface_ids(
                 ]
             )
         else:
-            surface_ids.append(surf)
+            allowed_surf_ids = _AllowedSurfaceIDs(field_info)()
+            if surf in allowed_surf_ids:
+                surface_ids.append(surf)
+            else:
+                raise DisallowedValuesError("surface", surf, allowed_surf_ids)
     return surface_ids
 
 
@@ -1437,7 +1449,7 @@ class FieldData:
             [
                 FieldDataProtoModule.PathlinesFieldRequest(
                     surfaceId=surface_id,
-                    field=field_name,
+                    field=self._allowed_scalar_field_names.valid_name(field_name),
                     additionalField=additional_field_name,
                     provideParticleTimeField=provide_particle_time_field,
                     dataLocation=(

ansys/fluent/core/session_base_meshing.py

@@ -118,10 +118,10 @@ class BaseMeshing:
                 from ansys.fluent.core import CODEGEN_OUTDIR
 
                 meshing_utilities_module = pyfluent.utils.load_module(
-                    f"MeshingUtilities_{self._version}",
+                    f"meshing_utilities_{self._version}",
                     CODEGEN_OUTDIR
                     / f"datamodel_{self._version}"
-                    / "MeshingUtilities.py",
+                    / "meshing_utilities.py",
                 )
                 meshing_utilities_root = meshing_utilities_module.Root(
                     self._se_service, "MeshingUtilities", []
@@ -130,7 +130,7 @@ class BaseMeshing:
             datamodel_logger.warning(_CODEGEN_MSG_DATAMODEL)
             if self.get_fluent_version() >= FluentVersion.v242:
                 meshing_utilities_root = PyMenuGeneric(
-                    self._se_service, "meshing_utilities"
+                    self._se_service, "MeshingUtilities"
                 )
         return meshing_utilities_root
 

ansys/fluent/core/session_meshing.py

@@ -64,7 +64,7 @@ class Meshing(PureMeshing):
             transcript can be subsequently started and stopped
             using method calls on the ``Session`` object.
         """
-        self.switched = False
+        self._switched = False
         super(Meshing, self).__init__(
             fluent_connection=fluent_connection,
             scheme_eval=scheme_eval,
@@ -89,14 +89,14 @@ class Meshing(PureMeshing):
             scheme_eval=self.scheme_eval,
             file_transfer_service=self._file_transfer_service,
         )
-        self.switched = True
+        self._switched = True
         return solver_session
 
     def __getattribute__(self, item: str):
-        if item == "switched":
+        if item == "_switched":
             return super(Meshing, self).__getattribute__(item)
 
-        if self.switched and item != "exit":
+        if self._switched and item != "exit":
             return None
 
         return super(Meshing, self).__getattribute__(item)

ansys/fluent/core/session_meshing.pyi

@@ -20,21 +20,21 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 
-from ansys.fluent.core.generated.datamodel_242.MeshingUtilities import (
+from ansys.fluent.core.generated.datamodel_251.meshing import Root as meshing_root
+from ansys.fluent.core.generated.datamodel_251.meshing_utilities import (
     Root as meshing_utilities_root,
 )
-from ansys.fluent.core.generated.datamodel_242.PMFileManagement import (
-    Root as pmfilemanagement_root,
-)
-from ansys.fluent.core.generated.datamodel_242.PartManagement import (
+from ansys.fluent.core.generated.datamodel_251.part_management import (
     Root as partmanagement_root,
 )
-from ansys.fluent.core.generated.datamodel_242.meshing import Root as meshing_root
-from ansys.fluent.core.generated.datamodel_242.preferences import (
+from ansys.fluent.core.generated.datamodel_251.pm_file_management import (
+    Root as pmfilemanagement_root,
+)
+from ansys.fluent.core.generated.datamodel_251.preferences import (
     Root as preferences_root,
 )
-from ansys.fluent.core.generated.datamodel_242.workflow import Root as workflow_root
-from ansys.fluent.core.generated.meshing.tui_242 import main_menu
+from ansys.fluent.core.generated.datamodel_251.workflow import Root as workflow_root
+from ansys.fluent.core.generated.meshing.tui_251 import main_menu
 
 class Meshing:
     @property

ansys/fluent/core/session_pure_meshing.pyi

@@ -20,21 +20,21 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 
-from ansys.fluent.core.generated.datamodel_242.MeshingUtilities import (
+from ansys.fluent.core.generated.datamodel_251.meshing import Root as meshing_root
+from ansys.fluent.core.generated.datamodel_251.meshing_utilities import (
     Root as meshing_utilities_root,
 )
-from ansys.fluent.core.generated.datamodel_242.PMFileManagement import (
-    Root as pmfilemanagement_root,
-)
-from ansys.fluent.core.generated.datamodel_242.PartManagement import (
+from ansys.fluent.core.generated.datamodel_251.part_management import (
     Root as partmanagement_root,
 )
-from ansys.fluent.core.generated.datamodel_242.meshing import Root as meshing_root
-from ansys.fluent.core.generated.datamodel_242.preferences import (
+from ansys.fluent.core.generated.datamodel_251.pm_file_management import (
+    Root as pmfilemanagement_root,
+)
+from ansys.fluent.core.generated.datamodel_251.preferences import (
     Root as preferences_root,
 )
-from ansys.fluent.core.generated.datamodel_242.workflow import Root as workflow_root
-from ansys.fluent.core.generated.meshing.tui_242 import main_menu
+from ansys.fluent.core.generated.datamodel_251.workflow import Root as workflow_root
+from ansys.fluent.core.generated.meshing.tui_251 import main_menu
 
 class PureMeshing:
     @property

ansys/fluent/core/session_solver.py

@@ -54,7 +54,7 @@ from ansys.fluent.core.solver.flobject import (
 import ansys.fluent.core.solver.function.reduction as reduction_old
 from ansys.fluent.core.streaming_services.events_streaming import SolverEvent
 from ansys.fluent.core.streaming_services.monitor_streaming import MonitorsManager
-from ansys.fluent.core.systemcoupling import SystemCoupling
+from ansys.fluent.core.system_coupling import SystemCoupling
 from ansys.fluent.core.utils.execution import asynchronous
 from ansys.fluent.core.utils.fluent_version import (
     FluentVersion,

ansys/fluent/core/session_solver.pyi

@@ -20,13 +20,13 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 
-from ansys.fluent.core.generated.datamodel_242.preferences import (
+from ansys.fluent.core.generated.datamodel_251.preferences import (
     Root as preferences_root,
 )
-from ansys.fluent.core.generated.datamodel_242.workflow import Root as workflow_root
-import ansys.fluent.core.generated.solver.settings_242 as settings_root
-from ansys.fluent.core.generated.solver.tui_242 import main_menu
-from ansys.fluent.core.systemcoupling import SystemCoupling
+from ansys.fluent.core.generated.datamodel_251.workflow import Root as workflow_root
+import ansys.fluent.core.generated.solver.settings_251 as settings_root
+from ansys.fluent.core.generated.solver.tui_251 import main_menu
+from ansys.fluent.core.system_coupling import SystemCoupling
 
 class Solver:
     @property

ansys/fluent/core/solver/_docstrings.py

@@ -0,0 +1,244 @@
+# 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.
+
+"""Module for analyzing API docstrings."""
+
+# N.b. misspellings:
+# - selected missing last e.
+# - many known API misspellings also have corresponding
+#   misspellingling for docstring.
+# - CGSN
+
+import re
+
+_choose_words = ("Choose", "Indicate", "Select", "Specify")
+
+_remove_first_words = _choose_words + ("Enter", "Set", "To")
+
+# Define problematic patterns with exclusions
+_dubious_patterns = [
+    (r"Create an instance of this.", ()),
+    (r"Enter the adaption .* menu.", ()),
+    (r"Allows you to .*", ()),
+    (r"Select to .*", ("method",)),
+    (r"Choose .*", ("method",)),
+    (r"Enter .*", ("method",)),
+    (r"Indicate .*", ("method",)),
+    (r"Perform .*", ("method",)),
+    (r"Select .*", ("method",)),
+    (r"Set .*", ("method",)),
+    (r"Specify .*", ("method",)),
+    (r".* menu.", ()),
+    (r"To .*", ()),
+    (r"Name for an object.*", ()),
+]
+
+# Rewriting problematic patterns for suggestions
+
+_bad_0 = {
+    r"Create an instance of this.": r"Create a new instance of the current object type.",
+    r"Allows you to (.*)": r"\1",
+}
+
+_bad_1 = {
+    rf"{w} (whether or not|whether|if) (.*)": r"Specifies whether \2"
+    for w in _choose_words
+}
+
+_bad_2 = {
+    r"Select to (.*)": r"Specifies whether to \1",
+    r"Perform (.*)": r"Specifies whether to perform \1",
+    r"Enter a (.*)": r"The \1",
+    r"Enter an (.*)": r"The \1",
+    r"(.*) menu.": r"\1 object.",
+}
+
+_bad_3 = {rf"{w} (.*)": r"\1" for w in _remove_first_words}
+
+_bad_4 = {r"Name for an object(.*)": r"Object name\1"}
+
+_bad_to_suggested = dict(**_bad_0, **_bad_1, **_bad_2, **_bad_3, **_bad_4)
+
+# Pre-compile fixed-format empty patterns (case-sensitive)
+_empty_patterns = [
+    re.compile(f"'.*' {item}.") for item in ("child", "command", "query")
+]
+
+
+def _suggest_fix(docstring: str):
+    """Suggest an improved version of a problematic docstring."""
+    for bad, suggestion in _bad_to_suggested.items():
+        match = re.match(bad, docstring)
+        if match:
+            replacement = match.expand(suggestion)
+
+            # Capitalize if original docstring started with a capital letter
+            if docstring[0].isupper():
+                replacement = replacement[0].upper() + replacement[1:]
+
+            # Ensure we don't add duplicate periods
+            if replacement.endswith("."):
+                return replacement
+            return replacement + "."
+
+    return None  # No fix available
+
+
+def _fixed_doc_string(api_item_type, docstring):
+    for pattern_str, exclude_types in _dubious_patterns:
+        if api_item_type in exclude_types:
+            continue
+
+        if re.match(pattern_str, docstring):
+            fix = _suggest_fix(docstring)
+            new_fix = None
+            if fix:
+                new_fix = _fixed_doc_string(api_item_type, fix)
+            return new_fix or fix
+
+    return None
+
+
+class _DocStringAnalysis:
+    """Analyzes docstrings for potential issues and categorizes them."""
+
+    def __init__(self):
+        """Initialize storage for categorized docstring issues."""
+        self.dubious = {}
+        self.empty = {}
+        self.clean = {}
+
+    def analyse(self, api_path: str, api_item_type: str, api_cls: object):
+        """Extract and analyze the docstring for a given API item."""
+        docstring = self.get_basic_docstring(api_cls)
+        self.analyse_docstring(api_path, api_item_type, docstring)
+
+    def analyse_docstring(self, api_path: str, api_item_type: str, docstring: str):
+        """Analyze a docstring and categorize it as clean, dubious, or empty."""
+
+        # Check for empty docstrings first (case-sensitive)
+        for pattern in _empty_patterns:
+            if pattern.match(docstring):
+                self.empty[api_path] = (api_item_type, docstring)
+                return
+
+        # Check for dubious patterns
+        # TODO just use None?
+        fix = _fixed_doc_string(api_item_type, docstring)
+        if fix:
+            self.dubious[api_path] = (api_item_type, docstring, fix)
+            return
+
+        # If no issues, classify as clean
+        self.clean[api_path] = (api_item_type, docstring)
+
+    def get_basic_docstring(self, api_cls: object):
+        """Extract and clean a class docstring, handling None values."""
+        raw_docstring = api_cls.__doc__ or ""
+        docstring = "".join(raw_docstring.splitlines()).strip()
+
+        # Remove parameters section if present
+        params_section = "        Parameters    ----------        "
+        idx = docstring.find(params_section)
+        return docstring[:idx] if idx != -1 else docstring
+
+    def show_results(self):
+        """Print a categorized summary of analyzed docstrings."""
+        print("\nSummary:\n")
+        for label, result in [
+            ("Empty", self.empty),
+            ("Dubious", self.dubious),
+            ("Clean", self.clean),
+        ]:
+            count = len(result)
+            print(f"{label}: {count}")
+            if label == "Dubious":
+                fix_count = len([i for i in result.values() if i[2]])
+                print(
+                    f"\tNumber with/without suggested fixes: {fix_count}/{count - fix_count}"
+                )
+
+        print("\nDetailed results:")
+        for label, result in [
+            ("Empty", self.empty),
+            ("Dubious", self.dubious),
+            ("Clean", self.clean),
+        ]:
+            print(f"\n{label} ({len(result)}):")
+            for k, (t, s, *extra) in result.items():
+                print(f"{k} ({t}):")
+                print(f"\t{s}")
+
+                # Suggest fixes for dubious patterns
+                if label == "Dubious" and extra:
+                    suggested = extra[0]
+                    if suggested:
+                        print(f"\tSuggested Fix: {suggested}")
+                    else:
+                        print("\tNo suggested fix")
+
+
+def show_all_doc_strings(api_path: str, api_item_type: str, api_cls: object):
+    """Prints all docstrings for debugging."""
+    indent = "  " * (api_path.count("."))
+    bullet = f"{indent}-"
+
+    print(f"{bullet} item: {api_path.split('.')[-1]}")
+    print(f"{bullet} type: {api_item_type}")
+    print(f"{bullet} docstring: {api_cls.__doc__}")
+
+
+if __name__ == "__main__":
+    import argparse
+    import importlib
+
+    from ansys.fluent.core.codegen import walk_api
+
+    # Sample Usage
+    #
+    # Whole Fluent settings API check with default settings
+    # >>> python src\ansys\fluent\core\solver\_docstrings.py --api-version=252
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--cls", dest="api_cls", type=str, default="root")
+    parser.add_argument("--path", dest="api_path", type=str, default="")
+    parser.add_argument("--output-type", dest="output_type", type=str, default="stats")
+    parser.add_argument("--api-version", dest="api_version", type=str, default="")
+
+    args = parser.parse_args()
+
+    api_cls = args.api_cls
+    api_path = args.api_path
+    output_type = args.output_type
+    api_version = args.api_version
+
+    mod = importlib.import_module(
+        name=f"ansys.fluent.core.generated.solver.settings_{api_version}"
+    )
+    cls = getattr(mod, api_cls)
+
+    if output_type == "show":
+        walk_api.walk_api(cls, show_all_doc_strings, api_path)
+    elif output_type == "stats":
+        analysis = _DocStringAnalysis()
+        walk_api.walk_api(cls, analysis.analyse, api_path)
+        analysis.show_results()

ansys/fluent/core/solver/error_message.py

@@ -24,45 +24,40 @@
 
 import difflib
 from functools import partial
-from typing import Any, List
+from typing import Any, Iterable
 
 
-def closest_allowed_names(trial_name: str, allowed_names: str) -> List[str]:
+def closest_allowed_names(trial_name: str, allowed_names: Iterable[str]) -> list[str]:
     """Checks if the 'trail_name' is closely matching the 'allowed_names'."""
     f = partial(difflib.get_close_matches, trial_name, allowed_names)
     return f(cutoff=0.6, n=5) or f(cutoff=0.3, n=1)
 
 
 def allowed_name_error_message(
-    allowed_values: Any | None = None,
+    allowed_values: Iterable[Any] | None = None,
     context: str | None = None,
-    trial_name: str | None = None,
+    trial_name: Any | None = None,
     message: str | None = None,
-    search_results: list | None = None,
 ) -> str:
     """Provide an error message with the closest names matching the 'trial_name' from
     the 'allowed_values' list."""
     if not message:
         message = f"'{context}' has no attribute '{trial_name}'"
     message += ".\n"
-    matches = None
     if allowed_values:
-        if isinstance(allowed_values, list) and isinstance(allowed_values[0], str):
+        matches = None
+        if all(isinstance(item, str) for item in allowed_values) and allowed_values:
             matches = closest_allowed_names(trial_name, allowed_values)
         if matches:
             message += f"The most similar names are: {', '.join(matches)}."
         else:
             message += f"The allowed values are: {allowed_values}."
-    elif search_results:
-        message = message + "\nThe most similar API names are:\n"
-        for search_result in search_results:
-            message += search_result + "\n"
 
     return message
 
 
 def allowed_values_error(
-    context: str, trial_name: str, allowed_values: List[str]
+    context: str, trial_name: str, allowed_values: Iterable[str | int]
 ) -> ValueError:
     """Provide an error message for disallowed values."""
     return ValueError(