luminarycloud 0.17.0__py3-none-any.whl → 0.18.1__py3-none-any.whl

luminarycloud/pipelines/api.py

@@ -0,0 +1,213 @@
+# Copyright 2023-2024 Luminary Cloud, Inc. All Rights Reserved.
+from dataclasses import dataclass
+
+from datetime import datetime
+
+from luminarycloud._helpers import timestamp_to_datetime
+
+from ..enum.pipeline_job_status import PipelineJobStatus
+from ..pipelines import Pipeline, PipelineArgs
+from .._client import get_default_client
+from .._proto.api.v0.luminarycloud.pipelines import pipelines_pb2 as pipelinespb
+
+
+@dataclass
+class PipelineRecord:
+    id: str
+    name: str
+    description: str | None
+    definition_yaml: str
+    create_time: datetime
+    update_time: datetime
+
+    def pipeline(self) -> Pipeline:
+        return Pipeline._from_yaml(self.definition_yaml)
+
+    @classmethod
+    def from_proto(cls, proto: pipelinespb.Pipeline) -> "PipelineRecord":
+        return cls(
+            id=proto.id,
+            name=proto.name,
+            description=proto.description,
+            definition_yaml=proto.definition_yaml,
+            create_time=timestamp_to_datetime(proto.created_at),
+            update_time=timestamp_to_datetime(proto.updated_at),
+        )
+
+
+@dataclass
+class PipelineJobRecord:
+    id: str
+    pipeline_id: str
+    project_id: str
+    name: str
+    description: str | None
+    status: PipelineJobStatus
+    create_time: datetime
+    update_time: datetime
+    started_at: datetime | None
+    completed_at: datetime | None
+
+    @classmethod
+    def from_proto(cls, proto: pipelinespb.PipelineJob) -> "PipelineJobRecord":
+        return cls(
+            id=proto.id,
+            pipeline_id=proto.pipeline_id,
+            project_id=proto.project_id,
+            name=proto.name,
+            description=proto.description,
+            status=PipelineJobStatus(proto.status),
+            create_time=timestamp_to_datetime(proto.created_at),
+            update_time=timestamp_to_datetime(proto.updated_at),
+            started_at=(
+                timestamp_to_datetime(proto.started_at) if proto.HasField("started_at") else None
+            ),
+            completed_at=(
+                timestamp_to_datetime(proto.completed_at)
+                if proto.HasField("completed_at")
+                else None
+            ),
+        )
+
+
+def create_pipeline(
+    name: str, pipeline: Pipeline | str, description: str | None = None
+) -> PipelineRecord:
+    """
+    Create a new pipeline.
+
+    Parameters
+    ----------
+    name : str
+        Name of the pipeline.
+    pipeline : Pipeline | str
+        The pipeline to create. Accepts a Pipeline object or a YAML-formatted pipeline definition.
+    description : str, optional
+        Description of the pipeline.
+    """
+    if isinstance(pipeline, Pipeline):
+        definition_yaml = pipeline.to_yaml()
+    else:
+        definition_yaml = pipeline
+    req = pipelinespb.CreatePipelineRequest(
+        name=name, definition_yaml=definition_yaml, description=description
+    )
+    res: pipelinespb.CreatePipelineResponse = get_default_client().CreatePipeline(req)
+    return PipelineRecord.from_proto(res.pipeline)
+
+
+def list_pipelines() -> list[PipelineRecord]:
+    """
+    List all pipelines.
+    """
+    req = pipelinespb.ListPipelinesRequest()
+    res: pipelinespb.ListPipelinesResponse = get_default_client().ListPipelines(req)
+    return [PipelineRecord.from_proto(p) for p in res.pipelines]
+
+
+def get_pipeline(id: str) -> PipelineRecord:
+    """
+    Get a pipeline by ID.
+
+    Parameters
+    ----------
+    id : str
+        ID of the pipeline to fetch.
+    """
+    req = pipelinespb.GetPipelineRequest(id=id)
+    res: pipelinespb.GetPipelineResponse = get_default_client().GetPipeline(req)
+    return PipelineRecord.from_proto(res.pipeline)
+
+
+def create_pipeline_job(
+    pipeline_id: str, args: PipelineArgs, project_id: str, name: str, description: str | None = None
+) -> PipelineJobRecord:
+    """
+    Create a new pipeline job.
+
+    Parameters
+    ----------
+    pipeline_id : str
+        ID of the pipeline to invoke.
+    args : PipelineArgs
+        Arguments to pass to the pipeline.
+    project_id : str
+        ID of the project to run the pipeline job in.
+    name : str
+        Name of the pipeline job.
+    description : str, optional
+        Description of the pipeline job.
+    """
+
+    col_values = [[] for _ in args.params]
+    for row in args.rows:
+        for i, v in enumerate(row.row_values):
+            col_values[i].append(v)
+
+    cols = []
+
+    for i, param in enumerate(args.params):
+        if param._represented_type() == str:
+            cols.append(
+                pipelinespb.PipelineJobArgsColumn(
+                    string_column=pipelinespb.PipelineJobArgsColumn.StringColumn(
+                        name=param.name,
+                        values=col_values[i],
+                    )
+                )
+            )
+        elif param._represented_type() == int:
+            cols.append(
+                pipelinespb.PipelineJobArgsColumn(
+                    int_column=pipelinespb.PipelineJobArgsColumn.IntColumn(
+                        name=param.name,
+                        values=col_values[i],
+                    )
+                )
+            )
+        elif param._represented_type() == float:
+            cols.append(
+                pipelinespb.PipelineJobArgsColumn(
+                    double_column=pipelinespb.PipelineJobArgsColumn.DoubleColumn(
+                        name=param.name,
+                        values=col_values[i],
+                    )
+                )
+            )
+        elif param._represented_type() == bool:
+            cols.append(
+                pipelinespb.PipelineJobArgsColumn(
+                    bool_column=pipelinespb.PipelineJobArgsColumn.BoolColumn(
+                        name=param.name,
+                        values=col_values[i],
+                    )
+                )
+            )
+
+    req = pipelinespb.CreatePipelineJobRequest(
+        pipeline_id=pipeline_id,
+        args_columns=cols,
+        name=name,
+        description=description,
+        project_id=project_id,
+    )
+    res: pipelinespb.CreatePipelineJobResponse = get_default_client().CreatePipelineJob(req)
+    return PipelineJobRecord.from_proto(res.pipeline_job)
+
+
+def get_pipeline_job(id: str) -> PipelineJobRecord:
+    """
+    Get a pipeline job by ID.
+    """
+    req = pipelinespb.GetPipelineJobRequest(id=id)
+    res: pipelinespb.GetPipelineJobResponse = get_default_client().GetPipelineJob(req)
+    return PipelineJobRecord.from_proto(res.pipeline_job)
+
+
+def list_pipeline_jobs() -> list[PipelineJobRecord]:
+    """
+    List all pipeline jobs.
+    """
+    req = pipelinespb.ListPipelineJobsRequest()
+    res: pipelinespb.ListPipelineJobsResponse = get_default_client().ListPipelineJobs(req)
+    return [PipelineJobRecord.from_proto(p) for p in res.pipeline_jobs]

