wip

Author: jacobrkerstetter

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

@@ -21,11 +21,21 @@
 # SOFTWARE.
 """Module containing the edges service implementation for v1."""
 
+from ansys.api.discovery.v1.commonmessages_pb2 import MultipleEntitiesRequest
 import grpc
 
 from ansys.geometry.core.errors import protect_grpc
 
+from ..base.conversions import to_distance
 from ..base.edges import GRPCEdgesService
+from .conversions import (
+    build_grpc_id,
+    from_grpc_curve_to_curve,
+    from_grpc_point_to_point3d,
+    from_length_to_grpc_quantity,
+    from_point3d_to_grpc_point,
+    from_unit_vector_to_grpc_direction,
+)
 
 
 class GRPCEdgesServiceV1(GRPCEdgesService):  # pragma: no cover
@@ -43,45 +53,168 @@ class GRPCEdgesServiceV1(GRPCEdgesService):  # pragma: no cover
 
     @protect_grpc
     def __init__(self, channel: grpc.Channel):  # noqa: D102
-        from ansys.api.geometry.v1.edges_pb2_grpc import EdgesStub
+        from ansys.api.discovery.v1.design.geometry.edge_pb2_grpc import EdgeStub
+        from ansys.api.discovery.v1.operations.edit_pb2_grpc import EditStub
 
-        self.stub = EdgesStub(channel)
+        self.stub = EdgeStub(channel)
+        self.EditStub = EditStub(channel)
 
     @protect_grpc
     def get_edge(self, **kwargs) -> dict:  # noqa: D102
-        return NotImplementedError
+        from ansys.api.discovery.v1.commonmessages_pb2 import EntityRequest
+
+        # Create the request - assumes all inputs are valid and of the proper type
+        request = EntityRequest(id=build_grpc_id(kwargs["id"]))
+
+        # Call the gRPC service
+        response = self.stub.Get(request=request)
+
+        # Return the response - formatted as a dictionary
+        return {
+            "id": response.edge.id,
+            "curve_type": response.edge.curve_type,
+            "is_reversed": response.edge.is_reversed,
+        }
 
     @protect_grpc
     def get_curve(self, **kwargs) -> dict:  # noqa: D102
-        return NotImplementedError
+        # Create the request - assumes all inputs are valid and of the proper type
+        request = MultipleEntitiesRequest(ids=[build_grpc_id(kwargs["id"])])
+
+        # Call the gRPC service
+        response = self.stub.GetCurve(request=request).response_data[0]
+
+        # Return the response - formatted as a dictionary
+        return {
+            "curve": from_grpc_curve_to_curve(response.curve),
+        }
 
     @protect_grpc
     def get_start_and_end_points(self, **kwargs) -> dict:  # noqa: D102
-        return NotImplementedError
+        # Create the request - assumes all inputs are valid and of the proper type
+        request = MultipleEntitiesRequest(ids=[build_grpc_id(kwargs["id"])])
+
+        # Call the gRPC service
+        response = self.stub.GetStartAndEndPoints(request=request).response_data[0]
+
+        # Return the response - formatted as a dictionary
+        return {
+            "start": from_grpc_point_to_point3d(response.start),
+            "end": from_grpc_point_to_point3d(response.end),
+        }
 
     @protect_grpc
     def get_length(self, **kwargs) -> dict:  # noqa: D102
-        return NotImplementedError
+        # Create the request - assumes all inputs are valid and of the proper type
+        request = MultipleEntitiesRequest(ids=[build_grpc_id(kwargs["id"])])
+
+        # Call the gRPC service
+        response = self.stub.GetLength(request=request).response_data[0]
+
+        # Return the response - formatted as a dictionary
+        return {
+            "length": to_distance(response.length.value_in_geometry_units),
+        }
 
     @protect_grpc
     def get_interval(self, **kwargs) -> dict:  # noqa: D102
