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

fxn/c/value.py

@@ -3,48 +3,221 @@
 #   Copyright © 2024 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

@@ -8,7 +8,7 @@ from typer import Typer
 from .auth import app as auth_app
 from .env import app as env_app
 from .misc import cli_options
-from .predict import predict
+from .predictions import create_prediction
 from .predictors import archive_predictor, delete_predictor, list_predictors, retrieve_predictor, search_predictors
 from ..version import __version__
 
@@ -31,7 +31,11 @@ app.add_typer(auth_app, name="auth", help="Login, logout, and check your authent
 # 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="predict",
+    help="Make a prediction.",
+    context_settings={ "allow_extra_args": True, "ignore_unknown_options": True }
+)(create_prediction)
 #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)

fxn/cli/{predict.py → predictions.py}

@@ -5,7 +5,7 @@
 
 from asyncio import run as run_async
 from io import BytesIO
-from numpy import ndarray
+from numpy import array_repr, ndarray
 from pathlib import Path, PurePath
 from PIL import Image
 from rich import print_json
@@ -14,34 +14,30 @@ from tempfile import mkstemp
 from typer import Argument, Context, Option
 
 from ..function import Function
+from ..types import Prediction
 from .auth import get_access_key
 
-def predict (
-    tag: str = Argument(..., help="Predictor tag."),
+def create_prediction (
+    tag: str=Argument(..., help="Predictor tag."),
+    quiet: bool=Option(False, "--quiet", help="Suppress verbose logging when creating the prediction."),
     context: Context = 0
 ):
-    run_async(_predict_async(tag, context=context))
+    run_async(_predict_async(tag, quiet=quiet, context=context))
 
-async def _predict_async (tag: str, context: Context):
+async def _predict_async (tag: str, quiet: bool, context: Context):
+    # Preload
+    fxn = Function(get_access_key())
+    fxn.predictions.create(tag, inputs={ }, verbose=not quiet)
+    # Predict
     with Progress(
         SpinnerColumn(spinner_name="dots"),
         TextColumn("[progress.description]{task.description}"),
         transient=True
     ) as progress:
         progress.add_task(description="Running Function...", total=None)
-        # Parse inputs
         inputs = { context.args[i].replace("-", ""): _parse_value(context.args[i+1]) for i in range(0, len(context.args), 2) }
-        # Stream
-        fxn = Function(get_access_key())
-        async for prediction in fxn.predictions.stream(tag, inputs=inputs):
-            # Parse results
-            images = [value for value in prediction.results or [] if isinstance(value, Image.Image)]
-            prediction.results = [_serialize_value(value) for value in prediction.results] if prediction.results is not None else None
-            # Print
-            print_json(data=prediction.model_dump())
-            # Show images
-            for image in images:
-                image.show()
+        prediction = fxn.predictions.create(tag, inputs=inputs)
+        _log_prediction(prediction)
 
 def _parse_value (value: str):
     """
@@ -70,33 +66,34 @@ def _parse_value (value: str):
         pass
     # File
     if value.startswith("@"):
-        return Path(value[1:])
+        path = Path(value[1:]).expanduser().resolve()
+        if path.suffix in [".txt", ".md"]:
+            with open(path) as f:
+                return f.read()
+        elif path.suffix in [".jpg", ".png"]:
+            return Image.open(path)
+        else:
+            with open(path, "rb") as f:
+                return BytesIO(f.read())
     # String
     return value
-    
+
+def _log_prediction (prediction: Prediction):
+    images = [value for value in prediction.results or [] if isinstance(value, Image.Image)]
+    prediction.results = [_serialize_value(value) for value in prediction.results] if prediction.results is not None else None
+    print_json(data=prediction.model_dump())
+    for image in images:
+        image.show()
+
 def _serialize_value (value):
-    # Convert ndarray to list
     if isinstance(value, ndarray):
-        return value.tolist()
-    # Write image
+        return array_repr(value)
     if isinstance(value, Image.Image):
         _, path = mkstemp(suffix=".png" if value.mode == "RGBA" else ".jpg")
         value.save(path)
         return path
-    # Serialize `BytesIO`
     if isinstance(value, BytesIO):
         return str(value)
-    # Serialize `Path`
     if isinstance(value, PurePath):
         return str(value)
-    # Return    
-    return value
-
-def _prediction_dict_factory (kv_pairs):
-    # Check if value
-    VALUE_KEYS = ["data", "type", "shape"]
-    keys = [k for k, _ in kv_pairs]
-    is_value = all(k in keys for k in VALUE_KEYS)
-    kv_pairs = [(k, v) for k, v in kv_pairs if v is not None] if is_value else kv_pairs
-    # Construct
-    return dict(kv_pairs)
+    return value

fxn/client.py

@@ -0,0 +1,46 @@
+#
+#   Function
+#   Copyright © 2024 NatML Inc. All Rights Reserved.
+#
+
+from requests import request
+from typing import Any, Literal
+
+class FunctionClient:
+    
+    def __init__(self, access_key: str, api_url: str | None) -> None:
+        self.access_key = access_key
+        self.api_url = api_url or "https://api.fxn.ai/v1"
+
+    def request (
+        self,
+        *,
+        method: Literal["GET", "POST", "DELETE"],
+        path: str,
+        body: dict[str, Any]=None
+    ) -> dict[str, Any] | list[Any]:
+        response = request(
+            method=method,
+            url=f"{self.api_url}{path}",
+            json=body,
+            headers={ "Authorization": f"Bearer {self.access_key}" }
+        )
+        data = None
+        try:
+            data = response.json()
+        except Exception as ex:
+            raise FunctionAPIError(str(ex), response.status_code)
+        if not response.ok:
+            error = data["errors"][0]["message"] if "errors" in data else str(ex)
+            raise FunctionAPIError(error, response.status_code)
+        return data
+
+class FunctionAPIError (Exception):
+
+    def __init__(self, message: str, status_code: int):
+        super().__init__(message)
+        self.message = message
+        self.status_code = status_code
+
+    def __str__(self):
+        return f"FunctionAPIError: {self.message} (Status Code: {self.status_code})"

fxn/function.py

@@ -5,7 +5,7 @@
 
 from os import environ
 
-from .api import GraphClient
+from .client import FunctionClient
 from .services import PredictionService, PredictorService, UserService
 
 class Function:
@@ -22,15 +22,15 @@ class Function:
         access_key (str): Function access key.
         api_url (str): Function API URL.
     """
-    client: GraphClient
+    client: FunctionClient
     users: UserService
     predictors: PredictorService
     predictions: PredictionService
 
     def __init__ (self, access_key: str=None, api_url: str=None):
         access_key = access_key or environ.get("FXN_ACCESS_KEY", None)
-        api_url = api_url or environ.get("FXN_API_URL", "https://api.fxn.ai")
-        self.client = GraphClient(access_key, api_url)
+        api_url = api_url or environ.get("FXN_API_URL")
+        self.client = FunctionClient(access_key, api_url)
         self.users = UserService(self.client)
         self.predictors = PredictorService(self.client)
         self.predictions = PredictionService(self.client)

fxn/services/__init__.py

@@ -3,6 +3,6 @@
 #   Copyright © 2024 NatML Inc. All Rights Reserved.
 #
 
-from .user import UserService, PROFILE_FIELDS, USER_FIELDS
-from .predictor import PredictorService, PREDICTOR_FIELDS
-from .prediction import PredictionService, PREDICTION_FIELDS
+from .user import UserService
+from .predictor import PredictorService
+from .prediction import PredictionService, Value