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

fxn/__init__.py

@@ -4,7 +4,8 @@
 #
 
 from .client import FunctionAPIError
-from .compile import *
+from .compile import compile, CompileTarget
 from .function import Function
+from .sandbox import Sandbox
 from .types import *
 from .version import *

fxn/beta/client.py

@@ -3,8 +3,17 @@
 #   Copyright © 2025 NatML Inc. All Rights Reserved.
 #
 
+from functools import wraps
+from inspect import signature as get_signature, Signature
+from typing import get_origin, Callable, Generator, Iterator, TypeVar
+
 from ..client import FunctionClient
+from ..services import PredictionService as EdgePredictionService
+from ..types import Acceleration
 from .prediction import PredictionService
+from .remote import RemoteAcceleration
+
+F = TypeVar("F", bound=Callable[..., object])
 
 class BetaClient:
     """
@@ -12,5 +21,53 @@ class BetaClient:
     """
     predictions: PredictionService
     
-    def __init__ (self, client: FunctionClient):
-        self.predictions = PredictionService(client)
+    def __init__ (
+        self,
+        client: FunctionClient,
+        *,
+        predictions: EdgePredictionService
+    ):
+        self.predictions = PredictionService(client)
+        self.__edge_predictions = predictions
+
+    def predict ( # INCOMPLETE # Preload
+        self,
+        tag: str,
+        *,
+        remote: bool=False,
+        acceleration: Acceleration | RemoteAcceleration="auto",
+        preload: bool=True
+    ) -> Callable[[F], F]:
+        """
+        Create a prediction and return results when the decorated function is invoked.
+
+        Parameters:
+            tag (str): Predictor tag.
+            remote (bool): Whether to create the prediction remotely.
+            acceleration (Acceleration | RemoteAcceleration): Prediction acceleration.
+            preload (bool): Whether to preload the predictor on the first run.
+        """
+        def decorator(func: F) -> F:
+            signature = get_signature(func)
+            @wraps(func)
+            def wrapper(*args, **kwargs):
+                bound_args = signature.bind(*args, **kwargs)
+                bound_args.apply_defaults()
+                stream = (
+                    signature.return_annotation is not Signature.empty and
+                    get_origin(signature.return_annotation) in [Iterator, Generator]
+                )
+                create_func = self.predictions.remote.create if remote else self.__edge_predictions.create
+                def _predict (): # INCOMPLETE
+                    prediction = create_func(
+                        tag=tag,
+                        inputs=bound_args.arguments,
+                        acceleration=acceleration
+                    )
+                    if prediction.error:
+                        raise RuntimeError(prediction.error)
+                    return tuple(prediction.results) if len(prediction.results) > 1 else prediction.results[0]
+                result = _predict()
+                return result
+            return wrapper
+        return decorator

fxn/beta/remote.py

@@ -13,7 +13,7 @@ from numpy import array, frombuffer, ndarray
 from PIL import Image
 from pydantic import BaseModel, Field
 from requests import get, put
-from typing import Any
+from typing import Literal
 from urllib.request import urlopen
 
 from ..c import Configuration
@@ -21,14 +21,7 @@ from ..client import FunctionClient
 from ..services import Value
 from ..types import Dtype, Prediction
 
-class RemoteAcceleration (str, Enum):
-    """
-    Remote acceleration.
-    """
-    Auto = "auto"
-    CPU = "cpu"
-    A40 = "a40"
-    A100 = "a100"
+RemoteAcceleration = Literal["auto", "cpu", "a40", "a100"]
 
 class RemotePredictionService:
     """
@@ -43,7 +36,7 @@ class RemotePredictionService:
         tag: str,
         *,
         inputs: dict[str, Value],
-        acceleration: RemoteAcceleration=RemoteAcceleration.Auto
+        acceleration: RemoteAcceleration="auto"
     ) -> Prediction:
         """
         Create a remote prediction.
@@ -74,51 +67,51 @@ class RemotePredictionService:
 
     def __to_value (
         self,
-        object: Value,
+        obj: Value,
         *,
         name: str,
         max_data_url_size: int=4 * 1024 * 1024
     ) -> RemoteValue:
-        object = self.__try_ensure_serializable(object)
-        if object is None:
+        obj = self.__try_ensure_serializable(obj)
+        if obj is None:
             return RemoteValue(data=None, type=Dtype.null)
