luminarycloud 0.15.3__py3-none-any.whl → 0.15.5__py3-none-any.whl

luminarycloud/params/simulation/time/time_step_ramp_.py

@@ -5,12 +5,11 @@ from dataclasses import dataclass, field
 from typing import Any
 from uuid import uuid4
 
-from luminarycloud.tables import RectilinearTable, _param_name_to_table_type
 from google.protobuf.message import Message as _Message
-
-from luminarycloud.tables import RectilinearTable
-from luminarycloud.types import Vector3
+from luminarycloud.tables import RectilinearTable, _param_name_to_table_type
+from luminarycloud.types import Vector3, LcFloat
 from luminarycloud.types.adfloat import _to_ad_proto, _from_ad_proto
+from luminarycloud._helpers._entity_identifier import _create_entity_identifier
 from luminarycloud._proto.client import simulation_pb2 as clientpb
 from luminarycloud._proto.client.entity_pb2 import EntityIdentifier
 from luminarycloud._helpers import CodeRepr

luminarycloud/params/simulation/time_.py

@@ -5,12 +5,11 @@ from dataclasses import dataclass, field
 from typing import Any
 from uuid import uuid4
 
-from luminarycloud.tables import RectilinearTable, _param_name_to_table_type
 from google.protobuf.message import Message as _Message
-
-from luminarycloud.tables import RectilinearTable
-from luminarycloud.types import Vector3
+from luminarycloud.tables import RectilinearTable, _param_name_to_table_type
+from luminarycloud.types import Vector3, LcFloat
 from luminarycloud.types.adfloat import _to_ad_proto, _from_ad_proto
+from luminarycloud._helpers._entity_identifier import _create_entity_identifier
 from luminarycloud._proto.client import simulation_pb2 as clientpb
 from luminarycloud._proto.client.entity_pb2 import EntityIdentifier
 from luminarycloud._helpers import CodeRepr
@@ -48,7 +47,7 @@ class Time(CodeRepr, ParamGroupWrapper[clientpb.Time]):
 
     time_marching: TimeMarching = field(default_factory=TimeImplicit)
     "Scheme for time-accurate integration. Possible types: ``TimeImplicit``, ``TimeExplicit`` from the ``time_marching`` module."
-    time_step: float = 0.0001
+    time_step: LcFloat = 0.0001
     "The fixed physical time step."
     time_step_ramp: TimeStepRamp = field(default_factory=TimeStepRampOff)
     "Use a larger time step value during the initial transients of a simulation and then ramp linearly towards the target value, to accelerate statistical convergence. Only applicable to transient problems with time implicit integration (dual time stepping). Possible types: ``TimeStepRampOff``, ``TimeStepRampOn`` from the ``time_step_ramp`` module."

luminarycloud/params/simulation/volume_entity_.py

@@ -5,12 +5,11 @@ from dataclasses import dataclass, field
 from typing import Any
 from uuid import uuid4
 
-from luminarycloud.tables import RectilinearTable, _param_name_to_table_type
 from google.protobuf.message import Message as _Message
-
-from luminarycloud.tables import RectilinearTable
-from luminarycloud.types import Vector3
+from luminarycloud.tables import RectilinearTable, _param_name_to_table_type
+from luminarycloud.types import Vector3, LcFloat
 from luminarycloud.types.adfloat import _to_ad_proto, _from_ad_proto
+from luminarycloud._helpers._entity_identifier import _create_entity_identifier
 from luminarycloud._proto.client import simulation_pb2 as clientpb
 from luminarycloud._proto.client.entity_pb2 import EntityIdentifier
 from luminarycloud._helpers import CodeRepr
@@ -23,7 +22,9 @@ from luminarycloud.params.simulation._lib import ParamGroupWrapper, create_uniqu
 class VolumeEntity(CodeRepr, ParamGroupWrapper[clientpb.VolumeEntity]):
     """Volume entity."""
 
