luminarycloud 0.22.1__py3-none-any.whl → 0.22.3__py3-none-any.whl

luminarycloud/pipelines/flowables.py

@@ -0,0 +1,138 @@
+from __future__ import annotations
+
+from abc import ABC
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import TYPE_CHECKING, Type, Mapping
+
+if TYPE_CHECKING:
+    from .core import Stage
+
+
+class PipelineInput:
+    """
+    A named input for a Stage. Explicitly connected to a PipelineOutput.
+    """
+
+    def __init__(self, upstream_output: "PipelineOutput", owner: "Stage", name: str):
+        self.upstream_output = upstream_output
+        self.owner = owner
+        self.name = name
+
+    def _to_dict(self, id_for_stage: dict) -> dict:
+        if self.upstream_output.owner not in id_for_stage:
+            raise ValueError(
+                f"Stage {self.owner} depends on a stage, {self.upstream_output.owner}, that isn't in the Pipeline. Did you forget to add it?"
+            )
+        upstream_stage_id = id_for_stage[self.upstream_output.owner]
+        upstream_output_name = self.upstream_output.name
+        return {self.name: f"{upstream_stage_id}.{upstream_output_name}"}
+
+
+class PipelineOutput(ABC):
+    """
+    A named output for a Stage. Can be used to spawn any number of connected PipelineInputs.
+    """
+
+    def __init__(self, owner: "Stage", name: str):
+        self.owner = owner
+        self.name = name
+        self.downstream_inputs: list[PipelineInput] = []
+
+    def _spawn_input(self, owner: "Stage", name: str) -> PipelineInput:
+        input = PipelineInput(self, owner, name)
+        self.downstream_inputs.append(input)
+        return input
+
+
+# Concrete PipelineOutput classes, i.e. the things that can "flow" in a Pipeline
+
+
+class PipelineOutputGeometry(PipelineOutput):
+    """A representation of a Geometry in a Pipeline."""
+
+    pass
+
+
+class PipelineOutputMesh(PipelineOutput):
+    """A representation of a Mesh in a Pipeline."""
+
+    pass
+
+
+class PipelineOutputSimulation(PipelineOutput):
+    """A representation of a Simulation in a Pipeline."""
+
+    pass
+
+
+# We don't inherit from StrEnum because that was added in Python 3.11, but we still want to support
+# older versions. Inheriting from str and Enum gives us the StrEnum-like behavior we want.
+class FlowableType(str, Enum):
+    """Canonical flowable type identifiers."""
+
+    GEOMETRY = "Geometry"
+    MESH = "Mesh"
+    SIMULATION = "Simulation"
+
+    def __str__(self) -> str:
+        return self.value
+
+
+_FLOWABLE_NAME_TO_CLASS: dict[FlowableType, Type[PipelineOutput]] = {
+    FlowableType.GEOMETRY: PipelineOutputGeometry,
+    FlowableType.MESH: PipelineOutputMesh,
+    FlowableType.SIMULATION: PipelineOutputSimulation,
+}
+
+
+def flowable_class_to_name(output_cls: Type[PipelineOutput]) -> FlowableType:
+    """
+    Convert a PipelineOutput subclass to the canonical flowable type name used in pipeline YAML.
+    """
+    for flowable_type, cls in _FLOWABLE_NAME_TO_CLASS.items():
+        if issubclass(output_cls, cls):
+            return flowable_type
+    raise ValueError(f"Unsupported PipelineOutput subclass: {output_cls.__name__}")
+
+
+def flowable_name_to_class(name: str | FlowableType) -> Type[PipelineOutput]:
+    """
+    Convert a canonical flowable type name into the corresponding PipelineOutput subclass.
+    """
+    try:
+        flowable_type = FlowableType(name)
+    except ValueError as exc:
+        supported = ", ".join(ft.value for ft in FlowableType)
+        raise ValueError(
+            f"Unknown flowable type '{name}'. Supported types are: {supported}"
+        ) from exc
+    return _FLOWABLE_NAME_TO_CLASS[flowable_type]
+
+
+def _ensure_flowable_mapping(data: Mapping[str, FlowableType | str]) -> dict[str, FlowableType]:
+    mapping: dict[str, FlowableType] = {}
+    for name, value in data.items():
+        mapping[name] = value if isinstance(value, FlowableType) else FlowableType(value)
+    return mapping
+
+
+@dataclass(slots=True)
+class FlowableIOSchema:
+    """Typed representation of RunScript input/output schema."""
+
+    inputs: dict[str, FlowableType] = field(default_factory=dict)
+    outputs: dict[str, FlowableType] = field(default_factory=dict)
+
+    @classmethod
+    def from_dict(cls, data: Mapping[str, Mapping[str, FlowableType | str]]) -> "FlowableIOSchema":
+        return cls(
+            inputs=_ensure_flowable_mapping(data["inputs"]),
+            outputs=_ensure_flowable_mapping(data["outputs"]),
+        )
+
+    def to_dict(self) -> dict[str, dict[str, str]]:
+        return {
+            "inputs": {name: flowable.value for name, flowable in self.inputs.items()},
+            "outputs": {name: flowable.value for name, flowable in self.outputs.items()},
+        }

