luminarycloud 0.14.1__py3-none-any.whl → 0.15.1__py3-none-any.whl

luminarycloud/simulation_template.py

@@ -8,7 +8,7 @@ from difflib import Differ
 from .enum import (
     TableType,
 )
-from ._helpers.warnings import experimental
+from ._helpers.warnings import experimental, deprecated
 from ._client import get_default_client
 from ._helpers._simulation_params_from_json import simulation_params_from_json_path
 from ._helpers._timestamp_to_datetime import timestamp_to_datetime
@@ -60,8 +60,6 @@ class SimulationTemplate(ProtoWrapperBase):
     "Simulation template ID."
     name: str
     "Simulation name."
-    parameters: clientpb.SimulationParam
-    "Simulation description."
 
     _proto: simtemplatepb.SimulationTemplate
 
@@ -77,7 +75,7 @@ class SimulationTemplate(ProtoWrapperBase):
         self,
         *,
         name: Optional[str] = None,
-        parameters: Optional[Union[clientpb.SimulationParam, SimulationParam, PathLike]] = None,
+        parameters: Optional[SimulationParam | PathLike] = None,
     ) -> None:
         """
         Update simulation template.
@@ -92,6 +90,17 @@ class SimulationTemplate(ProtoWrapperBase):
             changes applied by the backend (server), for example due to presets. Any differences
             between input and result are printed on screen.
         """
+        return self._update(name=name, parameters=parameters)
+
+    def _update(
+        self,
+        *,
+        name: Optional[str] = None,
+        parameters: Optional[SimulationParam | clientpb.SimulationParam | PathLike] = None,
+    ) -> None:
+        """
+        Update simulation template. See `update()` for more details.
+        """
         req = simtemplatepb.UpdateSimulationTemplateRequest(id=self.id)
 
         if name is not None:
@@ -110,12 +119,14 @@ class SimulationTemplate(ProtoWrapperBase):
                 # Table references are manipulated via the simulation template, hence we need to persist
                 # them when we update the parameters.
                 param_proto.table_references.clear()
-                for k, v in self.parameters.table_references.items():
+                for k, v in self._proto.parameters.table_references.items():
                     param_proto.table_references[k].CopyFrom(v)
 
             req.parameters.CopyFrom(param_proto)
 
