Stash changes for the client side dm-api.

codegen/allapigen.py

@@ -1,5 +1,7 @@
 """Helper module to generate Fluent API classes."""
+import os
 
+os.environ["PYFLUENT_FLUENT_ROOT"] = r"C:\ANSYSDev\ANSYSDev\vNNN\fluent"
 import argparse
 from time import time
 
@@ -21,6 +23,9 @@
         StaticInfoType.DATAMODEL_WORKFLOW: meshing._datamodel_service_se.get_static_info(
             "workflow"
         ),
+        StaticInfoType.DATAMODEL_WORKFLOW_API: meshing._datamodel_service_se.get_static_info(
+            "workflow_api"
+        ),
         StaticInfoType.DATAMODEL_MESHING: meshing._datamodel_service_se.get_static_info(
             "meshing"
         ),

doc/datamodel_rstgen.py

@@ -16,6 +16,7 @@ def generate_meshing_datamodels():
         "PMFileManagement",
         "preferences",
         "workflow",
+        "workflow_api",
     ]
     for meshing_datamodel in meshing_datamodels:
         try:
@@ -36,7 +37,7 @@ def generate_solver_datamodels():
     """Generate solver datamodel RST files."""
     solver_datamodel_roots = []
     available_datamodels = []
-    solver_datamodels = ["flicing", "preferences", "solverworkflow", "workflow"]
+    solver_datamodels = ["flicing", "preferences", "solverworkflow", "workflow", "workflow_api"]
     for solver_datamodel in solver_datamodels:
         try:
             datamodel = importlib.import_module(

src/ansys/fluent/core/codegen/__init__.py

@@ -32,6 +32,7 @@ class StaticInfoType(Enum):
     TUI_SOLVER = auto()
     TUI_MESHING = auto()
     DATAMODEL_WORKFLOW = auto()
+    DATAMODEL_WORKFLOW_API = auto()
     DATAMODEL_MESHING = auto()
     DATAMODEL_PART_MANAGEMENT = auto()
     DATAMODEL_PM_FILE_MANAGEMENT = auto()

src/ansys/fluent/core/codegen/datamodelgen.py

@@ -191,6 +191,16 @@ def __init__(self, version, static_infos: dict, verbose: bool = False):
                 ),
                 self.version,
             )
