def test_global(nullary_mm):
obj = object()
be = Backend()
be.__ua_function__ = lambda f, a, kw: obj
ua.set_global_backend(be)
assert nullary_mm() is obj
def test_global(cleanup_backends):
obj = object()
be = Backend()
be.__ua_function__ = lambda f, a, kw: obj
mm = ua.generate_multimethod(lambda: (), lambda a, kw, d: (a, kw),
"ua_tests")
ua.set_global_backend(be)
assert mm() is obj
def test_pickle_state():
ua.set_global_backend(ComparableBackend("a"))
ua.register_backend(ComparableBackend("b"))
with ua.set_backend(ComparableBackend("c")), ua.skip_backend(
ComparableBackend("d")):
state = ua.get_state()
state_loaded = pickle.loads(pickle.dumps(state))
assert state._pickle() == state_loaded._pickle()
def test_global_try_last(nullary_mm):
obj = object()
obj2 = object()
be = Backend()
be.__ua_function__ = lambda f, a, kw: obj
be2 = Backend()
be2.__ua_function__ = lambda f, a, kw: obj2
ua.set_global_backend(be, try_last=True)
ua.register_backend(be2)
assert nullary_mm() is obj2
def test_global_before_registered(cleanup_backends, nullary_mm):
obj = object()
obj2 = object()
be = Backend()
be.__ua_function__ = lambda f, a, kw: obj
be2 = Backend()
be2.__ua_function__ = lambda f, a, kw: obj2
ua.set_global_backend(be)
ua.register_backend(be2)
assert nullary_mm() is obj
def ctx_before_global(nullary_mm):
obj = object()
obj2 = object()
be = Backend()
be.__ua_function__ = lambda f, a, kw: obj
be2 = Backend()
be2.__ua_function__ = lambda f, a, kw: obj2
ua.set_global_backend(be)
with ua.set_backend(be2):
assert nullary_mm() is obj2
def test_getset_state(cleanup_backends):
ua.set_global_backend(Backend())
ua.register_backend(Backend())
with ua.set_backend(Backend()), ua.skip_backend(Backend()):
state = ua.get_state()
pstate = state._pickle()
assert pstate != ua.get_state()._pickle()
with ua.set_state(state):
assert pstate[:2] == ua.get_state()._pickle()[:2]
def test_global_only(nullary_mm):
obj = object()
be = Backend()
be.__ua_function__ = lambda f, a, kw: NotImplemented
be2 = Backend()
be2.__ua_function__ = lambda f, a, kw: obj
ua.set_global_backend(be, only=True)
ua.register_backend(be2)
with pytest.raises(ua.BackendNotImplementedError):
nullary_mm()
def test_global_before_registered(cleanup_backends):
obj = object()
obj2 = object()
be = Backend()
be.__ua_function__ = lambda f, a, kw: obj
be2 = Backend()
be2.__ua_function__ = lambda f, a, kw: obj2
mm = ua.generate_multimethod(lambda: (), lambda a, kw, d: (a, kw),
"ua_tests")
ua.set_global_backend(be)
ua.register_backend(be2)
assert mm() is obj
def test_clear_backends(nullary_mm):
obj = object()
obj2 = object()
be = Backend()
be.__ua_function__ = lambda f, a, kw: obj
be2 = Backend()
be2.__ua_function__ = lambda f, a, kw: obj2
ua.set_global_backend(be)
ua.register_backend(be2)
ua.clear_backends(Backend.__ua_domain__, registered=True, globals=True)
with pytest.raises(ua.BackendNotImplementedError):
nullary_mm()
def test_global_only(cleanup_backends):
obj = object()
be = Backend()
be.__ua_function__ = lambda f, a, kw: NotImplemented
be2 = Backend()
be2.__ua_function__ = lambda f, a, kw: obj
mm = ua.generate_multimethod(lambda: (), lambda a, kw, d: (a, kw),
"ua_tests")
ua.set_global_backend(be, only=True)
ua.register_backend(be2)
with pytest.raises(ua.BackendNotImplementedError):
mm()
def test_clear_backends(cleanup_backends):
obj = object()
obj2 = object()
be = Backend()
be.__ua_function__ = lambda f, a, kw: obj
be2 = Backend()
be2.__ua_function__ = lambda f, a, kw: obj2
mm = ua.generate_multimethod(lambda: (), lambda a, kw, d: (a, kw),
"ua_tests")
ua.set_global_backend(be)
ua.register_backend(be2)
ua.clear_backends(Backend.__ua_domain__, registered=True, globals=True)
with pytest.raises(ua.BackendNotImplementedError):
mm()
def test_multidomain_backends():
n_domains = 2
be = DisableBackend(domain=["ua_tests" + str(i) for i in range(n_domains)])
mms = [
ua.generate_multimethod(lambda: (), lambda a, kw, d: (a, kw),
"ua_tests" + str(i)) for i in range(n_domains)
]
def assert_no_backends():
for i in range(len(mms)):
with pytest.raises(ua.BackendNotImplementedError):
mms[i]()
def assert_backend_active(backend):
assert all(mms[i]() is backend.ret for i in range(len(mms)))
assert_no_backends()
with ua.set_backend(be):
assert_backend_active(be)
ua.set_global_backend(be)
assert_backend_active(be)
with ua.skip_backend(be):
assert_no_backends()
assert_backend_active(be)
for i in range(len(mms)):
ua.clear_backends(mms[i].domain, globals=True)
with pytest.raises(ua.BackendNotImplementedError):
mms[i]()
for j in range(i + 1, len(mms)):
assert mms[j]() is be.ret
assert_no_backends()
ua.register_backend(be)
assert_backend_active(be)
def test_hierarchical_backends():
mm = ua.generate_multimethod(lambda: (), lambda a, kw, d: (a, kw),
"ua_tests.foo.bar")
subdomains = "ua_tests.foo.bar".split(".")
depth = len(subdomains)
mms = [
ua.generate_multimethod(lambda: (), lambda a, kw, d: (a, kw),
".".join(subdomains[:i + 1]))
for i in range(depth)
]
be = [DisableBackend(".".join(subdomains[:i + 1])) for i in range(depth)]
ua.set_global_backend(be[1])
with pytest.raises(ua.BackendNotImplementedError):
mms[0]()
for i in range(1, depth):
assert mms[i]() is be[1].ret
ua.set_global_backend(be[0])
for i in range(depth):
assert mms[i]() is be[min(i, 1)].ret
ua.set_global_backend(be[2])
for i in range(depth):
assert mms[i]() is be[i].ret
be[2].active = False
for i in range(depth):
print(i)
assert mms[i]() is be[min(i, 1)].ret
be[1].active = False
for i in range(depth):
assert mms[i]() is be[0].ret
be[0].active = False
for i in range(depth):
with pytest.raises(ua.BackendNotImplementedError):
mms[i]()
# only=True prevents all further domain checking
be[0].active = True
be[1].active = True
with ua.set_backend(be[2], only=True), pytest.raises(
ua.BackendNotImplementedError):
mms[2]()
import udiff
import sparse
from math import *
from random import uniform, randrange
import unumpy.numpy_backend as NumpyBackend
import unumpy.torch_backend as TorchBackend
import unumpy.dask_backend as DaskBackend
import unumpy.sparse_backend as SparseBackend
import numpy as onp
from numpy.testing import assert_allclose
import pytest
ua.set_global_backend(NumpyBackend)
LIST_BACKENDS = [
NumpyBackend,
# DaskBackend,
# SparseBackend,
pytest.param(
TorchBackend,
marks=pytest.mark.xfail(reason="PyTorch not fully NumPy compatible."),
),
]
FULLY_TESTED_BACKENDS = [NumpyBackend, DaskBackend]
try:
import unumpy.cupy_backend as CupyBackend