-    volume_identifier: EntityIdentifier | None = None
+    volume_identifier: EntityIdentifier = field(
+        default_factory=_create_entity_identifier, init=True
+    )
     "Unique identifier for a volume entity."
 
     def _to_proto(self) -> clientpb.VolumeEntity:

luminarycloud/physics_ai/__init__.py

@@ -1,8 +1,10 @@
 from .architectures import (
     list_architectures as list_architectures,
     PhysicsAiArchitecture as PhysicsAiArchitecture,
+    PhysicsAiArchitectureVersion as PhysicsAiArchitectureVersion,
 )
 from .models import (
     list_pretrained_models as list_pretrained_models,
     PhysicsAiModel as PhysicsAiModel,
+    PhysicsAiModelVersion as PhysicsAiModelVersion,
 )

luminarycloud/physics_ai/architectures.py

@@ -1,37 +1,71 @@
 # Copyright 2025 Luminary Cloud, Inc. All Rights Reserved.
-from __future__ import annotations
-
-from typing import List
+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
+from ..types.ids import PhysicsAiArchitectureID, PhysicsAiArchitectureVersionID
+from ..enum.physics_ai_lifecycle_state import PhysicsAiLifecycleState
+
+
+@experimental
+@ProtoWrapper(physaipb.PhysicsAiArchitectureVersion)
+class PhysicsAiArchitectureVersion(ProtoWrapperBase):
+    """
+    Represents a specific version of a Physics AI architecture.
+
+    .. warning:: This feature is experimental and may change or be removed without notice.
+    """
+
+    id: PhysicsAiArchitectureVersionID
+    name: str
+    changelog: str
+    lifecycle_state: PhysicsAiLifecycleState
+    _proto: physaipb.PhysicsAiArchitectureVersion
 
 
 @experimental
 @ProtoWrapper(physaipb.PhysicsAiArchitecture)
 class PhysicsAiArchitecture(ProtoWrapperBase):
     """
-    Represents a Physics AI architecture.
+    Represents a Physics AI architecture with all its versions.
 
-    warning:: This feature is experimental and may change or be removed without notice.
+    .. warning:: This feature is experimental and may change or be removed without notice.
     """
 
     id: PhysicsAiArchitectureID
     name: str
     description: str
-    version: str
+    versions: List[PhysicsAiArchitectureVersion]
     _proto: physaipb.PhysicsAiArchitecture
 
+    def get_latest_version(self) -> Optional[PhysicsAiArchitectureVersion]:
+        """
+        Get the latest version of this architecture based on name.
+
+        Returns
+        -------
+        PhysicsAiArchitectureVersion or None
+            The first architecture version, or None if no versions exist.
+            Note: Version ordering is now determined by the backend.
+        """
+        if not self.versions:
+            return None
+        return self.versions[0] if self.versions else None
+
 
 @experimental
 def list_architectures() -> List[PhysicsAiArchitecture]:
     """
     List available Physics AI architectures for model training.
 
-    warning:: This feature is experimental and may change or be removed without notice.
+    .. warning:: This feature is experimental and may change or be removed without notice.
+
+    Returns
+    -------
+    list[PhysicsAiArchitecture]
+        A list of all available Physics AI architectures.
     """
     req = physaipb.ListArchitecturesRequest()
     res = get_default_client().ListArchitectures(req)

luminarycloud/physics_ai/inference.py

@@ -1,7 +1,5 @@
 # File: python/sdk/luminarycloud/inference/inference.py
 # Copyright 2025 Luminary Cloud, Inc. All Rights Reserved.
-from __future__ import annotations
-
 from datetime import datetime
 from typing import Any
 from json import loads as json_loads

luminarycloud/physics_ai/models.py

@@ -1,41 +1,70 @@
 # Copyright 2025 Luminary Cloud, Inc. All Rights Reserved.
