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

luminarycloud/params/simulation/adaptive_mesh_refinement_.py

@@ -41,6 +41,8 @@ class AdaptiveMeshRefinement(CodeRepr, ParamGroupWrapper[clientpb.AdaptiveMeshRe
     "The method to generate the computational mesh."
     target_cv_millions: int = 10
     "User-requested mesh size in millions of control volumes."
+    all_tet: enum.AllTet = enum.AllTet.ALL_TET_ON
+    "Automatically inserts high aspect ratio mesh elements in the boundary layer and ignores all adaptation boundary layer settings."
     user_scaling: LcFloat = 1.0
     "Scale factor between the geometry and the mesh."
     boundary_layer_profile: list[BoundaryLayerProfile] = field(default_factory=list)
@@ -55,6 +57,7 @@ class AdaptiveMeshRefinement(CodeRepr, ParamGroupWrapper[clientpb.AdaptiveMeshRe
         _proto.final_target_complexity.CopyFrom(_to_ad_proto(self.final_target_complexity))
         _proto.meshing_method = self.meshing_method.value
         _proto.target_cv_millions.value = self.target_cv_millions
+        _proto.all_tet = self.all_tet.value
         _proto.user_scaling.CopyFrom(_to_ad_proto(self.user_scaling))
         if self.boundary_layer_profile is not None:
             _proto.boundary_layer_profile.extend(v._to_proto() for v in self.boundary_layer_profile)
@@ -68,6 +71,7 @@ class AdaptiveMeshRefinement(CodeRepr, ParamGroupWrapper[clientpb.AdaptiveMeshRe
         self.final_target_complexity = _from_ad_proto(proto.final_target_complexity)
         self.meshing_method = enum.MeshingMethod(proto.meshing_method)
         self.target_cv_millions = proto.target_cv_millions.value
+        self.all_tet = enum.AllTet(proto.all_tet)
         self.user_scaling = _from_ad_proto(proto.user_scaling)
         self.boundary_layer_profile = [
             BoundaryLayerProfile.from_proto(v) for v in proto.boundary_layer_profile

luminarycloud/params/simulation/physics/__init__.py

@@ -1,6 +1,5 @@
 from . import fluid
 from . import heat
-from . import periodic_pair
 from . import solution_controls
 from .fluid_ import Fluid
 from .heat_ import Heat

luminarycloud/params/simulation/physics/periodic_pair_.py

@@ -17,17 +17,6 @@ import luminarycloud.params.enum._enum_wrappers as enum
 
 from luminarycloud.params.simulation._lib import ParamGroupWrapper, create_unique_id
 
-from luminarycloud.params.simulation.physics.periodic_pair.periodicity_type_ import PeriodicityType
-from luminarycloud.params.simulation.physics.periodic_pair.periodicity_type_ import *
-from luminarycloud.params.simulation.physics.periodic_pair.periodicity_type.rotational_periodicity_ import (
-    RotationalPeriodicity,
-)
-from luminarycloud.params.simulation.physics.periodic_pair.periodicity_type.rotational_periodicity_ import *
-from luminarycloud.params.simulation.physics.periodic_pair.periodicity_type.translational_periodicity_ import (
-    TranslationalPeriodicity,
-)
-from luminarycloud.params.simulation.physics.periodic_pair.periodicity_type.translational_periodicity_ import *
-
 
 @dataclass(kw_only=True)
 class PeriodicPair(CodeRepr, ParamGroupWrapper[clientpb.PeriodicPair]):
@@ -39,8 +28,12 @@ class PeriodicPair(CodeRepr, ParamGroupWrapper[clientpb.PeriodicPair]):
     ""
     surfaces_side_b: list[str] = field(default_factory=list)
     ""
-    periodicity_type: PeriodicityType = field(default_factory=TranslationalPeriodicity)
-    " Possible types: ``TranslationalPeriodicity``, ``RotationalPeriodicity`` from the ``periodicity_type`` module."
+    translation: Vector3 = field(default_factory=lambda: Vector3(0.0, 0.0, 0.0))
+    "Holds the translation vector in the x,y,z directions from each point on the first periodic boundary to its matching point on the second periodic boundary."
+    center: Vector3 = field(default_factory=lambda: Vector3(0.0, 0.0, 0.0))
+    "Origin for the rotational periodicity transformation."
+    rotation_vector: Vector3 = field(default_factory=lambda: Vector3(0.0, 0.0, 0.0))
+    "Holds the rotation vector needed to transform each point on the first periodic boundary to its matching point on the second periodic boundary. The vector direction defines the periodicity axis and its magnitude defines the periodicity angle, in degrees, from A to B according to the right-hand rule."
 
     def _to_proto(self) -> clientpb.PeriodicPair:
         _proto = clientpb.PeriodicPair()
@@ -50,28 +43,16 @@ class PeriodicPair(CodeRepr, ParamGroupWrapper[clientpb.PeriodicPair]):
             _proto.bound_a.extend(self.surfaces_side_a)
         if self.surfaces_side_b is not None:
             _proto.bound_b.extend(self.surfaces_side_b)
-        if isinstance(self.periodicity_type, TranslationalPeriodicity):
-            _proto.periodic_bc_type = clientpb.TRANSLATIONAL
-            _proto.periodic_translation.CopyFrom(self.periodicity_type.translation._to_ad_proto())
-        if isinstance(self.periodicity_type, RotationalPeriodicity):
-            _proto.periodic_bc_type = clientpb.ROTATIONAL
-            _proto.periodic_center_of_rotation.CopyFrom(self.periodicity_type.center._to_ad_proto())
-            _proto.periodic_rotation_angles.CopyFrom(
-                self.periodicity_type.rotation_vector._to_ad_proto()
-            )
+        _proto.periodic_translation.CopyFrom(self.translation._to_ad_proto())
+        _proto.periodic_center_of_rotation.CopyFrom(self.center._to_ad_proto())
+        _proto.periodic_rotation_angles.CopyFrom(self.rotation_vector._to_ad_proto())
         return _proto
 
     def _from_proto(self, proto: clientpb.PeriodicPair) -> None:
         self.name = proto.periodic_pair_name
         self.surfaces_side_a.extend(proto.bound_a)
         self.surfaces_side_b.extend(proto.bound_b)
-        if proto.periodic_bc_type == clientpb.INVALID_PERIODIC_BC_TYPE:
-            raise ValueError("Invalid periodicity_type")
-        elif proto.periodic_bc_type == clientpb.TRANSLATIONAL:
-            self.periodicity_type = TranslationalPeriodicity()
-            self.periodicity_type.translation._from_ad_proto(proto.periodic_translation)
-        elif proto.periodic_bc_type == clientpb.ROTATIONAL:
-            self.periodicity_type = RotationalPeriodicity()
-            self.periodicity_type.center._from_ad_proto(proto.periodic_center_of_rotation)
-            self.periodicity_type.rotation_vector._from_ad_proto(proto.periodic_rotation_angles)
+        self.translation._from_ad_proto(proto.periodic_translation)
+        self.center._from_ad_proto(proto.periodic_center_of_rotation)
+        self.rotation_vector._from_ad_proto(proto.periodic_rotation_angles)
         return None

luminarycloud/physics_ai/architectures.py

@@ -56,14 +56,14 @@ class PhysicsAiArchitectureVersion(ProtoWrapperBase):
             config["priority_class"] = "prod-batch-priority"
         if "resources" not in config:
             config["resources"] = {}
-        if "process_gpus" not in config["resources"]:
-            config["resources"]["process_gpus"] = 8
+        if "process_cpus" not in config["resources"]:
+            config["resources"]["process_cpus"] = 8
         if "train_gpus" not in config["resources"]:
-            config["resources"]["train_gpus"] = 8
+            config["resources"]["train_gpus"] = 1
         if "test_gpus" not in config["resources"]:
-            config["resources"]["test_gpus"] = 8
+            config["resources"]["test_gpus"] = 1
         if "mode" not in config:
-            config["mode"] = "full-gpu"
+            config["mode"] = "full"
 
         training_config_json = json.dumps(config, indent=2)
         external_dataset_uri = f"gs://training-data/architecture-{self.id}"

luminarycloud/physics_ai/inference.py

@@ -17,6 +17,7 @@ from ..project import Project
 from ..project import Project
 from .._helpers import upload_file
 from .._proto.upload import upload_pb2 as uploadpb
+from ..types.ids import PhysicsAiModelVersionID
 
 
 @dataclass
@@ -50,7 +51,7 @@ class ExtAeroInferenceResult:
 def external_aero_inference(
     project: Project,
     stl_file: str,
-    artifact_url: str,
+    model_version_id: PhysicsAiModelVersionID,
     conditions: Optional[Dict[str, Any]] = None,
     settings: Optional[Dict[str, Any]] = None,
     write_visualization_data=False,
@@ -62,8 +63,8 @@ def external_aero_inference(
         The project to which the inference files will be added.
     stl_file : str
         Fullpath the STL file to be used for inference.
-    artifact_url : str
-        Fullpath of the model artifact directory to be used for inference.
+    model_version_id : PhysicsAiModelVersionID
+        The ID of the trained model version to use for inference.
     conditions : Dict[str, Any], optional
         Dictionary of conditions to be passed to the inference service (e.g., alpha, beta, etc.).
     settings : Dict[str, Any], optional
@@ -80,7 +81,7 @@ def external_aero_inference(
     """
 
     result = perform_inference(
-        project, stl_file, artifact_url, conditions, settings, write_visualization_data
+        project, stl_file, model_version_id, conditions, settings, write_visualization_data
     )
     return ExtAeroInferenceResult(result)
 
@@ -88,7 +89,7 @@ def external_aero_inference(
 def perform_inference(
     project: Project,
     stl_file: str,
-    artifact_url: str,
+    model_version_id: PhysicsAiModelVersionID,
     conditions: Optional[Dict[str, Any]] = None,
     settings: Optional[Dict[str, Any]] = None,
     write_visualization_data=False,
@@ -100,8 +101,8 @@ def perform_inference(
         The project to which the inference files will be added.
     stl_file : str
         Fullpath the STL file to be used for inference.
-    artifact_url : str
-        Fullpath of the model artifact directory to be used for inference.
+    model_version_id : PhysicsAiModelVersionID
+        The ID of the trained model version to use for inference.
     conditions : Dict[str, Any], optional
         Dictionary of conditions to be passed to the inference service (e.g., alpha, beta, etc.).
     settings : Dict[str, Any], optional
@@ -142,7 +143,7 @@ def perform_inference(
     stl_url = upload_if_file(stl_file)
 
     raw = start_inference_job(
-        project, stl_url, artifact_url, conditions, settings, write_visualization_data
+        project, stl_url, model_version_id, conditions, settings, write_visualization_data
     )
     currated: dict[str, Any] = {}
     for k, v in raw.items():
@@ -162,7 +163,7 @@ def perform_inference(
 def start_inference_job(
     project: Project,
     stl_url: str,
-    artifact_url: str,
+    model_version_id: PhysicsAiModelVersionID,
     conditions: Optional[Dict[str, Any]] = None,
     settings: Optional[Dict[str, Any]] = None,
     write_visualization_data=False,
@@ -174,8 +175,8 @@ def start_inference_job(
         Reference to a project.
     stl_url : str
         URL of the STL file to be used for inference.
-    artifact_url : str
-        URL of the model artifact directory to be used for inference.
+    model_version_id : PhysicsAiModelVersionID
+        The ID of the trained model version to use for inference.
     conditions : Dict[str, Any], optional
         Dictionary of conditions to be passed to the inference service (e.g., alpha, beta, etc.).
     settings : Dict[str, Any], optional
@@ -203,13 +204,12 @@ def start_inference_job(
 
     req = inferencepb.CreateInferenceServiceJobRequest(
         stl_url=stl_url,
-        artifact_url=artifact_url,
+        model_version_id=str(model_version_id),
         conditions=conditions_bytes,
         settings=settings_bytes,
         project_id=project.id,
         write_visualization_data=write_visualization_data,
     )
-
     res: inferencepb.CreateInferenceServiceJobResponse = (
         get_default_client().CreateInferenceServiceJob(req)
     )

luminarycloud/physics_ai/solution.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import tarfile
-from typing import List, Optional, BinaryIO, cast
+from typing import List, Optional, BinaryIO, cast, Dict
 
 from .._client import get_default_client
 from .._helpers.download import download_solution_physics_ai as _download_solution_physics_ai
@@ -16,6 +16,7 @@ def _download_processed_solution_physics_ai(  # noqa: F841
     volume_fields_to_keep: Optional[List[QuantityType]] = None,
     process_volume: bool = False,
     single_precision: bool = True,
+    internal_options: Optional[Dict[str, str]] = None,
 ) -> tarfile.TarFile:
     """
     Download solution data with physics AI processing applied.
@@ -50,6 +51,7 @@ def _download_processed_solution_physics_ai(  # noqa: F841
         volume_fields_to_keep=volume_fields_to_keep,
         process_volume=process_volume,
         single_precision=single_precision,
+        internal_options=internal_options,
     )
 
     assert stream is not None, "Failed to download solution data"

luminarycloud/pipelines/__init__.py

@@ -2,6 +2,8 @@
 from .core import (
     Pipeline as Pipeline,
     PipelineParameter as PipelineParameter,
+    # Stage base class, mainly exported for testing
+    Stage as Stage,
 )
 
 from .parameters import (
@@ -11,9 +13,7 @@ from .parameters import (
     BoolPipelineParameter as BoolPipelineParameter,
 )
 
-from .operators import (
-    # Operator base class, mainly exported for testing
-    Operator as Operator,
+from .stages import (
     # PipelineOutputs, i.e. things that "flow" in a Pipeline
     PipelineOutputGeometry as PipelineOutputGeometry,
     PipelineOutputMesh as PipelineOutputMesh,
@@ -21,6 +21,8 @@ from .operators import (
     # Concrete operators and their output types
     ReadGeometry as ReadGeometry,
     ReadGeometryOutputs as ReadGeometryOutputs,
+    ReadMesh as ReadMesh,
+    ReadMeshOutputs as ReadMeshOutputs,
     ModifyGeometry as ModifyGeometry,
     ModifyGeometryOutputs as ModifyGeometryOutputs,
     Mesh as Mesh,
@@ -39,4 +41,10 @@ from .api import (
     list_pipelines as list_pipelines,
     get_pipeline as get_pipeline,
     create_pipeline_job as create_pipeline_job,
+    get_pipeline_job as get_pipeline_job,
+    list_pipeline_jobs as list_pipeline_jobs,
+    PipelineJobRecord as PipelineJobRecord,
+    PipelineRecord as PipelineRecord,
+    PipelineJobRunRecord as PipelineJobRunRecord,
+    LogLine as LogLine,
 )

luminarycloud/pipelines/api.py

@@ -1,15 +1,39 @@
 # Copyright 2023-2024 Luminary Cloud, Inc. All Rights Reserved.
-from typing import Literal
+from typing import Any, Literal
 from dataclasses import dataclass
 
 from datetime import datetime
+from time import time, sleep
+import logging
 
+from .arguments import PipelineArgValueType
 from ..pipelines import Pipeline, PipelineArgs
 from .._client import get_default_client
 
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class LogLine:
+    timestamp: datetime
+    level: int
+    message: str
+
+    @classmethod
+    def from_json(cls, json: dict) -> "LogLine":
+        return cls(
+            timestamp=datetime.fromisoformat(json["timestamp"]),
+            level=json["level"],
+            message=json["message"],
+        )
+
 
 @dataclass
 class PipelineRecord:
+    """
+    A PipelineRecord represents a persisted pipeline.
+    """
+
     id: str
     name: str
     description: str | None
@@ -17,8 +41,10 @@ class PipelineRecord:
     created_at: datetime
     updated_at: datetime
 
-    def pipeline(self) -> Pipeline:
-        return Pipeline._from_yaml(self.definition_yaml)
+    # I don't think users need to get the Pipeline object from a PipelineRecord, but if they did,
+    # it would be done like this.
+    # def pipeline(self) -> Pipeline:
+    #     return Pipeline._from_yaml(self.definition_yaml)
 
     @classmethod
     def from_json(cls, json: dict) -> "PipelineRecord":
@@ -31,14 +57,30 @@ class PipelineRecord:
             updated_at=datetime.fromisoformat(json["updated_at"]),
         )
 
+    def pipeline_jobs(self) -> "list[PipelineJobRecord]":
+        """
+        Returns a list of pipeline jobs that were created from this pipeline.
+
+        Returns
+        -------
+        list[PipelineJobRecord]
+            A list of PipelineJobRecord objects.
+        """
+        res = get_default_client().http.get(f"/rest/v0/pipelines/{self.id}/pipeline_jobs")
+        return [PipelineJobRecord.from_json(p) for p in res["data"]]
+
 
 @dataclass
 class PipelineJobRecord:
+    """
+    A PipelineJobRecord represents a persisted pipeline job.
+    """
+
     id: str
     pipeline_id: str
     name: str
     description: str | None
-    status: Literal["pending", "running", "completed", "failed", "cancelled"]
+    status: Literal["pending", "running", "completed", "failed"]
     created_at: datetime
     updated_at: datetime
     started_at: datetime | None
@@ -60,6 +102,200 @@ class PipelineJobRecord:
             ),
         )
 
+    def pipeline(self) -> PipelineRecord:
+        """
+        Returns the pipeline that this pipeline job was created from.
+
+        Returns
+        -------
+        PipelineRecord
+            The PipelineRecord for the pipeline that this pipeline job was created from.
+        """
+        return get_pipeline(self.pipeline_id)
+
+    def runs(self) -> "list[PipelineJobRunRecord]":
+        """
+        Returns a list of runs for this pipeline job.
+
+        Returns
+        -------
+        list[PipelineJobRunRecord]
+            A list of PipelineJobRunRecord objects.
+        """
+        res = get_default_client().http.get(f"/rest/v0/pipeline_jobs/{self.id}/runs")
+        return [PipelineJobRunRecord.from_json(r) for r in res["data"]]
+
+    def logs(self) -> list[LogLine]:
+        """
+        Returns a list of log lines for this pipeline job.
+
+        Each log line is a LogLine object, which has a timestamp, level, and message.
+
+        Returns
+        -------
+        list[LogLine]
+            A list of LogLine objects.
+        """
+        res = get_default_client().http.get(f"/rest/v0/pipeline_jobs/{self.id}/logs")
+        return [LogLine.from_json(l) for l in res["data"]]
+
+    def artifacts(self) -> list[dict]:
+        """
+        Returns a list of artifacts that were produced by this pipeline job.
+
+        Artifacts are things like Geometries, Meshes, and Simulations. Each artifact is a dictionary
+        with an "id" key, which is an identifier for the artifact.
+
+        .. warning:: This feature is experimental and may change or be removed in the future.
+
+        Returns
+        -------
+        list[dict]
+            A list of artifact dictionaries.
+        """
+        res = get_default_client().http.get(f"/rest/v0/pipeline_jobs/{self.id}/artifacts")
+        return res["data"]
+
+    def wait(
+        self,
+        *,
+        interval_seconds: float = 5,
+        timeout_seconds: float = float("inf"),
+        print_logs: bool = False,
+    ) -> Literal["completed", "failed"]:
+        """
+        Wait for the pipeline job to complete or fail.
+
+        This method polls the pipeline job status at regular intervals until it reaches
+        a terminal state (completed or failed).
+
+        Parameters
+        ----------
+        interval_seconds : float
+            Number of seconds between status polls. Default is 5 seconds.
+        timeout_seconds : float
+            Number of seconds before the operation times out. Default is infinity.
+        print_logs : bool
+            If True, prints new log lines as they become available. Default is False.
+
+        Returns
+        -------
+        Literal["completed", "failed"]
+            The final status of the pipeline job.
+
+        Raises
+        ------
+        TimeoutError
+            If the pipeline job does not complete within the specified timeout.
+
+        Examples
+        --------
+        >>> pipeline_job = pipelines.create_pipeline_job(pipeline.id, args, "My Job")
+        >>> final_status = pipeline_job.wait(timeout_seconds=3600)
+        >>> print(f"Pipeline job finished with status: {final_status}")
+        """
+        deadline = time() + timeout_seconds
+        last_log_count = 0
+
+        while True:
+            # Refresh the pipeline job status
+            updated_job = get_pipeline_job(self.id)
+
+            # Print new logs if requested
+            if print_logs:
+                logs = updated_job.logs()
+                if len(logs) > last_log_count:
+                    for log_line in logs[last_log_count:]:
+                        print(f"[{log_line.timestamp}] {log_line.message}")
+                    last_log_count = len(logs)
+
+            # Check if we've reached a terminal state
+            if updated_job.status == "completed":
+                logger.info(f"Pipeline job {self.id} completed successfully")
+                return "completed"
+            elif updated_job.status == "failed":
+                logger.warning(f"Pipeline job {self.id} failed")
+                return "failed"
+
+            # Check timeout
+            if time() >= deadline:
+                raise TimeoutError(
+                    f"Timed out waiting for pipeline job {self.id} to complete. "
+                    f"Current status: {updated_job.status}"
+                )
+
+            # Wait before next poll
+            sleep(max(0, min(interval_seconds, deadline - time())))
+
+            # Update self with the latest status
+            self.status = updated_job.status
+            self.updated_at = updated_job.updated_at
+            self.started_at = updated_job.started_at
+            self.completed_at = updated_job.completed_at
+
+
+@dataclass
+class PipelineJobRunRecord:
+    pipeline_job_id: str
+    idx: int
+    arguments: list[PipelineArgValueType]
+    status: Literal["pending", "running", "completed", "failed"]
+
+    @classmethod
+    def from_json(cls, json: dict) -> "PipelineJobRunRecord":
+        return cls(
+            pipeline_job_id=json["pipeline_job_id"],
+            idx=json["idx"],
+            arguments=json["arguments"],
+            status=json["status"],
+        )
+
+    def pipeline_job(self) -> PipelineJobRecord:
+        """
+        Returns the pipeline job that this pipeline job run was created from.
+
+        Returns
+        -------
+        PipelineJobRecord
+            The PipelineJobRecord for the pipeline job that this pipeline job run was created from.
+        """
+        return get_pipeline_job(self.pipeline_job_id)
+
+    def logs(self) -> list[LogLine]:
+        """
+        Returns a list of log lines for this pipeline job run.
+
+        Each log line is a LogLine object, which has a timestamp, level, and message.
+
+        Returns
+        -------
+        list[LogLine]
+            A list of LogLine objects.
+        """
+        res = get_default_client().http.get(
+            f"/rest/v0/pipeline_jobs/{self.pipeline_job_id}/runs/{self.idx}/logs"
+        )
+        return [LogLine.from_json(l) for l in res["data"]]
+
+    def artifacts(self) -> list[dict]:
+        """
+        Returns a list of artifacts that were produced by this pipeline job run.
+
+        Artifacts are things like Geometries, Meshes, and Simulations. Each artifact is a dictionary
+        with an "id" key, which is an identifier for the artifact.
+
+        .. warning:: This feature is experimental and may change or be removed in the future.
+
+        Returns
+        -------
+        list[dict]
+            A list of artifact dictionaries.
+        """
+        res = get_default_client().http.get(
+            f"/rest/v0/pipeline_jobs/{self.pipeline_job_id}/runs/{self.idx}/artifacts"
+        )
+        return res["data"]
+
 
 def create_pipeline(
     name: str, pipeline: Pipeline | str, description: str | None = None

luminarycloud/pipelines/arguments.py

@@ -103,3 +103,18 @@ class PipelineArgs:
         return (
             f"PipelineArgs(param_names={[p.name for p in self.params]}, row_count={len(self.rows)})"
         )
+
+    def print_as_table(self) -> None:
+        headers = [p.name for p in self.params]
+        row_strs = [[str(v) for v in row.row_values] for row in self.rows]
+        col_widths = [
+            max(len(headers[i]), *(len(r[i]) for r in row_strs)) for i in range(len(headers))
+        ]
+
+        def format_row(values: list[str]) -> str:
+            return " | ".join(val.ljust(col_widths[i]) for i, val in enumerate(values))
+
+        print(format_row(headers))
+        print("-+-".join("-" * w for w in col_widths))
+        for r in row_strs:
+            print(format_row(r))