luminarycloud/pipelines/stages.py

@@ -1,33 +1,9 @@
 # Copyright 2025 Luminary Cloud, Inc. All Rights Reserved.
 from dataclasses import dataclass
 
-from .core import Stage, StageInputs, StageOutputs, PipelineOutput
+from .core import StandardStage, StageInputs, StageOutputs
+from .flowables import PipelineOutputGeometry, PipelineOutputMesh, PipelineOutputSimulation
 from .parameters import BoolPipelineParameter, StringPipelineParameter, IntPipelineParameter
-from ..meshing import MeshGenerationParams
-
-
-# Concrete PipelineOutput classes, i.e. the things that can "flow" in a Pipeline
-
-
-class PipelineOutputGeometry(PipelineOutput):
-    """A representation of a Geometry in a Pipeline."""
-
-    pass
-
-
-class PipelineOutputMesh(PipelineOutput):
-    """A representation of a Mesh in a Pipeline."""
-
-    pass
-
-
-class PipelineOutputSimulation(PipelineOutput):
-    """A representation of a Simulation in a Pipeline."""
-
-    pass
-
-
-# Stages
 
 
 @dataclass
@@ -39,7 +15,7 @@ class ReadGeometryOutputs(StageOutputs):
     """
 
 
-class ReadGeometry(Stage[ReadGeometryOutputs]):
+class ReadGeometry(StandardStage[ReadGeometryOutputs]):
     """
     Reads a Geometry into the Pipeline.
 
@@ -93,7 +69,7 @@ class ReadMeshOutputs(StageOutputs):
     """
 
 
-class ReadMesh(Stage[ReadMeshOutputs]):
+class ReadMesh(StandardStage[ReadMeshOutputs]):
     """
     Reads a Mesh into the Pipeline.
 
@@ -137,7 +113,7 @@ class ModifyGeometryOutputs(StageOutputs):
 
 
 # TODO: figure out what `mods` actually is. What does the non-pipeline geo mod interface look like?
-class ModifyGeometry(Stage[ModifyGeometryOutputs]):
+class ModifyGeometry(StandardStage[ModifyGeometryOutputs]):
     """
     Modifies a Geometry.
 
@@ -178,7 +154,7 @@ class MeshOutputs(StageOutputs):
     """The Mesh generated from the given Geometry."""
 
 
-class Mesh(Stage[MeshOutputs]):
+class Mesh(StandardStage[MeshOutputs]):
     """
     Generates a Mesh from a Geometry.
 
@@ -224,7 +200,7 @@ class SimulateOutputs(StageOutputs):
     """The Simulation."""
 
 
