luminarycloud 0.22.3__py3-none-any.whl → 0.23.1__py3-none-any.whl

luminarycloud/_proto/geometry/geometry_pb2.pyi

@@ -435,7 +435,7 @@ class Pattern(google.protobuf.message.Message):
             def rotation(self) -> luminarycloud._proto.cad.transformation_pb2.Rotation:
                 """Rotation transformation."""
             full: builtins.bool
-            """Whether it's a full rotation: invalidates the andle in 'rotation'."""
+            """Whether it's a full rotation: invalidates the angle in 'rotation'."""
             def __init__(
                 self,
                 *,

luminarycloud/_proto/physicsaitrainingservice/physicsaitrainingservice_pb2.py

@@ -16,7 +16,7 @@ from luminarycloud._proto.api.v0.luminarycloud.physics_ai import physics_ai_pb2
 from luminarycloud._proto.ratelimit import ratelimit_pb2 as proto_dot_ratelimit_dot_ratelimit__pb2
 
 
-DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n=proto/physicsaitrainingservice/physicsaitrainingservice.proto\x12\'luminary.proto.physicsaitrainingservice\x1a\x36proto/api/v0/luminarycloud/physics_ai/physics_ai.proto\x1a\x1fproto/ratelimit/ratelimit.proto2\xbd\x05\n\x18PhysicsAiTrainingService\x12\x9e\x01\n\rCreateDataset\x12\x44.luminary.proto.api.v0.luminarycloud.physics_ai.CreateDatasetRequest\x1a\x45.luminary.proto.api.v0.luminarycloud.physics_ai.CreateDatasetResponse\"\x00\x12\x9b\x01\n\x0cListDatasets\x12\x43.luminary.proto.api.v0.luminarycloud.physics_ai.ListDatasetsRequest\x1a\x44.luminary.proto.api.v0.luminarycloud.physics_ai.ListDatasetsResponse\"\x00\x12\xb4\x01\n\x11SubmitTrainingJob\x12H.luminary.proto.api.v0.luminarycloud.physics_ai.SubmitTrainingJobRequest\x1aI.luminary.proto.api.v0.luminarycloud.physics_ai.SubmitTrainingJobResponse\"\n\x8a\xb5\x18\x06\x08\x05\x12\x02\x08\x01\x12\xaa\x01\n\x11\x43\x61ncelTrainingJob\x12H.luminary.proto.api.v0.luminarycloud.physics_ai.CancelTrainingJobRequest\x1aI.luminary.proto.api.v0.luminarycloud.physics_ai.CancelTrainingJobResponse\"\x00\x42\x37Z5luminarycloud.com/core/proto/physicsaitrainingserviceb\x06proto3')
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n=proto/physicsaitrainingservice/physicsaitrainingservice.proto\x12\'luminary.proto.physicsaitrainingservice\x1a\x36proto/api/v0/luminarycloud/physics_ai/physics_ai.proto\x1a\x1fproto/ratelimit/ratelimit.proto2\x8b\x08\n\x18PhysicsAiTrainingService\x12\x9e\x01\n\rCreateDataset\x12\x44.luminary.proto.api.v0.luminarycloud.physics_ai.CreateDatasetRequest\x1a\x45.luminary.proto.api.v0.luminarycloud.physics_ai.CreateDatasetResponse\"\x00\x12\x9b\x01\n\x0cListDatasets\x12\x43.luminary.proto.api.v0.luminarycloud.physics_ai.ListDatasetsRequest\x1a\x44.luminary.proto.api.v0.luminarycloud.physics_ai.ListDatasetsResponse\"\x00\x12\xb4\x01\n\x11SubmitTrainingJob\x12H.luminary.proto.api.v0.luminarycloud.physics_ai.SubmitTrainingJobRequest\x1aI.luminary.proto.api.v0.luminarycloud.physics_ai.SubmitTrainingJobResponse\"\n\x8a\xb5\x18\x06\x08\x05\x12\x02\x08\x01\x12\xaa\x01\n\x11\x43\x61ncelTrainingJob\x12H.luminary.proto.api.v0.luminarycloud.physics_ai.CancelTrainingJobRequest\x1aI.luminary.proto.api.v0.luminarycloud.physics_ai.CancelTrainingJobResponse\"\x00\x12\xa1\x01\n\x0eGetTrainingJob\x12\x45.luminary.proto.api.v0.luminarycloud.physics_ai.GetTrainingJobRequest\x1a\x46.luminary.proto.api.v0.luminarycloud.physics_ai.GetTrainingJobResponse\"\x00\x12\xa7\x01\n\x10ListTrainingJobs\x12G.luminary.proto.api.v0.luminarycloud.physics_ai.ListTrainingJobsRequest\x1aH.luminary.proto.api.v0.luminarycloud.physics_ai.ListTrainingJobsResponse\"\x00\x42\x37Z5luminarycloud.com/core/proto/physicsaitrainingserviceb\x06proto3')
 
 
 
