finalize testing and accepting multiple bodies to detect sweepability

Author: jacobrkerstetter

src/ansys/geometry/core/_grpc/_services/v0/prepare_tools.py

@@ -394,13 +394,13 @@ def create_sphere_enclosure(self, **kwargs) -> dict:  # noqa: D102
             "tracker_response": serialized_tracker_response,
         }
 
-	@protect_grpc
+    @protect_grpc
     def is_body_sweepable(self, **kwargs):  # noqa: D102
         from ansys.api.geometry.v0.preparetools_pb2 import IsBodySweepableRequest
 
         # Create the request - assumes all inputs are valid and of the proper type
         request = IsBodySweepableRequest(
-            body=build_grpc_id(kwargs["body_id"]),
+            bodies=[build_grpc_id(id=id) for id in kwargs["body_ids"]],
             get_source_target_faces=kwargs["get_source_target_faces"],
         )
 
@@ -409,13 +409,11 @@ def is_body_sweepable(self, **kwargs):  # noqa: D102
 
         # Return the response - formatted as a dictionary
         return {
-            "result": response.result,
-            "faces": [
+            "results": [
                 {
-                    "id": face.id,
-                    "surface_type": face.surface_type,
-                    "is_reversed": face.is_reversed,
+                    "sweepable": result.result,
+                    "face_ids": [face.id for face in result.face_ids]
                 }
-                for face in response.faces
-            ],
+                for result in response.response_data
+            ]
         }

src/ansys/geometry/core/_grpc/_services/v1/prepare_tools.py

@@ -96,4 +96,5 @@ def create_sphere_enclosure(self, **kwargs) -> dict:  # noqa: D102
         raise NotImplementedError
 
     @protect_grpc
-    def is_body_sweepable(self, **kwargs):  # noqa: D102
+    def is_body_sweepable(self, **kwargs):  # noqa: D102
+        raise NotImplementedError

src/ansys/geometry/core/tools/prepare_tools.py

@@ -38,6 +38,7 @@
     get_design_from_body,
     get_design_from_edge,
     get_design_from_face,
+    get_faces_from_ids,
 )
 from ansys.geometry.core.misc.checks import check_type_all_elements_in_iterable, min_backend_version
 from ansys.geometry.core.misc.measurements import Distance
@@ -780,48 +781,44 @@ def create_sphere_enclosure(
             self._grpc_client.log.info("Failed to create enclosure...")
             return []
 
-	@min_backend_version(26, 1, 0)
+    @min_backend_version(26, 1, 0)
     def is_body_sweepable(
         self,
-        body: "Body",
+        bodies: list["Body"],
         get_source_target_faces: bool = False,
-    ) -> tuple[bool, list["Face"]]:
-        """Check if a body is sweepable.
+    ) -> list[tuple[bool, list["Face"]]]:
+        """Check if bodies are sweepable.
 
         Parameters
         ----------
-        body : Body
-            Body to check.
+        bodies : list[Body]
+            List of bodies to check.
         get_source_target_faces : bool
             Whether to get source and target faces. By default, ``False``.
 
         Returns
         -------
-        tuple[bool, list[Face]]
-            Tuple containing a boolean indicating if the body is sweepable and
+        list[tuple[bool, list[Face]]]
+            List of tuples, each containing a boolean indicating if the body is sweepable and
             a list of source and target faces if requested.
         """
         from ansys.geometry.core.designer.body import Body
-        from ansys.geometry.core.designer.face import Face, SurfaceType
+        check_type_all_elements_in_iterable(bodies, Body)
 
-        # Verify inputs
-        check_type_all_elements_in_iterable([body], Body)
+        if not bodies:
+            return []
 
         response = self._grpc_client._services.prepare_tools.is_body_sweepable(
-            body_id=body.id,
+            body_ids=[body.id for body in bodies],
             get_source_target_faces=get_source_target_faces,
         )
 
-        faces = []
-        if get_source_target_faces:
-            faces = [
-                Face(
-                    face.get("id"),
-                    SurfaceType(face.get("surface_type")),
-                    self,
-                    self._grpc_client,
-                )
-            for face in response.get("faces")
-        ]
+        results = []
+        for result_data in response.get("results"):
+            faces = []
+            parent_design = get_design_from_body(bodies[0])
+            if get_source_target_faces:
+                faces.extend(get_faces_from_ids(parent_design, result_data.get("face_ids")))
+            results.append((result_data.get("sweepable"), faces))
 
-        return (response.get("result"), faces)
+        return results

tests/integration/test_prepare_tools.py

@@ -298,12 +298,46 @@ def test_sphere_enclosure(modeler):
 
 def test_is_body_sweepable(modeler: Modeler):
     """Test body sweepability detection."""
-    design = modeler.open_file(FILES_DIR / "1mm_Cube.dsco")
+    design = modeler.open_file(FILES_DIR / "DifferentShapes.scdocx")
 
     bodies = design.bodies
-    assert len(bodies) == 1
+    assert len(bodies) == 6
 
     # Test sweepability of the body
-    is_sweepable, faces = modeler.prepare_tools.is_body_sweepable(bodies[0])
+    is_sweepable, faces = modeler.prepare_tools.is_body_sweepable([bodies[0]])[0]
     assert is_sweepable
     assert len(faces) == 0
+
+    # Test non-sweepable body
+    is_sweepable, faces = modeler.prepare_tools.is_body_sweepable([bodies[2]])[0]
+    assert not is_sweepable
+    assert len(faces) == 0
+
+    # Test sweepability of a body and getting faces
+    is_sweepable, faces = modeler.prepare_tools.is_body_sweepable(
+        [bodies[0]], get_source_target_faces=True
+    )[0]
+    assert is_sweepable
+    assert len(faces) == 2
+
+    # Test multiple bodies at once
+    result = modeler.prepare_tools.is_body_sweepable(bodies)
+    assert len(result) == 6
+    assert result[0][0]  # first body is sweepable
+    assert result[1][0]  # second body is sweepable
+    assert not result[2][0]  # third body is not sweepable
+    assert not result[3][0]  # fourth body is not sweepable
+
+    # Test with multiple bodys and getting faces
+    result = modeler.prepare_tools.is_body_sweepable(bodies, get_source_target_faces=True)
+    assert len(result) == 6
+    assert result[0][0]  # first body is sweepable
+    assert len(result[0][1]) == 2  # two faces for first body
+    assert result[1][0]  # second body is sweepable
+    assert len(result[1][1]) == 2  # two faces for second body
+    assert not result[2][0]  # third body is not sweepable
+    assert len(result[2][1]) == 0  # no faces for third body
+
+    # Test with empty input
+    result = modeler.prepare_tools.is_body_sweepable([])
+    assert result == []