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

ansys/fluent/core/search.py

@@ -30,7 +30,6 @@ import os
 from pathlib import Path
 import pickle
 import re
-import warnings
 
 import ansys.fluent.core as pyfluent
 from ansys.fluent.core.solver.error_message import closest_allowed_names
@@ -54,16 +53,6 @@ def get_api_tree_file_name(version: str) -> Path:
     return (CODEGEN_OUTDIR / f"api_tree_{version}.pickle").resolve()
 
 
-def _match(source: str, word: str, match_whole_word: bool, match_case: bool):
-    if not match_case:
-        source = source.lower()
-        word = word.lower()
-    if match_whole_word:
-        return source == word
-    else:
-        return word in source
-
-
 def _remove_suffix(input: str, suffix):
     if hasattr(input, "removesuffix"):
         return input.removesuffix(suffix)
@@ -73,9 +62,6 @@ def _remove_suffix(input: str, suffix):
         return input
 
 
-_meshing_rules = ["workflow", "meshing", "PartManagement", "PMFileManagement"]
-
-
 def _generate_api_data(
     version: str | None = None,
 ):
@@ -118,6 +104,11 @@ def _generate_api_data(
                     next_path = f"{path}.{k}"
                 type_ = "Object" if isinstance(v, Mapping) else v
                 api_object_names.add(k)
+                next_path = (
+                    next_path.replace("MeshingUtilities", "meshing_utilities")
+                    if "MeshingUtilities" in next_path
+                    else next_path
+                )
                 if "tui" in next_path:
                     api_tui_objects.add(f"{next_path} ({type_})")
                 else:
@@ -172,37 +163,70 @@ def _get_api_tree_data():
         return api_tree_data
 
 
-def _print_search_results(queries: list, api_tree_data: dict):
-    """Print search results.
+def _print_search_results(
+    queries: list, api_tree_data: dict | None = None, api_path: str | None = None
+):
+    """
+    Print search results.
 
     Parameters
     ----------
-    queries: list
-        List of search string to match API object names.
-    api_tree_data: dict
-        All API object data.
+    queries : list
+        List of search strings or (string, score) tuples to match against API object names.
+    api_tree_data : dict, optional
+        The full API tree data, containing 'api_objects' and 'api_tui_objects'.
+        If None, it is retrieved using _get_api_tree_data().
+    api_path : str, optional
+        Specific path to restrict the search to. If None, searches the entire object hierarchy.
     """
-    results = []
-    api_tree_data = api_tree_data if api_tree_data else _get_api_tree_data()
-    api_tree_datas = [api_tree_data["api_objects"], api_tree_data["api_tui_objects"]]
+    api_tree_data = api_tree_data or _get_api_tree_data()
+    api_sources = [api_tree_data["api_objects"], api_tree_data["api_tui_objects"]]
+
+    def has_query(query, substrings):
+        """Check if query is present via dot or underscore notation."""
+        return any(
+            s.startswith(query)
+            or ("_" in s and (f"_{query}" in s or f"_{query}_" in s))
+            for s in substrings
+        )
 
-    def _get_results(api_tree_data):
-        results = []
-        for query in queries:
-            for api_object in api_tree_data:
-                if api_object.split()[0].endswith(query):
-                    results.append(api_object)
-        return results
+    def extract_results(api_data):
+        results = set()
+
+        for api_object in api_data:
+            target = api_object
+            if api_path:
+                start = api_object.find(api_path)
+                if start == -1:
+                    continue
+                target = api_object[start:]
+
+            first_token = target.split()[0]
+            substrings = first_token.split(".")
+
+            for query in queries:
+                if isinstance(query, tuple):
+                    name, score = query
+                    if name in first_token and has_query(name, substrings):
+                        results.add((api_object, round(score, 2)))
+                else:
+                    if query in first_token and has_query(query, substrings):
+                        results.add(api_object)
 
-    settings_results = _get_results(api_tree_datas[0])
-    tui_results = _get_results(api_tree_datas[1])
+        return sorted(results)
 
-    settings_results.sort()
-    tui_results.sort()
+    all_results = []
+    final_results = []
+    for source in api_sources:
+        all_results.extend(extract_results(source))
 
-    results.extend(settings_results)
-    results.extend(tui_results)
+    if all_results and isinstance(queries[0], tuple):
+        all_results = sorted(all_results, key=lambda item: item[1], reverse=True)
+        final_results.extend(
+            [f"{api_name} (similarity: {score}%)" for api_name, score in all_results]
+        )
 
+    results = final_results or all_results
     if pyfluent.PRINT_SEARCH_RESULTS:
         for result in results:
             print(result)
@@ -230,26 +254,49 @@ def _get_wildcard_matches_for_word_from_names(word: str, names: list):
     return [name for name in names if regex.match(name)]
 
 
-def _search_wildcard(search_string: str, api_tree_data: dict):
+def _search_wildcard(
+    search_string: str | list[tuple[str, float]],
+    api_tree_data: dict,
+    api_path: str | None = None,
+):
     """Perform wildcard search for a word through the Fluent's object hierarchy.
 
     Parameters
     ----------
-    search_string: str
+    search_string: str | list[(str, float)]
         Word to search for. Semantic search is default.
     api_tree_data: dict
         All API object data.
+    api_path: str, optional
+        The API path to search in. The default is ``None``. If ``None``, it searches in the whole
+        Fluent's object hierarchy.
 
     Returns
     -------
         List of search string matches.
     """
-    api_tree_data = api_tree_data if api_tree_data else _get_api_tree_data()
-    queries = _get_wildcard_matches_for_word_from_names(
-        search_string, names=api_tree_data["all_api_object_names"]
-    )
+    api_tree_data = api_tree_data or _get_api_tree_data()
+    all_names = api_tree_data["all_api_object_names"]
+    queries = []
+
+    def add_matches(word: str, score: float | None = None):
+        matches = _get_wildcard_matches_for_word_from_names(word, names=all_names)
+        if matches:
+            if score is not None:
+                queries.extend((match, score) for match in matches)
+            else:
+                queries.extend(matches)
+
+    if isinstance(search_string, str):
+        add_matches(search_string)
+    elif isinstance(search_string, list):
+        for word, score in search_string:
+            add_matches(word, score)
+
     if queries:
-        return _print_search_results(queries, api_tree_data=api_tree_data)
+        return _print_search_results(
+            queries, api_tree_data=api_tree_data, api_path=api_path
+        )
 
 
 def _get_exact_match_for_word_from_names(
@@ -343,6 +390,7 @@ def _search_whole_word(
     match_case: bool = False,
     match_whole_word: bool = True,
     api_tree_data: dict = None,
+    api_path: str | None = None,
 ):
     """Perform exact search for a word through the Fluent's object hierarchy.
 
@@ -358,6 +406,9 @@ def _search_whole_word(
         If ``True``, it matches the given word, and it's capitalize case.
     api_tree_data: dict
         All API object data.
+    api_path: str, optional
+        The API path to search in. The default is ``None``. If ``None``, it searches in the whole
+        Fluent's object hierarchy.
 
     Returns
     -------
@@ -401,7 +452,9 @@ def _search_whole_word(
                 )
             )
     if queries:
-        return _print_search_results(queries, api_tree_data=api_tree_data)
+        return _print_search_results(
+            queries, api_tree_data=api_tree_data, api_path=api_path
+        )
 
 
 def _download_nltk_data():
@@ -426,7 +479,41 @@ def _download_nltk_data():
         )
 
 
