luminarycloud 0.16.2__py3-none-any.whl → 0.18.0__py3-none-any.whl

luminarycloud/_auth/auth.py

@@ -38,9 +38,10 @@ class Auth0Client:
         (Optional) Auth0 client ID
     audience : str
         (Optional) Auth0 audience (i.e. target service ID)
-    no_browser : bool
-        (Optional) If True, prevents client from opening browser and raises an error if user
-        interaction via the browser becomes required.
+    noninteractive : bool
+        (Optional) If True, prevents client from ever attempting an interactive login (i.e.
+        launching an http server and opening the login page in a web browser). In cases where user
+        interaction is required, an error will be raised. Default: False
     access_token : str
         (Optional) Auth0 access token.
     refresh_token : str
@@ -55,7 +56,7 @@ class Auth0Client:
         domain: Optional[str] = None,
         client_id: Optional[str] = None,
         audience: Optional[str] = None,
-        no_browser: bool = False,
+        noninteractive: bool = False,
         access_token: Optional[str] = None,
         refresh_token: Optional[str] = None,
         refresh_rotation: Optional[bool] = None,
@@ -63,7 +64,7 @@ class Auth0Client:
         self.domain = domain or LC_AUTH_DOMAIN  # Auth0 tenant domain
         self.client_id = client_id or LC_AUTH_CLIENT_ID  # Auth0 ID for client
         self.audience = audience or LC_AUTH_SERVICE_ID  # Auth0 ID for service
-        self.no_browser = no_browser  # True to prevent client from opening browser
+        self.noninteractive = noninteractive  # True to prevent interactive login
         self.refresh_rotation = (
             refresh_rotation or LC_REFRESH_ROTATION
         )  # True if refresh token rotation is enabled on Auth0
@@ -187,12 +188,16 @@ class Auth0Client:
         Raises
         ------
         InteractiveAuthException
-            If user interaction is required, and self.no_browser is True.
+            If user interaction is required, and self.noninteractive is True.
         SecurityAlertException
             If the callback server receives a request from a potential attacker.
         AuthException
             If the tokens received from the Auth0 exchange are not found in the response.
         """
+        if self.noninteractive:
+            raise InteractiveAuthException(
+                "User interaction disabled, cannot initiate browser login."
+            )
 
         logger.info("Initiating user login.")
 
@@ -226,34 +231,18 @@ class Auth0Client:
             url_parameters["redirect_uri"] = redirect_uri
             authorize_url = urljoin(self.base_url, "authorize?" + urlencode(url_parameters))
 
-            logger.info("Attempting silent auth.")
-            # https://auth0.com/docs/authenticate/login/configure-silent-authentication
-            # TODO: This always fails due to lack of cookies: https://community.auth0.com/t/failed-silent-auth-login-required/33165/25?page=2
-            response = requests.get(authorize_url + "&prompt=none", timeout=TIMEOUT)
-            try:
-                response.raise_for_status()  # raise an error if we get a 40X status code
-                callback_args = listener.block_until_callback()
-            except KeyboardInterrupt:
-                raise
-            except Exception as e:
-                logger.info("Silent auth failed.", exc_info=e)
-                callback_args = MultiDict()
-
-            # Fall back to interactive auth if silent auth fails
-            if "error" in callback_args:
-                if self.no_browser:
-                    raise InteractiveAuthException(
-                        "Cannot login without user interaction via browser."
-                    )
-                logger.info("Silent auth failed. Prompting interactive login via browser.")
-                webbrowser.open_new(authorize_url)
-                print(
-                    "Interactive login required. Your browser has been opened to visit the following URL:\n\n",
-                    authorize_url,
-                    "\n",
-                )
-                logger.debug("Waiting for redirect callback.")
-                callback_args = listener.block_until_callback()
+            logger.info("Prompting interactive login via browser.")
+            if webbrowser.open_new(authorize_url):
+                interaction_detail = "Your browser has been opened to visit the following URL"
+            else:
+                interaction_detail = "Please visit the following URL in your browser"
+            print(
+                f"Interactive login required. {interaction_detail}:\n\n",
+                authorize_url,
+                "\n",
+            )
+            logger.debug("Waiting for redirect callback.")
+            callback_args = listener.block_until_callback()
 
         if "error" in callback_args:
             raise AuthException(callback_args["error"] + ": " + callback_args["error_description"])

luminarycloud/_client/client.py

@@ -4,7 +4,7 @@ import re
 import atexit
 from contextvars import ContextVar, Token
 from collections.abc import Iterable
-from typing import Any, Optional
+from typing import Any, Optional, Union
 
 import grpc
 
@@ -28,6 +28,7 @@ from .._proto.api.v0.luminarycloud.simulation_template.simulation_template_pb2_g
 from .._proto.api.v0.luminarycloud.named_variable_set.named_variable_set_pb2_grpc import (
     NamedVariableSetServiceStub,
 )
+from .._proto.api.v0.luminarycloud.pipelines.pipelines_pb2_grpc import PipelineServiceStub
 from .._proto.api.v0.luminarycloud.physics_ai.physics_ai_pb2_grpc import (
     PhysicsAiServiceStub,
 )
@@ -35,6 +36,9 @@ from .._proto.api.v0.luminarycloud.inference.inference_pb2_grpc import Inference
 from .._proto.api.v0.luminarycloud.thirdpartyintegration.onshape.onshape_pb2_grpc import (
     OnshapeServiceStub,
 )
+from .._proto.api.v0.luminarycloud.project_ui_state.project_ui_state_pb2_grpc import (
+    ProjectUIStateServiceStub,
+)
 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
@@ -61,9 +65,11 @@ class Client(
     OutputDefinitionServiceStub,
     StoppingConditionServiceStub,
     NamedVariableSetServiceStub,
+    PipelineServiceStub,
     PhysicsAiServiceStub,
     InferenceServiceStub,
     OnshapeServiceStub,
+    ProjectUIStateServiceStub,
 ):
     """
     Creates a Luminary API client.
