luminarycloud 0.20.0__py3-none-any.whl → 0.22.0__py3-none-any.whl

luminarycloud/__init__.py

@@ -13,18 +13,22 @@ 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,
 )
 from .geometry_version import (
     GeometryVersion as GeometryVersion,
+    get_geometry_version as get_geometry_version,
+    update_geometry_version as update_geometry_version,
 )
 from .mesh import (
     get_mesh as get_mesh,

luminarycloud/_client/client.py

@@ -44,6 +44,9 @@ 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 .._proto.api.v0.luminarycloud.feature_flag.feature_flag_pb2_grpc import (
+    FeatureFlagServiceStub,
+)
 from .authentication_plugin import AuthenticationPlugin
 from .config import LC_DOMAIN, LC_API_KEY
 from .logging_interceptor import LoggingInterceptor
@@ -71,6 +74,7 @@ class Client(
     InferenceServiceStub,
     OnshapeServiceStub,
     ProjectUIStateServiceStub,
+    FeatureFlagServiceStub,
 ):
     """
     Creates a Luminary API client.
@@ -248,6 +252,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

@@ -113,9 +113,11 @@ class HttpClient:
                 f"Bearer {self.auth0_client.fetch_access_token()}"
             )
 
-    def _request(self, method: str, path: str, **kwargs) -> requests.Response:
+    # This method, which takes a full URL instead of just a path, is made public so the upload
+    # helper can use it to make authenticated requests to a gcsproxy endpoint which is hosted by
+    # jobmaster, not apiserver
+    def raw_request(self, method: str, url: str, **kwargs) -> requests.Response:
         self._authenticate_session()
-        url = self._url(path)
         self._log_request(method, url, kwargs)
         resp = self.session.request(method, url, timeout=self.timeout, **kwargs)
         self._log_response(resp)
@@ -128,22 +130,22 @@ class HttpClient:
 
     # ---- Raw methods ----
     def raw_get(self, path: str, **kwargs) -> requests.Response:
-        return self._request("GET", path, **kwargs)
+        return self.raw_request("GET", self._url(path), **kwargs)
 
     def raw_post(self, path: str, body: dict | None = None, **kwargs) -> requests.Response:
-        return self._request("POST", path, json=body, **kwargs)
+        return self.raw_request("POST", self._url(path), json=body, **kwargs)
 
     def raw_put(self, path: str, body: dict | None = None, **kwargs) -> requests.Response:
-        return self._request("PUT", path, json=body, **kwargs)
+        return self.raw_request("PUT", self._url(path), json=body, **kwargs)
 
     def raw_patch(self, path: str, body: dict | None = None, **kwargs) -> requests.Response:
-        return self._request("PATCH", path, json=body, **kwargs)
+        return self.raw_request("PATCH", self._url(path), json=body, **kwargs)
 
     def raw_delete(self, path: str, **kwargs) -> requests.Response:
-        return self._request("DELETE", path, **kwargs)
+        return self.raw_request("DELETE", self._url(path), **kwargs)
 
     def raw_head(self, path: str, **kwargs) -> requests.Response:
-        return self._request("HEAD", path, **kwargs)
+        return self.raw_request("HEAD", self._url(path), **kwargs)
 
     # ---- JSON convenience methods ----
     def get(self, path: str, **kwargs) -> dict:

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/_upload_mesh.py

@@ -137,6 +137,7 @@ def _upload_mesh_from_path(
     logger.debug(f"started upload")
 
     gcs_resumable_upload(
+        client=client,
         filepath=pathlib.Path(filepath),
         signed_url=start_res.upload.gcs_resumable.signed_url,
         http_headers=start_res.upload.gcs_resumable.http_headers,

luminarycloud/_helpers/download.py

@@ -4,7 +4,7 @@ import logging
 import os
 from pathlib import Path
 import requests
-from typing import Any, Iterator, Optional, Union, cast, List
+from typing import Any, Iterator, Optional, Union, cast, List, Dict
 
 from .file_chunk_stream import FileChunkStream
 from .._proto.api.v0.luminarycloud.common import common_pb2 as commonpb
@@ -139,6 +139,7 @@ def download_solution_physics_ai(
     volume_fields_to_keep: Optional[List[QuantityType]] = None,
     process_volume: bool = False,
     single_precision: bool = False,
+    internal_options: Optional[Dict[str, str]] = None,
 ) -> Optional[FileChunkStream]:
     """
     Returns the download as a file-like object, or None if destination_url is provided.
@@ -184,6 +185,7 @@ def download_solution_physics_ai(
         ),
         process_volume=process_volume,
         single_precision=single_precision,
+        internal_options=internal_options or {},
     )
     response = client.GetSolutionDataPhysicsAI(request)
 

luminarycloud/_helpers/pagination.py

