luminarycloud 0.15.5__py3-none-any.whl → 0.16.1__py3-none-any.whl

luminarycloud/vis/visualization.py

@@ -13,6 +13,7 @@ from luminarycloud.types import Vector3, Vector3Like
 
 from .._client import get_default_client
 from .._helpers._get_project_id import _get_project_id
+from .._helpers._code_representation import CodeRepr
 from .._proto.quantity import quantity_pb2 as quantitypb
 from .._proto.api.v0.luminarycloud.vis import vis_pb2
 from ..types import SimulationID, MeshID
@@ -23,9 +24,6 @@ from luminarycloud.enum import (
     EntityType,
     SceneMode,
     VisQuantity,
-    FieldComponent,
-    Representation,
-    ColorMapPreset,
 )
 from ..exceptions import NotFoundError
 from ..geometry import Geometry, get_geometry
@@ -46,6 +44,7 @@ from .filters import (
     ScaledVectorGlyphs,
     FixedSizeVectorGlyphs,
     Isosurface,
+    _filter_to_obj_name,
 )
 from .interactive_scene import InteractiveScene
 from .vis_util import _InternalToken, _download_file, _get_status
@@ -58,7 +57,7 @@ def _is_valid_color(obj: common_pb2.Vector3) -> bool:
 
 
 @dc.dataclass
-class DirectionalCamera:
+class DirectionalCamera(CodeRepr):
     """
     Class defining a directional camera for visualization. Directional
     camera are oriented around the visible objects in the scene and will
@@ -102,7 +101,7 @@ class DirectionalCamera:
 
 
 @dc.dataclass
-class LookAtCamera:
+class LookAtCamera(CodeRepr):
     """
     Class defining a look at camera for visualization.  Unlike the directional
     camera which is placed relative to what is visisble, the the look at camera
@@ -335,7 +334,7 @@ class RenderOutput:
         self._deleted = True
 
 
-class Scene:
+class Scene(CodeRepr):
     """
     The scene class is the base for any visualization. The scene is constructed
     with what "entity" you want to visualize: a solution, a mesh, or
@@ -427,20 +426,18 @@ class Scene:
             simulation = get_simulation(self._solution.simulation_id)
             mesh_meta = get_mesh_metadata(simulation.mesh_id)
             mesh = get_mesh(simulation.mesh_id)
-            try:
-                geom = mesh.geometry_version().geometry()
-            except NotFoundError:
+            geo_ver = mesh.geometry_version()
+            if geo_ver is None:
                 self._has_tags = False
-            except Exception as e:
-                raise ValueError("An unknown error occurred retrieving tags")
+            else:
+                geom = geo_ver.geometry()
         elif self._entity_type == EntityType.MESH:
             mesh_meta = get_mesh_metadata(self._mesh.id)
-            try:
-                geom = get_geometry(self._mesh.geometry_version().geometry_id)
-            except NotFoundError:
+            geo_ver = self._mesh.geometry_version()
+            if geo_ver is None:
                 self._has_tags = False
-            except Exception as e:
-                raise ValueError("An unknown error occurred retrieving tags")
+            else:
+                geom = geo_ver.geometry()
         else:
             geom = self._geometry
 
@@ -510,7 +507,7 @@ class Scene:
         display attributes using tags, then surface ids.
         """
         if not surface_id in self._surface_ids:
-            raise ValueError(f"Id {id} not a boundary id")
+            raise ValueError(f"Id {surface_id} not a boundary id")
         self._surface_visibilities[surface_id] = visible
 
         if self._interactive_scene:
@@ -858,6 +855,158 @@ class Scene:
                 raise ValueError(f"Scene.clone: id {id} not present in tags or surface ids")
         return cloned
 
