fxn 0.0.43__py3-none-any.whl → 0.0.45__py3-none-any.whl

fxn/__init__.py

@@ -4,7 +4,7 @@
 #
 
 from .client import FunctionAPIError
-from .compile import compile
+from .compile import compile, CompileTarget
 from .function import Function
 from .sandbox import Sandbox
 from .types 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,21 @@
 #   Copyright © 2025 NatML Inc. All Rights Reserved.
 #
 
-from typer import Typer
+import typer
+
+from ..logging import TracebackMarkupConsole
+from ..version import __version__
 
 from .auth import app as auth_app
 from .compile import compile_predictor
 from .misc import cli_options
 from .predictions import create_prediction
 from .predictors import archive_predictor, delete_predictor, retrieve_predictor
-from ..version import __version__
+from .sources import retrieve_source
 
 # 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,
@@ -40,6 +44,7 @@ app.command(
 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)
+app.command(name="source", help="Retrieve the native source code for a given prediction.")(retrieve_source)
 
 # Run
 if __name__ == "__main__":

fxn/cli/compile.py

@@ -8,32 +8,36 @@ 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 re import sub
 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 ..client import FunctionAPIError
 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.")
+    path: str=Argument(..., help="Predictor path."),
+    overwrite: bool=Option(False, "--overwrite", help="Whether to delete any existing predictor with the same tag before compiling."),
 ):
-    run_async(_compile_predictor_async(path))
+    run_async(_compile_predictor_async(path, overwrite=overwrite))
 
-async def _compile_predictor_async (path: str):
+async def _compile_predictor_async (
+    path: str,
+    *,
+    overwrite: bool
+):
     fxn = Function(get_access_key())
     path: Path = Path(path).resolve()
-    with CustomProgress(
-        SpinnerColumn(spinner_name="dots", finished_text="[bold green]✔[/bold green]"),
-        TextColumn("[progress.description]{task.description}"),
-    ):
+    with CustomProgress():
         # Load
         with CustomProgressTask(loading_text="Loading predictor...") as task:
             func = _load_predictor_func(path)
@@ -48,10 +52,19 @@ async def _compile_predictor_async (path: str):
         # Compile
         with CustomProgressTask(loading_text="Running codegen...", done_text="Completed codegen"):
             with CustomProgressTask(loading_text="Creating predictor..."):
+                if overwrite:
+                    try:
+                        fxn.client.request(
+                            method="DELETE",
+                            path=f"/predictors/{spec.tag}"
+                        )
+                    except FunctionAPIError as error:
+                        if error.status_code != 404:
+                            raise
                 predictor = fxn.client.request(
                     method="POST",
                     path="/predictors",
-                    body=spec.model_dump(mode="json"),
+                    body=spec.model_dump(mode="json", exclude=spec.model_extra.keys(), by_alias=True),
                     response_type=_Predictor
                 )
             with ProgressLogQueue() as task_queue:
@@ -65,9 +78,9 @@ async def _compile_predictor_async (path: str):
                         task_queue.push_log(event)
                     elif isinstance(event, _ErrorEvent):
                         task_queue.push_error(event)
-                        raise RuntimeError(event.data.error)
+                        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 {predictor_url}")
+    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:
@@ -98,6 +111,8 @@ class _Predictor (BaseModel):
 class _LogData (BaseModel):
     message: str
     level: int = 0
+    status: Literal["success", "error"] = "success"
+    update: bool = False
 
 class _LogEvent (BaseModel):
     event: Literal["log"]
@@ -116,14 +131,19 @@ class ProgressLogQueue:
         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()
-        message = sub(r"`([^`]+)`", r"[hot_pink italic]\1[/hot_pink italic]", event.data.message)
-        task = CustomProgressTask(loading_text=message)
+        task = CustomProgressTask(loading_text=event.data.message)
         task.__enter__()
         self.queue.append((event.data.level, task))
 

fxn/cli/sources.py

