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 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 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

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.

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 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 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 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 highly limited coverage. We measure our compiler’s coverage across two dimensions:

Language Coverage

Because Function is designed to cover the full Python language, we keep a list of Python language features that we currently do not support, or only partially support:

Statement	Status	Notes
Recursive functions	🔨	Recursive functions must have a return type annotation.
Generator functions	🔨
Lambda functions	❌	Local lambda functions do not retain annotations at runtime.

Expression	Status	Notes
`if` statement	🔨
`match` statement	🔨	Implicitly supported when `if` statement is supported.

Expression	Status	Notes
`for` loops	🔨
`while` loops	🔨

Collection	Status	Notes
List literals	🔨
Dictionary literals	🔨
Set literals	🔨
Tuple literals	🔨

Expression	Status	Notes
List comprehension	🔨
Dictionary comprehension	🔨
Set comprehension	🔨

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

While supporting all Python libraries in the wild is wildly untractable, Function is focused specifically on compute-intensive prediction functions. As such, we mainly plan coverage for a handful of tensor and scientific computing libraries:

Library	Status	Notes
`numpy`	🔨
`Pillow`	🔨
`torch`	🔨	Only `torch.Tensor` and `torch.nn.functional` API.
`torchvision`	🔨	Only `torchvision.transforms` API.

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

Try it Out

We currently don’t have a definitive list of what’s supported and what’s not, so the best way to know is to simply try it out 😉

Compiler Playground

Compile a Python function and run it cross-platform.

Function Community

Come scream at us on Discord when something breaks.

Get Started

Making Predictions

Creating Predictors

Insiders

Function Signature

Function Body

Language Coverage

Library Coverage

Try it Out

Compiler Playground

Function Community

Get Started

Making Predictions

Creating Predictors

Insiders

​Function Signature

​Function Body

​Language Coverage

​Library Coverage

​Try it Out

Compiler Playground

Function Community

Function Signature

Function Body

Language Coverage

Library Coverage

Try it Out