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

luminarycloud/pipelines/api.py

@@ -7,8 +7,10 @@ from time import time, sleep
 import logging
 
 from .arguments import PipelineArgValueType
+from .core import Stage
 from ..pipelines import Pipeline, PipelineArgs
 from .._client import get_default_client
+from .._helpers import parse_iso_datetime
 
 logger = logging.getLogger(__name__)
 
@@ -22,7 +24,7 @@ class LogLine:
     @classmethod
     def from_json(cls, json: dict) -> "LogLine":
         return cls(
-            timestamp=datetime.fromisoformat(json["timestamp"]),
+            timestamp=parse_iso_datetime(json["timestamp"]),
             level=json["level"],
             message=json["message"],
         )
@@ -53,8 +55,8 @@ class PipelineRecord:
             name=json["name"],
             description=json["description"],
             definition_yaml=json["definition_yaml"],
-            created_at=datetime.fromisoformat(json["created_at"]),
-            updated_at=datetime.fromisoformat(json["updated_at"]),
+            created_at=parse_iso_datetime(json["created_at"]),
+            updated_at=parse_iso_datetime(json["updated_at"]),
         )
 
     def pipeline_jobs(self) -> "list[PipelineJobRecord]":
@@ -69,6 +71,25 @@ class PipelineRecord:
         res = get_default_client().http.get(f"/rest/v0/pipelines/{self.id}/pipeline_jobs")
         return [PipelineJobRecord.from_json(p) for p in res["data"]]
 
+    def delete(self) -> None:
+        """
+        Delete this pipeline.
+
+        This will permanently delete the pipeline and all associated pipeline jobs.
+        This operation cannot be undone.
+
+        Raises
+        ------
+        HTTPException
+            If the pipeline does not exist or if you do not have permission to delete it.
+
+        Examples
+        --------
+        >>> pipeline = pipelines.get_pipeline("pipeline-123")
+        >>> pipeline.delete()
+        """
+        get_default_client().http.delete(f"/rest/v0/pipelines/{self.id}")
+
 
 @dataclass
 class PipelineJobRecord:
@@ -80,11 +101,12 @@ class PipelineJobRecord:
     pipeline_id: str
     name: str
     description: str | None
-    status: Literal["pending", "running", "completed", "failed"]
+    status: Literal["pending", "running", "completed", "failed", "cancelled", "paused"]
     created_at: datetime
     updated_at: datetime
     started_at: datetime | None
     completed_at: datetime | None
+    paused_at: datetime | None
 
     @classmethod
     def from_json(cls, json: dict) -> "PipelineJobRecord":
@@ -92,14 +114,15 @@ class PipelineJobRecord:
             id=json["id"],
             pipeline_id=json["pipeline_id"],
             name=json["name"],
-            description=json["description"],
+            description=json.get("description"),
             status=json["status"],
-            created_at=datetime.fromisoformat(json["created_at"]),
-            updated_at=datetime.fromisoformat(json["updated_at"]),
-            started_at=datetime.fromisoformat(json["started_at"]) if json["started_at"] else None,
+            created_at=parse_iso_datetime(json["created_at"]),
+            updated_at=parse_iso_datetime(json["updated_at"]),
+            started_at=(parse_iso_datetime(json["started_at"]) if json.get("started_at") else None),
             completed_at=(
-                datetime.fromisoformat(json["completed_at"]) if json["completed_at"] else None
+                parse_iso_datetime(json["completed_at"]) if json.get("completed_at") else None
             ),
+            paused_at=(parse_iso_datetime(json["paused_at"]) if json.get("paused_at") else None),
         )
 
     def pipeline(self) -> PipelineRecord:
@@ -156,18 +179,37 @@ class PipelineJobRecord:
         res = get_default_client().http.get(f"/rest/v0/pipeline_jobs/{self.id}/artifacts")
         return res["data"]
 
