luminarycloud 0.22.0__py3-none-any.whl → 0.22.2__py3-none-any.whl

luminarycloud/physics_ai/inference.py

@@ -1,217 +1,184 @@
 # File: python/sdk/luminarycloud/inference/inference.py
 # Copyright 2025 Luminary Cloud, Inc. All Rights Reserved.
-from datetime import datetime
-from typing import Any, Callable, Dict, Optional
-from json import loads as json_loads, dumps as json_dumps
-from dataclasses import dataclass
-import base64
-import os
-import urllib.request
-
-from .._client import get_default_client
-from .._helpers._timestamp_to_datetime import timestamp_to_datetime
-from .._proto.api.v0.luminarycloud.inference import inference_pb2 as inferencepb
-from .._proto.inferenceservice import inferenceservice_pb2 as inferenceservicepb
+from typing import Any
+from enum import IntEnum
+from google.protobuf.json_format import MessageToDict
 from .._wrapper import ProtoWrapper, ProtoWrapperBase
-from ..project import Project
-from ..project import Project
-from .._helpers import upload_file
-from .._proto.upload import upload_pb2 as uploadpb
-from ..types.ids import PhysicsAiModelVersionID
+from .._proto.api.v0.luminarycloud.physicsaiinference import (
+    physicsaiinference_pb2 as physicsaiinferencepb,
+)
+from .._proto.base import base_pb2 as basepb
 
 
-@dataclass
-class ExtAeroInferenceResult:
-    """Result of an external aerodynamic inference job.
+class VisualizationOutput(IntEnum):
+    """
+    Represents the type of visualization output.
 
     Attributes
     ----------
-    drag_force: float
-        The drag force returned from the inference.
-    lift_force: float
-        The lift force returned from the inference.
-    wall_shear_stress:
-        A dict containing wall shear stress data, or None if not available.
-    pressure_surface:
-        A dict containing pressure surface stress data, or None if not available.
+    INVALID
+        Invalid visualization output type.
+    LUMINARY
+        Luminary visualization format.
+    VTK
+        VTK visualization format.
     """
 
-    drag_force: float
-    lift_force: float
-    wall_shear_stress: dict[str, Any] | None
-    pressure_surface: dict[str, Any] | None
-
-    def __init__(self, inference_result: dict[str, Any]) -> None:
-        self.drag_force = inference_result["drag_force"]
-        self.lift_force = inference_result["lift_force"]
-        self.wall_shear_stress = inference_result.get("wall-shear-stress", None)
-        self.pressure_surface = inference_result.get("pressure_surface", None)
-
-
-def external_aero_inference(
-    project: Project,
-    stl_file: str,
-    model_version_id: PhysicsAiModelVersionID,
-    conditions: Optional[Dict[str, Any]] = None,
-    settings: Optional[Dict[str, Any]] = None,
-    write_visualization_data=False,
-) -> ExtAeroInferenceResult:
-    """Performs an inference job returning external aerodynamic results.
-    Parameters
-    ----------
-    project : Project
-        The project to which the inference files will be added.
-    stl_file : str
-        Fullpath the STL file to be used for inference.
-    model_version_id : PhysicsAiModelVersionID
-        The ID of the trained model version to use for inference.
-    conditions : Dict[str, Any], optional
-        Dictionary of conditions to be passed to the inference service (e.g., alpha, beta, etc.).
-    settings : Dict[str, Any], optional
-        Dictionary of settings to be passed to inference service (e.g., stencil_size)
-    write_visualization_data : bool, optional
-        Whether to write LC visualization data for visualization by Luminary.
-
-
-    Returns
-    ExtAeroInferenceResult
-        Result of the external aerodynamic inference job.
-
-    warning:: This feature is experimental and may change or be removed without notice.
+    INVALID = physicsaiinferencepb.INVALID
+    LUMINARY = physicsaiinferencepb.LUMINARY
+    VTK = physicsaiinferencepb.VTK
+
+
+class InferenceFieldType(IntEnum):
     """
+    Represents the type of an inference field.
 
-    result = perform_inference(
-        project, stl_file, model_version_id, conditions, settings, write_visualization_data
-    )
-    return ExtAeroInferenceResult(result)
-
-
-def perform_inference(
-    project: Project,
-    stl_file: str,
-    model_version_id: PhysicsAiModelVersionID,
-    conditions: Optional[Dict[str, Any]] = None,
-    settings: Optional[Dict[str, Any]] = None,
-    write_visualization_data=False,
-) -> dict[str, Any]:
-    """Creates an inference service job.
-    Parameters
+    Attributes
     ----------
-    project : Project
-        The project to which the inference files will be added.
-    stl_file : str
-        Fullpath the STL file to be used for inference.
-    model_version_id : PhysicsAiModelVersionID
-        The ID of the trained model version to use for inference.
-    conditions : Dict[str, Any], optional
-        Dictionary of conditions to be passed to the inference service (e.g., alpha, beta, etc.).
-    settings : Dict[str, Any], optional
-        Dictionary of settings to be passed to inference service (e.g., stencil_size)
-    write_visualization_data : bool, optional
-        Whether to write LC visualization data for visualization by Luminary.
-
-
-    Returns
-    dict[str, Any]
-        Response from the server as key-value pairs.
-
-    warning:: This feature is experimental and may change or be removed without notice.
+    UNKNOWN_TYPE
+        Unknown field type.
+    SCALAR
+        Scalar field type (single value).
+    VECTOR
+        Vector field type (multiple values).
     """
 
-    client = get_default_client()
-
-    def upload_if_file(fname: str) -> str:
-        if os.path.exists(fname) and os.path.isfile(fname):
-            params = uploadpb.ResourceParams()
-            result = upload_file(client, project.id, params, fname)
-            return result[1].url
-        if fname.startswith("gs://"):
-            return fname
-        raise RuntimeError("Unsupported file for inference")
-
-    def future_file(url: str) -> Callable[[], dict[str, Any]]:
-        def download_file() -> dict[str, Any]:
-            with urllib.request.urlopen(url) as f:
-                serialized = f.read()
-                jsondata = json_loads(serialized)
-                data = base64.b64decode(jsondata["data"])
-                jsondata["data"] = data
-                return jsondata
-
-        return download_file
-
-    stl_url = upload_if_file(stl_file)
-
-    raw = start_inference_job(
-        project, stl_url, model_version_id, conditions, settings, write_visualization_data
-    )
-    currated: dict[str, Any] = {}
-    for k, v in raw.items():
-        if isinstance(v, str) and v.startswith("https://"):
-            tmp = future_file(v)
-            if k.endswith("_url"):
-                currated[k[:-4]] = tmp
-                currated[k] = v
-            else:
-                currated[k] = tmp
-                currated[k + "_url"] = v
-        else:
-            currated[k] = v
-    return currated
-
-
-def start_inference_job(
-    project: Project,
-    stl_url: str,
-    model_version_id: PhysicsAiModelVersionID,
-    conditions: Optional[Dict[str, Any]] = None,
-    settings: Optional[Dict[str, Any]] = None,
-    write_visualization_data=False,
-) -> dict[str, Any]:
-    """Creates an inference service job.
-    Parameters
+    UNKNOWN_TYPE = physicsaiinferencepb.UNKNOWN_TYPE
+    SCALAR = physicsaiinferencepb.SCALAR
+    VECTOR = physicsaiinferencepb.VECTOR
+
+
+class InferenceFieldCategory(IntEnum):
+    """
+    Represents the category of an inference field.
+
+    Attributes
     ----------
-    project : Project
-        Reference to a project.
-    stl_url : str
-        URL of the STL file to be used for inference.
-    model_version_id : PhysicsAiModelVersionID
-        The ID of the trained model version to use for inference.
-    conditions : Dict[str, Any], optional
-        Dictionary of conditions to be passed to the inference service (e.g., alpha, beta, etc.).
-    settings : Dict[str, Any], optional
-        Dictionary of settings to be passed to inference service (e.g., stencil_size)
-    write_visualization_data : bool, optional
-        Whether to write LC visualization data for visualization by Luminary.
-
-
-    Returns
-    dict[str, Any]
-        Response from the server as key-value pairs.
-
-    warning:: This feature is experimental and may change or be removed without notice.
+    UNKNOWN_CATEGORY
+        Unknown field category.
+    NUMERIC
+        Numeric field category (e.g., forces, moments).
+    SURFACE
+        Surface field category (e.g., surface pressure).
+    VOLUME
+        Volume field category (e.g., velocity, pressure).
     """
 
