fxn 0.0.40__py3-none-any.whl → 0.0.42__py3-none-any.whl

fxn/c/prediction.py

@@ -1,37 +1,76 @@
 #
 #   Function
-#   Copyright © 2024 NatML Inc. All Rights Reserved.
+#   Copyright © 2025 NatML Inc. All Rights Reserved.
 #
 
-from ctypes import c_char_p, c_double, c_int32, CDLL, POINTER, Structure
-from .status import FXNStatus
-from .map import FXNValueMapRef
-
-class FXNPrediction(Structure): pass
-
-FXNPredictionRef = POINTER(FXNPrediction)
-
-def _register_fxn_prediction (fxnc: CDLL) -> CDLL:
-    # FXNPredictionRelease
-    fxnc.FXNPredictionRelease.argtypes = [FXNPredictionRef]
-    fxnc.FXNPredictionRelease.restype = FXNStatus
-    # FXNPredictionGetID
-    fxnc.FXNPredictionGetID.argtypes = [FXNPredictionRef, c_char_p, c_int32]
-    fxnc.FXNPredictionGetID.restype = FXNStatus
-    # FXNPredictionGetLatency
-    fxnc.FXNPredictionGetLatency.argtypes = [FXNPredictionRef, POINTER(c_double)]
-    fxnc.FXNPredictionGetLatency.restype = FXNStatus
-    # FXNPredictionGetResults
-    fxnc.FXNPredictionGetResults.argtypes = [FXNPredictionRef, POINTER(FXNValueMapRef)]
-    fxnc.FXNPredictionGetResults.restype = FXNStatus
-    # FXNPredictionGetError
-    fxnc.FXNPredictionGetError.argtypes = [FXNPredictionRef, c_char_p, c_int32]
-    fxnc.FXNPredictionGetError.restype = FXNStatus
-    # FXNPredictionGetLogs
-    fxnc.FXNPredictionGetLogs.argtypes = [FXNPredictionRef, c_char_p, c_int32]
-    fxnc.FXNPredictionGetLogs.restype = FXNStatus
-    # FXNPredictionGetLogLength
-    fxnc.FXNPredictionGetLogLength.argtypes = [FXNPredictionRef, POINTER(c_int32)]
-    fxnc.FXNPredictionGetLogLength.restype = FXNStatus
-    # Return
-    return fxnc
+from ctypes import byref, c_double, c_int32, c_void_p, create_string_buffer
+from pathlib import Path
+from typing import final
+
+from .fxnc import get_fxnc, status_to_error, FXNStatus
+from .map import ValueMap
+
+@final
+class Prediction:
+
+    def __init__ (self, prediction):
+        self.__prediction = prediction
+
+    @property
+    def id (self) -> str:
+        id = create_string_buffer(256)
+        status = get_fxnc().FXNPredictionGetID(self.__prediction, id, len(id))
+        if status == FXNStatus.OK:
+            return id.value.decode("utf-8")
+        else:
+            raise RuntimeError(f"Failed to get prediction id with error: {status_to_error(status)}")
+    
+    @property
+    def latency (self) -> float:
+        latency = c_double()
+        status = get_fxnc().FXNPredictionGetLatency(self.__prediction, byref(latency))
+        if status == FXNStatus.OK:
+            return latency.value
+        else:
+            raise RuntimeError(f"Failed to get prediction latency with error: {status_to_error(status)}")
+
+    @property
+    def results (self) -> ValueMap | None:
+        map = c_void_p()
+        status = get_fxnc().FXNPredictionGetResults(self.__prediction, byref(map))
+        if status != FXNStatus.OK:
+            raise RuntimeError(f"Failed to get prediction results with error: {status_to_error(status)}")
+        map = ValueMap(map, owner=False)
+        return map if len(map) > 0 else None
+
+    @property
+    def error (self) -> str | None:
+        error = create_string_buffer(2048)
+        get_fxnc().FXNPredictionGetError(self.__prediction, error, len(error))
+        error = error.value.decode("utf-8")
+        return error if error else None
+
+    @property
+    def logs (self) -> str:
+        fxnc = get_fxnc()
+        log_length = c_int32()
+        status = fxnc.FXNPredictionGetLogLength(self.__prediction, byref(log_length))
+        if status != FXNStatus.OK:
+            raise RuntimeError(f"Failed to get prediction log length with error: {status_to_error(status)}")
+        logs = create_string_buffer(log_length.value + 1)
+        status = fxnc.FXNPredictionGetLogs(self.__prediction, logs, len(logs))
+        if status == FXNStatus.OK:
+            return logs.value.decode("utf-8")
+        else:
+            raise RuntimeError(f"Failed to get prediction logs with error: {status_to_error(status)}")
+
+    def __enter__ (self):
+        return self
+
+    def __exit__ (self, exc_type, exc_value, traceback):
+        self.__release()
+
+    def __release (self):
+        if self.__prediction:
+            get_fxnc().FXNPredictionRelease(self.__prediction)
+        self.__prediction = None