-from __future__ import annotations
-
-from datetime import datetime
-from typing import List
+from typing import List, Optional
 
 from .._client import get_default_client
-from .._helpers._timestamp_to_datetime import timestamp_to_datetime
 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
+from ..types.ids import PhysicsAiModelID, PhysicsAiModelVersionID
+from ..enum.physics_ai_lifecycle_state import PhysicsAiLifecycleState
+
+
+@experimental
+@ProtoWrapper(physaipb.PhysicsAiModelVersion)
+class PhysicsAiModelVersion(ProtoWrapperBase):
+    """
+    Represents a specific version of a Physics AI model.
+
+    .. warning:: This feature is experimental and may change or be removed without notice.
+    """
+
+    id: PhysicsAiModelVersionID
+    name: str
+    lifecycle_state: PhysicsAiLifecycleState
+    _proto: physaipb.PhysicsAiModelVersion
 
 
 @experimental
 @ProtoWrapper(physaipb.PhysicsAiModel)
 class PhysicsAiModel(ProtoWrapperBase):
-    """Represents a Physics AI model."""
+    """
+    Represents a Physics AI model with all its versions.
+
+    .. warning:: This feature is experimental and may change or be removed without notice.
+    """
 
     id: PhysicsAiModelID
     name: str
-    version: str
-
+    description: str
+    versions: List[PhysicsAiModelVersion]
     _proto: physaipb.PhysicsAiModel
 
-    @property
-    def create_time(self) -> datetime:
-        return timestamp_to_datetime(self._proto.create_time)
+    def get_latest_version(self) -> Optional[PhysicsAiModelVersion]:
+        """
+        Get the latest version of this model.
 
-    @property
-    def update_time(self) -> datetime:
-        return timestamp_to_datetime(self._proto.update_time)
+        Returns
+        -------
+        PhysicsAiModelVersion or None
+            The first model version, or None if no versions exist.
+            Note: Version ordering is now determined by the backend.
+        """
+        if not self.versions:
+            return None
+        return self.versions[0] if self.versions else None
 
 
 @experimental
 def list_pretrained_models() -> List[PhysicsAiModel]:
     """
     List available pretrained Physics AI models.
+
+    .. warning:: This feature is experimental and may change or be removed without notice.
+
+    Returns
+    -------
+    list[PhysicsAiModel]
+        A list of all available pretrained Physics AI models.
     """
     req = physaipb.ListPretrainedModelsRequest()
     res = get_default_client().ListPretrainedModels(req)

luminarycloud/project.py

@@ -1,6 +1,7 @@
 # Copyright 2023-2024 Luminary Cloud, Inc. All Rights Reserved.
 from __future__ import annotations
 
+import logging
 import re
 import uuid
 from datetime import datetime
@@ -45,7 +46,8 @@ from .enum import GPUType, MeshType, TableType
 from .meshing import MeshAdaptationParams, MeshGenerationParams
 from .simulation_param import SimulationParam
 from .tables import RectilinearTable, create_rectilinear_table
-from .types import MeshID, ProjectID, SimulationTemplateID
+from .types import MeshID, ProjectID, SimulationTemplateID, NamedVariableSetID, Expression, LcFloat
+from .named_variable_set import get_named_variable_set
 
 if TYPE_CHECKING:
     from .geometry import Geometry
@@ -482,6 +484,7 @@ class Project(ProtoWrapperBase):
         name: str,
         simulation_template_id: str,
         *,
+        _named_variable_set_id: Optional[NamedVariableSetID] = None,
         description: str = "",
         batch_processing: bool = True,
         gpu_type: Optional[GPUType] = None,