@@ -0,0 +1,46 @@
+# 
+#   Function
+#   Copyright © 2025 NatML Inc. All Rights Reserved.
+#
+
+from datetime import datetime
+from pathlib import Path
+from pydantic import BaseModel
+from rich import print_json
+from typer import Argument, Option
+from typing_extensions import Annotated
+
+from ..function import Function
+from ..logging import CustomProgress, CustomProgressTask
+from .auth import get_access_key
+
+def retrieve_source (
+    predictor: Annotated[str, Option(help="Predictor tag.")] = None,
+    prediction: Annotated[str, Option(help="Prediction identifier. If specified, this MUST be from a prediction returned by the Function API.")] = None,
+    output: Annotated[Path, Option(help="Path to output source file.")] = Path("predictor.cpp")
+):
+    if not ((predictor is not None) ^ (prediction is not None)):
+        raise ValueError(f"Predictor tag or prediction identifier must be provided, but not both.")
+    fxn = Function(get_access_key())
+    with CustomProgress(transient=True):
+        if prediction is None:
+            with CustomProgressTask(loading_text="Creating prediction..."):
+                empty_prediction = fxn.predictions.create(tag=predictor)
+                prediction = empty_prediction.id
+        with CustomProgressTask(loading_text="Retrieving source..."):
+            source = fxn.client.request(
+                method="GET",
+                path=f"/predictions/{prediction}/source",
+                response_type=_PredictionSource
+            )
+            output.write_text(source.code)
+            source.code = str(output.resolve())
+            print_json(data=source.model_dump(mode="json", by_alias=True))
+
+class _PredictionSource (BaseModel):
+    tag: str
+    target: str
+    code: str
+    created: datetime
+    compiled: datetime
+    latency: float # millis

fxn/compile.py

@@ -7,11 +7,15 @@ from collections.abc import Callable
 from functools import wraps
 from inspect import isasyncgenfunction, iscoroutinefunction
 from pathlib import Path
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, ConfigDict, Field
+from types import ModuleType
+from typing import Literal
 
 from .sandbox import Sandbox
 from .types import AccessMode
 
+CompileTarget = Literal["android", "ios", "linux", "macos", "visionos", "wasm", "windows"]
+
 class PredictorSpec (BaseModel):
     """
     Descriptor of a predictor to be compiled.
@@ -19,20 +23,25 @@ class PredictorSpec (BaseModel):
     tag: str = Field(description="Predictor tag.")
     description: str = Field(description="Predictor description. MUST be less than 100 characters long.", min_length=4, max_length=100)
     sandbox: Sandbox = Field(description="Sandbox to compile the function.")
+    targets: list[str] | None = Field(description="Targets to compile this predictor for. Pass `None` to compile for our default targets.")
     access: AccessMode = Field(description="Predictor access.")
     card: str | None = Field(default=None, description="Predictor card (markdown).")
     media: str | None = Field(default=None, description="Predictor media URL.")
     license: str | None = Field(default=None, description="Predictor license URL. This is required for public predictors.")
+    model_config = ConfigDict(arbitrary_types_allowed=True, extra="allow", frozen=True)
 
 def compile (
     tag: str,
     *,
     description: str,
     sandbox: Sandbox=None,
+    trace_modules: list[ModuleType]=[],
+    targets: list[CompileTarget]=None,
     access: AccessMode=AccessMode.Private,
     card: str | Path=None,
     media: Path=None,
     license: str=None,
+    **kwargs
 ):
     """
     Create a predictor by compiling a stateless function.