luminarycloud/pipelines/operators.py

@@ -124,8 +124,8 @@ class Mesh(Operator[MeshOutputs]):
 
     Parameters
     ----------
-    max_cv_count : int
-        The maximum number of control volumes to generate.
+    target_cv_count : int | None
+        The target number of control volumes to generate. If None, a minimal mesh will be generated.
     geometry : PipelineOutputGeometry
         The Geometry to mesh.
 
@@ -141,12 +141,12 @@ class Mesh(Operator[MeshOutputs]):
         self,
         *,
         task_name: str | None = None,
-        max_cv_count: int,
+        target_cv_count: int | None,
         geometry: PipelineOutputGeometry,
     ):
         super().__init__(
             task_name,
-            {"max_cv_count": max_cv_count},
+            {"target_cv_count": target_cv_count},
             OperatorInputs(self, geometry=(PipelineOutputGeometry, geometry)),
             MeshOutputs._instantiate_for(self),
         )

luminarycloud/project.py

@@ -6,7 +6,7 @@ import re
 import uuid
 from datetime import datetime
 from os import PathLike, path
-from typing import TYPE_CHECKING, Any, Dict, Optional, Union
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union, Literal
 
 import concurrent
 
@@ -121,22 +121,22 @@ class Project(ProtoWrapperBase):
 
     def create_geometry(
         self,
-        cad_file_path: PathLike | str,
+        cad_file_path: PathLike | str | List[PathLike | str],
         *,
         name: Optional[str] = None,
         scaling: Optional[float] = None,
         wait: bool = False,
     ) -> "Geometry":
         """
-        Create a new geometry in the project by uploading a supported CAD file.
+        Create a new geometry in the project by uploading supported CAD file(s).
 
         For more information on supported formats and best practices, see:
         https://docs.luminarycloud.com/en/articles/9274255-upload-cad
 
         Parameters
         ----------
-        cad_file_path : PathLike or str
-            Path or URL to the CAD file to upload.
+        cad_file_path : PathLike | str | List[PathLike | str]
+            Path(s) or URL to the CAD file(s) to upload.
 
         Other Parameters
         ----------------
@@ -662,6 +662,66 @@ class Project(ProtoWrapperBase):
             return None
         return get_named_variable_set(NamedVariableSetID(res.active_named_variable_set_id))
 
+    def share(self, email: str, role: Literal["viewer", "editor"]) -> None:
+        """
+        Share the project with a user identified by their email address. This function also allows
+        changing the role of the user in the project if the project has already been shared with
+        the input user.
+
+        Parameters
+        ----------
+        email : str
+            Email address of the user to share the project with. It must be an email whose domain
+            is registered within the allowed domains settings of your company account.
+        role : Literal["viewer", "editor"]
+            The role to assign to the user in the project. Must be either "viewer" or "editor".
+        """
+        if not re.match(r"[^@]+@[^@]+\.[^@]+", email):
+            raise ValueError(f"Invalid email address: {email}")
+        if role not in ["viewer", "editor"]:
+            raise ValueError(f"Invalid role: {role}. Must be 'viewer' or 'editor'.")
+        roleModel = (
+            projectpb.ShareProjectRequest.USER_ROLE_VIEWER
+            if role == "viewer"
+            else projectpb.ShareProjectRequest.USER_ROLE_EDITOR
+        )
+        req = projectpb.ShareProjectRequest(id=self.id, email=email, role=roleModel)
+        get_default_client().ShareProject(req)
+
+    def unshare(self, email: str) -> None:
+        """
+        Unshare the project with a user identified by their email address.
+
+        Parameters
+        ----------
+        email : str
+            Email address of the user to unshare the project with. It must be an email whose domain
+            must be registered within the allowed domains settings of your company account.
+        """
+        if not re.match(r"[^@]+@[^@]+\.[^@]+", email):
+            raise ValueError(f"Invalid email address: {email}")
+        req = projectpb.UnshareProjectRequest(id=self.id, email=email)
+        get_default_client().UnshareProject(req)
+
+    def share_with_support(self, message: str = "") -> None:
+        """
+        Share the project with Luminary Cloud support.
+
+        Parameters
+        ----------
+        message : str, optional
+            Message to include with the support share request.
+        """
+        req = projectpb.ShareProjectWithSupportRequest(id=self.id, message=message)
+        get_default_client().ShareProjectWithSupport(req)
+
+    def unshare_with_support(self) -> None:
+        """
+        Unshare the project with Luminary Cloud support.
+        """
+        req = projectpb.UnshareProjectWithSupportRequest(id=self.id)
+        get_default_client().UnshareProjectWithSupport(req)
+
 
 def add_named_variables_from_csv(project: Project, csv_path: str) -> list[NamedVariableSet]:
     """