+    def to_code(self, obj_name: str, hide_defaults: bool = True) -> str:
+        """
+        This function will produce a code string that reproduces the scene
+        in its current state.
+
+        Parameters
+        ----------
+        obj_name: str
+            the object name of the scene.
+        hide_defaults: bool, optional
+            If True, the code will make a best effort not include default values for attributes.
+        """
+        imports = "import luminarycloud as lc\n"
+        imports += "import luminarycloud.vis as vis\n"
+        imports += "from luminarycloud.types import Vector3\n"
+        imports += "from luminarycloud.enum import (\n"
+        imports += "    ColorMapPreset,\n"
+        imports += "    FieldComponent,\n"
+        imports += "    CameraProjection,\n"
+        imports += "    CameraDirection,\n"
+        imports += "    RenderStatusType,\n"
+        imports += "    Representation,\n"
+        imports += "    VisQuantity,\n"
+        imports += "    StreamlineDirection,\n"
+        imports += "    SurfaceStreamlineMode,\n"
+        imports += ")\n"
+
+        # This isn't technically needed, but I think its useful.
+        code = f"# project id = '{self._project_id}'\n"
+        code += "\n# Find the entity to build the scene from\n"
+        if self._entity_type == EntityType.SIMULATION:
+            imports += "from luminarycloud.simulation import get_simulation\n"
+
+            code += f"simulation = get_simulation('{self._solution.simulation_id}')\n"
+            code += "for sol in simulation.list_solutions():\n"
+            code += f"    if sol.id == '{self._solution.id}':\n"
+            code += f"        solution = sol\n"
+            code += f"        break\n"
+            code += "scene = vis.Scene(solution)\n"
+        elif self._entity_type == EntityType.MESH:
+            imports += "from luminarycloud.mesh import get_mesh\n"
+
+            code += f"mesh = get_mesh('{self._mesh.id}')\n"
+            code += "scene = vis.Scene(mesh)\n"
+        else:
+            imports += "from luminarycloud.geometry import get_geometry\n"
+            code += f"geom = get_geometry('{self._geometry.id}')\n"
+            code += "scene = vis.Scene(geom)\n"
+
+        code += "\n"
+
+        code += "# Set the scene attributes\n"
+        code += self.global_display_attrs._to_code_helper(
+            obj_name=f"{obj_name}.global_display_attrs", hide_defaults=hide_defaults
+        )
+        code += "\n"
+
+        code += f"{obj_name}.triad_visible = {self.triad_visible}\n"
+        code += f"{obj_name}.axes_grid_visible = {self.axes_grid_visible}\n"
+        code += f"{obj_name}.background_color = {self.background_color}\n"
+        code += f"{obj_name}.auto_color_map_annotations = {self.auto_color_map_annotations}\n"
+        code += f"{obj_name}.supersampling = {self.supersampling}\n"
+
+        code += "\n"
+        code += "# Set surface visibilities\n"
+        for surface_id, visible in self._surface_visibilities.items():
+            if surface_id in self._surface_ids:
+                code += f"{obj_name}.surface_visibility('{surface_id}', {visible})\n"
+            elif surface_id in self._tag_ids:
+                code += f"{obj_name}.tag_visibility('{surface_id}', {visible})\n"
+            else:
+                raise ValueError(f"Surface id {surface_id} not found in surface or tag ids")
+        code += "\n"
+
+        cam_count = 0
+
+        code += "# Add cameras\n"
+        for camera in self._cameras:
+            camera_name = f"camera{cam_count}"
+            code += camera._to_code_helper(camera_name, hide_defaults=hide_defaults)
+            code += f"scene.add_camera({camera_name})\n"
+            cam_count += 1
+            code += "\n"
+
+        # We can have many of the same type of filter so we need to track how
+        # many times we have seen a filter type to create the object name.
+        name_map: Dict[str, int] = {}
+        # Filters can be connected so we need to track what the ids are so we
+        # can connected them.
+        ids_to_obj_name: Dict[str, str] = {}
+        has_connections = False
+        for filter in self._filters:
+            # Name objects numerically: slice0, slice1, etc.
+            if filter._parent_id != "":
+                has_connections = True
+            name = _filter_to_obj_name(filter)
+            if name in name_map:
+                name_map[obj_name] += 1
+            else:
+                name_map[obj_name] = 0
+            obj_name = f"{name}{name_map[obj_name]}"
+            ids_to_obj_name[filter.id] = obj_name
+            code += filter._to_code_helper(obj_name, hide_defaults=hide_defaults)
+            code += f"scene.add_filter({obj_name})\n"
+            code += "\n"
+
+        if has_connections:
+            code += "# Connect filters\n"
+            for filter in self._filters:
+                if filter._parent_id != "":
+                    code += f"{ids_to_obj_name[filter.id]}.set_parent({ids_to_obj_name[filter._parent_id]})\n"
+        code += "\n"
+        if len(self._color_maps) != 0:
+            cmap_count = 0
+            code += "# Add color maps\n"
+            for color_map in self._color_maps:
+                cmap_name = f"color_map{cmap_count}"
+                code += color_map._to_code_helper(cmap_name, hide_defaults=hide_defaults)
+                code += f"scene.add_color_map({cmap_name})\n"
+                cmap_count += 1
+                code += "\n"
+
+        imports += "\n"
+        # The code gen is very verbose, so we can do some string replacements
+        # since we are importing the luminarycloud.vis package.
+        cleanup_list: List[str] = [
+            "luminarycloud.vis.display",
+            "luminarycloud.vis.visualization",
+            "luminarycloud.vis.filters",
+        ]
+        for cleanup in cleanup_list:
+            code = code.replace(cleanup, "vis")
+        # Many classes initialize the attributes, so we don't need to explicitly
+        # creat new objects for them. Additionally, its easier to do this here than
+        # in the individual classes.
+        remove_list: List[str] = [
+            "vis.DataRange()",
+            "luminarycloud.vis.primitives.Plane()",
+            "luminarycloud.vis.primitives.Box()",
+            "vis.DisplayAttributes()",
+        ]
+        # Remove entire lines containing any remove_list item
+        code_lines = code.splitlines()
+        filtered_lines = [
+            line
+            for line in code_lines
+            if not any(remove_item in line for remove_item in remove_list)
+        ]
+        code = "\n".join(filtered_lines)
+
+        return imports + code
+
 
 def list_quantities(solution: Solution) -> List[VisQuantity]:
     """
@@ -954,7 +1103,7 @@ def list_renders(entity: Geometry | Mesh | Solution) -> List[RenderOutput]:
     return results
 
 
-def _reconstruct(extract_id: str, project_id: str) -> Scene:
+def _spec_to_scene(spec: vis_pb2.ExtractSpec) -> Scene:
     """
     This function reconstructs a scene from an extract id and project id. The
     resulting scene should produce an identical image to the one that was