@@ -28,5 +28,5 @@ if _descriptor._USE_C_DESCRIPTORS == False:
   _PHYSICSAITRAININGSERVICE.methods_by_name['SubmitTrainingJob']._options = None
   _PHYSICSAITRAININGSERVICE.methods_by_name['SubmitTrainingJob']._serialized_options = b'\212\265\030\006\010\005\022\002\010\001'
   _PHYSICSAITRAININGSERVICE._serialized_start=196
-  _PHYSICSAITRAININGSERVICE._serialized_end=897
+  _PHYSICSAITRAININGSERVICE._serialized_end=1231
 # @@protoc_insertion_point(module_scope)

luminarycloud/_proto/physicsaitrainingservice/physicsaitrainingservice_pb2_grpc.py

@@ -35,6 +35,16 @@ class PhysicsAiTrainingServiceStub(object):
                 request_serializer=proto_dot_api_dot_v0_dot_luminarycloud_dot_physics__ai_dot_physics__ai__pb2.CancelTrainingJobRequest.SerializeToString,
                 response_deserializer=proto_dot_api_dot_v0_dot_luminarycloud_dot_physics__ai_dot_physics__ai__pb2.CancelTrainingJobResponse.FromString,
                 )
+        self.GetTrainingJob = channel.unary_unary(
+                '/luminary.proto.physicsaitrainingservice.PhysicsAiTrainingService/GetTrainingJob',
+                request_serializer=proto_dot_api_dot_v0_dot_luminarycloud_dot_physics__ai_dot_physics__ai__pb2.GetTrainingJobRequest.SerializeToString,
+                response_deserializer=proto_dot_api_dot_v0_dot_luminarycloud_dot_physics__ai_dot_physics__ai__pb2.GetTrainingJobResponse.FromString,
+                )
+        self.ListTrainingJobs = channel.unary_unary(
+                '/luminary.proto.physicsaitrainingservice.PhysicsAiTrainingService/ListTrainingJobs',
+                request_serializer=proto_dot_api_dot_v0_dot_luminarycloud_dot_physics__ai_dot_physics__ai__pb2.ListTrainingJobsRequest.SerializeToString,
+                response_deserializer=proto_dot_api_dot_v0_dot_luminarycloud_dot_physics__ai_dot_physics__ai__pb2.ListTrainingJobsResponse.FromString,
+                )
 
 
 class PhysicsAiTrainingServiceServicer(object):
@@ -69,6 +79,20 @@ class PhysicsAiTrainingServiceServicer(object):
         context.set_details('Method not implemented!')
         raise NotImplementedError('Method not implemented!')
 
