luminarycloud 0.19.1__py3-none-any.whl → 0.21.0__py3-none-any.whl

luminarycloud/project.py

@@ -12,6 +12,7 @@ import concurrent
 
 import luminarycloud as lc
 from luminarycloud._helpers.named_variables import _named_variables_to_proto
+from luminarycloud._helpers.pagination import PaginationIterator
 from luminarycloud.params.simulation.adjoint_ import Adjoint
 
 from ._client import get_default_client
@@ -785,53 +786,13 @@ def list_projects() -> list[Project]:
     return list(iterate_projects())
 
 
-class ProjectIterator:
+class ProjectIterator(PaginationIterator[Project]):
     """Iterator class for projects that provides length hint."""
 
-    def __init__(self, page_size: int):
-        self._page_size: int = page_size
-        self._page_token: str = ""
-        self._total_count: Optional[int] = None
-        self._current_page: Optional[list[projectpb.Project]] = None
-        self._client = get_default_client()
-        self._iterated_count: int = 0
-
-    def __iter__(self) -> "ProjectIterator":
-        return self
-
-    def __next__(self) -> Project:
-        if self._current_page is None:
-            self._fetch_next_page()
-
-        # _current_page really can't be None here, but this assertion is needed to appease mypy
-        assert self._current_page is not None
-
-        if len(self._current_page) == 0:
-            if not self._page_token:
-                raise StopIteration
-            self._fetch_next_page()
-
-        self._iterated_count += 1
-
-        return Project(self._current_page.pop(0))
-
-    def _fetch_next_page(self) -> None:
-        req = projectpb.ListProjectsRequest(page_size=self._page_size, page_token=self._page_token)
+    def _fetch_page(self, page_size: int, page_token: str) -> tuple[list[Project], str, int]:
+        req = projectpb.ListProjectsRequest(page_size=page_size, page_token=page_token)
         res = self._client.ListProjects(req)
-
-        self._current_page = list(res.projects)
-        self._page_token = res.next_page_token
-
-        # Set length hint on first fetch if available
-        if self._total_count is None:
-            self._total_count = res.total_count or 0
-
-    def __length_hint__(self) -> int:
-        if self._total_count is None:
-            # Fetch first page to get total size if not already fetched
-            if self._current_page is None:
-                self._fetch_next_page()
-        return max(0, (self._total_count or 0) - self._iterated_count)
+        return [Project(p) for p in res.projects], res.next_page_token, res.total_count
 
 
 def iterate_projects(page_size: int = 50) -> ProjectIterator:

luminarycloud/simulation.py

@@ -124,8 +124,7 @@ class Simulation(ProtoWrapperBase):
             interval_seconds=interval_seconds,
             timeout_seconds=timeout_seconds,
         )
-        self._proto = get_simulation(self.id)._proto
-        return self.status
+        return self.refresh().status
 
     def refresh(self) -> "Simulation":
         """
@@ -196,6 +195,12 @@ class Simulation(ProtoWrapperBase):
         """
         Downloads surface outputs (e.g. lift, drag, ...) in csv format.
 
+        Unless `reference_values` is explicitly passed, the Simulation's reference values -- i.e.
+        the ones specified when the Simulation was created -- will be used for computing
+        non-dimensional output quantities. While the Luminary Cloud UI lets you update the reference
+        values on a Simulation result after it has run, those updates only affect the output
+        calculations seen in the UI, they have no effect on the ones retrieved by this method.
+
         Parameters
         ----------
         quantity_type : luminarycloud.enum.QuantityType
@@ -207,9 +212,9 @@ class Simulation(ProtoWrapperBase):
         Other Parameters
         ----------------
         reference_values : ReferenceValues, optional
-            Reference values used for computing forces, moments and
-            other non-dimensional output quantities. If not provided, default
-            reference values will be used.
+            Reference values used for computing forces, moments, and other non-dimensional output
+            quantities. If not provided, the simulation's reference values will be used, i.e., the
+            ones specified when the simulation was created.
         calculation_type : CalculationType, optional
             Whether the calculation should be done for all the surfaces together or each surface
             individually. Default is AGGREGATE.

