luminarycloud 0.14.0__py3-none-any.whl → 0.15.0__py3-none-any.whl

luminarycloud/__init__.py

@@ -1,10 +1,11 @@
-# Copyright 2023-2024 Luminary Cloud, Inc. All Rights Reserved.
+# Copyright 2023-2025 Luminary Cloud, Inc. All Rights Reserved.
 import logging as _logging
 
 from ._version import __version__
 
 from . import (
     _patch as _patch,
+    enum as enum,
     exceptions as exceptions,
     meshing as meshing,
     outputs as outputs,
@@ -22,6 +23,9 @@ from .geometry import (
     get_geometry as get_geometry,
     Geometry as Geometry,
 )
+from .geometry_version import (
+    GeometryVersion as GeometryVersion,
+)
 from .mesh import (
     get_mesh as get_mesh,
     get_mesh_metadata as get_mesh_metadata,
@@ -55,6 +59,9 @@ from .reference_values import (
 from .volume_selection import (
     VolumeSelection as VolumeSelection,
 )
+from .named_variable_set import (
+    NamedVariableSet as NamedVariableSet,
+)
 
 # Log SDK version number
 logger = _logging.getLogger("luminarycloud")

luminarycloud/_client/client.py

@@ -25,6 +25,12 @@ from .._proto.api.v0.luminarycloud.simulation.simulation_pb2_grpc import (
 from .._proto.api.v0.luminarycloud.simulation_template.simulation_template_pb2_grpc import (
     SimulationTemplateServiceStub,
 )
+from .._proto.api.v0.luminarycloud.named_variable_set.named_variable_set_pb2_grpc import (
+    NamedVariableSetServiceStub,
+)
+from .._proto.api.v0.luminarycloud.physics_ai.physics_ai_pb2_grpc import (
+    PhysicsAiServiceStub,
+)
 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
@@ -50,6 +56,8 @@ class Client(
     OutputNodeServiceStub,
     OutputDefinitionServiceStub,
     StoppingConditionServiceStub,
+    NamedVariableSetServiceStub,
+    PhysicsAiServiceStub,
 ):
     """
     Creates a Luminary API client.
@@ -193,6 +201,7 @@ class Client(
         OutputNodeServiceStub.__init__(self, self._channel)
         OutputDefinitionServiceStub.__init__(self, self._channel)
         StoppingConditionServiceStub.__init__(self, self._channel)
+        PhysicsAiServiceStub.__init__(self, self._channel)
         for name, value in self.__dict__.items():
             if isinstance(value, grpc.UnaryUnaryMultiCallable):
                 setattr(self, name, rpc_error(value))

luminarycloud/_client/logging_interceptor.py

@@ -16,12 +16,33 @@ from .._version import __version__
 logger = logging.getLogger(__name__)
 
 
+def _get_ai_notebook_id() -> str:
+    # This needs to match the file name in frodo/src/use-jupyter-temp-files
+    ai_notebook_active_file = "lc-ai-nb-active-nb"
+    # Check if we're in the AI notebook env and read the notebook ID file
+    # if we are
+    notebook_id = ""
+    try:
+        with open(ai_notebook_active_file, "r") as f:
+            notebook_id = f.read()
+    except:
+        # Just suppress any errors in loading the notebook ID and don't include
+        # the invalid/missing ID. Either we're not in the AI notebook or the ID
+        # isn't in the file
+        pass
+    return notebook_id
+
+
 class LoggingInterceptor(UnaryUnaryClientInterceptor):
     """
     A client interceptor that logs gRPC method calls and appends the SDK version
     to the request metadata.
     """
 
+    def __init__(self) -> None:
+        super().__init__()
+        self._notebook_id = _get_ai_notebook_id()
+
     def intercept_unary_unary(
         self,
         continuation: Callable[[ClientCallDetails, Any], grpc.Call],
@@ -35,6 +56,10 @@ class LoggingInterceptor(UnaryUnaryClientInterceptor):
         # will look like: x-client-version: python-sdk-v0.1.0
         metadata.append(("x-client-version", f"python-sdk-v{__version__}"))
 
+        if self._notebook_id != "":
+            # will look like: x-ai-notebook-id: <id>
+            metadata.append(("x-ai-notebook-id", self._notebook_id))
+
         client_call_details = _ClientCallDetails(
             client_call_details.method,
             client_call_details.timeout,

luminarycloud/_client/tracing.py

@@ -14,6 +14,7 @@ from opentelemetry.sdk.trace.export import (
     SpanExportResult,
 )
 
+from .logging_interceptor import _get_ai_notebook_id
 from .. import __version__
 from .._auth import Auth0Client
 from .._version import __version__
@@ -23,13 +24,6 @@ logger = logging.getLogger(__name__)
 # By default, OpenTelemetry Python uses W3C Trace Context and W3C Baggage for propagation:
 # https://opentelemetry.io/docs/instrumentation/python/manual/#change-the-default-propagation-format
 
-_resource = Resource(
-    attributes={
-        SERVICE_NAME: "python/sdk",
-        SERVICE_VERSION: __version__,
-    }
-)
-
 
 # This is a hack to get opentelemetry to skip SSL verification when exporting traces.
 # We do it this way because opentelemetry overrides the `verify` option in their code when they make
@@ -104,6 +98,17 @@ def _get_collector_endpoint(primary_domain: str) -> str:
     return f"https://{primary_domain}/v1/traces"
 
 
+def _get_trace_resource() -> Resource:
+    resource = Resource(
+        attributes={
+            SERVICE_NAME: "python/sdk",
+            SERVICE_VERSION: __version__,
+            "notebook_id": _get_ai_notebook_id(),
+        }
+    )
+    return resource
+
+
 def _add_instrumentation(
     channel: Channel,
     endpoint: str,
@@ -111,7 +116,7 @@ def _add_instrumentation(
     api_key: Optional[str],
     verify_ssl: bool = True,
 ) -> Channel:
-    provider = TracerProvider(resource=_resource)
+    provider = TracerProvider(resource=_get_trace_resource())
     if api_key:
         processor = BatchSpanProcessor(
             ApiKeySpanExporter(

luminarycloud/_helpers/__init__.py

@@ -10,6 +10,7 @@ from .download import (
     download_volume_solution as download_volume_solution,
     download_surface_deformation_template as download_surface_deformation_template,
     download_surface_sensitivity_data as download_surface_sensitivity_data,
+    download_parameter_sensitivity_data as download_parameter_sensitivity_data,
     save_file as save_file,
 )
 from .file_chunk_stream import (
@@ -37,3 +38,4 @@ from ._upload_table import (
 from ._wait_for_simulation import (
     wait_for_simulation as wait_for_simulation,
 )
+from ._code_representation import CodeRepr as CodeRepr

luminarycloud/_helpers/_code_representation.py

@@ -0,0 +1,135 @@
+# Copyright 2025 Luminary Cloud, Inc. All Rights Reserved.
+from typing import Any
+from google.protobuf.message import Message as _ProtoMessage
+
+
+# Gives derived classes the ability to generate the code that would set the values of their members.
+# Evidently this is most suited for dataclasses.
+# Note that to allow recursion, the lines generated by this class DO NOT contain the name of the
+# object being generated, e.g. they will be of the form " = Type()", ".field = val".
+# Derived classes can use _to_code_helper to insert an adequate object name.
+class CodeRepr:
+    def to_code(self, hide_defaults: bool = True) -> str:
+        # Returns the code representation of a value with special cases for enums and classes
+        # that also implement "to_code" (thus triggering recursion), otherwise uses the default
+        # conversion to string.
+        def to_string(val: Any) -> str:
+            if "<enum " in str(type(val)):
+                str_val = val.__repr__()
+                return str_val.split(": ")[0][1:]
+            try:
+                return val.to_code(hide_defaults)
+            except:
+                return str(val)
+
+        # Returns the code to set the value of a given field of the class.
+        def generate(field: str, val: Any) -> str:
+            str_val = to_string(val)
+            code = ""
+            if issubclass(type(val), _ProtoMessage):
+                # Special case for protos.
+                # TODO(pedro): This is not working 100%.
+                code += "# NOTE: Google protobuf types are not fully supported yet.\n"
+                code += f".{field} = {type(val).__name__}()\n"
+                for line in str_val.split("\n"):
+                    if ":" in line:
+                        mod_line = line.replace(":", " =")
+                        code += f".{field}.{mod_line}\n"
+            elif str_val.endswith("\n"):
+                # Special case for fields with their own "to_code".
+                for line in str_val.split("\n"):
+                    if line.startswith("new_") or line.startswith("#"):
+                        code += f"{line}\n"
+                    elif line.startswith(".new_"):
+                        code += f"{line[1:]}\n"
+                    elif line:
+                        code += f".{field}{line}\n"
+            elif isinstance(val, str):
+                code += f'.{field} = "{str_val}"\n'
+            else:
+                code += f".{field} = {str_val}\n"
+            return code
+
+        # Returns the code representation of map keys, with special cases for enums and strings.
+        def map_key(key: Any) -> str:
+            if isinstance(key, str):
+                return f'"{key}"'
+            if "<enum " in str(type(key)):
+                str_key = key.__repr__()
+                return str_key.split(": ")[0][1:]
+            return str(key)
+
+        # Helper to generate short names for temporary objects that are built and inserted into
+        # containers.
+        def short_name(field: str) -> str:
+            if not "_" in field:
+                return field
+            return "".join([word[0] for word in field.split("_")])
+
+        # Create the top level object (default constructed), we do some manipulation of module paths
+        # (extracted from the type info) to make them consistent with the aliased imports in some
+        # __init__ files.
+        if "luminarycloud" in str(type(self)):
+            path = (
+                str(type(self))
+                .split("'")[1]
+                .replace("luminarycloud.params.simulation", "params")
+                .replace("luminarycloud.outputs.output_definitions", "outputs")
+            )
+            names = path.split(".")
+            if names[-2].endswith("_"):
+                path = path.replace(names[-2] + ".", "")
+            code = f" = {path}()\n"
+        else:
+            code = f" = {type(self).__name__}()\n"
+
+        default = type(self)()
+        for field, val in vars(self).items():
+            # Skip default values.
+            if hide_defaults and val == vars(default).get(field):
+                continue
+            field_short_name = short_name(field)
+            if isinstance(val, dict):
+                code += "# Clear the map and insert new items.\n"
+                code += f".{field} = {{}}\n"
+                for key, value in val.items():
+                    # Simplify the code for maps of built-in types by not creating a temporary
+                    # instance.
+                    if isinstance(value, (bool, int, float)):
+                        code += f".{field}[{map_key(key)}] = {value}\n"
+                    elif isinstance(value, str):
+                        code += f'.{field}[{map_key(key)}] = "{value}"\n'
+                    else:
+                        code += f"# Create a new {type(value).__name__} instance and insert it.\n"
+                        code += generate(f"new_{field_short_name}", value)
+                        code += f".{field}[{map_key(key)}] = new_{field_short_name}\n"
+            elif isinstance(val, list):
+                # Similar to maps, for classes with more complex representations create temporaries
+                # and append, otherwise use the default list representation (which also covers
+                # empty lists).
+                if len(val) > 0 and to_string(val[0]).endswith("\n"):
+                    code += f"# Clear the list of {type(val[0]).__name__} and append new items.\n"
+                    code += f".{field} = []\n"
+                    for value in val:
+                        code += f"# Create a new {type(value).__name__} instance and append it.\n"
+                        code += generate(f"new_{field_short_name}", value)
+                        code += f".{field}.append(new_{field_short_name})\n"
+                else:
+                    code += f".{field} = {to_string(val)}\n"
+            else:
+                code += generate(field, val)
+        return code
+
+    # See the class description.
+    def _to_code_helper(self, obj_name: str = "obj", hide_defaults: bool = True) -> str:
+        code = ""
+        for line in CodeRepr.to_code(self, hide_defaults).split("\n"):
+            if line:
+                if line.startswith(".new_"):
+                    code += f"{line[1:]}\n"
+                elif line[0] == "." or line.startswith(" = "):
+                    code += f"{obj_name}{line}\n"
+                else:
+                    # Handles comments and temporary objects.
+                    code += f"{line}\n"
+        return code

luminarycloud/_helpers/_simulation_params_from_json.py

@@ -2,7 +2,7 @@
 from os import PathLike
 from typing import Union
 
-from google.protobuf.json_format import Parse
+from google.protobuf.json_format import Parse, ParseDict
 
 from .._proto.client.simulation_pb2 import SimulationParam
 
@@ -11,6 +11,10 @@ def simulation_params_from_json(text: Union[str, bytes]) -> SimulationParam:
     return Parse(text, SimulationParam(), ignore_unknown_fields=True)
 
 
+def simulation_params_from_json_dict(data: dict) -> SimulationParam:
+    return ParseDict(data, SimulationParam(), ignore_unknown_fields=True)
+
+
 def simulation_params_from_json_path(json_path: PathLike | str) -> SimulationParam:
     with open(json_path, "rb") as fp:
         json_bytes = fp.read()

luminarycloud/_helpers/download.py

@@ -13,6 +13,7 @@ from .._proto.api.v0.luminarycloud.solution.solution_pb2 import (
     GetSolutionVolumeDataRequest,
     GetSurfaceDeformationTemplateRequest,
     GetSurfaceSensitivityDataRequest,
+    GetParameterSensitivityDataRequest,
 )
 from .._client import Client
 
@@ -152,6 +153,21 @@ def download_surface_sensitivity_data(
     return _create_file_chunk_stream(client, solution_id, "surface sensitivity data", response.file)
 
 
+def download_parameter_sensitivity_data(
+    client: Client,
+    solution_id: str,
+) -> FileChunkStream:
+    """
+    Similar to download_surface_solution.
+    """
+
+    request = GetParameterSensitivityDataRequest(id=solution_id)
+    response = client.GetParameterSensitivityData(request)
+    return _create_file_chunk_stream(
+        client, solution_id, "parameter sensitivity data", response.file
+    )
+
+
 def save_file(
     file_proto: commonpb.File,
     dest_dir: Union[os.PathLike, str],

luminarycloud/_helpers/named_variables.py

@@ -0,0 +1,25 @@
+from .._proto.base.base_pb2 import AdFloatType, ExpressionType
+
+from ..types.adfloat import _to_ad_proto, _from_ad_proto
+
+
+def _named_variables_to_proto(
+    named_variables: dict[str, float | str],
+) -> dict[str, AdFloatType]:
+    return {
+        k: (
+            _to_ad_proto(v)
+            if isinstance(v, float)
+            else AdFloatType(expression=ExpressionType(expression=v))
+        )
+        for k, v in named_variables.items()
+    }
+
+
+def _named_variables_from_proto(
+    named_variables: dict[str, AdFloatType],
+) -> dict[str, float | str]:
+    return {
+        k: v.variable.expression if v.HasField("variable") else _from_ad_proto(v)
+        for k, v in named_variables.items()
+    }

luminarycloud/_helpers/upload.py

@@ -5,6 +5,7 @@ import pathlib
 from typing import Mapping
 import requests
 import logging
+import grpc
 
 from . import util
 from .._client import Client
@@ -84,21 +85,40 @@ def upload_file(
     upload_id = create_upload_res.upload.id
     logger.debug(f"created upload: {upload_id}")
 
-    start_res: uploadpb.StartUploadReply = client.StartUpload(
-        uploadpb.StartUploadRequest(upload_id=upload_id, method=uploadpb.METHOD_GCS_RESUMABLE)
-    )
-    logger.debug(f"started upload")
+    try:
+        start_res = client.StartUpload(
+            uploadpb.StartUploadRequest(upload_id=upload_id, method=uploadpb.METHOD_GCS_RESUMABLE)
+        )
+        logger.debug("started gcs upload")
 
-    gcs_resumable_upload(
-        filepath=pathlib.Path(file_path),
-        signed_url=start_res.upload.gcs_resumable.signed_url,
-        http_headers=start_res.upload.gcs_resumable.http_headers,
-    )
-    logger.debug(f"successfully uploaded data")
+        gcs_resumable_upload(
+            filepath=pathlib.Path(file_path),
+            signed_url=start_res.upload.gcs_resumable.signed_url,
+            http_headers=start_res.upload.gcs_resumable.http_headers,
+        )
+        logger.debug("successfully uploaded gcs data")
+    except grpc.RpcError as e:
+        if e.code() != grpc.StatusCode.UNIMPLEMENTED:
+            raise e
+        start_res = client.StartUpload(
+            uploadpb.StartUploadRequest(upload_id=upload_id, method=uploadpb.METHOD_SIMPLE)
+        )
+        logger.debug("started simple upload")
+
+        # Simple non-chunked upload
+        with open(file_path, "rb") as fp:
+            client.UploadData(
+                uploadpb.UploadDataRequest(
+                    upload_id=upload_id,
+                    offset=0,
+                    data=fp.read(),
+                )
+            )
+        logger.debug("successfully uploaded simple data")
 
     finish_res: uploadpb.FinishUploadReply = client.FinishUpload(
         uploadpb.FinishUploadRequest(upload_id=upload_id)
     )
-    logger.debug(f"finished upload")
+    logger.debug("finished upload")
 
     return upload_id, finish_res

luminarycloud/_helpers/warnings/deprecated.py

@@ -7,7 +7,7 @@ from typing import Callable, TypeVar
 C = TypeVar("C")
 
 
-def deprecated(reason: str, version: str) -> Callable[[C], C]:
+def deprecated(reason: str, version: str = "") -> Callable[[C], C]:
     """
     Mark a class or function as deprecated.
 
@@ -15,26 +15,24 @@ def deprecated(reason: str, version: str) -> Callable[[C], C]:
     ----------
     reason : str
         The reason for deprecation.
-    version : str
-        The version in which the class or function was deprecated.
     """
 
-    def decorator(f: Callable | type[C]) -> Callable | type[C]:
+    def decorator(f: C) -> C:
         if isinstance(f, type):
-            return _deprecated_class(f, reason, version)
+            return _deprecated_class(f, reason)
         else:
-            return _deprecated_function(f, reason, version)
+            return _deprecated_function(f, reason)
 
     return decorator
 
 
-def _deprecated_class(cls: type[C], reason: str, version: str) -> type[C]:
+def _deprecated_class(cls: type[C], reason: str) -> type[C]:
     old_init = cls.__init__
 
     @wraps(old_init)
     def new_init(self, *args, **kwargs):
         warnings.warn(
-            f"{cls.__name__} is deprecated after version {version}: {reason}",
+            f"{cls.__name__} is deprecated: {reason}",
             category=DeprecationWarning,
             stacklevel=2,
         )
@@ -44,11 +42,11 @@ def _deprecated_class(cls: type[C], reason: str, version: str) -> type[C]:
     return cls
 
 
-def _deprecated_function(f: Callable, reason: str, version: str) -> Callable:
+def _deprecated_function(f: Callable, reason: str) -> Callable:
     @wraps(f)
     def new_func(*args, **kwargs):
         warnings.warn(
-            f"{f.__name__}() is deprecated after version {version}: {reason}",
+            f"{f.__name__}() is deprecated: {reason}",
             category=DeprecationWarning,
             stacklevel=2,
         )

luminarycloud/_helpers/warnings/experimental.py

@@ -7,12 +7,12 @@ from typing import Callable, TypeVar
 C = TypeVar("C")
 
 
-def experimental(f: Callable | type[C]) -> Callable | type[C]:
+def experimental(f: C) -> C:
     """Mark a function or class as experimental."""
-    if isinstance(f, type):
-        return _experimental_class(f)
-    else:
+    if isinstance(f, Callable):
         return _experimental_function(f)
+    else:
+        return _experimental_class(f)
 
 
 def _experimental_class(cls: type[C]) -> type[C]: