luminarycloud 0.20.0__py3-none-any.whl → 0.22.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
@@ -198,8 +199,6 @@ class Project(ProtoWrapperBase):
     def load_geometry_to_setup(self, geometry: "Geometry") -> None:
         """
         Load a geometry to the setup phase.
-        NOTE: this operation is irreversible and deletes all the existing meshes and simulations
-        in the project.
 
         Parameters
         ----------
@@ -324,6 +323,8 @@ class Project(ProtoWrapperBase):
         names_to_file_paths: Dict[str, Union[PathLike[Any], str]],
         params: hexmeshpb.HexMeshSpec,
         use_internal_wrap: bool = False,
+        request_id: Optional[str] = None,
+        n_vcpus: Optional[int] = None,
     ) -> "Mesh":
         """
         Creates a hex mesh. Only for internal use.
@@ -361,7 +362,14 @@ class Project(ProtoWrapperBase):
 
         params.use_wrap = use_internal_wrap
 
-        req = meshpb.CreateHexMeshRequest(project_id=self.id, hex_mesh_config=params)
+        if request_id is None:
+            request_id = str(uuid.uuid4())
+        req = meshpb.CreateHexMeshRequest(
+            project_id=self.id,
+            hex_mesh_config=params,
+            request_id=request_id,
+            n_vcpus=n_vcpus,
+        )
 
         res: meshpb.CreateHexMeshResponse = client.CreateHexMesh(req)
         get_mesh_res = client.GetMesh(meshpb.GetMeshRequest(id=res.mesh_id))
@@ -785,53 +793,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

@@ -195,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
@@ -206,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.
@@ -305,6 +311,19 @@ class Simulation(ProtoWrapperBase):
         req = simulationpb.GetSimulationParametersRequest(id=self.id)
         return SimulationParam.from_proto(get_default_client().GetSimulationParameters(req))
 
+    def _get_workflow_id(self) -> Optional[str]:
+        """
+        Retrieves the workflow ID associated with the current simulation.
+
+        Returns
+        -------
+        str | None
+            The workflow ID corresponding to this simulation's ID, or None if the simulation
+            has no associated workflow.
+        """
+        result = _get_workflow_ids([self.id])
+        return result.get(self.id)
+
     @deprecated(
         "Use get_parameters() instead. This method will be removed in a future release.",
     )
@@ -355,3 +374,47 @@ def get_simulation(id: SimulationID) -> Simulation:
     req = simulationpb.GetSimulationRequest(id=id)
     res = get_default_client().GetSimulation(req)
     return Simulation(res.simulation)
+
+
+def _get_workflow_ids(simulation_ids: list[SimulationID]) -> dict[SimulationID, str]:
+    """
+    Get the workflow IDs corresponding to simulation IDs.
+
+    This is useful for mapping between UI-created simulations (which have workflow IDs)
+    and the simulation IDs used in the API.
+
+    Parameters
+    ----------
+    simulation_ids : list[SimulationID]
+        The simulation IDs to look up.
+
+    Returns
+    -------
+    dict[SimulationID, str]
+        A mapping from simulation ID to workflow ID. Only simulation IDs that were
+        successfully resolved to workflow IDs are present as keys. Simulation IDs are
+        omitted if:
+
+        - The simulation ID does not exist
+        - The user lacks access to the simulation's project
+        - The simulation has no associated workflow ID
+
+    Examples
+    --------
+    >>> import luminarycloud as lc
+    >>> sim_ids = [lc.SimulationID("sim_123"), lc.SimulationID("sim_456")]
+    >>> workflow_ids = lc._get_workflow_ids(sim_ids)
+    >>> print(workflow_ids)
+    {SimulationID('sim_123'): 'wf_abc', SimulationID('sim_456'): 'wf_def'}
+
+    >>> # Check if a simulation has a workflow
+    >>> sim_id = lc.SimulationID("sim_123")
+    >>> if sim_id in workflow_ids:
+    ...     print(f"Workflow ID: {workflow_ids[sim_id]}")
+    ... else:
+    ...     print("No workflow found")
+    """
+    req = simulationpb.GetWorkflowIDsRequest(simulation_ids=simulation_ids)
+    res = get_default_client().GetWorkflowIDs(req)
+    # Return dict with SimulationID keys (not str keys)
+    return {SimulationID(sim_id): wf_id for sim_id, wf_id in res.data.items()}

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/types/matrix3.py