@@ -0,0 +1,62 @@
+from abc import ABC, abstractmethod
+from typing import Generic, Optional, TypeVar
+
+from .._client import get_default_client
+
+T = TypeVar("T")
+
+
+class PaginationIterator(ABC, Generic[T]):
+    """Generic iterator class that provides length hint for paginated results."""
+
+    @abstractmethod
+    def _fetch_page(self, page_size: int, page_token: str) -> tuple[list[T], str, int]:
+        """
+        Fetch a page of results from the server.  Must return a tuple of the list of results, the
+        next page token, and the total count of results.
+        """
+        pass
+
+    def __init__(self, page_size: int):
+        self._page_size: int = page_size
+        self._page_token: str = ""
+        self._total_count: Optional[int] = None
+        self._current_page: Optional[list[T]] = None
+        self._client = get_default_client()
+        self._iterated_count: int = 0
+
+    def __iter__(self) -> "PaginationIterator[T]":
+        return self
+
+    def __next__(self) -> T:
+        if self._current_page is None:
+            self._fetch_next_page()
+
+        # _current_page really can't be None here, but this assertion is needed to appease mypy
+        assert self._current_page is not None
+
+        if len(self._current_page) == 0:
+            if not self._page_token:
+                raise StopIteration
+            self._fetch_next_page()
+
+        self._iterated_count += 1
+
+        return self._current_page.pop(0)
+
+    def _fetch_next_page(self) -> None:
+        items, next_page_token, total_count = self._fetch_page(self._page_size, self._page_token)
+
+        self._current_page = items
+        self._page_token = next_page_token
+
+        # Set length hint on first fetch if available
+        if self._total_count is None:
+            self._total_count = total_count
+
+    def __length_hint__(self) -> int:
+        if self._total_count is None:
+            # Fetch first page to get total size if not already fetched
+            if self._current_page is None:
+                self._fetch_next_page()
+        return max(0, (self._total_count or 0) - self._iterated_count)

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/_helpers/upload.py

@@ -3,6 +3,7 @@ from os import PathLike
 import os
 import pathlib
 from typing import Mapping
+from urllib.parse import urlparse
 import requests
 import logging
 import grpc
@@ -15,7 +16,7 @@ logger = logging.getLogger(__name__)
 
 
 def gcs_resumable_upload(
-    filepath: PathLike | str, signed_url: str, http_headers: Mapping[str, str]
+    client: Client, filepath: PathLike | str, signed_url: str, http_headers: Mapping[str, str]
 ) -> None:
     """
     Performs a resumable upload to a GCS signed url.
@@ -24,12 +25,17 @@ def gcs_resumable_upload(
     """
 
     # initiate the upload
+    parsed_url = urlparse(signed_url)
     try:
-        post_res = requests.post(
-            url=signed_url,
-            headers=http_headers,
-            json={},  # intentionally empty, we're not uploading the file data yet
-        )
+        if parsed_url.hostname and parsed_url.hostname.endswith(".luminarycloud.com"):
+            # we must be using the gcsproxy, so we'll use the `client.http` client to authenticate
+            # with our backend
+            logger.debug("signed url points to LC backend, will use authenticated client")
+            post_res = client.http.raw_request("POST", signed_url, headers=http_headers)
+        else:
+            # we're using the GCS signed url directly, no additional authentication is needed
+            logger.debug("signed url points to GCS, will use unauthenticated client")
+            post_res = requests.post(url=signed_url, headers=http_headers)
         logger.debug(
             f"sucessfully initialized signed URL upload for {filepath}, POST status code: {post_res.status_code}"
         )
@@ -49,6 +55,8 @@ def gcs_resumable_upload(
         session_uri = post_res.headers["Location"]
         size = os.path.getsize(filepath)
         with open(filepath, "rb") as fp:
+            # even if a signed url upload is initiated via the gcsproxy, the subsequent PUT request
+            # goes straight to GCS, so we don't want to use the authenticated client here
             put_res = requests.put(
                 url=session_uri,
                 headers={
@@ -57,14 +65,11 @@ def gcs_resumable_upload(
                 data=fp.read(size),
             )
             logger.debug(f"sucessfully uploaded {filepath}, PUT status code: {put_res.status_code}")
-    except:
+    except Exception as e:
         # don't log the session_uri, just to be safe
-        msg = (
-            f"failed to upload {filepath}, PUT status code: {put_res.status_code}, content: "
-            + str(put_res.content)
-        )
+        msg = f"failed to upload {filepath}, {e})"
         logger.error(msg)
-        raise Exception(msg)
+        raise Exception(e)
 
 
 def upload_file(
@@ -92,6 +97,7 @@ def upload_file(
         logger.debug("started gcs upload")
 
         gcs_resumable_upload(
+            client=client,
             filepath=pathlib.Path(file_path),
             signed_url=start_res.upload.gcs_resumable.signed_url,
             http_headers=start_res.upload.gcs_resumable.http_headers,

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: ...