-        elif isinstance(object, float):
-            object = array(object, dtype=Dtype.float32)
-            return self.__to_value(object, name=name, max_data_url_size=max_data_url_size)
-        elif isinstance(object, bool):
-            object = array(object, dtype=Dtype.bool)
-            return self.__to_value(object, name=name, max_data_url_size=max_data_url_size)
-        elif isinstance(object, int):
-            object = array(object, dtype=Dtype.int32)
-            return self.__to_value(object, name=name, max_data_url_size=max_data_url_size)
-        elif isinstance(object, ndarray):
-            buffer = BytesIO(object.tobytes())
+        elif isinstance(obj, float):
+            obj = array(obj, dtype=Dtype.float32)
+            return self.__to_value(obj, name=name, max_data_url_size=max_data_url_size)
+        elif isinstance(obj, bool):
+            obj = array(obj, dtype=Dtype.bool)
+            return self.__to_value(obj, name=name, max_data_url_size=max_data_url_size)
+        elif isinstance(obj, int):
+            obj = array(obj, dtype=Dtype.int32)
+            return self.__to_value(obj, name=name, max_data_url_size=max_data_url_size)
+        elif isinstance(obj, ndarray):
+            buffer = BytesIO(obj.tobytes())
             data = self.__upload(buffer, name=name, max_data_url_size=max_data_url_size)
-            return RemoteValue(data=data, type=object.dtype.name, shape=list(object.shape))
-        elif isinstance(object, str):
-            buffer = BytesIO(object.encode())
+            return RemoteValue(data=data, type=obj.dtype.name, shape=list(obj.shape))
+        elif isinstance(obj, str):
+            buffer = BytesIO(obj.encode())
             data = self.__upload(buffer, name=name, mime="text/plain", max_data_url_size=max_data_url_size)
             return RemoteValue(data=data, type=Dtype.string)
-        elif isinstance(object, list):
-            buffer = BytesIO(dumps(object).encode())
+        elif isinstance(obj, list):
+            buffer = BytesIO(dumps(obj).encode())
             data = self.__upload(buffer, name=name, mime="application/json", max_data_url_size=max_data_url_size)
             return RemoteValue(data=data, type=Dtype.list)
-        elif isinstance(object, dict):
-            buffer = BytesIO(dumps(object).encode())
+        elif isinstance(obj, dict):
+            buffer = BytesIO(dumps(obj).encode())
             data = self.__upload(buffer, name=name, mime="application/json", max_data_url_size=max_data_url_size)
             return RemoteValue(data=data, type=Dtype.dict)
-        elif isinstance(object, Image.Image):
+        elif isinstance(obj, Image.Image):
             buffer = BytesIO()
-            format = "PNG" if object.mode == "RGBA" else "JPEG"
+            format = "PNG" if obj.mode == "RGBA" else "JPEG"
             mime = f"image/{format.lower()}"
-            object.save(buffer, format=format)
+            obj.save(buffer, format=format)
             data = self.__upload(buffer, name=name, mime=mime, max_data_url_size=max_data_url_size)
             return RemoteValue(data=data, type=Dtype.image)
-        elif isinstance(object, BytesIO):
-            data = self.__upload(object, name=name, max_data_url_size=max_data_url_size)
+        elif isinstance(obj, BytesIO):
+            data = self.__upload(obj, name=name, max_data_url_size=max_data_url_size)
             return RemoteValue(data=data, type=Dtype.binary)
         else:
-            raise ValueError(f"Failed to serialize value '{object}' of type `{type(object)}` because it is not supported")
+            raise ValueError(f"Failed to serialize value '{obj}' of type `{type(obj)}` because it is not supported")
 
     def __to_object (self, value: RemoteValue) -> Value:
         if value.type == Dtype.null:
@@ -177,16 +170,16 @@ class RemotePredictionService:
         return result
 
     @classmethod
