From 40ef4465268f4726b86e14a8ca24ece927f14905 Mon Sep 17 00:00:00 2001 From: mayankansys Date: Wed, 6 May 2026 16:53:50 +0530 Subject: [PATCH 1/8] meshing update --- src/ansys/fluent/core/__init__.py | 8 + .../core/meshing/meshing_workflow_new.py | 371 +++++++++++------- src/ansys/fluent/core/session_base_meshing.py | 124 +++--- tests/test_server_meshing_workflow.py | 81 ++++ 4 files changed, 385 insertions(+), 199 deletions(-) diff --git a/src/ansys/fluent/core/__init__.py b/src/ansys/fluent/core/__init__.py index e9d8d022ca0..4412e4d34d0 100644 --- a/src/ansys/fluent/core/__init__.py +++ b/src/ansys/fluent/core/__init__.py @@ -59,6 +59,14 @@ connect_to_fluent, launch_fluent, ) +from ansys.fluent.core.meshing.meshing_workflow_new import ( # noqa: F401 + CreateWorkflow, + FaultTolerantMeshing, + LoadWorkflow, + TopologyBasedMeshing, + TwoDimensionalMeshing, + WatertightMeshing, +) from ansys.fluent.core.parametric import LocalParametricStudy # noqa: F401 from ansys.fluent.core.pyfluent_warnings import ( # noqa: F401 PyFluentDeprecationWarning, diff --git a/src/ansys/fluent/core/meshing/meshing_workflow_new.py b/src/ansys/fluent/core/meshing/meshing_workflow_new.py index 00763626f83..bcfb99d1241 100644 --- a/src/ansys/fluent/core/meshing/meshing_workflow_new.py +++ b/src/ansys/fluent/core/meshing/meshing_workflow_new.py @@ -27,121 +27,163 @@ from enum import Enum import os +from typing import TYPE_CHECKING from ansys.fluent.core._types import PathType from ansys.fluent.core.services.datamodel_se import PyMenu +from ansys.fluent.core.session_shared import _make_datamodel_module from ansys.fluent.core.utils.fluent_version import FluentVersion from ansys.fluent.core.workflow_new import Workflow +if TYPE_CHECKING: + from ansys.fluent.core.session_base_meshing import BaseMeshing + from ansys.fluent.core.session_meshing import Meshing + from ansys.fluent.core.session_pure_meshing import PureMeshing + + +def _get_base_meshing(session) -> "BaseMeshing": + """Extract a ``BaseMeshing`` instance from a session object. + + Parameters + ---------- + session : PureMeshing | Meshing | BaseMeshing + A meshing session or its internal ``BaseMeshing`` helper. + + Returns + ------- + BaseMeshing + The underlying ``BaseMeshing`` instance. + + Raises + ------ + TypeError + If *session* is not a recognised meshing session type. + """ + from ansys.fluent.core.session_base_meshing import BaseMeshing + + if isinstance(session, BaseMeshing): + return session + + # PureMeshing / Meshing expose _base_meshing + base = getattr(session, "_base_meshing", None) + if base is not None and isinstance(base, BaseMeshing): + return base + + raise TypeError( + f"Expected a PureMeshing, Meshing, or BaseMeshing instance, " + f"got {type(session).__name__}." + ) + class MeshingWorkflow(Workflow): """Provides meshing specialization of the workflow wrapper that extends the core - functionality in an object-oriented manner.""" + functionality in an object-oriented manner. + + Parameters + ---------- + session : PureMeshing | Meshing | BaseMeshing + The meshing session from which the workflow is constructed. + name : str + Workflow name used to initialise the workflow + (e.g. ``"Watertight Geometry"``). + initialize : bool, optional + If ``True`` (default), the workflow is initialised immediately. + + Examples + -------- + >>> meshing = pyfluent.launch_fluent(mode=pyfluent.FluentMode.MESHING) + >>> wf = MeshingWorkflow(session=meshing, name="Watertight Geometry") + """ def __init__( self, - workflow: PyMenu, - meshing: PyMenu, + session: "PureMeshing | Meshing | BaseMeshing", name: str, - fluent_version: FluentVersion, initialize: bool = True, ) -> None: - """Initialize MeshingWorkflow. - - Parameters - ---------- - workflow : PyMenu - Underlying workflow object. - meshing : PyMenu - Meshing object. - name: str - Workflow name to initialize it. - fluent_version: FluentVersion - Version of Fluent in this session. - initialize: bool - Flag to initialize the workflow, defaults to True. - """ + base = _get_base_meshing(session) + workflow_root = _make_datamodel_module(base, "meshing_workflow") + meshing_root = base.meshing + fluent_version = base.get_fluent_version() + super().__init__( - workflow=workflow, command_source=meshing, fluent_version=fluent_version + workflow=workflow_root, + command_source=meshing_root, + fluent_version=fluent_version, ) - self._meshing = meshing + self._meshing = meshing_root + self._base_meshing = base self._name = name if initialize: self._new_workflow(name=self._name) self._initialized = True + base._current_workflow = self class WatertightMeshingWorkflow(MeshingWorkflow): - """Provides watertight meshing specialization of the workflow wrapper.""" + """Watertight meshing workflow. + + Initialises the *Watertight Geometry* guided workflow on the connected + Fluent meshing session. + + Parameters + ---------- + session : PureMeshing | Meshing | BaseMeshing + The meshing session from which the workflow is constructed. + initialize : bool, optional + If ``True`` (default), the workflow is initialised immediately. + + Examples + -------- + >>> meshing = pyfluent.launch_fluent(mode=pyfluent.FluentMode.MESHING) + >>> watertight = WatertightMeshing(session=meshing) + """ def __init__( self, - workflow: PyMenu, - meshing: PyMenu, - fluent_version: FluentVersion, + session: "PureMeshing | Meshing | BaseMeshing", initialize: bool = True, ) -> None: - """Initialize WatertightMeshingWorkflow. - - Parameters - ---------- - workflow : PyMenu - Underlying workflow object. - meshing : PyMenu - Meshing object. - fluent_version: FluentVersion - Version of Fluent in this session. - initialize: bool - Flag to initialize the workflow, defaults to True. - """ super().__init__( - workflow=workflow, - meshing=meshing, + session=session, name="Watertight Geometry", - fluent_version=fluent_version, initialize=initialize, ) class FaultTolerantMeshingWorkflow(MeshingWorkflow): - """Provides fault-tolerant meshing specialization of the workflow wrapper.""" + """Fault-tolerant meshing workflow. + + Initialises the *Fault-tolerant Meshing* guided workflow on the connected + Fluent meshing session. + + Parameters + ---------- + session : PureMeshing | Meshing | BaseMeshing + The meshing session from which the workflow is constructed. + initialize : bool, optional + If ``True`` (default), the workflow is initialised immediately. + + Examples + -------- + >>> meshing = pyfluent.launch_fluent(mode=pyfluent.FluentMode.MESHING) + >>> fault_tolerant = FaultTolerantMeshing(session=meshing) + """ def __init__( self, - workflow: PyMenu, - meshing: PyMenu, - part_management: PyMenu, - pm_file_management: PyMenu, - fluent_version: FluentVersion, + session: "PureMeshing | Meshing | BaseMeshing", initialize: bool = True, ) -> None: - """Initialize FaultTolerantMeshingWorkflow. - - Parameters - ---------- - workflow : PyMenu - Underlying workflow object. - meshing : PyMenu - Meshing object. - part_management : PyMenu - Part management object. - pm_file_management : PyMenu - File management object in the part management object. - fluent_version: FluentVersion - Version of Fluent in this session. - initialize: bool - Flag to initialize the workflow, defaults to True. - """ + base = _get_base_meshing(session) super().__init__( - workflow=workflow, - meshing=meshing, + session=base, name="Fault-tolerant Meshing", - fluent_version=fluent_version, initialize=initialize, ) - self._parent_workflow = workflow - self._part_management = part_management - self._pm_file_management = pm_file_management + self._parent_workflow = self._workflow + self._part_management = base.PartManagement + self._pm_file_management = base.PMFileManagement @property def parts(self) -> PyMenu | None: @@ -191,65 +233,63 @@ def pm_file_management(self) -> PyMenu | None: class TwoDimensionalMeshingWorkflow(MeshingWorkflow): - """Provides 2D meshing specialization of the workflow wrapper.""" + """2-D meshing workflow. + + Initialises the *2D Meshing* guided workflow on the connected Fluent + meshing session. + + Parameters + ---------- + session : PureMeshing | Meshing | BaseMeshing + The meshing session from which the workflow is constructed. + initialize : bool, optional + If ``True`` (default), the workflow is initialised immediately. + + Examples + -------- + >>> meshing = pyfluent.launch_fluent(mode=pyfluent.FluentMode.MESHING) + >>> two_d = TwoDimensionalMeshing(session=meshing) + """ def __init__( self, - workflow: PyMenu, - meshing: PyMenu, - fluent_version: FluentVersion, + session: "PureMeshing | Meshing | BaseMeshing", initialize: bool = True, ) -> None: - """Initialize TwoDimensionalMeshingWorkflow. - - Parameters - ---------- - workflow : PyMenu - Underlying workflow object. - meshing : PyMenu - Meshing object. - fluent_version: FluentVersion - Version of Fluent in this session. - initialize: bool - Flag to initialize the workflow, defaults to True. - """ super().__init__( - workflow=workflow, - meshing=meshing, + session=session, name="2D Meshing", - fluent_version=fluent_version, initialize=initialize, ) class TopologyBasedMeshingWorkflow(MeshingWorkflow): - """Provides topology-based meshing specialization of the workflow wrapper.""" + """Topology-based meshing workflow. + + Initialises the *Topology Based Meshing* guided workflow on the connected + Fluent meshing session. + + Parameters + ---------- + session : PureMeshing | Meshing | BaseMeshing + The meshing session from which the workflow is constructed. + initialize : bool, optional + If ``True`` (default), the workflow is initialised immediately. + + Examples + -------- + >>> meshing = pyfluent.launch_fluent(mode=pyfluent.FluentMode.MESHING) + >>> topo = TopologyBasedMeshing(session=meshing) + """ def __init__( self, - workflow: PyMenu, - meshing: PyMenu, - fluent_version: FluentVersion, + session: "PureMeshing | Meshing | BaseMeshing", initialize: bool = True, ) -> None: - """Initialize TopologyBasedMeshingWorkflow. - - Parameters - ---------- - workflow : PyMenu - Underlying workflow object. - meshing : PyMenu - Meshing object. - fluent_version: FluentVersion - Version of Fluent in this session. - initialize: bool - Flag to initialize the workflow, defaults to True. - """ super().__init__( - workflow=workflow, - meshing=meshing, + session=session, name="Topology Based Meshing", - fluent_version=fluent_version, initialize=initialize, ) @@ -264,69 +304,98 @@ class WorkflowMode(Enum): class LoadWorkflow(Workflow): - """Provides a specialization of the workflow wrapper for a loaded workflow.""" + """Load a previously saved meshing workflow from a file. + + Parameters + ---------- + session : PureMeshing | Meshing | BaseMeshing + The meshing session from which the workflow is constructed. + file_path : str or PathType, optional + Path to the saved workflow file. + initialize : bool, optional + If ``True`` (default), the workflow is loaded immediately. + + Examples + -------- + >>> meshing = pyfluent.launch_fluent(mode=pyfluent.FluentMode.MESHING) + >>> loaded = LoadWorkflow(session=meshing, file_path="my_workflow.wft") + """ def __init__( self, - workflow: PyMenu, - meshing: PyMenu, - fluent_version: FluentVersion, + session: "PureMeshing | Meshing | BaseMeshing", file_path: PathType = None, initialize: bool = True, ) -> None: - """Initialize a ``LoadWorkflow`` instance. - - Parameters - ---------- - workflow : PyMenu - Underlying workflow object. - meshing : PyMenu - Meshing object. - file_path: os.PathLike[str | bytes] | str | bytes - Path to the saved workflow file. - fluent_version: FluentVersion - Version of Fluent in this session. - initialize: bool - Flag to initialize the workflow, defaults to True. - """ + base = _get_base_meshing(session) + workflow_root = _make_datamodel_module(base, "meshing_workflow") + meshing_root = base.meshing + fluent_version = base.get_fluent_version() + super().__init__( - workflow=workflow, command_source=meshing, fluent_version=fluent_version + workflow=workflow_root, + command_source=meshing_root, + fluent_version=fluent_version, ) - self._meshing = meshing + self._meshing = meshing_root + self._base_meshing = base if initialize: self._load_workflow(file_path=os.fspath(file_path)) + base._current_workflow = self class CreateWorkflow(Workflow): - """Provides a specialization of the workflow wrapper for a newly created - workflow.""" + """Create a new blank meshing workflow for manual task configuration. + + Parameters + ---------- + session : PureMeshing | Meshing | BaseMeshing + The meshing session from which the workflow is constructed. + initialize : bool, optional + If ``True`` (default), an empty workflow is created immediately. + + Examples + -------- + >>> meshing = pyfluent.launch_fluent(mode=pyfluent.FluentMode.MESHING) + >>> blank = CreateWorkflow(session=meshing) + """ def __init__( self, - workflow: PyMenu, - meshing: PyMenu, - fluent_version: FluentVersion, + session: "PureMeshing | Meshing | BaseMeshing", initialize: bool = True, ) -> None: - """Initialize a ``CreateWorkflow`` instance. - - Parameters - ---------- - workflow : PyMenu - Underlying workflow object. - meshing : PyMenu - Meshing object. - fluent_version: FluentVersion - Version of Fluent in this session. - initialize: bool - Flag to initialize the workflow, defaults to True. - """ + base = _get_base_meshing(session) + workflow_root = _make_datamodel_module(base, "meshing_workflow") + meshing_root = base.meshing + fluent_version = base.get_fluent_version() + super().__init__( - workflow=workflow, command_source=meshing, fluent_version=fluent_version + workflow=workflow_root, + command_source=meshing_root, + fluent_version=fluent_version, ) - self._meshing = meshing + self._meshing = meshing_root + self._base_meshing = base if initialize: self._create_workflow() + base._current_workflow = self + + +# --------------------------------------------------------------------------- +# Public aliases – short, user-facing names +# --------------------------------------------------------------------------- +WatertightMeshing = WatertightMeshingWorkflow +"""Alias for :class:`WatertightMeshingWorkflow`.""" + +FaultTolerantMeshing = FaultTolerantMeshingWorkflow +"""Alias for :class:`FaultTolerantMeshingWorkflow`.""" + +TwoDimensionalMeshing = TwoDimensionalMeshingWorkflow +"""Alias for :class:`TwoDimensionalMeshingWorkflow`.""" + +TopologyBasedMeshing = TopologyBasedMeshingWorkflow +"""Alias for :class:`TopologyBasedMeshingWorkflow`.""" def _get_current_workflow(current_workflow, name: str): diff --git a/src/ansys/fluent/core/session_base_meshing.py b/src/ansys/fluent/core/session_base_meshing.py index 7a93cd3b5f4..f8c94bccaae 100644 --- a/src/ansys/fluent/core/session_base_meshing.py +++ b/src/ansys/fluent/core/session_base_meshing.py @@ -215,15 +215,22 @@ def watertight_workflow(self, initialize: bool = True, legacy: bool | None = Non if legacy: root_module = "workflow" from ansys.fluent.core.meshing.meshing_workflow import WorkflowMode + + self._current_workflow = WorkflowMode.WATERTIGHT_MESHING_MODE.value( + _make_datamodel_module(self, root_module), + self.meshing, + self.get_fluent_version(), + initialize, + ) else: - root_module = "meshing_workflow" - from ansys.fluent.core.meshing.meshing_workflow_new import WorkflowMode - self._current_workflow = WorkflowMode.WATERTIGHT_MESHING_MODE.value( - _make_datamodel_module(self, root_module), - self.meshing, - self.get_fluent_version(), - initialize, - ) + from ansys.fluent.core.meshing.meshing_workflow_new import ( + WatertightMeshingWorkflow, + ) + + self._current_workflow = WatertightMeshingWorkflow( + session=self, + initialize=initialize, + ) return self._current_workflow def fault_tolerant_workflow( @@ -249,17 +256,24 @@ def fault_tolerant_workflow( if legacy: root_module = "workflow" from ansys.fluent.core.meshing.meshing_workflow import WorkflowMode + + self._current_workflow = WorkflowMode.FAULT_TOLERANT_MESHING_MODE.value( + _make_datamodel_module(self, root_module), + self.meshing, + self.PartManagement, + self.PMFileManagement, + self.get_fluent_version(), + initialize, + ) else: - root_module = "meshing_workflow" - from ansys.fluent.core.meshing.meshing_workflow_new import WorkflowMode - self._current_workflow = WorkflowMode.FAULT_TOLERANT_MESHING_MODE.value( - _make_datamodel_module(self, root_module), - self.meshing, - self.PartManagement, - self.PMFileManagement, - self.get_fluent_version(), - initialize, - ) + from ansys.fluent.core.meshing.meshing_workflow_new import ( + FaultTolerantMeshingWorkflow, + ) + + self._current_workflow = FaultTolerantMeshingWorkflow( + session=self, + initialize=initialize, + ) return self._current_workflow def two_dimensional_meshing_workflow( @@ -285,15 +299,22 @@ def two_dimensional_meshing_workflow( if legacy: root_module = "workflow" from ansys.fluent.core.meshing.meshing_workflow import WorkflowMode + + self._current_workflow = WorkflowMode.TWO_DIMENSIONAL_MESHING_MODE.value( + _make_datamodel_module(self, root_module), + self.meshing, + self.get_fluent_version(), + initialize, + ) else: - root_module = "meshing_workflow" - from ansys.fluent.core.meshing.meshing_workflow_new import WorkflowMode - self._current_workflow = WorkflowMode.TWO_DIMENSIONAL_MESHING_MODE.value( - _make_datamodel_module(self, root_module), - self.meshing, - self.get_fluent_version(), - initialize, - ) + from ansys.fluent.core.meshing.meshing_workflow_new import ( + TwoDimensionalMeshingWorkflow, + ) + + self._current_workflow = TwoDimensionalMeshingWorkflow( + session=self, + initialize=initialize, + ) return self._current_workflow def topology_based_meshing_workflow( @@ -319,16 +340,22 @@ def topology_based_meshing_workflow( if legacy: root_module = "workflow" from ansys.fluent.core.meshing.meshing_workflow import WorkflowMode + + self._current_workflow = WorkflowMode.TOPOLOGY_BASED_MESHING_MODE.value( + _make_datamodel_module(self, root_module), + self.meshing, + self.get_fluent_version(), + initialize, + ) else: - root_module = "meshing_workflow" - from ansys.fluent.core.meshing.meshing_workflow_new import WorkflowMode - - self._current_workflow = WorkflowMode.TOPOLOGY_BASED_MESHING_MODE.value( - _make_datamodel_module(self, root_module), - self.meshing, - self.get_fluent_version(), - initialize, - ) + from ansys.fluent.core.meshing.meshing_workflow_new import ( + TopologyBasedMeshingWorkflow, + ) + + self._current_workflow = TopologyBasedMeshingWorkflow( + session=self, + initialize=initialize, + ) return self._current_workflow def load_workflow( @@ -370,15 +397,12 @@ def load_workflow( self.get_fluent_version(), ) else: - root_module = "meshing_workflow" from ansys.fluent.core.meshing.meshing_workflow_new import LoadWorkflow self._current_workflow = LoadWorkflow( - _make_datamodel_module(self, root_module), - self.meshing, - self.get_fluent_version(), - os.fspath(file_path), - initialize, + session=self, + file_path=os.fspath(file_path), + initialize=initialize, ) return self._current_workflow @@ -405,16 +429,20 @@ def create_workflow(self, initialize: bool = True, legacy: bool | None = None): if legacy: root_module = "workflow" from ansys.fluent.core.meshing.meshing_workflow import CreateWorkflow + + self._current_workflow = CreateWorkflow( + _make_datamodel_module(self, root_module), + self.meshing, + self.get_fluent_version(), + initialize, + ) else: - root_module = "meshing_workflow" from ansys.fluent.core.meshing.meshing_workflow_new import CreateWorkflow - self._current_workflow = CreateWorkflow( - _make_datamodel_module(self, root_module), - self.meshing, - self.get_fluent_version(), - initialize, - ) + self._current_workflow = CreateWorkflow( + session=self, + initialize=initialize, + ) return self._current_workflow def current_workflow(self, legacy: bool | None = None): diff --git a/tests/test_server_meshing_workflow.py b/tests/test_server_meshing_workflow.py index f3679dd2ed3..96dbaf7571b 100644 --- a/tests/test_server_meshing_workflow.py +++ b/tests/test_server_meshing_workflow.py @@ -2064,3 +2064,84 @@ def test_rename(new_meshing_session): with pytest.raises(LookupError): watertight.import_geometry["Import Geometry"] assert watertight.import_geometry["IG"] + + +# --------------------------------------------------------------------------- +# Direct-construction tests (issue #5112) +# --------------------------------------------------------------------------- + + +@pytest.mark.codegen_required +@pytest.mark.fluent_version(">=26.1") +def test_direct_construction_watertight(new_meshing_session): + """WatertightMeshing(session=meshing) should work identically to + meshing.watertight().""" + from ansys.fluent.core import WatertightMeshing + from ansys.fluent.core.meshing.meshing_workflow_new import ( + WatertightMeshingWorkflow, + ) + + meshing = new_meshing_session + watertight = WatertightMeshing(session=meshing) + + # Correct type + assert isinstance(watertight, WatertightMeshingWorkflow) + # Session's current_workflow is kept in sync + assert meshing.current_workflow is watertight + # Workflow is usable – the first task exists + assert watertight.import_geometry + + +@pytest.mark.codegen_required +@pytest.mark.fluent_version(">=26.1") +def test_direct_construction_fault_tolerant(new_meshing_session): + """FaultTolerantMeshing(session=meshing) should set up part management.""" + from ansys.fluent.core import FaultTolerantMeshing + from ansys.fluent.core.meshing.meshing_workflow_new import ( + FaultTolerantMeshingWorkflow, + ) + + meshing = new_meshing_session + fault_tolerant = FaultTolerantMeshing(session=meshing) + + assert isinstance(fault_tolerant, FaultTolerantMeshingWorkflow) + assert meshing.current_workflow is fault_tolerant + assert fault_tolerant.import_cad_and_part_management + + +@pytest.mark.codegen_required +@pytest.mark.fluent_version(">=26.1") +def test_direct_construction_2d_meshing(new_meshing_session): + """TwoDimensionalMeshing(session=meshing) should produce a 2D workflow.""" + from ansys.fluent.core import TwoDimensionalMeshing + from ansys.fluent.core.meshing.meshing_workflow_new import ( + TwoDimensionalMeshingWorkflow, + ) + + meshing = new_meshing_session + two_d = TwoDimensionalMeshing(session=meshing) + + assert isinstance(two_d, TwoDimensionalMeshingWorkflow) + assert meshing.current_workflow is two_d + + +@pytest.mark.codegen_required +@pytest.mark.fluent_version(">=26.1") +def test_direct_construction_create_workflow(new_meshing_session): + """CreateWorkflow(session=meshing) should create a blank workflow.""" + from ansys.fluent.core import CreateWorkflow + + meshing = new_meshing_session + blank = CreateWorkflow(session=meshing) + + assert meshing.current_workflow is blank + + +@pytest.mark.codegen_required +@pytest.mark.fluent_version(">=26.1") +def test_direct_construction_invalid_session(): + """Passing a non-session object should raise TypeError.""" + from ansys.fluent.core import WatertightMeshing + + with pytest.raises(TypeError): + WatertightMeshing(session="not_a_session") From 274817115d23f19810d40fc6bb5403711d80978f Mon Sep 17 00:00:00 2001 From: pyansys-ci-bot <92810346+pyansys-ci-bot@users.noreply.github.com> Date: Mon, 11 May 2026 02:55:02 +0000 Subject: [PATCH 2/8] chore: adding changelog file 5118.added.md [dependabot-skip] --- doc/changelog.d/5118.added.md | 1 + 1 file changed, 1 insertion(+) create mode 100644 doc/changelog.d/5118.added.md diff --git a/doc/changelog.d/5118.added.md b/doc/changelog.d/5118.added.md new file mode 100644 index 00000000000..88057cb75df --- /dev/null +++ b/doc/changelog.d/5118.added.md @@ -0,0 +1 @@ +Meshing update From 4fd43329bd90b97ce70409c84dc112a0ae5421e5 Mon Sep 17 00:00:00 2001 From: mayankansys Date: Mon, 11 May 2026 18:36:30 +0530 Subject: [PATCH 3/8] handled the code style checks --- src/ansys/fluent/core/meshing/meshing_workflow_new.py | 1 - 1 file changed, 1 deletion(-) diff --git a/src/ansys/fluent/core/meshing/meshing_workflow_new.py b/src/ansys/fluent/core/meshing/meshing_workflow_new.py index bcfb99d1241..27ddc5d1eaf 100644 --- a/src/ansys/fluent/core/meshing/meshing_workflow_new.py +++ b/src/ansys/fluent/core/meshing/meshing_workflow_new.py @@ -32,7 +32,6 @@ from ansys.fluent.core._types import PathType from ansys.fluent.core.services.datamodel_se import PyMenu from ansys.fluent.core.session_shared import _make_datamodel_module -from ansys.fluent.core.utils.fluent_version import FluentVersion from ansys.fluent.core.workflow_new import Workflow if TYPE_CHECKING: From 68ed98d09a31780c1fe0fafaccc27ca82a4e9483 Mon Sep 17 00:00:00 2001 From: mayankansys Date: Mon, 18 May 2026 16:14:43 +0530 Subject: [PATCH 4/8] removed the BaseMeshing --- .../core/meshing/meshing_workflow_new.py | 30 +++++++++---------- 1 file changed, 15 insertions(+), 15 deletions(-) diff --git a/src/ansys/fluent/core/meshing/meshing_workflow_new.py b/src/ansys/fluent/core/meshing/meshing_workflow_new.py index 27ddc5d1eaf..517944a12e3 100644 --- a/src/ansys/fluent/core/meshing/meshing_workflow_new.py +++ b/src/ansys/fluent/core/meshing/meshing_workflow_new.py @@ -45,7 +45,7 @@ def _get_base_meshing(session) -> "BaseMeshing": Parameters ---------- - session : PureMeshing | Meshing | BaseMeshing + session : PureMeshing | Meshing A meshing session or its internal ``BaseMeshing`` helper. Returns @@ -80,7 +80,7 @@ class MeshingWorkflow(Workflow): Parameters ---------- - session : PureMeshing | Meshing | BaseMeshing + session : PureMeshing | Meshing The meshing session from which the workflow is constructed. name : str Workflow name used to initialise the workflow @@ -96,7 +96,7 @@ class MeshingWorkflow(Workflow): def __init__( self, - session: "PureMeshing | Meshing | BaseMeshing", + session: "PureMeshing | Meshing ", name: str, initialize: bool = True, ) -> None: @@ -127,7 +127,7 @@ class WatertightMeshingWorkflow(MeshingWorkflow): Parameters ---------- - session : PureMeshing | Meshing | BaseMeshing + session : PureMeshing | Meshing The meshing session from which the workflow is constructed. initialize : bool, optional If ``True`` (default), the workflow is initialised immediately. @@ -140,7 +140,7 @@ class WatertightMeshingWorkflow(MeshingWorkflow): def __init__( self, - session: "PureMeshing | Meshing | BaseMeshing", + session: "PureMeshing | Meshing ", initialize: bool = True, ) -> None: super().__init__( @@ -158,7 +158,7 @@ class FaultTolerantMeshingWorkflow(MeshingWorkflow): Parameters ---------- - session : PureMeshing | Meshing | BaseMeshing + session : PureMeshing | Meshing The meshing session from which the workflow is constructed. initialize : bool, optional If ``True`` (default), the workflow is initialised immediately. @@ -171,7 +171,7 @@ class FaultTolerantMeshingWorkflow(MeshingWorkflow): def __init__( self, - session: "PureMeshing | Meshing | BaseMeshing", + session: "PureMeshing | Meshing ", initialize: bool = True, ) -> None: base = _get_base_meshing(session) @@ -239,7 +239,7 @@ class TwoDimensionalMeshingWorkflow(MeshingWorkflow): Parameters ---------- - session : PureMeshing | Meshing | BaseMeshing + session : PureMeshing | Meshing The meshing session from which the workflow is constructed. initialize : bool, optional If ``True`` (default), the workflow is initialised immediately. @@ -252,7 +252,7 @@ class TwoDimensionalMeshingWorkflow(MeshingWorkflow): def __init__( self, - session: "PureMeshing | Meshing | BaseMeshing", + session: "PureMeshing | Meshing ", initialize: bool = True, ) -> None: super().__init__( @@ -270,7 +270,7 @@ class TopologyBasedMeshingWorkflow(MeshingWorkflow): Parameters ---------- - session : PureMeshing | Meshing | BaseMeshing + session : PureMeshing | Meshing The meshing session from which the workflow is constructed. initialize : bool, optional If ``True`` (default), the workflow is initialised immediately. @@ -283,7 +283,7 @@ class TopologyBasedMeshingWorkflow(MeshingWorkflow): def __init__( self, - session: "PureMeshing | Meshing | BaseMeshing", + session: "PureMeshing | Meshing ", initialize: bool = True, ) -> None: super().__init__( @@ -307,7 +307,7 @@ class LoadWorkflow(Workflow): Parameters ---------- - session : PureMeshing | Meshing | BaseMeshing + session : PureMeshing | Meshing The meshing session from which the workflow is constructed. file_path : str or PathType, optional Path to the saved workflow file. @@ -322,7 +322,7 @@ class LoadWorkflow(Workflow): def __init__( self, - session: "PureMeshing | Meshing | BaseMeshing", + session: "PureMeshing | Meshing ", file_path: PathType = None, initialize: bool = True, ) -> None: @@ -348,7 +348,7 @@ class CreateWorkflow(Workflow): Parameters ---------- - session : PureMeshing | Meshing | BaseMeshing + session : PureMeshing | Meshing The meshing session from which the workflow is constructed. initialize : bool, optional If ``True`` (default), an empty workflow is created immediately. @@ -361,7 +361,7 @@ class CreateWorkflow(Workflow): def __init__( self, - session: "PureMeshing | Meshing | BaseMeshing", + session: "PureMeshing | Meshing ", initialize: bool = True, ) -> None: base = _get_base_meshing(session) From e16a5f5542ccc186fd8660714730b74111b279af Mon Sep 17 00:00:00 2001 From: mayankansys Date: Wed, 20 May 2026 15:20:01 +0530 Subject: [PATCH 5/8] removed the type checking --- src/ansys/fluent/core/meshing/meshing_workflow_new.py | 9 +++------ 1 file changed, 3 insertions(+), 6 deletions(-) diff --git a/src/ansys/fluent/core/meshing/meshing_workflow_new.py b/src/ansys/fluent/core/meshing/meshing_workflow_new.py index 517944a12e3..f9ced9ae13d 100644 --- a/src/ansys/fluent/core/meshing/meshing_workflow_new.py +++ b/src/ansys/fluent/core/meshing/meshing_workflow_new.py @@ -27,18 +27,15 @@ from enum import Enum import os -from typing import TYPE_CHECKING from ansys.fluent.core._types import PathType from ansys.fluent.core.services.datamodel_se import PyMenu +from ansys.fluent.core.session_base_meshing import BaseMeshing +from ansys.fluent.core.session_meshing import Meshing +from ansys.fluent.core.session_pure_meshing import PureMeshing from ansys.fluent.core.session_shared import _make_datamodel_module from ansys.fluent.core.workflow_new import Workflow -if TYPE_CHECKING: - from ansys.fluent.core.session_base_meshing import BaseMeshing - from ansys.fluent.core.session_meshing import Meshing - from ansys.fluent.core.session_pure_meshing import PureMeshing - def _get_base_meshing(session) -> "BaseMeshing": """Extract a ``BaseMeshing`` instance from a session object. From f41abafa0b2bb890e50ecdc83117b3477de1feed Mon Sep 17 00:00:00 2001 From: mayankansys Date: Wed, 20 May 2026 15:36:39 +0530 Subject: [PATCH 6/8] CI issue resolved --- src/ansys/fluent/core/meshing/meshing_workflow_new.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/ansys/fluent/core/meshing/meshing_workflow_new.py b/src/ansys/fluent/core/meshing/meshing_workflow_new.py index f9ced9ae13d..1744b3d9917 100644 --- a/src/ansys/fluent/core/meshing/meshing_workflow_new.py +++ b/src/ansys/fluent/core/meshing/meshing_workflow_new.py @@ -109,7 +109,7 @@ def __init__( ) self._meshing = meshing_root self._base_meshing = base - self._name = name + self._name = "Create New" if initialize: self._new_workflow(name=self._name) self._initialized = True @@ -395,7 +395,7 @@ def __init__( def _get_current_workflow(current_workflow, name: str): - if current_workflow and current_workflow._name == name: + if current_workflow and getattr(current_workflow, "_name", None) == name: return current_workflow From 77db32b99a91f78e10231af0e50521305cfa0e6e Mon Sep 17 00:00:00 2001 From: mayankansys Date: Thu, 4 Jun 2026 13:04:31 +0530 Subject: [PATCH 7/8] updated testfile --- tests/test_server_meshing_workflow.py | 36 +++++++++++++-------------- 1 file changed, 17 insertions(+), 19 deletions(-) diff --git a/tests/test_server_meshing_workflow.py b/tests/test_server_meshing_workflow.py index 6a518e2a9eb..190dbb179e6 100644 --- a/tests/test_server_meshing_workflow.py +++ b/tests/test_server_meshing_workflow.py @@ -23,7 +23,20 @@ from conftest import SKIP_UNKNOWN import pytest -from ansys.fluent.core import FluentVersion, PyFluentUserWarning, examples +from ansys.fluent.core import ( + CreateWorkflow, + FaultTolerantMeshing, + FluentVersion, + PyFluentUserWarning, + TwoDimensionalMeshing, + WatertightMeshing, + examples, +) +from ansys.fluent.core.meshing.meshing_workflow_new import ( + FaultTolerantMeshingWorkflow, + TwoDimensionalMeshingWorkflow, + WatertightMeshingWorkflow, +) from ansys.fluent.core.services.datamodel_se import PyMenu @@ -2036,7 +2049,7 @@ def test_rename(new_meshing_session): # --------------------------------------------------------------------------- -# Direct-construction tests (issue #5112) +# Direct-construction tests # --------------------------------------------------------------------------- @@ -2045,10 +2058,6 @@ def test_rename(new_meshing_session): def test_direct_construction_watertight(new_meshing_session): """WatertightMeshing(session=meshing) should work identically to meshing.watertight().""" - from ansys.fluent.core import WatertightMeshing - from ansys.fluent.core.meshing.meshing_workflow_new import ( - WatertightMeshingWorkflow, - ) meshing = new_meshing_session watertight = WatertightMeshing(session=meshing) @@ -2065,11 +2074,6 @@ def test_direct_construction_watertight(new_meshing_session): @pytest.mark.fluent_version(">=26.1") def test_direct_construction_fault_tolerant(new_meshing_session): """FaultTolerantMeshing(session=meshing) should set up part management.""" - from ansys.fluent.core import FaultTolerantMeshing - from ansys.fluent.core.meshing.meshing_workflow_new import ( - FaultTolerantMeshingWorkflow, - ) - meshing = new_meshing_session fault_tolerant = FaultTolerantMeshing(session=meshing) @@ -2082,11 +2086,6 @@ def test_direct_construction_fault_tolerant(new_meshing_session): @pytest.mark.fluent_version(">=26.1") def test_direct_construction_2d_meshing(new_meshing_session): """TwoDimensionalMeshing(session=meshing) should produce a 2D workflow.""" - from ansys.fluent.core import TwoDimensionalMeshing - from ansys.fluent.core.meshing.meshing_workflow_new import ( - TwoDimensionalMeshingWorkflow, - ) - meshing = new_meshing_session two_d = TwoDimensionalMeshing(session=meshing) @@ -2098,8 +2097,6 @@ def test_direct_construction_2d_meshing(new_meshing_session): @pytest.mark.fluent_version(">=26.1") def test_direct_construction_create_workflow(new_meshing_session): """CreateWorkflow(session=meshing) should create a blank workflow.""" - from ansys.fluent.core import CreateWorkflow - meshing = new_meshing_session blank = CreateWorkflow(session=meshing) @@ -2110,10 +2107,11 @@ def test_direct_construction_create_workflow(new_meshing_session): @pytest.mark.fluent_version(">=26.1") def test_direct_construction_invalid_session(): """Passing a non-session object should raise TypeError.""" - from ansys.fluent.core import WatertightMeshing with pytest.raises(TypeError): WatertightMeshing(session="not_a_session") + + @pytest.mark.fluent_version(">=27.1") def test_workflow_getattr_suggests_close_match(new_meshing_session): """AttributeError for a near-miss name should list the closest task name.""" From cd21422e121b75cd4302988e46e1c98bd5b871e6 Mon Sep 17 00:00:00 2001 From: mayankansys Date: Thu, 4 Jun 2026 15:38:03 +0530 Subject: [PATCH 8/8] updated the _name --- src/ansys/fluent/core/meshing/meshing_workflow_new.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/ansys/fluent/core/meshing/meshing_workflow_new.py b/src/ansys/fluent/core/meshing/meshing_workflow_new.py index 1744b3d9917..28147684bfc 100644 --- a/src/ansys/fluent/core/meshing/meshing_workflow_new.py +++ b/src/ansys/fluent/core/meshing/meshing_workflow_new.py @@ -109,7 +109,7 @@ def __init__( ) self._meshing = meshing_root self._base_meshing = base - self._name = "Create New" + self._name = name if initialize: self._new_workflow(name=self._name) self._initialized = True @@ -335,6 +335,7 @@ def __init__( ) self._meshing = meshing_root self._base_meshing = base + self._name = "Load Workflow" if initialize: self._load_workflow(file_path=os.fspath(file_path)) base._current_workflow = self @@ -373,6 +374,7 @@ def __init__( ) self._meshing = meshing_root self._base_meshing = base + self._name = "Create New" if initialize: self._create_workflow() base._current_workflow = self