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

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(

ansys/fluent/core/solver/flobject.py

@@ -69,13 +69,13 @@ from typing import (
 import warnings
 import weakref
 
-import ansys.fluent.core as pyfluent
 from ansys.fluent.core.pyfluent_warnings import (
     PyFluentDeprecationWarning,
     PyFluentUserWarning,
 )
 from ansys.fluent.core.utils.fluent_version import FluentVersion
 
+from . import _docstrings
 from .error_message import allowed_name_error_message, allowed_values_error
 from .flunits import UnhandledQuantity, get_si_unit_for_fluent_quantity
 from .settings_external import expand_api_file_argument
@@ -695,9 +695,14 @@ class _Alias:
 
 def _create_child(cls, name, parent: weakref.CallableProxyType, alias_path=None):
     if alias_path or isinstance(parent, _Alias):
+        bases = (cls,)
+        # True child of parent alias is already derived from _Alias.
+        # Avoiding duplicate derivation and mro resolution issue.
+        if _Alias not in cls.__mro__:
+            bases = (_Alias, cls)
         alias_cls = type(
             f"{cls.__name__}_alias",
-            (_Alias, cls),
+            bases,
             dict(cls.__dict__) | {"alias_path": alias_path},
         )
         return alias_cls(name, parent.__repr__.__self__)
@@ -945,6 +950,23 @@ def _command_query_name_filter(
     return ret
 
 
+def _get_type_for_completer_info(cls) -> str:
+    if issubclass(cls, (FileName, _InputFile)):
+        return "InputFilename"
+    elif issubclass(cls, (FileName, _OutputFile)):
+        return "OutputFilename"
+    elif issubclass(cls, (FileName, _InOutFile)):
+        return "InOutFilename"
+    elif issubclass(cls, (FilenameList, _InputFile)):
+        return "InputFilenameList"
+    elif issubclass(cls, (FilenameList, _OutputFile)):
+        return "OutputFilenameList"
+    elif issubclass(cls, (FilenameList, _InOutFile)):
+        return "InOutFilenameList"
+    else:
+        return cls.__bases__[0].__name__
+
+
 class Group(SettingsBase[DictStateType]):
     """A ``Group`` container object.
 
@@ -1073,7 +1095,7 @@ class Group(SettingsBase[DictStateType]):
                     ret.append(
                         [
                             child_name,
-                            child.__class__.__bases__[0].__name__,
+                            _get_type_for_completer_info(child.__class__),
                             child.__doc__,
                         ]
                     )
@@ -1105,18 +1127,12 @@ class Group(SettingsBase[DictStateType]):
                 attr._check_stable()
             return attr
         except AttributeError as ex:
-            pyfluent.PRINT_SEARCH_RESULTS = False
-            search_results = pyfluent.utils.search(
-                search_string=name,
-                match_case=False,
-                match_whole_word=False,
-            )
-            pyfluent.PRINT_SEARCH_RESULTS = True
-            results = search_results if search_results else []
             error_msg = allowed_name_error_message(
                 trial_name=name,
                 message=ex.args[0],
-                search_results=results,
+                allowed_values=sorted(
+                    set(self.get_active_child_names() + self.command_names)
+                ),
             )
             ex.args = (error_msg,)
             raise
@@ -1625,7 +1641,7 @@ class Action(Base):
                     ret.append(
                         [
                             argument_name,
-                            argument.__class__.__bases__[0].__name__,
+                            _get_type_for_completer_info(argument.__class__),
                             argument.__doc__,
                         ]
                     )
@@ -1809,13 +1825,22 @@ _baseTypes = {
 
 
 def _clean_helpinfo(helpinfo):
-    helpinfo = helpinfo.strip("\n")
+    helpinfo = helpinfo.strip("\n").lstrip(" ")
     if not helpinfo.endswith("."):
         helpinfo += "."
     helpinfo = helpinfo[0].upper() + helpinfo[1:]
     return helpinfo
 
 
+def _fix_help_info(obj_type, helpinfo):
+    # The else clause is just picking "object" due to our current
+    # knowledge that the implementation only distinguishes between
+    # "method" and everything else. This is fragile.
+    api_item_type = "method" if obj_type in ("command", "query") else "object"
+    fix = _docstrings._fixed_doc_string(api_item_type, helpinfo)
+    return fix or helpinfo
+
+
 class _ChildNamedObjectAccessorMixin(collections.abc.MutableMapping):
     """A mixin class to provide a dictionary interface at a Group class level if the
     Group has multiple named objects of a similar type. For example, boundary conditions
@@ -1983,7 +2008,7 @@ def get_cls(name, info, parent=None, version=None, parent_taboo=None):
         dct = {"fluent_name": name, "version": version}
         helpinfo = info.get("help")
         if helpinfo:
-            dct["__doc__"] = _clean_helpinfo(helpinfo)
+            dct["__doc__"] = _fix_help_info(obj_type, _clean_helpinfo(helpinfo))
         else:
             if parent is None:
                 dct["__doc__"] = "'root' object."

ansys/fluent/core/utils/fluent_version.py

@@ -27,7 +27,6 @@ from functools import total_ordering
 import os
 
 import ansys.fluent.core as pyfluent
-from ansys.fluent.core._version import fluent_dev_version, fluent_release_version
 
 
 class AnsysVersionNotFound(RuntimeError):
@@ -131,7 +130,7 @@ class FluentVersion(Enum):
         FluentVersion
             FluentVersion member corresponding to the latest release.
         """
-        return cls(fluent_release_version)
+        return cls(pyfluent.FLUENT_RELEASE_VERSION)
 
     @classmethod
     def current_dev(cls):
@@ -142,7 +141,7 @@ class FluentVersion(Enum):
         FluentVersion
             FluentVersion member corresponding to the latest development version.
         """
-        return cls(fluent_dev_version)
+        return cls(pyfluent.FLUENT_DEV_VERSION)
 
     @property
     def awp_var(self):

ansys/fluent/core/workflow.py

@@ -1365,6 +1365,7 @@ class Workflow:
                     "service",
                     "task_object",
                     "workflow",
+                    "rename",
                 },
                 _fluent_version=fluent_version,
             )