+    def GetTrainingJob(self, request, context):
+        """Get a physics AI training job by ID
+        """
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def ListTrainingJobs(self, request, context):
+        """List physics AI training jobs for the current user
+        """
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
 
 def add_PhysicsAiTrainingServiceServicer_to_server(servicer, server):
     rpc_method_handlers = {
@@ -92,6 +116,16 @@ def add_PhysicsAiTrainingServiceServicer_to_server(servicer, server):
                     request_deserializer=proto_dot_api_dot_v0_dot_luminarycloud_dot_physics__ai_dot_physics__ai__pb2.CancelTrainingJobRequest.FromString,
                     response_serializer=proto_dot_api_dot_v0_dot_luminarycloud_dot_physics__ai_dot_physics__ai__pb2.CancelTrainingJobResponse.SerializeToString,
             ),
+            'GetTrainingJob': grpc.unary_unary_rpc_method_handler(
+                    servicer.GetTrainingJob,
+                    request_deserializer=proto_dot_api_dot_v0_dot_luminarycloud_dot_physics__ai_dot_physics__ai__pb2.GetTrainingJobRequest.FromString,
+                    response_serializer=proto_dot_api_dot_v0_dot_luminarycloud_dot_physics__ai_dot_physics__ai__pb2.GetTrainingJobResponse.SerializeToString,
+            ),
+            'ListTrainingJobs': grpc.unary_unary_rpc_method_handler(
+                    servicer.ListTrainingJobs,
+                    request_deserializer=proto_dot_api_dot_v0_dot_luminarycloud_dot_physics__ai_dot_physics__ai__pb2.ListTrainingJobsRequest.FromString,
+                    response_serializer=proto_dot_api_dot_v0_dot_luminarycloud_dot_physics__ai_dot_physics__ai__pb2.ListTrainingJobsResponse.SerializeToString,
+            ),
     }
     generic_handler = grpc.method_handlers_generic_handler(
             'luminary.proto.physicsaitrainingservice.PhysicsAiTrainingService', rpc_method_handlers)
@@ -170,3 +204,37 @@ class PhysicsAiTrainingService(object):
             proto_dot_api_dot_v0_dot_luminarycloud_dot_physics__ai_dot_physics__ai__pb2.CancelTrainingJobResponse.FromString,
             options, channel_credentials,
             insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
