Environment.usenumba module

Import numba.jit or a dummy decorator.

Environment.usenumba.USE_NUMBA = True

Configure the use of numba

Environment.usenumba.jit(signature_or_function=None, locals={}, target='cpu', cache=False, pipeline_class=None, **options)[source]

This decorator is used to compile a Python function into native code.


The (optional) signature or list of signatures to be compiled. If not passed, required signatures will be compiled when the decorated function is called, depending on the argument values. As a convenience, you can directly pass the function to be compiled instead.

locals: dict

Mapping of local variable names to Numba types. Used to override the types deduced by Numba’s type inference engine.

target: str

Specifies the target platform to compile for. Valid targets are cpu, gpu, npyufunc, and cuda. Defaults to cpu.

pipeline_class: type numba.compiler.CompilerBase

The compiler pipeline type for customizing the compilation stages.

For a cpu target, valid options are:
nopython: bool

Set to True to disable the use of PyObjects and Python API calls. The default behavior is to allow the use of PyObjects and Python API. Default value is False.

forceobj: bool

Set to True to force the use of PyObjects for every value. Default value is False.

looplift: bool

Set to True to enable jitting loops in nopython mode while leaving surrounding code in object mode. This allows functions to allocate NumPy arrays and use Python objects, while the tight loops in the function can still be compiled in nopython mode. Any arrays that the tight loop uses should be created before the loop is entered. Default value is True.

error_model: str

The error-model affects divide-by-zero behavior. Valid values are ‘python’ and ‘numpy’. The ‘python’ model raises exception. The ‘numpy’ model sets the result to +/-inf or nan. Default value is ‘python’.

inline: str or callable

The inline option will determine whether a function is inlined at into its caller if called. String options are ‘never’ (default) which will never inline, and ‘always’, which will always inline. If a callable is provided it will be called with the call expression node that is requesting inlining, the caller’s IR and callee’s IR as arguments, it is expected to return Truthy as to whether to inline. NOTE: This inlining is performed at the Numba IR level and is in no way related to LLVM inlining.

A callable usable as a compiled function. Actual compiling will be done lazily if no explicit signatures are passed.

The function can be used in the following ways:

  1. jit(signatures, target=’cpu’, **targetoptions) -> jit(function)

    Equivalent to:

    d = dispatcher(function, targetoptions) for signature in signatures:


    Create a dispatcher object for a python function. Then, compile the function with the given signature(s).


    @jit(“int32(int32, int32)”) def foo(x, y):

    return x + y

    @jit([“int32(int32, int32)”, “float32(float32, float32)”]) def bar(x, y):

    return x + y

  2. jit(function, target=’cpu’, **targetoptions) -> dispatcher

    Create a dispatcher function object that specializes at call site.


    @jit def foo(x, y):

    return x + y

    @jit(target=’cpu’, nopython=True) def bar(x, y):

    return x + y