fxn/c/predictor.py

@@ -1,31 +1,59 @@
 #
 #   Function
-#   Copyright © 2024 NatML Inc. All Rights Reserved.
+#   Copyright © 2025 NatML Inc. All Rights Reserved.
 #
 
-from ctypes import CDLL, POINTER, Structure
-from .configuration import FXNConfigurationRef
-from .prediction import FXNPredictionRef
-from .stream import FXNPredictionStreamRef
-from .status import FXNStatus
-from .map import FXNValueMapRef
-
-class FXNPredictor(Structure): pass
-
-FXNPredictorRef = POINTER(FXNPredictor)
-
-def _register_fxn_predictor (fxnc: CDLL) -> CDLL:
-    # FXNPredictorCreate
-    fxnc.FXNPredictorCreate.argtypes = [FXNConfigurationRef, POINTER(FXNPredictorRef)]
-    fxnc.FXNPredictorCreate.restype = FXNStatus
-    # FXNPredictorRelease
-    fxnc.FXNPredictorRelease.argtypes = [FXNPredictorRef]
-    fxnc.FXNPredictorRelease.restype = FXNStatus
-    # FXNPredictorCreatePrediction
-    fxnc.FXNPredictorCreatePrediction.argtypes = [FXNPredictorRef, FXNValueMapRef, POINTER(FXNPredictionRef)]
-    fxnc.FXNPredictorCreatePrediction.restype = FXNStatus
-    # FXNPredictorStreamPrediction
-    fxnc.FXNPredictorStreamPrediction.argtypes = [FXNPredictionRef, FXNValueMapRef, POINTER(FXNPredictionStreamRef)]
-    fxnc.FXNPredictorStreamPrediction.restype = FXNStatus
-    # Return
-    return fxnc
+from ctypes import byref, c_void_p
+from typing import final
+
+from .configuration import Configuration
+from .fxnc import get_fxnc, status_to_error, FXNStatus
+from .map import ValueMap
+from .prediction import Prediction
+from .stream import PredictionStream
+
+@final
+class Predictor:
+
+    def __init__ (self, configuration: Configuration):
+        predictor = c_void_p()
+        status = get_fxnc().FXNPredictorCreate(configuration._Configuration__configuration, byref(predictor))
+        if status == FXNStatus.OK:
+            self.__predictor = predictor
+        else:
+            raise RuntimeError(f"Failed to create predictor with error: {status_to_error(status)}")
+
+    def create_prediction (self, inputs: ValueMap) -> Prediction:
+        prediction = c_void_p()
+        status = get_fxnc().FXNPredictorCreatePrediction(
+            self.__predictor,
+            inputs._ValueMap__map,
+            byref(prediction)
+        )
+        if status == FXNStatus.OK:
+            return Prediction(prediction)
+        else:
+            raise RuntimeError(f"Failed to create prediction with error: {status_to_error(status)}")
+
+    def stream_prediction (self, inputs: ValueMap) -> PredictionStream:
+        stream = c_void_p()
+        status = get_fxnc().FXNPredictorStreamPrediction(
+            self.__predictor,
+            inputs._ValueMap__map,
+            byref(stream)
+        )
+        if status == FXNStatus.OK:
+            return PredictionStream(stream)
+        else:
+            raise RuntimeError(f"Failed to stream prediction with error: {status_to_error(status)}")
+
+    def __enter__ (self):
+        return self
+
+    def __exit__ (self, exc_type, exc_value, traceback):
+        self.__release()
+
+    def __release (self):
+        if self.__predictor:
+            get_fxnc().FXNPredictorRelease(self.__predictor)
+        self.__predictor = None

