luminarycloud 0.14.1__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,

luminarycloud/_client/client.py

@@ -28,6 +28,9 @@ 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.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
@@ -54,6 +57,7 @@ class Client(
     OutputDefinitionServiceStub,
     StoppingConditionServiceStub,
     NamedVariableSetServiceStub,
+    PhysicsAiServiceStub,
 ):
     """
     Creates a Luminary API client.
@@ -197,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/_helpers/__init__.py

@@ -38,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/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]: