luminarycloud 0.18.0__py3-none-any.whl → 0.19.0__py3-none-any.whl

luminarycloud/pipelines/api.py

@@ -1,14 +1,11 @@
 # Copyright 2023-2024 Luminary Cloud, Inc. All Rights Reserved.
+from typing import Literal
 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
@@ -17,21 +14,21 @@ class PipelineRecord:
     name: str
     description: str | None
     definition_yaml: str
-    create_time: datetime
-    update_time: datetime
+    created_at: datetime
+    updated_at: datetime
 
     def pipeline(self) -> Pipeline:
         return Pipeline._from_yaml(self.definition_yaml)
 
     @classmethod
-    def from_proto(cls, proto: pipelinespb.Pipeline) -> "PipelineRecord":
+    def from_json(cls, json: dict) -> "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),
+            id=json["id"],
+            name=json["name"],
+            description=json["description"],
+            definition_yaml=json["definition_yaml"],
+            created_at=datetime.fromisoformat(json["created_at"]),
+            updated_at=datetime.fromisoformat(json["updated_at"]),
         )
 
 
@@ -42,30 +39,26 @@ class PipelineJobRecord:
     project_id: str
     name: str
     description: str | None
-    status: PipelineJobStatus
-    create_time: datetime
-    update_time: datetime
+    status: Literal["pending", "running", "completed", "failed", "cancelled"]
+    created_at: datetime
+    updated_at: datetime
     started_at: datetime | None
     completed_at: datetime | None
 
     @classmethod
-    def from_proto(cls, proto: pipelinespb.PipelineJob) -> "PipelineJobRecord":
+    def from_json(cls, json: dict) -> "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
-            ),
+            id=json["id"],
+            pipeline_id=json["pipeline_id"],
+            project_id=json["project_id"],
+            name=json["name"],
+            description=json["description"],
+            status=json["status"],
+            created_at=datetime.fromisoformat(json["created_at"]),
+            updated_at=datetime.fromisoformat(json["updated_at"]),
+            started_at=datetime.fromisoformat(json["started_at"]) if json["started_at"] else None,
             completed_at=(
-                timestamp_to_datetime(proto.completed_at)
-                if proto.HasField("completed_at")
-                else None
+                datetime.fromisoformat(json["completed_at"]) if json["completed_at"] else None
             ),
         )
 
@@ -89,20 +82,21 @@ def create_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)
+    body = {
+        "name": name,
+        "definition_yaml": definition_yaml,
+        "description": description,
+    }
+    res = get_default_client().http.post("/rest/v0/pipelines", body)
+    return PipelineRecord.from_json(res)
 
 
 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]
+    res = get_default_client().http.get("/rest/v0/pipelines")
+    return [PipelineRecord.from_json(p) for p in res]
 
 
 def get_pipeline(id: str) -> PipelineRecord:
@@ -114,9 +108,8 @@ def get_pipeline(id: str) -> PipelineRecord:
     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)
+    res = get_default_client().http.get(f"/rest/v0/pipelines/{id}")
+    return PipelineRecord.from_json(res)
 
 
 def create_pipeline_job(
@@ -139,75 +132,29 @@ def create_pipeline_job(
         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)
+    arg_rows = [row.row_values for row in args.rows]
+    body = {
+        "name": name,
+        "project_id": project_id,
+        "argument_names": [p.name for p in args.params],
+        "argument_rows": arg_rows,
+    }
+
+    res = get_default_client().http.post(f"/rest/v0/pipelines/{pipeline_id}/pipeline_jobs", body)
+    return PipelineJobRecord.from_json(res)
 
 
 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)
+    res = get_default_client().http.get(f"/rest/v0/pipeline_jobs/{id}")
+    return PipelineJobRecord.from_json(res)
 
 
 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]
+    res = get_default_client().http.get("/rest/v0/pipeline_jobs")
+    return [PipelineJobRecord.from_json(p) for p in res]

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

@@ -10,8 +10,6 @@ from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union, Literal
 
 import concurrent
 
-import grpc
-
 import luminarycloud as lc
 from luminarycloud._helpers.named_variables import _named_variables_to_proto
 from luminarycloud.params.simulation.adjoint_ import Adjoint
@@ -258,19 +256,16 @@ class Project(ProtoWrapperBase):
         )
         return lc.Mesh(_mesh)
 