fxn/c/stream.py

@@ -1,22 +1,40 @@
 #
 #   Function
-#   Copyright © 2024 NatML Inc. All Rights Reserved.
+#   Copyright © 2025 NatML Inc. All Rights Reserved.
 #
 
-from ctypes import CDLL, POINTER, Structure
-from .prediction import FXNPredictionRef
-from .status import FXNStatus
+from ctypes import byref, c_void_p
+from typing import final
 
-class FXNPredictionStream(Structure): pass
+from .fxnc import get_fxnc, status_to_error, FXNStatus
+from .prediction import Prediction
 
-FXNPredictionStreamRef = POINTER(FXNPredictionStream)
+@final
+class PredictionStream:
 
-def _register_fxn_prediction_stream (fxnc: CDLL) -> CDLL:
-    # FXNPredictionStreamRelease
-    fxnc.FXNPredictionStreamRelease.argtypes = [FXNPredictionStreamRef]
-    fxnc.FXNPredictionStreamRelease.restype = FXNStatus
-    # FXNPredictionStreamReadNext
-    fxnc.FXNPredictionStreamReadNext.argtypes = [FXNPredictionStreamRef, POINTER(FXNPredictionRef)]
-    fxnc.FXNPredictionStreamReadNext.restype = FXNStatus
-    # Return
-    return fxnc
+    def __init__ (self, stream):
+        self.__stream = stream
+
+    def __iter__ (self):
+        return self
+    
+    def __next__ (self) -> Prediction:
+        prediction = c_void_p()
+        status = get_fxnc().FXNPredictionStreamReadNext(self.__stream, byref(prediction))
+        if status == FXNStatus.ERROR_INVALID_OPERATION:
+            raise StopIteration()
+        elif status != FXNStatus.OK:
+            raise RuntimeError(f"Failed to read next prediction in stream with error: {status_to_error(status)}")
+        else:
+            return Prediction(prediction)
+
+    def __enter__ (self):
+        return self
+
+    def __exit__ (self, exc_type, exc_value, traceback):
+        self.__release()
+
+    def __release (self):
+        if self.__stream:
+            get_fxnc().FXNPredictionStreamRelease(self.__stream)
+        self.__stream = None

fxn/c/value.py

@@ -1,50 +1,223 @@
 #
 #   Function
-#   Copyright © 2024 NatML Inc. All Rights Reserved.
+#   Copyright © 2025 NatML Inc. All Rights Reserved.
 #
 
-from ctypes import c_char_p, c_int, c_int32, c_void_p, CDLL, POINTER, Structure
-from .dtype import FXNDtype
-from .status import FXNStatus
+from __future__ import annotations
+from collections.abc import Iterable
+from enum import IntFlag
+from ctypes import byref, cast, c_char_p, c_int, c_int32, c_uint8, c_void_p, string_at, POINTER
+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 PIL import Image
+from typing import final, Any
 
-class FXNValueFlags(c_int):
+from ..types import Dtype
+from .fxnc import get_fxnc, status_to_error, FXNStatus
+
+class ValueFlags (IntFlag):
     NONE = 0
     COPY_DATA = 1
 