@@ -965,28 +1114,24 @@ def _reconstruct(extract_id: str, project_id: str) -> Scene:
     When we get the extract back, we don't know if it was auto-generated or not.
     Thus, the resulting color maps will be much more verbose than the original.
     """
-    req = vis_pb2.GetExtractRequest()
-    req.extract_id = extract_id
-    req.project_id = project_id
-    res: vis_pb2.GetExtractSpecResponse = get_default_client().GetExtractSpec(req)
-    if res.spec.data_only:
+    if spec.data_only:
         raise ValueError("Error: cannot reconstruct a scene from a data only extract")
 
-    entity = res.spec.entity_type.WhichOneof("entity")
+    entity = spec.entity_type.WhichOneof("entity")
     if entity == "geometry":
-        geom = get_geometry(res.spec.entity_type.geometry.id)
+        geom = get_geometry(spec.entity_type.geometry.id)
         scene = Scene(geom)
     elif entity == "mesh":
-        mesh_id = MeshID(res.spec.entity_type.mesh.id)
+        mesh_id = MeshID(spec.entity_type.mesh.id)
         mesh = get_mesh(mesh_id)
         scene = Scene(mesh)
     elif entity == "simulation":
-        sim_id = SimulationID(res.spec.entity_type.simulation.id)
+        sim_id = SimulationID(spec.entity_type.simulation.id)
         sim = get_simulation(sim_id)
         sols = sim.list_solutions()
         found = False
         for sol in sols:
-            if sol.id == res.spec.entity_type.simulation.solution_id:
+            if sol.id == spec.entity_type.simulation.solution_id:
                 scene = Scene(sol)
                 found = True
                 break
@@ -1003,7 +1148,7 @@ def _reconstruct(extract_id: str, project_id: str) -> Scene:
     # keep track of filter ids so we connect them later and  keep track of
     # surface and tag visibilties.
     filter_ids: List[str] = []
-    for filter in res.spec.filters:
+    for filter in spec.filters:
         filter_ids.append(filter.id)
         typ = filter.WhichOneof("value")
         pfilter: Filter | None = None
@@ -1042,13 +1187,13 @@ def _reconstruct(extract_id: str, project_id: str) -> Scene:
         pfilter._from_proto(filter)
         # Set the display attributes
         pattrs = DisplayAttributes()
-        attrs = res.spec.display_attributes[pfilter.id]
+        attrs = spec.display_attributes[pfilter.id]
         assert attrs is not None, "Internal error: display attributes not set"
         pfilter.display_attrs._from_proto(attrs)
         scene.add_filter(pfilter)
 
     # Connect filters to their parents.
-    for parent_id, children in res.spec.filter_connections.items():
+    for parent_id, children in spec.filter_connections.items():
         parent_filter = next((f for f in scene._filters if f.id == parent_id), None)
         if parent_filter is not None:
             for child_id in children.children_id:
@@ -1063,17 +1208,17 @@ def _reconstruct(extract_id: str, project_id: str) -> Scene:
             raise ValueError(f"Error: parent filter {parent_id} not found in the scene filters")
 
     # scene attributes
-    scene.supersampling = res.spec.supersampling_ratio
-    scene.triad_visible = res.spec.triad_properties.visible
-    scene.axes_grid_visible = res.spec.axes_grid_properties.visible
+    scene.supersampling = spec.supersampling_ratio
+    scene.triad_visible = spec.triad_properties.visible
+    scene.axes_grid_visible = spec.axes_grid_properties.visible
     scene.background_color = Vector3(
-        x=res.spec.background_properties.color.r,
-        y=res.spec.background_properties.color.g,
-        z=res.spec.background_properties.color.b,
+        x=spec.background_properties.color.r,
+        y=spec.background_properties.color.g,
+        z=spec.background_properties.color.b,
     )
-    scene.global_display_attrs._from_proto(res.spec.global_display_attributes)
+    scene.global_display_attrs._from_proto(spec.global_display_attributes)
 
-    for id, attrs in res.spec.display_attributes.items():
+    for id, attrs in spec.display_attributes.items():
         if id in filter_ids:
             continue  # Skip filters, we already processed them.
         if id in scene._surface_ids or id in scene._tag_ids:
@@ -1081,7 +1226,7 @@ def _reconstruct(extract_id: str, project_id: str) -> Scene:
             # attributes are set in the global display attributes.
             scene._surface_visibilities[id] = attrs.visible
 
-    for static_ani in res.spec.animation_properties.statics.items:
+    for static_ani in spec.animation_properties.statics.items:
         cam_typ = static_ani.camera.WhichOneof("specification")
         if cam_typ == "direction":
             cam = DirectionalCamera()
@@ -1093,8 +1238,20 @@ def _reconstruct(extract_id: str, project_id: str) -> Scene:
             scene.add_camera(l_cam)
 
     # Add color maps
-    for color_map in res.spec.color_maps:
+    for color_map in spec.color_maps:
         cmap = ColorMap()
         cmap._from_proto(color_map)
         scene.add_color_map(cmap)
     return scene
+
+
+def _reconstruct(extract_id: str, project_id: str) -> Scene:
+    """
+    Helper function to reconstruct a scene from an extract id and project id.
+    This helper exists to do sdk integration testing.
+    """
+    req = vis_pb2.GetExtractRequest()
+    req.extract_id = extract_id
+    req.project_id = project_id
+    res: vis_pb2.GetExtractSpecResponse = get_default_client().GetExtractSpec(req)
+    return _spec_to_scene(res.spec)

luminarycloud/volume_selection.py

@@ -157,8 +157,8 @@ class VolumeSelection:
         cad_url = finish_res.url
 
         feature = gpb.Feature(feature_name=feature_name)
-        getattr(feature, "import").CopyFrom(
-            gpb.Import(
+        feature.import_geometry.CopyFrom(
+            gpb.ImportGeometry(
                 geometry_url=cad_url,
                 scaling=scaling,
                 force_discrete=force_discrete,

{luminarycloud-0.15.5.dist-info → luminarycloud-0.16.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: luminarycloud
-Version: 0.15.5
+Version: 0.16.1
 Summary: Luminary Cloud SDK
 Project-URL: Homepage, https://www.luminarycloud.com/
 Project-URL: Documentation, https://app.luminarycloud.com/docs/api/
@@ -13,13 +13,13 @@ Requires-Dist: grpcio-status~=1.51
 Requires-Dist: grpcio-tools~=1.51
 Requires-Dist: grpcio~=1.51
 Requires-Dist: importlib-metadata~=6.0.0
-Requires-Dist: opentelemetry-api~=1.25.0
-Requires-Dist: opentelemetry-exporter-otlp-proto-common~=1.25.0
-Requires-Dist: opentelemetry-exporter-otlp-proto-http~=1.25.0
+Requires-Dist: opentelemetry-api~=1.25
+Requires-Dist: opentelemetry-exporter-otlp-proto-common~=1.25
+Requires-Dist: opentelemetry-exporter-otlp-proto-http~=1.25
 Requires-Dist: opentelemetry-instrumentation-grpc~=0.46b0
 Requires-Dist: opentelemetry-instrumentation~=0.46b0
-Requires-Dist: opentelemetry-proto~=1.25.0
-Requires-Dist: opentelemetry-sdk~=1.25.0
+Requires-Dist: opentelemetry-proto~=1.25
+Requires-Dist: opentelemetry-sdk~=1.25
 Requires-Dist: opentelemetry-semantic-conventions~=0.46b0
 Requires-Dist: protobuf~=4.21
 Requires-Dist: pyjwt~=2.6