-    # Embed settings and store as bytes
-    settings_bytes = b""
-    if settings is not None:
-        settings_bytes = json_dumps(settings).encode("utf-8")
-
-    # Convert parameters dict to bytes if provided
-    conditions_bytes = b""
-    if conditions is not None:
-        conditions_bytes = json_dumps(conditions).encode("utf-8")
-
-    req = inferencepb.CreateInferenceServiceJobRequest(
-        stl_url=stl_url,
-        model_version_id=str(model_version_id),
-        conditions=conditions_bytes,
-        settings=settings_bytes,
-        project_id=project.id,
-        write_visualization_data=write_visualization_data,
-    )
-    res: inferencepb.CreateInferenceServiceJobResponse = (
-        get_default_client().CreateInferenceServiceJob(req)
-    )
-
-    return json_loads(str(res.response, encoding="utf-8"))
+    UNKNOWN_CATEGORY = physicsaiinferencepb.UNKNOWN_CATEGORY
+    NUMERIC = physicsaiinferencepb.NUMERIC
+    SURFACE = physicsaiinferencepb.SURFACE
+    VOLUME = physicsaiinferencepb.VOLUME
+
+
+@ProtoWrapper(physicsaiinferencepb.VisualizationExport)
+class VisualizationExport(ProtoWrapperBase):
+    """Represents a visualization export."""
+
+    type: VisualizationOutput
+    url: str
+    _proto: physicsaiinferencepb.VisualizationExport
+
+    def get_url(self) -> str:
+        return self.url
+
+
+@ProtoWrapper(physicsaiinferencepb.NumericResult)
+class NumericResult(ProtoWrapperBase):
+    """Represents a numeric result."""
+
+    scalar: float
+    vector: list[float]
+    _proto: physicsaiinferencepb.NumericResult
+
+    def get_value(self) -> Any:
+        if self._proto.HasField("scalar"):
+            return self.scalar
+        if self._proto.HasField("vector"):
+            return list(self._proto.vector.values)
+        return None
+
+
+@ProtoWrapper(physicsaiinferencepb.SurfaceForInference)
+class SurfaceForInference(ProtoWrapperBase):
+    """Represents a surface for inference."""
+
+    name: str
+    url: str
+    _proto: physicsaiinferencepb.SurfaceForInference
+
+    def get_name(self) -> str:
+        return self.name
+
+    def get_url(self) -> str:
+        return self.url
+
+
+@ProtoWrapper(physicsaiinferencepb.InferenceResult)
+class InferenceResult(ProtoWrapperBase):
+    """Represents an inference result."""
+
+    name: str
+    surface_results: dict[str, str]
+    volume_results: dict[str, str]
+    visualizations: list[VisualizationExport]
+
+    @property
+    def number_outputs(self) -> dict[str, NumericResult]:
+        """Returns number_outputs with wrapped NumericResult values."""
+        return {k: NumericResult(v) for k, v in self._proto.number_outputs.items()}
+
+    def get_number_outputs(self) -> dict[str, Any]:
+        return MessageToDict(self._proto.number_outputs, preserving_proto_field_name=True)
+
+    def get_surface_results(self) -> dict[str, Any]:
+        return MessageToDict(self.surface_results, preserving_proto_field_name=True)
+
+    def get_volume_results(self) -> dict[str, Any]:
+        return MessageToDict(self.volume_results, preserving_proto_field_name=True)
+
+    def get_visualizations(self) -> list[dict[str, Any]]:
+        return [
+            MessageToDict(viz._proto, preserving_proto_field_name=True)
+            for viz in self.visualizations
+        ]
+
+
+@ProtoWrapper(physicsaiinferencepb.InferenceServiceJob)
+class InferenceJob(ProtoWrapperBase):
+    """Represents an inference service job."""
+
+    job_id: str
+    status: basepb.JobStatus
+    results: list[InferenceResult]
+    merged_visualizations: list[VisualizationExport]
+    _proto: physicsaiinferencepb.InferenceServiceJob
+
+    @property
+    def id(self) -> str:
+        """Alias for job_id for convenience."""
+        return self.job_id
+
+    def get_status(self) -> str:
+        return basepb.JobStatusType.Name(self.status.typ)
+
+    def get_results(self) -> list[dict[str, Any]]:
+        return [
+            MessageToDict(result._proto, preserving_proto_field_name=True)
+            for result in self.results
+        ]
+
+    def get_merged_visualizations(self) -> list[dict[str, Any]]:
+        return [
+            MessageToDict(viz._proto, preserving_proto_field_name=True)
+            for viz in self.merged_visualizations
+        ]
+
+
+@ProtoWrapper(physicsaiinferencepb.InferenceField)
+class InferenceField(ProtoWrapperBase):
+    """Represents an inference field."""
+
+    name: str
+    type: InferenceFieldType
+    category: InferenceFieldCategory
+    _proto: physicsaiinferencepb.InferenceField

