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

fxn/types/predictor.py

@@ -3,21 +3,24 @@
 #   Copyright © 2024 NatML Inc. All Rights Reserved.
 #
 
-from enum import Enum
-from pydantic import AliasChoices, BaseModel, Field
-from typing import List, Optional, Tuple, Union
+from enum import Enum, IntFlag
+from io import BytesIO
+from numpy.typing import NDArray
+from PIL import Image
+from pydantic import AliasChoices, BaseModel, ConfigDict, Field
+from typing import Any, Dict, List, Optional, Tuple
 
 from .dtype import Dtype
 from .profile import Profile
-from .value import Value
 
-class Acceleration (str, Enum):
+class Acceleration (IntFlag):
     """
     Predictor acceleration.
     """
-    CPU = "CPU"
-    A40 = "A40"
-    A100 = "A100"
+    Default = 0,
+    CPU = 1 << 0,
+    GPU = 1 << 1,
+    NPU = 1 << 2
 
 class AccessMode (str, Enum):
     """
@@ -26,13 +29,6 @@ class AccessMode (str, Enum):
     Public = "PUBLIC"
     Private = "PRIVATE"
 
-class PredictorType (str, Enum):
-    """
-    Predictor type.
-    """
-    Cloud = "CLOUD"
-    Edge = "EDGE"
-
 class PredictorStatus (str, Enum):
     """
     Predictor status.
@@ -51,7 +47,7 @@ class EnumerationMember (BaseModel):
         value (str | int): Enumeration member value.
     """
     name: str = Field(description="Enumeration member name.")
-    value: Union[str, int] = Field(description="Enumeration member value.")
+    value: str | int = Field(description="Enumeration member value.")
 
 class Parameter (BaseModel):
     """
@@ -64,7 +60,7 @@ class Parameter (BaseModel):
         optional (bool): Whether the parameter is optional.
         range (tuple): Parameter value range for numeric parameters.
         enumeration (list): Parameter value choices for enumeration parameters.
-        default_value (Value): Parameter default value.
+        default_value (str | float | int | bool | ndarray | list | dict | PIL.Image | BytesIO): Parameter default value.
         value_schema (dict): Parameter JSON schema. This is only populated for `list` and `dict` parameters.
     """
     name: str = Field(description="Parameter name.")
@@ -73,8 +69,9 @@ class Parameter (BaseModel):
     optional: Optional[bool] = Field(default=None, description="Whether the parameter is optional.")
     range: Optional[Tuple[float, float]] = Field(default=None, description="Parameter value range for numeric parameters.")
     enumeration: Optional[List[EnumerationMember]] = Field(default=None, description="Parameter value choices for enumeration parameters.")
-    default_value: Optional[Value] = Field(default=None, description="Parameter default value.", serialization_alias="defaultValue", validation_alias=AliasChoices("default_value", "defaultValue"))
+    default_value: Optional[str | float | int | bool | NDArray | List[Any] | Dict[str, Any] | Image.Image | BytesIO] = Field(default=None, description="Parameter default value.", serialization_alias="defaultValue", validation_alias=AliasChoices("default_value", "defaultValue"))
     value_schema: Optional[dict] = Field(default=None, description="Parameter JSON schema. This is only populated for `list` and `dict` parameters.", serialization_alias="schema", validation_alias=AliasChoices("schema", "value_schema"))
+    model_config = ConfigDict(arbitrary_types_allowed=True)
 
 class Signature (BaseModel):
     """
@@ -95,7 +92,6 @@ class Predictor (BaseModel):
         tag (str): Predictor tag.
         owner (Profile): Predictor owner.
         name (str): Predictor name.
-        type (PredictorType): Predictor type.
         status (PredictorStatus): Predictor status.
         access (AccessMode): Predictor access.
         signature (Signature): Predictor signature.
@@ -103,13 +99,11 @@ class Predictor (BaseModel):
         description (str): Predictor description.
         card (str): Predictor card.
         media (str): Predictor media URL.