-def _search_semantic(search_string: str, language: str, api_tree_data: dict):
+def _are_words_semantically_close(query, api_name, language="eng"):
+    from nltk.corpus import wordnet as wn
+
+    similarity_threshold = (
+        3.2 if language == "eng" else 0.8
+    )  # Max values are 3.7 and 1.0 respectively
+    max_similarity = 0.0
+
+    synsets1 = wn.synsets(query, lang=language)
+    synsets2 = wn.synsets(api_name, lang="eng")
+
+    for syn1 in synsets1:
+        for syn2 in synsets2:
+            if syn1.pos() == syn2.pos():
+                similarity = (
+                    syn1.lch_similarity(syn2)  # Leacock–Chodorow similarity
+                    if language == "eng"
+                    else syn1.wup_similarity(syn2)  # Wu–Palmer similarity
+                )
+                if similarity is not None:
+                    max_similarity = max(max_similarity, similarity)
+                    if similarity >= similarity_threshold:
+                        score = (
+                            (similarity / 3.7) * 100
+                            if language == "eng"
+                            else similarity * 100
+                        )
+                        return True, score
+
+    return False, 0
+
+
+def _search_semantic(
+    search_string: str, language: str, api_tree_data: dict, api_path: str | None = None
+):
     """Perform semantic search for a word through the Fluent's object hierarchy.
 
     Parameters
@@ -445,26 +532,26 @@ def _search_semantic(search_string: str, language: str, api_tree_data: dict):
     queries: list
         List of search string matches.
     """
