fxn 0.0.35__py3-none-any.whl → 0.0.37__py3-none-any.whl

fxn/services/prediction.py

@@ -0,0 +1,456 @@
+#
+#   Function
+#   Copyright © 2024 NatML Inc. All Rights Reserved.
+#
+
+from ctypes import byref, cast, c_char_p, c_double, c_int32, c_uint8, c_void_p, create_string_buffer, string_at, CDLL, POINTER
+from dataclasses import asdict, is_dataclass
+from datetime import datetime, timezone
+from importlib import resources
+from io import BytesIO
+from json import dumps, loads
+from numpy import array, dtype, int32, ndarray, zeros
+from numpy.ctypeslib import as_array, as_ctypes_type
+from numpy.typing import NDArray
+from pathlib import Path
+from PIL import Image
+from platform import machine, system
+from pydantic import BaseModel
+from requests import get, post
+from typing import Any, AsyncIterator, Dict, List, Optional, Union
+from urllib.parse import urlparse
+
+from ..api import GraphClient
+from ..c import load_fxnc, FXNConfigurationRef, FXNDtype, FXNPredictionRef, FXNPredictorRef, FXNStatus, FXNValueRef, FXNValueFlags, FXNValueMapRef
+from ..types import Acceleration, Prediction, PredictionResource
+
+class PredictionService:
+
+    def __init__ (self, client: GraphClient):
+        self.client = client
+        self.__fxnc = PredictionService.__load_fxnc()
+        self.__cache = { }
+
+    def create (
+        self,
+        tag: str,
+        *,
+        inputs: Optional[Dict[str, Union[ndarray, str, float, int, bool, List, Dict[str, Any], Path, Image.Image]]] = None,
+        acceleration: Acceleration=Acceleration.Default,
+        client_id: str=None,
+        configuration_id: str=None
+    ) -> Prediction:
+        """
+        Create a prediction.
+
+        Parameters:
+            tag (str): Predictor tag.
+            inputs (dict): Input values.
+            acceleration (Acceleration): Prediction acceleration.
+            client_id (str): Function client identifier. Specify this to override the current client identifier.
+            configuration_id (str): Configuration identifier. Specify this to override the current client configuration identifier.
+
+        Returns:
+            Prediction: Created prediction.
+        """
+        # Check if cached
+        if tag in self.__cache:
+            return self.__predict(tag=tag, predictor=self.__cache[tag], inputs=inputs)
+        # Query
+        response = post(
+            f"{self.client.api_url}/predict/{tag}?rawOutputs=true",
+            json={ },
+            headers={
+                "Authorization": f"Bearer {self.client.access_key}",
+                "fxn-client": client_id if client_id is not None else self.__get_client_id(),
+                "fxn-configuration-token": configuration_id if configuration_id is not None else self.__get_configuration_id()
+            }
+        )
+        # Check
+        prediction = response.json()
+        try:
+            response.raise_for_status()
+        except Exception as ex:
+            error = prediction["errors"][0]["message"] if "errors" in prediction else str(ex)
+            raise RuntimeError(error)
+        # Check raw prediction
+        prediction = Prediction(**prediction)
+        if inputs is None:
+            return prediction
+        # Create edge prediction
+        predictor = self.__load(prediction, acceleration=acceleration)
+        self.__cache[tag] = predictor
+        prediction = self.__predict(tag=tag, predictor=predictor, inputs=inputs)
+        # Return
+        return prediction
+    
+    async def stream ( # INCOMPLETE # Streaming support
+        self,
+        tag: str,
+        *,
+        inputs: Dict[str, Union[float, int, str, bool, NDArray, List[Any], Dict[str, Any], Path, Image.Image]] = {},
+        acceleration: Acceleration=Acceleration.Default,
+        client_id: str=None,
+        configuration_id: str=None
+    ) -> AsyncIterator[Prediction]:
+        """
+        Create a streaming prediction.
+
+        NOTE: This feature is currently experimental.
+
+        Parameters:
+            tag (str): Predictor tag.
+            inputs (dict): Input values.
+            acceleration (Acceleration): Prediction acceleration.
+            client_id (str): Function client identifier. Specify this to override the current client identifier.
+            configuration_id (str): Configuration identifier. Specify this to override the current client configuration identifier.
+
+        Returns:
+            Prediction: Created prediction.
+        """
+        # Check if cached
+        if tag in self.__cache:
+            yield self.__predict(tag=tag, predictor=self.__cache[tag], inputs=inputs)
+            return
+        # Create prediction
+        prediction = self.create(
+            tag=tag,
+            client_id=client_id,
+            configuration_id=configuration_id
+        )
+        # Make single prediction
+        predictor = self.__load(prediction, acceleration=acceleration)
+        self.__cache[tag] = predictor
+        prediction = self.__predict(tag=tag, predictor=predictor, inputs=inputs)
+        # Yield
+        yield prediction
+    
+    @classmethod
+    def __load_fxnc (self) -> Optional[CDLL]:
+        # Get resource
+        package, resource = None, None
+        os = system()
+        if os == "Darwin":
+            package = f"fxn.lib.macos.{machine()}"
+            resource = f"Function.dylib"
+        elif os == "Linux" and False: # INCOMPLETE # Linux
+            package = f"fxn.lib.linux.{machine()}"
+            resource = f"libFunction.so"
+        elif os == "Windows":
+            package = f"fxn.lib.windows.{machine()}"
+            resource = f"Function.dll"
+        else:
+            return None
+        # Load
+        with resources.path(package, resource) as fxnc_path:
+            return load_fxnc(fxnc_path)
+
+    def __get_client_id (self) -> str:
+        # Fallback if fxnc failed to load
+        if not self.__fxnc:
+            return {
+                "Darwin":  f"macos-{machine()}",
+                "Linux": f"linux-{machine()}",
+                "Windows": f"windows-{machine()}"
+            }[system()]
+        # Get
+        buffer = create_string_buffer(64)
+        status = self.__fxnc.FXNConfigurationGetClientID(buffer, len(buffer))
+        assert status.value == FXNStatus.OK, \
+            f"Failed to retrieve prediction client identifier with status: {status.value}"
+        client_id = buffer.value.decode("utf-8")
+        # Return
+        return client_id
+
+    def __get_configuration_id (self) -> Optional[str]:
+        # Check
+        if not self.__fxnc:
+            return None
+        # Get
+        buffer = create_string_buffer(2048)
+        status = self.__fxnc.FXNConfigurationGetUniqueID(buffer, len(buffer))
+        assert status.value == FXNStatus.OK, \
+            f"Failed to retrieve prediction configuration identifier with error: {self.__class__.__status_to_error(status.value)}"
+        uid = buffer.value.decode("utf-8")
+        # Return
+        return uid
+
+    def __load (
+        self,
+        prediction: Prediction,
+        *,
+        acceleration: Acceleration=Acceleration.Default
+    ) -> type[FXNPredictorRef]:
+        fxnc = self.__fxnc
+        configuration = FXNConfigurationRef()
+        try:
+            # Create configuration
+            status = fxnc.FXNConfigurationCreate(byref(configuration))
+            assert status.value == FXNStatus.OK, \
+                f"Failed to create {prediction.tag} configuration with error: {self.__class__.__status_to_error(status.value)}"
+            status = fxnc.FXNConfigurationSetTag(configuration, prediction.tag.encode())
+            assert status.value == FXNStatus.OK, \
+                f"Failed to set configuration tag with error: {self.__class__.__status_to_error(status.value)}"
+            status = fxnc.FXNConfigurationSetToken(configuration, prediction.configuration.encode())
+            assert status.value == FXNStatus.OK, \
+                f"Failed to set configuration token with error: {self.__class__.__status_to_error(status.value)}"
+            status = fxnc.FXNConfigurationSetAcceleration(configuration, int(acceleration))
+            assert status.value == FXNStatus.OK, \
+                f"Failed to set configuration acceleration with error: {self.__class__.__status_to_error(status.value)}"
+            for resource in prediction.resources:
+                if resource.type == "fxn": # CHECK # Remove in fxnc 0.0.27
+                    continue
+                path = self.__get_resource_path(resource)
+                status = fxnc.FXNConfigurationAddResource(configuration, resource.type.encode(), str(path).encode())
+                assert status.value == FXNStatus.OK, \
+                    f"Failed to set prediction configuration resource with type {resource.type} for tag {prediction.tag} with error: {self.__class__.__status_to_error(status.value)}"
+            # Create predictor
+            predictor = FXNPredictorRef()
+            status = fxnc.FXNPredictorCreate(configuration, byref(predictor))
+            assert status.value == FXNStatus.OK, \
+                f"Failed to create prediction for tag {prediction.tag} with error: {self.__class__.__status_to_error(status.value)}"
+            # Return
+            return predictor
+        finally:
+            fxnc.FXNConfigurationRelease(configuration)
+
+    def __predict (self, *, tag: str, predictor, inputs: Dict[str, Any]) -> Prediction:
+        fxnc = self.__fxnc
+        input_map = FXNValueMapRef()
+        prediction = FXNPredictionRef()
+        try:
+            # Marshal inputs
+            status = fxnc.FXNValueMapCreate(byref(input_map))
+            assert status.value == FXNStatus.OK, \
+                f"Failed to create {tag} prediction because input values could not be provided to the predictor with error: {self.__class__.__status_to_error(status.value)}"
+            for name, value in inputs.items():
+                value = self.__to_value(value)
+                fxnc.FXNValueMapSetValue(input_map, name.encode(), value)
+            # Predict
+            status = fxnc.FXNPredictorCreatePrediction(predictor, input_map, byref(prediction))
+            assert status.value == FXNStatus.OK, \
+                f"Failed to create {tag} prediction with error: {self.__class__.__status_to_error(status.value)}"
+            # Marshal prediction
+            id = create_string_buffer(256)
+            error = create_string_buffer(2048)
+            latency = c_double()
+            status = fxnc.FXNPredictionGetID(prediction, id, len(id))
+            assert status.value == FXNStatus.OK, \
+                f"Failed to get {tag} prediction identifier with error: {self.__class__.__status_to_error(status.value)}"
+            status = fxnc.FXNPredictionGetLatency(prediction, byref(latency))
+            assert status.value == FXNStatus.OK, \
+                f"Failed to get {tag} prediction latency with error: {self.__class__.__status_to_error(status.value)}"
+            fxnc.FXNPredictionGetError(prediction, error, len(error))
+            id = id.value.decode("utf-8")
+            latency = latency.value
+            error = error.value.decode("utf-8")
+            log_length = c_int32()
+            fxnc.FXNPredictionGetLogLength(prediction, byref(log_length))
+            logs = create_string_buffer(log_length.value + 1)
+            fxnc.FXNPredictionGetLogs(prediction, logs, len(logs))
+            logs = logs.value.decode("utf-8")
+            # Marshal outputs
+            results = []
+            output_count = c_int32()
+            output_map = FXNValueMapRef()
+            status = fxnc.FXNPredictionGetResults(prediction, byref(output_map))
+            assert status.value == FXNStatus.OK, f"Failed to get {tag} prediction results with error: {self.__class__.__status_to_error(status.value)}"
+            status = fxnc.FXNValueMapGetSize(output_map, byref(output_count))
+            assert status.value == FXNStatus.OK, f"Failed to get {tag} prediction result count with error: {self.__class__.__status_to_error(status.value)}"
+            for idx in range(output_count.value):
+                name = create_string_buffer(256)
+                status = fxnc.FXNValueMapGetKey(output_map, idx, name, len(name))
+                assert status.value == FXNStatus.OK, \
+                    f"Failed to get {tag} prediction output name at index {idx} with error: {self.__class__.__status_to_error(status.value)}"
+                value = FXNValueRef()
+                status = fxnc.FXNValueMapGetValue(output_map, name, byref(value))
+                assert status.value == FXNStatus.OK, \
+                    f"Failed to get {tag} prediction output value at index {idx} with error: {self.__class__.__status_to_error(status.value)}"
+                name = name.value.decode("utf-8")
+                value = self.__to_object(value)
+                results.append(value)
+            # Return
+            return Prediction(
+                id=id,
+                tag=tag,
+                results=results if not error else None,
+                latency=latency,
+                error=error if error else None,
+                logs=logs,
+                created=datetime.now(timezone.utc).isoformat()
+            )
+        finally:
+            fxnc.FXNPredictionRelease(prediction)
+            fxnc.FXNValueMapRelease(input_map)
+    
+    def __to_value (
+        self,
+        value: Union[float, int, bool, str, NDArray, List[Any], Dict[str, Any], Image.Image, bytes, bytearray, memoryview, BytesIO, None]
+    ) -> type[FXNValueRef]:
+        value = PredictionService.__try_ensure_serializable(value)
+        fxnc = self.__fxnc
+        result = FXNValueRef()
+        if result is None:
+            fxnc.FXNValueCreateNull(byref(result))
+        elif isinstance(value, bool):
+            return self.__to_value(array(value, dtype="bool"))
+        elif isinstance(value, int):
+            return self.__to_value(array(value, dtype="int32"))
+        elif isinstance(value, float):
+            return self.__to_value(array(value, dtype="float32"))
+        elif isinstance(value, ndarray):
+            dtype = _NP_TO_FXN_DTYPE.get(value.dtype)
+            assert dtype is not None, f"Failed to convert numpy array to Function value because array data type is not supported: {value.dtype}"
+            fxnc.FXNValueCreateArray(
+                value.ctypes.data_as(c_void_p),
+                value.ctypes.shape_as(c_int32),
+                len(value.shape),
+                dtype,
+                FXNValueFlags.NONE,
+                byref(result)
+            )
+        elif isinstance(value, str):
+            fxnc.FXNValueCreateString(value.encode(), byref(result))
+        elif isinstance(value, list):
+            fxnc.FXNValueCreateList(dumps(value).encode(), byref(result))
+        elif isinstance(value, dict):
+            fxnc.FXNValueCreateDict(dumps(value).encode(), byref(result))
+        elif isinstance(value, Image.Image):
+            value = array(value)
+            status = fxnc.FXNValueCreateImage(
+                value.ctypes.data_as(c_void_p),
+                value.shape[1],
+                value.shape[0],
+                value.shape[2],
+                FXNValueFlags.COPY_DATA,
+                byref(result)
+            )
+            assert status.value == FXNStatus.OK, f"Failed to create image value with error: {self.__class__.__status_to_error(status.value)}"
+        elif isinstance(value, (bytes, bytearray, memoryview, BytesIO)):
+            copy = isinstance(value, memoryview) 
+            view = memoryview(value.getvalue() if isinstance(value, BytesIO) else value) if not isinstance(value, memoryview) else value
+            buffer = (c_uint8 * len(view)).from_buffer(view)
+            fxnc.FXNValueCreateBinary(
+                buffer,
+                len(view),
+                FXNValueFlags.COPY_DATA if copy else FXNValueFlags.NONE,
+                byref(result)
+            )
+        else:
+            raise RuntimeError(f"Failed to convert Python value to Function value because Python value has an unsupported type: {type(value)}")
+        return result
+    
+    def __to_object (
+        self,
+        value: type[FXNValueRef]
+    ) -> Union[float, int, bool, str, NDArray, List[Any], Dict[str, Any], Image.Image, BytesIO, None]:
+        # Type
+        fxnc = self.__fxnc
+        dtype = FXNDtype()
+        status = fxnc.FXNValueGetType(value, byref(dtype))
+        assert status.value == FXNStatus.OK, f"Failed to get value data type with error: {self.__class__.__status_to_error(status.value)}"
+        dtype = dtype.value
+        # Get data
+        data = c_void_p()
+        status = fxnc.FXNValueGetData(value, byref(data))
+        assert status.value == FXNStatus.OK, f"Failed to get value data with error: {self.__class__.__status_to_error(status.value)}"
+        # Get shape
+        dims = c_int32()
+        status = fxnc.FXNValueGetDimensions(value, byref(dims))
+        assert status.value == FXNStatus.OK, f"Failed to get value dimensions with error: {self.__class__.__status_to_error(status.value)}"
+        shape = zeros(dims.value, dtype=int32)
+        status = fxnc.FXNValueGetShape(value, shape.ctypes.data_as(POINTER(c_int32)), dims)
+        assert status.value == FXNStatus.OK, f"Failed to get value shape with error: {self.__class__.__status_to_error(status.value)}"
+        # Switch
+        if dtype == FXNDtype.NULL:
+            return None
+        elif dtype in _FXN_TO_NP_DTYPE:
+            dtype_c = as_ctypes_type(_FXN_TO_NP_DTYPE[dtype])
+            tensor = as_array(cast(data, POINTER(dtype_c)), shape)
+            return tensor.item() if len(tensor.shape) == 0 else tensor.copy()
+        elif dtype == FXNDtype.STRING:
+            return cast(data, c_char_p).value.decode()
+        elif dtype == FXNDtype.LIST:
+            return loads(cast(data, c_char_p).value.decode())
+        elif dtype == FXNDtype.DICT:
+            return loads(cast(data, c_char_p).value.decode())
+        elif dtype == FXNDtype.IMAGE:
+            pixel_buffer = as_array(cast(data, POINTER(c_uint8)), shape)
+            return Image.fromarray(pixel_buffer.copy())
+        elif dtype == FXNDtype.BINARY:
+            return BytesIO(string_at(data, shape[0]))
+        else:
+            raise RuntimeError(f"Failed to convert Function value to Python value because Function value has unsupported type: {dtype}")
+
+    def __get_resource_path (self, resource: PredictionResource) -> Path:
+        cache_dir = Path.home() / ".fxn" / "cache"
+        cache_dir.mkdir(exist_ok=True)
+        res_name = Path(urlparse(resource.url).path).name
+        res_path = cache_dir / res_name
+        if res_path.exists():
+            return res_path
+        req = get(resource.url)
+        req.raise_for_status()
+        with open(res_path, "wb") as f:
+            f.write(req.content)
+        return res_path
+    
+    @classmethod
+    def __try_ensure_serializable (cls, object: Any) -> Any:
+        if object is None:
+            return object
+        if isinstance(object, list):
+            return [cls.__try_ensure_serializable(x) for x in object]
+        if is_dataclass(object) and not isinstance(object, type):
+            return asdict(object)
+        if isinstance(object, BaseModel):
+            return object.model_dump(mode="json", by_alias=True)
+        return object
+    
+    @classmethod
+    def __status_to_error (cls, status: int) -> str:
+        if status == FXNStatus.ERROR_INVALID_ARGUMENT:
+            return "FXN_ERROR_INVALID_ARGUMENT"
+        elif status == FXNStatus.ERROR_INVALID_OPERATION:
+            return "FXN_ERROR_INVALID_OPERATION"
+        elif status == FXNStatus.ERROR_NOT_IMPLEMENTED:
+            return "FXN_ERROR_NOT_IMPLEMENTED"
+        return ""
+
+PREDICTION_FIELDS = f"""
+id
+tag
+type
+configuration
+resources {{
+    type
+    url
+    name
+}}
+results {{
+    data
+    type
+    shape
+}}
+latency
+error
+logs
+created
+"""
+
+_FXN_TO_NP_DTYPE = {
+    FXNDtype.FLOAT16:   dtype("float16"),
+    FXNDtype.FLOAT32:   dtype("float32"),
+    FXNDtype.FLOAT64:   dtype("float64"),
+    FXNDtype.INT8:      dtype("int8"),
+    FXNDtype.INT16:     dtype("int16"),
+    FXNDtype.INT32:     dtype("int32"),
+    FXNDtype.INT64:     dtype("int64"),
+    FXNDtype.UINT8:     dtype("uint8"),
+    FXNDtype.UINT16:    dtype("uint16"),
+    FXNDtype.UINT32:    dtype("uint32"),
+    FXNDtype.UINT64:    dtype("uint64"),
+    FXNDtype.BOOL:      dtype("bool"),
+}
+
+_NP_TO_FXN_DTYPE = { value: key for key, value in _FXN_TO_NP_DTYPE.items() }