@@ -838,6 +898,6 @@ def iterate_projects(page_size: int = 50) -> ProjectIterator:
     Project(...)
     >>> next(my_projects) # second page of projects is fetched, third project is returned
     Project(...)
-    >>> next(my_projects) # if there areno more projects, this call raises StopIteration
+    >>> next(my_projects) # if there are no more projects, this call raises StopIteration
     """
     return ProjectIterator(page_size)

luminarycloud/simulation.py

@@ -18,6 +18,7 @@ from .enum import (
     CalculationType,
     QuantityType,
     ResidualNormalization,
+    MomentConventionType,
     SimulationStatus,
     Vector3Component,
 )
@@ -188,6 +189,7 @@ class Simulation(ProtoWrapperBase):
         moment_center: Optional[Vector3Like] = None,
         averaging_type: AveragingType = AveragingType.UNSPECIFIED,
         vector_component: Vector3Component = Vector3Component.UNSPECIFIED,
+        moment_convention_type: MomentConventionType = MomentConventionType.BODY_FRAME,
     ) -> _DownloadedTextFile:
         """
         Downloads surface outputs (e.g. lift, drag, ...) in csv format.
@@ -224,6 +226,9 @@ class Simulation(ProtoWrapperBase):
         vector_component : Vector3Component, optional
             For 3-vector quantity types (e.g. `QuantityType.VELOCITY`), the component of the vector to extract.
             Ignored for scalar quantity types.
