chore: v1 general cleanup

doc/changelog.d/2455.maintenance.md

@@ -0,0 +1 @@
+Chore: v1 general cleanup

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

@@ -732,8 +732,8 @@ def boolean(self, **kwargs) -> dict:  # noqa: D102
         serialized_tracker_response = {}
         try:
             request = BooleanRequest(
-                body1=kwargs["target"].id,
-                tool_bodies=[other.id for other in kwargs["other"]],
+                body1=kwargs["target"],
+                tool_bodies=[other for other in kwargs["other"]],
                 method=kwargs["method"],
             )
             if pyansys_geom.USE_TRACKER_TO_UPDATE_DESIGN:

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

@@ -311,7 +311,7 @@ def create_box_enclosure(self, **kwargs) -> dict:  # noqa: D102
 
         # Create the request - assumes all inputs are valid and of the proper type
         request = CreateEnclosureBoxRequest(
-            bodies=[GRPCBody(id=body.id) for body in kwargs["bodies"]],
+            bodies=[GRPCBody(id=id) for id in kwargs["body_ids"]],
             x_low=from_measurement_to_server_length(kwargs["x_low"]),
             x_high=from_measurement_to_server_length(kwargs["x_high"]),
             y_low=from_measurement_to_server_length(kwargs["y_low"]),
@@ -345,7 +345,7 @@ def create_cylinder_enclosure(self, **kwargs) -> dict:  # noqa: D102
 
         # Create the request - assumes all inputs are valid and of the proper type
         request = CreateEnclosureCylinderRequest(
-            bodies=[GRPCBody(id=body.id) for body in kwargs["bodies"]],
+            bodies=[GRPCBody(id=id) for id in kwargs["body_ids"]],
             axial_distance_low=from_measurement_to_server_length(kwargs["axial_distance_low"]),
             axial_distance_high=from_measurement_to_server_length(kwargs["axial_distance_high"]),
             radial_distance=from_measurement_to_server_length(kwargs["radial_distance"]),
@@ -376,7 +376,7 @@ def create_sphere_enclosure(self, **kwargs) -> dict:  # noqa: D102
 
         # Create the request - assumes all inputs are valid and of the proper type
         request = CreateEnclosureSphereRequest(
-            bodies=[GRPCBody(id=body.id) for body in kwargs["bodies"]],
+            bodies=[GRPCBody(id=id) for id in kwargs["body_ids"]],
             radial_distance=from_measurement_to_server_length(kwargs["radial_distance"]),
             enclosure_options=grpc_enclosure_options,
         )

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

@@ -517,7 +517,7 @@ def inspect_geometry(self, **kwargs) -> dict:  # noqa: D102
         from ansys.api.geometry.v0.repairtools_pb2 import InspectGeometryRequest
 
         # Create the request - assumes all inputs are valid and of the proper type
-        request = InspectGeometryRequest(bodies=kwargs.get("bodies"))
+        request = InspectGeometryRequest(bodies=kwargs.get("bodies", []))
 
         # Call the gRPC service
         inspect_result_response = self.stub.InspectGeometry(request)

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

@@ -61,9 +61,9 @@ def create_align_condition(self, **kwargs) -> dict:  # noqa: D102
         request = CreateAlignRequest(
             request_data=[
                 CreateAlignRequestData(
-                    parent=build_grpc_id(kwargs["parent_id"]),
-                    geometric_a=build_grpc_id(kwargs["geometric_a_id"]),
-                    geometric_b=build_grpc_id(kwargs["geometric_b_id"]),
+                    parent_id=build_grpc_id(kwargs["parent_id"]),
+                    geometric_a_id=build_grpc_id(kwargs["geometric_a_id"]),
+                    geometric_b_id=build_grpc_id(kwargs["geometric_b_id"]),
                 )
             ]
         )
@@ -93,9 +93,9 @@ def create_tangent_condition(self, **kwargs) -> dict:  # noqa: D102
         request = CreateTangentRequest(
             request_data=[
                 CreateTangentRequestData(
-                    parent=build_grpc_id(kwargs["parent_id"]),
-                    geometric_a=build_grpc_id(kwargs["geometric_a_id"]),
-                    geometric_b=build_grpc_id(kwargs["geometric_b_id"]),
+                    parent_id=build_grpc_id(kwargs["parent_id"]),
+                    geometric_a_id=build_grpc_id(kwargs["geometric_a_id"]),
+                    geometric_b_id=build_grpc_id(kwargs["geometric_b_id"]),
                 )
             ]
         )
@@ -125,9 +125,9 @@ def create_orient_condition(self, **kwargs) -> dict:  # noqa: D102
         request = CreateOrientRequest(
             request_data=[
                 CreateOrientRequestData(
-                    parent=build_grpc_id(kwargs["parent_id"]),
-                    geometric_a=build_grpc_id(kwargs["geometric_a_id"]),
-                    geometric_b=build_grpc_id(kwargs["geometric_b_id"]),
+                    parent_id=build_grpc_id(kwargs["parent_id"]),
+                    geometric_a_id=build_grpc_id(kwargs["geometric_a_id"]),
+                    geometric_b_id=build_grpc_id(kwargs["geometric_b_id"]),
                 )
             ]
         )

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

@@ -456,23 +456,24 @@ def create_surface_body_from_trimmed_curves(self, **kwargs) -> dict:  # noqa: D1
     @protect_grpc
     def translate(self, **kwargs) -> dict:  # noqa: D102
         from ansys.api.discovery.v1.operations.edit_pb2 import (
-            MoveTranslateRequest,
-            MoveTranslateRequestData,
+            TranslateRequest,
+            TranslateRequestData,
         )
 
         # Create the request with selection_ids, direction, and distance
-        request = MoveTranslateRequest(
+        request = TranslateRequest(
             request_data=[
-                MoveTranslateRequestData(
-                    selection_ids=[build_grpc_id(body_id) for body_id in kwargs["ids"]],
-                    direction=from_unit_vector_to_grpc_direction(kwargs["direction"]),
-                    distance=from_length_to_grpc_quantity(kwargs["distance"]),
+                TranslateRequestData(
+                    id=build_grpc_id(id),
+                    translation=from_unit_vector_to_grpc_direction(kwargs["direction"]),
+                    distance=from_measurement_to_server_length(kwargs["distance"]),
                 )
+                for id in kwargs["ids"]
             ]
         )
 
         # Call the gRPC service
-        self.edit_stub.MoveTranslate(request=request)
+        self.edit_stub.Translate(request=request)
 
         # Return the response - formatted as a dictionary
         return {}
@@ -788,30 +789,27 @@ def set_suppressed(self, **kwargs) -> dict:  # noqa: D102
     @protect_grpc
     def rotate(self, **kwargs) -> dict:  # noqa: D102
         from ansys.api.discovery.v1.operations.edit_pb2 import (
-            MoveRotateRequest,
-            MoveRotateRequestData,
+            RotateOptions,
+            RotateRequest,
+            RotateRequestData,
         )
 
-        from ansys.geometry.core.shapes.curves.line import Line
-
-        from .conversions import from_angle_to_grpc_quantity, from_line_to_grpc_line
+        from .conversions import from_angle_to_grpc_quantity
 
-        # Create a Line from axis_origin and axis_direction
-        axis = Line(kwargs["axis_origin"], kwargs["axis_direction"])
+        # Create options
+        options = RotateOptions(
+            angle=from_angle_to_grpc_quantity(kwargs["angle"]),
+            axis_origin=from_point3d_to_grpc_point(kwargs["axis_origin"]),
+            axis_direction=from_unit_vector_to_grpc_direction(kwargs["axis_direction"]),
+        )
 
         # Create the request with selection_ids, axis, and angle
-        request = MoveRotateRequest(
-            request_data=[
-                MoveRotateRequestData(
-                    selection_ids=[build_grpc_id(kwargs["id"])],
-                    axis=from_line_to_grpc_line(axis),
-                    angle=from_angle_to_grpc_quantity(kwargs["angle"]),
-                )
-            ]
+        request = RotateRequest(
+            request_data=[RotateRequestData(id=build_grpc_id(kwargs["id"]), options=options)]
         )
 
         # Call the gRPC service
-        self.edit_stub.MoveRotate(request=request)
+        self.edit_stub.Rotate(request=request)
 
         # Return the response - formatted as a dictionary
         return {}
@@ -838,12 +836,16 @@ def scale(self, **kwargs) -> dict:  # noqa: D102
 
     @protect_grpc
     def mirror(self, **kwargs) -> dict:  # noqa: D102
-        from ansys.api.discovery.v1.operations.edit_pb2 import MirrorRequest
+        from ansys.api.discovery.v1.operations.edit_pb2 import MirrorRequest, MirrorRequestData
 
         # Create the request - assumes all inputs are valid and of the proper type
         request = MirrorRequest(
-            selection_ids=[build_grpc_id(kwargs["id"])],
-            plane=from_plane_to_grpc_plane(kwargs["plane"]),
+            request_data=[
+                MirrorRequestData(
+                    ids=[build_grpc_id(kwargs["id"])],
+                    mirror_plane=from_plane_to_grpc_plane(kwargs["plane"]),
+                )
+            ]
         )
 
         # Call the gRPC service
@@ -988,87 +990,82 @@ def get_tesellation_with_options(self, **kwargs) -> dict:  # noqa: D102
 
     @protect_grpc
     def boolean(self, **kwargs) -> dict:  # noqa: D102
-        # v1 uses the combine method instead of a separate boolean method
-        # Map the v0 parameters to v1 combine parameters
-        return self.combine(
-            target=kwargs["target"],
-            other=kwargs["other"],
-            type_bool_op=kwargs["method"],
+        from ansys.api.discovery.v1.operations.edit_pb2 import BooleanRequest
+
+        # Create the request - assumes all inputs are valid and of the proper type
+        request = BooleanRequest(
+            body1_id=build_grpc_id(kwargs["target"]),
+            tool_body_ids=[build_grpc_id(id) for id in kwargs["other"]],
+            method=kwargs["method"],
             keep_other=kwargs["keep_other"],
-            transfer_named_selections=False,
         )
 
+        # Call the gRPC service
+        response = self.edit_stub.Boolean(request=request)
+
+        if not response.tracked_command_response.command_response.success:
+            raise ValueError(f"Boolean operation failed: {kwargs['err_msg']}")
+
+        # Return the response - formatted as a dictionary
+        return {"complete_command_response": response}
+
     @protect_grpc
     def combine(self, **kwargs) -> dict:  # noqa: D102
         from ansys.api.discovery.v1.operations.edit_pb2 import (
             CombineIntersectBodiesRequest,
             CombineIntersectBodiesRequestData,
-            CombineMergeBodiesRequest,
-            CombineMergeBodiesRequestData,
         )
 
-        target_body = kwargs["target"]
-        other_bodies = kwargs["other"]
-        type_bool_op = kwargs["type_bool_op"]
-        keep_other = kwargs["keep_other"]
-        transfer_named_selections = kwargs.get("transfer_named_selections", False)
+        # Create the request - assumes all inputs are valid and of the proper type
+        request = CombineIntersectBodiesRequest(
+            request_data=[
+                CombineIntersectBodiesRequestData(
+                    target_selection_ids=[build_grpc_id(kwargs["target"])],
+                    tool_selection_ids=[build_grpc_id(id) for id in kwargs["other"]],
+                    keep_cutter=kwargs["keep_other"],
+                    subtract_from_target=True,
+                    transfer_named_selections=kwargs["transfer_named_selections"],
+                )
+            ]
+        )
 
-        if type_bool_op == "intersect":
-            request_data = CombineIntersectBodiesRequestData(
-                target_selection_ids=[build_grpc_id(target_body)],
-                tool_selection_ids=[build_grpc_id(body) for body in other_bodies],
-                keep_cutter=keep_other,
-                subtract_from_target=False,
-                transfer_named_selections=transfer_named_selections,
-            )
-            request = CombineIntersectBodiesRequest(request_data=[request_data])
-            response = self.edit_stub.CombineIntersectBodies(request=request)
-        elif type_bool_op == "subtract":
-            request_data = CombineIntersectBodiesRequestData(
-                target_selection_ids=[build_grpc_id(target_body)],
-                tool_selection_ids=[build_grpc_id(body) for body in other_bodies],
-                keep_cutter=keep_other,
-                subtract_from_target=True,
-                transfer_named_selections=transfer_named_selections,
-            )
-            request = CombineIntersectBodiesRequest(request_data=[request_data])
-            response = self.edit_stub.CombineIntersectBodies(request=request)
-        elif type_bool_op == "unite":
-            # Create request data with all body IDs
-            all_body_ids = [build_grpc_id(target_body)]
-            all_body_ids.extend([build_grpc_id(body) for body in other_bodies])
-
-            request_data = CombineMergeBodiesRequestData(target_selection_ids=all_body_ids)
-            request = CombineMergeBodiesRequest(request_data=[request_data])
-            response = self.edit_stub.CombineMergeBodies(request=request)
-        else:
-            raise ValueError(f"Invalid boolean operation type: {type_bool_op}")
-
-        if not response.success:
-            raise ValueError(f"Boolean operation failed: {response}")
+        # Call the gRPC service
+        response = self.edit_stub.CombineIntersectBodies(request=request)
+
+        if not response.tracked_command_response.command_response.success:
+            raise ValueError(f"Boolean operation failed: {kwargs['err_msg']}")
 
         # Return the response - formatted as a dictionary
         return {"complete_command_response": response}
 
     @protect_grpc
     def split_body(self, **kwargs) -> dict:  # noqa: D102
-        from ansys.api.discovery.v1.operations.edit_pb2 import SplitBodyRequest
+        from ansys.api.discovery.v1.operations.edit_pb2 import (
+            SplitBodyRequest,
+            SplitBodyRequestData,
+        )
 
         # Create the request - assumes all inputs are valid and of the proper type
         request = SplitBodyRequest(
-            selection=[build_grpc_id(id) for id in kwargs["body_ids"]],
-            split_by_plane=from_plane_to_grpc_plane(kwargs["plane"]) if kwargs["plane"] else None,
-            split_by_slicer=[build_grpc_id(id) for id in kwargs["slicer_ids"]],
-            split_by_faces=[build_grpc_id(id) for id in kwargs["face_ids"]],
-            extend_surfaces=kwargs["extend_surfaces"],
+            request_data=[
+                SplitBodyRequestData(
+                    selection_ids=[build_grpc_id(id) for id in kwargs["body_ids"]],
+                    split_by_plane=(
+                        from_plane_to_grpc_plane(kwargs["plane"]) if kwargs["plane"] else None
+                    ),
+                    split_by_slicer_ids=[build_grpc_id(id) for id in kwargs["slicer_ids"]],
+                    split_by_face_ids=[build_grpc_id(id) for id in kwargs["face_ids"]],
+                    extend_surfaces=kwargs["extend_surfaces"],
+                )
+            ]
         )
 
         # Call the gRPC service
         resp = self.edit_stub.SplitBodies(request=request)
 
         # Return the response - formatted as a dictionary
         return {
-            "success": resp.success,
+            "success": resp.tracked_command_response.command_response.success,
         }
 
     @protect_grpc
@@ -1145,7 +1142,7 @@ def assign_midsurface_thickness(self, **kwargs) -> dict:  # noqa: D102
             request_data=[
                 SetMidSurfaceThicknessRequestData(
                     ids=[build_grpc_id(id) for id in kwargs["ids"]],
-                    thickness=from_measurement_to_server_length(kwargs["thickness"]),
+                    thickness=from_length_to_grpc_quantity(kwargs["thickness"]),
                 )
             ]
         )

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

@@ -89,10 +89,20 @@ def create(self, **kwargs) -> dict:  # noqa: D102
 
     @protect_grpc
     def set_name(self, **kwargs) -> dict:  # noqa: D102
-        from ansys.api.discovery.v1.design.designmessages_pb2 import SetDesignEntityNameRequest
+        from ansys.api.discovery.v1.design.designmessages_pb2 import (
+            SetDesignEntityNameRequest,
+            SetDesignEntityNameRequestData,
+        )
 
         # Create the request - assumes all inputs are valid and of the proper type
-        request = SetDesignEntityNameRequest(id=build_grpc_id(kwargs["id"]), name=kwargs["name"])
+        request = SetDesignEntityNameRequest(
+            request_data=[
+                SetDesignEntityNameRequestData(
+                    id=build_grpc_id(kwargs["id"]),
+                    name=kwargs["name"],
+                )
+            ]
+        )
 
         # Call the gRPC service
         _ = self.stub.SetName(request)

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

@@ -478,7 +478,11 @@ def from_grpc_edge_tess_to_pd(tess: GRPCEdgeTessellation) -> "pv.PolyData":
 
 def from_grpc_edge_tess_to_raw_data(tess: GRPCEdgeTessellation) -> dict:
     """Convert a ``EdgeTessellation`` to raw data."""
-    return {"vertices": [coord for pt in tess.vertices for coord in (pt.x, pt.y, pt.z)]}
+    return {
+        "vertices": [
+            coord.value_in_geometry_units for pt in tess.vertices for coord in (pt.x, pt.y, pt.z)
+        ]
+    }
 
 
 def from_tess_options_to_grpc_tess_options(
@@ -1204,15 +1208,18 @@ def from_grpc_surface_to_surface(surface: GRPCSurface, surface_type: "SurfaceTyp
     origin = from_grpc_point_to_point3d(surface.origin)
     axis = UnitVector3D([surface.axis.x, surface.axis.y, surface.axis.z])
     reference = UnitVector3D([surface.reference.x, surface.reference.y, surface.reference.z])
+    radius = surface.radius.value_in_geometry_units
+    major_radius = surface.major_radius.value_in_geometry_units
+    minor_radius = surface.minor_radius.value_in_geometry_units
 
     if surface_type == SurfaceType.SURFACETYPE_CONE:
-        result = Cone(origin, surface.radius, surface.half_angle, reference, axis)
+        result = Cone(origin, radius, surface.half_angle.value_in_geometry_units, reference, axis)
     elif surface_type == SurfaceType.SURFACETYPE_CYLINDER:
-        result = Cylinder(origin, surface.radius, reference, axis)
+        result = Cylinder(origin, radius, reference, axis)
     elif surface_type == SurfaceType.SURFACETYPE_SPHERE:
-        result = Sphere(origin, surface.radius, reference, axis)
+        result = Sphere(origin, radius, reference, axis)
     elif surface_type == SurfaceType.SURFACETYPE_TORUS:
-        result = Torus(origin, surface.major_radius, surface.minor_radius, reference, axis)
+        result = Torus(origin, major_radius, minor_radius, reference, axis)
     elif surface_type == SurfaceType.SURFACETYPE_PLANE:
         result = PlaneSurface(origin, reference, axis)
     else:
@@ -1264,7 +1271,7 @@ def from_driving_dimension_to_grpc_driving_dimension(
         id=driving_dimension.id,
         name=driving_dimension.name,
         dimension_type=driving_dimension.dimension_type.value,
-        dimension_value=from_length_to_grpc_quantity(driving_dimension.dimension_value),
+        dimension_value=GRPCQuantity(value_in_geometry_units=driving_dimension.dimension_value),
     )