fxn/services/predictor.py

@@ -3,19 +3,16 @@
 #   Copyright © 2024 NatML Inc. All Rights Reserved.
 #
 
-from pathlib import Path
-from typing import Dict, List, Union
+from typing import List
 
-from ..graph import GraphClient
-from ..types import Acceleration, AccessMode, Predictor, PredictorStatus, PredictorType, UploadType
-from .storage import StorageService
+from ..api import GraphClient
+from ..types import Predictor, PredictorStatus
 from .user import PROFILE_FIELDS
 
 class PredictorService:
 
-    def __init__ (self, client: GraphClient, storage: StorageService) -> None:
+    def __init__ (self, client: GraphClient) -> None:
         self.client = client
-        self.storage = storage
 
     def retrieve (self, tag: str) -> Predictor:
         """
@@ -120,70 +117,6 @@ class PredictorService:
         # Return
         return predictors
     
-    def create (
-        self,
-        tag: str,
-        notebook: Union[str, Path],
-        type: PredictorType=None,
-        access: AccessMode=None,
-        description: str=None,
-        media: Union[str, Path]=None,
-        acceleration: Acceleration=None,
-        environment: Dict[str, str]=None,
-        license: str=None,
-        overwrite: bool=None
-    ) -> Predictor:
-        """
-        Create a predictor.
-
-        Parameters:
-            tag (str): Predictor tag.
-            notebook (str | Path): Predictor notebook path or URL.
-            type (PredictorType): Predictor type. This defaults to `CLOUD`.
-            access (AccessMode): Predictor access mode. This defaults to `PRIVATE`.
-            description (str): Predictor description. This must be under 200 characters long.
-            media (str | Path): Predictor media path or URL.
-            acceleration (Acceleration): Predictor acceleration. This only applies for cloud predictors and defaults to `CPU`. 
-            environment (dict): Predictor environment variables.
-            license (str): Predictor license URL.
-            overwrite (bool): Overwrite any existing predictor with the same tag. Existing predictor will be deleted.
-
-        Returns:
-            Predictor: Created predictor.
-        """
-        # Prepare
-        environment = [{ "name": name, "value": value } for name, value in environment.items()] if environment is not None else []
-        notebook = self.storage.upload(notebook, type=UploadType.Notebook) if isinstance(notebook, Path) else notebook
-        media = self.storage.upload(media, type=UploadType.Media) if isinstance(media, Path) else media
-        # Query
-        response = self.client.query(f"""
-            mutation ($input: CreatePredictorInput!) {{
-                createPredictor (input: $input) {{
-                    {PREDICTOR_FIELDS}
-                }}
-            }}
-            """,
-            {
-                "input": {
-                    "tag": tag,
-                    "type": type,
-                    "notebook": notebook,
-                    "access": access,
-                    "description": description,
-                    "media": media,
-                    "acceleration": acceleration,
-                    "environment": environment,
-                    "overwrite": overwrite,
-                    "license": license
-                }
-            }
-        )
-        # Create predictor
-        predictor = response["createPredictor"]
-        predictor = Predictor(**predictor) if predictor else None
-        # Return
-        return predictor
-    
     def delete (self, tag: str) -> bool:
         """
         Delete a predictor.
