Package: array-api-strict
array-api-strictarray_api_strictis a strict, minimal implementation of thePython array
APIThe purpose of array-api-strict is to provide an implementation of the array
API for consuming libraries to test against so they can be completely sure
their usage of the array API is portable.It isnotintended to be used by end-users. End-users of the array API
should just use their favorite array library (NumPy, CuPy, PyTorch, etc.) as
usual. It is also not intended to be used as a dependency by consuming
libraries. Consuming library code should use thearray-api-compatpackage to
support the array API. Rather, it is intended to be used in the test suites of
consuming libraries to test their array API usage.Installarray-api-strictis available on bothPyPIpython -m pip install array-api-strictandConda-forgeconda install --channel conda-forge array-api-strictarray-api-strict supports NumPy 1.26 and (the upcoming) NumPy 2.0.RationaleThe array API has many functions and behaviors that are required to be
implemented by conforming libraries, but it does not, in most cases, disallow
implementing additional functions, keyword arguments, and behaviors that
aren't explicitly required by the standard.However, this poses a problem for consumers of the array API, as they may
accidentally use a function or rely on a behavior which just happens to be
implemented in every array library they test against (e.g., NumPy and
PyTorch), but isn't required by the standard and may not be included in other
libraries.array-api-strict solves this problem by providing a strict, minimal
implementation of the array API standard. Only those functions and behaviors
that are explicitlyrequiredby the standard are implemented. For example,
most NumPy functions accept Python scalars as inputs:>>>importnumpyasnp>>>np.sin(0.0)0.0However, the standard only specifies function inputs onArrayobjects. And
indeed, some libraries, such as PyTorch, do not allow this:>>>importtorch>>>torch.sin(0.0)Traceback(mostrecentcalllast):File"<stdin>",line1,in<module>TypeError:sin():argument'input'(position1)mustbeTensor,notfloatIn array-api-strict, this is also an error:>>>importarray_api_strictasxp>>>xp.sin(0.0)Traceback(mostrecentcalllast):...AttributeError:'float'objecthasnoattribute'dtype'Here is an (incomplete) list of the sorts of ways that array-api-strict is
strict/minimal:Only those functions and methods that aredefined in the
standardare included.In those functions, only the keyword-arguments that are defined by the
standard are included. All signatures in array-api-strict usepositional-only
arguments.
As noted above, onlyarray_api_strictarray objects are accepted by
functions, except in the places where the standard allows Python scalars
(i.e., functions do not automatically callasarrayon their inputs).Only thosedtypes that are defined in the
standardare included.All functions and methods reject inputs if the standard does notrequirethe input dtype(s) to be supported. This is one of the most restrictive
aspects of the library. For example, in NumPy, most transcendental functions
likesinwill accept integer array inputs, but thestandard only requires
them to accept floating-point
inputs,
so in array-api-strict,sin(integer_array)will raise an exception.Theindexingsemantics required by the standard are limited compared to those implemented
by NumPy (e.g., out-of-bounds slices are not supported, integer array
indexing is not supported, only a single boolean array index is supported).There are no distinct "scalar" objects as in NumPy. There are only 0-D
arrays.Dtype objects are just empty objects that only implementequality
comparison.
The way to access dtype objects in the standard is by name, likexp.float32.The array object type itself is private and should not be accessed.
Subclassing or otherwise trying to directly initialize this object is not
supported. Arrays should be created with one of thearray creation
functionssuch asasarray.Caveatsarray-api-strict is a thin pure Python wrapper around NumPy. NumPy 2.0 fully
supports the array API but NumPy 1.26 does not, so many behaviors are wrapped
in NumPy 1.26 to provide array API compatible behavior. Although it is based
on NumPy, mixing NumPy arrays with array-api-strict arrays is not supported.
This should generally raise an error, as it indicates a potential portability
issue, but this hasn't necessarily been tested thoroughly.array-api-strict is validated against thearray API test
suite. However, there may be
a few minor instances where NumPy deviates from the standard in a way that
is inconvenient to workaround in array-api-strict, since it aims to remain
pure Python. You can see the full list of tests that are known to fail in
thexfails
file.The most notable of these is that in NumPy 1.26, thecopy=Falseflag is
not implemented forasarrayand thereforearray_api_strictraisesNotImplementedErrorin that case.Since NumPy is a CPU-only library, thedevice
supportin array-api-strict is superficial only.x.deviceis always a (private)CPU_DEVICEobject, anddevicekeywords to creation functions only
accept either this object orNone. A future version of array-api-strictmay add support for a CuPy
backendso that
more significant device support can be tested.Although only array types are expected in array-api-strict functions,
currently most functions do not do extensive type checking on their inputs,
so a sufficiently duck-typed object may pass through silently (or at best,
you may getAttributeErrorinstead ofTypeError). However, all type
signatures have type annotations (based on those from the standard), so
this deviation may be tested with type checking. Thisbehavior may improve
in the future.There are some behaviors in the standard that are not required to be
implemented by libraries that cannot supportdata dependent
shapes.
This includestheunique_*functions,boolean array
indexing,
and thenonzerofunction. array-api-strict currently implements all of these. In the
future,there may be a way to disable them.array-api-strict currently only supports the latest version of the array
API standard.This may change in the future depending on
need.UsageTODO: Add a sample CI script here.Relationship tonumpy.array_apiPreviously this implementation was available asnumpy.array_api, but it was
moved to a separate package for NumPy 2.0.Note that the history of this repo prior to commit
fbefd42e4d11e9be20e0a4785f2619fc1aef1e7c was generated automatically
from the numpy git history, using the followinggit-filter-repocommand:git_filter_repo.py --path numpy/array_api/ --path-rename numpy/array_api:array_api_strict --replace-text <(echo -e "numpy.array_api==>array_api_strict\nfrom ..core==>from numpy.core\nfrom .._core==>from numpy._core\nfrom ..linalg==>from numpy.linalg\nfrom numpy import array_api==>import array_api_strict") --commit-callback 'commit.message = commit.message.rstrip() + b"\n\nOriginal NumPy Commit: " + commit.original_id'