feat: Create UI for meshing workflow.

codegen/allapigen.py

@@ -17,6 +17,7 @@
     gt_222 = FluentVersion(version) > FluentVersion.v222
     ge_231 = FluentVersion(version) >= FluentVersion.v231
     ge_242 = FluentVersion(version) >= FluentVersion.v242
+    ge_261 = FluentVersion(version) >= FluentVersion.v261
 
     static_infos = {
         StaticInfoType.DATAMODEL_WORKFLOW: meshing._datamodel_service_se.get_static_info(
@@ -40,6 +41,10 @@
         static_infos[StaticInfoType.DATAMODEL_MESHING_UTILITIES] = (
             meshing._datamodel_service_se.get_static_info("MeshingUtilities")
         )
+    if ge_261:
+        static_infos[StaticInfoType.DATAMODEL_MESHING_WORKFLOW] = (
+            meshing._datamodel_service_se.get_static_info("meshing_workflow")
+        )
     meshing.exit()
 
     solver = launch_fluent(

doc/changelog.d/3748.added.md

@@ -0,0 +1 @@
+Updates for the client side dm-api.

doc/changelog.d/4476.added.md

@@ -0,0 +1 @@
+Create UI for meshing workflow.

doc/datamodel_rstgen.py

@@ -16,6 +16,7 @@ def generate_meshing_datamodels():
         "pm_file_management",
         "preferences",
         "workflow",
+        "meshing_workflow",
     ]
     for meshing_datamodel in meshing_datamodels:
         try:

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

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

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

@@ -188,6 +188,7 @@ def _build_command_query_docstring(
     "MeshingUtilities": "meshing_utilities",
     "flicing": "flicing",
     "solverworkflow": "solver_workflow",
+    "meshing_workflow": "meshing_workflow",
 }
 
 
@@ -242,6 +243,13 @@ def __init__(self, version, static_infos: dict, verbose: bool = False):
                 ),
                 self.version,
             )