+        moment_convention_type : MomentConventionType, optional
+            The frame type to use for "aerodynamic moment" quantity types.
+            Ignored for non-moment quantity types.
 
         Returns
         -------
@@ -261,6 +266,7 @@ class Simulation(ProtoWrapperBase):
             moment_center=_to_vector3_proto(moment_center) if moment_center else None,
             averaging_type=averaging_type.value,
             vector_component=vector_component.value,
+            moment_convention_type=moment_convention_type.value,
         )
         res = get_default_client().GetSimulationSurfaceQuantityOutput(req)
         return _DownloadedTextFile(res.csv_file)

luminarycloud/simulation_param.py

@@ -14,7 +14,7 @@ from luminarycloud._proto.client import simulation_pb2 as clientpb
 from luminarycloud._proto.client.entity_pb2 import EntityIdentifier
 from luminarycloud._proto.output import output_pb2 as outputpb
 from luminarycloud._proto.quantity import quantity_options_pb2 as quantityoptspb
-from luminarycloud.enum import AveragingType, QuantityType, SpaceAveragingType
+from luminarycloud.enum import AveragingType, MomentConventionType, QuantityType, SpaceAveragingType
 from luminarycloud.params.geometry import Volume
 from luminarycloud.params.simulation import (
     EntityRelationships,
@@ -265,6 +265,7 @@ class SimulationParam(_SimulationParam):
         frame_id: str = "",
         force_direction: Optional[Vector3Like] = None,
         moment_center: Optional[Vector3Like] = None,
+        moment_convention_type: MomentConventionType = MomentConventionType.BODY_FRAME,
         averaging_type: AveragingType = AveragingType.UNSPECIFIED,
     ) -> None:
         """
@@ -303,6 +304,7 @@ class SimulationParam(_SimulationParam):
                         _to_vector3_ad_proto(force_direction) if force_direction else None
                     ),
                     moment_center=_to_vector3_ad_proto(moment_center) if moment_center else None,
+                    moment_convention_type=moment_convention_type.value,
                 )
             )
         else:
@@ -329,7 +331,7 @@ class SimulationParam(_SimulationParam):
 ## code that creates (from scratch) an identical object. As such, some parts do
 ## not match 1 to 1 with hand-written examples.
 import luminarycloud
-from luminarycloud.types import Vector3
+from luminarycloud.types import Vector3, Expression
 from luminarycloud.tables import RectilinearTable
 from luminarycloud.enum import *
 from luminarycloud.params.enum import *

luminarycloud/simulation_queue.py

@@ -0,0 +1,130 @@
+# Copyright 2025 Luminary Cloud, Inc. All Rights Reserved.
+
+"""Simulation queue management functionality."""
+
+from datetime import datetime
+from typing import Optional
+
+from ._client import get_default_client
+from ._helpers._timestamp_to_datetime import timestamp_to_datetime
+from ._proto.api.v0.luminarycloud.simulation import simulation_pb2 as simulationpb
+from ._wrapper import ProtoWrapper, ProtoWrapperBase
+from .types import ProjectID, SimulationID
+
+
+@ProtoWrapper(simulationpb.SimulationQueueStatus)
+class SimulationQueueStatus(ProtoWrapperBase):
+    """Represents the status of a queued simulation."""
+
+    project_id: ProjectID
+    """The ID of the project to which the simulation belongs."""
+    simulation_id: SimulationID
+    """The ID of the simulation."""
+    name: str
+    """The name of the simulation."""
+    is_lma: bool
+    """Whether this is an LMA simulation."""
+    priority: bool
+    """Whether this is a priority simulation."""
+
+    _proto: simulationpb.SimulationQueueStatus
+
+    @property
+    def creation_time(self) -> datetime:
+        """The time when the simulation was created."""
+        return timestamp_to_datetime(self._proto.creation_time)
+
+    @property
+    def started_time(self) -> Optional[datetime]:
+        """The time when the simulation started running, if it has started."""
+        if self._proto.HasField("started_time"):
+            return timestamp_to_datetime(self._proto.started_time)
+        return None
+
+
+class SimulationStatusQueueIterator:
+    """Iterator class for simulation status queue 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[simulationpb.SimulationQueueStatus]] = None
+        self._client = get_default_client()
+        self._iterated_count: int = 0
+
+    def __iter__(self) -> "SimulationStatusQueueIterator":
+        return self
+
+    def __next__(self) -> SimulationQueueStatus:
+        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 SimulationQueueStatus(self._current_page.pop(0))
+
+    def _fetch_next_page(self) -> None:
+        req = simulationpb.ListQueuedSimulationsRequest(
+            page_size=self._page_size, page_token=self._page_token
+        )
+        res = self._client.ListQueuedSimulations(req)
+
+        self._current_page = list(res.simulations)
+        self._page_token = res.next_page_token
+        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)
+
+
+def iterate_simulation_status_queue(page_size: int = 50) -> SimulationStatusQueueIterator:
+    """
+    Iterate over all simulations in the scheduling queue for the current account.
+
+    This function is only available for accounts with a Subscription Plan.
+
+    Parameters
+    ----------
+    page_size : int, optional
+        Number of simulations to fetch per page. Defaults to 50, max is 100.
+
+    Returns
+    -------
+    SimulationStatusQueueIterator
+        An iterator that yields SimulationQueueStatus objects one at a time.
+
+    Examples
+    --------
+    Fetch all queued simulations and filter them for LMA simulations.
+
+    >>> lma_sims = [sim for sim in iterate_simulation_status_queue() if sim.is_lma]
+    [SimulationQueueStatus(...), SimulationQueueStatus(...)]
+
+    Lazily fetch simulations.
+    (A batch size of 2 is a bad idea in real-world usage, but it helps demonstrate the lazy
+    fetching.)
+
+    >>> my_sims = iterate_simulation_status_queue(page_size=2)
+    >>> next(my_sims) # first page of simulations is fetched, first simulation is returned.
+    SimulationQueueStatus(...)
+    >>> next(my_sims) # second simulation is returned from memory.
+    SimulationQueueStatus(...)
+    >>> next(my_sims) # second page of simulations is fetched, third simulation is returned.
+    SimulationQueueStatus(...)
+    >>> next(my_sims) # if there are no more simulations, this call raises StopIteration.
+    """
+    return SimulationStatusQueueIterator(page_size)