-    def __try_ensure_serializable (cls, object: Any) -> Any:
-        if object is None:
-            return object
-        if isinstance(object, list):
-            return [cls.__try_ensure_serializable(x) for x in object]
-        if is_dataclass(object) and not isinstance(object, type):
-            return asdict(object)
-        if isinstance(object, BaseModel):
-            return object.model_dump(mode="json", by_alias=True)
-        return object
+    def __try_ensure_serializable (cls, obj: object) -> object:
+        if obj is None:
+            return obj
+        if isinstance(obj, list):
+            return [cls.__try_ensure_serializable(x) for x in obj]
+        if is_dataclass(obj) and not isinstance(obj, type):
+            return asdict(obj)
+        if isinstance(obj, BaseModel):
+            return obj.model_dump(mode="json", by_alias=True)
+        return obj
 
 class RemoteValue (BaseModel):
     data: str | None

fxn/c/configuration.py

@@ -16,15 +16,18 @@ class Configuration:
     def __init__ (self):
         configuration = c_void_p()
         status = get_fxnc().FXNConfigurationCreate(byref(configuration))
-        if status == FXNStatus.OK:
-            self.__configuration = configuration
-        else:
+        if status != FXNStatus.OK:
             raise RuntimeError(f"Failed to create configuration with error: {status_to_error(status)}")
+        self.__configuration = configuration            
 
     @property
     def tag (self) -> str:
         buffer = create_string_buffer(2048)
-        status = get_fxnc().FXNConfigurationGetTag(self.__configuration, buffer, len(buffer))
+        status = get_fxnc().FXNConfigurationGetTag(
+            self.__configuration,
+            buffer,
+            len(buffer)
+        )
         if status != FXNStatus.OK:
             raise RuntimeError(f"Failed to get configuration tag with error: {status_to_error(status)}")
         tag = buffer.value.decode("utf-8")
@@ -40,7 +43,11 @@ class Configuration:
     @property
     def token (self) -> str:
         buffer = create_string_buffer(2048)
-        status = get_fxnc().FXNConfigurationGetToken(self.__configuration, buffer, len(buffer))
+        status = get_fxnc().FXNConfigurationGetToken(
+            self.__configuration,
+            buffer,
+            len(buffer)
+        )
         if status != FXNStatus.OK:
             raise RuntimeError(f"Failed to get configuration token with error: {status_to_error(status)}")
         token = buffer.value.decode("utf-8")
@@ -56,26 +63,33 @@ class Configuration:
     @property
     def acceleration (self) -> Acceleration:
         acceleration = c_int()
-        status = get_fxnc().FXNConfigurationGetAcceleration(self.__configuration, byref(acceleration))
-        if status == FXNStatus.OK:
-            return Acceleration(acceleration.value)
-        else:
+        status = get_fxnc().FXNConfigurationGetAcceleration(
+            self.__configuration,
+            byref(acceleration)
+        )
+        if status != FXNStatus.OK:
             raise RuntimeError(f"Failed to get configuration acceleration with error: {status_to_error(status)}")
+        return self.__to_acceleration_str(acceleration.value)
 
     @acceleration.setter
     def acceleration (self, acceleration: Acceleration):
-        status = get_fxnc().FXNConfigurationSetAcceleration(self.__configuration, acceleration.value)
+        status = get_fxnc().FXNConfigurationSetAcceleration(
+            self.__configuration,
+            self.__to_acceleration_int(acceleration)
+        )
         if status != FXNStatus.OK:
             raise RuntimeError(f"Failed to set configuration acceleration with error: {status_to_error(status)}")
 
     @property
     def device (self):
         device = c_void_p()
-        status = get_fxnc().FXNConfigurationGetDevice(self.__configuration, byref(device))
-        if status == FXNStatus.OK:
-            return device if device.value else None
-        else:
+        status = get_fxnc().FXNConfigurationGetDevice(
+            self.__configuration,
+            byref(device)
+        )
+        if status != FXNStatus.OK:
             raise RuntimeError(f"Failed to get configuration device with error: {status_to_error(status)}")
+        return device if device.value else None            
 
     @device.setter
     def device (self, device):
@@ -84,29 +98,21 @@ class Configuration:
             raise RuntimeError(f"Failed to set configuration device with error: {status_to_error(status)}")
 
     def add_resource (self, type: str, path: Path):
-        status = get_fxnc().FXNConfigurationAddResource(self.__configuration, type.encode(), str(path).encode())
+        status = get_fxnc().FXNConfigurationAddResource(
+            self.__configuration,
+            type.encode(),
+            str(path).encode()
+        )
         if status != FXNStatus.OK:
             raise RuntimeError(f"Failed to add configuration resource with error: {status_to_error(status)}")
 