-        acceleration (Acceleration): Predictor acceleration. This only applies to cloud predictors.
         license (str): Predictor license URL.
     """
     tag: str = Field(description="Predictor tag.")
     owner: Profile = Field(description="Predictor owner.")
     name: str = Field(description="Predictor name.")
-    type: PredictorType = Field(description="Predictor type.")
     status: PredictorStatus = Field(description="Predictor status.")
     access: AccessMode = Field(description="Predictor access.")
     signature: Signature = Field(description="Predictor signature.")
@@ -117,5 +111,4 @@ class Predictor (BaseModel):
     description: Optional[str] = Field(default=None, description="Predictor description.")
     card: Optional[str] = Field(default=None, description="Predictor card.")
     media: Optional[str] = Field(default=None, description="Predictor media URL.")
-    acceleration: Optional[Acceleration] = Field(default=None, description="Predictor acceleration. This only applies to cloud predictors.")
     license: Optional[str] = Field(default=None, description="Predictor license URL.")

fxn/version.py

@@ -3,4 +3,4 @@
 #   Copyright © 2024 NatML Inc. All Rights Reserved.
 #
 
-__version__ = "0.0.35"
+__version__ = "0.0.36"

{fxn-0.0.35.dist-info → fxn-0.0.36.dist-info}/METADATA

@@ -1,7 +1,7 @@
 Metadata-Version: 2.1
 Name: fxn
-Version: 0.0.35
-Summary: Run on-device and cloud AI prediction functions in Python. Register at https://fxn.ai.
+Version: 0.0.36
+Summary: Run prediction functions locally in Python. Register at https://fxn.ai.
 Author-email: "NatML Inc." <hi@fxn.ai>
 License: Apache License
                                    Version 2.0, January 2004
@@ -213,14 +213,12 @@ Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: OS Independent
 Classifier: Topic :: Scientific/Engineering :: Image Recognition
 Classifier: Topic :: Software Development :: Libraries
-Requires-Python: >=3.9
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: aiohttp
-Requires-Dist: magika
 Requires-Dist: numpy
 Requires-Dist: pillow
-Requires-Dist: pydantic >=2.0
+Requires-Dist: pydantic>=2.0
 Requires-Dist: requests
 Requires-Dist: rich
 Requires-Dist: typer
@@ -231,52 +229,52 @@ Requires-Dist: typer
 
 [![Dynamic JSON Badge](https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fdiscord.com%2Fapi%2Finvites%2Fy5vwgXkz2f%3Fwith_counts%3Dtrue&query=%24.approximate_member_count&logo=discord&logoColor=white&label=Function%20community)](https://fxn.ai/community)
 
-Run AI prediction functions (a.k.a "predictors") in your Python apps. With Function, you can build AI-powered apps by creating and composing GPU-accelerated predictors that run in the cloud. In a few steps:
+Run prediction functions (a.k.a "predictors") locally in your Python apps, with full GPU acceleration and zero dependencies. In a few steps:
 
 ## Installing Function
 Function is distributed on PyPi. This distribution contains both the Python client and the command line interface (CLI). To install, open a terminal and run the following command:
 ```sh
-pip install --upgrade fxn
+# Install Function
+$ pip install --upgrade fxn
 ```
 
 > [!NOTE]
 > Function requires Python 3.9+
 
-## Making a Prediction
-Let's run the [`@samplefxn/stable-diffusion`](https://fxn.ai/@samplefxn/stable-diffusion) predictor which accepts a text `prompt` and generates a corresponding image.
+## Retrieving your Access Key
+Head over to [fxn.ai](https://fxn.ai) to create an account by logging in. Once you do, generate an access key:
+
+![generate access key](https://raw.githubusercontent.com/fxnai/.github/main/access_key.gif)
 
-### In Python
-Run the following Python script:
+## Making a Prediction
+Let's run the [`@fxn/greeting`](https://fxn.ai/@fxn/greeting) predictor which accepts a `name` and returns a congenial greeting. Run the following Python script:
 ```py
 from fxn import Function
 
 # Create the Function client
-fxn = Function()
+fxn = Function(access_key="<Function access key>")
 # Create a prediction
 prediction = fxn.predictions.create(
-    tag="@samplefxn/stable-diffusion",
-    inputs={
-        "prompt": "An astronaut riding a horse on Mars"
-    }
+    tag="@fxn/greeting",
+    inputs={ "name": "Peter" }
 )
-# Show the generated image
-image = prediction.results[0]
-image.show()
+# Print the returned greeting
+print(prediction.results[0])
 ```
 
-### In the CLI
+> [!TIP]
+> Explore public predictors [on Function](https://fxn.ai/explore) or [create your own](https://fxn.ai/waitlist).
+r
+## Using the Function CLI
 Open up a terminal and run the following command:
 
 ```sh
-fxn predict @samplefxn/stable-diffusion --prompt "An astronaut riding a horse on the moon"
-```
+# Login to Function
+fxn auth login <ACCESS KEY>
 
-Within a few seconds, you should see a creepy-looking image pop up 😅:
-
-![prediction](https://raw.githubusercontent.com/fxnai/.github/main/predict.gif)
-
-## Creating a Predictor
-At some point, you might want to create your own predictor. With Function, you don't have to deal with GitHub repos, Dockerfiles, or weird YAMLs. All you need is a Jupyter Notebook with a `predict` function. See our [samples project](https://github.com/fxnai/samples) for more.
+# Make a prediction using the Function CLI
+fxn predict @fxn/greeting --name Peter
+```
 
 ___
 

fxn-0.0.36.dist-info/RECORD

@@ -0,0 +1,49 @@
+fxn/__init__.py,sha256=tWk0-aCNHX_yCS-Dg90pYnniNka9MWFoNMk6xY7u4nI,157
+fxn/function.py,sha256=NBEH37NX6GFj6pf3nBja8xeYb1IoKCPiE4Sxwpwj-mM,1452
+fxn/magic.py,sha256=PQmXhO9EvJ5EZylioV-6gsCvqhVRYscKBSOBoN4VhTk,1041
+fxn/version.py,sha256=BiY9-f6E3ZNjYc2X4h8op-HBbBeHAEepyx3H_ePXT58,95
+fxn/api/__init__.py,sha256=rJIDBhYg5jcrWO4hT4-CpwPq6dSgmLTEHCfUYTLpVaI,103
+fxn/api/client.py,sha256=WCNsebcuwIlP9W5k_8AQCpxOCcy7cpbengfu2rIkGmc,1192
+fxn/c/__init__.py,sha256=qBnS4_eoBe5biKoyhW0Fsfr3cqJ9SAvzmm-XB56ev0A,438
+fxn/c/configuration.py,sha256=BU6WRaYVCjdCSTESNqZX9ghvA19l1yLUCn5EhChQTpA,2707
+fxn/c/dtype.py,sha256=jcbFpQSnpvMPwXQ3mVyTZRSlJxcaArM2cvgXwAqzx0Q,386
+fxn/c/fxnc.py,sha256=kaEWw_bmDVj55IcSJR8sPmmEE2-DwTAt-MW6h3p8aIU,859
+fxn/c/map.py,sha256=IXYPGp4KEmgoO7v-EXJNDBVDm8qmMEuDDYZR1SCKFCM,1234
+fxn/c/prediction.py,sha256=foPETcJUGn8QxBbub0O7EBPA8G3i9XNdwV22iB1Rm-A,1476
+fxn/c/predictor.py,sha256=sqJo7BMnl_tVUlZx5tNy5IwoxK8bx-sHJzgYtSJkQR0,1172
+fxn/c/status.py,sha256=QodZjS0pVI5NIBw5x2OobJLV44VVNhB0UNKmOI9yuAk,225
+fxn/c/stream.py,sha256=F2R9eUPW3fvUzb7KBfRCk9KiGFl_Yhdf0gqEzM06RKs,725
+fxn/c/value.py,sha256=FZbEaeJYBxdOIVOPR4n0wJ1G_8I0RZ6dRFPcVsDLYbU,1931
+fxn/c/version.py,sha256=fnV14LTAXSl6Q03YFIWOINOUrs0DJpyBOcwP5VZvLFc,282
+fxn/cli/__init__.py,sha256=c9qBvRTHSWnO-8Ny431RlkZWznF7sShJfHYfjBazjRk,1481
+fxn/cli/auth.py,sha256=tMjgNA6AQeom3I5AsgPvWvN62cM3nFGBcjjXB7x4s8U,1688
+fxn/cli/env.py,sha256=shqoP4tUiXdOoil73oiUYpqGeVcR119HPYFKgnoF894,1553
+fxn/cli/misc.py,sha256=J3WgNjrxRzm-_iKC3Cp0o4VHeBYBQ1ta_t2-ozD9roo,662
+fxn/cli/predict.py,sha256=hpd1VZtw1OBNkZwePCFtyTHLSDOzc8fuSODGmvmmG1E,3026
+fxn/cli/predictors.py,sha256=SSvxf5emr_upcU78vhdB2F9PM351YdP2a1bqf8FRaxE,2248
+fxn/lib/__init__.py,sha256=c_q01PLV3Mi-qV0_HVbNRHOI2TIUr_cDIJHvCASsYZk,71
+fxn/lib/macos/arm64/Function.dylib,sha256=N-ewU2AXqgVAsYPpEnlWU09uyxLAywtsL0ous4MG3Zg,268736
+fxn/lib/macos/x86_64/Function.dylib,sha256=DfoGF8v-lvxo8a10QUZ0egbfQZo6B6tNct5NMV1kpYc,269744
+fxn/lib/windows/arm64/Function.dll,sha256=kvixEsiKalAqMOyCRpcAcFgkXxK_9Vt-WDQgws5M6Xg,425472
+fxn/lib/windows/x86_64/Function.dll,sha256=lEHVER_6PQUqJHDd6YWMqZ2X6PLnJTmVa68cUgp5lJ8,450560
+fxn/services/__init__.py,sha256=OTBRL_wH94hc_scZgRd42VrJQfldNLjv4APN4YaWBAw,366
+fxn/services/environment.py,sha256=ITodddygFR9Kw8cdSh3vtTcTpUmUIsTFGpHnqx2RMVo,3714
+fxn/services/prediction.py,sha256=EfjnwF_GEKSifClzsBWBuKe-NeSk9CeAMQAYDT0lF9A,20228
+fxn/services/predictor.py,sha256=yhrg5msrfVsIomPB1jlOa0z7jVGTDZIdvBnB-OYiQdk,5163
+fxn/services/storage.py,sha256=qGijBsfdGWQAumNAOYL6-SfSkrvYDuCK12FevdJl4cM,5480
+fxn/services/user.py,sha256=niExZwZFl_hlgLTz9lvrU3QrVR8oKdMcm623wyQK-cA,1217
+fxn/types/__init__.py,sha256=GY7ST0Ue_sh4rB3a4MHkvql_Cn0p9qZ4wlf3luPOwk8,398
+fxn/types/dtype.py,sha256=YpTnIG-yzrQwda27GzfGZcel-zF3gOMMoHhcWD915BY,617
+fxn/types/environment.py,sha256=FbmfGjSb5yYMT9IyDj8zNUpsoP3RbzqM6tK8gn2TfDs,394
+fxn/types/prediction.py,sha256=y54TA0w16MVW2jUwN6U-BtXARZgyk2WXy2mHDf9Hsjw,2028
+fxn/types/predictor.py,sha256=bqpt3m616JloxkcIGxUKP1_-7ioLXepe8DjgfEPzj-E,4699
+fxn/types/profile.py,sha256=1KWqPusKieCIcw4KSS2sScpwP0Z-mU4ThMYOZRxZ_68,1123
+fxn/types/storage.py,sha256=AtVKR3CtHzvSWLiJS_bbUyIA2Of_IKZVeL5_1PqqrQ0,228
+fxn/types/tag.py,sha256=hWzSDCo8VjRHjS5ZLuFi3xVo8cuCNaNeULQ2mHEuwzM,707
+fxn/types/user.py,sha256=_hc1YQh0WydniAurywA70EDs4VCY5rnGRYSiRc97Ab0,150
+fxn-0.0.36.dist-info/LICENSE,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
+fxn-0.0.36.dist-info/METADATA,sha256=Hk1xVRWsEy87RvJrvIFY9zSetdg_Ms5iTOfxYgh4Bho,16068
+fxn-0.0.36.dist-info/WHEEL,sha256=Mdi9PDNwEZptOjTlUcAth7XJDFtKrHYaQMPulZeBCiQ,91
+fxn-0.0.36.dist-info/entry_points.txt,sha256=O_AwD5dYaeB-YT1F9hPAPuDYCkw_W0tdNGYbc5RVR2k,45
+fxn-0.0.36.dist-info/top_level.txt,sha256=1ULIEGrnMlhId8nYAkjmRn9g3KEFuHKboq193SEKQkA,4
+fxn-0.0.36.dist-info/RECORD,,

{fxn-0.0.35.dist-info → fxn-0.0.36.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.43.0)
+Generator: setuptools (73.0.1)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

fxn/libs/linux/__init__.py

@@ -1,4 +0,0 @@
-# 
-#   Function
-#   Copyright © 2024 NatML Inc. All Rights Reserved.
-#

fxn/libs/macos/__init__.py

@@ -1,4 +0,0 @@
-# 
-#   Function
-#   Copyright © 2024 NatML Inc. All Rights Reserved.
-#

fxn/libs/windows/__init__.py

@@ -1,4 +0,0 @@
-# 
-#   Function
-#   Copyright © 2024 NatML Inc. All Rights Reserved.
-#

fxn/services/prediction/__init__.py

@@ -1,6 +0,0 @@
-#
-#   Function
-#   Copyright © 2024 NatML Inc. All Rights Reserved.
-#
-
-from .service import PredictionService, PREDICTION_FIELDS

fxn/services/prediction/fxnc.py

@@ -1,312 +0,0 @@
-#
-#   Function
-#   Copyright © 2024 NatML Inc. All Rights Reserved.
-#
-
-from ctypes import byref, cast, c_bool, c_char_p, c_double, c_int, c_int32, c_uint8, c_void_p, string_at, CDLL, POINTER, Structure, _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 numpy.typing import NDArray
-from pathlib import Path
-from PIL import Image
-from typing import Any, Dict, List, Union
-
-# https://github.com/fxnai/fxnc
-
-class FXNStatus(c_int):
-    OK = 0
-    ERROR_INVALID_ARGUMENT = 1
-    ERROR_INVALID_OPERATION = 2
-    ERROR_NOT_IMPLEMENTED = 3
-
-class FXNDtype(c_int):
-    NULL = 0
-    FLOAT16 = 1
-    FLOAT32 = 2
-    FLOAT64 = 3
-    INT8 = 4
-    INT16 = 5
-    INT32 = 6
-    INT64 = 7
-    UINT8 = 8
-    UINT16 = 9
-    UINT32 = 10
-    UINT64 = 11
-    BOOL = 12
-    STRING = 13
-    LIST = 14
-    DICT = 15
-    IMAGE = 16
-    BINARY = 17
-
-class FXNValueFlags(c_int):
-    NONE = 0
-    COPY_DATA = 1
-
-class FXNAcceleration(c_int):
-    FXN_ACCELERATION_DEFAULT = 0
-    FXN_ACCELERATION_CPU = 1 << 0
-    FXN_ACCELERATION_GPU = 1 << 1
-    FXN_ACCELERATION_NPU = 1 << 2
-
-class FXNValue(Structure): pass
-class FXNValueMap(Structure): pass
-class FXNConfiguration(Structure): pass
-class FXNPrediction(Structure): pass
-class FXNPredictionStream(Structure): pass
-class FXNPredictor(Structure): pass
-
-FXNValueRef = POINTER(FXNValue)
-FXNValueMapRef = POINTER(FXNValueMap)
-FXNConfigurationRef = POINTER(FXNConfiguration)
-FXNPredictionRef = POINTER(FXNPrediction)
-FXNPredictionStreamRef = POINTER(FXNPredictionStream)
-FXNPredictorRef = POINTER(FXNPredictor)
-
-def load_fxnc (path: Path) -> CDLL:
-    # Open
-    fxnc = CDLL(str(path))
-    # 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
-    # FXNValueMapCreate
-    fxnc.FXNValueMapCreate.argtypes = [POINTER(FXNValueMapRef)]
-    fxnc.FXNValueMapCreate.restype = FXNStatus
-    # FXNValueMapRelease
-    fxnc.FXNValueMapRelease.argtypes = [FXNValueMapRef]
-    fxnc.FXNValueMapRelease.restype = FXNStatus
-    # FXNValueMapGetSize
-    fxnc.FXNValueMapGetSize.argtypes = [FXNValueMapRef, POINTER(c_int32)]
-    fxnc.FXNValueMapGetSize.restype = FXNStatus
-    # FXNValueMapGetKey
-    fxnc.FXNValueMapGetKey.argtypes = [FXNValueMapRef, c_int32, c_char_p, c_int32]
-    fxnc.FXNValueMapGetKey.restype = FXNStatus
-    # FXNValueMapGetValue
-    fxnc.FXNValueMapGetValue.argtypes = [FXNValueMapRef, c_char_p, POINTER(FXNValueRef)]
-    fxnc.FXNValueMapGetValue.restype = FXNStatus
-    # FXNValueMapSetValue
-    fxnc.FXNValueMapSetValue.argtypes = [FXNValueMapRef, c_char_p, FXNValueRef]
-    fxnc.FXNValueMapSetValue.restype = FXNStatus
-    # FXNConfigurationGetUniqueID
-    fxnc.FXNConfigurationGetUniqueID.argtypes = [c_char_p, c_int32]
-    fxnc.FXNConfigurationGetUniqueID.restype = FXNStatus
-    # FXNConfigurationCreate
-    fxnc.FXNConfigurationCreate.argtypes = [POINTER(FXNConfigurationRef)]
-    fxnc.FXNConfigurationCreate.restype = FXNStatus
-    # FXNConfigurationRelease
-    fxnc.FXNConfigurationRelease.argtypes = [FXNConfigurationRef]
-    fxnc.FXNConfigurationRelease.restype = FXNStatus
-    # FXNConfigurationGetTag
-    fxnc.FXNConfigurationGetTag.argtypes = [FXNConfigurationRef, c_char_p, c_int32]
-    fxnc.FXNConfigurationRelease.restype = FXNStatus
-    # FXNConfigurationSetTag
-    fxnc.FXNConfigurationSetTag.argtypes = [FXNConfigurationRef, c_char_p]
-    fxnc.FXNConfigurationSetTag.restype = FXNStatus
-    # FXNConfigurationGetToken
-    fxnc.FXNConfigurationGetToken.argtypes = [FXNConfigurationRef, c_char_p, c_int32]
-    fxnc.FXNConfigurationGetToken.restype = FXNStatus
-    # FXNConfigurationSetToken
-    fxnc.FXNConfigurationSetToken.argtypes = [FXNConfigurationRef, c_char_p]
-    fxnc.FXNConfigurationSetToken.restype = FXNStatus
-    # FXNConfigurationGetAcceleration
-    fxnc.FXNConfigurationGetAcceleration.argtypes = [FXNConfigurationRef, POINTER(FXNAcceleration)]
-    fxnc.FXNConfigurationGetAcceleration.restype = FXNStatus
-    # FXNConfigurationSetAcceleration
-    fxnc.FXNConfigurationSetAcceleration.argtypes = [FXNConfigurationRef, FXNAcceleration]
-    fxnc.FXNConfigurationSetAcceleration.restype = FXNStatus
-    # FXNConfigurationGetDevice
-    fxnc.FXNConfigurationGetDevice.argtypes = [FXNConfigurationRef, POINTER(c_void_p)]
-    fxnc.FXNConfigurationGetDevice.restype = FXNStatus
-    # FXNConfigurationSetDevice
-    fxnc.FXNConfigurationSetDevice.argtypes = [FXNConfigurationRef, c_void_p]
-    fxnc.FXNConfigurationSetDevice.restype = FXNStatus
-    # FXNConfigurationAddResource
-    fxnc.FXNConfigurationAddResource.argtypes = [FXNConfigurationRef, c_char_p, c_char_p]
-    fxnc.FXNConfigurationAddResource.restype = FXNStatus
-    # 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
-    # FXNPredictionStreamRelease
-    fxnc.FXNPredictionStreamRelease.argtypes = [FXNPredictionStreamRef]
-    fxnc.FXNPredictionStreamRelease.restype = FXNStatus
-    # FXNPredictionStreamReadNext
-    fxnc.FXNPredictionStreamReadNext.argtypes = [FXNPredictionStreamRef, POINTER(FXNPredictionRef)]
-    fxnc.FXNPredictionStreamReadNext.restype = FXNStatus
-    # 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
-    # FXNGetVersion
-    fxnc.FXNGetVersion.argtypes = []
-    fxnc.FXNGetVersion.restype = c_char_p
-    # Return
-    return fxnc
-
-def to_fxn_value (
-    fxnc: CDLL,
-    value: Union[float, int, bool, str, NDArray, List[Any], Dict[str, Any], Image.Image, bytes, bytearray, memoryview, BytesIO, None],
-    *,
-    copy: bool=False
-) -> type[FXNValueRef]:
-    result = FXNValueRef()
-    if result is None:
-        fxnc.FXNValueCreateNull(byref(result))
-    elif isinstance(value, bool):
-        return to_fxn_value(fxnc, array(value, dtype="bool"))
-    elif isinstance(value, int):
-        return to_fxn_value(fxnc, array(value, dtype="int32"))
-    elif isinstance(value, float):
-        return to_fxn_value(fxnc, 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.COPY_DATA if copy else 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 status: {status.value}"
-    elif isinstance(value, (bytes, bytearray, memoryview, BytesIO)):
-        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_py_value (
-    fxnc: CDLL,
-    value: type[FXNValueRef]
-) -> Union[float, int, bool, str, NDArray, List[Any], Dict[str, Any], Image.Image, BytesIO, None]:
-    # Type
-    dtype = FXNDtype()
-    status = fxnc.FXNValueGetType(value, byref(dtype))
-    assert status.value == FXNStatus.OK, f"Failed to get value data type with status: {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 status: {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 status: {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 status: {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)
-    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}")
-
-_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() }