luminarycloud/simulation_param.py

@@ -232,15 +232,6 @@ class SimulationParam(_SimulationParam):
                 f"physics {_stringify_identifier(v.physics_identifier)}. Overwriting..."
             ),
         )
-        _remove_from_list_with_warning(
-            _list=volume_physics_pairs,
-            _accessor=lambda v: get_id(v.physics_identifier),
-            _to_remove=get_id(physics.physics_identifier),
-            _warning_message=lambda v: (
-                f"Physics {_stringify_identifier(physics.physics_identifier)} has already been "
-                f"assigned to volume {_stringify_identifier(v.volume_identifier)}. Overwriting..."
-            ),
-        )
 
         if volume_identifier.id not in (get_id(v.volume_identifier) for v in self.volume_entity):
             self.volume_entity.append(VolumeEntity(volume_identifier=volume_identifier))

luminarycloud/vis/__init__.py

@@ -4,8 +4,14 @@ from .visualization import (
     EntityType as EntityType,
     list_renders as list_renders,
     list_quantities as list_quantities,
+    list_quantities as list_quantities,
+    list_cameras as list_cameras,
+    RangeResult as RangeResult,
+    range_query as range_query,
+    get_camera as get_camera,
     DirectionalCamera as DirectionalCamera,
     LookAtCamera as LookAtCamera,
+    CameraEntry as CameraEntry,
 )
 
 from .primitives import (
@@ -52,3 +58,14 @@ from .interactive_scene import (
 from .interactive_inference import (
     InteractiveInference as InteractiveInference,
 )
+
+# Unreleased/internal for testing now
+
+# from .report import (
+#    Report as Report,
+# )
+
+# from .interactive_report import (
+#    InteractiveReport as InteractiveReport,
+#    ReportEntry as ReportEntry,
+# )

luminarycloud/vis/data_extraction.py

@@ -22,6 +22,7 @@ from luminarycloud.params.simulation.physics.fluid.boundary_conditions import Fa
 from .._helpers._code_representation import CodeRepr
 from ..types import SimulationID
 from collections import defaultdict
+import copy
 
 
 logger = logging.getLogger(__name__)
@@ -227,14 +228,14 @@ class ExtractOutput:
         extract_id: str,
         project_id: str,
         name: str,
-        desciption: str,
+        description: str,
         status: ExtractStatusType,
     ) -> None:
         self._extract_id = extract_id
         self._project_id = project_id
         self.status = status
         self.name = name
-        self.description = desciption
+        self.description = description
 
     def __repr__(self) -> str:
         return f"ExtractOutput (Id: {self._extract_id} status: {self.status})"
@@ -563,7 +564,7 @@ class DataExtractor:
             extract_id=res.extract.extract_id,
             project_id=self._project_id,
             name=name,
-            desciption=description,
+            description=description,
             status=ExtractStatusType(res.extract.status),
         )
         return extract_output
@@ -657,6 +658,21 @@ class DataExtractor:
 
         return imports + code
 
