feat: beta features access

doc/changelog.d/4153.added.md

@@ -0,0 +1 @@
+beta features access

pyproject.toml

@@ -19,7 +19,7 @@ classifiers = [
     "Operating System :: OS Independent",
 ]
 dependencies = [
-    "ansys-api-fluent>=0.3.35",
+    "ansys-api-fluent>=0.3.36",
     "ansys-platform-instancemanagement~=1.1",
     "ansys-tools-filetransfer>=0.1,<0.3",
     "ansys-units>=0.6.dev1,<1.0",

src/ansys/fluent/core/fluent_connection.py

@@ -47,6 +47,7 @@
 from ansys.fluent.core.services.app_utilities import (
     AppUtilitiesOld,
     AppUtilitiesService,
+    AppUtilitiesV252,
 )
 from ansys.fluent.core.services.scheme_eval import SchemeEvalService
 from ansys.fluent.core.utils.execution import timeout_exec, timeout_loop
@@ -277,18 +278,22 @@ def __init__(self, create_grpc_service, error_state):
         self.scheme_eval = service_creator("scheme_eval").create(
             self._scheme_eval_service
         )
-        if (
-            pyfluent.FluentVersion(self.scheme_eval.version)
-            < pyfluent.FluentVersion.v252
-        ):
-            self._app_utilities = AppUtilitiesOld(self.scheme_eval)
-        else:
-            self._app_utilities_service = create_grpc_service(
-                AppUtilitiesService, error_state
-            )
-            self._app_utilities = service_creator("app_utilities").create(
-                self._app_utilities_service
-            )
+        self._app_utilities_service = create_grpc_service(
+            AppUtilitiesService, error_state
+        )
+        match pyfluent.FluentVersion(self.scheme_eval.version):
+            case v if v < pyfluent.FluentVersion.v252:
+                self._app_utilities = AppUtilitiesOld(self.scheme_eval)
+
+            case pyfluent.FluentVersion.v252:
+                self._app_utilities = AppUtilitiesV252(
+                    self._app_utilities_service, self.scheme_eval
+                )
+
+            case _:
+                self._app_utilities = service_creator("app_utilities").create(
+                    self._app_utilities_service
+                )
 
     @property
     def product_build_info(self) -> str:

src/ansys/fluent/core/services/app_utilities.py

@@ -104,6 +104,12 @@ def is_beta_enabled(
         """Is beta enabled RPC of AppUtilities service."""
         return self._stub.IsBetaEnabled(request, metadata=self._metadata)
 
+    def enable_beta(
+        self, request: AppUtilitiesProtoModule.EnableBetaRequest
+    ) -> AppUtilitiesProtoModule.EnableBetaResponse:
+        """Is beta enabled RPC of AppUtilities service."""
+        return self._stub.EnableBeta(request, metadata=self._metadata)
+
     def is_wildcard(
         self, request: AppUtilitiesProtoModule.IsWildcardRequest
     ) -> AppUtilitiesProtoModule.IsWildcardResponse:
@@ -255,6 +261,18 @@ def is_beta_enabled(self) -> bool:
         """Is beta enabled."""
         return self.scheme.eval("(is-beta-feature-available?)")
 
+    def enable_beta(self):
+        """Enable beta features.
+
+        Raises
+        ------
+        RuntimeError
+            Not supported before Fluent 2025 R2.
+        """
+        raise RuntimeError(
+            "Enabling beta is not supported py PyFluent for Fluent versions before 2025 R2."
+        )
+
     def is_wildcard(self, input: str | None = None) -> bool:
         """Is wildcard."""
         return self.scheme.eval(f'(has-fnmatch-wild-card? "{input}")')
@@ -405,6 +423,11 @@ def is_beta_enabled(self) -> bool:
         response = self.service.is_beta_enabled(request)
         return response.is_beta_enabled
 
+    def enable_beta(self) -> None:
+        """Enable beta features."""
+        request = AppUtilitiesProtoModule.EnableBetaRequest()
+        self.service.enable_beta(request)
+
     def is_wildcard(self, input: str | None = None) -> bool:
         """Is wildcard."""
         request = AppUtilitiesProtoModule.IsWildcardRequest()
@@ -456,3 +479,19 @@ def set_working_directory(self, path: str) -> None:
         request = AppUtilitiesProtoModule.SetWorkingDirectoryRequest()
         request.path = path
         self.service.set_working_directory(request)
+
+
+class AppUtilitiesV252(AppUtilities):
+    """AppUtilitiesV252.
+    This is for methods whose implementations are missing in the 25R2 server.
+    """
+
+    def __init__(self, service: AppUtilitiesService, scheme):
+        super().__init__(service)
+        self.scheme = scheme
+
+    def enable_beta(self) -> None:
+        """Enable beta features."""
+        self.scheme.eval(
+            '(fl-execute-cmd "file" "beta-settings" (list (cons "enable?" #t)))'
+        )

src/ansys/fluent/core/session.py

@@ -452,9 +452,18 @@ def __dir__(self):
             "field_data_streaming",
             "start_journal",
             "stop_journal",
+            "scheme_eval",
         }
         return sorted(dir_list)
 
+    def enable_beta_features(self):
+        """Enable access to Fluent beta-features"""
+        self._app_utilities.enable_beta()
+
+    @property
+    def _is_beta_enabled(self):
+        return self._app_utilities.is_beta_enabled()
+
 
 class Fields:
     """Container for field and solution variables."""

src/ansys/fluent/core/session_pure_meshing.py

@@ -175,13 +175,12 @@ def topology_based(self):
 
         Raises
         ------
-        RuntimeError
+        AttributeError
             If beta features are not enabled in Fluent.
         """
-        if not self._app_utilities.is_beta_enabled():
-            raise RuntimeError("Topology-based Meshing is a beta feature in Fluent.")
-        self._base_meshing.topology_based_meshing_workflow.initialize()
-        return self._base_meshing.topology_based_meshing_workflow
+        if not self._is_beta_enabled:
+            raise AttributeError("Topology-based Meshing is a beta feature in Fluent.")
+        return self._base_meshing.topology_based_meshing_workflow()
 
     @property
     def PartManagement(self):
@@ -238,3 +237,8 @@ def transfer_mesh_to_solvers(
             clean_up_mesh_file,
             overwrite_previous,
         )
+
+    def __dir__(self):
+        if self._fluent_connection is not None and self._is_beta_enabled is False:
+            return sorted(set(super().__dir__()) - {"topology_based"})
+        return super().__dir__()

src/ansys/fluent/core/session_pure_meshing.pyi

@@ -66,3 +66,4 @@ class PureMeshing:
         clean_up_mesh_file: bool = ...,
         overwrite_previous: bool = ...,
     ): ...
+    def enable_beta_features(self): ...

src/ansys/fluent/core/session_solver.py

@@ -347,16 +347,44 @@ def __getattr__(self, name):
                 raise ex
 
     def __dir__(self):
-        if self._fluent_connection is None:
-            return ["is_active"]
-        dir_list = set(list(self.__dict__.keys()) + dir(type(self))) - {
+        dir_list = set(super().__dir__()) - {
             "svar_data",
             "svar_info",
             "reduction",
-            "field_data",
-            "field_info",
-            "field_data_streaming",
-            "start_journal",
-            "stop_journal",
         }
+        if self._fluent_connection is not None and self._is_beta_enabled is False:
+            return sorted(dir_list - {"switch_to_meshing"})
         return sorted(dir_list)
+
+    def switch_to_meshing(self):
+        """Switch to meshing mode and return a meshing session object. Deactivate this
+        object's public interface and streaming services.
+
+        Raises
+        ------
+        AttributeError
+            If beta features are not enabled in Fluent.
+
+        Returns
+        -------
+        Meshing
+        """
+        if not self._is_beta_enabled:
+            raise AttributeError(
+                "Switching to meshing mode is a beta feature in Fluent."
+            )
+        from ansys.fluent.core.session_meshing import Meshing
+
+        self.settings.switch_to_meshing_mode()
+        for cb in self._fluent_connection.finalizer_cbs:
+            cb()
+        meshing_session = Meshing(
+            fluent_connection=self._fluent_connection,
+            scheme_eval=self.scheme,
+            file_transfer_service=self._file_transfer_service,
+        )
+        self._fluent_connection = None
+        self.__doc__ = (
+            "The solver session is no longer usable after switching to meshing mode."
+        )
+        return meshing_session

src/ansys/fluent/core/session_solver.pyi

@@ -44,3 +44,4 @@ class Solver:
     def write_case(self, file_name: str): ...
     @property
     def settings(self) -> settings_root.root: ...
+    def enable_beta_features(self): ...

src/ansys/fluent/core/solver/flobject.py

@@ -2159,7 +2159,6 @@ def _process_cls_names(info_dict, names, write_doc=False):
         commands = info.get("commands")
         if commands:
             commands.pop("exit", None)
-            commands.pop("switch-to-meshing-mode", None)
         if commands and not user_creatable:
             commands.pop("create", None)
         if commands:

tests/conftest.py

@@ -334,6 +334,13 @@ def new_solver_session():
     solver.exit()
 
 
+@pytest.fixture
+def new_solver_session_wo_exit():
+    solver = create_session()
+    yield solver
+    # Exit is intentionally avoided here. Please exit from the method using this.
+
+
 @pytest.fixture
 def new_solver_session_t4():
     solver = create_session(processor_count=4)

tests/test_session.py

@@ -745,3 +745,105 @@ def test_solver_attr_lookup(new_solver_session):
         solver.xyz
     with pytest.raises(AttributeError):
         solver.settings.xyz
+
+
+@pytest.mark.fluent_version(">=25.2")
+def test_beta_meshing_session(new_meshing_session_wo_exit):
+    meshing = new_meshing_session_wo_exit
+    assert "topology_based" not in dir(meshing)
+    with pytest.raises(AttributeError):
+        tp = meshing.topology_based()
+    meshing.enable_beta_features()
+    assert "topology_based" in dir(meshing)
+    tp = meshing.topology_based()
+    assert tp
+
+    assert meshing.is_active() is True
+    solver = meshing.switch_to_solver()
+    assert meshing.is_active() is False
+    assert solver.is_active() is True
+    solver.exit()
+
+
+@pytest.mark.fluent_version(">=25.2")
+def test_beta_solver_session(new_solver_session_wo_exit):
+    solver = new_solver_session_wo_exit
+    assert solver.is_active() is True
+    assert "switch_to_meshing" not in dir(solver)
+    with pytest.raises(AttributeError):
+        meshing = solver.switch_to_meshing()
+    solver.enable_beta_features()
+    assert "switch_to_meshing" in dir(solver)
+    meshing = solver.switch_to_meshing()
+
+    assert solver.is_active() is False
+    assert meshing.is_active() is True
+    meshing.exit()
+
+
+@pytest.mark.fluent_version(">=24.2")
+def test_error_raised_for_beta_feature_access_for_older_versions(
+    new_meshing_session, new_solver_session
+):
+    meshing = new_meshing_session
+    solver = new_solver_session
+
+    if meshing.get_fluent_version() >= FluentVersion.v252:
+        meshing.enable_beta_features()
+        assert "topology_based" in dir(meshing)
+    else:
+        with pytest.raises(RuntimeError):
+            meshing.enable_beta_features()
+
+    if solver.get_fluent_version() >= FluentVersion.v252:
+        solver.enable_beta_features()
+        assert "switch_to_meshing" in dir(solver)
+    else:
+        with pytest.raises(RuntimeError):
+            solver.enable_beta_features()
+
+
+@pytest.mark.fluent_version(">=25.2")
+def test_dir_for_session(new_meshing_session_wo_exit):
+    meshing = new_meshing_session_wo_exit
+
+    for attr in [
+        "watertight",
+        "fault_tolerant",
+        "two_dimensional_meshing",
+        "fields",
+        "scheme",
+    ]:
+        assert getattr(meshing, attr)
+        assert attr in dir(meshing)
+
+    for attr in ["field_data", "field_info", "scheme_eval"]:
+        # Deprecated methods are accessible but hidden in dir()
+        assert getattr(meshing, attr)
+        assert attr not in dir(meshing)
+
+    solver = meshing.switch_to_solver()
+
+    assert dir(meshing) == ["is_active"]
+
+    for attr in ["read_case_lightweight", "settings"]:
+        assert getattr(solver, attr)
+        assert attr in dir(solver)
+
+    for attr in [
+        "field_data",
+        "field_info",
+        "scheme_eval",
+        "svar_data",
+        "svar_info",
+        "reduction",
+    ]:
+        # Deprecated methods are accessible but hidden in dir()
+        assert getattr(solver, attr)
+        assert attr not in dir(solver)
+
+    solver.enable_beta_features()
+    meshing_new = solver.switch_to_meshing()
+
+    assert dir(solver) == ["is_active"]
+    assert len(dir(meshing_new)) > 1

tests/test_settings_api.py

@@ -621,10 +621,9 @@ def test_nested_alias(mixing_elbow_settings_session):
 def test_commands_not_in_settings(new_solver_session):
     solver = new_solver_session
 
-    for command in ["exit", "switch_to_meshing_mode"]:
-        assert command not in dir(solver.settings)
-        with pytest.raises(AttributeError):
-            getattr(solver.settings, command)
+    assert "exit" not in dir(solver.settings)
+    with pytest.raises(AttributeError):
+        solver.settings.exit()
 
 
 @pytest.mark.fluent_version(">=25.1")