fxn 0.0.35__tar.gz → 0.0.36__tar.gz

{fxn-0.0.35 → fxn-0.0.36}/PKG-INFO

@@ -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,11 +213,9 @@ 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
@@ -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.35 → fxn-0.0.36}/README.md

@@ -4,52 +4,52 @@
 
 [![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/fxn/c/__init__.py

@@ -0,0 +1,16 @@
+#
+#   Function
+#   Copyright © 2024 NatML Inc. All Rights Reserved.
+#
+
+# https://github.com/fxnai/fxnc
+
+from .status import FXNStatus
+from .value import FXNDtype, FXNValueRef, FXNValueFlags
+from .map import FXNValueMapRef
+from .configuration import FXNConfigurationRef, FXNAcceleration
+from .prediction import FXNPredictionRef
+from .stream import FXNPredictionStreamRef
+from .predictor import FXNPredictorRef
+
+from .fxnc import load_fxnc

fxn-0.0.36/fxn/c/configuration.py

@@ -0,0 +1,60 @@
+#
+#   Function
+#   Copyright © 2024 NatML Inc. All Rights Reserved.
+#
+
+from ctypes import c_char_p, c_int, c_int32, c_void_p, CDLL, POINTER, Structure
+from .status import FXNStatus
+
+class FXNAcceleration(c_int):
+    FXN_ACCELERATION_DEFAULT = 0
+    FXN_ACCELERATION_CPU = 1 << 0
+    FXN_ACCELERATION_GPU = 1 << 1
+    FXN_ACCELERATION_NPU = 1 << 2
+
+class FXNConfiguration(Structure): pass
+
+FXNConfigurationRef = POINTER(FXNConfiguration)
+
+def _register_fxn_configuration (fxnc: CDLL) -> CDLL:
+    # FXNConfigurationGetUniqueID
+    fxnc.FXNConfigurationGetUniqueID.argtypes = [c_char_p, c_int32]
+    fxnc.FXNConfigurationGetUniqueID.restype = FXNStatus
+    # FXNConfigurationGetClientID
+    fxnc.FXNConfigurationGetClientID.argtypes = [c_char_p, c_int32]
+    fxnc.FXNConfigurationGetClientID.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
+    # Return
+    return fxnc

fxn-0.0.36/fxn/c/dtype.py

@@ -0,0 +1,26 @@
+#
+#   Function
+#   Copyright © 2024 NatML Inc. All Rights Reserved.
+#
+
+from ctypes import c_int
+
+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

fxn-0.0.36/fxn/c/fxnc.py

@@ -0,0 +1,28 @@
+#
+#   Function
+#   Copyright © 2024 NatML Inc. All Rights Reserved.
+#
+
+from ctypes import CDLL
+from pathlib import Path
+from .configuration import _register_fxn_configuration
+from .prediction import _register_fxn_prediction
+from .stream import _register_fxn_prediction_stream
+from .predictor import _register_fxn_predictor
+from .value import _register_fxn_value
+from .map import _register_fxn_value_map
+from .version import _register_fxn_version
+
+def load_fxnc (path: Path) -> CDLL:
+    # Open
+    fxnc = CDLL(str(path))
+    # Register
+    fxnc = _register_fxn_value(fxnc)
+    fxnc = _register_fxn_value_map(fxnc)
+    fxnc = _register_fxn_configuration(fxnc)
+    fxnc = _register_fxn_prediction(fxnc)
+    fxnc = _register_fxn_prediction_stream(fxnc)
+    fxnc = _register_fxn_predictor(fxnc)
+    fxnc = _register_fxn_version(fxnc)
+    # Return
+    return fxnc

fxn-0.0.36/fxn/c/map.py

@@ -0,0 +1,34 @@
+#
+#   Function
+#   Copyright © 2024 NatML Inc. All Rights Reserved.
+#
+
+from ctypes import c_char_p, c_int32, CDLL, POINTER, Structure
+from .status import FXNStatus
+from .value import FXNValueRef
+
+class FXNValueMap(Structure): pass
+
+FXNValueMapRef = POINTER(FXNValueMap)
+
+def _register_fxn_value_map (fxnc: CDLL) -> CDLL:
+    # 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
+    # Return
+    return fxnc

fxn-0.0.36/fxn/c/prediction.py

@@ -0,0 +1,37 @@
+#
+#   Function
+#   Copyright © 2024 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

fxn-0.0.36/fxn/c/predictor.py

@@ -0,0 +1,31 @@
+#
+#   Function
+#   Copyright © 2024 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

fxn-0.0.36/fxn/c/status.py

@@ -0,0 +1,12 @@
+#
+#   Function
+#   Copyright © 2024 NatML Inc. All Rights Reserved.
+#
+
+from ctypes import c_int
+
+class FXNStatus(c_int):
+    OK = 0
+    ERROR_INVALID_ARGUMENT = 1
+    ERROR_INVALID_OPERATION = 2
+    ERROR_NOT_IMPLEMENTED = 3

fxn-0.0.36/fxn/c/stream.py

@@ -0,0 +1,22 @@
+#
+#   Function
+#   Copyright © 2024 NatML Inc. All Rights Reserved.
+#
+
+from ctypes import CDLL, POINTER, Structure
+from .prediction import FXNPredictionRef
+from .status import FXNStatus
+
+class FXNPredictionStream(Structure): pass
+
+FXNPredictionStreamRef = POINTER(FXNPredictionStream)
+
+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

fxn-0.0.36/fxn/c/value.py

@@ -0,0 +1,50 @@
+#
+#   Function
+#   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
+
+class FXNValueFlags(c_int):
+    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

fxn-0.0.36/fxn/c/version.py

@@ -0,0 +1,13 @@
+#
+#   Function
+#   Copyright © 2024 NatML Inc. All Rights Reserved.
+#
+
+from ctypes import c_char_p, CDLL
+
+def _register_fxn_version (fxnc: CDLL) -> CDLL:
+    # FXNGetVersion
+    fxnc.FXNGetVersion.argtypes = []
+    fxnc.FXNGetVersion.restype = c_char_p
+    # Return
+    return fxnc

{fxn-0.0.35 → fxn-0.0.36}/fxn/cli/__init__.py

@@ -9,7 +9,7 @@ from .auth import app as auth_app
 from .env import app as env_app
 from .misc import cli_options
 from .predict import predict
-from .predictors import archive_predictor, create_predictor, delete_predictor, list_predictors, retrieve_predictor, search_predictors
+from .predictors import archive_predictor, delete_predictor, list_predictors, retrieve_predictor, search_predictors
 from ..version import __version__
 
 # Define CLI
@@ -26,16 +26,16 @@ 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.")
+#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="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="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)
 
 # Run
 if __name__ == "__main__":

{fxn-0.0.35 → fxn-0.0.36}/fxn/cli/auth.py

@@ -15,7 +15,7 @@ app = Typer(no_args_is_help=True)
 def login (
     access_key: str=Argument(..., help="Function access key.", envvar="FXN_ACCESS_KEY")
 ):
-    fxn = Function(access_key)
+    fxn = Function(access_key=access_key)
     user = fxn.users.retrieve()
     user = user.model_dump() if user else None
     _set_access_key(access_key if user is not None else None)

{fxn-0.0.35 → fxn-0.0.36}/fxn/cli/predict.py

@@ -18,12 +18,11 @@ from .auth import get_access_key
 
 def predict (
     tag: str = Argument(..., help="Predictor tag."),
-    raw_outputs: bool = Option(False, "--raw-outputs", help="Output raw Function values instead of converting into plain Python values."),
     context: Context = 0
 ):
-    run_async(_predict_async(tag, context=context, raw_outputs=raw_outputs))
+    run_async(_predict_async(tag, context=context))
 
-async def _predict_async (tag: str, context: Context, raw_outputs: bool):
+async def _predict_async (tag: str, context: Context):
     with Progress(
         SpinnerColumn(spinner_name="dots"),
         TextColumn("[progress.description]{task.description}"),
@@ -34,7 +33,7 @@ async def _predict_async (tag: str, context: Context, raw_outputs: bool):
         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, raw_outputs=raw_outputs, return_binary_path=True):
+        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

{fxn-0.0.35 → fxn-0.0.36}/fxn/cli/predictors.py

@@ -5,12 +5,10 @@
 
 from rich import print_json
 from rich.progress import Progress, SpinnerColumn, TextColumn
-from pathlib import Path
 from typer import Argument, Option
-from typing import List
 
 from ..function import Function
-from ..types import Acceleration, AccessMode, PredictorStatus, PredictorType
+from ..types import PredictorStatus
 from .auth import get_access_key
 
 def retrieve_predictor (
@@ -47,43 +45,6 @@ def search_predictors (
     predictors = [predictor.model_dump() for predictor in predictors]
     print_json(data=predictors)
 
-def create_predictor (
-    tag: str=Argument(..., help="Predictor tag."),
-    notebook: Path=Argument(..., help="Path to predictor notebook."),
-    type: PredictorType=Option(None, case_sensitive=False, help="Predictor type. This defaults to `cloud`."),
-    edge: bool=Option(False, "--edge", is_flag=True, help="Shorthand for `--type edge`."),
-    cloud: bool=Option(False, "--cloud", is_flag=True, help="Shorthand for `--type cloud`."),
-    access: AccessMode=Option(None, case_sensitive=False, help="Predictor access mode. This defaults to `private`."),
-    description: str=Option(None, help="Predictor description. This must be less than 200 characters long."),
-    media: Path=Option(None, help="Predictor image path."),
-    acceleration: Acceleration=Option(None, case_sensitive=False, help="Cloud predictor acceleration. This defaults to `cpu`."),
-    license: str=Option(None, help="Predictor license URL."),
-    env: List[str]=Option([], help="Specify a predictor environment variable."),
-    overwrite: bool=Option(None, "--overwrite", help="Overwrite any existing predictor with the same tag.")
-):
-    with Progress(
-        SpinnerColumn(spinner_name="dots"),
-        TextColumn("[progress.description]{task.description}"),
-        transient=True
-    ) as progress:
-        progress.add_task(description="Analyzing Function...", total=None)
-        fxn = Function(get_access_key())
-        type = PredictorType.Cloud if cloud else PredictorType.Edge if edge else type
-        environment = { e.split("=")[0].strip(): e.split("=")[1].strip() for e in env }
-        predictor = fxn.predictors.create(
-            tag=tag,
-            notebook=notebook,
-            type=type,
-            access=access,
-            description=description,
-            media=media,
-            acceleration=acceleration,
-            environment=environment,
-            license=license,
-            overwrite=overwrite
-        )
-        print_json(data=predictor.model_dump())
-
 def delete_predictor (
     tag: str=Argument(..., help="Predictor tag.")
 ):