luminarycloud/simulation_template.py

@@ -17,7 +17,7 @@ from ._proto.api.v0.luminarycloud.simulation_template import (
 )
 from ._proto.client import simulation_pb2 as clientpb
 from ._wrapper import ProtoWrapper, ProtoWrapperBase
-from .types import SimulationTemplateID
+from .types import SimulationTemplateID, ProjectID
 from .tables import RectilinearTable
 from .simulation_param import SimulationParam
 from .outputs import (
@@ -59,7 +59,9 @@ class SimulationTemplate(ProtoWrapperBase):
     id: SimulationTemplateID
     "Simulation template ID."
     name: str
-    "Simulation name."
+    "Simulation template name."
+    project_id: ProjectID
+    "Project this simulation template belongs to."
 
     _proto: simtemplatepb.SimulationTemplate
 
@@ -71,6 +73,13 @@ class SimulationTemplate(ProtoWrapperBase):
     def update_time(self) -> datetime:
         return timestamp_to_datetime(self._proto.update_time)
 
+    def sync_to_ui(self) -> None:
+        """
+        Sets this simulation template as the one that is used for the "Setup" tab in the UI.
+        """
+        req = simtemplatepb.SyncSimulationTemplateToUIRequest(id=self.id)
+        get_default_client().SyncSimulationTemplateToUI(req)
+
     def update(
         self,
         *,
@@ -480,10 +489,10 @@ class SimulationTemplate(ProtoWrapperBase):
         code = code.replace("SimulationParam", "SimulationTemplate")
         code += "\n\n\n"
         code += '# Create a new simulation template or modify the one that is synced with the UI "Setup" tab.\n'
-        code += "# TODO(USER): Replace ... with project ID, or create a project.\n"
-        code += 'project = luminarycloud.get_project("...")\n'
-        code += f"# template = project.create_simulation_template(name={self.name})\n"
-        code += "template = project.list_simulation_templates()[0] # Setup template\n\n"
+        code += f'project = luminarycloud.get_project("{self.project_id}")\n'
+        code += f"template = project.create_simulation_template(name={self.name})\n"
+        code += '# TODO(USER): To modify the "Setup" template, uncomment the line below and comment out the line above.\n'
+        code += "# template = project.list_simulation_templates()[0] # Setup template\n\n"
 
         if parameters._table_references:
             code += "# Upload tabular data.\n"
@@ -509,6 +518,11 @@ class SimulationTemplate(ProtoWrapperBase):
         for i, definition in enumerate(output_definitions):
             if i == 0:
                 code += "output_list = []\n"
+            if isinstance(definition, DerivedOutputDefinition):
+                code += "# WARNING: Output {i} - Custom outputs are not yet supported in the SDK.\n"
+                # This is to make the stopping condition ID logic work.
+                code += "output_list.append(None)\n\n"
+                continue
             output_code = definition._to_code_helper("new_output", hide_defaults)
             for line in output_code.split("\n"):
                 # Omit ID because we are generating for create_output_definition.
@@ -526,7 +540,7 @@ class SimulationTemplate(ProtoWrapperBase):
                 code += "\n# Output-based conditions require the ID of the associated output.\n"
             # Find the old output to use the new ID created by create_output_definition.
             for j, od in enumerate(output_definitions):
-                if sc.output_definition_id == od.id:
+                if sc.output_definition_id == od.id and not isinstance(od, DerivedOutputDefinition):
                     code += f"template.create_or_update_stopping_condition(output_list[{j}].id, "
                     code += f"{sc.threshold}, {sc.start_at_iteration}, {sc.averaging_iterations}, "
                     code += f"{sc.iterations_to_consider})\n"

luminarycloud/types/adfloat.py

@@ -145,6 +145,9 @@ class Expression:
             return False
         return self._value == other._value and self._expression == other._expression
 
+    def _to_code(self, *args) -> str:
+        return f"Expression({self._expression.__repr__()})"
+
 
 LcFloat = Union[float, FirstOrderAdFloat, SecondOrderAdFloat, Expression]
 

luminarycloud/vis/__init__.py

@@ -48,3 +48,7 @@ from .display import (
 from .interactive_scene import (
     InteractiveScene as InteractiveScene,
 )
+
+from .interactive_inference import (
+    InteractiveInference as InteractiveInference,
+)