-class Simulate(Stage[SimulateOutputs]):
+class Simulate(StandardStage[SimulateOutputs]):
     """
     Runs a Simulation.
 

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
@@ -701,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/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/filters.py

@@ -139,6 +139,101 @@ class Slice(Filter):
         self.plane._from_proto(filter.slice.plane)
 
 
+class MultiSlice(Filter):
+    """
+    Creates multiple parallel slice planes between two positions.
+    Primarily useful as a convenience wrapper when combined with child filters like Threshold, avoiding manual slice filter loops.
+
+    .. warning:: This feature is experimental and may change or be removed in the future.
+
+    Attributes:
+    -----------
+    start_position : Vector3Like
+        The position of the first slice plane.
+    end_position : Vector3Like
+        The position of the last slice plane.
+    n_slices : int
+        The number of slice planes to create between start and end positions.
+    name : str
+        A user provided name for the filter.
+    project_vectors: bool
+        When true, vector fields will be projected onto the plane of each slice. This is often
+        useful for visualizing vector fields by removing the vector components in the normal
+        direction of the planes. Default: False
+    display_attrs : DisplayAttributes
+        Specifies this filter's appearance.
+    """
+
+    def __init__(self, name: str = "") -> None:
+        super().__init__(generate_id("multi-slice-"))
+        self._start_position: Vector3Like = Vector3(x=0, y=0, z=0)
+        self._end_position: Vector3Like = Vector3(x=1, y=0, z=0)
+        self._n_slices: int = 10
+        self._project_vectors: bool = False
+        self.name = name
+
+    @property
+    def start_position(self) -> Vector3Like:
+        return self._start_position
+
+    @start_position.setter
+    def start_position(self, new_start_position: Vector3Like) -> None:
+        self._start_position = _to_vector3(new_start_position)
+
+    @property
+    def end_position(self) -> Vector3Like:
+        return self._end_position
+
+    @end_position.setter
+    def end_position(self, new_end_position: Vector3Like) -> None:
+        self._end_position = _to_vector3(new_end_position)
+
+    @property
+    def n_slices(self) -> int:
+        return self._n_slices
+
+    @n_slices.setter
+    def n_slices(self, new_n_slices: int) -> None:
+        if not isinstance(new_n_slices, int):
+            raise TypeError(f"Expected 'int', got {type(new_n_slices).__name__}")
+        if new_n_slices < 2:
+            raise ValueError("n_slices must be at least 2")
+        self._n_slices = new_n_slices
+
+    @property
+    def project_vectors(self) -> bool:
+        return self._project_vectors
+
+    @project_vectors.setter
+    def project_vectors(self, new_project_vectors: bool) -> None:
+        if not isinstance(new_project_vectors, bool):
+            raise TypeError(f"Expected 'bool', got {type(new_project_vectors).__name__}")
+        self._project_vectors = new_project_vectors
+
+    def _to_proto(self) -> vis_pb2.Filter:
+        vis_filter = vis_pb2.Filter()
+        vis_filter.id = self.id
+        vis_filter.name = self.name
+        vis_filter.multi_slice.start_position.CopyFrom(_to_vector3(self.start_position)._to_proto())
+        vis_filter.multi_slice.end_position.CopyFrom(_to_vector3(self.end_position)._to_proto())
+        vis_filter.multi_slice.n_slices = self.n_slices
+        vis_filter.multi_slice.project_vectors = self.project_vectors
+        return vis_filter
+
+    def _from_proto(self, filter: vis_pb2.Filter) -> None:
+        typ = filter.WhichOneof("value")
+        if typ != "multi_slice":
+            raise TypeError(f"Expected 'multi_slice', got {typ}")
+        self.id = filter.id
+        self.name = filter.name
+        self.start_position = Vector3()
+        self.start_position._from_proto(filter.multi_slice.start_position)
+        self.end_position = Vector3()
+        self.end_position._from_proto(filter.multi_slice.end_position)
+        self.n_slices = filter.multi_slice.n_slices
+        self.project_vectors = filter.multi_slice.project_vectors
+
+
 class Isosurface(Filter):
     """
     Isosurface is used to evaluate scalar fields at constant values, known as
@@ -1130,6 +1225,8 @@ def _filter_to_obj_name(filter: Filter) -> str:
         raise TypeError(f"Expected 'Filter', got {type(filter).__name__}")
     if isinstance(filter, Slice):
         return "slice"