@@ -514,12 +517,19 @@ class Project(ProtoWrapperBase):
             Number of GPUs to use for the simulation. Must be specified to a
             positive value if `gpu_type` is specified.
         """
+
+        named_variable_set_version_id: Optional[str] = None
+        if _named_variable_set_id is not None:
+            named_variable_set = get_named_variable_set(_named_variable_set_id)
+            named_variable_set_version_id = named_variable_set._version_id
+
         _simulation = create_simulation(
             get_default_client(),
             self.id,
             mesh_id,
             name,
             simulation_template_id,
+            named_variable_set_version_id=named_variable_set_version_id,
             description=description,
             batch_processing=batch_processing,
             gpu_type=gpu_type,
@@ -550,7 +560,7 @@ class Project(ProtoWrapperBase):
         *,
         parameters: Optional[SimulationParam] = None,
         params_json_path: Optional[PathLike | str] = None,
-        copy_from: Optional["SimulationTemplate" | SimulationTemplateID | str] = None,
+        copy_from: "Optional[SimulationTemplate | SimulationTemplateID | str]" = None,
     ) -> "SimulationTemplate":
         """
         Create a new simulation template object.
@@ -600,7 +610,7 @@ class Project(ProtoWrapperBase):
 
     @experimental
     def create_named_variable_set(
-        self, name: str, named_variables: dict[str, float | str]
+        self, name: str, named_variables: dict[str, LcFloat]
     ) -> NamedVariableSet:
         """
         Create a new named variable set.
@@ -626,6 +636,47 @@ class Project(ProtoWrapperBase):
         return [lc.NamedVariableSet(n) for n in res.named_variable_sets]
 
 
+@experimental
+def add_named_variables_from_csv(project: Project, csv_path: str) -> list[NamedVariableSet]:
+    """
+    This function reads named variables from a CSV file and creates corresponding NamedVariableSets in the given project.
+    The CSV file should have the following format:
+    name, var1, var2, ...
+    name1, val1, val2, ...
+    name2, val1, val2, ...
+    """
+    import csv
+
+    def is_float(s: str) -> bool:
+        try:
+            float(s)
+            return True
+        except ValueError:
+            return False
+
+    named_variable_sets = []
+    with open(csv_path) as csvfile:
+        reader = csv.reader(csvfile)
+        header = next(reader)
+        keys = [k.strip() for k in header[1:]]
+        for row in reader:
+            if len(row) != len(keys) + 1:
+                logging.warning(
+                    f"Skipping row {row} because it has the wrong number of columns ({len(row)} instead of {len(keys) + 1})"
+                )
+                continue
+            name = row[0]
+            named_variables: dict[str, LcFloat] = {
+                k: float(v.strip()) if is_float(v.strip()) else Expression(v.strip())
+                for k, v in zip(keys, row[1:])
+            }
+            named_variable_sets.append(
+                project.create_named_variable_set(name=name, named_variables=named_variables)
+            )
+            logging.info(f"Created named variable set {name} with {len(named_variables)} variables")
+    return named_variable_sets
+
+
 def create_project(
     name: str,
     description: str = "",

luminarycloud/simulation_template.py

@@ -2,7 +2,7 @@
 from datetime import datetime
 from os import PathLike
 from copy import deepcopy
-from typing import Optional, Union, overload
+from typing import Optional, overload
 from difflib import Differ
 
 from .enum import (
@@ -76,6 +76,7 @@ class SimulationTemplate(ProtoWrapperBase):
         *,
         name: Optional[str] = None,
         parameters: Optional[SimulationParam | PathLike] = None,
+        copy_from: "Optional[SimulationTemplate | SimulationTemplateID | str]" = None,
     ) -> None:
         """
         Update simulation template.
@@ -84,19 +85,23 @@ class SimulationTemplate(ProtoWrapperBase):
         ----------
         name : str, optional
             New project name.
-        parameters : SimulationParam or PathLike
+        parameters : SimulationParam or PathLike, optional
             New complete simulation parameters object or path to local JSON file containing
             simulation parameters. In the former case, the input argument is modified to reflect
             changes applied by the backend (server), for example due to presets. Any differences
             between input and result are printed on screen.