@@ -20,7 +20,19 @@ class Matrix3:
             c=basepb.Vector3(x=self.c.x, y=self.c.y, z=self.c.z),
         )
 
+    def _to_ad_proto(self) -> basepb.AdMatrix3:
+        return basepb.AdMatrix3(
+            a=self.a._to_ad_proto(),
+            b=self.b._to_ad_proto(),
+            c=self.c._to_ad_proto(),
+        )
+
     def _from_proto(self, proto: basepb.Matrix3) -> None:
         self.a = Vector3(x=proto.a.x, y=proto.a.y, z=proto.a.z)
         self.b = Vector3(x=proto.b.x, y=proto.b.y, z=proto.b.z)
         self.c = Vector3(x=proto.c.x, y=proto.c.y, z=proto.c.z)
+
+    def _from_ad_proto(self, proto: basepb.AdMatrix3) -> None:
+        self.a = Vector3.from_ad_proto(proto.a)
+        self.b = Vector3.from_ad_proto(proto.b)
+        self.c = Vector3.from_ad_proto(proto.c)

luminarycloud/vis/__init__.py

@@ -6,6 +6,8 @@ from .visualization import (
     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,

luminarycloud/vis/interactive_report.py

@@ -1,10 +1,6 @@
 import io
-from . import ExtractOutput
-from .vis_util import _InternalToken, _get_status
 from .visualization import RenderOutput
-from ..enum import ExtractStatusType
-from .._client import get_default_client
-from .._proto.api.v0.luminarycloud.vis import vis_pb2
+from .report import ReportEntry
 
 try:
     import luminarycloud_jupyter as lcj
@@ -12,42 +8,24 @@ except ImportError:
     lcj = None
 
 
-# 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:
-    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
-
-    # 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 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.
+    """
 
-class InteractiveReport:
     # 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.
@@ -59,62 +37,70 @@ class InteractiveReport:
         if len(self.entries) == 0:
             raise ValueError("Invalid number of entries, must be > 0")
 
-        report_data = []
-        for row, re in enumerate(self.entries):
-            row_data = []
-            re.download_extracts()
-            for extract in re._extracts:
-                if isinstance(extract, RenderOutput):
-                    image_and_label = extract.download_images()
-                    row_data.extend([il[0] for il in image_and_label])
-                else:
-                    plot_data = extract.download_data()
-                    # Plot absolute pressure for each intersection curve we have
-                    # TODO will: make these params of the extract/report entry
-                    # We'll pick the first item that's not x/y/z coordinates to be the data we plot
-                    x_axis = "x"
-                    y_axis = [n for n in plot_data[0][0][0] if n != "x" and n != "y" and n != "z"][
-                        0
-                    ]
-                    scatter_plots = []
-                    for p in plot_data:
-                        data = p[0]
-                        x_idx = data[0].index(x_axis)
-                        y_idx = data[0].index(y_axis)
-
-                        scatter_data = lcj.ScatterPlotData()
-                        scatter_data.name = f"plot-{row}"
-                        for r in data[1:]:
-                            scatter_data.x.append(r[x_idx])
-                            scatter_data.y.append(r[y_idx])
-                        scatter_plots.append(scatter_data)
-                    row_data.append(scatter_plots)
-
-            report_data.append(row_data)
-
-        # TODO Validate the grid configuration is valid, all report entries should have the
-        # same # of extract IDs and metadata keys
-        # maybe not needed, b/c this is something we'd control internally later?
-        nrows = len(report_data)
-        ncols = len(report_data[0]) if len(report_data) > 0 else 0
-
-        for i, r in enumerate(report_data):
-            if len(r) != ncols:
-                raise ValueError(
-                    f"Invalid report configuration: row {i} does not have {ncols} columns"
-                )
+        # 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)
-        for row, row_data in enumerate(report_data):
-            for col, col_data in enumerate(row_data):
-                if isinstance(col_data, list) and isinstance(col_data[0], lcj.ScatterPlotData):
-                    x_axis = "x"
-                    y_axis = "Absolute Pressure (Pa)"
-                    self.widget.set_cell_scatter_plot(
-                        row, col, f"{row} {y_axis} v {x_axis}", x_axis, y_axis, col_data
-                    )
-                elif isinstance(col_data, io.BytesIO):
-                    self.widget.set_cell_data(row, col, col_data.getvalue(), "jpg")
+
+        # 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:
         """