+    elif isinstance(filter, MultiSlice):
+        return "multi_slice"
     elif isinstance(filter, Isosurface):
         return "isosurface"
     elif isinstance(filter, PlaneClip):

luminarycloud/vis/visualization.py

@@ -38,6 +38,7 @@ from .filters import (
     Filter,
     PlaneClip,
     Slice,
+    MultiSlice,
     SurfaceStreamlines,
     SurfaceLIC,
     Threshold,
@@ -1282,6 +1283,8 @@ def _spec_to_scene(spec: vis_pb2.ExtractSpec) -> Scene:
                 pfilter = PlaneClip("")
         elif typ == "slice":
             pfilter = Slice("")
+        elif typ == "multi_slice":
+            pfilter = MultiSlice("")
         elif typ == "streamlines":
             s_typ = filter.streamlines.WhichOneof("seed_type")
             if s_typ == "surface":

luminarycloud/volume_selection.py

@@ -727,17 +727,17 @@ class VolumeSelection:
 
         params = gpb.Create()
         if isinstance(shape, Sphere):
-            params.sphere.CopyFrom(shape._to_proto())  # type: ignore
+            params.sphere.CopyFrom(shape._to_proto())
         elif isinstance(shape, Cube):
-            params.box.CopyFrom(shape._to_proto())  # type: ignore
+            params.box.CopyFrom(shape._to_proto())
         elif isinstance(shape, Cylinder):
-            params.cylinder.CopyFrom(shape._to_proto())  # type: ignore
+            params.cylinder.CopyFrom(shape._to_proto())
         elif isinstance(shape, Torus):
-            params.torus.CopyFrom(shape._to_proto())  # type: ignore
+            params.torus.CopyFrom(shape._to_proto())
         elif isinstance(shape, Cone):
-            params.cone.CopyFrom(shape._to_proto())  # type: ignore
+            params.cone.CopyFrom(shape._to_proto())
         elif isinstance(shape, HalfSphere):
-            params.half_sphere.CopyFrom(shape._to_proto())  # type: ignore
+            params.half_sphere.CopyFrom(shape._to_proto())
         else:
             raise TypeError(f"Unsupported shape type: {type(shape)}")
         self.__create_feature(

luminarycloud/workflow_utils.py

@@ -0,0 +1,149 @@
+# Copyright 2025 Luminary Cloud, Inc. All Rights Reserved.
+"""Utilities for working with workflows and entity IDs."""
+
+from luminarycloud.simulation import _get_workflow_ids
+from luminarycloud.types import SimulationID, GeometryID
+from luminarycloud._client.client import _get_primary_domain_for_apiserver_domain
+import luminarycloud as lc
+
+
+def get_workflow_url_from_entity(entity_id: str, base_url: str | None = None) -> str:
+    """
+    Get a complete workflow URL from either a geometry ID or simulation ID.
+
+    The base URL is automatically determined from the current client's API domain.
+    For example, if connected to apis.main.int.luminarycloud.com, the URL will use
+    https://main.int.luminarycloud.com.
+
+
+    Parameters
+    ----------
+    entity_id : str
+        Either a geometry ID (starting with 'geo-') or simulation ID (starting with 'sim-')
+    base_url : str, optional
+        Override the base URL for the Luminary Cloud application. If not provided,
+        it will be automatically determined from the client's API domain.
+
+    Returns
+    -------
+    str
+        The complete workflow URL
+
+    Raises
+    ------
+    ValueError
+        If the entity_id is not a valid geometry or simulation ID, or if no simulations
+        are found using the specified geometry ID
+    """
+    # Use the batch function for a single entity
+    urls = get_workflow_urls_from_entities([entity_id], base_url)
+
+    if entity_id not in urls:
+        if entity_id.startswith("geo-"):
+            raise ValueError(f"No simulations found using geometry ID: {entity_id}")
+        elif entity_id.startswith("sim-"):
+            raise ValueError(f"Unable to resolve simulation ID: {entity_id}")
+        else:
+            raise ValueError(
+                f"Invalid entity ID: {entity_id}. " f"Expected ID starting with 'geo-' or 'sim-'"
+            )
+
+    return urls[entity_id]
+
+
+def get_workflow_urls_from_entities(
+    entity_ids: list[str], base_url: str | None = None
+) -> dict[str, str]:
+    """
+    Get workflow URLs for multiple entity IDs in a single batch operation.
+
+    Parameters
+    ----------
+    entity_ids : list[str]
+        List of entity IDs (geometry IDs starting with 'geo-' or simulation IDs
+        starting with 'sim-')
+    base_url : str, optional
+        Override the base URL for the Luminary Cloud application. If not provided,
+        it will be automatically determined from the client's API domain.
+
+    Returns
+    -------
+    dict[str, str]
+        Dictionary mapping entity IDs to their workflow URLs. Only includes entity IDs
+        that were successfully resolved (partial data pattern).
+
+    Raises
+    ------
+    ValueError
+        If base_url cannot be determined from the client
+
+    Notes
+    -----
+    - Geometry IDs that don't map to any simulation will be omitted from the result
+    - Invalid entity IDs will be omitted from the result
+    """
+    if not entity_ids:
+        return {}
+
+    # Auto-detect base URL from client if not provided
+    if base_url is None:
+        client = lc.get_default_client()
+        # Remove port if present from the API domain
+        api_domain = client._apiserver_domain.split(":", maxsplit=1)[0]
+        primary_domain = _get_primary_domain_for_apiserver_domain(api_domain)
+        if primary_domain is None:
+            raise ValueError(f"Unable to determine web URL for API domain: {api_domain}")
+        base_url = f"https://{primary_domain}"
+
+    # Separate simulation IDs and geometry IDs
+    sim_ids_to_entity: dict[SimulationID, str] = {}
+    geo_ids_to_entity: dict[GeometryID, str] = {}
+
+    for entity_id in entity_ids:
+        if entity_id.startswith("sim-"):
+            sim_ids_to_entity[SimulationID(entity_id)] = entity_id
+        elif entity_id.startswith("geo-"):
+            geo_ids_to_entity[GeometryID(entity_id)] = entity_id
+
+    # Get project IDs for all simulation IDs
+    sim_to_project: dict[SimulationID, str] = {}
+    for sim_id in sim_ids_to_entity.keys():
+        try:
+            sim = lc.get_simulation(sim_id)
+            sim_to_project[sim_id] = sim.project_id
+        except Exception:
+            # Skip simulation IDs that can't be resolved
+            continue
+
+    # Handle geometry IDs - find simulations that use each geometry
+    for geo_id_typed, entity_id in geo_ids_to_entity.items():
+        try:
+            geom = lc.get_geometry(geo_id_typed)
+            project = geom.project()
+
+            # Find first simulation using this geometry
+            for sim in project.list_simulations():
+                mesh = lc.get_mesh(sim.mesh_id)
+                geom_version = mesh.geometry_version()
+
+                if geom_version and geom_version.geometry().id == entity_id:
+                    # Found a simulation using this geometry
+                    sim_ids_to_entity[sim.id] = entity_id
+                    sim_to_project[sim.id] = project.id
+                    break
+        except Exception:
+            # Skip geometry IDs that can't be resolved
+            continue
+
+    # Batch get workflow IDs for all simulation IDs
+    result: dict[str, str] = {}
+    if sim_ids_to_entity:
+        workflow_ids = _get_workflow_ids(list(sim_ids_to_entity.keys()))
+
+        for sim_id, workflow_id in workflow_ids.items():
+            entity_id = sim_ids_to_entity[sim_id]
+            project_id = sim_to_project.get(sim_id)
+            if project_id:
+                result[entity_id] = f"{base_url}/project/{project_id}/simulation/{workflow_id}"
+
+    return result

{luminarycloud-0.22.1.dist-info → luminarycloud-0.22.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: luminarycloud
-Version: 0.22.1
+Version: 0.22.3
 Summary: Luminary Cloud SDK
 Project-URL: Homepage, https://www.luminarycloud.com/
 Project-URL: Documentation, https://app.luminarycloud.com/docs/api/