-class FXNValue(Structure): pass
-
-FXNValueRef = POINTER(FXNValue)
-
-def _register_fxn_value (fxnc: CDLL) -> CDLL:
-    # FXNValueRelease
-    fxnc.FXNValueRelease.argtypes = [FXNValueRef]
-    fxnc.FXNValueRelease.restype = FXNStatus
-    # FXNValueGetData
-    fxnc.FXNValueGetData.argtypes = [FXNValueRef, POINTER(c_void_p)]
-    fxnc.FXNValueGetData.restype = FXNStatus
-    # FXNValueGetType
-    fxnc.FXNValueGetType.argtypes = [FXNValueRef, POINTER(FXNDtype)]
-    fxnc.FXNValueGetType.restype = FXNStatus
-    # FXNValueGetDimensions
-    fxnc.FXNValueGetDimensions.argtypes = [FXNValueRef, POINTER(c_int32)]
-    fxnc.FXNValueGetDimensions.restype = FXNStatus
-    # FXNValueGetShape
-    fxnc.FXNValueGetShape.argtypes = [FXNValueRef, POINTER(c_int32), c_int32]
-    fxnc.FXNValueGetShape.restype = FXNStatus
-    # FXNValueCreateArray
-    fxnc.FXNValueCreateArray.argtypes = [c_void_p, POINTER(c_int32), c_int32, FXNDtype, FXNValueFlags, POINTER(FXNValueRef)]
-    fxnc.FXNValueCreateArray.restype = FXNStatus
-    # FXNValueCreateString
-    fxnc.FXNValueCreateString.argtypes = [c_char_p, POINTER(FXNValueRef)]
-    fxnc.FXNValueCreateString.restype = FXNStatus
-    # FXNValueCreateList
-    fxnc.FXNValueCreateList.argtypes = [c_char_p, POINTER(FXNValueRef)]
-    fxnc.FXNValueCreateList.restype = FXNStatus
-    # FXNValueCreateDict
-    fxnc.FXNValueCreateDict.argtypes = [c_char_p, POINTER(FXNValueRef)]
-    fxnc.FXNValueCreateDict.restype = FXNStatus
-    # FXNValueCreateImage
-    fxnc.FXNValueCreateImage.argtypes = [c_void_p, c_int32, c_int32, c_int32, FXNValueFlags, POINTER(FXNValueRef)]
-    fxnc.FXNValueCreateImage.restype = FXNStatus
-    # Return
-    return fxnc
+@final
+class Value:
+
+    def __init__ (self, value, *, owner: bool=True):
+        self.__value = value
+        self.__owner = owner
+
+    @property
+    def data (self):
+        data = c_void_p()
+        status = get_fxnc().FXNValueGetData(self.__value, byref(data))
+        if status == FXNStatus.OK:
+            return data
+        else:
+            raise RuntimeError(f"Failed to get value data with error: {status_to_error(status)}")
+
+    @property
+    def type (self) -> Dtype:
+        dtype = c_int()
+        status = get_fxnc().FXNValueGetType(self.__value, byref(dtype))
+        if status == FXNStatus.OK:
+            return _DTYPE_TO_STR.get(dtype.value)
+        else:
+            raise RuntimeError(f"Failed to get value data type with error: {status_to_error(status)}")
+
+    @property
+    def shape (self) -> list[int] | None:
+        if self.type not in _TENSOR_DTYPES:
+            return None
+        fxnc = get_fxnc()
+        dims = c_int32()
+        status = fxnc.FXNValueGetDimensions(self.__value, byref(dims))
+        if status != FXNStatus.OK:
+            raise RuntimeError(f"Failed to get value dimensions with error: {status_to_error(status)}")
+        shape = zeros(dims.value, dtype=int32)
+        status = fxnc.FXNValueGetShape(self.__value, shape.ctypes.data_as(POINTER(c_int32)), dims)
+        if status == FXNStatus.OK:
+            return shape.tolist()
+        else:
+            raise RuntimeError(f"Failed to get value shape with error: {status_to_error(status)}")
+
+    def to_object (self) -> Any:
+        type = self.type
+        if type == Dtype.null:
+            return None
+        elif type in _TENSOR_DTYPES:
+            ctype = as_ctypes_type(dtype(type))
+            tensor = as_array(cast(self.data, POINTER(ctype)), self.shape)
+            return tensor.item() if len(tensor.shape) == 0 else tensor.copy()
+        elif type == Dtype.string:
+            return cast(self.data, c_char_p).value.decode()
+        elif type in [Dtype.list, Dtype.dict]:
+            return loads(cast(self.data, c_char_p).value.decode())
+        elif type == Dtype.image:
+            pixel_buffer = as_array(cast(self.data, POINTER(c_uint8)), self.shape)
+            return Image.fromarray(pixel_buffer.squeeze()).copy()
+        elif type == Dtype.binary:
+            return BytesIO(string_at(self.data, self.shape[0]))
+        else:
+            raise RuntimeError(f"Failed to convert Function value to object because value has unsupported type: {type}")
+
+    def __enter__ (self):
+        return self
+
+    def __exit__ (self, exc_type, exc_value, traceback):
+        self.__release()
+
+    def __release (self):
+        if self.__value and self.__owner:
+            get_fxnc().FXNValueRelease(self.__value)
+        self.__value = None
+
+    @classmethod
+    def create_array (
+        cls,
+        data: ndarray,
+        *,
+        flags: ValueFlags=ValueFlags.NONE
+    ) -> Value:
+        dtype = _STR_TO_DTYPE.get(data.dtype.name)
+        if dtype is None:
+            raise RuntimeError(f"Failed to create array value because data type is not supported: {data.dtype}")
+        value = c_void_p()
+        status = get_fxnc().FXNValueCreateArray(
+            data.ctypes.data_as(c_void_p),
+            data.ctypes.shape_as(c_int32),
+            len(data.shape),
+            dtype,
+            flags,
+            byref(value)
+        )
+        if status == FXNStatus.OK:
+            return Value(value)
+        else:
+            raise RuntimeError(f"Failed to create array value with error: {status_to_error(status)}")
+
+    @classmethod
+    def create_string (cls, data: str) -> Value:
+        value = c_void_p()
+        status = get_fxnc().FXNValueCreateString(data.encode(), byref(value))
+        if status == FXNStatus.OK:
+            return Value(value)
+        else:
+            raise RuntimeError(f"Failed to create string value with error: {status_to_error(status)}")
+
+    @classmethod
+    def create_list (cls, data: Iterable[Any]) -> Value:
+        value = c_void_p()
+        status = get_fxnc().FXNValueCreateList(dumps(data).encode(), byref(value))
+        if status == FXNStatus.OK:
+            return Value(value)
+        else:
+            raise RuntimeError(f"Failed to create list value with error: {status_to_error(status)}")
+    
+    @classmethod
+    def create_dict (cls, data: dict[str, Any]) -> Value:
+        value = c_void_p()
+        status = get_fxnc().FXNValueCreateDict(dumps(data).encode(), byref(value))
+        if status == FXNStatus.OK:
+            return Value(value)
+        else:
+            raise RuntimeError(f"Failed to create dict value with error: {status_to_error(status)}")
+
+    @classmethod
+    def create_image (cls, image: Image.Image) -> Value:
+        value = c_void_p()
+        pixel_buffer = array(image)
+        status = get_fxnc().FXNValueCreateImage(
+            pixel_buffer.ctypes.data_as(c_void_p),
+            image.width,
+            image.height,
+            pixel_buffer.shape[2],
+            ValueFlags.COPY_DATA,
+            byref(value)
+        )
+        if status == FXNStatus.OK:
+            return Value(value)
+        else:
+            raise RuntimeError(f"Failed to create image value with error: {status_to_error(status)}")        
+
+    @classmethod
+    def create_binary (
+        cls,
+        data: memoryview,
+        *,
+        flags: ValueFlags=ValueFlags.NONE
+    ) -> Value:
+        buffer = (c_uint8 * len(data)).from_buffer(data)
+        value = c_void_p()
+        status = get_fxnc().FXNValueCreateBinary(buffer, len(data), flags, byref(value))
+        if status == FXNStatus.OK:
+            return Value(value)
+        else:
+            raise RuntimeError(f"Failed to create binary value with error: {status_to_error(status)}")
+
+    @classmethod
+    def create_null (cls) -> Value:
+        value = c_void_p()
+        status = get_fxnc().FXNValueCreateNull(byref(value))
+        if status == FXNStatus.OK:
+            return Value(value)
+        else:
+            raise RuntimeError(f"Failed to create null value with error: {status_to_error(status)}")
+
+
+_STR_TO_DTYPE = {
+    Dtype.null: 0,
+    Dtype.float16: 1,
+    Dtype.float32: 2,
+    Dtype.float64: 3,
+    Dtype.int8: 4,
+    Dtype.int16: 5,
+    Dtype.int32: 6,
+    Dtype.int64: 7,
+    Dtype.uint8: 8,
+    Dtype.uint16: 9,
+    Dtype.uint32: 10,
+    Dtype.uint64: 11,
+    Dtype.bool: 12,
+    Dtype.string: 13,
+    Dtype.list: 14,
+    Dtype.dict: 15,
+    Dtype.image: 16,
+    Dtype.binary: 17,
+}
+_DTYPE_TO_STR = { value: key for key, value in _STR_TO_DTYPE.items() }
+_TENSOR_DTYPES = {
+    Dtype.float16,
+    Dtype.float32,
+    Dtype.float64,
+    Dtype.int8,
+    Dtype.int16,
+    Dtype.int32,
+    Dtype.int64,
+    Dtype.uint8,
+    Dtype.uint16,
+    Dtype.uint32,
+    Dtype.uint64,
+    Dtype.bool,
+}