+        if StaticInfoType.DATAMODEL_WORKFLOW_API in static_infos:
+            self._static_info["workflow_api"] = DataModelStaticInfo(
+                StaticInfoType.DATAMODEL_WORKFLOW_API,
+                "workflow_api",
+                (
+                    "meshing",
+                    "solver",
+                ),
+                self.version,
+            )
         if StaticInfoType.DATAMODEL_MESHING in static_infos:
             self._static_info["meshing"] = DataModelStaticInfo(
                 StaticInfoType.DATAMODEL_MESHING, "meshing", ("meshing",), self.version
@@ -477,6 +487,9 @@ def generate(version, static_infos: dict, verbose: bool = False):
         StaticInfoType.DATAMODEL_WORKFLOW: meshing._datamodel_service_se.get_static_info(
             "workflow"
         ),
+        StaticInfoType.DATAMODEL_WORKFLOW_API: meshing._datamodel_service_se.get_static_info(
+            "workflow_api"
+        ),
         StaticInfoType.DATAMODEL_MESHING: meshing._datamodel_service_se.get_static_info(
             "meshing"
         ),

src/ansys/fluent/core/session_base_meshing.py

@@ -75,6 +75,7 @@ def __init__(
         self._fluent_version = fluent_version
         self._meshing_utilities = None
         self._old_workflow = None
+        self._workflow_api = None
         self._part_management = None
         self._pm_file_management = None
         self._preferences = None
@@ -148,15 +149,24 @@ def workflow(self):
             self._old_workflow = _make_datamodel_module(self, "workflow")
         return self._old_workflow
 
+    @property
+    def workflow_api(self):
+        if self._workflow_api is None:
+            self._workflow_api = _make_datamodel_module(self, "workflow_api")
+        return self._workflow_api
+
     def watertight_workflow(self, initialize: bool = True):
         """Datamodel root of workflow."""
-        self._current_workflow = WorkflowMode.WATERTIGHT_MESHING_MODE.value(
-            _make_datamodel_module(self, "workflow"),
-            self.meshing,
-            self.get_fluent_version(),
-            initialize,
-        )
+        self._current_workflow = WorkflowWrapper(_make_datamodel_module(self, "workflow_api"))
+        self._current_workflow.initialize_workflow(workflow_type="Watertight Geometry")
         return self._current_workflow
+        # self._current_workflow = WorkflowMode.WATERTIGHT_MESHING_MODE.value(
+        #     _make_datamodel_module(self, "workflow"),
+        #     self.meshing,
+        #     self.get_fluent_version(),
+        #     initialize,
+        # )
+        # return self._current_workflow
 
     def fault_tolerant_workflow(self, initialize: bool = True):
         """Datamodel root of workflow."""
@@ -269,3 +279,83 @@ def preferences(self):
         if self._preferences is None:
             self._preferences = _make_datamodel_module(self, "preferences")
         return self._preferences
+
+
+class WorkflowWrapper:
+    def __init__(self, workflow):
+        self.workflow = workflow
+
+    def __getattr__(self, name):
+        try:
+            return getattr(self.workflow, name)
+        except AttributeError as ex:
+            _task_object= self.workflow.task_object.get(name)
+            if _task_object:
+                return TaskWrapper(_task_object)
+            else:
+                raise ex
+
+class TaskWrapper:
+    def __init__(self, task):
+        self.task = task
+
+    def __getattr__(self, name):
+        try:
+            return getattr(self.task, name)
+        except AttributeError as ex:
+            if name in self.task.arguments():
+                return ArgumentWrapper(self.task, name, self.task.arguments().get(name))
+            else:
+                raise ex
+
+    def __call__(self, *args, **kwargs):
+        self.task.execute()
+
+
+class ArgumentWrapper:
+    def __init__(self, task, arg_name, arg_state):
+        self.__dict__.update(
+            dict(
+                tash=task,
+                arg_name=arg_name,
+                arg_state=arg_state,
+            )
+        )
+
+    def __getattr__(self, name):
+        # try:
+        #     return getattr(self.task.arguments()[self.arg_name], name)
+        # except AttributeError as ex:
+        try:
+            if type(self.arg_state) is dict:
+                return ArgumentWrapper(self.task, name, self.arg_state[name])
+            else:
+                return self.arg_state[name]
+        except KeyError:
+            raise AttributeError(f"{self.arg_name} has no object named {name}.")
+
+    # def __setattr__(self, name, value):
+    #     try:
+    #         # if type(self.arg_state) is dict:
+    #         #     ArgumentWrapper(self.task, self.arg_state[name])
+    #         # else:
+    #         self.task.arguments.update_dict(dict(name=value))
+    #     except KeyError as ex:
+    #         raise AttributeError(f"No object named {name}.") from ex
+
+
+    def __call__(self, *args, **kwargs):
+        return self.arg_state
+
+
+# class SubArgumentWrapper:
+#     def __init__(self, arg_state):
+#         self.arg_state = arg_state
+#
+#     def __getattr__(self, name):
+#         if type(self.arg_state[name]) is dict:
+#             return SubArgumentWrapper(self.arg_state[name])
+#         else:
+#             return self.arg_state[name]
+
+

src/ansys/fluent/core/session_pure_meshing.py

@@ -49,6 +49,7 @@ class PureMeshing(BaseSession):
 
     _rules = [
         "workflow",
+        "workflow_api",
         "meshing",
         "MeshingUtilities",
         "PartManagement",
@@ -145,6 +146,11 @@ def workflow(self):
         """Datamodel root of workflow."""
         return self._base_meshing.workflow
 
+    @property
+    def workflow_api(self):
+        """Datamodel root of workflow."""
+        return self._base_meshing.workflow_api
+
     def watertight(self):
         """Get a new watertight workflow."""
         return self._base_meshing.watertight_workflow()

tests/test_codegen.py

@@ -174,6 +174,7 @@ def test_codegen_with_tui_solver_static_info(mode, monkeypatch):
 
 _static_info_type_by_rules = {
     "workflow": StaticInfoType.DATAMODEL_WORKFLOW,
+    "workflow_api": StaticInfoType.DATAMODEL_WORKFLOW_API,
     "meshing": StaticInfoType.DATAMODEL_MESHING,
     "PartManagement": StaticInfoType.DATAMODEL_PART_MANAGEMENT,
     "PMFileManagement": StaticInfoType.DATAMODEL_PM_FILE_MANAGEMENT,
@@ -371,6 +372,7 @@ def test_codegen_with_datamodel_static_info(monkeypatch, rules):
     api_tree_expected = {"<meshing_session>": {}, "<solver_session>": {}}
     if rules in [
         "workflow",
+        "workflow_api",
         "meshing",
         "PartManagement",
         "PMFileManagement",