+    def delete(self) -> None:
+        """
+        Delete this pipeline job.
+
+        This will permanently delete the pipeline job and all associated runs and tasks.
+        This operation cannot be undone.
+
+        Raises
+        ------
+        HTTPException
+            If the pipeline job does not exist or if you do not have permission to delete it.
+
+        Examples
+        --------
+        >>> pipeline_job = pipelines.get_pipeline_job("pipelinejob-123")
+        >>> pipeline_job.delete()
+        """
+        get_default_client().http.delete(f"/rest/v0/pipeline_jobs/{self.id}")
+
     def wait(
         self,
         *,
         interval_seconds: float = 5,
         timeout_seconds: float = float("inf"),
         print_logs: bool = False,
-    ) -> Literal["completed", "failed"]:
+    ) -> Literal["completed", "failed", "cancelled"]:
         """
-        Wait for the pipeline job to complete or fail.
+        Wait for the pipeline job to complete, fail, or be cancelled.
 
         This method polls the pipeline job status at regular intervals until it reaches
-        a terminal state (completed or failed).
+        a terminal state (completed, failed, or cancelled).
 
         Parameters
         ----------
@@ -180,7 +222,7 @@ class PipelineJobRecord:
 
         Returns
         -------
-        Literal["completed", "failed"]
+        Literal["completed", "failed", "cancelled"]
             The final status of the pipeline job.
 
         Raises
@@ -216,6 +258,9 @@ class PipelineJobRecord:
             elif updated_job.status == "failed":
                 logger.warning(f"Pipeline job {self.id} failed")
                 return "failed"
+            elif updated_job.status == "cancelled":
+                logger.info(f"Pipeline job {self.id} was cancelled")
+                return "cancelled"
 
             # Check timeout
             if time() >= deadline:
@@ -233,13 +278,86 @@ class PipelineJobRecord:
             self.started_at = updated_job.started_at
             self.completed_at = updated_job.completed_at
 
+    def get_concurrency_limits(self) -> dict[str, int]:
+        """
+        Returns the concurrency limits for this pipeline job.
+
+        Returns
+        -------
+        dict[str, int]
+            A dictionary mapping stage IDs to their concurrency limits.
+        """
+        res = get_default_client().http.get(f"/rest/v0/pipeline_jobs/{self.id}/concurrency_limits")
+        return {k: v["limit"] for k, v in res["data"].items()}
+
+    def set_concurrency_limits(self, limits: dict[str, int]) -> None:
+        """
+        Sets the concurrency limits for this pipeline job.
+
+        Parameters
+        ----------
+        limits : dict[str, int]
+            A dictionary mapping stage IDs to their concurrency limits.
+        """
+        body = {k: {"limit": v} for k, v in limits.items()}
+        get_default_client().http.put(f"/rest/v0/pipeline_jobs/{self.id}/concurrency_limits", body)
+
+    def cancel(self) -> None:
+        """Cancel this running pipeline job.
+
+        This will request cancellation of the underlying Prefect flow run. The
+        job should eventually transition to a cancelled terminal state once
+        the backend processes the cancellation.
+
+        Raises
+        ------
+        HTTPError
+            If the pipeline job cannot be cancelled (e.g., not found, not
+            running, or lacks the necessary Prefect flow run ID).
+        """
+        get_default_client().http.post(f"/rest/v0/pipeline_jobs/{self.id}/cancel", {})
+        logger.info(f"Cancelled pipeline job {self.id}")
+
+    def pause(self) -> None:
+        """Pause this running pipeline job.
+
+        This will prevent new tasks from being scheduled while allowing
+        in-progress tasks to complete. The job status will be set to PAUSED
+        and all stage concurrency limits will be temporarily set to 0.
+
+        Call resume() to continue execution.
+
+        Raises
+        ------
+        HTTPError
+            If the pipeline job cannot be paused (e.g., not found or not in
+            RUNNING state).
+        """
+        get_default_client().http.post(f"/rest/v0/pipeline_jobs/{self.id}/pause", {})
+        logger.info(f"Paused pipeline job {self.id}")
+
+    def resume(self) -> None:
+        """Resume this paused pipeline job.
+
+        This will restore the job status to RUNNING and restore the original
+        concurrency limits, allowing new tasks to be scheduled again.
+
+        Raises
+        ------
+        HTTPError
+            If the pipeline job cannot be resumed (e.g., not found or not in
+            PAUSED state).
+        """
+        get_default_client().http.post(f"/rest/v0/pipeline_jobs/{self.id}/resume", {})
+        logger.info(f"Resumed pipeline job {self.id}")
+
 
 @dataclass
 class PipelineJobRunRecord:
     pipeline_job_id: str
     idx: int
     arguments: list[PipelineArgValueType]
-    status: Literal["pending", "running", "completed", "failed"]
+    status: Literal["pending", "running", "completed", "failed", "cancelled"]
 
     @classmethod
     def from_json(cls, json: dict) -> "PipelineJobRunRecord":
@@ -347,7 +465,11 @@ def get_pipeline(id: str) -> PipelineRecord:
 
 
 def create_pipeline_job(
-    pipeline_id: str, args: PipelineArgs, name: str, description: str | None = None
+    pipeline_id: str,
+    args: PipelineArgs,
+    name: str,
+    description: str | None = None,
+    concurrency_limits: dict[str, int] | None = None,
 ) -> PipelineJobRecord:
     """
     Create a new pipeline job.
