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

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/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/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/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/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/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/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/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/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/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/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/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/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/cli/misc.py

@@ -9,18 +9,24 @@ from webbrowser import open as open_browser
 
 from ..version import __version__
 
-def _learn_callback (value: bool):
+def _explore (value: bool):
+    if value:
+        open_browser("https://fxn.ai/explore")
+        raise Exit()
+
+def _learn (value: bool):
     if value:
         open_browser("https://docs.fxn.ai")
         raise Exit()
 
-def _version_callback (value: bool):
+def _version (value: bool):
     if value:
         print(__version__)
         raise Exit()
 
 def cli_options (
-    learn: bool = Option(None, "--learn", callback=_learn_callback, help="Learn about Function."),
-    version: bool = Option(None, "--version", callback=_version_callback, help="Get the Function CLI version.")
+    explore: bool = Option(None, "--explore", callback=_explore, help="Explore predictors on Function."),
+    learn: bool = Option(None, "--learn", callback=_learn, help="Learn about Function."),
+    version: bool = Option(None, "--version", callback=_version, help="Get the Function CLI version.")
 ):
     pass

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/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.")
 ):

fxn/function.py

@@ -5,8 +5,8 @@
 
 from os import environ
 
-from .graph import GraphClient
-from .services import EnvironmentVariableService, PredictionService, PredictorService, StorageService, UserService
+from .api import GraphClient
+from .services import PredictionService, PredictorService, UserService
 
 class Function:
     """
@@ -17,8 +17,6 @@ class Function:
         users (UserService): Manage users.
         predictors (PredictorService): Manage predictors.
         predictions (PredictionService): Manage predictions.
-        environment_variables (EnvironmentVariableService): Manage predictor environment variables.
-        storage (StorageService): Upload and download files.
 
     Constructor:
         access_key (str): Function access key.
@@ -28,15 +26,11 @@ class Function:
     users: UserService
     predictors: PredictorService
     predictions: PredictionService
-    environment_variables: EnvironmentVariableService
-    storage: StorageService
 
     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)
         self.users = UserService(self.client)
-        self.storage = StorageService(self.client)
-        self.predictors = PredictorService(self.client, self.storage)
-        self.predictions = PredictionService(self.client, self.storage)
-        self.environment_variables = EnvironmentVariableService(self.client)
+        self.predictors = PredictorService(self.client)
+        self.predictions = PredictionService(self.client)

fxn/services/__init__.py

@@ -5,6 +5,4 @@
 
 from .user import UserService, PROFILE_FIELDS, USER_FIELDS
 from .predictor import PredictorService, PREDICTOR_FIELDS
-from .prediction import PredictionService, PREDICTION_FIELDS
-from .environment import EnvironmentVariableService, ENVIRONMENT_VARIABLE_FIELDS
-from .storage import StorageService
+from .prediction import PredictionService, PREDICTION_FIELDS