luminarycloud 0.21.2__py3-none-any.whl → 0.22.1__py3-none-any.whl

luminarycloud/__init__.py

@@ -13,12 +13,14 @@ from . import (
     types as types,
     vis as vis,
 )
-
 from ._client import (
     Client as Client,
     get_default_client as get_default_client,
     set_default_client as set_default_client,
 )
+from ._feature_flag import (
+    _get_feature_flags as _get_feature_flags,
+)
 from .geometry import (
     get_geometry as get_geometry,
     Geometry as Geometry,

luminarycloud/_client/authentication_plugin.py

@@ -38,3 +38,52 @@ class AuthenticationPlugin(grpc.AuthMetadataPlugin):
             callback(metadata, None)
         except Exception as err:
             callback(None, err)
+
+
+class AuthInterceptor(
+    grpc.UnaryUnaryClientInterceptor,
+    grpc.UnaryStreamClientInterceptor,
+    grpc.StreamUnaryClientInterceptor,
+    grpc.StreamStreamClientInterceptor,
+):
+    """
+    I need this as a workaround for container-to-host connections because I need to create a channel
+    that uses CallCredentials but doesn't use any ChannelCredentials. I.e. I need to authenticate
+    the requests, but I need the connection to be unencrypted. This is because the grpc server on
+    the native host isn't using SSL, so I can't use grpc.ssl_channel_credentials(), but it's also
+    not reachable on a loopback interface, so I can't use grpc.local_channel_credentials() either.
+    So I need to use a grpc.insecure_channel(), but you can't use CallCredentials with an insecure
+    channel. So the workaround is to use an interceptor instead of CallCredentials.
+
+    Also, I don't care about auth0, so I'm only supporting an API key.
+    """
+
+    def __init__(self, api_key: str):
+        self._api_key = api_key
+
+    def _augment(self, metadata):
+        return metadata + [("x-api-key", self._api_key)]
+
+    def intercept_unary_unary(self, continuation, client_call_details, request):
+        new_details = client_call_details._replace(
+            metadata=self._augment(client_call_details.metadata or [])
+        )
+        return continuation(new_details, request)
+
+    def intercept_unary_stream(self, continuation, client_call_details, request):
+        new_details = client_call_details._replace(
+            metadata=self._augment(client_call_details.metadata or [])
+        )
+        return continuation(new_details, request)
+
+    def intercept_stream_unary(self, continuation, client_call_details, request_iter):
+        new_details = client_call_details._replace(
+            metadata=self._augment(client_call_details.metadata or [])
+        )
+        return continuation(new_details, request_iter)
+
+    def intercept_stream_stream(self, continuation, client_call_details, request_iter):
+        new_details = client_call_details._replace(
+            metadata=self._augment(client_call_details.metadata or [])
+        )
+        return continuation(new_details, request_iter)

luminarycloud/_client/client.py

@@ -44,7 +44,10 @@ from .._proto.api.v0.luminarycloud.project_ui_state.project_ui_state_pb2_grpc im
 from .._proto.api.v0.luminarycloud.solution.solution_pb2_grpc import SolutionServiceStub
 from .._proto.api.v0.luminarycloud.upload.upload_pb2_grpc import UploadServiceStub
 from .._proto.api.v0.luminarycloud.vis.vis_pb2_grpc import VisAPIServiceStub
-from .authentication_plugin import AuthenticationPlugin
+from .._proto.api.v0.luminarycloud.feature_flag.feature_flag_pb2_grpc import (
+    FeatureFlagServiceStub,
+)
+from .authentication_plugin import AuthenticationPlugin, AuthInterceptor
 from .config import LC_DOMAIN, LC_API_KEY
 from .logging_interceptor import LoggingInterceptor
 from .retry_interceptor import RetryInterceptor
@@ -71,6 +74,7 @@ class Client(
     InferenceServiceStub,
     OnshapeServiceStub,
     ProjectUIStateServiceStub,
+    FeatureFlagServiceStub,
 ):
     """
     Creates a Luminary API client.
@@ -89,11 +93,20 @@ class Client(
         The URL of the HTTP REST server. If not provided, it will default to the `target`.
     localhost : bool
         True if the API server is running locally.
+    insecure_grpc_channel : bool
+        True to use an unencrypted gRPC channel, even though requests are authenticated. There's no
+        legitimate reason to do this outside of a local development situation where the SDK is
+        running from a container and connecting to an API server that is running on the host.
     grpc_channel_options : Optional[Iterable[tuple[str, str]]]
         A list of gRPC channel args. The full list is available here:
         https://github.com/grpc/grpc/blob/v1.46.x/include/grpc/impl/codegen/grpc_types.h
     api_key : Optional[str]
         The API key to use for authentication.
+    log_retries : bool
+        True to log each retriable error response. There are some errors the API server may return
+        that are known to be transient, and the client will always retry requests when it gets one
+        of them. By default, the client retries silently. Set this to True to log the error
+        responses (at INFO level) for the retriable errors.
     **kwargs : dict, optional
         Additional arguments are passed to Auth0Client. See _auth/auth.py.
 
@@ -112,9 +125,11 @@ class Client(
         target: str = LC_DOMAIN,
         http_target: str | None = None,
         localhost: bool = False,
+        insecure_grpc_channel: bool = False,
         grpc_channel_options: Optional[Iterable[tuple[str, Union[str, int]]]] = None,
         channel_credentials: Optional[grpc.ChannelCredentials] = None,
         api_key: Optional[str] = LC_API_KEY,
+        log_retries: bool = False,
         **kwargs: Any,
     ):
         self._target = target
@@ -135,7 +150,12 @@ class Client(
         if grpc_channel_options:
             grpc_channel_options_with_keep_alive.extend(grpc_channel_options)
         self._channel = self._create_channel(
-            localhost, grpc_channel_options_with_keep_alive, channel_credentials, api_key
+            localhost,
+            insecure_grpc_channel,
+            grpc_channel_options_with_keep_alive,
+            channel_credentials,
+            api_key,
+            log_retries,
         )
         self._context_tokens: list[Token] = []
         self.__register_rpcs()
@@ -189,9 +209,11 @@ class Client(
     def _create_channel(
         self,
         localhost: bool = False,
+        insecure: bool = False,
         grpc_channel_options: Optional[Iterable[tuple[str, Union[str, int]]]] = None,
         channel_credentials: Optional[grpc.ChannelCredentials] = None,
         api_key: Optional[str] = None,
+        log_retries: bool = False,
     ) -> grpc.Channel:
         if channel_credentials is None:
             if localhost:
@@ -213,15 +235,22 @@ class Client(
         call_creds = grpc.metadata_call_credentials(auth_plugin)
         composite_creds = grpc.composite_channel_credentials(channel_credentials, call_creds)
         options = grpc_channel_options and list(grpc_channel_options)
-        channel = grpc.secure_channel(
-            self._target,
-            composite_creds,
-            options=options,
-        )
+        if insecure:
+            channel = grpc.insecure_channel(self._target, options=options)
+            channel = grpc.intercept_channel(
+                channel,
+                AuthInterceptor(api_key),
+            )
+        else:
+            channel = grpc.secure_channel(
+                self._target,
+                composite_creds,
+                options=options,
+            )
         intercepted_channel = grpc.intercept_channel(
             channel,
             LoggingInterceptor(),
-            RetryInterceptor(),
+            RetryInterceptor(log_retries),
         )
         return add_instrumentation(
             intercepted_channel,
@@ -248,6 +277,7 @@ class Client(
         NamedVariableSetServiceStub.__init__(self, self._channel)
         OnshapeServiceStub.__init__(self, self._channel)
         ProjectUIStateServiceStub.__init__(self, self._channel)
+        FeatureFlagServiceStub.__init__(self, self._channel)
         for name, value in self.__dict__.items():
             if isinstance(value, grpc.UnaryUnaryMultiCallable):
                 setattr(self, name, rpc_error(value))

luminarycloud/_client/http_client.py

@@ -32,7 +32,7 @@ class HttpClient:
         api_key: str | None = None,
         auth0_client: Auth0Client | None = None,
         *,
-        timeout: int = 10,
+        timeout: int | None = 300,
         retries: int = 3,
         backoff_factor: float = 0.3,
         retriable_status_codes: tuple = (500, 502, 503, 504, 429),

luminarycloud/_client/retry_interceptor.py

@@ -2,19 +2,68 @@
 from collections.abc import Callable
 from time import sleep
 from typing import Any
+import logging
 
 import grpc
 from grpc import (
     ClientCallDetails,
     UnaryUnaryClientInterceptor,
 )
+from grpc_status.rpc_status import GRPC_DETAILS_METADATA_KEY
 
 from luminarycloud.exceptions import AuthenticationError
+from luminarycloud._proto.base import base_pb2
+
+
+def _is_rate_limited(call: grpc.Call) -> bool:
+    """
+    Check if a gRPC call failed due to rate limiting.
+
+    Rate limit errors are identified with the SUBCODE_RATE_LIMITED subcode and UNAVAILABLE status.
+
+    Args:
+        call: The gRPC call to check
+
+    Returns:
+        True if the error is a rate limit error, False otherwise
+    """
+    if call.code() != grpc.StatusCode.UNAVAILABLE:
+        return False
+
+    try:
+        # Get the trailing metadata which contains error details
+        # Metadata is a sequence of tuples (key, value)
+        for key, value in call.trailing_metadata() or []:
+            if key != GRPC_DETAILS_METADATA_KEY or not isinstance(value, bytes):
+                continue
+
+            status = base_pb2.Status()
+            status.ParseFromString(value)
+            for any_detail in status.details:
+                if any_detail.Is(base_pb2.StatusPayload.DESCRIPTOR):
+                    payload = base_pb2.StatusPayload()
+                    any_detail.Unpack(payload)
+                    if payload.subcode == base_pb2.SUBCODE_RATE_LIMITED:
+                        return True
+    except Exception:
+        pass
+    return False
+
+
+logger = logging.getLogger(__name__)
 
 
 class RetryInterceptor(UnaryUnaryClientInterceptor):
+    def __init__(self, log_retries: bool = False):
+        self.log_retries = log_retries
+        super().__init__()
+
     """
-    A retry interceptor that retries on status code RESOURCE_EXHAUSTED (i.e. rate-limited).
+    A retry interceptor that retries on rate limit errors and other retryable errors.
+
+    This interceptor handles:
+    1. Rate limit errors (UNAVAILABLE with SUBCODE_RATE_LIMITED) - always retried
+    2. [grpc.StatusCode.RESOURCE_EXHAUSTED, grpc.StatusCode.UNAVAILABLE] - retried
 
     This is required because, while the retry policy for the gRPC client is configurable via
     https://github.com/grpc/grpc-proto/blob/master/grpc/service_config/service_config.proto,
@@ -43,7 +92,10 @@ class RetryInterceptor(UnaryUnaryClientInterceptor):
         n_max_retries = 20
         max_retry_seconds = 20
         backoffs = [min(i * 2, max_retry_seconds) for i in range(1, n_max_retries)]
-        for backoff in backoffs:  # in seconds
+        backoff_index = 0
+        while True:
+            if backoff_index >= len(backoffs):
+                break
             call = continuation(client_call_details, request)
             if call.code() not in retryable_codes:
                 break
@@ -54,7 +106,17 @@ class RetryInterceptor(UnaryUnaryClientInterceptor):
                 details = call.details() or ""
                 if "InteractiveAuthException" in details:
                     break
+            backoff = backoffs[backoff_index]
+            if self.log_retries:
+                logger.info(
+                    f"Retrying {client_call_details.method} in {backoff} seconds (last response: {call.code()}, {call.details()})"
+                )
             sleep(backoff)
+            # Keep retrying rate-limited calls while increasing the backoff up to the max.
+            backoff_index += 1
+            if _is_rate_limited(call):
+                backoff_index = max(min(backoff_index, len(backoffs) - 2), 0)
+
         try:
             call.result()
         except grpc.RpcError as e:

luminarycloud/_feature_flag.py

@@ -0,0 +1,22 @@
+# Copyright 2023-2025 Luminary Cloud, Inc. All Rights Reserved.
+from google.protobuf import empty_pb2
+
+from ._proto.api.v0.luminarycloud.feature_flag import feature_flag_pb2
+from ._client import get_default_client
+
+
+def _get_feature_flags() -> dict[int, str]:
+    """Get enabled feature flags for the authenticated user.
+
+    Feature flags are used to control access to experimental and internal features.
+    Each flag is identified by an experiment ID and a feature flag name.
+
+    Returns
+    -------
+    dict[int, str]
+        A dictionary mapping experiment IDs (uint64) to feature flag names.
+        Returns an empty dictionary if no feature flags are enabled for the user.
+    """
+    req = empty_pb2.Empty()
+    res = get_default_client().GetFeatureFlags(req)
+    return dict(res.enabled_feature_flags)

luminarycloud/_helpers/_create_simulation.py

@@ -7,6 +7,9 @@ from .._proto.api.v0.luminarycloud.simulation.simulation_pb2 import (
     SimulationOptions,
     CreateSimulationRequest,
 )
+from .._proto.api.v0.luminarycloud.simulation_template.simulation_template_pb2 import (
+    SimulationTemplate,
+)
 from .._client import Client
 from ..enum import GPUType
 
@@ -18,8 +21,9 @@ def create_simulation(
     project_id: str,
     mesh_id: str,
     name: str,
-    simulation_template_id: str,
+    simulation_template_id: Optional[str] = None,
     *,
+    simulation_template: Optional[SimulationTemplate] = None,
     named_variable_set_version_id: Optional[str] = None,
     description: str = "",
     batch_processing: bool = True,
@@ -32,7 +36,8 @@ def create_simulation(
         CreateSimulationRequest(
             project_id=project_id,
             mesh_id=mesh_id,
-            simulation_template_id=simulation_template_id,
+            simulation_template_id=simulation_template_id or "",
+            simulation_template=simulation_template,
             named_variable_set_version_id=named_variable_set_version_id or "",
             name=name,
             description=description,

luminarycloud/_helpers/download.py

@@ -17,6 +17,7 @@ from .._proto.api.v0.luminarycloud.solution.solution_pb2 import (
 )
 from .._proto.api.v0.luminarycloud.physics_ai.physics_ai_pb2 import (
     GetSolutionDataPhysicsAIRequest,
+    SurfaceGroup,
 )
 from .._client import Client
 from ..enum.quantity_type import QuantityType
@@ -140,6 +141,7 @@ def download_solution_physics_ai(
     process_volume: bool = False,
     single_precision: bool = False,
     internal_options: Optional[Dict[str, str]] = None,
+    export_surface_groups: Optional[Dict[str, List[str]]] = None,
 ) -> Optional[FileChunkStream]:
     """
     Returns the download as a file-like object, or None if destination_url is provided.
@@ -165,6 +167,9 @@ def download_solution_physics_ai(
         Whether to process volume meshes during physics AI processing.
     single_precision: bool
         If True, the solution will be downloaded in single precision.
+    export_surface_groups: Optional[Dict[str, List[str]]]
+        Dictionary mapping group names to lists of surface names.
+        Each group will be exported as an individual STL file.
 
     Examples
     --------
@@ -173,6 +178,11 @@ def download_solution_physics_ai(
     ...         fp.write(dl.read())
     """
 
+    surface_groups_pb = []
+    if export_surface_groups:
+        for group_name, surfaces in export_surface_groups.items():
+            surface_groups_pb.append(SurfaceGroup(name=group_name, surfaces=surfaces))
+
     request = GetSolutionDataPhysicsAIRequest(
         solution_id=solution_id,
         exclude_surfaces=exclude_surfaces or [],
@@ -186,6 +196,7 @@ def download_solution_physics_ai(
         process_volume=process_volume,
         single_precision=single_precision,
         internal_options=internal_options or {},
+        export_surface_groups=surface_groups_pb,
     )
     response = client.GetSolutionDataPhysicsAI(request)
 

luminarycloud/_helpers/proto_decorator.py

@@ -9,6 +9,9 @@ from typing import (
 from google.protobuf.message import Message
 
 from luminarycloud.types import Vector3
+from luminarycloud.types.adfloat import _to_ad_proto
+from luminarycloud.types.vector3 import _to_vector3_ad_proto
+from .._proto.base.base_pb2 import AdFloatType, AdVector3
 
 P = TypeVar("P", bound=Message)
 C = TypeVar("C")
@@ -36,11 +39,16 @@ class proto_decorator(Generic[P]):
                 _type = type_hints.get(field.name, None)
                 if _type:
                     value = getattr(self, field.name)
-                    if issubclass(_type, Vector3):
-                        vector_proto = getattr(proto, field.name)
-                        vector_proto.x = value.x
-                        vector_proto.y = value.y
-                        vector_proto.z = value.z
+                    proto_value = getattr(proto, field.name)
+                    if issubclass(_type, float) and isinstance(proto_value, AdFloatType):
+                        proto_value.CopyFrom(_to_ad_proto(value))
+                    elif issubclass(_type, Vector3):
+                        if isinstance(proto_value, 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
                     else:
                         setattr(proto, field.name, value)
             return proto

luminarycloud/_proto/api/v0/luminarycloud/feature_flag/feature_flag_pb2.py

@@ -0,0 +1,55 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: proto/api/v0/luminarycloud/feature_flag/feature_flag.proto
+"""Generated protocol buffer code."""
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import message as _message
+from google.protobuf import reflection as _reflection
+from google.protobuf import symbol_database as _symbol_database
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+from google.api import annotations_pb2 as google_dot_api_dot_annotations__pb2
+from google.protobuf import empty_pb2 as google_dot_protobuf_dot_empty__pb2
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n:proto/api/v0/luminarycloud/feature_flag/feature_flag.proto\x12\x30luminary.proto.api.v0.luminarycloud.feature_flag\x1a\x1cgoogle/api/annotations.proto\x1a\x1bgoogle/protobuf/empty.proto\"\xd9\x01\n\x17GetFeatureFlagsResponse\x12\x81\x01\n\x15\x65nabled_feature_flags\x18\x01 \x03(\x0b\x32\x62.luminary.proto.api.v0.luminarycloud.feature_flag.GetFeatureFlagsResponse.EnabledFeatureFlagsEntry\x1a:\n\x18\x45nabledFeatureFlagsEntry\x12\x0b\n\x03key\x18\x01 \x01(\x04\x12\r\n\x05value\x18\x02 \x01(\t:\x02\x38\x01\x32\xa6\x01\n\x12\x46\x65\x61tureFlagService\x12\x8f\x01\n\x0fGetFeatureFlags\x12\x16.google.protobuf.Empty\x1aI.luminary.proto.api.v0.luminarycloud.feature_flag.GetFeatureFlagsResponse\"\x19\x82\xd3\xe4\x93\x02\x13\x12\x11/v0/feature_flagsB@Z>luminarycloud.com/core/proto/api/v0/luminarycloud/feature_flagb\x06proto3')
+
+
+
+_GETFEATUREFLAGSRESPONSE = DESCRIPTOR.message_types_by_name['GetFeatureFlagsResponse']
+_GETFEATUREFLAGSRESPONSE_ENABLEDFEATUREFLAGSENTRY = _GETFEATUREFLAGSRESPONSE.nested_types_by_name['EnabledFeatureFlagsEntry']
+GetFeatureFlagsResponse = _reflection.GeneratedProtocolMessageType('GetFeatureFlagsResponse', (_message.Message,), {
+
+  'EnabledFeatureFlagsEntry' : _reflection.GeneratedProtocolMessageType('EnabledFeatureFlagsEntry', (_message.Message,), {
+    'DESCRIPTOR' : _GETFEATUREFLAGSRESPONSE_ENABLEDFEATUREFLAGSENTRY,
+    '__module__' : 'proto.api.v0.luminarycloud.feature_flag.feature_flag_pb2'
+    # @@protoc_insertion_point(class_scope:luminary.proto.api.v0.luminarycloud.feature_flag.GetFeatureFlagsResponse.EnabledFeatureFlagsEntry)
+    })
+  ,
+  'DESCRIPTOR' : _GETFEATUREFLAGSRESPONSE,
+  '__module__' : 'proto.api.v0.luminarycloud.feature_flag.feature_flag_pb2'
+  # @@protoc_insertion_point(class_scope:luminary.proto.api.v0.luminarycloud.feature_flag.GetFeatureFlagsResponse)
+  })
+_sym_db.RegisterMessage(GetFeatureFlagsResponse)
+_sym_db.RegisterMessage(GetFeatureFlagsResponse.EnabledFeatureFlagsEntry)
+
+_FEATUREFLAGSERVICE = DESCRIPTOR.services_by_name['FeatureFlagService']
+if _descriptor._USE_C_DESCRIPTORS == False:
+
+  DESCRIPTOR._options = None
+  DESCRIPTOR._serialized_options = b'Z>luminarycloud.com/core/proto/api/v0/luminarycloud/feature_flag'
+  _GETFEATUREFLAGSRESPONSE_ENABLEDFEATUREFLAGSENTRY._options = None
+  _GETFEATUREFLAGSRESPONSE_ENABLEDFEATUREFLAGSENTRY._serialized_options = b'8\001'
+  _FEATUREFLAGSERVICE.methods_by_name['GetFeatureFlags']._options = None
+  _FEATUREFLAGSERVICE.methods_by_name['GetFeatureFlags']._serialized_options = b'\202\323\344\223\002\023\022\021/v0/feature_flags'
+  _GETFEATUREFLAGSRESPONSE._serialized_start=172
+  _GETFEATUREFLAGSRESPONSE._serialized_end=389
+  _GETFEATUREFLAGSRESPONSE_ENABLEDFEATUREFLAGSENTRY._serialized_start=331
+  _GETFEATUREFLAGSRESPONSE_ENABLEDFEATUREFLAGSENTRY._serialized_end=389
+  _FEATUREFLAGSERVICE._serialized_start=392
+  _FEATUREFLAGSERVICE._serialized_end=558
+# @@protoc_insertion_point(module_scope)

luminarycloud/_proto/api/v0/luminarycloud/feature_flag/feature_flag_pb2.pyi

@@ -0,0 +1,52 @@
+"""
+@generated by mypy-protobuf.  Do not edit manually!
+isort:skip_file
+"""
+import builtins
+import collections.abc
+import google.protobuf.descriptor
+import google.protobuf.internal.containers
+import google.protobuf.message
+import sys
+
+if sys.version_info >= (3, 8):
+    import typing as typing_extensions
+else:
+    import typing_extensions
+
+DESCRIPTOR: google.protobuf.descriptor.FileDescriptor
+
+class GetFeatureFlagsResponse(google.protobuf.message.Message):
+    DESCRIPTOR: google.protobuf.descriptor.Descriptor
+
+    class EnabledFeatureFlagsEntry(google.protobuf.message.Message):
+        DESCRIPTOR: google.protobuf.descriptor.Descriptor
+
+        KEY_FIELD_NUMBER: builtins.int
+        VALUE_FIELD_NUMBER: builtins.int
+        key: builtins.int
+        value: builtins.str
+        def __init__(
+            self,
+            *,
+            key: builtins.int = ...,
+            value: builtins.str = ...,
+        ) -> None: ...
+        def ClearField(self, field_name: typing_extensions.Literal["key", b"key", "value", b"value"]) -> None: ...
+
+    ENABLED_FEATURE_FLAGS_FIELD_NUMBER: builtins.int
+    @property
+    def enabled_feature_flags(self) -> google.protobuf.internal.containers.ScalarMap[builtins.int, builtins.str]:
+        """Map of enabled feature flags where:
+        - Key: experiment ID (uint64)
+        - Value: feature flag name (string)
+        Returns an empty map if no feature flags are enabled for the user.
+        """
+    def __init__(
+        self,
+        *,
+        enabled_feature_flags: collections.abc.Mapping[builtins.int, builtins.str] | None = ...,
+    ) -> None: ...
+    def ClearField(self, field_name: typing_extensions.Literal["enabled_feature_flags", b"enabled_feature_flags"]) -> None: ...
+
+global___GetFeatureFlagsResponse = GetFeatureFlagsResponse

luminarycloud/_proto/api/v0/luminarycloud/feature_flag/feature_flag_pb2_grpc.py

@@ -0,0 +1,72 @@
+# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT!
+"""Client and server classes corresponding to protobuf-defined services."""
+import grpc
+
+from google.protobuf import empty_pb2 as google_dot_protobuf_dot_empty__pb2
+from luminarycloud._proto.api.v0.luminarycloud.feature_flag import feature_flag_pb2 as proto_dot_api_dot_v0_dot_luminarycloud_dot_feature__flag_dot_feature__flag__pb2
+
+
+class FeatureFlagServiceStub(object):
+    """Manages feature flags for internal users.
+    """
+
+    def __init__(self, channel):
+        """Constructor.
+
+        Args:
+            channel: A grpc.Channel.
+        """
+        self.GetFeatureFlags = channel.unary_unary(
+                '/luminary.proto.api.v0.luminarycloud.feature_flag.FeatureFlagService/GetFeatureFlags',
+                request_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
+                response_deserializer=proto_dot_api_dot_v0_dot_luminarycloud_dot_feature__flag_dot_feature__flag__pb2.GetFeatureFlagsResponse.FromString,
+                )
+
+
+class FeatureFlagServiceServicer(object):
+    """Manages feature flags for internal users.
+    """
+
+    def GetFeatureFlags(self, request, context):
+        """Gets all enabled feature flags for the authenticated user.
+        Feature flags are used to control access to experimental and internal features.
+        """
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+
+def add_FeatureFlagServiceServicer_to_server(servicer, server):
+    rpc_method_handlers = {
+            'GetFeatureFlags': grpc.unary_unary_rpc_method_handler(
+                    servicer.GetFeatureFlags,
+                    request_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
+                    response_serializer=proto_dot_api_dot_v0_dot_luminarycloud_dot_feature__flag_dot_feature__flag__pb2.GetFeatureFlagsResponse.SerializeToString,
+            ),
+    }
+    generic_handler = grpc.method_handlers_generic_handler(
+            'luminary.proto.api.v0.luminarycloud.feature_flag.FeatureFlagService', rpc_method_handlers)
+    server.add_generic_rpc_handlers((generic_handler,))
+
+
+ # This class is part of an EXPERIMENTAL API.
+class FeatureFlagService(object):
+    """Manages feature flags for internal users.
+    """
+
+    @staticmethod
+    def GetFeatureFlags(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.api.v0.luminarycloud.feature_flag.FeatureFlagService/GetFeatureFlags',
+            google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
+            proto_dot_api_dot_v0_dot_luminarycloud_dot_feature__flag_dot_feature__flag__pb2.GetFeatureFlagsResponse.FromString,
+            options, channel_credentials,
+            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

luminarycloud/_proto/api/v0/luminarycloud/feature_flag/feature_flag_pb2_grpc.pyi

@@ -0,0 +1,35 @@
+"""
+@generated by mypy-protobuf.  Do not edit manually!
+isort:skip_file
+"""
+import abc
+import google.protobuf.empty_pb2
+import grpc
+import luminarycloud._proto.api.v0.luminarycloud.feature_flag.feature_flag_pb2
+
+class FeatureFlagServiceStub:
+    """Manages feature flags for internal users."""
+
+    def __init__(self, channel: grpc.Channel) -> None: ...
+    GetFeatureFlags: grpc.UnaryUnaryMultiCallable[
+        google.protobuf.empty_pb2.Empty,
+        luminarycloud._proto.api.v0.luminarycloud.feature_flag.feature_flag_pb2.GetFeatureFlagsResponse,
+    ]
+    """Gets all enabled feature flags for the authenticated user.
+    Feature flags are used to control access to experimental and internal features.
+    """
+
+class FeatureFlagServiceServicer(metaclass=abc.ABCMeta):
+    """Manages feature flags for internal users."""
+
+    @abc.abstractmethod
+    def GetFeatureFlags(
+        self,
+        request: google.protobuf.empty_pb2.Empty,
+        context: grpc.ServicerContext,
+    ) -> luminarycloud._proto.api.v0.luminarycloud.feature_flag.feature_flag_pb2.GetFeatureFlagsResponse:
+        """Gets all enabled feature flags for the authenticated user.
+        Feature flags are used to control access to experimental and internal features.
+        """
+
+def add_FeatureFlagServiceServicer_to_server(servicer: FeatureFlagServiceServicer, server: grpc.Server) -> None: ...