fxn/cli/__init__.py

@@ -1,15 +1,15 @@
 # 
 #   Function
-#   Copyright © 2024 NatML Inc. All Rights Reserved.
+#   Copyright © 2025 NatML Inc. All Rights Reserved.
 #
 
 from typer import Typer
 
 from .auth import app as auth_app
-from .env import app as env_app
+#from .compile import compile_predictor
 from .misc import cli_options
-from .predict import predict
-from .predictors import archive_predictor, delete_predictor, list_predictors, retrieve_predictor, search_predictors
+from .predictions import create_prediction
+from .predictors import retrieve_predictor
 from ..version import __version__
 
 # Define CLI
@@ -26,16 +26,18 @@ app.callback()(cli_options)
 
 # Add subcommands
 app.add_typer(auth_app, name="auth", help="Login, logout, and check your authentication status.")
-#app.add_typer(env_app, name="env", help="Manage predictor environment variables.")
 
 # Add top-level commands
-#app.command(name="create", help="Create a predictor.")(create_predictor)
-#app.command(name="delete", help="Delete a predictor.")(delete_predictor)
-app.command(name="predict", help="Make a prediction.", context_settings={ "allow_extra_args": True, "ignore_unknown_options": True })(predict)
-#app.command(name="list", help="List predictors.")(list_predictors)
-#app.command(name="search", help="Search predictors.")(search_predictors)
-#app.command(name="retrieve", help="Retrieve a predictor.")(retrieve_predictor)
-#app.command(name="archive", help="Archive a predictor.")(archive_predictor)
+app.command(
+    name="predict",
+    help="Make a prediction.",
+    context_settings={ "allow_extra_args": True, "ignore_unknown_options": True }
+)(create_prediction)
+# app.command(
+#     name="compile",
+#     help="Create a predictor by compiling a Python function."
+# )(compile_predictor)
+app.command(name="retrieve", help="Retrieve a predictor.")(retrieve_predictor)
 
 # Run
 if __name__ == "__main__":

fxn/cli/auth.py

@@ -1,6 +1,6 @@
 # 
 #   Function
-#   Copyright © 2024 NatML Inc. All Rights Reserved.
+#   Copyright © 2025 NatML Inc. All Rights Reserved.
 #
 
 from pathlib import Path

fxn/cli/misc.py

@@ -1,6 +1,6 @@
 # 
 #   Function
-#   Copyright © 2024 NatML Inc. All Rights Reserved.
+#   Copyright © 2025 NatML Inc. All Rights Reserved.
 #
 
 from rich import print