@@ -41,6 +50,8 @@ def compile (
         tag (str): Predictor tag.
         description (str): Predictor description. MUST be less than 100 characters long.
         sandbox (Sandbox): Sandbox to compile the function.
+        trace_modules (list): Modules to trace and compile.
+        targets (list): Targets to compile this predictor for. Pass `None` to compile for our default targets.
         access (AccessMode): Predictor access.
         card (str | Path): Predictor card markdown string or path to card.
         media (Path): Predictor thumbnail image (jpeg or png) path.
@@ -51,21 +62,19 @@ def compile (
         if not callable(func):
             raise TypeError("Cannot compile non-function objects")
         if isasyncgenfunction(func) or iscoroutinefunction(func):
-            raise TypeError(f"Function '{func.__name__}' must be a regular function or generator")            
+            raise TypeError(f"Entrypoint function '{func.__name__}' must be a regular function or generator")            
         # Gather metadata
-        if isinstance(card, Path):
-            with open(card_content, "r") as f:
-                card_content = f.read()
-        else:
-            card_content = card
         spec = PredictorSpec(
             tag=tag,
             description=description,
             sandbox=sandbox if sandbox is not None else Sandbox(),
+            targets=targets,
             access=access,
-            card=card_content,
+            card=card.read_text() if isinstance(card, Path) else card,
             media=None, # INCOMPLETE
-            license=license
+            license=license,
+            trace_modules=trace_modules,
+            **kwargs
         )
         # Wrap
         @wraps(func)

fxn/function.py

@@ -30,11 +30,16 @@ class Function:
     predictions: PredictionService
     beta: BetaClient
 
-    def __init__ (self, access_key: str=None, api_url: str=None):
-        access_key = access_key or environ.get("FXN_ACCESS_KEY", None)
+    def __init__ (
+        self,
+        access_key: str=None,
+        *,
+        api_url: str=None
+    ):
+        access_key = access_key or environ.get("FXN_ACCESS_KEY")
         api_url = api_url or environ.get("FXN_API_URL")
         self.client = FunctionClient(access_key, api_url)
         self.users = UserService(self.client)
         self.predictors = PredictorService(self.client)
         self.predictions = PredictionService(self.client)
-        self.beta = BetaClient(self.client)
+        self.beta = BetaClient(self.client, predictions=self.predictions)

fxn/logging.py

@@ -4,12 +4,62 @@
 #
 
 from contextvars import ContextVar
-from rich.progress import BarColumn, Progress, ProgressColumn, SpinnerColumn, TextColumn
-from typing import Literal
+from rich.console import Console, ConsoleOptions, RenderResult
+from rich.progress import Progress, ProgressColumn, SpinnerColumn, TextColumn
+from rich.text import Text
+from rich.traceback import Traceback
+from types import MethodType
 
 current_progress = ContextVar("current_progress", default=None)
 progress_task_stack = ContextVar("progress_task_stack", default=[])
 
+class CustomSpinnerColumn (SpinnerColumn):
+    
+    def __init__ (
+        self,
+        spinner_name="dots",
+        success_text="[bold green]✔[/bold green]",
+        failure_text="[bright_red]✘[/bright_red]",
+        style="",
+    ):
+        super().__init__(spinner_name=spinner_name, style=style)
+        self.success_text = success_text
+        self.failure_text = failure_text
+
+    def render (self, task):
+        done_text = (
+            self.failure_text
+            if task.fields.get("status") == "error"
+            else self.success_text
+        )
+        return done_text if task.finished else self.spinner
+
+class CustomTextColumn (TextColumn):
+    """Custom text column that changes color based on task status"""
+    
+    def __init__ (self, text_format="{task.description}"):
+        super().__init__(text_format)
+    
+    def render (self, task):
+        # Indent and color
+        description = task.description
+        indent_level = task.fields.get("indent_level", 0)
+        indent = self.__get_indent(indent_level)
+        task.description = f"{indent}{description}"
+        if task.fields.get("status") == "error":
+            task.description = f"[bright_red]{task.description}[/bright_red]"
+        # Render
+        text = super().render(task)
+        task.description = description        
+        # Return
+        return text
+    
+    def __get_indent (self, level: int) -> str:
+        if level == 0:
+            return ""
+        indicator = "└── "
+        return " " * len(indicator) * (level - 1) + indicator
+
 class CustomProgress(Progress):
 
     def __init__ (
@@ -27,8 +77,8 @@ class CustomProgress(Progress):
         expand=False
     ):
         default_columns = list(columns) if len(columns) > 0 else [
-            SpinnerColumn(spinner_name="dots", finished_text="[bold green]✔[/bold green]"),
-            TextColumn("[progress.description]{task.description}"),
+            CustomSpinnerColumn(),
+            CustomTextColumn("[progress.description]{task.description}"),
         ]
         super().__init__(
             *default_columns,
@@ -71,19 +121,18 @@ class CustomProgressTask:
         columns: list[ProgressColumn]=None
     ):
         self.loading_text = loading_text
-        self.done_text = done_text if done_text is not None else loading_text
+        self.done_text = done_text
         self.task_id = None
         self.columns = columns
 
     def __enter__ (self):
         progress = current_progress.get()
-        indent_level = len(progress_task_stack.get())
-        indent = self.__get_indent(indent_level)
         if progress is not None:
             self.task_id = progress.add_task(
-                f"{indent}{self.loading_text}",
+                self.loading_text,
                 total=1,
-                columns=self.columns
+                columns=self.columns,
+                indent_level=len(progress_task_stack.get())
             )
             current_stack = progress_task_stack.get()
             progress_task_stack.set(current_stack + [self.task_id])
@@ -92,20 +141,13 @@ class CustomProgressTask:
     def __exit__ (self, exc_type, exc_val, exc_tb):
         progress = current_progress.get()
         if progress is not None and self.task_id is not None:
-            indent_level = len(progress_task_stack.get()) - 1
-            indent = self.__get_indent(indent_level)
-            if exc_type is None:
-                total = progress._tasks[self.task_id].total
-                progress.update(
-                    self.task_id,
-                    description=f"{indent}{self.done_text}",
-                    completed=total
-                )
-            else:
-                progress.update(
-                    self.task_id,
-                    description=f"{indent}[bright_red]✘ {self.loading_text}[/bright_red]",
-                )
+            current_task = progress._tasks[self.task_id]
+            progress.update(
+                self.task_id,
+                description=self.done_text or current_task.description,
+                completed=current_task.total,
+                status="error" if exc_type is not None else current_task.fields.get("status")
+            )
             current_stack = progress_task_stack.get()
             if current_stack:
                 progress_task_stack.set(current_stack[:-1])
@@ -116,22 +158,62 @@ class CustomProgressTask:
         progress = current_progress.get()
         if progress is None or self.task_id is None:
             return
-        if "description" in kwargs:
-            stack = progress_task_stack.get()
-            try:
-                index = stack.index(self.task_id)
-            except ValueError:
-                index = len(stack) - 1
-            indent = self.__get_indent(index)
-            description = kwargs["description"]
-            kwargs["description"] = f"{indent}{description}"
         progress.update(self.task_id, **kwargs)
 
     def finish (self, message: str):
         self.done_text = message
+    
+class TracebackMarkupConsole (Console):
 
-    def __get_indent (self, level: int) -> str:
-        if level == 0:
-            return ""
-        indicator = "└── "
-        return " " * len(indicator) * (level - 1) + indicator
+    def print(
+        self,
+        *objects,
+        sep = " ",
+        end = "\n",
+        style = None,
+        justify = None,
+        overflow = None,
+        no_wrap = None,
+        emoji = None,
+        markup = None,
+        highlight = None,
+        width = None,
+        height = None,
+        crop = True,
+        soft_wrap = None,
+        new_line_start = False
+    ):
+        traceback = objects[0]
+        if isinstance(traceback, Traceback):
+            stack = traceback.trace.stacks[0]
+            original_rich_console = traceback.__rich_console__
+            def __rich_console__ (self: Traceback, console: Console, options: ConsoleOptions) -> RenderResult:
+                for renderable in original_rich_console(console, options):
+                    if (
+                        isinstance(renderable, Text) and
+                        any(part.startswith(f"{stack.exc_type}:") for part in renderable._text)
+                    ):
+                        yield Text.assemble(
+                            (f"{stack.exc_type}: ", "traceback.exc_type"),
+                            Text.from_markup(stack.exc_value)
+                        )
+                    else:
+                        yield renderable
+            traceback.__rich_console__ = MethodType(__rich_console__, traceback)
+        return super().print(
+            *objects,
+            sep=sep,
+            end=end,
+            style=style,
+            justify=justify,
+            overflow=overflow,
+            no_wrap=no_wrap,
+            emoji=emoji,
+            markup=markup,
+            highlight=highlight,
+            width=width,
+            height=height,
+            crop=crop,
+            soft_wrap=soft_wrap,
+            new_line_start=new_line_start
+        )

fxn/services/prediction.py

@@ -13,7 +13,7 @@ from pydantic import BaseModel
 from requests import get
 from rich.progress import BarColumn, DownloadColumn, TransferSpeedColumn, TimeRemainingColumn
 from tempfile import gettempdir, NamedTemporaryFile
-from typing import Any, AsyncIterator
+from typing import Iterator
 from urllib.parse import urlparse
 
 from ..c import Configuration, Predictor, Prediction as CPrediction, Value as CValue, ValueFlags, ValueMap
@@ -21,7 +21,19 @@ from ..client import FunctionClient
 from ..logging import CustomProgressTask
 from ..types import Acceleration, Prediction, PredictionResource
 
-Value = ndarray | str | float | int | bool | list[Any] | dict[str, Any] | Image.Image | BytesIO | memoryview
+Value = (
+    None                |
+    float               |
+    int                 |
+    bool                |
+    ndarray             |
+    str                 |
+    list[object]        |
+    dict[str, object]   |
+    Image.Image         |
+    BytesIO             |
+    memoryview
+)
 
 class PredictionService:
 
@@ -48,7 +60,7 @@ class PredictionService:
         tag: str,
         *,
         inputs: dict[str, Value] | None=None,
-        acceleration: Acceleration=Acceleration.Auto,
+        acceleration: Acceleration="auto",
         device=None,
         client_id: str=None,
         configuration_id: str=None
@@ -85,14 +97,14 @@ class PredictionService:
         ):
             return self.__to_prediction(tag, prediction)
 
-    async def stream (
+    def stream (
         self,
         tag: str,
         *,
         inputs: dict[str, Value],
-        acceleration: Acceleration=Acceleration.Auto,
+        acceleration: Acceleration="auto",
         device=None
-    ) -> AsyncIterator[Prediction]:
+    ) -> Iterator[Prediction]:
         """
         Stream a prediction.
 
@@ -140,7 +152,7 @@ class PredictionService:
     def __get_predictor (
         self,
         tag: str,
-        acceleration: Acceleration=Acceleration.Auto,
+        acceleration: Acceleration="auto",
         device=None,
         client_id: str=None,
         configuration_id: str=None
@@ -266,7 +278,7 @@ class PredictionService:
             return Path(gettempdir())
 
     @classmethod
-    def __try_ensure_serializable (cls, object: Any) -> Any:
+    def __try_ensure_serializable (cls, object: object) -> object:
         if object is None:
             return object
         if isinstance(object, list):

fxn/types/dtype.py

@@ -11,6 +11,9 @@ class Dtype (str, Enum):
     This follows `numpy` dtypes.
     """
     null = "null"
+    float16 = "float16"
+    float32 = "float32"
+    float64 = "float64"
     int8 = "int8"
     int16 = "int16"
     int32 = "int32"
@@ -19,9 +22,6 @@ class Dtype (str, Enum):
     uint16 = "uint16"
     uint32 = "uint32"
     uint64 = "uint64"
-    float16 = "float16"
-    float32 = "float32"
-    float64 = "float64"
     bool = "bool"
     string = "string"
     list = "list"

fxn/types/prediction.py

@@ -3,9 +3,10 @@
 #   Copyright © 2025 NatML Inc. All Rights Reserved.
 #
 
-from enum import IntFlag
 from pydantic import BaseModel, Field
-from typing import Any
+from typing import Literal
+
+Acceleration = Literal["auto", "cpu", "gpu", "npu"]
 
 class PredictionResource (BaseModel):
     """
@@ -39,17 +40,8 @@ class Prediction (BaseModel):
     tag: str = Field(description="Predictor tag.")
     configuration: str | None = Field(default=None, description="Prediction configuration token. This is only populated for `EDGE` predictions.")
     resources: list[PredictionResource] | None = Field(default=None, description="Prediction resources. This is only populated for `EDGE` predictions.")
-    results: list[Any] | None = Field(default=None, description="Prediction results.")
+    results: list[object] | None = Field(default=None, description="Prediction results.")
     latency: float | None = Field(default=None, description="Prediction latency in milliseconds.")
     error: str | None = Field(default=None, description="Prediction error. This is `None` if the prediction completed successfully.")
     logs: str | None = Field(default=None, description="Prediction logs.")
-    created: str = Field(description="Date created.")
-
-class Acceleration (IntFlag):
-    """
-    Predictor acceleration.
-    """
-    Auto    = 0,
-    CPU     = 1 << 0,
-    GPU     = 1 << 1,
-    NPU     = 1 << 2
+    created: str = Field(description="Date created.")

fxn/version.py

@@ -3,4 +3,4 @@
 #   Copyright © 2025 NatML Inc. All Rights Reserved.
 #
 
-__version__ = "0.0.43"
+__version__ = "0.0.45"

{fxn-0.0.43.dist-info → fxn-0.0.45.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: fxn
-Version: 0.0.43
+Version: 0.0.45
 Summary: Run prediction functions locally in Python. Register at https://fxn.ai.
 Author-email: "NatML Inc." <hi@fxn.ai>
 License:                                  Apache License
@@ -222,6 +222,7 @@ Requires-Dist: pydantic>=2.0
 Requires-Dist: requests
 Requires-Dist: rich
 Requires-Dist: typer
+Dynamic: license-file
 
 # Function for Python and CLI
 

{fxn-0.0.43.dist-info → fxn-0.0.45.dist-info}/RECORD

@@ -1,28 +1,29 @@
-fxn/__init__.py,sha256=62Jg67pac85KHx1pd0ipJqTZmdd8bOrzCHw7qrSThVw,242
+fxn/__init__.py,sha256=eOYYoHwwQWzYVnyBO1VtcWR0JnUm1GPl4kr8IzhnCqg,257
 fxn/client.py,sha256=Deje8eiS1VOHX85tQnV34viv2CPVx2ljwHSbyVB5Z1o,3790
-fxn/compile.py,sha256=v5ZiXZoBmurdbPPIIPyh6uLA3dgDRQK2epKmP31VNjk,2800
-fxn/function.py,sha256=JBZnGaLedgoY-wV5Tg-Rxwpd3tK_ADkD0Qve45NBaA0,1342
-fxn/logging.py,sha256=sDEoRiCoVOWwHaoTep5820dS5IAVt0YRL9UI58lyAx0,4728
+fxn/compile.py,sha256=Z63DMk_pscerqf8uOgWYYEsEsJTDvfrfYBqKYk3PbKE,3426
+fxn/function.py,sha256=XeEuALkbVhkvwEBUfP0A2fu3tdimwHemoR17oomhzc8,1407
+fxn/logging.py,sha256=MsTSf0GZxrHNDwVAXDOh8_zRUg9hkeZ8DfhFUJs7D8A,7250
 fxn/sandbox.py,sha256=w2dnHMBaKOERxFMpeAP11X6_SPqcvnpd6SmX6b_FOYQ,7000
-fxn/version.py,sha256=2DgGAdo8M0eRSYqVhukqPY23jLiNk1bQDMfLzUqoxmg,95
+fxn/version.py,sha256=59sX9tjcjcy9gw0lAlJ18hN47PCe6nQlyoQ8YVYW0hM,95
 fxn/beta/__init__.py,sha256=gKoDhuXtXCjdhUYUqmF0gDPMhJfg3UwFgbvMtRB5ipo,111
-fxn/beta/client.py,sha256=x1AVAz0PlX0Wnemi7KXk5XfC8R6HC7vOQaGUviPJLN8,363
+fxn/beta/client.py,sha256=0lfwQPcB9ToIJC7AcCXO6DlJKkmId8EChhd9bk29GGE,2611
 fxn/beta/prediction.py,sha256=9DTBahNF6m0TicLab2o9e8IKpiSV6K7cUSTYaFju0ZU,356
-fxn/beta/remote.py,sha256=MMFM6QYyxNkpf2czql_JZz9dVbuWHIzhC4mq7pcyPdo,7778
+fxn/beta/remote.py,sha256=HC8OIslZYyxw3XafVCCrP_wrPa00y5uekkKd_tkzyV0,7551
 fxn/c/__init__.py,sha256=NMIduqO_MYtI9jVCu6ZxvbBtYQXoQyNEWblNy3m2UPY,313
-fxn/c/configuration.py,sha256=Jq4kWLu3xb1MWjkfNA4xPr_TykABppbHctUEOHBFdRM,4887
+fxn/c/configuration.py,sha256=56_-NNT4yoHDNfvB6jJNYF2eKJYMRLVrv3mIg7g6qaE,5597
 fxn/c/fxnc.py,sha256=YrvwOlzPmTlSDuz2zmKZfws2WK5BY4YZ62edoplcMJU,1381
 fxn/c/map.py,sha256=47fBJ0Q6uB_xeW3sn9aCLYJ539edg8ff9DU-EIfWRGA,2352
 fxn/c/prediction.py,sha256=-d-5yreFAaRS-nDHzhfabRNtgYcmJGiY_N2dt09gk84,2689
 fxn/c/predictor.py,sha256=48poLj1AthzCgU9n6Wv9gL8o4gFucIlOnBO2wdor6r0,1925
 fxn/c/stream.py,sha256=Y1Xv1Bt3_qlnWg9rCn7NWESpouF1eKMzDiQjhZWbXTg,1105
-fxn/c/value.py,sha256=zkmuKb153UUEnenPO560gXFzxJ_ATvs8_HM-j3OLrJU,7362
-fxn/cli/__init__.py,sha256=6HY2vwoR6W6bT3tXYyeVlp1Ap4F_8BdS0APomiwTG98,1303
+fxn/c/value.py,sha256=h5n91nm8C3YvEEFORfJBUdncZ29DFIdUKGWQ_KpLsWc,7420
+fxn/cli/__init__.py,sha256=vLCNLiXneZzMCFViDOngg3kQZ1rZwnZXzUSEOB38Il0,1542
 fxn/cli/auth.py,sha256=6iGbNbjxfCr8OZT3_neLThXdWeKRBZATwru8vU0XmRw,1688
-fxn/cli/compile.py,sha256=g8u2J58fKL9pyDkMUQe7sX4FMg27npISe0k5tG6GeEY,5307
+fxn/cli/compile.py,sha256=dd3IV1bhBCbMEo0Py6KGxn3vfv_TSDCLL2f-4qLzfiw,6037
 fxn/cli/misc.py,sha256=LcJbCj_GAgtGraTRva2zHHOPpNwI6SOFntRksxwlqvM,843
 fxn/cli/predictions.py,sha256=ma7wbsKD5CFCRTU_TtJ8N0nN1fgFX2BZPGG8qm8HlNI,3182
 fxn/cli/predictors.py,sha256=bVQAuBue_Jxb79X85RTCzOerWRRT2Ny1oF5DNYAsx4M,1545
+fxn/cli/sources.py,sha256=HQ_PBLXY2CZ5tGuuqQeJQTpM9S9rKtBzyNVTK-ywG84,1781
 fxn/lib/__init__.py,sha256=-w1ikmmki5NMpzJjERW-O4SwOfBNkimej_0jL8ujYRk,71
 fxn/lib/linux/arm64/libFunction.so,sha256=NU9PEuQNObqtWPr5vXrWeQuYhzBfmX_Z4guaregFjrI,207632
 fxn/lib/linux/x86_64/libFunction.so,sha256=qZNlczayaaHIP_tJ9eeZ1TVpV1Os-ztvSWOoBuY9yWE,236272
@@ -31,17 +32,17 @@ fxn/lib/macos/x86_64/Function.dylib,sha256=qIu4dhx0Xk5dQHgTnZTcm2IpoMYJwRPmKRi9J
 fxn/lib/windows/arm64/Function.dll,sha256=FyL-oipK9wSxXdbD9frc8QFbUKTPMCdtmCkCT8ooIIM,419328
 fxn/lib/windows/x86_64/Function.dll,sha256=iL6w1FwDgBkHlNhQmhE7XgfoeHsiYQgpVGzeGDdHGUw,454656
 fxn/services/__init__.py,sha256=Bif8IttwJ089mSRsd3MFdob7z2eF-MKigKu4ZQFZBCQ,190
-fxn/services/prediction.py,sha256=zWk1Y35m1a0849xVammTaxrkOfSucB2qEhG-r9cUgTQ,10243
+fxn/services/prediction.py,sha256=QCop-f7ojkGR7DI5tLJe3FPnr0BvPJ_vWhCk4kg8Fqg,10373
 fxn/services/predictor.py,sha256=Wl_7YKiD5mTpC5x2Zaq4BpatRjwRUX8Th9GIrwd38MA,791
 fxn/services/user.py,sha256=ADl5MFLsk4K0altgKHnI-i64E3g1wU3e56Noq_ciRuk,685
 fxn/types/__init__.py,sha256=MEg71rzbGgoWfgB4Yi5QvxbnovHTZRIzCUZLtWtWP1E,292
-fxn/types/dtype.py,sha256=b0V91aknED2Ql0_BOG_vEg__YJVJByxsgB0cR4rtotE,617
-fxn/types/prediction.py,sha256=YVnRcqm6IPEx0796OuT3dqn_jOPjhWblzuM2lkk-Vzo,2173
+fxn/types/dtype.py,sha256=71Tuu4IydmELcBcSBbmWswhCE-7WqBSQ4VkETsFRzjA,617
+fxn/types/prediction.py,sha256=BdLTxnKiSFbz5warX8g_Z4DedNxXK3gaNjSKR2FP8tA,2051
 fxn/types/predictor.py,sha256=KRGZEuDt7WPMCyRcZvQq4y2FMocfVrLEUNJCJgfDY9Y,4000
 fxn/types/user.py,sha256=Z44TwEocyxSrfKyzcNfmAXUrpX_Ry8fJ7MffSxRn4oU,1071
-fxn-0.0.43.dist-info/LICENSE,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
-fxn-0.0.43.dist-info/METADATA,sha256=u2o6KhRYg6lkAeKgHVBnT1-x9pp-0uUK5xtma4CI8rg,16122
-fxn-0.0.43.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-fxn-0.0.43.dist-info/entry_points.txt,sha256=O_AwD5dYaeB-YT1F9hPAPuDYCkw_W0tdNGYbc5RVR2k,45
-fxn-0.0.43.dist-info/top_level.txt,sha256=1ULIEGrnMlhId8nYAkjmRn9g3KEFuHKboq193SEKQkA,4
-fxn-0.0.43.dist-info/RECORD,,
+fxn-0.0.45.dist-info/licenses/LICENSE,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
+fxn-0.0.45.dist-info/METADATA,sha256=5g5H7YpEWWAkji5HLSLajTb4npfo6igzAbNp6GQWjH4,16144
+fxn-0.0.45.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+fxn-0.0.45.dist-info/entry_points.txt,sha256=O_AwD5dYaeB-YT1F9hPAPuDYCkw_W0tdNGYbc5RVR2k,45
+fxn-0.0.45.dist-info/top_level.txt,sha256=1ULIEGrnMlhId8nYAkjmRn9g3KEFuHKboq193SEKQkA,4
+fxn-0.0.45.dist-info/RECORD,,

{fxn-0.0.43.dist-info → fxn-0.0.45.dist-info}/WHEEL

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