@@ -102,7 +108,7 @@ class Client(
         self,
         target: str = LC_DOMAIN,
         localhost: bool = False,
-        grpc_channel_options: Optional[Iterable[tuple[str, str]]] = None,
+        grpc_channel_options: Optional[Iterable[tuple[str, Union[str, int]]]] = None,
         channel_credentials: Optional[grpc.ChannelCredentials] = None,
         api_key: Optional[str] = LC_API_KEY,
         **kwargs: Any,
@@ -111,8 +117,19 @@ class Client(
         self._apiserver_domain = target.split(":", maxsplit=1)[0]
         # Initialize Auth0 client only if not using API key
         self._auth0_client = None if api_key else Auth0Client(**kwargs)
+        # It seems that both python and golang cliens have trouble sometimes RPC calls getting
+        # stuck. In go, setting some keepalive options seems to help, so we'll do the same here. See
+        # https://github.com/grpc/grpc/blob/d8b7d55975b945a9dee40db5ee87f170590721d9/examples/python/keep_alive/greeter_client.py#L1.
+        grpc_channel_options_with_keep_alive: list[tuple[str, Union[str, int]]] = [
+            ("grpc.keepalive_time_ms", 50000),
+            ("grpc.keepalive_timeout_ms", 5000),
+            ("grpc.keepalive_permit_without_calls", 1),
+            ("grpc.http2.max_pings_without_data", 10),
+        ]
+        if grpc_channel_options:
+            grpc_channel_options_with_keep_alive.extend(grpc_channel_options)
         self._channel = self._create_channel(
-            localhost, grpc_channel_options, channel_credentials, api_key
+            localhost, grpc_channel_options_with_keep_alive, channel_credentials, api_key
         )
         self._context_tokens: list[Token] = []
         self.__register_rpcs()
@@ -157,7 +174,7 @@ class Client(
     def _create_channel(
         self,
         localhost: bool = False,
-        grpc_channel_options: Optional[Iterable[tuple[str, str]]] = None,
+        grpc_channel_options: Optional[Iterable[tuple[str, Union[str, int]]]] = None,
         channel_credentials: Optional[grpc.ChannelCredentials] = None,
         api_key: Optional[str] = None,
     ) -> grpc.Channel:
@@ -207,10 +224,12 @@ class Client(
         OutputNodeServiceStub.__init__(self, self._channel)
         OutputDefinitionServiceStub.__init__(self, self._channel)
         StoppingConditionServiceStub.__init__(self, self._channel)
+        PipelineServiceStub.__init__(self, self._channel)
         PhysicsAiServiceStub.__init__(self, self._channel)
         InferenceServiceStub.__init__(self, self._channel)
         NamedVariableSetServiceStub.__init__(self, self._channel)
         OnshapeServiceStub.__init__(self, self._channel)
+        ProjectUIStateServiceStub.__init__(self, self._channel)
         for name, value in self.__dict__.items():
             if isinstance(value, grpc.UnaryUnaryMultiCallable):
                 setattr(self, name, rpc_error(value))

luminarycloud/_client/retry_interceptor.py

@@ -47,6 +47,13 @@ class RetryInterceptor(UnaryUnaryClientInterceptor):
             call = continuation(client_call_details, request)
             if call.code() not in retryable_codes:
                 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
             sleep(backoff)
         try:
             call.result()

luminarycloud/_helpers/_create_geometry.py

@@ -1,21 +1,152 @@
 # Copyright 2024 Luminary Cloud, Inc. All Rights Reserved.
 from luminarycloud._proto.api.v0.luminarycloud.geometry import geometry_pb2 as geometrypb
 from luminarycloud._proto.upload import upload_pb2 as uploadpb
+from luminarycloud.types.adfloat import _to_ad_proto
 from os import PathLike
 from .._client import Client
 from .upload import upload_file
-from typing import Optional
+from typing import List, Optional
 from luminarycloud._helpers import util
 import uuid
 import random
 import time
+import tempfile
+import zipfile
+from pathlib import Path
 
 import logging
 
 logger = logging.getLogger(__name__)
 
 
+def _create_zip(file_paths: List[PathLike | str]) -> Path:
+    """Create ZIP file."""
+
+    zip_path = Path(tempfile.mktemp(suffix=".zip"))
+
+    with zipfile.ZipFile(zip_path, "w") as zf:
+        for file_path in file_paths:
+            path = Path(file_path)
+            zf.write(path, path.name)  # Flatten structure
+
+    return zip_path
+
+
+def _create_geometry_from_url(
+    client: Client,
+    project_id: str,
+    url: str,
+    name: str,
+    web_geometry_id: str,
+    scaling: Optional[float],
+    wait: bool,
+) -> geometrypb.Geometry:
+    """Create geometry from already-uploaded URL (shared logic)."""
+
+    if scaling is None:
+        # default to no scaling
+        scaling = 1.0
+
+    create_geo_res: geometrypb.CreateGeometryResponse = client.CreateGeometry(
+        geometrypb.CreateGeometryRequest(
+            project_id=project_id,
+            name=name,
+            url=url,
+            web_geometry_id=web_geometry_id,
+            scaling=_to_ad_proto(scaling),
+            wait=False,
+            request_id=str(uuid.uuid4()),
+        )
+    )
+    geo = create_geo_res.geometry
+
+    # Prefer polling on the client than waiting on the server (although waiting on the server
+    # notifies the clients potentially faster).
+    if wait:
+        last_version_id = ""
+        while not last_version_id:
+            jitter = random.uniform(0.5, 1.5)
+            time.sleep(2 + jitter)
+            req = geometrypb.GetGeometryRequest(geometry_id=create_geo_res.geometry.id)
+            res_geo: geometrypb.GetGeometryResponse = client.GetGeometry(req)
+            geo = res_geo.geometry
+            last_version_id = geo.last_version_id
+
+    logger.info(f"created geometry {geo.name} ({geo.id})")
+    return geo
+
+
+def _create_geometry_from_multiple_files(
+    client: Client,
+    cad_file_paths: List[PathLike | str],
+    project_id: str,
+    *,
+    name: Optional[str] = None,
+    scaling: Optional[float] = None,
+    wait: bool = False,
+) -> geometrypb.Geometry:
+    """
+    Create geometry from multiple files using frontend's proven pattern.
+
+    Creates a ZIP file and uploads using meshParams (not geometryParams)
+    to leverage existing FileSetManifest infrastructure.
+    """
+
+    # Create ZIP file (simple, no validation - like single-file)
+    zip_path = _create_zip(cad_file_paths)
+
+    try:
+        # Upload ZIP using meshParams
+        finish_res = upload_file(
+            client,
+            project_id,
+            uploadpb.ResourceParams(mesh_params=uploadpb.MeshParams(scaling=scaling or 1.0)),
+            zip_path,
+        )[1]
+
+        # Create geometry from uploaded ZIP URL
+        return _create_geometry_from_url(
+            client,
+            project_id,
+            finish_res.url,
+            name or "Multi-file Geometry",
+            "",
+            scaling,
+            wait,
+        )
+    finally:
+        # Clean up ZIP
+        zip_path.unlink()
+
+
 def create_geometry(
+    client: Client,
+    cad_file_path: PathLike | str | List[PathLike | str],
+    project_id: str,
+    *,
+    name: Optional[str] = None,
+    scaling: Optional[float] = None,
+    wait: bool = False,
+) -> geometrypb.Geometry:
+    """
+    Create a geometry from single or multiple CAD files.
+    """
+
+    # Route to appropriate handler based on input type
+    if isinstance(cad_file_path, (list, tuple)) and len(cad_file_path) > 1:
+        # Multi-file: use mesh upload pattern (like frontend)
+        return _create_geometry_from_multiple_files(
+            client, cad_file_path, project_id, name=name, scaling=scaling, wait=wait
+        )
+
+    # Single file: existing logic
+    single_path = cad_file_path[0] if isinstance(cad_file_path, (list, tuple)) else cad_file_path
+    return _create_geometry_from_single_file(
+        client, single_path, project_id, name=name, scaling=scaling, wait=wait
+    )
+
+
+def _create_geometry_from_single_file(
     client: Client,
     cad_file_path: PathLike | str,
     project_id: str,
@@ -23,8 +154,8 @@ def create_geometry(
     name: Optional[str] = None,
     scaling: Optional[float] = None,
     wait: bool = False,
-    convert_to_discrete: bool = False,
 ) -> geometrypb.Geometry:
+    """Create geometry from single file."""
 
     # TODO(onshape): Document this publicly when we release
     cad_file_path_str = str(cad_file_path)
@@ -62,35 +193,4 @@ def create_geometry(
             # if the caller did not provide a name, use the file name
             name = cad_file_meta.name
 
-    if scaling is None:
-        # default to no scaling
-        scaling = 1.0
-
-    create_geo_res: geometrypb.CreateGeometryResponse = client.CreateGeometry(
-        geometrypb.CreateGeometryRequest(
-            project_id=project_id,
-            name=name,
-            url=url,
-            web_geometry_id=web_geometry_id,
-            scaling=scaling,
-            wait=False,
-            request_id=str(uuid.uuid4()),
-            force_discrete=convert_to_discrete,
-        )
-    )
-    geo = create_geo_res.geometry
-
-    # Prefer polling on the client than waiting on the server (although waiting on the server
-    # notifies the clients potentially faster).
-    if wait:
-        last_version_id = ""
-        while not last_version_id:
-            jitter = random.uniform(0.5, 1.5)
-            time.sleep(2 + jitter)
-            req = geometrypb.GetGeometryRequest(geometry_id=create_geo_res.geometry.id)
-            res_geo: geometrypb.GetGeometryResponse = client.GetGeometry(req)
-            geo = res_geo.geometry
-            last_version_id = geo.last_version_id
-
-    logger.info(f"created geometry {geo.name} ({geo.id})")
-    return geo
+    return _create_geometry_from_url(client, project_id, url, name, web_geometry_id, scaling, wait)

luminarycloud/_helpers/_wait_for_mesh.py

@@ -1,6 +1,7 @@
 # Copyright 2023-2024 Luminary Cloud, Inc. All Rights Reserved.
 import logging
 from time import time, sleep
+import grpc
 
 from .._proto.api.v0.luminarycloud.mesh.mesh_pb2 import Mesh, GetMeshRequest
 from .._client import Client
@@ -35,11 +36,20 @@ def wait_for_mesh(
     """
     deadline = time() + timeout_seconds
     while True:
-        response = client.GetMesh(GetMeshRequest(id=mesh.id))
+        if time() >= deadline:
+            logger.error("`wait_for_mesh` timed out.")
+            raise TimeoutError
+        # It seems this call sometimes hangs. It seems as well that python gRPC is known to hang
+        # in some cases, so we'll add a deadline and catch deadline exceeded errors to retry.
+        try:
+            response = client.GetMesh(GetMeshRequest(id=mesh.id), timeout=15)
+        except grpc.RpcError as e:
+            if e.code() == grpc.StatusCode.DEADLINE_EXCEEDED:
+                logger.error("Deadline exceeded while waiting for mesh.")
+                sleep(max(0, min(interval_seconds, deadline - time())))
+                continue
+            raise e
         status = response.mesh.status
         if status in [Mesh.MESH_STATUS_COMPLETED, Mesh.MESH_STATUS_FAILED]:
             return status
         sleep(max(0, min(interval_seconds, deadline - time())))
-        if time() >= deadline:
-            logger.error("`wait_for_mesh` timed out.")
-            raise TimeoutError

luminarycloud/_helpers/cond.py

@@ -403,7 +403,6 @@ def params_to_dict(sim_params: SimulationParam) -> dict[str, Any]:
     tree = MessageToDict(
         sim_params,
         preserving_proto_field_name=True,
-        including_default_value_fields=False,
     )
     helper = CondHelper()
     return helper.prune(tree)