-    from nltk.corpus import wordnet as wn
-
     api_tree_data = api_tree_data if api_tree_data else _get_api_tree_data()
     similar_keys = set()
-    search_string_synsets = set(wn.synsets(search_string, lang=language))
-    for api_object_name, api_object_synset_names in list(
-        api_tree_data["all_api_object_name_synsets"].items()
-    ):
-        api_object_synsets = {
-            wn.synset(api_object_synset_name)
-            for api_object_synset_name in api_object_synset_names
-        }
-        if search_string_synsets & api_object_synsets:
-            similar_keys.add(api_object_name + "*")
+    api_object_names = api_tree_data["all_api_object_names"]
+    for api_object_name in api_object_names:
+        api_obj_name = (
+            api_object_name.replace("_", " ")
+            if "_" in api_object_name
+            else api_object_name
+        )
+        is_similar, score = _are_words_semantically_close(
+            search_string, api_obj_name, language=language
+        )
+        if is_similar:
+            similar_keys.add((api_object_name + "*", score))
     if similar_keys:
+        sorted_similar_keys = sorted(similar_keys)
         results = []
-        for key in similar_keys:
-            result = _search_wildcard(key, api_tree_data)
-            if result:
-                results.extend(result)
+        result = _search_wildcard(sorted_similar_keys, api_tree_data, api_path=api_path)
+        if result:
+            results.extend(result)
         if results:
             return results
     else:
@@ -473,15 +560,17 @@ def _search_semantic(search_string: str, language: str, api_tree_data: dict):
             names=api_tree_data["all_api_object_names"],
         )
         if queries:
-            return _print_search_results(queries, api_tree_data=api_tree_data)
+            return _print_search_results(
+                queries, api_tree_data=api_tree_data, api_path=api_path
+            )
 
 
 def search(
     search_string: str,
     language: str | None = "eng",
-    wildcard: bool | None = False,
     match_whole_word: bool = False,
     match_case: bool | None = True,
+    api_path: str | None = None,
 ):
     """Search for a word through the Fluent's object hierarchy.
 
@@ -493,52 +582,49 @@ def search(
         ISO 639-3 code for the language to use for the semantic search.
         The default is ``eng`` for English. For the list of supported languages,
         see `OMW Version 1 <https://omwn.org/omw1.html>`_.
-    wildcard: bool, optional
-        Whether to use the wildcard pattern. The default is ``False``. If ``True``, the
-        wildcard pattern is based on the ``fnmatch`` module and semantic matching
-        is turned off.
     match_whole_word: bool, optional
         Whether to find only exact matches. The default is ``False``. If ``True``,
         only exact matches are found and semantic matching is turned off.
     match_case: bool, optional
         Whether to match case. The default is ``True``. If ``False``, the search is case-insensitive.
+    api_path: str, optional
+        The API path to search in. The default is ``None``. If ``None``, it searches in the whole
+        Fluent's object hierarchy.
 
     Examples
     --------
     >>> import ansys.fluent.core as pyfluent
     >>> pyfluent.search("font", match_whole_word=True)
     >>> pyfluent.search("Font")
-    >>> pyfluent.search("iter*", wildcard=True)
+    >>> pyfluent.search("local*", api_path="<solver_session>.setup")
+    <solver_session>.setup.dynamic_mesh.methods.smoothing.radial_settings.local_smoothing (Parameter)
+    <solver_session>.setup.mesh_interfaces.interface["<name>"].local_absolute_mapped_tolerance (Parameter)
+    <solver_session>.setup.mesh_interfaces.interface["<name>"].local_relative_mapped_tolerance (Parameter)
     >>> pyfluent.search("读", language="cmn")   # search 'read' in Chinese
-    The most similar API objects are:
     <solver_session>.file.read (Command)
     <solver_session>.file.import_.read (Command)
     <solver_session>.mesh.surface_mesh.read (Command)
     <solver_session>.tui.display.display_states.read (Command)
     <meshing_session>.tui.display.display_states.read (Command)
     """