-        res = get_default_client().UpdateSimulationTemplate(req)
+        res: simtemplatepb.UpdateSimulationTemplateResponse = (
+            get_default_client().UpdateSimulationTemplate(req)
+        )
         self._proto = res.simulation_template
 
         def print_diff(
@@ -134,11 +145,11 @@ class SimulationTemplate(ProtoWrapperBase):
         # Show any inconsistency after the update and update the input argument.
         if isinstance(parameters, SimulationParam):
             old_param = deepcopy(parameters)
-            parameters._from_proto(self.parameters)
+            parameters._from_proto(self._proto.parameters)
             print_diff(old_param, parameters)
         elif isinstance(parameters, clientpb.SimulationParam):
-            print_diff(parameters, self.parameters)
-            parameters.CopyFrom(self.parameters)
+            print_diff(parameters, self._proto.parameters)
+            parameters.CopyFrom(self._proto.parameters)
 
     def delete(self) -> None:
         """
@@ -147,12 +158,17 @@ class SimulationTemplate(ProtoWrapperBase):
         req = simtemplatepb.DeleteSimulationTemplateRequest(id=self.id)
         get_default_client().DeleteSimulationTemplate(req)
 
+    def get_parameters(self) -> SimulationParam:
+        return self.get_simulation_param()
+
+    @deprecated(
+        "Use get_parameters() instead. This method will be removed in a future release.",
+    )
     def get_simulation_param(self) -> SimulationParam:
         """
-        Returns the simulation parameters associated with this template to allow customization of
-        the parameters.
+        Returns a copy of the simulation parameters associated with this template.
         """
-        return SimulationParam.from_proto(self.parameters)
+        return SimulationParam.from_proto(self._proto.parameters)
 
     def list_tables(
         self,
@@ -172,7 +188,7 @@ class SimulationTemplate(ProtoWrapperBase):
             List of tables.
         """
         res: list[RectilinearTable] = []
-        for id, metadata in self.parameters.table_references.items():
+        for id, metadata in self._proto.parameters.table_references.items():
             if table_type is None or table_type.value == metadata.table_type:
                 res.append(
                     RectilinearTable(
@@ -357,7 +373,7 @@ class SimulationTemplate(ProtoWrapperBase):
         iterations_to_consider: int | None = None,
     ) -> StoppingCondition:
         """
-        Create a stopping condition on an output definition, or update it if the stopping condition
+        Create a stopping condition on an output definition, or update it if the output definition
         already has one.
 
         While this API will prevent the creation of multiple stopping conditions on the same output
@@ -442,6 +458,61 @@ class SimulationTemplate(ProtoWrapperBase):
             self.id, max_iterations, max_physical_time, max_inner_iterations, stop_on_any
         )
 
+    def to_code(self, hide_defaults: bool = True) -> str:
+        """
+        Returns the python code that generates an identical SimulationTemplate object.
+        By default parameters with default values are omitted, this change be changed with
+        hide_defaults=False.
+        """
+        param_code = self.get_simulation_param().to_code(hide_defaults)
+        code, param_code = param_code.split("\n\n\n")
+
+        # Modify the header note included by SimulationParam.to_code.
+        code = code.replace("SimulationParam", "SimulationTemplate")
+        code += "\n\n\n"
+        code += '# Create a new simulation template or modify the "Setup" template.\n'
+        code += 'project = get_project("...")\n'
+        code += f"# template = project.create_simulation_template(name={self.name})\n"
+        code += "template = project.list_simulation_templates()[0]\n\n"
+
+        code += "# Define the simulation parameters.\n"
+        code += param_code
+        code += "\n# Update the simulation template with the parameters.\n"
+        code += "template.update(parameters=obj)\n\n"
+
+        code += "# Define the outputs for monitoring simulations.\n"
+        code += "# This assumes the outputs do not exist yet, to modify an exiting output use\n"
+        code += "# update_output_definition instead of create_output_definition, the former\n"
+        code += "# requires the definition ID, that is obtained from list_output_definitions.\n"
+        output_definitions = self.list_output_definitions()
+        for i, definition in enumerate(output_definitions):
+            if i == 0:
+                code += "output_list = []\n"
+            output_code = definition._to_code_helper("new_output", hide_defaults)
+            for line in output_code.split("\n"):
+                # Omit ID because we are generating for create_output_definition.
+                if line and not line.startswith("new_output.id"):
+                    code += f"{line}\n"
+            code += "output_list.append(template.create_output_definition(new_output))\n\n"
+
+        code += "# Define the basic and output-based stopping conditions.\n"
+        gsc = self.get_general_stopping_conditions()
+        code += f"template.update_general_stopping_conditions({gsc.max_iterations}, "
+        code += f"{gsc.max_physical_time}, {gsc.max_inner_iterations}, {gsc.stop_on_any})\n"
+
+        for i, sc in enumerate(self.list_stopping_conditions()):
+            if i == 0:
+                code += "\n# Output-based conditions require the ID of the associated output.\n"
+            # Find the old output to use the new ID created by create_output_definition.
+            for j, od in enumerate(output_definitions):
+                if sc.output_definition_id == od.id:
+                    code += f"template.create_or_update_stopping_condition(output_list[{j}].id, "
+                    code += f"{sc.threshold}, {sc.start_at_iteration}, {sc.averaging_iterations}, "
+                    code += f"{sc.iterations_to_consider})\n"
+                    break
+
+        return code
+
 
 def get_simulation_template(id: SimulationTemplateID) -> SimulationTemplate:
     """

luminarycloud/types/adfloat.py

@@ -36,6 +36,15 @@ class FirstOrderAdFloat(AdFloat):
     def adjoint(self) -> tuple[float, ...]:
         return self._adjoint
 
+    def __eq__(self, other: Any) -> bool:
+        if not isinstance(other, FirstOrderAdFloat):
+            return False
+        return (
+            float(self) == float(other)
+            and self.tangent == other.tangent
+            and self.adjoint == other.adjoint
+        )
+
     @staticmethod
     def _from_proto(proto: FirstOrderAdType) -> "FirstOrderAdFloat":
         return FirstOrderAdFloat(
@@ -53,7 +62,7 @@ class SecondOrderAdFloat(AdFloat):
     _adjoint: tuple[FirstOrderAdFloat, ...]
 
     def __new__(cls, value: FirstOrderAdFloat, *_: Any) -> "SecondOrderAdFloat":
-        return super().__new__(cls, value)
+        return super().__new__(cls, float(value))
 
     def __init__(
         self,
@@ -83,6 +92,15 @@ class SecondOrderAdFloat(AdFloat):
     def adjoint(self) -> tuple[FirstOrderAdFloat, ...]:
         return self._adjoint
 
+    def __eq__(self, other: Any) -> bool:
+        if not isinstance(other, SecondOrderAdFloat):
+            return False
+        return (
+            self._value == other._value
+            and self._tangent == other._tangent
+            and self._adjoint == other._adjoint
+        )
+
     @staticmethod
     def _from_proto(proto: SecondOrderAdType) -> "SecondOrderAdFloat":
         return SecondOrderAdFloat(

luminarycloud/types/ids.py

@@ -9,3 +9,5 @@ SolutionID = NewType("SolutionID", str)
 SimulationTemplateID = NewType("SimulationTemplateID", str)
 GeometryFeatureID = NewType("GeometryFeatureID", str)
 NamedVariableSetID = NewType("NamedVariableSetID", str)
+PhysicsAiArchitectureID = NewType("PhysicsAiArchitectureID", str)
+PhysicsAiModelID = NewType("PhysicsAiModelID", str)

luminarycloud/vis/__init__.py

@@ -37,6 +37,3 @@ from .display import (
 from .interactive_scene import (
     InteractiveScene as InteractiveScene,
 )
-
-from ..enum.vis_enums import *
-from ..types.vector3 import Vector3, Vector3Like

luminarycloud/vis/display.py

@@ -185,4 +185,5 @@ class ColorMap:
             res.height = self.appearance.height
             res.lower_left_anchor_location.x = self.appearance.lower_left_x
             res.lower_left_anchor_location.y = self.appearance.lower_left_y
+            res.text_size = self.appearance.text_size
         return res

luminarycloud/vis/interactive_scene.py

@@ -1,13 +1,16 @@
 from .display import DisplayAttributes
-from .filters import SurfaceStreamlines, Filter
+from .filters import SurfaceStreamlines, Filter, SurfaceLIC
 from .._client import get_default_client
 from ..enum.vis_enums import EntityType, SceneMode
-from typing import TYPE_CHECKING, cast
+from typing import TYPE_CHECKING, cast, Union
 
 from .._proto.api.v0.luminarycloud.vis import vis_pb2
 
 if TYPE_CHECKING:
-    from .visualization import Scene, LookAtCamera
+    from .visualization import Scene, LookAtCamera, ColorMap
+    from ..geometry import Geometry
+    from ..mesh import Mesh
+    from ..solution import Solution
 
 try:
     import luminarycloud_jupyter as lcj
@@ -32,7 +35,8 @@ class InteractiveScene:
         if not lcj:
             raise ImportError("InteractiveScene requires luminarycloud[jupyter] to be installed")
         self.widget = lcj.LCVisWidget(scene_mode=mode)
-        self.set_scene(scene)
+        self._scene = scene
+        self.set_scene(scene, False)
 
     def _ipython_display_(self) -> None:
         """
@@ -41,7 +45,10 @@ class InteractiveScene:
         """
         self.widget._ipython_display_()
 
-    def set_scene(self, scene: "Scene") -> None:
+    def set_scene(self, scene: "Scene", isComparator: bool) -> None:
+        # TODO(matt): we could make isCompartor and index so we could compare
+        # more than two scenes at once.
+
         # Import here to avoid circular import issue
         from .visualization import LookAtCamera
 
@@ -73,6 +80,12 @@ class InteractiveScene:
                 bad_ids = scene._validate_surfaces_and_tags(streamlines._surface_names)
                 if len(bad_ids) != 0:
                     raise ValueError(f"SurfaceStreamlines has invalid surfaces: {bad_ids}")
+            if isinstance(filter, SurfaceLIC):
+                # Validate surfaces names
+                lic = cast(SurfaceLIC, filter)
+                bad_ids = scene._validate_surfaces_and_tags(lic._surface_names)
+                if len(bad_ids) != 0:
+                    raise ValueError(f"SurfaceStreamlines has invalid surfaces: {bad_ids}")
 
             if isinstance(filter, Filter):
                 vis_filter: vis_pb2.Filter = filter._to_proto()
@@ -88,8 +101,10 @@ class InteractiveScene:
 
         # TODO: would be nice to print/report some download progress info
         # This can be done on the app frontend side now that the download
-        # is moved there.
-        self.widget.set_workspace_state(scene, resp)
+        # is moved there. Matt: this would be a lot of work. The current vis service
+        # call used in the backend doesn't use the streaming version. Further, there is
+        # a lot of extra code to manage the streaming callbacks.
+        self.widget.set_workspace_state(scene, resp, isComparator)
 
         # Sync display attributes and visibilities for surfaces
         self.set_display_attributes(_SOURCE_FILTER_ID, scene.global_display_attrs)
@@ -107,6 +122,10 @@ class InteractiveScene:
             set_camera = True
             self.set_camera(c)
 
+        # Set any color maps we have. TODO(matt): only a few attributes are connected atm.
+        for color_map in scene._color_maps:
+            self.set_color_map(color_map)
+
         # If we don't have an initial camera to use, reset the camera after loading
         # the workspace state
         if not set_camera:
@@ -125,12 +144,14 @@ class InteractiveScene:
         self.widget.reset_camera()
 
     def set_camera(self, camera: "LookAtCamera") -> None:
-        # Clear the camera pan, we should add this to the SDK later
-        self.widget.camera_pan = [0, 0]
+        self.widget.camera_pan = [camera.pan_x, camera.pan_y]
         self.widget.camera_position = [camera.position[0], camera.position[1], camera.position[2]]
         self.widget.camera_look_at = [camera.look_at[0], camera.look_at[1], camera.look_at[2]]
         self.widget.camera_up = [camera.up[0], camera.up[1], camera.up[2]]
 
+    def set_color_map(self, color_map: "ColorMap") -> None:
+        self.widget.set_color_map(color_map)
+
     def get_camera(self) -> "LookAtCamera":
         # Import here to avoid circular import issue
         from .visualization import LookAtCamera
@@ -139,7 +160,19 @@ class InteractiveScene:
         camera.position = self.widget.camera_position
         camera.look_at = self.widget.camera_look_at
         camera.up = self.widget.camera_up
+        # Immediately after creation, the widget's camera_pan is empty, so avoid going out of bounds
+        # and report 0 which is what it would be anyway
+        camera.pan_x = self.widget.camera_pan[0] if self.widget.camera_pan else 0
+        camera.pan_y = self.widget.camera_pan[1] if self.widget.camera_pan else 0
         return camera
 
     def set_triad_visible(self, visible: bool) -> None:
         self.widget.set_triad_visible(visible)
+
+    def compare(self, entity: Union["Geometry", "Mesh", "Solution"]) -> None:
+        # The entity can be a Geometry, Mesh, or Solution and is checked by the
+        # clone method. This can raise error if the scenes are incompatiable.
+        # This happens when tags or surface ids aren't shared or if we try to
+        # compare two different types of entities.
+        comparison_scene = self._scene.clone(entity)
+        self.set_scene(comparison_scene, True)

luminarycloud/vis/visualization.py

@@ -1,27 +1,29 @@
-from .._proto.api.v0.luminarycloud.vis import vis_pb2
+import dataclasses as dc
+import io
+import json
+import logging
+import copy
+from time import sleep, time
+from typing import Dict, List, Tuple, cast
+
 import luminarycloud._proto.api.v0.luminarycloud.common.common_pb2 as common_pb2
+import requests
+from luminarycloud.params.simulation.physics.fluid.boundary_conditions import Farfield
+from luminarycloud.types import Vector3, Vector3Like
+
 from .._client import get_default_client
-from ..solution import Solution
-from ..mesh import get_mesh_metadata, Mesh, get_mesh
-from ..geometry import Geometry, get_geometry, Tag
+from .._helpers._get_project_id import _get_project_id
+from .._proto.api.v0.luminarycloud.vis import vis_pb2
 from ..enum.vis_enums import *
-from ..enum.quantity_type import QuantityType
+from ..exceptions import NotFoundError
+from ..geometry import Geometry, get_geometry
+from ..mesh import Mesh, get_mesh, get_mesh_metadata
 from ..simulation import get_simulation
-from .display import DisplayAttributes, ColorMap, Field, ColorMapAppearance
-from .filters import Filter, PlaneClip, Slice, BoxClip, SurfaceStreamlines
-from luminarycloud.types import Vector3, Vector3Like
+from ..solution import Solution
 from ..types.vector3 import _to_vector3
-from .._helpers._get_project_id import _get_project_id
-from ..exceptions import NotFoundError
+from .display import ColorMap, ColorMapAppearance, DisplayAttributes, Field
+from .filters import BoxClip, Filter, PlaneClip, Slice, SurfaceStreamlines, SurfaceLIC
 from .interactive_scene import InteractiveScene
-import io
-import json
-from luminarycloud._proto.client import simulation_pb2 as clientpb
-from typing import List, Tuple, cast, Union, Dict
-import requests
-from time import time, sleep
-import logging
-import dataclasses as dc
 
 logger = logging.getLogger(__name__)
 
@@ -87,6 +89,20 @@ class LookAtCamera:
     """ The width of the output image in pixels. Default: 1024 """
     height: int = 1024
     """ The height of the output image in pixels. Default: 1024 """
+    pan_x: float = 0
+    """
+    Pan the camera in the x direction (right). This is a world space value defined in
+    the camera coordinate system. Pan is not typically directly set by the user,
+    but pan is useful for reproducing camera parameters from an interactive
+    scene where pan is used (i.e., control + middle mouse).
+    """
+    pan_y: float = 0
+    """
+    Pan the camera in the y direction (up). This is a world space value defined in
+    the camera coordinate system. Pan is not typically directly set by the user,
+    but pan is useful for reproducing camera parameters from an interactive
+    scene where pan is used (i.e., control + middle mouse).
+    """
 
 
 class _InternalToken:
@@ -414,8 +430,8 @@ class Scene:
             params = simulation.get_parameters()
             for physics in params.physics:
                 if physics.fluid:
-                    for bc in physics.fluid.boundary_conditions_fluid:
-                        if bc.physical_boundary == clientpb.PhysicalBoundary.FARFIELD:
+                    for bc in physics.fluid.boundary_conditions:
+                        if isinstance(bc, Farfield):
                             for bc_surface in bc.surfaces:
                                 self._far_field_boundary_ids.append(bc_surface)
 
@@ -547,6 +563,8 @@ class Scene:
                 out_camera.look_at.position.CopyFrom(_to_vector3(lookat.position)._to_proto())
                 out_camera.look_at.up.CopyFrom(_to_vector3(lookat.up)._to_proto())
                 out_camera.look_at.look_at.CopyFrom(_to_vector3(lookat.look_at)._to_proto())
+                out_camera.look_at.pan.x = lookat.pan_x
+                out_camera.look_at.pan.y = lookat.pan_y
             elif isinstance(camera, DirectionalCamera):
                 out_camera.direction = camera.direction.value
                 if camera.zoom_in <= 0 or camera.zoom_in > 1:
@@ -589,6 +607,12 @@ class Scene:
                 bad_ids = self._validate_surfaces_and_tags(streamlines._surface_names)
                 if len(bad_ids) != 0:
                     raise ValueError(f"SurfaceStreamlines has invalid surfaces: {bad_ids}")
+            if isinstance(filter, SurfaceLIC):
+                # Validate surfaces names
+                lic = cast(SurfaceLIC, filter)
+                bad_ids = self._validate_surfaces_and_tags(lic._surface_names)
+                if len(bad_ids) != 0:
+                    raise ValueError(f"SurfaceLIC has invalid surfaces: {bad_ids}")
 
             if isinstance(filter, Filter):
                 vis_filter: vis_pb2.Filter = filter._to_proto()
@@ -633,6 +657,7 @@ class Scene:
                     # processing them above
                     cmap.appearance = ColorMapAppearance()
                     auto_cmaps.append(cmap)
+
             if len(auto_cmaps) != 0:
                 # These are all default contructed, so they all have the same dimentions.
                 # All the coordinates are in normalized device space.
@@ -726,6 +751,62 @@ class Scene:
         self._interactive_scene = InteractiveScene(self, mode=scene_mode)
         return self._interactive_scene
 
+    def clone(self, entity: Geometry | Mesh | Solution) -> "Scene":
+        """
+        Clone this scene is based on a new entity. The new entity must be of
+        the same type as the previous one. For example, you can't swap a scene
+        based on a geometry with a solution. This is a deep copy operation.
+        Both entities must be compatible with one another, meaning they share tags
+        or surfaces ids used for setting surface visibilities and some filters like
+        surface streamlines and surface LIC.
+        """
+
+        entity_type: EntityType
+        if isinstance(entity, Solution):
+            entity_type = EntityType.SIMULATION
+        elif isinstance(entity, Mesh):
+            entity_type = EntityType.MESH
+        elif isinstance(entity, Geometry):
+            entity_type = EntityType.GEOMETRY
+        else:
+            raise TypeError(
+                f"Swap expected Solution, Mesh or Geometry, got {type(entity).__name__}"
+            )
+
+        if entity_type != self._entity_type:
+            raise TypeError(
+                f"Swap entity type mismatch expected {self._entity_type} got {entity_type}"
+            )
+
+        cloned = Scene(entity)
+        cloned.global_display_attrs = copy.deepcopy(self.global_display_attrs)
+        cloned.triad_visible = self.triad_visible
+        cloned.axes_grid_visible = self.axes_grid_visible
+        cloned.auto_color_map_annotations = self.auto_color_map_annotations
+        cloned.background_color = copy.deepcopy(self.background_color)
+        cloned.supersampling = self.supersampling
+        # TODO(matt): This is really meant for interactive case comparison. The label field in each
+        # camera could contain information specific to the previous scene. We could skip this and force
+        # the user to add more cameras.
+        cloned._cameras = copy.deepcopy(self._cameras)
+        # TODO(matt): for filters we could do some validation here to make sure that anything with
+        # surfaces (e.g., LIC and surface streamlines) have valid ids in them.
+        cloned._filters = copy.deepcopy(self._filters)
+
+        cloned._color_maps = copy.deepcopy(self._color_maps)
+        # TODO(matt): depending on what we want to do here, we could have a flag
+        # to ignore incompatible visibilitites. Filter surfaces are validated
+        # when the request is made. We could also skip these checks if they are
+        # based on the same geometry or mesh.
+        # Now loop through the surface visibilies and make sure they are compatible with the new
+        # scene based on the entity.
+        for id, visible in self._surface_visibilities.items():
+            if id in cloned._surface_ids or id in cloned._tag_ids:
+                cloned._surface_visibilities[id] = visible
+            else:
+                raise ValueError(f"Scene.clone: id {id} not present in tags or surface ids")
+        return cloned
+
 
 def get_render(project_id: str, extract_id: str) -> RenderOutput:
     """

luminarycloud/volume_selection.py

@@ -209,7 +209,7 @@ class VolumeSelection:
 
     def subtract(
         self,
-        tool_volumes: list[Volume],
+        tool_volumes: Iterable[Volume],
         *,
         propagate_tags: bool = False,
         feature_name: str = "Subtract",
@@ -221,7 +221,7 @@ class VolumeSelection:
 
         Parameters
         ----------
-        tool_volumes : list[Volume]
+        tool_volumes : Iterable[Volume]
             The volumes to subtract from the selected volumes.
         propagate_tags : bool
             Whether to propagate the tool volume tags to the surfaces created by the subtraction.
@@ -265,7 +265,7 @@ class VolumeSelection:
 
     def chop(
         self,
-        tool_volumes: list[Volume],
+        tool_volumes: Iterable[Volume],
         *,
         propagate_tags: bool = False,
         feature_name: str = "Chop",
@@ -278,7 +278,7 @@ class VolumeSelection:
 
         Parameters
         ----------
-        tool_volumes : list[Volume]
+        tool_volumes : Iterable[Volume]
             The volumes to chop the selected volumes with.
         propagate_tags : bool
             Whether to propagate the tool volume tags to the surfaces created by the chop.
@@ -460,7 +460,7 @@ class VolumeSelection:
         self,
         resolution_min: Optional[float] = None,
         resolution_max: Optional[float] = None,
-        tool: Optional[Iterator[VolumeSelection]] = None,
+        tool: Optional[Iterable[Volume]] = None,
         *,
         feature_name: str = "Shrinkwrap",
     ) -> None:

{luminarycloud-0.14.1.dist-info → luminarycloud-0.15.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: luminarycloud
-Version: 0.14.1
+Version: 0.15.1
 Summary: Luminary Cloud SDK
 Project-URL: Homepage, https://www.luminarycloud.com/
 Project-URL: Documentation, https://app.luminarycloud.com/docs/api/
@@ -45,6 +45,6 @@ and functionality may change significantly).
 import luminarycloud as lc
 project = lc.create_project("NACA 0012", "My first SDK project.")
 mesh = project.upload_mesh("./airfoil.lcmesh")
-sim_template = project.create_simulation_template("test template", "./simulation_template.json")
+sim_template = project.create_simulation_template("test template", params_json_path="./simulation_template.json")
 sim = project.create_simulation(mesh.id, "My simulation", sim_template.id)
 ```