+        copy_from : SimulationTemplate or SimulationTemplateID or str, optional
+            Simulation template to copy. If provided, it will be deep-copied into this simulation
+            template. Can pass a SimulationTemplate object or an ID of the template to copy.
         """
-        return self._update(name=name, parameters=parameters)
+        return self._update(name=name, parameters=parameters, copy_from=copy_from)
 
     def _update(
         self,
         *,
         name: Optional[str] = None,
         parameters: Optional[SimulationParam | clientpb.SimulationParam | PathLike] = None,
+        copy_from: "Optional[SimulationTemplate | SimulationTemplateID | str]" = None,
     ) -> None:
         """
         Update simulation template. See `update()` for more details.
@@ -124,21 +129,31 @@ class SimulationTemplate(ProtoWrapperBase):
 
             req.parameters.CopyFrom(param_proto)
 
+        if copy_from is not None:
+            if isinstance(copy_from, SimulationTemplate):
+                req.copy_from = copy_from.id
+            elif isinstance(copy_from, str):
+                req.copy_from = copy_from
+            else:
+                raise ValueError(f"Invalid copy_from argument: {copy_from}")
+
         res: simtemplatepb.UpdateSimulationTemplateResponse = (
             get_default_client().UpdateSimulationTemplate(req)
         )
         self._proto = res.simulation_template
 
         def print_diff(
-            old: Union[clientpb.SimulationParam, SimulationParam],
-            new: Union[clientpb.SimulationParam, SimulationParam],
+            old: clientpb.SimulationParam | SimulationParam,
+            new: clientpb.SimulationParam | SimulationParam,
         ) -> None:
             diffs = list(Differ().compare(str(old).split("\n"), str(new).split("\n")))
             has_diffs = False
             for diff in diffs:
                 if diff.startswith("-") or diff.startswith("+"):
                     if not has_diffs:
-                        print("The input parameters have been modified:\n")
+                        print(
+                            "The given parameters have been modified, both in memory and server-side, due to presets. The modifications:\n"
+                        )
                         has_diffs = True
                     print(diff)
 

luminarycloud/solution.py

@@ -38,7 +38,7 @@ class Solution(ProtoWrapperBase):
     "Solution ID."
     simulation_id: SimulationID
     "Simulation ID of parent"
-    iteration: str
+    iteration: int
     "Iteration index of the solution."
     physical_time: float
     "The physical time, in seconds, of the solution iteration (for transient simulations)."

luminarycloud/types/__init__.py