-    def __enter__ (self):
-        return self
-    
-    def __exit__ (self, exc_type, exc_value, traceback):
-        self.__release()
-
-    def __release (self):
-        if self.__configuration:
-            get_fxnc().FXNConfigurationRelease(self.__configuration)
-        self.__configuration = None
-
     @classmethod
     def get_unique_id (cls) -> str:
         buffer = create_string_buffer(2048)
         status = get_fxnc().FXNConfigurationGetUniqueID(buffer, len(buffer))
-        if status == FXNStatus.OK:
-            return buffer.value.decode("utf-8")
-        else:
+        if status != FXNStatus.OK:
             raise RuntimeError(f"Failed to retrieve configuration identifier with error: {status_to_error(status)}")
+        return buffer.value.decode("utf-8")
 
     @classmethod
     def get_client_id (cls) -> str:
@@ -115,4 +121,30 @@ class Configuration:
         if status == FXNStatus.OK:
             return buffer.value.decode("utf-8")
         else:
-            raise RuntimeError(f"Failed to retrieve client identifier with error: {status_to_error(status)}")
+            raise RuntimeError(f"Failed to retrieve client identifier with error: {status_to_error(status)}")
+        
+    def __enter__ (self):
+        return self
+    
+    def __exit__ (self, exc_type, exc_value, traceback):
+        self.__release()
+
+    def __release (self):
+        if self.__configuration:
+            get_fxnc().FXNConfigurationRelease(self.__configuration)
+        self.__configuration = None
+
+    def __to_acceleration_int (self, value: Acceleration) -> int:
+        match value:
+            case "auto": return 0
+            case "cpu": return 1
+            case "gpu": return 2
+            case "npu": return 4
+
+    def __to_acceleration_str (self, value: int) -> Acceleration:
+        match value:
+            case 0: return "auto"
+            case 1: return "cpu"
+            case 2: return "gpu"
+            case 4: return "npu"
+            case _: return None

fxn/c/value.py

@@ -48,7 +48,7 @@ class Value:
 
     @property
     def shape (self) -> list[int] | None:
-        if self.type not in _TENSOR_DTYPES:
+        if self.type not in _TENSOR_ISH_DTYPES:
             return None
         fxnc = get_fxnc()
         dims = c_int32()
@@ -220,4 +220,5 @@ _TENSOR_DTYPES = {
     Dtype.uint32,
     Dtype.uint64,
     Dtype.bool,
-}
+}
+_TENSOR_ISH_DTYPES = _TENSOR_DTYPES | { Dtype.image }

fxn/cli/__init__.py

@@ -3,17 +3,19 @@
 #   Copyright © 2025 NatML Inc. All Rights Reserved.
 #
 
-from typer import Typer
+import typer
 
 from .auth import app as auth_app
-#from .compile import compile_predictor
+from .compile import compile_predictor
 from .misc import cli_options
 from .predictions import create_prediction
-from .predictors import retrieve_predictor
+from .predictors import archive_predictor, delete_predictor, retrieve_predictor
+from ..logging import TracebackMarkupConsole
 from ..version import __version__
 
 # Define CLI
