Defining your Function

Function supports compiling a tiny-but-growing subset of Python language constructs. Below are requirements and guidelines for compiling a Python function with Function:

Function Signature

The prediction function must be a module-level function, and must have parameter and return type annotations:

from fxn import compile

@compile(...)
def greeting (name: str) -> str:
    return f"Hello {name}"

The prediction function must not have any variable-length positional or keyword arguments.

Function supports a fixed set of predictor input and output value types. Below are supported type annotations:

Floating Point Values

Floating-point input and return values should be annotated with the float built-in type.

from fxn import compile

@compile(...)
def square (number: float) -> float:
    return number ** 2

Unlike Python which defaults to 64-bit floats, Function will always lower a Python float to 32 bits.

For control over the binary width of the number, use the numpy.float[16,32,64] types:

from fxn import compile
import numpy as np

@compile(...)
def square (number: np.float64) -> float64:
    return number ** 2

Integer Values

Integer input and return values should be annotated with the int built-in type.

from fxn import compile

@compile(...)
def square (number: int) -> int:
    return number ** 2

Unlike Python which supports arbitrary-precision integers, Function will always lower a Python int to 32 bits.

For control over the binary width of the integer, use the numpy.int[8,16,32,64] types:

from fxn import compile
import numpy as np

@compile(...)
def square (number: np.int16) -> np.int16:
    return number ** 2

Boolean Values

Tensor Values

Tensor input and return values must be annotated with the NumPy numpy.typing.NDArray[T] type, where T is the tensor element type.

from fxn import compile
import numpy as np
from numpy.typing import NDArray

@compile(...)
def cholesky_decompose (tensor: NDArray[np.float64]) -> np.ndarray:
    return np.linalg.cholesky(tensor).astype("float32")

You can also annotate with the np.ndarray type, but doing so will always assume a float32 element type (following PyTorch semantics).

Below are the supported element types:

Numpy data type	Function data type
`np.float16`	`float16`
`np.float32`	`float32`
`np.float64`	`float64`
`np.int8`	`int8`
`np.int16`	`int16`
`np.int32`	`int32`
`np.int64`	`int64`
`np.uint8`	`uint8`
`np.uint16`	`uint16`
`np.uint32`	`uint32`
`np.uint64`	`uint64`
`bool`	`bool`

Function does not yet support complex numbers or tensors.

Function only supports, and will always assume, little-endian ordering for multi-byte element types.

String Values

List Values

List input and return values must be annotated with the list[T] built-in type, where T is the element type.

from fxn import compile

@compile(...)
def slice (items: list[str]) -> list[str]:
    return items[:3]

When the list element type T is a Pydantic BaseModel, a full JSON schema will be generated.

Providing an element type T is optional but strongly recommended because it is used to generate a schema for the parameter or return value.

Dictionary Values

Dictionary input and return values can be annotated in one of two ways:

Using a Pydantic BaseModel subclass.
Using the dict[str, T] built-in type.

from fxn import compile
from pydantic import BaseModel
from typing import Literal

class Person (BaseModel):
    city: str
    age: int

class Pet (BaseModel):
    sound: Literal["bark", "meow"]
    legs: int

@compile(...)
def choose_favorite_pet (person: Person) -> Pet:
    return Pet(sound="meow", legs=6)

We strongly recommend the Pydantic BaseModel annotation, as it allows us to generate a full JSON schema.

When using the dict annotation, they key type must be str. The value type T can be any arbitrary type.

Image Values

Image input and return values must be annotated with the Pillow PIL.Image.Image type.

from fxn import compile
from PIL import Image

@compile(...)
def resize (image: Image.Image) -> Image.Image:
    return image.resize((512, 512))

Binary Values

Binary input and return values can be annotated in one of three ways:

Using the bytes built-in type.
Using the bytearray built-in type.
Using the io.BytesIO type.

from fxn import compile
from PIL import Image

def resize_pixels (pixels: bytes) -> bytes
    return Image.frombytes("L", (4,4), pixels).resize((8,8)).tobytes()

Function Body

The function body can contain arbitrary Python code. Given that the Function compiler is currently a proof of concept, it has limited coverage. Below is a list of Python language features that we either partially support, or do not support at all:

Functions

Statement	Status	Notes
Recursive functions	🔨	Recursive functions must have a return type annotation.
Lambda expressions	🚧	Lambda expressions can be invoked, but cannot be used as objects.

Literals

Collection	Status	Notes
List literals	🔨	List must contain primitive members (e.g. `int`, `str`).
Dictionary literals	🔨	Dictionary must contain primitive members (e.g. `int`, `str`).
Set literals	🔨	Set must contain primitive members (e.g. `int`, `str`).
Tuple literals	🔨	Tuple must contain primitive members (e.g. `int`, `str`).

Classes

Exceptions

Statement	Status	Notes
`raise` statements	🔨
`try..except` statement	🔨

Over time the list of unsupported language features will shrink and eventually, will be empty.

Library Coverage

We are adding support for popular libraries, across tensor frameworks, scientific computing, and more:

Supported Libraries

If you need a specific library to be supported by the Function compiler, reach out to us.

Get Started

Making Predictions

Creating Predictors

Insiders

Function Signature

Function Body

Library Coverage

Get Started

Making Predictions

Creating Predictors

Insiders

​Function Signature

​Function Body

​Library Coverage

Function Signature

Function Body

Library Coverage