-    if (wildcard and match_whole_word) or (wildcard and match_case):
-        warnings.warn(
-            "``wildcard=True`` matches wildcard pattern.",
-            UserWarning,
-        )
-    elif language and wildcard:
-        warnings.warn(
-            "``wildcard=True`` matches wildcard pattern.",
-            UserWarning,
-        )
 
     api_tree_data = _get_api_tree_data()
 
-    if wildcard:
+    wildcard_pattern = re.compile(r"[*?\[\]]")
+
+    if bool(wildcard_pattern.search(search_string)):
         return _search_wildcard(
             search_string,
             api_tree_data=api_tree_data,
+            api_path=api_path,
         )
     elif match_whole_word:
         if not match_case:
             return _search_whole_word(
-                search_string, match_whole_word=True, api_tree_data=api_tree_data
+                search_string,
+                match_whole_word=True,
+                api_tree_data=api_tree_data,
+                api_path=api_path,
             )
         else:
             return _search_whole_word(
@@ -546,16 +632,17 @@ def search(
                 match_case=True,
                 match_whole_word=True,
                 api_tree_data=api_tree_data,
+                api_path=api_path,
             )
     else:
         try:
             return _search_semantic(
-                search_string, language, api_tree_data=api_tree_data
+                search_string, language, api_tree_data=api_tree_data, api_path=api_path
             )
         except ModuleNotFoundError:
             pass
         except LookupError:
             _download_nltk_data()
             return _search_semantic(
-                search_string, language, api_tree_data=api_tree_data
+                search_string, language, api_tree_data=api_tree_data, api_path=api_path
             )

ansys/fluent/core/services/app_utilities.py

@@ -22,6 +22,7 @@
 
 """Wrappers over AppUtilities gRPC service of Fluent."""
 
+from dataclasses import dataclass
 from enum import Enum
 from typing import List, Tuple
 
@@ -150,6 +151,25 @@ class AppUtilitiesService:
         return self._stub.SetWorkingDirectory(request, metadata=self._metadata)
 
 
+@dataclass
+class ProcessInfo:
+    """ProcessInfo dataclass to hold process information."""
+
+    process_id: int
+    hostname: str
+    working_directory: str
+
+
+@dataclass
+class BuildInfo:
+    """BuildInfo dataclass to hold build information."""
+
+    build_time: str
+    build_id: str
+    vcs_revision: str
+    vcs_branch: str
+
+
 class AppUtilitiesOld:
     """AppUtilitiesOld."""
 
@@ -167,34 +187,34 @@ class AppUtilitiesOld:
         build_id = self.scheme.eval("(inquire-build-id)")
         vcs_revision = self.scheme.eval("(inquire-src-vcs-id)")
         vcs_branch = self.scheme.eval("(inquire-src-vcs-branch)")
-        return {
-            "build_time": build_time,
-            "build_id": build_id,
-            "vcs_revision": vcs_revision,
-            "vcs_branch": vcs_branch,
-        }
+        return BuildInfo(
+            build_time=build_time,
+            build_id=build_id,
+            vcs_revision=vcs_revision,
+            vcs_branch=vcs_branch,
+        )
 
     def get_controller_process_info(self) -> dict:
         """Get controller process info."""
         cortex_host = self.scheme.eval("(cx-cortex-host)")
         cortex_pid = self.scheme.eval("(cx-cortex-id)")
         cortex_pwd = self.scheme.eval("(cortex-pwd)")
-        return {
-            "hostname": cortex_host,
-            "process_id": cortex_pid,
-            "working_directory": cortex_pwd,
-        }
+        return ProcessInfo(
+            process_id=cortex_pid,
+            hostname=cortex_host,
+            working_directory=cortex_pwd,
+        )
 
     def get_solver_process_info(self) -> dict:
         """Get solver process info."""
         fluent_host = self.scheme.eval("(cx-client-host)")
         fluent_pid = self.scheme.eval("(cx-client-id)")
         fluent_pwd = self.scheme.eval("(cx-send '(cx-client-pwd))")
-        return {
-            "hostname": fluent_host,
-            "process_id": fluent_pid,
-            "working_directory": fluent_pwd,
-        }
+        return ProcessInfo(
+            process_id=fluent_pid,
+            hostname=fluent_host,
+            working_directory=fluent_pwd,
+        )
 
     def get_app_mode(self) -> Enum:
         """Get app mode."""
@@ -312,32 +332,32 @@ class AppUtilities:
         """Get build info."""
         request = AppUtilitiesProtoModule.GetBuildInfoRequest()
         response = self.service.get_build_info(request)
-        return {
-            "build_time": response.build_time,
-            "build_id": response.build_id,
-            "vcs_revision": response.vcs_revision,
-            "vcs_branch": response.vcs_branch,
-        }
+        return BuildInfo(
+            build_time=response.build_time,
+            build_id=response.build_id,
+            vcs_revision=response.vcs_revision,
+            vcs_branch=response.vcs_branch,
+        )
 
     def get_controller_process_info(self) -> dict:
         """Get controller process info."""
         request = AppUtilitiesProtoModule.GetControllerProcessInfoRequest()
         response = self.service.get_controller_process_info(request)
-        return {
-            "hostname": response.hostname,
-            "process_id": response.process_id,
-            "working_directory": response.working_directory,
-        }
+        return ProcessInfo(
+            process_id=response.process_id,
+            hostname=response.hostname,
+            working_directory=response.working_directory,
+        )
 
     def get_solver_process_info(self) -> dict:
         """Get solver process info."""
         request = AppUtilitiesProtoModule.GetSolverProcessInfoRequest()
         response = self.service.get_solver_process_info(request)
-        return {
-            "hostname": response.hostname,
-            "process_id": response.process_id,
-            "working_directory": response.working_directory,
-        }
+        return ProcessInfo(
+            process_id=response.process_id,
+            hostname=response.hostname,
+            working_directory=response.working_directory,
+        )
 
     def get_app_mode(self) -> Enum:
         """Get app mode.

ansys/fluent/core/services/datamodel_se.py

@@ -1970,9 +1970,12 @@ class PyCommand:
                 id,
             ]
         # Possible error thrown from the grpc layer
-        except (RuntimeError, ValueError):
+        except (RuntimeError, ValueError) as e:
             logger.warning(
-                "Create command arguments object is available from 23.1 onwards"
+                "datamodels_se.PyCommand was unable to construct command arguments. "
+                "This may be due to gRPC issues or unsupported Fluent version (23.1+ required). "
+                "Error details: %s",
+                e,
             )
 
     def create_instance(self) -> "PyCommandArguments":
@@ -2225,7 +2228,7 @@ arg_class_by_type = {
         ["String", "ListString", "String List"], PyTextualCommandArgumentsSubItem
     ),
     **dict.fromkeys(
-        ["Real", "Int", "ListReal", "Real List", "Integer", "ListInt"],
+        ["Real", "Int", "ListReal", "Real List", "Integer", "ListInt", "Integer List"],
         PyNumericalCommandArgumentsSubItem,
     ),
     "Dict": PyDictionaryCommandArgumentsSubItem,

ansys/fluent/core/services/scheme_eval.py

@@ -43,6 +43,7 @@ from ansys.api.fluent.v0.scheme_pointer_pb2 import SchemePointer
 from ansys.fluent.core.services.interceptors import (
     BatchInterceptor,
     ErrorStateInterceptor,
+    GrpcErrorInterceptor,
     TracingInterceptor,
 )
 from ansys.fluent.core.utils.fluent_version import FluentVersion
@@ -60,6 +61,7 @@ class SchemeEvalService:
         """__init__ method of SchemeEvalService class."""
         intercept_channel = grpc.intercept_channel(
             channel,
+            GrpcErrorInterceptor(),
             ErrorStateInterceptor(fluent_error_state),
             TracingInterceptor(),
             BatchInterceptor(),