-app = Typer(
+typer.main.console_stderr = TracebackMarkupConsole()
+app = typer.Typer(
     name=f"Function CLI {__version__}",
     no_args_is_help=True,
     pretty_exceptions_show_locals=False,
@@ -33,11 +35,13 @@ app.command(
     help="Make a prediction.",
     context_settings={ "allow_extra_args": True, "ignore_unknown_options": True }
 )(create_prediction)
-# app.command(
-#     name="compile",
-#     help="Create a predictor by compiling a Python function."
-# )(compile_predictor)
+app.command(
+    name="compile",
+    help="Create a predictor by compiling a Python function."
+)(compile_predictor)
 app.command(name="retrieve", help="Retrieve a predictor.")(retrieve_predictor)
+app.command(name="archive", help="Archive a predictor.")(archive_predictor)
+app.command(name="delete", help="Delete a predictor.")(delete_predictor)
 
 # Run
 if __name__ == "__main__":

fxn/cli/compile.py

@@ -0,0 +1,147 @@
+# 
+#   Function
+#   Copyright © 2025 NatML Inc. All Rights Reserved.
+#
+
+from asyncio import run as run_async
+from importlib.util import module_from_spec, spec_from_file_location
+from inspect import getmembers, getmodulename, isfunction
+from pathlib import Path
+from pydantic import BaseModel
+from rich import print as print_rich
+from rich.progress import SpinnerColumn, TextColumn
+import sys
+from typer import Argument, Option
+from typing import Callable, Literal
+from urllib.parse import urlparse, urlunparse
+
+from ..compile import PredictorSpec
+from ..function import Function
+from ..sandbox import EntrypointCommand
+from ..logging import CustomProgress, CustomProgressTask
+from .auth import get_access_key
+
+class CompileError (Exception):
+    pass
+
+def compile_predictor (
+    path: str=Argument(..., help="Predictor path.")
+):
+    run_async(_compile_predictor_async(path))
+
+async def _compile_predictor_async (path: str):
+    fxn = Function(get_access_key())
+    path: Path = Path(path).resolve()
+    with CustomProgress():
+        # Load
+        with CustomProgressTask(loading_text="Loading predictor...") as task:
+            func = _load_predictor_func(path)
+            entrypoint = EntrypointCommand(from_path=str(path), to_path="./", name=func.__name__)
+            spec: PredictorSpec = func.__predictor_spec
+            task.finish(f"Loaded prediction function: [bold cyan]{spec.tag}[/bold cyan]")
+        # Populate
+        sandbox = spec.sandbox
+        sandbox.commands.append(entrypoint)
+        with CustomProgressTask(loading_text="Uploading sandbox...", done_text="Uploaded sandbox"):
+            sandbox.populate(fxn=fxn)
+        # Compile
+        with CustomProgressTask(loading_text="Running codegen...", done_text="Completed codegen"):
+            with CustomProgressTask(loading_text="Creating predictor..."):
+                predictor = fxn.client.request(
+                    method="POST",
+                    path="/predictors",
+                    body=spec.model_dump(mode="json", exclude=spec.model_extra.keys(), by_alias=True),
+                    response_type=_Predictor
+                )
+            with ProgressLogQueue() as task_queue:
+                async for event in fxn.client.stream(
+                    method="POST",
+                    path=f"/predictors/{predictor.tag}/compile",
+                    body={ },
+                    response_type=_LogEvent | _ErrorEvent
+                ):
+                    if isinstance(event, _LogEvent):
+                        task_queue.push_log(event)
+                    elif isinstance(event, _ErrorEvent):
+                        task_queue.push_error(event)
+                        raise CompileError(event.data.error)
+    predictor_url = _compute_predictor_url(fxn.client.api_url, spec.tag)
+    print_rich(f"\n[bold spring_green3]🎉 Predictor is now being compiled.[/bold spring_green3] Check it out at [link={predictor_url}]{predictor_url}[/link]")
+
+def _load_predictor_func (path: str) -> Callable[...,object]:
+    if "" not in sys.path:
+        sys.path.insert(0, "")
+    path: Path = Path(path).resolve()
+    sys.path.insert(0, str(path.parent))
+    name = getmodulename(path)
+    spec = spec_from_file_location(name, path)
+    module = module_from_spec(spec)
+    sys.modules[name] = module
+    spec.loader.exec_module(module)
+    main_func = next(func for _, func in getmembers(module, isfunction) if hasattr(func, "__predictor_spec"))
+    return main_func
+
+def _compute_predictor_url (api_url: str, tag: str) -> str:
+    parsed_url = urlparse(api_url)
+    hostname_parts = parsed_url.hostname.split(".")
+    if hostname_parts[0] == "api":
+        hostname_parts.pop(0)
+    hostname = ".".join(hostname_parts)
+    netloc = hostname if not parsed_url.port else f"{hostname}:{parsed_url.port}"
+    predictor_url = urlunparse(parsed_url._replace(netloc=netloc, path=f"{tag}"))
+    return predictor_url
+
+class _Predictor (BaseModel):
+    tag: str
+
+class _LogData (BaseModel):
+    message: str
+    level: int = 0
+    status: Literal["success", "error"] = "success"
+    update: bool = False
+
+class _LogEvent (BaseModel):
+    event: Literal["log"]
+    data: _LogData
+
+class _ErrorData (BaseModel):
+    error: str
+
+class _ErrorEvent (BaseModel):
+    event: Literal["error"]
+    data: _ErrorData
+
+class ProgressLogQueue:
+
+    def __init__ (self):
+        self.queue: list[tuple[int, CustomProgressTask]] = []
+
+    def push_log (self, event: _LogEvent):
+        # Check for update
+        if event.data.update and self.queue:
+            current_level, current_task = self.queue[-1]
+            current_task.update(description=event.data.message, status=event.data.status)
+            return
+        # Pop
+        while self.queue:
+            current_level, current_task = self.queue[-1]
+            if event.data.level > current_level:
+                break
+            current_task.__exit__(None, None, None)
+            self.queue.pop()
+        task = CustomProgressTask(loading_text=event.data.message)
+        task.__enter__()
+        self.queue.append((event.data.level, task))
+
+    def push_error (self, error: _ErrorEvent):
+        while self.queue:
+            _, current_task = self.queue.pop()
+            current_task.__exit__(RuntimeError, None, None)
+
+    def __enter__ (self):
+        return self
+    
+    def __exit__ (self, exc_type, exc_value, traceback):
+        while self.queue:
+            _, current_task = self.queue.pop()
+            current_task.__exit__(None, None, None)

fxn/cli/predictions.py

@@ -9,11 +9,11 @@ from numpy import array_repr, ndarray
 from pathlib import Path, PurePath
 from PIL import Image
 from rich import print_json
-from rich.progress import Progress, SpinnerColumn, TextColumn
 from tempfile import mkstemp
 from typer import Argument, Context, Option
 
 from ..function import Function
+from ..logging import CustomProgress, CustomProgressTask
 from ..types import Prediction
 from .auth import get_access_key
 
@@ -26,18 +26,21 @@ def create_prediction (
 
 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)
-        inputs = { context.args[i].replace("-", ""): _parse_value(context.args[i+1]) for i in range(0, len(context.args), 2) }
-        prediction = fxn.predictions.create(tag, inputs=inputs)
-        _log_prediction(prediction)
+    with CustomProgress(transient=True, disable=quiet):
+        fxn = Function(get_access_key())
+        with CustomProgressTask(
+            loading_text="Preloading predictor...",
+            done_text="Preloaded predictor"
+        ):
+            fxn.predictions.create(tag, inputs={ })
+        with CustomProgressTask(loading_text="Making prediction..."):
+            inputs = { }
+            for i in range(0, len(context.args), 2):
+                name = context.args[i].replace("-", "")
+                value = _parse_value(context.args[i+1])
+                inputs[name] = value
+            prediction = fxn.predictions.create(tag, inputs=inputs)
+    _log_prediction(prediction)
 
 def _parse_value (value: str):
     """

fxn/cli/predictors.py

@@ -7,12 +7,43 @@ from rich import print_json
 from typer import Argument
 
 from ..function import Function
+from ..logging import CustomProgress, CustomProgressTask
 from .auth import get_access_key
 
 def retrieve_predictor (
     tag: str=Argument(..., help="Predictor tag.")
 ):
-    fxn = Function(get_access_key())
-    predictor = fxn.predictors.retrieve(tag)
-    predictor = predictor.model_dump() if predictor else None
-    print_json(data=predictor)
+    with CustomProgress(transient=True):
+        with CustomProgressTask(loading_text="Retrieving predictor..."):
+            fxn = Function(get_access_key())
+            predictor = fxn.predictors.retrieve(tag)
+            predictor = predictor.model_dump() if predictor else None
+            print_json(data=predictor)
+
+def archive_predictor (
+    tag: str=Argument(..., help="Predictor tag.")
+):
+    with CustomProgress():
+        with CustomProgressTask(
+            loading_text="Archiving predictor...",
+            done_text=f"Archived predictor: [bold dark_orange]{tag}[/bold dark_orange]"
+        ):
+            fxn = Function(get_access_key())
+            fxn.client.request(
+                method="POST",
+                path=f"/predictors/{tag}/archive"
+            )
+
+def delete_predictor (
+    tag: str=Argument(..., help="Predictor tag.")
+):
+    with CustomProgress():
+        with CustomProgressTask(
+            loading_text="Deleting predictor...",
+            done_text=f"Deleted predictor: [bold red]{tag}[/bold red]"
+        ):
+            fxn = Function(get_access_key())
+            fxn.client.request(
+                method="DELETE",
+                path=f"/predictors/{tag}"
+            )