@@ -239,14 +172,12 @@ owner {{
     {PROFILE_FIELDS}
 }}
 name
-type
 status
 access
 created
 description
 card
 media
-acceleration
 signature {{
     inputs {{
         name

fxn/services/user.py

@@ -3,7 +3,7 @@
 #   Copyright © 2024 NatML Inc. All Rights Reserved.
 #
 
-from ..graph import GraphClient
+from ..api import GraphClient
 from ..types import Profile
 
 class UserService:

fxn/types/__init__.py

@@ -6,8 +6,7 @@
 from .dtype import Dtype
 from .environment import EnvironmentVariable
 from .prediction import Prediction, PredictionResource
-from .predictor import Acceleration, AccessMode, EnumerationMember, Parameter, Predictor, PredictorStatus, PredictorType, Signature
+from .predictor import Acceleration, AccessMode, EnumerationMember, Parameter, Predictor, PredictorStatus, Signature
 from .profile import Profile
 from .storage import UploadType
-from .user import User
-from .value import Value
+from .user import User

fxn/types/prediction.py

@@ -6,8 +6,6 @@
 from pydantic import BaseModel, Field
 from typing import Any, List, Optional
 
-from .predictor import PredictorType
-
 class PredictionResource (BaseModel):
     """
     Prediction resource.
@@ -28,7 +26,6 @@ class Prediction (BaseModel):
     Members:
         id (str): Prediction identifier.
         tag (str): Predictor tag.
-        type (PredictorType): Prediction type.
         configuration (str): Prediction configuration token. This is only populated for `EDGE` predictions.
         resources (list): Prediction resources. This is only populated for `EDGE` predictions.
         results (list): Prediction results.
@@ -39,7 +36,6 @@ class Prediction (BaseModel):
     """
     id: str = Field(description="Prediction identifier.")
     tag: str = Field(description="Predictor tag.")
-    type: PredictorType = Field(description="Prediction type.")
     configuration: Optional[str] = Field(default=None, description="Prediction configuration token. This is only populated for `EDGE` predictions.")
     resources: Optional[List[PredictionResource]] = Field(default=None, description="Prediction resources. This is only populated for `EDGE` predictions.")
     results: Optional[List[Any]] = Field(default=None, description="Prediction results.")