+        if StaticInfoType.DATAMODEL_MESHING_WORKFLOW in static_infos:
+            self._static_info["meshing_workflow"] = DataModelStaticInfo(
+                StaticInfoType.DATAMODEL_MESHING_WORKFLOW,
+                "meshing_workflow",
+                ("meshing",),
+                self.version,
+            )
         if StaticInfoType.DATAMODEL_MESHING in static_infos:
             self._static_info["meshing"] = DataModelStaticInfo(
                 StaticInfoType.DATAMODEL_MESHING, "meshing", ("meshing",), self.version
@@ -623,6 +631,10 @@ def generate(version, static_infos: dict, verbose: bool = False):
         static_infos[StaticInfoType.DATAMODEL_MESHING_UTILITIES] = (
             meshing._datamodel_service_se.get_static_info("MeshingUtilities")
         )
+    if FluentVersion(version) >= FluentVersion.v261:
+        static_infos[StaticInfoType.DATAMODEL_MESHING_WORKFLOW] = (
+            meshing._datamodel_service_se.get_static_info("meshing_workflow")
+        )
     parser = argparse.ArgumentParser(
         description="A script to write Fluent API files with an optional verbose output."
     )

src/ansys/fluent/core/session_base_meshing.py

@@ -72,6 +72,7 @@ def __init__(
         self._fluent_version = fluent_version
         self._meshing_utilities = None
         self._old_workflow = None
+        self._meshing_workflow = None
         self._part_management = None
         self._pm_file_management = None
         self._preferences = None
@@ -127,6 +128,13 @@ def workflow(self):
             self._old_workflow = _make_datamodel_module(self, "workflow")
         return self._old_workflow
 
+    @property
+    def meshing_workflow(self):
+        """Full API to meshing and meshing_workflow."""
+        if self._meshing_workflow is None:
+            self._meshing_workflow = _make_datamodel_module(self, "meshing_workflow")
+        return self._meshing_workflow
+
     def watertight_workflow(self, initialize: bool = True):
         """Datamodel root of workflow."""
         self._current_workflow = WorkflowMode.WATERTIGHT_MESHING_MODE.value(
@@ -248,3 +256,81 @@ 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_meshing.py

@@ -127,6 +127,11 @@ def workflow(self):
         """Workflow datamodel root."""
         return super(Meshing, self).workflow
 
+    @property
+    def meshing_workflow(self):
+        """Full API to meshing and meshing_workflow."""
+        return super(Meshing, self).meshing_workflow
+
     @property
     def PartManagement(self):
         """Part management datamodel root."""

src/ansys/fluent/core/session_pure_meshing.py

@@ -50,6 +50,7 @@ class PureMeshing(BaseSession):
 
     _rules = [
         "workflow",
+        "meshing_workflow",
         "meshing",
         "MeshingUtilities",
         "PartManagement",
@@ -146,6 +147,11 @@ def workflow(self):
         """Datamodel root of workflow."""
         return self._base_meshing.workflow
 
+    @property
+    def meshing_workflow(self):
+        """Full API to meshing and meshing_workflow."""
+        return self._base_meshing.meshing_workflow
+
     def watertight(self):
         """Get a new watertight workflow."""
         return self._base_meshing.watertight_workflow()

src/ansys/fluent/core/session_pure_meshing.pyi

@@ -34,6 +34,9 @@ from ansys.fluent.core.generated.datamodel_252.preferences import (
     Root as preferences_root,
 )
 from ansys.fluent.core.generated.datamodel_252.workflow import Root as workflow_root
+from ansys.fluent.core.generated.datamodel_261.meshing_workflow import (
+    Root as meshing_workflow_root,
+)
 from ansys.fluent.core.generated.meshing.tui_252 import main_menu
 
 class PureMeshing:
@@ -45,6 +48,8 @@ class PureMeshing:
     def meshing_utilities(self) -> meshing_utilities_root: ...
     @property
     def workflow(self) -> workflow_root: ...
+    @property
+    def meshing_workflow(self) -> meshing_workflow_root: ...
     def watertight(self): ...
     def fault_tolerant(self): ...
     def two_dimensional_meshing(self): ...

src/ansys/fluent/core/ui/standalone_web_ui.py

@@ -34,6 +34,11 @@
         "Missing dependencies, use 'pip install ansys-fluent-core[ui]' to install them."
     ) from exc
 
+from ansys.fluent.core.services.datamodel_se import (
+    PyCommand,
+    PyMenu,
+    PyNamedObjectContainer,
+)
 from ansys.fluent.core.solver.flobject import (
     BaseCommand,
     Group,
@@ -255,8 +260,14 @@ def _settings_view(obj, indent: int = 0) -> pn.viewable.Viewable:
         else:
             command_names = obj.command_names
             child_names = list(obj) + command_names
+    elif isinstance(obj, (PyMenu, PyNamedObjectContainer)):
+        child_names = list(obj())
+        command_names = []
+        # for item in child_names:
+        #     if isinstance(getattr(obj, item), PyCommand):
+        #         command_names.append(item)
     else:
-        if isinstance(obj, BaseCommand):
+        if isinstance(obj, (BaseCommand, PyCommand)):
             return _command_view(obj, props) if props["is_active"] else pn.pane.HTML("")
         else:
             return _param_view(obj, props) if props["is_active"] else pn.pane.HTML("")
@@ -269,7 +280,10 @@ def _loader(name=child_name, parent=obj, lvl=indent + 1):
             try:
                 child_obj = getattr(parent, name)
             except AttributeError:
-                child_obj = parent[name]
+                try:
+                    child_obj = parent[name]
+                except TypeError:
+                    child_obj = getattr(parent, name.split(":")[0])[name.split(":")[-1]]
             return _settings_view(child_obj, lvl)
 
         # Each child gets its own one-item accordion (mirrors your ipywidgets UX)

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

@@ -22,6 +22,7 @@
 
 """Utilities methods for ui rendering."""
 
+from ansys.fluent.core.services.datamodel_se import PyNumerical, PyTextual
 from ansys.fluent.core.solver.flobject import (
     BaseCommand,
     Boolean,
@@ -133,9 +134,9 @@ def _render_widget_from_props_generic(
             return widget_map["bool"](bool(settings_val))
         elif isinstance(settings_obj, Integer):
             return widget_map["int"](int(settings_val))
-        elif isinstance(settings_obj, Real):
+        elif isinstance(settings_obj, (Real, PyNumerical)):
             return widget_map["float"](float(settings_val))
-        elif isinstance(settings_obj, String):
+        elif isinstance(settings_obj, (String, PyTextual)):
             if allowed:
                 options = [str(v) for v in allowed]
                 val = str(settings_val)

tests/test_codegen.py

@@ -192,6 +192,7 @@ def test_codegen_with_tui_solver_static_info(mode, monkeypatch):
 
 _static_info_type_by_rules = {
     "workflow": StaticInfoType.DATAMODEL_WORKFLOW,
+    "meshing_workflow": StaticInfoType.DATAMODEL_MESHING_WORKFLOW,
     "meshing": StaticInfoType.DATAMODEL_MESHING,
     "PartManagement": StaticInfoType.DATAMODEL_PART_MANAGEMENT,
     "PMFileManagement": StaticInfoType.DATAMODEL_PM_FILE_MANAGEMENT,
@@ -428,6 +429,7 @@ def test_codegen_with_datamodel_static_info(monkeypatch, rules):
     api_tree_expected = {"<meshing_session>": {}, "<solver_session>": {}}
     if rules in [
         "workflow",
+        "meshing_workflow",
         "meshing",
         "PartManagement",
         "PMFileManagement",