+    def clone(self, solution: Solution) -> "DataExtractor":
+        """
+        Clone this extract based on a new solution. This is a deep copy
+        operation. Both solution must be compatible with one another, meaning
+        they share tags or surfaces ids for extractors such as
+        IntersectionCurve.
+        """
+        if not isinstance(solution, Solution):
+            raise TypeError("Expected a Solution object.")
+        cloned = DataExtractor(solution)
+        for extract in self._extracts:
+            copied_extract = copy.deepcopy(extract)
+            cloned.add_data_extract(copied_extract)
+        return cloned
+
 
 def list_data_extracts(solution: Solution) -> list[ExtractOutput]:
     """
@@ -700,7 +716,7 @@ def list_data_extracts(solution: Solution) -> list[ExtractOutput]:
             extract_id=extract.extract_id,
             project_id=extract.project_id,
             name=extract.name,
-            desciption=extract.description,
+            description=extract.description,
             status=ExtractStatusType(extract.status),
         )
         # This need to be fixed on the backend, but manually refreshing works for now.

luminarycloud/vis/interactive_report.py

@@ -0,0 +1,110 @@
+import io
+from .visualization import RenderOutput
+from .report import ReportEntry
+
+try:
+    import luminarycloud_jupyter as lcj
+except ImportError:
+    lcj = None
+
+
+class InteractiveReport:
+    """
+    Interactive report widget with lazy loading for large datasets.
+
+    How it works:
+    1. on initialization:
+       - sends metadata for all rows (for filtering/selection)
+       - downloads the first row (to determine grid dimensions)
+       - other rows remain unloaded
+
+    2. on user request:
+       - _load_row_data() is called with row index
+       - downloads and sends images/plots for that specific row
+       - python sets row_states to 'loading' -> 'loaded' (or 'error')
+
+    This allows working with 1000+ row datasets without waiting for all data upfront.
+    """
+
+    # TODO Will/Matt: this list of report entries could be how we store stuff in the DB
+    # for interactive reports, to reference the post proc. extracts. A report is essentially
+    # a bunch of extracts + metadata.
+    def __init__(self, entries: list[ReportEntry]) -> None:
+        if not lcj:
+            raise ImportError("InteractiveScene requires luminarycloud[jupyter] to be installed")
+
+        self.entries = entries
+        if len(self.entries) == 0:
+            raise ValueError("Invalid number of entries, must be > 0")
+
+        # Determine grid dimensions by downloading first entry
+        # to understand the structure (number of columns)
+        first_entry = self.entries[0]
+        first_entry.download_extracts()
+
+        # Calculate actual number of columns by counting how many cells
+        # each extract produces (RenderOutput can produce multiple images)
+        ncols = 0
+        for extract in first_entry._extracts:
+            if isinstance(extract, RenderOutput):
+                image_and_label = extract.download_images()
+                ncols += len(image_and_label)
+            else:
+                ncols += 1  # Plot data extracts produce one cell
+
+        nrows = len(self.entries)
+
+        # Create widget with metadata but without data
+        self.widget = lcj.EnsembleWidget([re._metadata for re in self.entries], nrows, ncols)
+
+        # Set the callback for lazy loading row data
+        self.widget.set_row_data_callback(self._load_row_data)
+
+    def _load_row_data(self, row: int) -> None:
+        """
+        Load and send data for a specific row to the widget.
+        This is called on-demand when the user requests data for a row.
+        """
+        re = self.entries[row]
+
+        # Download extracts if not already downloaded
+        if len(re._extracts) == 0:
+            re.download_extracts()
+
+        # Process each extract and send to widget
+        # Track the actual column index as we may have multiple cells per extract
+        col = 0
+        for extract in re._extracts:
+            if isinstance(extract, RenderOutput):
+                image_and_label = extract.download_images()
+                # Each image gets its own column
+                for il in image_and_label:
+                    self.widget.set_cell_data(row, col, il[0].getvalue(), "jpg")
+                    col += 1
+            else:
+                plot_data = extract.download_data()
+                data = plot_data[0][0]
+                all_axis_labels = data[0]
+
+                axis_data = []
+                for axis_idx in range(len(all_axis_labels)):
+                    axis_values = [row[axis_idx] for row in data[1:]]
+                    axis_data.append(axis_values)
+
+                self.widget.set_cell_scatter_plot(
+                    row,
+                    col,
+                    f"Row #{row} - Multi-axis Plot",
+                    all_axis_labels,
+                    axis_data,
+                    plot_name=f"plot-{row}",
+                    plot_mode="markers",
+                )
+                col += 1
+
+    def _ipython_display_(self) -> None:
+        """
+        When the InteractiveReport is shown in Jupyter we show the underlying widget
+        to run the widget's frontend code
+        """
+        self.widget._ipython_display_()

luminarycloud/vis/interactive_scene.py

@@ -18,7 +18,16 @@ try:
     import luminarycloud_jupyter as lcj
 
     if TYPE_CHECKING:
-        from luminarycloud_jupyter import InteractiveLCVisWidget, LCVisPlaneWidget
+        from luminarycloud_jupyter import (
+            InteractiveLCVisWidget,
+            LCVisPlaneWidget,
+            LCVisLineWidget,
+            LCVisBoxWidget,
+            LCVisCylinderWidget,
+            LCVisHalfSphereWidget,
+            LCVisSphereWidget,
+            LCVisFinitePlaneWidget,
+        )
 except ImportError:
     lcj = None
 
@@ -134,7 +143,7 @@ class InteractiveScene:
     def set_surface_visibility(self, surface_id: str, visible: bool) -> None:
         self.widget.set_surface_visibility(surface_id, visible)
 
-    def set_surface_color(self, surface_id: str, color: list[float]) -> None:
+    def set_surface_color(self, surface_id: str, color: "list[float]") -> None:
         self.widget.set_surface_color(surface_id, color)
 
     def set_display_attributes(self, object_id: str, attrs: DisplayAttributes) -> None:
@@ -199,6 +208,24 @@ class InteractiveScene:
     def add_plane_widget(self) -> "LCVisPlaneWidget":
         return self.widget.add_plane_widget()
 
+    def add_line_widget(self) -> "LCVisLineWidget":
+        return self.widget.add_line_widget()
+
+    def add_box_widget(self) -> "LCVisBoxWidget":
+        return self.widget.add_box_widget()
+
+    def add_cylinder_widget(self) -> "LCVisCylinderWidget":
+        return self.widget.add_cylinder_widget()
+
+    def add_half_sphere_widget(self) -> "LCVisHalfSphereWidget":
+        return self.widget.add_half_sphere_widget()
+
+    def add_finite_plane_widget(self) -> "LCVisFinitePlaneWidget":
+        return self.widget.add_finite_plane_widget()
+
+    def add_sphere_widget(self) -> "LCVisSphereWidget":
+        return self.widget.add_sphere_widget()
+
     def delete_widget(self, widget: "InteractiveLCVisWidget") -> None:
         self.widget.delete_widget(widget)
 

luminarycloud/vis/report.py

@@ -0,0 +1,252 @@
+import json
+import os
+from typing import TYPE_CHECKING
+
+from .visualization import Scene, RenderOutput, range_query
+from .data_extraction import DataExtractor, ExtractOutput
+from ..enum import RenderStatusType, ExtractStatusType, FieldAssociation
+from ..solution import Solution
+from .vis_util import _InternalToken, _get_status
+from time import sleep
+from .._proto.api.v0.luminarycloud.vis import vis_pb2
+from .._client import get_default_client
+from .._helpers._get_project_id import _get_project_id
+import luminarycloud.enum.quantity_type as quantity_type
+
+if TYPE_CHECKING:
+    from .interactive_report import InteractiveReport
+
+
+# TODO Will/Matt: this could be something like what we store in the DB
+# A report can contain a list of report entries that reference post proc.
+# extracts + styling info for how they should be displayed
+class ReportEntry:
+    """
+    A single entry in a report, containing references to extracts and metadata.
+    Each extract can have multiple pieces of data (e.g. multiple images for a
+    RenderOutput, or multiple curves for an ExtractOutput).  Metadata is a
+    dictionary of key/value pairs that can be used to store additional
+    information about the report entry. Typically, the metadata would include
+    things like simulation ID, lift/drag values, and scalar ranges for each
+    solution. The metadata is used to filter and sort data in the ensemble
+    widget.
+    """
+
+    def __init__(
+        self, project_id: str, extract_ids: list[str] = [], metadata: dict[str, str | float] = {}
+    ) -> None:
+        self._project_id = project_id
+        self._extract_ids = extract_ids
+        self._extracts: list[ExtractOutput | RenderOutput] = []
+        self._metadata = metadata
+        self._statuses = statuses = [RenderStatusType.INVALID] * len(self._extract_ids)
+
+    def to_dict(self) -> dict:
+        return {
+            "project_id": self._project_id,
+            "extract_ids": self._extract_ids,
+            "metadata": self._metadata,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "ReportEntry":
+        return cls(
+            project_id=data["project_id"],
+            extract_ids=data.get("extract_ids", []),
+            metadata=data.get("metadata", {}),
+        )
+
+    def refresh_statuses(self) -> None:
+        for i, eid in enumerate(self._extract_ids):
+            self._statuses[i] = _get_status(self._project_id, eid)
+
+    def is_complete(self) -> bool:
+        self.refresh_statuses()
+        return all(
+            (status == RenderStatusType.COMPLETED or status == RenderStatusType.FAILED)
+            for status in self._statuses
+        )
+
+    # Download all extracts for this report entry
+    def download_extracts(self) -> None:
+        self._extracts = []
+        for eid in self._extract_ids:
+            status = _get_status(self._project_id, eid)
+            if status != ExtractStatusType.COMPLETED:
+                raise Exception(f"Extract {eid} is not complete")
+            req = vis_pb2.DownloadExtractRequest()
+            req.extract_id = eid
+            req.project_id = self._project_id
+            # TODO: This is a bit awkward in that we download the extract to figure out what type
+            # it is, but this is just a temporary thing, later we'll have a report DB table that
+            # stores the extracts for a report and their types, etc.
+            res: vis_pb2.DownloadExtractResponse = get_default_client().DownloadExtract(req)
+            extract = (
+                ExtractOutput(_InternalToken())
+                if res.HasField("line_data")
+                else RenderOutput(_InternalToken())
+            )
+            extract._set_data(eid, self._project_id, eid, eid, status)
+            self._extracts.append(extract)
+
+
+class Report:
+    """
+    A report containing multiple report entries. There is support for
+    serialization and deserialization to/from JSON since generating the extracts
+    and metadata can be expensive.
+    """
+
+    def __init__(self, entries: list[ReportEntry]):
+        self._entries = entries
+
+    def to_dict(self) -> dict:
+        return {"entries": [entry.to_dict() for entry in self._entries]}
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "Report":
+        entries = [ReportEntry.from_dict(e) for e in data.get("entries", [])]
+        return cls(entries)
+
+    def _check_status(self) -> bool:
+        """Check the status of all ReportEntries and their extracts, grouped by entry."""
+        still_pending = False
+        print("\n" + "=" * 60)
+        print("STATUS CHECK".center(60))
+        print("=" * 60)
+
+        if not self._entries:
+            raise RuntimeError("No report entries to check status.")
+
+        print(f"{'Entry':<8} | {'Extract ID':<20} | {'Status':<15}")
+        print("-" * 60)
+        for idx, entry in enumerate(self._entries):
+            entry.refresh_statuses()
+            for eid, status in zip(entry._extract_ids, entry._statuses):
+                if status != RenderStatusType.COMPLETED and status != RenderStatusType.FAILED:
+                    still_pending = True
+                print(f"{idx:<8} | {eid:<20} | {status.name:<15}")
+        print("=" * 60)
+        return still_pending
+
+    def wait_for_completion(self):
+        """Wait for all report entries' extracts to complete."""
+        if not self._entries:
+            raise RuntimeError("No report entries to wait for.")
+        while self._check_status():
+            sleep(5)
+        print("All report entries' extracts have completed.")
+
+    def interact(self) -> "InteractiveReport":
+        from .interactive_report import InteractiveReport
+
+        if not self._check_status:
+            raise ValueError("Error: report entries are still pending")
+        return InteractiveReport(self._entries)
+
+
+class ReportGenerator:
+    """
+    A helper for generating reports from multiple solutions, scenes, data extractors and
+    per solution metatdata.
+
+    Attributes:
+    -----------
+    calculate_ranges: bool
+        Whether to auto-calculate solution quantity ranges and add them to the
+        metadata. Default is False.
+    """
+
+    def __init__(self, solutions: list[Solution]):
+        self._scenes: list[Scene] = []
+        self._data_extractors: list[DataExtractor] = []
+        self._solution: list[Solution] = solutions
+        # When we fire off requests we use these objects to track the progress.
+        self._extract_outputs: list[ExtractOutput] = []
+        self._render_outputs: list[RenderOutput] = []
+        # Controls if we should calculate solution quanity ranges
+        self.calculate_ranges: bool = False
+        # Key is solution ID, value is the metadata dict
+        self._metadata: dict[str, dict[str, str | float]] = {}
+        for solution in solutions:
+            if not isinstance(solution, Solution):
+                raise TypeError("Expected a list of Solution objects.")
+
+    def add_scene(self, scene: Scene):
+        if not isinstance(scene, Scene):
+            raise TypeError("Expected a Scene object.")
+        self._scenes.append(scene)
+
+    # TODO(Matt): we could just make this a single data extract then control how they
+    # are added to each solution.
+    def add_data_extractor(self, data_extractor: DataExtractor):
+        if not isinstance(data_extractor, DataExtractor):
+            raise TypeError("Expected a DataExtractor object.")
+        self._data_extractors.append(data_extractor)
+
+    def add_metadata(self, solution_id: str, metadata: dict[str, str | float]):
+        if solution_id not in self._metadata:
+            self._metadata[solution_id] = {}
+        self._metadata[solution_id].update(metadata)
+
+    def create_report(self) -> Report:
+        entries = []
+        for solution in self._solution:
+            extract_ids = []
+            project_id = _get_project_id(solution)
+            if not project_id:
+                raise ValueError("Solution does not have a project_id.")
+            metadata = self._metadata.get(solution.id, {})
+            metadata["solution id"] = solution.id
+            if self.calculate_ranges:
+                print(f"Calculating solution quantity ranges {solution.id}")
+                ranges = range_query(solution, FieldAssociation.CELLS)
+                for range_res in ranges:
+                    if not quantity_type._is_vector(range_res.quantity):
+                        metadata[f"{range_res.field_name} min"] = range_res.ranges[0].min_value
+                        metadata[f"{range_res.field_name} max"] = range_res.ranges[0].max_value
+                    else:
+                        for r in range(len(range_res.ranges)):
+                            if r == 0:
+                                comp = "x"
+                            elif r == 1:
+                                comp = "y"
+                            elif r == 2:
+                                comp = "z"
+                            elif r == 3:
+                                comp = "mag"
+                            comp_range = range_res.ranges[r]
+                            metadata[f"{range_res.field_name} min ({comp})"] = comp_range.min_value
+                            metadata[f"{range_res.field_name} max ({comp})"] = comp_range.max_value
+            for extractor in self._data_extractors:
+                sol_extractor = extractor.clone(solution)
+                extract = sol_extractor.create_extracts(
+                    name="Report Extract", description="Generated Report Extract"
+                )
+                extract_ids.append(extract._extract_id)
+
+            for scene in self._scenes:
+                sol_scene = scene.clone(solution)
+                render_extract = sol_scene.render_images(
+                    name="Report Scene", description="Generated Report Scene"
+                )
+                extract_ids.append(render_extract._extract_id)
+
+            entries.append(ReportEntry(project_id, extract_ids, metadata))
+        return Report(entries)
+
+
+def save_report_to_json(report: Report, name: str, directory: str = ".") -> str:
+    """Save a Report object to a JSON file named {name}_lcreport.json in the specified directory."""
+    filename = f"{name}_lcreport.json"
+    filepath = os.path.join(directory, filename)
+    with open(filepath, "w") as f:
+        json.dump(report.to_dict(), f, indent=2)
+    return filepath
+
+
+def load_report_from_json(filepath: str) -> "Report":
+    """Load a Report object from a JSON file at the given file path."""
+    with open(filepath, "r") as f:
+        data = json.load(f)
+    return Report.from_dict(data)