+
+    @staticmethod
+    def GetTrainingJob(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(request, target, '/luminary.proto.physicsaitrainingservice.PhysicsAiTrainingService/GetTrainingJob',
+            proto_dot_api_dot_v0_dot_luminarycloud_dot_physics__ai_dot_physics__ai__pb2.GetTrainingJobRequest.SerializeToString,
+            proto_dot_api_dot_v0_dot_luminarycloud_dot_physics__ai_dot_physics__ai__pb2.GetTrainingJobResponse.FromString,
+            options, channel_credentials,
+            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
+
+    @staticmethod
+    def ListTrainingJobs(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(request, target, '/luminary.proto.physicsaitrainingservice.PhysicsAiTrainingService/ListTrainingJobs',
+            proto_dot_api_dot_v0_dot_luminarycloud_dot_physics__ai_dot_physics__ai__pb2.ListTrainingJobsRequest.SerializeToString,
+            proto_dot_api_dot_v0_dot_luminarycloud_dot_physics__ai_dot_physics__ai__pb2.ListTrainingJobsResponse.FromString,
+            options, channel_credentials,
+            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

luminarycloud/_proto/physicsaitrainingservice/physicsaitrainingservice_pb2_grpc.pyi

@@ -30,6 +30,16 @@ class PhysicsAiTrainingServiceStub:
         luminarycloud._proto.api.v0.luminarycloud.physics_ai.physics_ai_pb2.CancelTrainingJobResponse,
     ]
     """Cancel a physics AI training job"""
+    GetTrainingJob: grpc.UnaryUnaryMultiCallable[
+        luminarycloud._proto.api.v0.luminarycloud.physics_ai.physics_ai_pb2.GetTrainingJobRequest,
+        luminarycloud._proto.api.v0.luminarycloud.physics_ai.physics_ai_pb2.GetTrainingJobResponse,
+    ]
+    """Get a physics AI training job by ID"""
+    ListTrainingJobs: grpc.UnaryUnaryMultiCallable[
+        luminarycloud._proto.api.v0.luminarycloud.physics_ai.physics_ai_pb2.ListTrainingJobsRequest,
+        luminarycloud._proto.api.v0.luminarycloud.physics_ai.physics_ai_pb2.ListTrainingJobsResponse,
+    ]
+    """List physics AI training jobs for the current user"""
 
 class PhysicsAiTrainingServiceServicer(metaclass=abc.ABCMeta):
     """PhysicsAiTrainingService provides training functionality for Physics AI"""
@@ -62,5 +72,19 @@ class PhysicsAiTrainingServiceServicer(metaclass=abc.ABCMeta):
         context: grpc.ServicerContext,
     ) -> luminarycloud._proto.api.v0.luminarycloud.physics_ai.physics_ai_pb2.CancelTrainingJobResponse:
         """Cancel a physics AI training job"""
+    @abc.abstractmethod
+    def GetTrainingJob(
+        self,
+        request: luminarycloud._proto.api.v0.luminarycloud.physics_ai.physics_ai_pb2.GetTrainingJobRequest,
+        context: grpc.ServicerContext,
+    ) -> luminarycloud._proto.api.v0.luminarycloud.physics_ai.physics_ai_pb2.GetTrainingJobResponse:
+        """Get a physics AI training job by ID"""
+    @abc.abstractmethod
+    def ListTrainingJobs(
+        self,
+        request: luminarycloud._proto.api.v0.luminarycloud.physics_ai.physics_ai_pb2.ListTrainingJobsRequest,
+        context: grpc.ServicerContext,
+    ) -> luminarycloud._proto.api.v0.luminarycloud.physics_ai.physics_ai_pb2.ListTrainingJobsResponse:
+        """List physics AI training jobs for the current user"""
 
 def add_PhysicsAiTrainingServiceServicer_to_server(servicer: PhysicsAiTrainingServiceServicer, server: grpc.Server) -> None: ...

luminarycloud/enum/__init__.py

@@ -23,6 +23,7 @@ from .vis_enums import (
     CameraProjection,
     ColorMapPreset,
     EntityType,
+    ExtremaType,
     FieldAssociation,
     FieldComponent,
     RenderStatusType,

luminarycloud/enum/gpu_type.py

@@ -1,14 +1,54 @@
-from enum import IntEnum
+from enum import Enum
 from .._proto.api.v0.luminarycloud.simulation import simulation_pb2 as simulationpb
+from .._proto.clusterconfig import clusterconfig_pb2 as clusterconfigpb
 
 
-class GPUType(IntEnum):
+# We don't inherit from StrEnum because that was added in Python 3.11, but we still want to support
+# older versions. Inheriting from str and Enum gives us the StrEnum-like behavior we want.
+class GPUType(str, Enum):
     """
     Represents a GPU type.
     """
 
-    UNSPECIFIED = simulationpb.SimulationOptions.GPU_TYPE_UNSPECIFIED
-    V100 = simulationpb.SimulationOptions.GPU_TYPE_V100
-    A100 = simulationpb.SimulationOptions.GPU_TYPE_A100
-    T4 = simulationpb.SimulationOptions.GPU_TYPE_T4
-    H100 = simulationpb.SimulationOptions.GPU_TYPE_H100
+    UNSPECIFIED = "unspecified"
+    CPU = "cpu"
+    T4 = "t4"
+    V100 = "v100"
+    A100 = "a100"
+    A100_80 = "a100_80"
+    H100 = "h100"
+
+    def __str__(self) -> str:
+        return self.value
+
+    def _to_sim_options_gpu_type(self) -> int:
+        if self == GPUType.UNSPECIFIED:
+            return simulationpb.SimulationOptions.GPU_TYPE_UNSPECIFIED
+        elif self == GPUType.T4:
+            return simulationpb.SimulationOptions.GPU_TYPE_T4
+        elif self == GPUType.V100:
+            return simulationpb.SimulationOptions.GPU_TYPE_V100
+        elif self == GPUType.A100:
+            return simulationpb.SimulationOptions.GPU_TYPE_A100
+        elif self == GPUType.H100:
+            return simulationpb.SimulationOptions.GPU_TYPE_H100
+        else:
+            raise ValueError(f"Invalid GPU type: {self.value}")
+
+    def _to_clusterconfig_gpu_type(self) -> int:
+        if self == GPUType.UNSPECIFIED:
+            return clusterconfigpb.GPUType.UNSPECIFIED
+        elif self == GPUType.CPU:
+            return clusterconfigpb.GPUType.CPU
+        elif self == GPUType.T4:
+            return clusterconfigpb.GPUType.T4
+        elif self == GPUType.V100:
+            return clusterconfigpb.GPUType.V100
+        elif self == GPUType.A100:
+            return clusterconfigpb.GPUType.A100
+        elif self == GPUType.A100_80:
+            return clusterconfigpb.GPUType.A100_80
+        elif self == GPUType.H100:
+            return clusterconfigpb.GPUType.H100
+        else:
+            raise ValueError(f"Invalid GPU type: {self.value}")

luminarycloud/enum/vis_enums.py

@@ -332,3 +332,21 @@ class FieldAssociation(IntEnum):
 
     POINTS = 0
     CELLS = 1
+
+
+class ExtremaType(IntEnum):
+    """
+    An enum to specify whether to find minimum or maximum values in an extrema query.
+
+    .. warning:: This feature is experimental and may change or be removed in the future.
+
+    Attributes
+    ----------
+    MIN
+        Find the minimum values.
+    MAX
+        Find the maximum values.
+    """
+
+    MIN = vis_pb2.EXTREMA_TYPE_MIN
+    MAX = vis_pb2.EXTREMA_TYPE_MAX

luminarycloud/geometry.py

@@ -10,6 +10,8 @@ from typing import Union, Sequence
 from typing_extensions import TYPE_CHECKING
 
 import luminarycloud as lc
+from luminarycloud.exceptions import NotFoundError
+from luminarycloud.geometry_contacts import get_geometry_contacts
 
 from ._client import get_default_client
 from ._helpers._timestamp_to_datetime import timestamp_to_datetime
@@ -30,6 +32,7 @@ from .named_variable_set import NamedVariableSet, get_named_variable_set
 if TYPE_CHECKING:
     from .project import Project
     from .geometry_version import GeometryVersion, GeometryVersionIterator
+    from .geometry_contacts import GeometryContacts
 
 
 @ProtoWrapper(geometrypb.Geometry)
@@ -681,6 +684,84 @@ class Geometry(ProtoWrapperBase):
         res: geometrypb.GetGeometryResponse = get_default_client().GetGeometry(req)
         self._proto = res.geometry
 
+    def compute_contacts(self) -> "GeometryContacts":
+        """
+        Compute geometry contacts for this geometry.
+
+        This initiates an asynchronous computation to identify contact surfaces
+        between bodies in the geometry. Returns a GeometryContacts object immediately,
+        which can be used to wait for completion or check status.
+
+        Returns
+        -------
+        GeometryContacts
+            The contacts object. Initially found=False. Use .wait() to block until
+            computation completes, or .refresh() to check current status.
+
+        Examples
+        --------
+        >>> geometry = lc.get_geometry("geo-123")
+        >>> contacts = geometry.compute_contacts()
+        >>> contacts.wait()  # Block until computation completes
+        >>> if not contacts.operation_error:
+        ...     for contact in contacts.contacts:
+        ...         print(f"Contact {contact.id}: faces {contact.side_a} vs {contact.side_b}")
+
+        Or poll asynchronously:
+        >>> contacts = geometry.compute_contacts()
+        >>> # Do other work...
+        >>> contacts.refresh()
+        >>> if contacts.found and not contacts.operation_error:
+        ...     print(f"Found {len(contacts.contacts)} contacts")
+        """
+
+        latest_geometry_version = self.latest_version()
+
+        req = geometrypb.StartComputeGeometryContactsRequest(
+            geometry_id=self.id,
+            geometry_version_id=latest_geometry_version.id,
+            project_id=self.project_id,
+        )
+        get_default_client().StartComputeGeometryContacts(req)
+
+        # Return the GeometryContacts object immediately (found=False initially)
+        contacts = get_geometry_contacts(self.id, latest_geometry_version.id, self.project_id)
+        return contacts
+
+    def get_contacts(self) -> "GeometryContacts | None":
+        """
+        Get the computed contacts for this geometry, if available.
+
+        Returns None if contacts have not been computed yet or not found.
+
+        Returns
+        -------
+        GeometryContacts | None
+            The computed contacts, or None if not found.
+
+        Raises
+        ------
+        RpcError
+            If there is an error communicating with the API (other than NotFoundError).
+
+        Examples
+        --------
+        >>> geometry = lc.get_geometry("geo-123")
+        >>> contacts = geometry.get_contacts()
+        >>> if contacts and contacts.found and not contacts.operation_error:
+        ...     print(f"Found {len(contacts.contacts)} contacts")
+        """
+        latest_geometry_version = self.latest_version()
+
+        try:
+            contacts = get_geometry_contacts(self.id, latest_geometry_version.id, self.project_id)
+            if contacts.found:
+                return contacts
+            return None
+        except NotFoundError:
+            # Contacts haven't been computed yet
+            return None
+
     def to_code(self) -> str:
         """
         Returns the python code that creates (from scratch) an identical geometry.

luminarycloud/geometry_contacts.py

@@ -0,0 +1,222 @@
+# Copyright 2026 Luminary Cloud, Inc. All Rights Reserved.
+from __future__ import annotations
+
+import logging
+from time import sleep, time
+from typing import TYPE_CHECKING
+
+import luminarycloud as lc
+from luminarycloud.exceptions import SDKException, Timeout
+
+from ._client import get_default_client
+from ._proto.api.v0.luminarycloud.geometry import geometry_pb2 as geometrypb
+from ._wrapper import ProtoWrapperBase
+
+if TYPE_CHECKING:
+    from .geometry import Geometry
+
+logger = logging.getLogger(__name__)
+
+
+class GeometryContactsError(SDKException):
+    """Raised when geometry contacts computation fails."""
+
+    pass
+
+
+def wait_for_geometry_contacts(
+    geometry_id: str,
+    geometry_version_id: str,
+    project_id: str,
+    *,
+    interval_seconds: float = 2,
+    timeout_seconds: float = float("inf"),
+) -> GeometryContacts:
+    """
+    Waits for geometry contacts computation to complete.
+
+    Polls the GetGeometryContacts RPC until the computation is found
+    and either succeeds or fails.
+
+    Parameters
+    ----------
+    geometry_id: str
+        The geometry ID
+    geometry_version_id: str
+        The geometry version ID
+    project_id: str
+        The project ID
+    interval_seconds: float
+        Number of seconds between polls. Default is 2 seconds.
+    timeout_seconds: float
+        Number of seconds before the operation times out.
+        Default is infinity.
+
+    Returns
+    -------
+    GeometryContacts
+        The computed geometry contacts.
+
+    Raises
+    ------
+    Timeout
+        If the operation times out before completion.
+    """
+    deadline = time() + timeout_seconds
+    while True:
+        if time() >= deadline:
+            raise Timeout("Timed out waiting for geometry contacts to be computed.")
+
+        response = get_geometry_contacts(geometry_id, geometry_version_id, project_id)
+
+        if response.found:
+            if response.operation_error:
+                raise GeometryContactsError(
+                    f"Geometry contacts computation failed with error. Issues: {response.issues}"
+                )
+            return response
+
+        # not yet found/complete, continue polling
+        sleep(max(0, min(interval_seconds, deadline - time())))
+
+
+class Contact:
+    """Represents a single contact between two surfaces."""
+
+    def __init__(self, id: str, side_a: list[str], side_b: list[str]):
+        self.id = id
+        self.side_a = side_a
+        self.side_b = side_b
+
+    def __repr__(self) -> str:
+        return f"Contact(id={self.id}, " f"side_a={self.side_a}, " f"side_b={self.side_b})"
+
+
+class GeometryContacts(ProtoWrapperBase):
+    _proto: "geometrypb.GetGeometryContactsResponse"
+
+    def __init__(self, proto: "geometrypb.GetGeometryContactsResponse"):
+        self._proto = proto
+        self.geometry_id: str = ""
+        self.geometry_version_id: str = ""
+        self.project_id: str = ""
+
+    @property
+    def found(self) -> bool:
+        """Whether the contacts computation was found."""
+        return self._proto.contacts.found
+
+    @property
+    def operation_error(self) -> bool:
+        """Whether the contacts computation encountered an error."""
+        return self._proto.contacts.operation_error
+
+    @property
+    def contacts(self) -> list[Contact]:
+        """List of computed contacts."""
+        return [
+            Contact(
+                id=c.id,
+                side_a=list(c.side_a),
+                side_b=list(c.side_b),
+            )
+            for c in self._proto.contacts.contacts
+        ]
+
+    @property
+    def issues(self) -> list:
+        """List of issues/warnings from the computation."""
+        return list(self._proto.contacts.issues)
+
+    def geometry(self) -> "Geometry":
+        """Get the geometry these contacts are for."""
+        return lc.get_geometry(self.geometry_id)
+
+    def refresh(self) -> "GeometryContacts":
+        """
+        Sync the GeometryContacts object with the backend.
+
+        Returns
+        -------
+        GeometryContacts
+            Updated contacts consistent with the backend.
+        """
+        self._proto = get_geometry_contacts(
+            self.geometry_id, self.geometry_version_id, self.project_id
+        )._proto
+        return self
+
+    def wait(
+        self,
+        *,
+        interval_seconds: float = 2,
+        timeout_seconds: float = float("inf"),
+    ) -> bool:
+        """
+        Wait until the geometry contacts computation has either completed or failed.
+
+        Mutates self with the final status and results.
+
+        Parameters
+        ----------
+        interval_seconds : float, optional
+            Number of seconds between polls. Default is 2 seconds.
+        timeout_seconds : float, optional
+            Number of seconds before timeout.
+
+        Returns
+        -------
+        bool
+            True if computation completed without error, False if operation_error is True.
+        """
+        computed_contacts = wait_for_geometry_contacts(
+            self.geometry_id,
+            self.geometry_version_id,
+            self.project_id,
+            interval_seconds=interval_seconds,
+            timeout_seconds=timeout_seconds,
+        )
+        # Update self with the final results
+        self._proto = computed_contacts._proto
+        return self.operation_error is False
+
+
+def get_geometry_contacts(
+    geometry_id: str,
+    geometry_version_id: str,
+    project_id: str,
+) -> GeometryContacts:
+    """
+    Get computed contacts for a specific geometry version.
+
+    Parameters
+    ----------
+    geometry_id : str
+        The geometry ID
+    geometry_version_id : str
+        The geometry version ID
+    project_id : str
+        The project ID
+
+    Returns
+    -------
+    GeometryContacts
+        The contacts information (may indicate not found if not yet computed)
+
+    Examples
+    --------
+    >>> contacts = lc.get_geometry_contacts("geo-123", "gv-456")
+    >>> if contacts.found:
+    ...     print(f"Found {len(contacts.contacts)} contacts")
+    """
+    req = geometrypb.GetGeometryContactsRequest(
+        geometry_id=geometry_id,
+        geometry_version_id=geometry_version_id,
+        project_id=project_id,
+    )
+    res = get_default_client().GetGeometryContacts(req)
+    contacts = GeometryContacts(res)
+    contacts.geometry_id = geometry_id
+    contacts.geometry_version_id = geometry_version_id
+    contacts.project_id = project_id
+    return contacts

luminarycloud/meshing/mesh_generation_params.py

@@ -15,7 +15,7 @@ from ..params.geometry import (
     Volume,
 )
 from ..types import Vector3
-from .sizing_strategy import MaxCount, Minimal, MinimalCount, SizingStrategy, TargetCount
+from .sizing_strategy import MaxCount, Minimal, SizingStrategy, TargetCount
 
 
 @dataclass(kw_only=True)
@@ -108,7 +108,7 @@ class RefinementRegion:
         proto.h_limit = self.h_limit
         if isinstance(self.shape, Sphere):
             proto.sphere.center_float.CopyFrom(self.shape.center._to_base_proto())
-            proto.sphere.radius_float = self.shape.radius
+            proto.sphere.radius_float = float(self.shape.radius)
         elif isinstance(self.shape, SphereShell):
             proto.sphere_shell.center.CopyFrom(self.shape.center._to_base_proto())
             proto.sphere_shell.radius = self.shape.radius
@@ -125,7 +125,7 @@ class RefinementRegion:
         elif isinstance(self.shape, Cylinder):
             proto.cylinder.start_float.CopyFrom(self.shape.start._to_base_proto())
             proto.cylinder.end_float.CopyFrom(self.shape.end._to_base_proto())
-            proto.cylinder.radius_float = self.shape.radius
+            proto.cylinder.radius_float = float(self.shape.radius)
         elif isinstance(self.shape, AnnularCylinder):
             proto.annular_cylinder.start.CopyFrom(self.shape.start._to_base_proto())
             proto.annular_cylinder.end.CopyFrom(self.shape.end._to_base_proto())
@@ -178,7 +178,7 @@ class MeshGenerationParams:
             )
         )
 
-        if isinstance(self.sizing_strategy, (MinimalCount, Minimal)):
+        if isinstance(self.sizing_strategy, Minimal):
             proto.mesh_complexity_params.type = (
                 meshpb.MeshGenerationParams.MeshComplexityParams.ComplexityType.MIN
             )

luminarycloud/meshing/sizing_strategy/__init__.py

@@ -1,6 +1,5 @@
 from .sizing_strategies import (
     SizingStrategy,
-    MinimalCount,
     Minimal,
     TargetCount,
     MaxCount,

luminarycloud/meshing/sizing_strategy/sizing_strategies.py

@@ -1,7 +1,5 @@
 from dataclasses import dataclass
 
-from luminarycloud._helpers.warnings.deprecated import deprecated
-
 
 @dataclass
 class SizingStrategy:
@@ -10,24 +8,6 @@ class SizingStrategy:
     pass
 
 
-@deprecated(
-    "Use luminarycloud.meshing.sizing_strategy.Minimal instead.",
-    "0.10.2",
-)
-@dataclass
-class MinimalCount(SizingStrategy):
-    """
-    Minimal sizing strategy parameters.
-
-    If this is used, all other meshing parameters are ignored.
-
-    .. deprecated:: 0.10.2
-        Use [`Minimal()`](#luminarycloud.meshing.sizing_strategy.Minimal) instead.
-    """
-
-    pass
-
-
 @dataclass
 class Minimal(SizingStrategy):
     """