ansys-fluent-core 0.27.dev1__py3-none-any.whl → 0.28.dev0__py3-none-any.whl

ansys/fluent/core/__init__.py

@@ -4,8 +4,6 @@ import os
 from pathlib import Path
 import pydoc
 
-import platformdirs
-
 # isort: off
 # Logging has to be imported before importing other PyFluent modules
 from ansys.fluent.core.logging import set_console_logging_level  # noqa: F401
@@ -38,7 +36,7 @@ from ansys.fluent.core.streaming_services.events_streaming import (  # noqa: F40
     MeshingEvent,
     SolverEvent,
 )
-from ansys.fluent.core.utils import fldoc
+from ansys.fluent.core.utils import fldoc, get_examples_download_dir
 from ansys.fluent.core.utils.fluent_version import FluentVersion  # noqa: F401
 from ansys.fluent.core.utils.setup_for_fluent import setup_for_fluent  # noqa: F401
 from ansys.fluent.core.warnings import (  # noqa: F401
@@ -52,7 +50,7 @@ try:
 except (ImportError, AttributeError, SyntaxError):
     pass
 
-_VERSION_INFO = "Build date: October 15, 2024 16:51 UTC ShaID: 2247e24"
+_VERSION_INFO = "Build date: November 27, 2024 17:14 UTC ShaID: 566bc31"
 """Global variable indicating the version of the PyFluent package - Empty by default"""
 
 _THIS_DIRNAME = os.path.dirname(__file__)
@@ -78,9 +76,7 @@ def version_info() -> str:
     return _VERSION_INFO if _VERSION_INFO is not None else __version__
 
 
-EXAMPLES_PATH = os.path.join(
-    platformdirs.user_documents_dir(), "ansys_fluent_core_examples"
-)
+EXAMPLES_PATH = str(get_examples_download_dir())
 
 # Host path which is mounted to the container
 CONTAINER_MOUNT_SOURCE = None
@@ -117,8 +113,11 @@ CODEGEN_OUTDIR = (Path(__file__) / ".." / "generated").resolve()
 # Whether to zip settings API files during codegen
 CODEGEN_ZIP_SETTINGS = os.getenv("PYFLUENT_CODEGEN_ZIP_SETTINGS", False)
 
-# Whether to show mesh after case read
-SHOW_MESH_AFTER_CASE_READ = False
+# Whether to show mesh in Fluent after case read
+FLUENT_SHOW_MESH_AFTER_CASE_READ = False
+
+# Whether to write the automatic transcript in Fluent
+FLUENT_AUTOMATIC_TRANSCRIPT = False
 
 # Whether to interrupt Fluent solver from PyFluent
 SUPPORT_SOLVER_INTERRUPT = False
@@ -128,3 +127,17 @@ START_WATCHDOG = None
 
 # Whether to skip health check
 CHECK_HEALTH = True
+
+# Whether to print search results
+PRINT_SEARCH_RESULTS = True
+
+# Whether to clear environment variables related to Fluent parallel mode
+CLEAR_FLUENT_PARA_ENVS = False
+
+# Set stdout of the launched Fluent process
+# Valid values are same as subprocess.Popen's stdout argument
+LAUNCH_FLUENT_STDOUT = None
+
+# Set stderr of the launched Fluent process
+# Valid values are same as subprocess.Popen's stderr argument
+LAUNCH_FLUENT_STDERR = None

ansys/fluent/core/_version.py

@@ -6,10 +6,13 @@ version_info = 0, 1, 'dev0'
 """
 
 # major, minor, patch
-version_info = 0, 27, "dev1"
+version_info = 0, 28, "dev0"
 
 # Nice string for the version
 __version__ = ".".join(map(str, version_info))
 
 # Current Fluent version
-fluent_release_version = "24.1.0"
+fluent_release_version = "24.2.0"
+
+# Dev Fluent version
+fluent_dev_version = "25.2.0"

ansys/fluent/core/codegen/__init__.py

@@ -18,6 +18,3 @@ class StaticInfoType(Enum):
     DATAMODEL_SOLVER_WORKFLOW = auto()
     DATAMODEL_MESHING_UTILITIES = auto()
     SETTINGS = auto()
-
-
-CODEGEN_GENERATE_BUILTIN_SETTINGS = True

ansys/fluent/core/codegen/allapigen.py

@@ -4,7 +4,6 @@ import os
 from pathlib import Path
 import pickle
 
-from ansys.fluent.core import codegen
 from ansys.fluent.core.codegen import (  # noqa: F401
     builtin_settingsgen,
     datamodelgen,
@@ -12,7 +11,6 @@ from ansys.fluent.core.codegen import (  # noqa: F401
     tuigen,
 )
 from ansys.fluent.core.search import get_api_tree_file_name
-from ansys.fluent.core.utils.fluent_version import FluentVersion
 
 
 def _update_first_level(d, u):
@@ -33,9 +31,7 @@ def generate(version: str, static_infos: dict):
     Path(api_tree_file).parent.mkdir(parents=True, exist_ok=True)
     with open(api_tree_file, "wb") as f:
         pickle.dump(api_tree, f)
-    if codegen.CODEGEN_GENERATE_BUILTIN_SETTINGS and FluentVersion(version) == next(
-        iter(FluentVersion)
-    ):
+    if os.getenv("PYFLUENT_CODEGEN_SKIP_BUILTIN_SETTINGS") != "1":
         builtin_settingsgen.generate(version)
 
 

ansys/fluent/core/codegen/builtin_settingsgen.py

@@ -1,9 +1,10 @@
 """Generate builtin setting classes."""
 
 import os
+from zipimport import zipimporter
 
 from ansys.fluent.core import CODEGEN_OUTDIR, FluentVersion
-from ansys.fluent.core.solver.flobject import CreatableNamedObjectMixin
+from ansys.fluent.core.solver.flobject import CreatableNamedObjectMixin, NamedObject
 from ansys.fluent.core.solver.settings_builtin_data import DATA
 
 _PY_FILE = CODEGEN_OUTDIR / "solver" / "settings_builtin.py"
@@ -32,12 +33,22 @@ def _get_settings_root(version: str):
     return settings.root
 
 
-def _get_named_object_type(root, path):
-    for comp in path.split("."):
-        root = root._child_classes[comp]
-    return (
-        "Creatable" if issubclass(root, CreatableNamedObjectMixin) else "NonCreatable"
-    )
+def _get_named_objects_in_path(root, path, kind):
+    named_objects = []
+    cls = root
+    comps = path.split(".")
+    for i, comp in enumerate(comps):
+        cls = cls._child_classes[comp]
+        if i < len(comps) - 1 and issubclass(cls, NamedObject):
+            named_objects.append(comp)
+            cls = cls.child_object_type
+    final_type = ""
+    if kind == "NamedObject":
+        if issubclass(cls, CreatableNamedObjectMixin):
+            final_type = "Creatable"
+        else:
+            final_type = "NonCreatable"
+    return named_objects, final_type
 
 
 def generate(version: str):
@@ -45,10 +56,12 @@ def generate(version: str):
     print("Generating builtin settings...")
     CODEGEN_OUTDIR.mkdir(exist_ok=True)
     root = _get_settings_root(version)
+    version = FluentVersion(version)
     with open(_PY_FILE, "w") as f:
         f.write('"""Solver settings."""\n\n')
         f.write(
-            "from ansys.fluent.core.solver.settings_builtin_bases import _SingletonSetting, _CreatableNamedObjectSetting, _NonCreatableNamedObjectSetting\n\n\n"
+            "from ansys.fluent.core.solver.settings_builtin_bases import _SingletonSetting, _CreatableNamedObjectSetting, _NonCreatableNamedObjectSetting, Solver\n"
+            "from ansys.fluent.core.solver.flobject import SettingsBase\n\n\n"
         )
         f.write("__all__ = [\n")
         for name, _ in DATA.items():
@@ -56,11 +69,32 @@ def generate(version: str):
         f.write("]\n\n")
         for name, v in DATA.items():
             kind, path = v
+            if isinstance(path, dict):
+                if version not in path:
+                    continue
+                path = path[version]
+            named_objects, final_type = _get_named_objects_in_path(root, path, kind)
             if kind == "NamedObject":
-                path = path[FluentVersion(version)] if isinstance(path, dict) else path
-                kind = f"{_get_named_object_type(root, path)}NamedObject"
+                kind = f"{final_type}NamedObject"
             f.write(f"class {name}(_{kind}Setting):\n")
             f.write(f'    """{name} setting."""\n\n')
+            f.write("    def __init__(self")
+            for named_object in named_objects:
+                f.write(f", {named_object}: str")
+            f.write(", settings_source: SettingsBase | Solver | None = None")
+            if kind == "NonCreatableNamedObject":
+                f.write(", name: str = None")
+            elif kind == "CreatableNamedObject":
+                f.write(", name: str = None, new_instance_name: str = None")
+            f.write("):\n")
+            f.write("        super().__init__(settings_source=settings_source")
+            if kind == "NonCreatableNamedObject":
+                f.write(", name=name")
+            elif kind == "CreatableNamedObject":
+                f.write(", name=name, new_instance_name=new_instance_name")
+            for named_object in named_objects:
+                f.write(f", {named_object}={named_object}")
+            f.write(")\n\n")
 
     with open(_PYI_FILE, "w") as f:
         for version in FluentVersion:

ansys/fluent/core/codegen/datamodelgen.py

@@ -1,6 +1,6 @@
 """Module to generate Fluent datamodel API classes."""
 
-from io import FileIO
+from io import FileIO, StringIO
 import os
 from pathlib import Path
 import shutil
@@ -21,11 +21,11 @@ _ROOT_DIR = Path(__file__) / ".." / ".." / ".." / ".." / ".." / ".."
 
 _PY_TYPE_BY_DM_TYPE = {
     **dict.fromkeys(["Logical", "Bool"], "bool"),
-    **dict.fromkeys(["Logical List", "ListBool"], "List[bool]"),
+    **dict.fromkeys(["Logical List", "ListBool"], "list[bool]"),
     "String": "str",
-    **dict.fromkeys(["String List", "ListString"], "List[str]"),
+    **dict.fromkeys(["String List", "ListString"], "list[str]"),
     **dict.fromkeys(["Integer", "Int"], "int"),
-    **dict.fromkeys(["Integer List", "ListInt"], "List[int]"),
+    **dict.fromkeys(["Integer List", "ListInt"], "list[int]"),
     "Real": "float",
     **dict.fromkeys(
         [
@@ -36,9 +36,9 @@ _PY_TYPE_BY_DM_TYPE = {
             "Real Triplet List",
             "ListRealTriplet",
         ],
-        "List[float]",
+        "list[float]",
     ),
-    **dict.fromkeys(["Dict", "ModelObject"], "Dict[str, Any]"),
+    **dict.fromkeys(["Dict", "ModelObject"], "dict[str, Any]"),
     "None": "None",
 }
 
@@ -66,6 +66,19 @@ _SOLVER_DM_DOC_DIR = os.path.normpath(
 )
 
 
+def _write_command_query_stub(name: str, info: Any, f: FileIO):
+    signature = StringIO()
+    indent = "        "
+    signature.write(f"(\n{indent}self,\n")
+    if info.get("args"):
+        for arg in info.get("args"):
+            signature.write(
+                f'{indent}{arg["name"]}: {_PY_TYPE_BY_DM_TYPE[arg["type"]]} | None = None,\n'
+            )
+    signature.write(f'{indent}) -> {_PY_TYPE_BY_DM_TYPE[info["returntype"]]}: ...')
+    f.write(f"\n    def {name}{signature.getvalue()}\n")
+
+
 def _build_singleton_docstring(name: str):
     return f"Singleton {name}."
 
@@ -130,6 +143,8 @@ class DataModelStaticInfo:
         datamodel_dir = (pyfluent.CODEGEN_OUTDIR / f"datamodel_{version}").resolve()
         datamodel_dir.mkdir(exist_ok=True)
         self.file_name = (datamodel_dir / f"{rules_save_name}.py").resolve()
+        if rules == "MeshingUtilities":
+            self.stub_file = (datamodel_dir / "MeshingUtilities.pyi").resolve()
         if len(modes) > 1:
             for mode in modes[1:]:
                 DataModelStaticInfo._noindices.append(f"{mode}.datamodel.{rules}")
@@ -244,7 +259,7 @@ class DataModelGenerator:
                         print(
                             "Information: Icing settings not generated ( R23.1+ is required )\n"
                         )
-                except:
+                except Exception:
                     print(
                         "Information: Problem accessing flserver datamodel for icing settings\n"
                     )
@@ -316,12 +331,12 @@ class DataModelGenerator:
                 # print("\t\texcluded", k)
                 pass
         for k in parameters:
-            k_type = _PY_TYPE_BY_DM_TYPE[info["parameters"][k]["type"]]
-            if k_type in ["str", "List[str]"]:
+            k_type = info["parameters"][k]["type"]
+            if k_type in {"String", "String List", "ListString"}:
                 f.write(f"{indent}    class {k}(PyTextual):\n")
-            elif k_type in ["int", "float"]:
+            elif k_type in {"Integer", "Int", "Real"}:
                 f.write(f"{indent}    class {k}(PyNumerical):\n")
-            elif k_type in ["Dict", "Dict[str, Any]"]:
+            elif k_type in {"Dict", "ModelObject"}:
                 f.write(f"{indent}    class {k}(PyDictionary):\n")
             else:
                 f.write(f"{indent}    class {k}(PyParameter):\n")
@@ -333,6 +348,32 @@ class DataModelGenerator:
             f.write(f'{indent}        """\n')
             f.write(f"{indent}        pass\n\n")
             api_tree[k] = "Parameter"
+        if "MeshingUtilities" in f.name:
+            stub_file = self._static_info["MeshingUtilities"].stub_file
+            stub_file.unlink(missing_ok=True)
+            with open(stub_file, "w", encoding="utf8") as file:
+                file.write("#\n")
+                file.write("# This is an auto-generated file.  DO NOT EDIT!\n")
+                file.write("#\n")
+                file.write("# pylint: disable=line-too-long\n\n")
+                file.write(
+                    "from ansys.fluent.core.services.datamodel_se import PyMenu\n"
+                )
+                file.write("from typing import Any\n")
+                file.write("\n\n")
+                file.write("class Root(PyMenu):\n")
+                for k in commands:
+                    _write_command_query_stub(
+                        k,
+                        info["commands"][k]["commandinfo"],
+                        file,
+                    )
+                for k in queries:
+                    _write_command_query_stub(
+                        k,
+                        info["queries"][k]["queryinfo"],
+                        file,
+                    )
         for k in commands:
             f.write(f"{indent}    class {k}(PyCommand):\n")
             f.write(f'{indent}        """\n')
@@ -361,7 +402,7 @@ class DataModelGenerator:
         """Write API classes to files."""
         api_tree = {"<meshing_session>": {}, "<solver_session>": {}}
         for name, info in self._static_info.items():
-            if info.static_info == None:
+            if info.static_info is None:
                 continue
             with open(info.file_name, "w", encoding="utf8") as f:
                 f.write("#\n")

ansys/fluent/core/codegen/settingsgen.py

@@ -10,7 +10,12 @@ from typing import IO
 import ansys.fluent.core as pyfluent
 from ansys.fluent.core import launch_fluent
 from ansys.fluent.core.codegen import StaticInfoType
-from ansys.fluent.core.solver.flobject import ListObject, NamedObject, get_cls
+from ansys.fluent.core.solver.flobject import (
+    ListObject,
+    NamedObject,
+    get_cls,
+    to_python_name,
+)
 from ansys.fluent.core.utils.fix_doc import fix_settings_doc
 from ansys.fluent.core.utils.fluent_version import get_version_for_file_name
 
@@ -142,7 +147,7 @@ def _write_function_stub(name, data, s_stub):
     for arg_name in data["argument_names"]:
         arg_type = _arg_type_strings[data["child_classes"][arg_name]["bases"][0]]
         s_stub.write(f", {arg_name}: {arg_type}")
-    s_stub.write(f"):\n")
+    s_stub.write("):\n")
     # TODO: add return type
     doc = data["doc"]
     doc = doc.strip().replace("\n", "\n        ")
@@ -173,30 +178,32 @@ def _write_data(cls_name: str, python_name: str, data: dict, f: IO, f_stub: IO |
     s.write(f"    fluent_name = {data['fluent_name']!r}\n")
     # _python_name preserves the original non-suffixed name of the class.
     s.write(f"    _python_name = {python_name!r}\n")
-    s_stub.write(f"    version: str\n")
-    s_stub.write(f"    fluent_name: str\n")
-    s_stub.write(f"    _python_name: str\n")
+    s_stub.write("    version: str\n")
+    s_stub.write("    fluent_name: str\n")
+    s_stub.write("    _python_name: str\n")
     child_names = data["child_names"]
     if child_names:
         s.write(f"    child_names = {child_names}\n")
-        s_stub.write(f"    child_names: list[str]\n")
+        s_stub.write("    child_names: list[str]\n")
     command_names = data["command_names"]
     if command_names:
         s.write(f"    command_names = {command_names}\n")
-        s_stub.write(f"    command_names: list[str]\n")
+        s_stub.write("    command_names: list[str]\n")
     query_names = data["query_names"]
     if query_names:
         s.write(f"    query_names = {query_names}\n")
-        s_stub.write(f"    query_names: list[str]\n")
+        s_stub.write("    query_names: list[str]\n")
     argument_names = data["argument_names"]
     if argument_names:
         s.write(f"    argument_names = {argument_names}\n")
-        s_stub.write(f"    argument_names: list[str]\n")
+        s_stub.write("    argument_names: list[str]\n")
     classes_to_write = {}  # values are (class_name, data, hash, should_write_stub)
     if data["child_classes"]:
         s.write("    _child_classes = dict(\n")
         for k, v in data["child_classes"].items():
             name = v["name"]
+            # Retrieving the original python name before get_cls() modifies it.
+            child_python_name = to_python_name(v["fluent_name"])
             hash_ = _gethash(v)
             # We are within a tree-traversal, so the global _NAME_BY_HASH dict
             # must be updated immediately at the point of lookup. Same lookup
@@ -216,10 +223,10 @@ def _write_data(cls_name: str, python_name: str, data: dict, f: IO, f_stub: IO |
             # the _CLASS_WRITTEN set.
             if k in command_names + query_names:
                 _write_function_stub(k, v, s_stub)
-                classes_to_write[unique_name] = (name, v, hash_, False)
+                classes_to_write[unique_name] = (child_python_name, v, hash_, False)
             else:
                 s_stub.write(f"    {k}: {unique_name}\n")
-                classes_to_write[unique_name] = (name, v, hash_, True)
+                classes_to_write[unique_name] = (child_python_name, v, hash_, True)
         s.write("    )\n")
     if child_object_name:
         child_object_type = data["child_object_type"]
@@ -241,7 +248,7 @@ def _write_data(cls_name: str, python_name: str, data: dict, f: IO, f_stub: IO |
     return_type = data["return_type"]
     if return_type:
         s.write(f"    return_type = {return_type!r}\n")
-        s_stub.write(f"    return_type: str\n")
+        s_stub.write("    return_type: str\n")
     s.write("\n")
     for name, (python_name, data, hash_, should_write_stub) in classes_to_write.items():
         if name not in _CLASS_WRITTEN:
@@ -270,6 +277,8 @@ def generate(version: str, static_infos: dict) -> None:
     # _populate_data() collects all strings to write to the file in a nested dict.
     # which is then written to the file using _write_data().
     data = _populate_data(cls, api_tree, version)
+    _NAME_BY_HASH.clear()
+    _CLASS_WRITTEN.clear()
     with open(output_file, "w") as f, open(output_stub_file, "w") as f_stub:
         header = StringIO()
         header.write("#\n")

ansys/fluent/core/codegen/settingsgen_old.py

@@ -461,7 +461,7 @@ def _populate_classes(parent_dir):
             child_aliases = getattr(cls, "_child_aliases", None)
             if child_aliases:
                 f.write(f"{istr1}_child_aliases = dict(\n")
-                f.writelines([f'{istr2}{k}="{v}",\n' for k, v in child_aliases.items()])
+                f.writelines([f"{istr2}{k}={v!r},\n" for k, v in child_aliases.items()])
                 f.write(f"{istr1})\n\n")
 
             # write object type
@@ -490,7 +490,7 @@ def _populate_init(parent_dir, hash):
         f.write("# This is an auto-generated file.  DO NOT EDIT!\n")
         f.write("#\n")
         f.write("\n")
-        f.write(f'"""A package providing Fluent\'s Settings Objects in Python."""')
+        f.write('"""A package providing Fluent\'s Settings Objects in Python."""')
         f.write("\n")
         f.write("from ansys.fluent.core.solver.flobject import *\n\n")
         f.write(f'SHASH = "{hash}"\n')

ansys/fluent/core/codegen/tuigen.py

@@ -62,7 +62,7 @@ def _get_tui_docdir(mode: str):
             "source",
             "api",
             mode,
-            f"tui",
+            "tui",
         )
     )
 

ansys/fluent/core/codegen/write_settings_yaml.py

@@ -7,7 +7,6 @@ Usage:
 import sys
 
 import ansys.fluent.core as pyfluent
-from ansys.fluent.core.services import settings
 
 indent_factor = 2
 
@@ -37,9 +36,9 @@ if "__main__" == __name__:
         print("Usage: write_settings_yaml.py [outfile]")
     else:
         session = pyfluent.launch_fluent(mode="solver")
-        settings = session.settings_service.get_static_info()
+        static_info = session.settings_service.get_static_info()
         if len(sys.argv) == 2:
             with open(sys.argv[1], "w") as f:
-                write_yaml(f, settings)
+                write_yaml(f, static_info)
         elif len(sys.argv) == 1:
-            write_yaml(sys.stdout, settings)
+            write_yaml(sys.stdout, static_info)