Add option to patch existing installation with codegen

codegen/allapigen.py

@@ -20,10 +20,15 @@ def _update_first_level(d, u):
 
 if __name__ == "__main__":
     api_tree = {"<meshing_session>": {}, "<solver_session>": {}}
+    parser = argparse.ArgumentParser(
+        description="Generate python code from Fluent APIs"
+    )
+    parser.add_argument(
+        "--pyfluent-path",
+        dest="pyfluent_path",
+        help="Specify the pyfluent installation folder to patch, with full path.  Such as /my-venv/Lib/site-packages",
+    )
     if not os.getenv("PYFLUENT_LAUNCH_CONTAINER"):
-        parser = argparse.ArgumentParser(
-            description="Generate python code from Fluent APIs"
-        )
         parser.add_argument(
             "--ansys-version",
             dest="ansys_version",
@@ -34,8 +39,9 @@ def _update_first_level(d, u):
             dest="fluent_path",
             help="Specify the fluent folder to use, with full path.  Such as /apps/ansys_inc/v232/fluent",
         )
-        args = parser.parse_args()
 
+    args = parser.parse_args()
+    if not os.getenv("PYFLUENT_LAUNCH_CONTAINER"):
         if args.ansys_version:
             awp_root = os.environ[
                 "AWP_ROOT"
@@ -45,11 +51,11 @@ def _update_first_level(d, u):
         if args.fluent_path:
             os.environ["PYFLUENT_FLUENT_ROOT"] = args.fluent_path
     version = get_version_for_filepath()
-    print_fluent_version.generate(version)
-    _update_first_level(api_tree, tuigen.generate(version))
-    _update_first_level(api_tree, datamodelgen.generate(version))
-    _update_first_level(api_tree, settingsgen.generate(version))
-    api_tree_file = get_api_tree_filepath(version)
+    print_fluent_version.generate(version, args.pyfluent_path)
+    _update_first_level(api_tree, tuigen.generate(version, args.pyfluent_path))
+    _update_first_level(api_tree, datamodelgen.generate(version, args.pyfluent_path))
+    _update_first_level(api_tree, settingsgen.generate(version, args.pyfluent_path))
+    api_tree_file = get_api_tree_filepath(version, args.pyfluent_path)
     Path(api_tree_file).parent.mkdir(parents=True, exist_ok=True)
     with open(api_tree_file, "wb") as f:
         pickle.dump(api_tree, f)

codegen/datamodelgen.py

@@ -83,22 +83,25 @@ class DataModelStaticInfo:
     _noindices = []
 
     def __init__(
-        self, rules: str, modes: tuple, version: str, rules_save_name: str = ""
+        self,
+        pyfluent_path: str,
+        rules: str,
+        modes: tuple,
+        version: str,
+        rules_save_name: str = "",
     ):
         self.rules = rules
         self.modes = modes
         self.static_info = None
         if rules_save_name == "":
             rules_save_name = rules
         datamodel_dir = (
-            _THIS_DIR
-            / ".."
-            / "src"
+            (Path(pyfluent_path) if pyfluent_path else (Path(_THIS_DIR) / ".." / "src"))
             / "ansys"
             / "fluent"
             / "core"
             / f"datamodel_{version}"
-        )
+        ).resolve()
         datamodel_dir.mkdir(exist_ok=True)
         self.filepath = (datamodel_dir / f"{rules_save_name}.py").resolve()
         if len(modes) > 1:
@@ -107,32 +110,38 @@ def __init__(
 
 
 class DataModelGenerator:
-    def __init__(self, version):
+    def __init__(self, version, pyfluent_path):
         self.version = version
         self._static_info: Dict[str, DataModelStaticInfo] = {
             "workflow": DataModelStaticInfo(
+                pyfluent_path,
                 "workflow",
                 (
                     "meshing",
                     "solver",
                 ),
                 self.version,
             ),
-            "meshing": DataModelStaticInfo("meshing", ("meshing",), self.version),
+            "meshing": DataModelStaticInfo(
+                pyfluent_path, "meshing", ("meshing",), self.version
+            ),
             "PartManagement": DataModelStaticInfo(
-                "PartManagement", ("meshing",), self.version
+                pyfluent_path, "PartManagement", ("meshing",), self.version
             ),
             "PMFileManagement": DataModelStaticInfo(
-                "PMFileManagement", ("meshing",), self.version
+                pyfluent_path, "PMFileManagement", ("meshing",), self.version
             ),
             "flicing": DataModelStaticInfo(
-                "flserver", ("flicing",), self.version, "flicing"
+                pyfluent_path, "flserver", ("flicing",), self.version, "flicing"
             ),
             "preferences": DataModelStaticInfo(
-                "preferences", ("meshing", "solver", "flicing,"), self.version
+                pyfluent_path,
+                "preferences",
+                ("meshing", "solver", "flicing,"),
+                self.version,
             ),
             "solverworkflow": DataModelStaticInfo(
-                "solverworkflow", ("solver",), self.version
+                pyfluent_path, "solverworkflow", ("solver",), self.version
             )
             if int(self.version) >= 231
             else None,
@@ -420,10 +429,10 @@ def _delete_generated_files(self):
             shutil.rmtree(Path(_SOLVER_DM_DOC_DIR))
 
 
-def generate(version):
-    return DataModelGenerator(version).write_static_info()
+def generate(version, pyfluent_path):
+    return DataModelGenerator(version, pyfluent_path).write_static_info()
 
 
 if __name__ == "__main__":
     version = get_version_for_filepath()
-    generate(version)
+    generate(version, None)

codegen/print_fluent_version.py

@@ -1,23 +1,22 @@
 import os
+from pathlib import Path
 
 import ansys.fluent.core as pyfluent
 from ansys.fluent.core.utils.fluent_version import get_version_for_filepath
 
 _THIS_DIR = os.path.dirname(__file__)
 
 
-def print_fluent_version(version):
+def print_fluent_version(version, pyfluent_path):
     session = pyfluent.launch_fluent()
     eval = session.scheme_eval.scheme_eval
-    version_file = os.path.join(
-        _THIS_DIR,
-        "..",
-        "src",
-        "ansys",
-        "fluent",
-        "core",
-        f"fluent_version_{version}.py",
-    )
+    version_file = (
+        (Path(pyfluent_path) if pyfluent_path else (Path(_THIS_DIR) / ".." / "src"))
+        / "ansys"
+        / "fluent"
+        / "core"
+        / f"fluent_version_{version}.py"
+    ).resolve()
     with open(version_file, "w", encoding="utf8") as f:
         f.write(f'FLUENT_VERSION = "{session.get_fluent_version()}"\n')
         f.write(f'FLUENT_BUILD_TIME = "{eval("(inquire-build-time)")}"\n')
@@ -27,10 +26,10 @@ def print_fluent_version(version):
     session.exit()
 
 
-def generate(version):
-    print_fluent_version(version)
+def generate(version, pyfluent_path):
+    print_fluent_version(version, pyfluent_path)
 
 
 if __name__ == "__main__":
     version = get_version_for_filepath()
-    generate(version)
+    generate(version, None)

codegen/settingsgen.py

@@ -28,6 +28,7 @@
 import hashlib
 import io
 import os
+from pathlib import Path
 import pickle
 import pprint
 import shutil
@@ -458,20 +459,16 @@ def _populate_init(parent_dir, sinfo):
         f.write(f"from .{root_class_path} import root")
 
 
-def generate(version):
+def generate(version, pyfluent_path):
     dirname = os.path.dirname(__file__)
-    parent_dir = os.path.normpath(
-        os.path.join(
-            dirname,
-            "..",
-            "src",
-            "ansys",
-            "fluent",
-            "core",
-            "solver",
-            f"settings_{version}",
-        )
-    )
+    parent_dir = (
+        (Path(pyfluent_path) if pyfluent_path else (Path(dirname) / ".." / "src"))
+        / "ansys"
+        / "fluent"
+        / "core"
+        / "solver"
+        / f"settings_{version}"
+    ).resolve()
 
     # Clear previously generated data
     if os.path.exists(parent_dir):
@@ -494,4 +491,4 @@ def generate(version):
 
 if __name__ == "__main__":
     version = get_version_for_filepath()
-    generate(version)
+    generate(version, None)

codegen/tuigen.py

@@ -41,19 +41,15 @@
 _THIS_DIRNAME = os.path.dirname(__file__)
 
 
-def _get_tui_filepath(mode: str, version: str):
-    return os.path.normpath(
-        os.path.join(
-            _THIS_DIRNAME,
-            "..",
-            "src",
-            "ansys",
-            "fluent",
-            "core",
-            mode,
-            f"tui_{version}.py",
-        )
-    )
+def _get_tui_filepath(mode: str, version: str, pyfluent_path: str):
+    return (
+        (Path(pyfluent_path) if pyfluent_path else (Path(_THIS_DIRNAME) / ".." / "src"))
+        / "ansys"
+        / "fluent"
+        / "core"
+        / mode
+        / f"tui_{version}.py"
+    ).resolve()
 
 
 _INDENT_STEP = 4
@@ -170,10 +166,10 @@ def get_command_path(self, command: str) -> str:
 class TUIGenerator:
     """Class to generate explicit TUI menu classes."""
 
-    def __init__(self, mode: str, version: str):
+    def __init__(self, mode: str, version: str, pyfluent_path: str):
         self._mode = mode
         self._version = version
-        self._tui_file = _get_tui_filepath(mode, version)
+        self._tui_file = _get_tui_filepath(mode, version, pyfluent_path)
         if Path(self._tui_file).exists():
             Path(self._tui_file).unlink()
         self._tui_doc_dir = _get_tui_docdir(mode)
@@ -348,14 +344,18 @@ def generate(self) -> None:
         return api_tree
 
 
-def generate(version):
+def generate(version, pyfluent_path):
     # pyfluent.set_log_level("WARNING")
     api_tree = {}
     if version > "222":
         _copy_tui_help_xml_file(version)
     _populate_xml_helpstrings()
-    api_tree["<meshing_session>"] = TUIGenerator("meshing", version).generate()
-    api_tree["<solver_session>"] = TUIGenerator("solver", version).generate()
+    api_tree["<meshing_session>"] = TUIGenerator(
+        "meshing", version, pyfluent_path
+    ).generate()
+    api_tree["<solver_session>"] = TUIGenerator(
+        "solver", version, pyfluent_path
+    ).generate()
     if os.getenv("PYFLUENT_HIDE_LOG_SECRETS") != "1":
         logger.info(
             "XML help is available but not picked for the following %i paths: ",
@@ -368,4 +368,4 @@ def generate(version):
 
 if __name__ == "__main__":
     version = get_version_for_filepath()
-    generate(version)
+    generate(version, None)

src/ansys/fluent/core/utils/search.py

@@ -13,9 +13,15 @@
 from ansys.fluent.core.workflow import BaseTask, TaskContainer, WorkflowWrapper
 
 
-def get_api_tree_filepath(version: str) -> Path:
+def get_api_tree_filepath(version: str, pyfluent_path: str) -> Path:
     return (
-        Path(__file__) / ".." / ".." / "data" / f"api_tree_{version}.pickle"
+        (
+            (Path(pyfluent_path) / "ansys" / "fluent" / "core")
+            if pyfluent_path
+            else (Path(__file__) / ".." / "..")
+        )
+        / "data"
+        / f"api_tree_{version}.pickle"
     ).resolve()
 
 
@@ -174,9 +180,9 @@ def search(
     if not version:
         for fluent_version in FluentVersion:
             version = get_version_for_filepath(str(fluent_version))
-            if get_api_tree_filepath(version).exists():
+            if get_api_tree_filepath(version, None).exists():
                 break
-    api_tree_file = get_api_tree_filepath(version)
+    api_tree_file = get_api_tree_filepath(version, None)
     with open(api_tree_file, "rb") as f:
         api_tree = pickle.load(f)