@@ -362,6 +484,8 @@ def create_pipeline_job(
         Name of the pipeline job.
     description : str, optional
         Description of the pipeline job.
+    concurrency_limits : dict[str, int], optional
+        A dictionary mapping stage IDs to their concurrency limits.
     """
 
     arg_rows = [row.row_values for row in args.rows]
@@ -373,7 +497,10 @@ def create_pipeline_job(
     }
 
     res = get_default_client().http.post(f"/rest/v0/pipelines/{pipeline_id}/pipeline_jobs", body)
-    return PipelineJobRecord.from_json(res["data"])
+    pjr = PipelineJobRecord.from_json(res["data"])
+    if concurrency_limits is not None:
+        pjr.set_concurrency_limits(concurrency_limits)
+    return pjr
 
 
 def get_pipeline_job(id: str) -> PipelineJobRecord:

luminarycloud/pipelines/core.py

@@ -292,7 +292,7 @@ class Pipeline:
     def pipeline_params(self) -> set[PipelineParameter]:
         return self._stages_dict_and_params()[1]
 
-    def _get_stage_id(self, stage: Stage) -> str:
+    def get_stage_id(self, stage: Stage) -> str:
         return self._stage_ids[stage]
 
     def _stages_dict_and_params(self) -> tuple[dict, set[PipelineParameter]]:

luminarycloud/pipelines/stages.py

@@ -2,7 +2,7 @@
 from dataclasses import dataclass
 
 from .core import Stage, StageInputs, StageOutputs, PipelineOutput
-from .parameters import StringPipelineParameter, IntPipelineParameter
+from .parameters import BoolPipelineParameter, StringPipelineParameter, IntPipelineParameter
 from ..meshing import MeshGenerationParams
 
 
@@ -49,6 +49,20 @@ class ReadGeometry(Stage[ReadGeometryOutputs]):
     ----------
     geometry_id : str | StringPipelineParameter
         The ID of the Geometry to retrieve.
+    use_geo_without_copying : bool | BoolPipelineParameter
+        By default, this is False, meaning that each Geometry this stage references will be copied
+        and the PipelineJob will actually operate on the copied Geometry. This is done so that a
+        PipelineJob can be based on a single parametric Geometry which each PipelineJobRun modifies
+        by applying a NamedVariableSet. That modification mutates the Geometry, so those runs can
+        only happen in parallel without intefrering with each other if they each operate on a
+        different copy of the Geometry.
+
+        However, if you've already prepared your Geometry in advance and you don't want the
+        PipelineJob to create copies, you can set this to True. In that case, the referenced
+        Geometry will be used directly without being copied.
+
+        IMPORTANT: If you set this to True, you must ensure no two PipelineJobRuns operate on the
+        same Geometry, i.e. no two PipelineArgs rows contain the same Geometry ID.
 
     Outputs
     -------
@@ -61,10 +75,11 @@ class ReadGeometry(Stage[ReadGeometryOutputs]):
         *,
         stage_name: str | None = None,
         geometry_id: str | StringPipelineParameter,
+        use_geo_without_copying: bool | BoolPipelineParameter = False,
     ):
         super().__init__(
             stage_name,
-            {"geometry_id": geometry_id},
+            {"geometry_id": geometry_id, "use_geo_without_copying": use_geo_without_copying},
             StageInputs(self),
             ReadGeometryOutputs._instantiate_for(self),
         )
@@ -202,13 +217,6 @@ class Mesh(Stage[MeshOutputs]):
             MeshOutputs._instantiate_for(self),
         )
 
-    # TODO: bring back the full MeshGenerationParams, but we need to be able to hydrate it from the
-    # pipeline YAML. I can probably bake that logic into PipelineDictable, `from_pipeline_dict` or
-    # something.
-    # @classmethod
-    # def _parse_params(cls, params: dict) -> dict:
-    #     return {"mesh_gen_params": MeshGenerationParams.from_pipeline_dict(**params["mesh_gen_params"])}
-
 
 @dataclass
 class SimulateOutputs(StageOutputs):
@@ -230,6 +238,9 @@ class Simulate(Stage[SimulateOutputs]):
         The name to assign to the Simulation. If None, a default name will be used.
     sim_template_id : str | StringPipelineParameter
         The ID of the SimulationTemplate to use for the Simulation.
+    batch_processing : bool | BoolPipelineParameter, default True
+        If True, the Simulation will run as a standard job. If False, the Simulation will run as a
+        priority job.
 
     Outputs
     -------
@@ -244,10 +255,12 @@ class Simulate(Stage[SimulateOutputs]):
         mesh: PipelineOutputMesh,
         sim_name: str | StringPipelineParameter | None = None,
         sim_template_id: str | StringPipelineParameter,
+        batch_processing: bool | BoolPipelineParameter = True,
     ):
         super().__init__(
             stage_name,
             {
+                "batch_processing": batch_processing,
                 "sim_name": sim_name,
                 "sim_template_id": sim_template_id,
             },

luminarycloud/project.py

@@ -25,6 +25,10 @@ from ._helpers import (
     upload_file,
     upload_mesh,
     upload_table_as_json,
+    create_inference_job,
+    get_inference_job,
+    list_inference_jobs,
+    SurfaceForInference,
 )
 from ._helpers.warnings import deprecated
 from ._proto.api.v0.luminarycloud.geometry import geometry_pb2 as geometrypb
@@ -47,10 +51,20 @@ from ._proto.upload import upload_pb2 as uploadpb
 from ._wrapper import ProtoWrapper, ProtoWrapperBase
 from .enum import GPUType, MeshType, TableType
 from .meshing import MeshAdaptationParams, MeshGenerationParams
+from .named_variable_set import NamedVariableSet, get_named_variable_set
+from .physics_ai.inference import InferenceJob, VisualizationExport
 from .simulation_param import SimulationParam
 from .tables import RectilinearTable, create_rectilinear_table
-from .types import MeshID, ProjectID, SimulationTemplateID, NamedVariableSetID, Expression, LcFloat
-from .named_variable_set import get_named_variable_set
+from .types import (
+    MeshID,
+    ProjectID,
+    SimulationTemplateID,
+    NamedVariableSetID,
+    Expression,
+    LcFloat,
+    PhysicsAiInferenceJobID,
+    PhysicsAiModelVersionID,
+)
 
 if TYPE_CHECKING:
     from .geometry import Geometry
@@ -485,15 +499,14 @@ class Project(ProtoWrapperBase):
         description : str, optional
             Simulation description.
         batch_processing : bool, default True
-            If True, batch processing will be used for this
-            simulation.
-            Use Batch Processing on simulations that are not time-sensitive to
-            save up to 65% in credits.
+            If True, this simulation will run as a standard job. If False, this simulation will run
+            as a priority job.
         gpu_type : GPUType, optional
             GPU type to use for the simulation.
         gpu_count : int, optional
-            Number of GPUs to use for the simulation. Must be specified to a
-            positive value if `gpu_type` is specified.
+            Number of GPUs to use for the simulation. Only relevant if `gpu_type` is
+            specified. If this is set to 0 or omitted and `gpu_type` is specified, the number
+            of gpus will be automatically determined.
         """
 
         named_variable_set_version_id: Optional[str] = None
@@ -702,6 +715,46 @@ class Project(ProtoWrapperBase):
         req = projectpb.UnshareProjectWithSupportRequest(id=self.id)
         get_default_client().UnshareProjectWithSupport(req)
 
+    def create_inference_job(
+        self,
+        geometry: str,
+        model_version_id: PhysicsAiModelVersionID,
+        synchronous: bool = False,
+        conditions: Optional[Dict[str, Any]] = None,
+        settings: Optional[Dict[str, Any]] = None,
+        surfaces: Optional[list[SurfaceForInference]] = None,
+        inference_fields: Optional[list[str]] = None,
+        per_surface_visualizations: Optional[list[VisualizationExport]] = None,
+        merged_visualizations: Optional[list[VisualizationExport]] = None,
+    ) -> InferenceJob:
+        """
+        Create a new Physics AI inference job.
+        """
+        return create_inference_job(
+            self.id,
+            geometry,
+            model_version_id,
+            synchronous,
+            conditions,
+            settings,
+            surfaces,
+            inference_fields,
+            per_surface_visualizations,
+            merged_visualizations,
+        )
+
+    def get_inference_job(self, job_id: PhysicsAiInferenceJobID) -> InferenceJob:
+        """
+        Get a Physics AI inference job by its ID.
+        """
+        return get_inference_job(job_id)
+
+    def list_inference_jobs(self) -> list[InferenceJob]:
+        """
+        List all inference jobs for the project.
+        """
+        return list_inference_jobs(self.id)
+
 
 def add_named_variables_from_csv(project: Project, csv_path: str) -> list[NamedVariableSet]:
     """

luminarycloud/simulation.py

@@ -22,6 +22,7 @@ from .enum import (
     SimulationStatus,
     Vector3Component,
 )
+from .outputs.stopping_conditions import StoppingConditionStatusResult
 from .simulation_param import SimulationParam
 from .reference_values import ReferenceValues
 from .simulation_param import SimulationParam
@@ -324,6 +325,30 @@ class Simulation(ProtoWrapperBase):
         result = _get_workflow_ids([self.id])
         return result.get(self.id)
 
+    def get_stopping_condition_status(self) -> StoppingConditionStatusResult:
+        """
+        Retrieves the stopping condition status for a completed simulation.
+
+        This evaluates the stopping conditions defined in the simulation parameters
+        against the final simulation results to determine which conditions were satisfied.
+
+        Returns
+        -------
+        StoppingConditionStatusResult
+            The stopping condition status containing:
+            - overall_success: Whether the overall stopping criteria were met
+            - force_stopped: Whether a force-stop condition was triggered
+            - condition_results: Results for each individual condition (output name, threshold, value, satisfied)
+
+        Raises
+        ------
+        SDKException
+            If the simulation has not completed or the status cannot be retrieved.
+        """
+        req = simulationpb.GetStoppingConditionStatusRequest(id=self.id)
+        res = get_default_client().GetStoppingConditionStatus(req)
+        return StoppingConditionStatusResult._from_proto(res)
+
     @deprecated(
         "Use get_parameters() instead. This method will be removed in a future release.",
     )

luminarycloud/types/__init__.py

@@ -7,6 +7,8 @@ from .ids import (
     SimulationTemplateID as SimulationTemplateID,
     GeometryFeatureID as GeometryFeatureID,
     NamedVariableSetID as NamedVariableSetID,
+    PhysicsAiInferenceJobID as PhysicsAiInferenceJobID,
+    PhysicsAiModelVersionID as PhysicsAiModelVersionID,
 )
 
 from .adfloat import (

luminarycloud/types/ids.py

@@ -11,5 +11,7 @@ GeometryFeatureID = NewType("GeometryFeatureID", str)
 NamedVariableSetID = NewType("NamedVariableSetID", str)
 PhysicsAiArchitectureID = NewType("PhysicsAiArchitectureID", str)
 PhysicsAiArchitectureVersionID = NewType("PhysicsAiArchitectureVersionID", str)
+PhysicsAiInferenceJobID = NewType("PhysicsAiInferenceJobID", str)
 PhysicsAiModelID = NewType("PhysicsAiModelID", str)
 PhysicsAiModelVersionID = NewType("PhysicsAiModelVersionID", str)
+PhysicsAiTrainingJobID = NewType("PhysicsAiTrainingJobID", str)

luminarycloud/types/vector3.py

@@ -8,11 +8,10 @@ from .adfloat import (
     _to_ad_proto as _float_to_ad_proto,
     _from_ad_proto as _float_from_ad_proto,
 )
-from ..pipeline_util.dictable import PipelineDictable
 
 
 @dataclass
-class Vector3(PipelineDictable):
+class Vector3:
     """Represents a 3-dimensional vector.
 
     Supports direct component access, indexing, iteration, and conversion to numpy arrays.

luminarycloud/vis/__init__.py

@@ -22,6 +22,7 @@ from .primitives import (
 
 from .filters import (
     Slice as Slice,
+    MultiSlice as MultiSlice,
     PlaneClip as PlaneClip,
     BoxClip as BoxClip,
     FixedSizeVectorGlyphs as FixedSizeVectorGlyphs,

luminarycloud/vis/data_extraction.py

@@ -602,7 +602,7 @@ class DataExtractor:
         code += f"    if sol.id == '{self._solution.id}':\n"
         code += f"        solution = sol\n"
         code += f"        break\n"
-        code += "data_extractor = vis.DataExtractor(solution)\n"
+        code += f"{obj_name} = vis.DataExtractor(solution)\n"
         code += "\n"
 
         code += "\n"
@@ -615,11 +615,11 @@ class DataExtractor:
         for extract in self._extracts:
             # Name objects numerically: slice0, slice1, etc.
             name = _data_extract_to_obj_name(extract)
-            obj_name = f"{name}{name_map[obj_name]}"
-            name_map[obj_name] += 1
-            ids_to_obj_name[extract.id] = obj_name
-            code += extract._to_code_helper(obj_name, hide_defaults=hide_defaults)
-            code += f"data_extractor.add_data_extract({obj_name})\n"
+            extract_obj_name = f"{name}{name_map[name]}"
+            name_map[name] += 1
+            ids_to_obj_name[extract.id] = extract_obj_name
+            code += extract._to_code_helper(extract_obj_name, hide_defaults=hide_defaults)
+            code += f"{obj_name}.add_data_extract({extract_obj_name})\n"
             code += "\n"
 
         if include_imports:
@@ -649,7 +649,7 @@ class DataExtractor:
         code = "\n".join(filtered_lines)
 
         code += "\n"
-        code += "extract_output = extractor.create_extracts(name='extract data', description='lonerg description')\n"
+        code += f"extract_output = {obj_name}.create_extracts(name='extract data', description='longer description')\n"
         code += "status = extract_output.wait()\n"
         code += "if status == ExtractStatusType.COMPLETED:\n"
         code += "    extract_output.save_files('data_extracts_prefix', True)\n"