-    @deprecated("Use create_or_get_mesh() instead", "0.10.0")
-    def create_mesh(
+    def create_or_get_mesh(
         self,
         params: MeshAdaptationParams | MeshGenerationParams,
         *,
         name: str,
+        request_id: Optional[str] = None,
     ) -> "Mesh":
         """
-        Create a new mesh in the project.
-
-        .. deprecated:: 0.10.0
-            `create_mesh()` will be removed in v0.11.0, it is replaced by
-            `create_or_get_mesh()`.
+        Create a new mesh in the project, or return an existing mesh with the same request_id
+        if it already exists.
 
         Parameters
         ----------
@@ -279,14 +274,24 @@ class Project(ProtoWrapperBase):
             existing geometry, use MeshGenerationParams. If adapting a mesh from an existing,
             solution use MeshAdaptationParams.
         name : str
-            (Optional) Mesh name. Max 256 characters.
+            Mesh name. Max 256 characters.
+        request_id : str, optional
+            Can be useful as an idempotency key. If there's an existing Mesh with the given
+            request_id, that Mesh will be returned. If there's no existing Mesh with the given
+            request_id, then a Mesh will be created and associated with that request_id. If not
+            provided, a random request_id will be generated for the Mesh, effectively preventing it
+            from being retrieved by a future `create_or_get_mesh` request. Max 256 characters.
         """
 
+        if request_id is None:
+            request_id = str(uuid.uuid4())
+
         client = get_default_client()
 
         req = meshpb.CreateMeshRequest(
             project_id=self.id,
             name=name,
+            request_id=request_id,
         )
 
         if isinstance(params, meshpb.MeshGenerationParams):
@@ -314,39 +319,6 @@ class Project(ProtoWrapperBase):
         res: meshpb.CreateMeshResponse = client.CreateMesh(req)
         return lc.Mesh(res.mesh)
 
-    def create_or_get_mesh(
-        self,
-        params: MeshAdaptationParams | MeshGenerationParams,
-        *,
-        name: str,
-    ) -> "Mesh":
-        """
-        Create a new mesh in the project, or return an existing mesh with the same parameters
-        if it already exists.
-
-        Parameters
-        ----------
-        params : MeshGenerationParams | MeshAdaptationParams
-            The parameters to use to create the mesh. If generating a new mesh from an
-            existing geometry, use MeshGenerationParams. If adapting a mesh from an existing,
-            solution use MeshAdaptationParams.
-        name : str
-            Mesh name. Max 256 characters.
-        """
-
-        try:
-            return self.create_mesh(params, name=name)
-        except grpc.RpcError as e:
-            if e.code() == grpc.StatusCode.ALREADY_EXISTS:
-                message = e.details()
-                match = re.search(r"mesh-[a-f0-9-]+$", message)
-                if match:
-                    existing_mesh_id = match.group(0)
-                    req = meshpb.GetMeshRequest(id=existing_mesh_id)
-                    res = get_default_client().GetMesh(req)
-                    return lc.Mesh(res.mesh)
-            raise
-
     def _create_hex_mesh(
         self,
         names_to_file_paths: Dict[str, Union[PathLike[Any], str]],
@@ -898,6 +870,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

@@ -518,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.
@@ -535,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/tables.py

@@ -10,7 +10,6 @@ from typing import Union
 from .enum import TableType, QuantityType
 from ._helpers import CodeRepr
 from ._proto.table import table_pb2 as tablepb
-from ._proto.quantity import quantity_pb2 as quantitypb
 
 
 def create_rectilinear_table(
@@ -37,30 +36,30 @@ def create_rectilinear_table(
     def lc_defined_header(table_type: TableType) -> list[Union[int, str]]:
         """Returns the required header (if any) for a type of table."""
         if table_type == TableType.MONITOR_POINTS:
-            return [quantitypb.LENGTH, quantitypb.LENGTH, quantitypb.LENGTH, "name", "id"]
+            return [QuantityType.LENGTH, QuantityType.LENGTH, QuantityType.LENGTH, "name", "id"]
         elif table_type == TableType.RADIAL_DISTRIBUTION:
             return [
-                quantitypb.RELATIVE_RADIUS,
-                quantitypb.THRUST_PROFILE,
-                quantitypb.TORQUE_PROFILE,
-                quantitypb.RADIAL_FORCE_PROFILE,
+                QuantityType.RELATIVE_RADIUS,
+                QuantityType.THRUST_PROFILE,
+                QuantityType.TORQUE_PROFILE,
+                QuantityType.RADIAL_FORCE_PROFILE,
             ]
         elif table_type == TableType.BLADE_GEOMETRY:
             return [
-                quantitypb.RELATIVE_RADIUS,
-                quantitypb.TWIST_ANGLE,
-                quantitypb.SWEEP_ANGLE,
-                quantitypb.ANHEDRAL_ANGLE,
-                quantitypb.RELATIVE_CHORD,
+                QuantityType.RELATIVE_RADIUS,
+                QuantityType.TWIST_ANGLE,
+                QuantityType.SWEEP_ANGLE,
+                QuantityType.ANHEDRAL_ANGLE,
+                QuantityType.RELATIVE_CHORD,
             ]
         elif table_type == TableType.PROFILE_BC:
             return []
         elif table_type == TableType.FAN_CURVE:
-            return [quantitypb.VOLUME_FLOW_RATE, quantitypb.PRESSURE_RISE]
+            return [QuantityType.VOLUME_FLOW_RATE, QuantityType.PRESSURE_RISE]
         elif table_type == TableType.CUSTOM_SAMPLE_DOE:
             return []
         elif table_type == TableType.TEMP_VARYING:
-            return [quantitypb.TEMPERATURE, "quantity"]
+            return [QuantityType.TEMPERATURE, "quantity"]
         else:
             raise RuntimeError("Unknown type of table.")
 
@@ -113,7 +112,7 @@ def create_rectilinear_table(
         if isinstance(first_header, str):
             table.header.axis_label[-1].name = first_header
         else:
-            table.header.axis_label[-1].quantity = QuantityType(first_header).value
+            table.header.axis_label[-1].quantity = first_header.value
         table.axis.append(tablepb.Axis())
 
     for label in header[has_axis(table_type) :]:
@@ -121,7 +120,7 @@ def create_rectilinear_table(
         if isinstance(label, str):
             table.header.record_label[-1].name = label
         else:
-            table.header.record_label[-1].quantity = QuantityType(label).value
+            table.header.record_label[-1].quantity = label.value
 
     types = data_types(table_type, len(header))
 

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]