-        return NotImplementedError
+        # Create the request - assumes all inputs are valid and of the proper type
+        request = MultipleEntitiesRequest(ids=[build_grpc_id(kwargs["id"])])
+
+        # Call the gRPC service
+        response = self.stub.GetInterval(request=request).response_data[0]
+
+        # Return the response - formatted as a dictionary
+        return {
+            "start": response.start,
+            "end": response.end,
+        }
 
     @protect_grpc
     def get_faces(self, **kwargs) -> dict:  # noqa: D102
-        return NotImplementedError
+        # Create the request - assumes all inputs are valid and of the proper type
+        request = MultipleEntitiesRequest(ids=[build_grpc_id(kwargs["id"])])
+
+        # Call the gRPC service
+        response = self.stub.GetFaces(request=request).response_data[0]
+
+        # Return the response - formatted as a dictionary
+        return {
+            "faces": [
+                {
+                    "id": face.id,
+                    "surface_type": face.surface_type,
+                    "is_reversed": face.is_reversed,
+                }
+                for face in response.faces
+            ],
+        }
 
     @protect_grpc
     def get_vertices(self, **kwargs) -> dict:  # noqa: D102
-        return NotImplementedError
+        # Create the request - assumes all inputs are valid and of proper type
+        request = MultipleEntitiesRequest(ids=[build_grpc_id(kwargs["id"])])
+
+        # Call the gRPC service
+        response = self.stub.GetVertices(request=request).response_data[0]
+
+        # Return the response - formatted as a dictionary
+        return {
+            "vertices": [
+                {
+                    "id": vertex.id.id,
+                    "position": from_grpc_point_to_point3d(vertex.position),
+                }
+                for vertex in response.vertices
+            ],
+        }
 
     @protect_grpc
     def get_bounding_box(self, **kwargs) -> dict:  # noqa: D102
-        return NotImplementedError
+        # Create the request - assumes all inputs are valid and of the proper type
+        request = MultipleEntitiesRequest(ids=[build_grpc_id(kwargs["id"])])
+
+        # Call the gRPC service
+        response = self.stub.GetBoundingBox(request=request).response_data[0]
+
+        # Return the response - formatted as a dictionary
+        return {
+            "min_corner": from_grpc_point_to_point3d(response.box.min),
+            "max_corner": from_grpc_point_to_point3d(response.box.max),
+            "center": from_grpc_point_to_point3d(response.box.center),
+        }
 
     @protect_grpc
     def extrude_edges(self, **kwargs) -> dict:  # noqa: D102
-        return NotImplementedError
+        from ansys.api.geometry.v0.commands_pb2 import ExtrudeEdgesRequest
+
+        # Parse some optional arguments
+        point = from_point3d_to_grpc_point(kwargs["point"]) if kwargs["point"] else None
+        direction = (
+            from_unit_vector_to_grpc_direction(kwargs["direction"]) if kwargs["direction"] else None
+        )
+
+        # Create the request - assumes all inputs are valid and of the proper type
+        request = ExtrudeEdgesRequest(
+            edges=[build_grpc_id(edge_id) for edge_id in kwargs["edge_ids"]],
+            distance=from_length_to_grpc_quantity(kwargs["distance"]),
+            face=build_grpc_id(kwargs["face"]),
+            point=point,
+            direction=direction,
+            extrude_type=kwargs["extrude_type"].value,
+            pull_symmetric=kwargs["pull_symmetric"],
+            copy=kwargs["copy"],
+            natural_extension=kwargs["natural_extension"],
+        )
+
+        # Call the gRPC service
+        resp = self.EditStub.ExtrudeEdges(request)
+
+        # Return the response - formatted as a dictionary
+        return {
+            "created_bodies": [body.id for body in resp.created_bodies],
+            "success": resp.success,
+        }
 
     @protect_grpc
     def extrude_edges_up_to(self, **kwargs) -> dict:  # noqa: D102