@@ -12,6 +12,8 @@ from .ids import (
 from .adfloat import (
     FirstOrderAdFloat as FirstOrderAdFloat,
     SecondOrderAdFloat as SecondOrderAdFloat,
+    Expression as Expression,
+    LcFloat as LcFloat,
 )
 from .vector3 import (
     Vector3 as Vector3,

luminarycloud/types/adfloat.py

@@ -1,10 +1,10 @@
 from abc import ABCMeta
-from typing import Any
-from .._proto.base.base_pb2 import AdFloatType, FirstOrderAdType, SecondOrderAdType
+from typing import Any, Union
+from .._proto.base.base_pb2 import AdFloatType, ExpressionType, FirstOrderAdType, SecondOrderAdType
 
 
 class AdFloat(float, metaclass=ABCMeta):
-    """An immutable float with adjoints/tangents"""
+    """An immutable float with adjoints/tangents or an expression"""
 
     pass
 
@@ -110,8 +110,47 @@ class SecondOrderAdFloat(AdFloat):
         )
 
 
-def _to_ad_proto(value: float) -> AdFloatType:
-    """Convert a float to an AdFloatType proto."""
+class Expression:
+    """An expression or value that can be evaluated or used in evaluations."""
+
+    _value: float
+    _expression: str
+
+    def __init__(self, expression: str):
+        if not expression:
+            raise ValueError("Expression cannot be empty")
+        self._value = 0.0
+        self._expression = expression
+
+    @property
+    def expression(self) -> str:
+        return self._expression
+
+    @property
+    def value(self) -> float:
+        return self._value
+
+    def _to_proto(self) -> AdFloatType:
+        return AdFloatType(variable=ExpressionType(value=self.value, expression=self.expression))
+
+    @staticmethod
+    def _from_proto(proto: AdFloatType) -> "Expression":
+        expr = object.__new__(Expression)  # Create a new instance without calling __init__
+        expr._value = proto.variable.value
+        expr._expression = proto.variable.expression
+        return expr
+
+    def __eq__(self, other: Any) -> bool:
+        if not isinstance(other, Expression):
+            return False
+        return self._value == other._value and self._expression == other._expression
+
+
+LcFloat = Union[float, FirstOrderAdFloat, SecondOrderAdFloat, Expression]
+
+
+def _to_ad_proto(value: LcFloat) -> AdFloatType:
+    """Convert an LcFloat to an AdFloatType proto."""
     if isinstance(value, FirstOrderAdFloat):
         return AdFloatType(
             first_order=FirstOrderAdType(
@@ -128,18 +167,21 @@ def _to_ad_proto(value: float) -> AdFloatType:
                 adjoint=[_to_ad_proto(a).first_order for a in value.adjoint],
             )
         )
+    elif isinstance(value, Expression):
+        return value._to_proto()
     return AdFloatType(value=float(value))
 
 
-def _from_ad_proto(proto: AdFloatType) -> float:
-    """Convert an AdFloatType proto to a float."""
+def _from_ad_proto(proto: AdFloatType) -> LcFloat:
+    """Convert an AdFloatType proto to an LcFloat."""
     if proto.HasField("first_order"):
         return FirstOrderAdFloat._from_proto(proto.first_order)
     elif proto.HasField("second_order"):
         return SecondOrderAdFloat._from_proto(proto.second_order)
     elif proto.HasField("value"):
         return float(proto.value)
-
+    elif proto.HasField("variable"):
+        return Expression._from_proto(proto)
     # An empty proto evaluates to 0.0
     if not proto.ListFields():
         return 0.0

luminarycloud/types/ids.py

@@ -10,4 +10,6 @@ SimulationTemplateID = NewType("SimulationTemplateID", str)
 GeometryFeatureID = NewType("GeometryFeatureID", str)
 NamedVariableSetID = NewType("NamedVariableSetID", str)
 PhysicsAiArchitectureID = NewType("PhysicsAiArchitectureID", str)
+PhysicsAiArchitectureVersionID = NewType("PhysicsAiArchitectureVersionID", str)
 PhysicsAiModelID = NewType("PhysicsAiModelID", str)
+PhysicsAiModelVersionID = NewType("PhysicsAiModelVersionID", str)

luminarycloud/vis/__init__.py

@@ -8,12 +8,15 @@ from .visualization import (
     LookAtCamera as LookAtCamera,
 )
 
+from .primitives import (
+    Plane as Plane,
+    Box as Box,
+)
+
 from .filters import (
     Slice as Slice,
     PlaneClip as PlaneClip,
     BoxClip as BoxClip,
-    Plane as Plane,
-    Box as Box,
     FixedSizeVectorGlyphs as FixedSizeVectorGlyphs,
     ScaledVectorGlyphs as ScaledVectorGlyphs,
     RakeStreamlines as RakeStreamlines,
@@ -23,6 +26,13 @@ from .filters import (
     Isosurface as Isosurface,
 )
 
+from .data_extraction import (
+    IntersectionCurve as IntersectionCurve,
+    DataExtractor as DataExtractor,
+    ExtractOutput as ExtractOutput,
+    list_data_extracts as list_data_extracts,
+)
+
 from .display import (
     Field as Field,
     DataRange as DataRange,