luminarycloud/physics_ai/models.py

@@ -3,6 +3,9 @@ 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 .._proto.api.v0.luminarycloud.physicsaiinference import (
+    physicsaiinference_pb2 as physicsaiinferencepb,
+)
 from .._wrapper import ProtoWrapper, ProtoWrapperBase
 from ..types.ids import PhysicsAiModelID, PhysicsAiModelVersionID
 from ..enum.physics_ai_lifecycle_state import PhysicsAiLifecycleState
@@ -21,6 +24,25 @@ class PhysicsAiModelVersion(ProtoWrapperBase):
     lifecycle_state: PhysicsAiLifecycleState
     _proto: physaipb.PhysicsAiModelVersion
 
+    def get_inference_fields(self) -> list[str]:
+        """Gets the inference fields available for a trained model version.
+
+        This retrieves the list of output fields that can be requested from a specific
+        model version during inference.
+
+        Returns
+        -------
+        list[str]
+            List of available inference field names that can be requested from the model.
+
+        warning:: This feature is experimental and may change or be removed without notice.
+        """
+        req = physicsaiinferencepb.GetInferenceFieldsRequest(model_version_id=str(self.id))
+        res: physicsaiinferencepb.GetInferenceFieldsResponse = (
+            get_default_client().GetInferenceFields(req)
+        )
+        return list(res.inference_fields)
+
 
 @ProtoWrapper(physaipb.PhysicsAiModel)
 class PhysicsAiModel(ProtoWrapperBase):

luminarycloud/physics_ai/solution.py

@@ -17,6 +17,7 @@ def _download_processed_solution_physics_ai(  # noqa: F841
     process_volume: bool = False,
     single_precision: bool = True,
     internal_options: Optional[Dict[str, str]] = None,
+    export_surface_groups: Optional[Dict[str, List[str]]] = None,
 ) -> tarfile.TarFile:
     """
     Download solution data with physics AI processing applied.
@@ -37,6 +38,8 @@ def _download_processed_solution_physics_ai(  # noqa: F841
             If None, all available volume fields are included.
         process_volume: Whether to process volume data
         single_precision: Whether to use single precision for floating point fields
+        export_surface_groups: Dictionary mapping group names to lists of surface names.
+            Each group will be exported as an individual STL file.
 
     Raises:
         ValueError: If invalid field names are provided
@@ -46,6 +49,7 @@ def _download_processed_solution_physics_ai(  # noqa: F841
         get_default_client(),
         solution_id,
         exclude_surfaces=exclude_surfaces,
+        export_surface_groups=export_surface_groups,
         fill_holes=fill_holes,
         surface_fields_to_keep=surface_fields_to_keep,
         volume_fields_to_keep=volume_fields_to_keep,