luminarycloud 0.19.0__py3-none-any.whl → 0.22.0__py3-none-any.whl

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)

luminarycloud/vis/visualization.py

@@ -24,6 +24,7 @@ from luminarycloud.enum import (
     SceneMode,
     VisQuantity,
     QuantityType,
+    FieldAssociation,
 )
 from ..exceptions import NotFoundError
 from ..geometry import Geometry, get_geometry
@@ -162,7 +163,7 @@ class LookAtCamera(CodeRepr):
         self.projection = CameraProjection(static_ani.camera.projection)
 
     def __repr__(self) -> str:
-        return self._to_code_helper(obj_name="camera")
+        return self._to_code_helper(obj_name="camera", hide_defaults=False)
 
 
 class RenderOutput:
@@ -206,13 +207,18 @@ class RenderOutput:
         self._deleted = False
 
     def _set_data(
-        self, extract_id: str, project_id: str, name: str, desciption: str, status: RenderStatusType
+        self,
+        extract_id: str,
+        project_id: str,
+        name: str,
+        description: str,
+        status: RenderStatusType,
     ) -> 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"RenderOutput(Id: {self._extract_id} status: {self.status})"
@@ -806,7 +812,7 @@ class Scene(CodeRepr):
             extract_id=res.extract.extract_id,
             project_id=self._project_id,
             name=name,
-            desciption=description,
+            description=description,
             status=RenderStatusType(res.extract.status),
         )
         return render_output
@@ -1089,6 +1095,65 @@ def list_quantities(solution: Solution) -> List[VisQuantity]:
     return result
 
 
+@dc.dataclass
+class RangeResult:
+    ranges: List[DataRange]
+    """
+    A list of ranges per component. Scalars have a single range and vector ranges are in
+    in x,y,z, magnitude order.
+    """
+    quantity: VisQuantity
+    """ The quantity type for the field, if available.  """
+    field_name: str
+    """ Name of the field.  """
+
+
+def range_query(solution: Solution, field_association: FieldAssociation) -> List[RangeResult]:
+    """
+    The range query returns the min/max values for all fields in a solution. Two
+    types of ranges can be chosen: cell-centered and point-centered data. The
+    results will vary based on the choice. The solver natively outputs cell-centered
+    data, so the cell based query will return the actual min/max values
+    from the solver run. Visualization operates on point-centered data, which is
+    recentered from the cell-centered data.
+
+    Parameters
+    ----------
+    solution: Solution
+        The the solution object to query.
+    field_association: FieldAssociation
+        The type of data to query, either cell-centered or point-centered.
+    """
+    if not isinstance(solution, Solution):
+        raise TypeError(f"Expected 'Solution', got {type(solution).__name__}")
+
+    if not isinstance(field_association, FieldAssociation):
+        raise TypeError(f"Expected 'FieldAssociation', got {type(field_association).__name__}")
+
+    sim = get_simulation(solution.simulation_id)
+    req = vis_pb2.RangeQueryRequest()
+    req.entity.simulation.id = solution.simulation_id
+    req.entity.simulation.solution_id = solution.id
+    req.project_id = sim.project_id
+    if field_association == FieldAssociation.POINTS:
+        req.field_association = vis_pb2.FieldAssociation.FIELD_ASSOCIATION_POINTS
+    else:
+        req.field_association = vis_pb2.FieldAssociation.FIELD_ASSOCIATION_CELLS
+    res: vis_pb2.RangeQueryReply = get_default_client().RangeQuery(req)
+    result: List[RangeResult] = []
+    for r in res.range:
+        ranges = []
+        for r_range in r.range:
+            data_range = DataRange()
+            data_range.min_value = r_range.min
+            data_range.max_value = r_range.max
+            ranges.append(data_range)
+        result.append(
+            RangeResult(ranges=ranges, quantity=VisQuantity(r.quantity), field_name=r.field_name)
+        )
+    return result
+
+
 def list_renders(entity: Geometry | Mesh | Solution) -> List[RenderOutput]:
     """
     Lists all previously created renders associated with a project and an entity.
@@ -1145,7 +1210,7 @@ def list_renders(entity: Geometry | Mesh | Solution) -> List[RenderOutput]:
             extract_id=extract.extract_id,
             project_id=extract.project_id,
             name=extract.name,
-            desciption=extract.description,
+            description=extract.description,
             status=RenderStatusType(extract.status),
         )
         # This need to be fixed on the backend, but manually refreshing works for now.
@@ -1315,3 +1380,60 @@ def _reconstruct(extract_id: str, project_id: str) -> Scene:
     req.project_id = project_id
     res: vis_pb2.GetExtractSpecResponse = get_default_client().GetExtractSpec(req)
     return _spec_to_scene(res.spec)
+
+
+@dc.dataclass
+class CameraEntry:
+    camera_id: int
+    name: str
+
+
+def list_cameras(project_id: str = "") -> List[CameraEntry]:
+    """
+    List all cameras in the specified project. If no project id is provided,
+    global cameras are returned.
+    """
+    req = vis_pb2.ListCamerasRequest()
+    req.project_id = project_id
+    res: vis_pb2.ListCamerasReply = get_default_client().ListCameras(req)
+    return [CameraEntry(camera_id=c.camera_id, name=c.name) for c in res.camera]
+
+
+def get_camera(entry: CameraEntry, width: int, height: int) -> LookAtCamera:
+    """
+    Instantiate a LookAt camera by its entry returned from list_cameras. The
+    width and the height impact orthographic cameras. Most screens have a 16:9
+    aspect ratio, so using the width = 1920 and height = 1080 is a good default
+    to match cameras created in the UI, otherwise parts of the scene may be
+    clipped.
+
+    .. warning:: This feature is experimental and may change or be removed in the future.
+
+    Parameters
+    ----------
+    entry: CameraEntry, required
+        A camera entry returned from list_cameras.
+    width: int, required
+        The target width of the camera.
+    height: int, required
+        The target height of the camera.
+    """
+    req = vis_pb2.GetCameraRequest()
+    req.camera_id = entry.camera_id
+    req.resolution.width = width
+    req.resolution.height = height
+    res: vis_pb2.GetCameraReply = get_default_client().GetCamera(req)
+    cam = LookAtCamera()
+    cam.width = width
+    cam.height = height
+    cam.label = entry.name
+    cam.up = Vector3()
+    cam.up._from_proto(res.camera.look_at.up)
+    cam.look_at = Vector3()
+    cam.look_at._from_proto(res.camera.look_at.look_at)
+    cam.position = Vector3()
+    cam.position._from_proto(res.camera.look_at.position)
+    cam.projection = CameraProjection(res.camera.projection)
+    cam.pan_x = res.camera.look_at.pan.x
+    cam.pan_y = res.camera.look_at.pan.y
+    return cam