feat: standarizing response usage, handling conversion and simplifying access

Author: RobPasMue

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

@@ -21,7 +21,7 @@
 # SOFTWARE.
 """Module containing server-version agnostic conversions."""
 
-from ansys.geometry.core.misc.measurements import DEFAULT_UNITS, Measurement
+from ansys.geometry.core.misc.measurements import DEFAULT_UNITS, Distance, Measurement
 
 
 def from_measurement_to_server_length(input: Measurement) -> float:
@@ -54,3 +54,24 @@ def from_measurement_to_server_angle(input: Measurement) -> float:
         Angle value in server-defined units. By default, radians.
     """
     return input.value.m_as(DEFAULT_UNITS.SERVER_ANGLE)
+
+
+def to_distance(value: float | int) -> Distance:
+    """Convert a server value to a Distance object.
+
+    Notes
+    -----
+    The value is converted to a Distance object using the default server length unit.
+    The value should represent a length in the server's unit system.
+
+    Parameters
+    ----------
+    value : float | int
+        Value to convert.
+
+    Returns
+    -------
+    Distance
+        Converted distance.
+    """
+    return Distance(value, DEFAULT_UNITS.SERVER_LENGTH)

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

@@ -51,25 +51,21 @@ def __init__(self, channel: grpc.Channel):  # noqa: D102
     def min_distance_between_objects(self, **kwargs) -> dict:  # noqa: D102
         from ansys.api.geometry.v0.measuretools_pb2 import MinDistanceBetweenObjectsRequest
 
-        bodies = kwargs["bodies"]
-        selection = kwargs["selection"]
-        backend_version = kwargs["backend_version"]
+        from ..base.conversions import to_distance
 
         # Create the request - assumes all inputs are valid and of the proper type
         # Request is different based on backend_version (25.2 vs. earlier)
-        if backend_version < (25, 2, 0):
-            request = MinDistanceBetweenObjectsRequest(bodies=bodies)
+        if kwargs["backend_version"] < (25, 2, 0):
+            request = MinDistanceBetweenObjectsRequest(bodies=kwargs["selection"])
         else:
             from ansys.api.dbu.v0.dbumodels_pb2 import EntityIdentifier
 
             request = MinDistanceBetweenObjectsRequest(
-                selection=[EntityIdentifier(id=selection[0]), EntityIdentifier(id=selection[1])]
+                selection=[EntityIdentifier(id=item) for item in kwargs["selection"]]
             )
 
         # Call the gRPC service
         response = self.stub.MinDistanceBetweenSelectionObjects(request)
 
         # Return the response - formatted as a dictionary
-        return {
-            "distance": response.gap.distance,
-        }
+        return {"distance": to_distance(response.gap.distance)}

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

@@ -189,8 +189,8 @@ def __init__(
         response = self._services.admin.get_backend()
 
         # Store the backend type and version
-        self._backend_type = response["backend"]
-        self._backend_version = response["version"]
+        self._backend_type = response.get("backend")
+        self._backend_version = response.get("version")
 
         # Register the close method to be called at exit - irrespectively of
         # the user calling it or not...
@@ -357,8 +357,7 @@ def _get_service_logs(
             the current logs are retrieved). The ``dump_to_file`` parameter
             must be set to ``True``.
         """
-        response = self._services.admin.get_logs(all_logs=all_logs)
-        logs: dict[str, str] = response["logs"]
+        logs: dict[str, str] = self._services.admin.get_logs(all_logs=all_logs).get("logs")
 
         # Let's handle the various scenarios...
         if not dump_to_file:

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

@@ -129,7 +129,7 @@ def __init__(
         response = self._grpc_client.services.named_selection.create_named_selection(
             name=name, members=ids
         )
-        self._id = response["id"]
+        self._id = response.get("id")
 
     @property
     def id(self) -> str:
@@ -204,15 +204,15 @@ def __verify_ns(self) -> None:
             return
 
         # Get all entities from the named selection
-        resp = self._grpc_client.services.named_selection.get_named_selection(id=self._id)
+        response = self._grpc_client.services.named_selection.get_named_selection(id=self._id)
 
         # Check if the named selection has changed
         ids = {
-            "bodies": resp["bodies"],
-            "faces": resp["faces"],
-            "edges": resp["edges"],
-            "beams": resp["beams"],
-            "design_points": resp["design_points"],
+            "bodies": response.get("bodies"),
+            "faces": response.get("faces"),
+            "edges": response.get("edges"),
+            "beams": response.get("beams"),
+            "design_points": response.get("design_points"),
         }
 
         for key in ids:

src/ansys/geometry/core/modeler.py

@@ -566,15 +566,15 @@ def run_discovery_script_file(
             api_version=api_version.value if api_version is not None else None,
         )
 
-        if not response["success"]:
-            raise GeometryRuntimeError(response["message"])
+        if not response.get("success"):
+            raise GeometryRuntimeError(response.get("message"))
 
-        self.client.log.debug(f"Script result message: {response['message']}")
+        self.client.log.debug(f"Script result message: {response.get('message')}")
 
         if import_design:
-            return response["values"], self.read_existing_design()
+            return response.get("values"), self.read_existing_design()
         else:
-            return response["values"], None
+            return response.get("values"), None
 
     @property
     def repair_tools(self) -> RepairTools:

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

@@ -25,8 +25,7 @@
 
 from ansys.geometry.core.connection import GrpcClient
 from ansys.geometry.core.misc.checks import min_backend_version
-from ansys.geometry.core.misc.measurements import DEFAULT_UNITS, Distance
-from ansys.geometry.core.typing import Real
+from ansys.geometry.core.misc.measurements import Distance
 
 if TYPE_CHECKING:  # pragma: no cover
     from ansys.geometry.core.designer.body import Body
@@ -52,23 +51,6 @@ def distance(self) -> Distance:
         """Returns the closest distance between two bodies."""
         return self._distance
 
-    @classmethod
-    def _from_distance_response(cls, distance: Real) -> "Gap":
-        """Construct ``Gap`` object from distance response.
-
-        Parameters
-        ----------
-        response : MinDistanceBetweenObjectsResponse
-            Response from the gRPC server.
-
-        Notes
-        -----
-        This method is used internally to construct a ``Gap`` object from a
-        gRPC response.
-        """
-        distance = Distance(distance, unit=DEFAULT_UNITS.LENGTH)
-        return cls(distance)
-
 
 class MeasurementTools:
     """Measurement tools for PyAnsys Geometry.
@@ -102,8 +84,7 @@ def min_distance_between_objects(
             Gap between two bodies.
         """
         response = self._grpc_client.services.measurement_tools.min_distance_between_objects(
-            bodies=[object1.id, object2.id],
             selection=[object1.id, object2.id],
             backend_version=self._grpc_client.backend_version,
         )
-        return Gap._from_distance_response(response["distance"])
+        return Gap(response.get("distance"))