feat: conservative approach to single design per modeler (#1740)

Co-authored-by: pyansys-ci-bot <[email protected]>

Author: RobPasMue

doc/changelog.d/1740.added.md

@@ -0,0 +1 @@
+conservative approach to single design per modeler

src/ansys/geometry/core/__init__.py

@@ -55,11 +55,17 @@
 """Global constant for checking whether to use service colors for plotting
 purposes. If set to False, the default colors will be used (speed gain)."""
 
-DISABLE_MULTIPLE_DESIGN_CHECK: bool = False
+# TODO: This is a deprecated constant. Not used in the codebase.
+# Left here for backwards compatibility (with older versions of the codebase).
+# https://github.com/ansys/pyansys-geometry/issues/1319
+DISABLE_MULTIPLE_DESIGN_CHECK: bool = True
+"""Deprecated constant. Use ``DISABLE_ACTIVE_DESIGN_CHECK`` instead."""
+
+DISABLE_ACTIVE_DESIGN_CHECK: bool = False
 """Global constant for disabling the ``ensure_design_is_active`` check.
 
 Only set this to false if you are sure you want to disable this check
-and you will ONLY be working with one design.
+and your objects will always exist on the server side.
 """
 
 DOCUMENTATION_BUILD: bool = os.environ.get("PYANSYS_GEOMETRY_DOC_BUILD", "false").lower() == "true"

src/ansys/geometry/core/connection/client.py

@@ -29,6 +29,7 @@
 import warnings
 
 from ansys.geometry.core.errors import protect_grpc
+from ansys.geometry.core.misc.checks import deprecated_method
 
 # TODO: Remove this context and filter once the protobuf UserWarning issue is downgraded to INFO
 # https://github.com/grpc/grpc/issues/37609
@@ -224,18 +225,6 @@ def __init__(
 
         # Store the backend type
         self._backend_type = backend_type
-        self._multiple_designs_allowed = (
-            False
-            if backend_type
-            in (
-                BackendType.DISCOVERY,
-                BackendType.LINUX_SERVICE,
-                BackendType.CORE_LINUX,
-                BackendType.CORE_WINDOWS,
-                BackendType.DISCOVERY_HEADLESS,
-            )
-            else True
-        )
 
         # retrieve the backend version
         if hasattr(grpc_backend_response, "version"):
@@ -277,15 +266,18 @@ def backend_version(self) -> semver.version.Version:
         return self._backend_version
 
     @property
+    @deprecated_method(info="Multiple designs for the same service are no longer supported.")
     def multiple_designs_allowed(self) -> bool:
         """Flag indicating whether multiple designs are allowed.
 
+        Deprecated since version 0.8.X.
+
         Notes
         -----
-        This method will return ``False`` if the backend type is ``Discovery`` or
-        ``Linux Service``. Otherwise, it will return ``True``.
+        Currently, only one design is allowed per service. This method will always
+        return ``False``.
         """
-        return self._multiple_designs_allowed
+        return False
 
     @property
     def channel(self) -> grpc.Channel:

src/ansys/geometry/core/designer/design.py

@@ -143,7 +143,6 @@ def __init__(self, name: str, modeler: Modeler, read_existing_design: bool = Fal
         self._beam_profiles = {}
         self._design_id = ""
         self._is_active = False
-        self._is_closed = False
         self._modeler = modeler
 
         # Check whether we want to process an existing design or create a new one.
@@ -189,13 +188,13 @@ def is_active(self) -> bool:
 
     @property
     def is_closed(self) -> bool:
-        """Whether the design is closed."""
-        return self._is_closed
+        """Whether the design is closed (i.e. not active)."""
+        return not self._is_active
 
     def close(self) -> None:
         """Close the design."""
         # Check if the design is already closed
-        if self._is_closed:
+        if self.is_closed:
             self._grpc_client.log.warning(f"Design {self.name} is already closed.")
             return
 
@@ -207,15 +206,11 @@ def close(self) -> None:
             self._grpc_client.log.warning("Ignoring response and assuming the design is closed.")
 
         # Consider the design closed (even if the close request failed)
-        self._is_closed = True
+        self._is_active = False
 
     @protect_grpc
     def _activate(self, called_after_design_creation: bool = False) -> None:
         """Activate the design."""
-        # Deactivate all designs first
-        for design in self._modeler._designs.values():
-            design._is_active = False
-
         # Activate the current design
         if not called_after_design_creation:
             self._design_stub.PutActive(EntityIdentifier(id=self._design_id))
@@ -1199,13 +1194,5 @@ def _update_design_inplace(self) -> None:
         self._named_selections = {}
         self._coordinate_systems = {}
 
-        # Get the previous design id
-        previous_design_id = self._design_id
-
         # Read the existing design
         self.__read_existing_design()
-
-        # If the design id has changed, update the design id in the Modeler
-        if previous_design_id != self._design_id:
-            self._modeler._designs[self._design_id] = self
-            self._modeler._designs.pop(previous_design_id)

src/ansys/geometry/core/misc/checks.py

@@ -45,7 +45,7 @@ def wrapper(self, *args, **kwargs):
         import ansys.geometry.core as pyansys_geometry
         from ansys.geometry.core.errors import GeometryRuntimeError
 
-        if pyansys_geometry.DISABLE_MULTIPLE_DESIGN_CHECK:
+        if pyansys_geometry.DISABLE_ACTIVE_DESIGN_CHECK:
             # If the user has disabled the check, then we can skip it
             return method(self, *args, **kwargs)
 
@@ -73,17 +73,6 @@ def get_design_ref(obj) -> "Design":
                 "The design has been closed on the backend. Cannot perform any operations on it."
             )
 
-        # Activate the design if it is not active
-        if not design.is_active:
-            # First, check the backend allows for multiple documents
-            if not design._grpc_client.multiple_designs_allowed:
-                raise GeometryRuntimeError(
-                    "The design is not active and multiple designs are "
-                    "not allowed with the current backend."
-                )
-            else:
-                design._activate()
-
         # Finally, call method
         return method(self, *args, **kwargs)
 

src/ansys/geometry/core/modeler.py

@@ -37,8 +37,7 @@
 from ansys.geometry.core.connection.client import GrpcClient
 from ansys.geometry.core.connection.defaults import DEFAULT_HOST, DEFAULT_PORT
 from ansys.geometry.core.errors import GeometryRuntimeError, protect_grpc
-from ansys.geometry.core.logger import LOG
-from ansys.geometry.core.misc.checks import check_type, min_backend_version
+from ansys.geometry.core.misc.checks import check_type, deprecated_method, min_backend_version
 from ansys.geometry.core.misc.options import ImportOptions
 from ansys.geometry.core.tools.measurement_tools import MeasurementTools
 from ansys.geometry.core.tools.prepare_tools import PrepareTools
@@ -120,15 +119,15 @@ def __init__(
             backend_type=backend_type,
         )
 
-        # Maintaining references to all designs within the modeler workspace
-        self._designs: dict[str, "Design"] = {}
+        # Single design for the Modeler
+        self._design: Optional["Design"] = None
 
         # Initialize the RepairTools - Not available on Linux
         # TODO: delete "if" when Linux service is able to use repair tools
         # https://github.com/ansys/pyansys-geometry/issues/1319
         if BackendType.is_core_service(self.client.backend_type):
             self._measurement_tools = None
-            LOG.warning("CoreService backend does not support measurement tools.")
+            self.client.log.warning("CoreService backend does not support measurement tools.")
         else:
             self._measurement_tools = MeasurementTools(self._grpc_client)
 
@@ -138,28 +137,26 @@ def __init__(
         self._geometry_commands = GeometryCommands(self._grpc_client)
         self._unsupported = UnsupportedCommands(self._grpc_client, self)
 
-        # Check if the backend allows for multiple designs and throw warning if needed
-        if not self.client.multiple_designs_allowed:
-            LOG.warning(
-                "Linux and Ansys Discovery backends do not support multiple "
-                "designs open in the same session. Only the last design created "
-                "will be available to perform modeling operations."
-            )
-
     @property
     def client(self) -> GrpcClient:
         """``Modeler`` instance client."""
         return self._grpc_client
 
     @property
+    def design(self) -> "Design":
+        """Retrieve the design within the modeler workspace."""
+        return self._design
+
+    @property
+    @deprecated_method(alternative="design")
     def designs(self) -> dict[str, "Design"]:
-        """All designs within the modeler workspace.
+        """Retrieve the design within the modeler workspace.
 
         Notes
         -----
-        This property is read-only. **DO NOT** modify the dictionary.
+        This method is deprecated. Use the :func:`design` property instead.
         """
-        return self._designs
+        return {self._design.id: self._design}
 
     def create_design(self, name: str) -> "Design":
         """Initialize a new design with the connected client.
@@ -177,14 +174,20 @@ def create_design(self, name: str) -> "Design":
         from ansys.geometry.core.designer.design import Design
 
         check_type(name, str)
+
+        # If a previous design was available... inform the user that it will be deleted
+        # when creating a new design.
+        if self._design is not None and self._design.is_active:
+            self.client.log.warning("Closing previous design before creating a new one.")
+            self._design.close()
+
+        # Create the new design
         design = Design(name, self)
-        self._designs[design.design_id] = design
-        if len(self._designs) > 1:
-            LOG.warning(
-                "Some backends only support one design. "
-                + "Previous designs may be deleted (on the service) when creating a new one."
-            )
-        return self._designs[design.design_id]
+
+        # Update the design stored in the modeler
+        self._design = design
+
+        return self._design
 
     def get_active_design(self, sync_with_backend: bool = True) -> "Design":
         """Get the active design on the modeler object.
@@ -201,14 +204,13 @@ def get_active_design(self, sync_with_backend: bool = True) -> "Design":
         Design
             Design object already existing on the modeler.
         """
-        for _, design in self._designs.items():
-            if design._is_active:
-                # Check if sync_with_backend is requested
-                if sync_with_backend:
-                    design._update_design_inplace()
-
-                # Return the active design
-                return design
+        if self._design is not None and self._design.is_active:
+            # Check if sync_with_backend is requested
+            if sync_with_backend:
+                self._design._update_design_inplace()
+            return self._design
+        else:
+            self.client.log.warning("No active design available.")
 
         return None
 
@@ -222,43 +224,45 @@ def read_existing_design(self) -> "Design":
         """
         from ansys.geometry.core.designer.design import Design
 
-        design = Design("", self, read_existing_design=True)
-        self._designs[design.design_id] = design
-        if len(self._designs) > 1:
-            LOG.warning(
-                "Some backends only support one design. "
-                + "Previous designs may be deleted (on the service) when reading a new one."
-            )
-        return self._designs[design.design_id]
+        # Simply deactivate the existing design in case it is active...
+        # - If it is the same design, it will be re-read (but we should not close it on the server)
+        # - If it is a different design, it was closed previously (via open_file or create_design)
+        if self._design is not None and self._design.is_active:
+            self._design._is_active = False
 
-    def close(self, close_designs: bool = True) -> None:
+        self._design = Design("", self, read_existing_design=True)
+
+        return self._design
+
+    def close(self, close_design: bool = True) -> None:
         """Access the client's close method.
 
         Parameters
         ----------
-        close_designs : bool, default: True
-            Whether to close all designs before closing the client.
+        close_design : bool, default: True
+            Whether to close the design before closing the client.
         """
-        # Close all designs (if requested)
-        [design.close() for design in self._designs.values() if close_designs]
+        # Close design (if requested)
+        if close_design and self._design is not None:
+            self._design.close()
 
         # Close the client
         self.client.close()
 
-    def exit(self, close_designs: bool = True) -> None:
+    def exit(self, close_design: bool = True) -> None:
         """Access the client's close method.
 
         Parameters
         ----------
-        close_designs : bool, default: True
-            Whether to close all designs before closing the client.
+        close_design : bool, default: True
+            Whether to close the design before closing the client.
 
         Notes
         -----
         This method is calling the same method as
         :func:`close() <ansys.geometry.core.modeler.Modeler.close>`.
         """
-        self.close(close_designs=close_designs)
+        self.close(close_design=close_design)
 
     def _upload_file(
         self,
@@ -301,7 +305,7 @@ def _upload_file(
         with fp_path.open(mode="rb") as file:
             data = file.read()
 
-        c_stub = CommandsStub(self._grpc_client.channel)
+        c_stub = CommandsStub(self.client.channel)
 
         response = c_stub.UploadFile(
             UploadFileRequest(
@@ -348,6 +352,10 @@ def open_file(
         # Use str format of Path object here
         file_path = str(file_path) if isinstance(file_path, Path) else file_path
 
+        # Close the existing design if it is active
+        if self._design is not None and self._design.is_active:
+            self._design.close()
+
         # Format-specific logic - upload the whole containing folder for assemblies
         if upload_to_server:
             if any(
@@ -361,7 +369,7 @@ def open_file(
                         self._upload_file(full_path)
             self._upload_file(file_path, True, import_options)
         else:
-            DesignsStub(self._grpc_client.channel).Open(
+            DesignsStub(self.client.channel).Open(
                 OpenRequest(filepath=file_path, import_options=import_options.to_dict())
             )
 
@@ -372,7 +380,7 @@ def __repr__(self) -> str:
         lines = []
         lines.append(f"Ansys Geometry Modeler ({hex(id(self))})")
         lines.append("")
-        lines.append(str(self._grpc_client))
+        lines.append(str(self.client))
         return "\n".join(lines)
 
     @protect_grpc
@@ -468,7 +476,7 @@ def run_discovery_script_file(
                 api_version = ApiVersions.parse_input(api_version)
 
         serv_path = self._upload_file(file_path)
-        ga_stub = DbuApplicationStub(self._grpc_client.channel)
+        ga_stub = DbuApplicationStub(self.client.channel)
         request = RunScriptFileRequest(
             script_path=serv_path,
             script_args=script_args,

tests/integration/conftest.py

@@ -161,11 +161,9 @@ def modeler(session_modeler: Modeler):
     # Yield the modeler
     yield session_modeler
 
-    # Cleanup on exit
-    [design.close() for design in session_modeler.designs.values()]
-
-    # Empty the designs dictionary
-    session_modeler._designs = {}
+    # Cleanup on exit (if design exists)
+    if session_modeler.design:
+        session_modeler.design.close()
 
 
 @pytest.fixture(scope="session", autouse=True)