luminarycloud 0.22.2__py3-none-any.whl → 0.23.0__py3-none-any.whl

luminarycloud/__init__.py

@@ -25,6 +25,13 @@ from .geometry import (
     get_geometry as get_geometry,
     Geometry as Geometry,
 )
+from .geometry_contacts import (
+    get_geometry_contacts as get_geometry_contacts,
+    wait_for_geometry_contacts as wait_for_geometry_contacts,
+    GeometryContacts as GeometryContacts,
+    GeometryContactsError as GeometryContactsError,
+    Contact as Contact,
+)
 from .geometry_version import (
     GeometryVersion as GeometryVersion,
     get_geometry_version as get_geometry_version,
@@ -39,7 +46,6 @@ from .project import (
     create_project as create_project,
     add_named_variables_from_csv as add_named_variables_from_csv,
     get_project as get_project,
-    list_projects as list_projects,
     iterate_projects as iterate_projects,
     Project as Project,
 )
@@ -90,7 +96,7 @@ def use_itar_environment() -> None:
 
     >>> import luminarycloud as lc
     >>> lc.use_itar_environment()
-    >>> lc.list_projects() # lists projects in the user's ITAR environment
+    >>> list(lc.iterate_projects()) # lists projects in the user's ITAR environment
     """
     set_default_client(
         Client(
@@ -117,7 +123,7 @@ def use_standard_environment() -> None:
 
     >>> import luminarycloud as lc
     >>> lc.use_standard_environment()
-    >>> lc.list_projects() # lists projects in the user's Standard environment
+    >>> list(lc.iterate_projects()) # lists projects in the user's Standard environment
     """
     set_default_client(Client())
     logger.info("using Luminary Cloud Standard Environment")

luminarycloud/_client/client.py

@@ -118,7 +118,7 @@ class Client(
 
     >>> import luminarycloud as lc
     >>> with lc.Client(access_token="blahblahblah"):
-    >>>     project = lc.list_projects()[0]
+    >>>     project = next(lc.iterate_projects())
     >>>     sims = project.list_simulations()
     """
 

luminarycloud/_client/retry_interceptor.py

@@ -88,7 +88,15 @@ class RetryInterceptor(UnaryUnaryClientInterceptor):
         client_call_details: ClientCallDetails,
         request: Any,
     ) -> grpc.Call:
-        retryable_codes = [grpc.StatusCode.RESOURCE_EXHAUSTED, grpc.StatusCode.UNAVAILABLE]
+        # We sometimes get fault filter abort from the envoy proxies that GCP seems to use for their
+        # LBs that are installed via GKE's gateway. The error codes in this case are UNIMPLEMENTED.
+        # We need to retry those as well since sometimes we get transient errors related to those
+        # LBs.
+        retryable_codes = [
+            grpc.StatusCode.RESOURCE_EXHAUSTED,
+            grpc.StatusCode.UNAVAILABLE,
+            grpc.StatusCode.UNIMPLEMENTED,
+        ]
         n_max_retries = 20
         max_retry_seconds = 20
         backoffs = [min(i * 2, max_retry_seconds) for i in range(1, n_max_retries)]
@@ -99,11 +107,14 @@ class RetryInterceptor(UnaryUnaryClientInterceptor):
             call = continuation(client_call_details, request)
             if call.code() not in retryable_codes:
                 break
+            details = call.details() or ""
+            if call.code() == grpc.StatusCode.UNIMPLEMENTED:
+                if "fault filter abort" not in details:
+                    break
             if call.code() == grpc.StatusCode.UNAVAILABLE:
                 # if the auth plugin errors, that unfortunately shows up here as UNAVAILABLE, so we
                 # have to check for auth plugin exceptions that shouldn't be retried by matching
                 # their name in the details string
-                details = call.details() or ""
                 if "InteractiveAuthException" in details:
                     break
             backoff = backoffs[backoff_index]

luminarycloud/_helpers/_code_representation.py

@@ -90,6 +90,7 @@ class CodeRepr:
                 str(type(self))
                 .split("'")[1]
                 .replace("luminarycloud.params.simulation", "sim_params")
+                .replace("luminarycloud.params.outputs.output", "luminarycloud.params.outputs")
                 .replace("luminarycloud.outputs.output_definitions", "outputs")
             )
             names = path.split(".")

luminarycloud/_helpers/_create_simulation.py

@@ -43,7 +43,11 @@ def create_simulation(
             description=description,
             simulation_options=SimulationOptions(
                 batch_processing=batch_processing,
-                gpu_type=gpu_type.value if gpu_type is not None else GPUType.UNSPECIFIED.value,
+                gpu_type=(
+                    gpu_type._to_sim_options_gpu_type()
+                    if gpu_type is not None
+                    else GPUType.UNSPECIFIED._to_sim_options_gpu_type()
+                ),
                 gpu_count=gpu_count or 0,
             ),
         )

luminarycloud/_helpers/proto_decorator.py

@@ -5,23 +5,26 @@ from typing import (
     get_type_hints,
 )
 
+from google.protobuf.descriptor import FieldDescriptor
 from google.protobuf.message import Message
 
+from luminarycloud._proto.api.v0.luminarycloud.common import common_pb2 as commonpb
 from luminarycloud._proto.base import base_pb2 as basepb
-from luminarycloud.types import Vector3
-from luminarycloud.types.adfloat import _from_ad_proto, _to_ad_proto
-from luminarycloud.types.vector3 import _to_vector3_ad_proto
+from luminarycloud.types import LcFloat, Vector3
+from luminarycloud.types.adfloat import _from_ad_proto, _lcfloat_to_float, _to_ad_proto
+from luminarycloud.types.vector3 import (
+    _to_vector3_ad_proto,
+    _to_vector3_base_proto,
+    _to_vector3_proto,
+)
 
 P = TypeVar("P", bound=Message)
 C = TypeVar("C")
 
 
+# Abstract mixin to satisfy the type checker when using `@proto_decorator`.
+# Declares statically that `_to_proto` and `_from_proto` will be added by the decorator.
 class ProtoConvertible(Generic[P]):
-    """
-    Abstract mixin to satisfy the type checker when using `@proto_decorator`.
-    Declares statically that `_to_proto` and `_from_proto` will be added by the decorator.
-    """
-
     def _to_proto(self) -> P: ...
 
     def _from_proto(self, proto: P) -> None: ...
@@ -42,45 +45,50 @@ class proto_decorator(Generic[P]):
 
     def __call__(decorator, cls: type[C]) -> type[C]:
         type_hints = get_type_hints(cls)
-        fields = decorator.proto_type.DESCRIPTOR.fields
+        proto_fields: list[FieldDescriptor] = decorator.proto_type.DESCRIPTOR.fields
 
         def _to_proto(self: type[C]) -> P:
             proto = decorator.proto_type()
-            for field in fields:
-                _type = type_hints.get(field.name, None)
-                if _type:
-                    value = getattr(self, field.name)
-                    proto_value = getattr(proto, field.name)
-                    if issubclass(_type, float) and isinstance(proto_value, basepb.AdFloatType):
-                        proto_value.CopyFrom(_to_ad_proto(value))
-                    elif issubclass(_type, Vector3):
-                        if isinstance(proto_value, basepb.AdVector3):
-                            proto_value.CopyFrom(_to_vector3_ad_proto((value.x, value.y, value.z)))
-                        else:
-                            proto_value.x = value.x
-                            proto_value.y = value.y
-                            proto_value.z = value.z
+            for proto_field in proto_fields:
+                if proto_field.name not in type_hints:
+                    continue  # don't try to match fields that aren't in the wrapper class
+                value = getattr(self, proto_field.name)
+                proto_value = getattr(proto, proto_field.name)
+                if isinstance(proto_value, basepb.AdFloatType):
+                    proto_value.CopyFrom(_to_ad_proto(value))
+                elif isinstance(proto_value, basepb.AdVector3):
+                    proto_value.CopyFrom(_to_vector3_ad_proto(value))
+                elif isinstance(proto_value, basepb.Vector3):
+                    proto_value.CopyFrom(_to_vector3_base_proto(value))
+                elif isinstance(proto_value, commonpb.Vector3):
+                    proto_value.CopyFrom(_to_vector3_proto(value))
+                elif isinstance(proto_value, Message):
+                    proto_value.CopyFrom(value._to_proto())
+                else:  # proto field is primitive type
+                    if isinstance(value, LcFloat):
+                        proto_value = _lcfloat_to_float(value)
                     else:
-                        setattr(proto, field.name, value)
+                        setattr(proto, proto_field.name, value)
             return proto
 
         setattr(cls, "_to_proto", _to_proto)
 
         def _from_proto(self: type[C], proto: type[P]) -> None:
-            for field in fields:
-                _type = type_hints.get(field.name, None)
-                if _type:
-                    proto_value = getattr(proto, field.name)
-                    if isinstance(proto_value, basepb.AdFloatType):
-                        setattr(self, field.name, _from_ad_proto(proto_value))
-                    elif issubclass(_type, Vector3):
-                        vec = getattr(self, field.name)
-                        if isinstance(proto_value, basepb.Vector3):
-                            vec._from_proto(proto_value)
-                        elif isinstance(proto_value, basepb.AdVector3):
-                            vec._from_ad_proto(proto_value)
-                    else:
-                        setattr(self, field.name, proto_value)
+            for proto_field in proto_fields:
+                _type = type_hints.get(proto_field.name, None)
+                if not _type:
+                    continue  # don't try to match fields that aren't in the wrapper class
+                proto_value = getattr(proto, proto_field.name)
+                if isinstance(proto_value, basepb.AdFloatType):
+                    setattr(self, proto_field.name, _from_ad_proto(proto_value))
+                elif issubclass(_type, Vector3):
+                    vec = getattr(self, proto_field.name)
+                    if isinstance(proto_value, basepb.Vector3):
+                        vec._from_proto(proto_value)
+                    elif isinstance(proto_value, basepb.AdVector3):
+                        vec._from_ad_proto(proto_value)
+                else:
+                    setattr(self, proto_field.name, proto_value)
             return None
 
         setattr(cls, "_from_proto", _from_proto)