luminarycloud 0.16.0__py3-none-any.whl → 0.16.2__py3-none-any.whl

luminarycloud/geometry_version.py

@@ -126,6 +126,29 @@ class GeometryVersion(ProtoWrapperBase):
         )
         return list(res.features_issues)
 
+    def to_code(self) -> str:
+        """
+        Returns the Python code that creates (from scratch) an identical geometry of
+        this particular version.
+
+        Returns
+        -------
+        str
+            The SDK code that can be used to recreate this specific geometry version.
+
+        Examples
+        --------
+        >>> geometry_version = lc.get_geometry_version("version-id")
+        >>> python_code = geometry_version.to_code()
+        >>> print(python_code)
+        """
+        req = geometrypb.GetSdkCodeRequest(
+            geometry_id=self.geometry_id,
+            geometry_version_id=self.id,
+        )
+        res: geometrypb.GetSdkCodeResponse = get_default_client().GetSdkCode(req)
+        return res.sdk_code
+
 
 def get_geometry_version(id: str) -> GeometryVersion:
     """

luminarycloud/named_variable_set.py

@@ -4,7 +4,6 @@ from datetime import datetime
 from ._client import get_default_client
 from ._helpers._timestamp_to_datetime import timestamp_to_datetime
 from ._helpers.named_variables import _named_variables_from_proto, _named_variables_to_proto
-from ._helpers.warnings import experimental
 from ._proto.api.v0.luminarycloud.named_variable_set import (
     named_variable_set_pb2 as namedvariablepb,
 )
@@ -12,13 +11,12 @@ from ._wrapper import ProtoWrapper, ProtoWrapperBase
 from .types import ProjectID, NamedVariableSetID, LcFloat
 
 
-@experimental
 @ProtoWrapper(namedvariablepb.NamedVariableSet)
 class NamedVariableSet(ProtoWrapperBase):
     """
     Represents a named variable set object.
 
-    Note: This class is experimental and may change in the future.
+    .. warning:: This feature is experimental and may change or be removed without notice.
 
     Attributes
     ----------
@@ -119,11 +117,12 @@ class NamedVariableSet(ProtoWrapperBase):
         return self._named_variables
 
 
-@experimental
 def get_named_variable_set(id: NamedVariableSetID) -> NamedVariableSet:
     """
     Retrieve a specific named variable set by ID.
 
+    .. warning:: This feature is experimental and may change or be removed without notice.
+
     Parameters
     ----------
     id : str

luminarycloud/outputs/stopping_conditions.py

@@ -4,7 +4,6 @@ from .._client import get_default_client
 from .._proto.api.v0.luminarycloud.stopping_condition import stopping_condition_pb2 as stopcondpb
 from .._proto.output import output_pb2 as outputpb
 from dataclasses import dataclass
-from .._helpers.warnings import experimental
 
 
 @dataclass
@@ -155,7 +154,6 @@ def delete_stopping_condition(simulation_template_id: str, id: str) -> None:
     get_default_client().DeleteStoppingCondition(req)
 
 
-@experimental
 def get_general_stopping_conditions(simulation_template_id: str) -> GeneralStoppingConditions:
     """
     Get the general stopping conditions for a simulation template.
@@ -174,7 +172,6 @@ def get_general_stopping_conditions(simulation_template_id: str) -> GeneralStopp
     return GeneralStoppingConditions._from_proto(res.basic_stopping_conditions)
 
 
-@experimental
 def update_general_stopping_conditions(
     simulation_template_id: str,
     max_iterations: int | None = None,

luminarycloud/params/simulation/adjoint_.py

@@ -22,7 +22,7 @@ from luminarycloud.params.simulation._lib import ParamGroupWrapper, create_uniqu
 class Adjoint(CodeRepr, ParamGroupWrapper[clientpb.Adjoint]):
     """Settings for adjoint sensitivity analysis."""
 
-    output: Any | None = None
+    _output: Any | None = None
     "Function to differentiate."
     surfaces: list[str] = field(default_factory=list)
     ""
@@ -33,8 +33,8 @@ class Adjoint(CodeRepr, ParamGroupWrapper[clientpb.Adjoint]):
 
     def _to_proto(self) -> clientpb.Adjoint:
         _proto = clientpb.Adjoint()
-        if self.output is not None:
-            _proto.adjoint_output.CopyFrom(self.output)
+        if self._output is not None:
+            _proto.adjoint_output.CopyFrom(self._output)
         if self.surfaces is not None:
             _proto.surfaces.extend(self.surfaces)
         if self.deformed_coords_id is not None:
@@ -44,7 +44,7 @@ class Adjoint(CodeRepr, ParamGroupWrapper[clientpb.Adjoint]):
         return _proto
 
     def _from_proto(self, proto: clientpb.Adjoint) -> None:
-        self.output = proto.adjoint_output
+        self._output = proto.adjoint_output
         self.surfaces.extend(proto.surfaces)
         self.deformed_coords_id = proto.deformed_coords_id
         self.primal_simulation_id = proto.primal_simulation_id

luminarycloud/params/simulation/material/material_fluid_.py

@@ -85,7 +85,7 @@ class MaterialFluid(CodeRepr, ParamGroupWrapper[clientpb.MaterialFluid]):
     "Model for the laminar thermal conductivity of a fluid. Possible types: ``PrescribedPrandtlNumber``, ``PrescribedConductivity``, ``TemperatureDependentConductivity`` from the ``thermal_conductivity_model`` module."
     boussinesq_approximation: BoussinesqApproximation = field(default_factory=BoussinesqOn)
     "Introduce a body force due to thermal expansion without modifying the material density. Possible types: ``BoussinesqOff``, ``BoussinesqOn`` from the ``boussinesq_approximation`` module."
-    preset: enum.MaterialFluidPreset = enum.MaterialFluidPreset.CUSTOM_MATERIAL_FLUID
+    preset: enum.MaterialFluidPreset = enum.MaterialFluidPreset.STANDARD_AIR
     "Select a predefined set of material properties or allow a custom set of properties."
     viscosity_model: ViscosityModel = field(default_factory=Sutherland)
     "Models available for the dynamic viscosity of the fluid. Possible types: ``Sutherland``, ``PrescribedViscosity``, ``TemperatureDependentViscosity`` from the ``viscosity_model`` module."

luminarycloud/params/simulation/material/material_solid_.py

@@ -30,7 +30,7 @@ class MaterialSolid(CodeRepr, ParamGroupWrapper[clientpb.MaterialSolid]):
     "The thermal conductivity of the material."
     thermal_conductivity_table: RectilinearTable | None = None
     "Correlation between thermal conductivity and temperature."
-    preset: enum.MaterialSolidPreset = enum.MaterialSolidPreset.CUSTOM_MATERIAL_SOLID
+    preset: enum.MaterialSolidPreset = enum.MaterialSolidPreset.ALUMINUM
     "Select a predefined set of material properties or allow a custom set of properties."
 
     def _to_proto(self) -> clientpb.MaterialSolid:

luminarycloud/params/simulation/output_.py

@@ -22,7 +22,7 @@ from luminarycloud.params.simulation._lib import ParamGroupWrapper, create_uniqu
 class Output(CodeRepr, ParamGroupWrapper[clientpb.Output]):
     """Solution output settings."""
 
-    iters_per_output: int = 1000
+    iters_per_output: int = 0
     "Number of (pseudo) timesteps between successive full solution output. If ≤0, only the final solution is written."
     include_residuals: bool = False
     "Include the residuals for each equation in the volume solution."

luminarycloud/params/simulation/physics/fluid/initialization/fluid_existing_solution_.py

@@ -19,6 +19,10 @@ from luminarycloud.params.simulation._lib import ParamGroupWrapper, create_uniqu
 
 from luminarycloud.params.simulation.physics.fluid.initialization_fluid_ import InitializationFluid
 from luminarycloud.params.simulation.physics.fluid.initialization_fluid_ import *
+from luminarycloud.params.simulation.physics.fluid.initialization.turbulence_initialization_ import (
+    TurbulenceInitialization,
+)
+from luminarycloud.params.simulation.physics.fluid.initialization.turbulence_initialization_ import *
 
 
 @dataclass(kw_only=True)
@@ -27,16 +31,40 @@ class FluidExistingSolution(InitializationFluid):
 
     solution_id: str = ""
     "ID for the existing solution to use for initialization."
+    turbulence: TurbulenceInitialization = field(default_factory=TurbulenceInitialization)
+    ""
 
     def _to_proto(self) -> clientpb.InitializationFluid:
         _proto = super()._to_proto()
         _proto.initialization_type = clientpb.InitializationType.EXISTING_SOLUTION
         if self.solution_id is not None:
             _proto.existing_solution_id = self.solution_id
+        _proto.turbulent_variable_initialization_type_sa = self.turbulence.spalart_allmaras.value
+        _proto.turbulent_variable_initialization_type_komega = self.turbulence.komega.value
+        _proto.init_turbulent_viscosity_ratio.CopyFrom(
+            _to_ad_proto(self.turbulence.viscosity_ratio)
+        )
+        _proto.init_turbulent_viscosity.CopyFrom(_to_ad_proto(self.turbulence.viscosity))
+        _proto.init_turbulence_intensity.CopyFrom(_to_ad_proto(self.turbulence.intensity))
+        _proto.uniform_nu_tilde.CopyFrom(_to_ad_proto(self.turbulence.sa_variable))
+        _proto.uniform_tke.CopyFrom(_to_ad_proto(self.turbulence.tke))
+        _proto.uniform_omega.CopyFrom(_to_ad_proto(self.turbulence.omega))
         return _proto
 
     def _from_proto(self, proto: clientpb.InitializationFluid) -> None:
         super()._from_proto(proto)
         assert proto.initialization_type == clientpb.InitializationType.EXISTING_SOLUTION
         self.solution_id = proto.existing_solution_id
+        self.turbulence.spalart_allmaras = enum.TurbulentVariableInitializationTypeSa(
+            proto.turbulent_variable_initialization_type_sa
+        )
+        self.turbulence.komega = enum.TurbulentVariableInitializationTypeKomega(
+            proto.turbulent_variable_initialization_type_komega
+        )
+        self.turbulence.viscosity_ratio = _from_ad_proto(proto.init_turbulent_viscosity_ratio)
+        self.turbulence.viscosity = _from_ad_proto(proto.init_turbulent_viscosity)
+        self.turbulence.intensity = _from_ad_proto(proto.init_turbulence_intensity)
+        self.turbulence.sa_variable = _from_ad_proto(proto.uniform_nu_tilde)
+        self.turbulence.tke = _from_ad_proto(proto.uniform_tke)
+        self.turbulence.omega = _from_ad_proto(proto.uniform_omega)
         return None

luminarycloud/params/simulation/simulation_param_.py

@@ -77,6 +77,8 @@ class SimulationParam(CodeRepr, ParamGroupWrapper[clientpb.SimulationParam]):
     "Body frame."
     surface_name: dict[str, SurfaceName] = field(default_factory=dict)
     "Surface name map."
+    _table_references: dict[str, Any] = field(default_factory=dict)
+    "Solution inputs - metadata for general n-dimensional rectilinear grid data (Monitor points, radial distribution, blade geometry, airfoil performance)."
     output: Output = field(default_factory=Output)
     "Solution output settings."
     entity_relationships: EntityRelationships = field(default_factory=EntityRelationships)
@@ -115,6 +117,9 @@ class SimulationParam(CodeRepr, ParamGroupWrapper[clientpb.SimulationParam]):
         if self.surface_name is not None:
             for k, v in self.surface_name.items():
                 _proto.surface_name[k].CopyFrom(v._to_proto())
+        if self._table_references is not None:
+            for k, v in self._table_references.items():
+                _proto.table_references[k].CopyFrom(v)
         if self.output is not None:
             _proto.output.CopyFrom(self.output._to_proto())
         if self.entity_relationships is not None:
@@ -140,6 +145,7 @@ class SimulationParam(CodeRepr, ParamGroupWrapper[clientpb.SimulationParam]):
         self.monitor_plane = [MonitorPlane.from_proto(v) for v in proto.monitor_plane]
         self.body_frame = BodyFrame.from_proto(proto.body_frame)
         self.surface_name = {k: SurfaceName.from_proto(v) for k, v in proto.surface_name.items()}
+        self._table_references.update(proto.table_references)
         self.output = Output.from_proto(proto.output)
         self.entity_relationships = EntityRelationships.from_proto(proto.entity_relationships)
         self.adaptive_mesh_refinement = AdaptiveMeshRefinement.from_proto(

luminarycloud/physics_ai/architectures.py

@@ -4,12 +4,10 @@ from typing import List, Optional
 from .._client import get_default_client
 from .._proto.api.v0.luminarycloud.physics_ai import physics_ai_pb2 as physaipb
 from .._wrapper import ProtoWrapper, ProtoWrapperBase
-from .._helpers.warnings import experimental
 from ..types.ids import PhysicsAiArchitectureID, PhysicsAiArchitectureVersionID
 from ..enum.physics_ai_lifecycle_state import PhysicsAiLifecycleState
 
 
-@experimental
 @ProtoWrapper(physaipb.PhysicsAiArchitectureVersion)
 class PhysicsAiArchitectureVersion(ProtoWrapperBase):
     """
@@ -25,7 +23,6 @@ class PhysicsAiArchitectureVersion(ProtoWrapperBase):
     _proto: physaipb.PhysicsAiArchitectureVersion
 
 
-@experimental
 @ProtoWrapper(physaipb.PhysicsAiArchitecture)
 class PhysicsAiArchitecture(ProtoWrapperBase):
     """
@@ -55,7 +52,6 @@ class PhysicsAiArchitecture(ProtoWrapperBase):
         return self.versions[0] if self.versions else None
 
 
-@experimental
 def list_architectures() -> List[PhysicsAiArchitecture]:
     """
     List available Physics AI architectures for model training.

luminarycloud/physics_ai/inference.py

@@ -14,7 +14,6 @@ from .._proto.api.v0.luminarycloud.inference import inference_pb2 as inferencepb
 from .._proto.inferenceservice import inferenceservice_pb2 as inferenceservicepb
 from .._wrapper import ProtoWrapper, ProtoWrapperBase
 from ..project import Project
-from .._helpers.warnings import experimental
 from ..project import Project
 from .._helpers import upload_file
 from .._proto.upload import upload_pb2 as uploadpb
@@ -48,7 +47,6 @@ class ExtAeroInferenceResult:
         self.pressure_surface = inference_result.get("pressure_surface", None)
 
 
-@experimental
 def external_aero_inference(
     project: Project, stl_file: str, checkpoint_file: str, config_name: str, stencil_size: int
 ) -> ExtAeroInferenceResult:
@@ -77,7 +75,6 @@ def external_aero_inference(
     return ExtAeroInferenceResult(result)
 
 
-@experimental
 def perform_inference(
     project: Project, stl_file: str, checkpoint_file: str, config_name: str, stencil_size: int
 ) -> dict[str, Any]:
@@ -144,7 +141,6 @@ def perform_inference(
     return currated
 
 
-@experimental
 def start_inference_job(
     project: Project,
     stl_url: str,

luminarycloud/physics_ai/models.py

@@ -4,12 +4,10 @@ from typing import List, Optional
 from .._client import get_default_client
 from .._proto.api.v0.luminarycloud.physics_ai import physics_ai_pb2 as physaipb
 from .._wrapper import ProtoWrapper, ProtoWrapperBase
-from .._helpers.warnings import experimental
 from ..types.ids import PhysicsAiModelID, PhysicsAiModelVersionID
 from ..enum.physics_ai_lifecycle_state import PhysicsAiLifecycleState
 
 
-@experimental
 @ProtoWrapper(physaipb.PhysicsAiModelVersion)
 class PhysicsAiModelVersion(ProtoWrapperBase):
     """
@@ -24,7 +22,6 @@ class PhysicsAiModelVersion(ProtoWrapperBase):
     _proto: physaipb.PhysicsAiModelVersion
 
 
-@experimental
 @ProtoWrapper(physaipb.PhysicsAiModel)
 class PhysicsAiModel(ProtoWrapperBase):
     """
@@ -54,7 +51,6 @@ class PhysicsAiModel(ProtoWrapperBase):
         return self.versions[0] if self.versions else None
 
 
-@experimental
 def list_pretrained_models() -> List[PhysicsAiModel]:
     """
     List available pretrained Physics AI models.

luminarycloud/physics_ai/solution.py

@@ -4,12 +4,10 @@ import tarfile
 from typing import List, Optional, BinaryIO, cast
 
 from .._client import get_default_client
-from .._helpers.warnings import experimental
 from .._helpers.download import download_solution_physics_ai as _download_solution_physics_ai
 from ..enum.quantity_type import QuantityType
 
 
-@experimental
 def _download_processed_solution_physics_ai(  # noqa: F841
     solution_id: str,
     exclude_surfaces: Optional[List[str]] = None,
@@ -25,6 +23,8 @@ def _download_processed_solution_physics_ai(  # noqa: F841
     Returns a compressed archive containing processed solution files including
     merged surfaces (VTP/STL) and optionally volume data (VTU).
 
+    .. warning:: This feature is experimental and may change or be removed without notice.
+
     Args:
         solution_id: ID of the solution to download
         exclude_surfaces: List of surface names to exclude from processing

luminarycloud/pipelines/__init__.py

@@ -1,6 +1,7 @@
 # Copyright 2025 Luminary Cloud, Inc. All Rights Reserved.
 from .core import (
     Pipeline as Pipeline,
+    PipelineParameter as PipelineParameter,
 )
 
 from .parameters import (
@@ -27,3 +28,8 @@ from .operators import (
     Simulate as Simulate,
     SimulateOutputs as SimulateOutputs,
 )
+
+from .arguments import (
+    PipelineArgs as PipelineArgs,
+    ArgNamedVariableSet as ArgNamedVariableSet,
+)

luminarycloud/pipelines/arguments.py

@@ -0,0 +1,105 @@
+# Copyright 2025 Luminary Cloud, Inc. All Rights Reserved.
+from typing import Any, Type
+
+from .core import PipelineParameter
+
+
+class _NVS(PipelineParameter):
+    @classmethod
+    def _represented_type(cls) -> Type:
+        return str
+
+    @classmethod
+    def _type_name(cls) -> str:
+        return "Named Variable Set"
+
+    def _validate(self) -> None:
+        if self.name != "$named-variable-set":
+            raise ValueError(
+                "The Named Variable Set PipelineParameter must be named '$named-variable-set'"
+            )
+
+    def _add_to_params(self, params: dict) -> None:
+        raise ValueError(
+            "The NamedVariableSet parameter cannot be used explicitly in a Pipeline. It can only be used in PipelineArgs."
+        )
+
+    def _is_valid_value(self, value: Any) -> bool:
+        return isinstance(value, str) and value.startswith("namedvarset-")
+
+
+ArgNamedVariableSet = _NVS("$named-variable-set")
+"""
+This can be used in a PipelineArgs params list to add a Named Variable Set column to the args table.
+There must be zero or one of these in a PipelineArgs params list.
+"""
+
+# The types that are allowed as PipelineArgs values. This is a union of all concrete
+# PipelineParameters' "represented types".
+PipelineArgValueType = str | int | float | bool
+
+
+class PipelineArgsRow:
+    def __init__(self, args: "PipelineArgs", row_values: list[PipelineArgValueType]):
+        self.args = args
+        self.row_values = row_values
+        self._validate()
+
+    def _validate(self) -> None:
+        if len(self.row_values) != len(self.args.params):
+            raise ValueError(
+                f"PipelineArgs row wrong size. Expected {len(self.args.params)}, got {len(self.row_values)}"
+            )
+        for i, v in enumerate(self.row_values):
+            param = self.args.params[i]
+            if not param._is_valid_value(v):
+                raise ValueError(f"PipelineArgs value {v} is invalid for parameter {param}")
+
+    def value_for(self, param_name: str) -> PipelineArgValueType:
+        return self.row_values[self.args.column_for(param_name)]
+
+    def has_column_for(self, param_name: str) -> bool:
+        return self.args.has_column_for(param_name)
+
+    def __str__(self) -> str:
+        s = "PipelineArgsRow("
+        for i, v in enumerate(self.row_values):
+            s += f"{self.args.params[i].name}={repr(v)}, "
+        s += ")"
+        return s
+
+
+class PipelineArgs:
+    def __init__(self, params: list[PipelineParameter], args: list[list[PipelineArgValueType]]):
+        self.params = params
+        self._param_index_by_name = {p.name: i for i, p in enumerate(params)}
+        self._validate_params()
+        self.rows = [PipelineArgsRow(self, arg) for arg in args]
+
+    def has_column_for(self, param_name: str) -> bool:
+        return param_name in self._param_index_by_name
+
+    def column_for(self, param_name: str) -> int:
+        if not self.has_column_for(param_name):
+            raise ValueError(f'Parameter "{param_name}" not found')
+        return self._param_index_by_name[param_name]
+
+    def _validate_params(self) -> None:
+        has_nvs = False
+        seen_param_names = set()
+        for p in self.params:
+            if isinstance(p, _NVS):
+                if has_nvs:
+                    raise ValueError(
+                        "There can be at most one Named Variable Set column in a PipelineArgs"
+                    )
+                has_nvs = True
+            else:
+                if p.name in seen_param_names:
+                    raise ValueError(f'There is more than one parameter named "{p.name}"')
+                seen_param_names.add(p.name)
+
+    def __str__(self) -> str:
+        return (
+            f"PipelineArgs(param_names={[p.name for p in self.params]}, row_count={len(self.rows)})"
+        )