def test_introspect_curry_py3():
if not PY3:
return
f = aiotoolz.curry(make_func(''))
assert num_required_args(f) == 0
assert is_arity(0, f)
assert has_varargs(f) is False
assert has_keywords(f) is False
f = aiotoolz.curry(make_func('x'))
assert num_required_args(f) == 0
assert is_arity(0, f) is False
assert is_arity(1, f) is False
assert has_varargs(f) is False
assert has_keywords(f) # A side-effect of being curried
f = aiotoolz.curry(make_func('x, y, z=0'))
assert num_required_args(f) == 0
assert is_arity(0, f) is False
assert is_arity(1, f) is False
assert is_arity(2, f) is False
assert is_arity(3, f) is False
assert has_varargs(f) is False
assert has_keywords(f)
f = aiotoolz.curry(make_func('*args, **kwargs'))
assert num_required_args(f) == 0
assert has_varargs(f)
assert has_keywords(f)
def test_EqualityHashKey_callable_key():
# Common simple hash key functions.
EqualityHashLen = curry(EqualityHashKey, len)
EqualityHashType = curry(EqualityHashKey, type)
EqualityHashId = curry(EqualityHashKey, id)
EqualityHashFirst = curry(EqualityHashKey, first)
data1 = [[], [1], (), (1, ), {}, {1: 2}]
data2 = [[1, 2], (1, 2), (1, 3), [1, 3], [2, 1], {1: 2}]
assert list(unique(data1 * 3, key=EqualityHashLen)) == data1
assert list(unique(data2 * 3, key=EqualityHashLen)) == data2
assert list(unique(data1 * 3, key=EqualityHashType)) == data1
assert list(unique(data2 * 3, key=EqualityHashType)) == data2
assert list(unique(data1 * 3, key=EqualityHashId)) == data1
assert list(unique(data2 * 3, key=EqualityHashId)) == data2
assert list(unique(data2 * 3, key=EqualityHashFirst)) == data2
def test_EqualityHashKey_default_key():
EqualityHashDefault = curry(EqualityHashKey, None)
L1 = [1]
L2 = [2]
data1 = [L1, L1, L2, [], [], [1], [2], {}, ()]
set1 = set(map(EqualityHashDefault, data1))
set2 = set(map(EqualityHashDefault, [[], [1], [2], {}, ()]))
assert set1 == set2
assert len(set1) == 5
# Test that ``EqualityHashDefault(item)`` is distinct from ``item``
T0 = ()
T1 = (1, )
data2 = list(map(EqualityHashDefault, [T0, T0, T1, T1, (), (1, )]))
data2.extend([T0, T1, (), (1, )])
set3 = set(data2)
assert set3 == {(), (1, ),
EqualityHashDefault(()),
EqualityHashDefault((1, ))}
assert len(set3) == 4
assert EqualityHashDefault(()) in set3
assert EqualityHashDefault((1, )) in set3
# Miscellaneous
E1 = EqualityHashDefault(L1)
E2 = EqualityHashDefault(L2)
assert str(E1) == '=[1]='
assert repr(E1) == '=[1]='
assert E1 != E2
assert not (E1 == E2)
assert E1 == EqualityHashDefault(L1)
assert not (E1 != EqualityHashDefault(L1))
assert E1 != L1
assert not (E1 == L1)
def test_EqualityHashKey_index_key():
d1 = {'firstname': 'Alice', 'age': 21, 'data': {}}
d2 = {'firstname': 'Alice', 'age': 34, 'data': {}}
d3a = {'firstname': 'Bob', 'age': 56, 'data': {}}
d3b = {'firstname': 'Bob', 'age': 56, 'data': {}}
EqualityHashFirstname = curry(EqualityHashKey, 'firstname')
assert list(unique(3 * [d1, d2, d3a, d3b],
key=EqualityHashFirstname)) == [d1, d2, d3a]
EqualityHashFirstnameAge = curry(EqualityHashKey, ['firstname', 'age'])
assert list(unique(3 * [d1, d2, d3a, d3b],
key=EqualityHashFirstnameAge)) == [d1, d2, d3a]
list1 = [0] * 10
list2 = [0] * 100
list3a = [1] * 10
list3b = [1] * 10
EqualityHash0 = curry(EqualityHashKey, 0)
assert list(unique(3 * [list1, list2, list3a, list3b],
key=EqualityHash0)) == [list1, list2, list3a]
def test_introspect_curry_valid_py3(check_valid=is_valid_args,
incomplete=False):
if not PY3:
return
orig_check_valid = check_valid
check_valid = lambda _func, *args, **kwargs: orig_check_valid(
_func, args, kwargs)
f = aiotoolz.curry(make_func('x, y, z=0'))
assert check_valid(f)
assert check_valid(f, 1)
assert check_valid(f, 1, 2)
assert check_valid(f, 1, 2, 3)
assert check_valid(f, 1, 2, 3, 4) is False
assert check_valid(f, invalid_keyword=True) is False
assert check_valid(f(1))
assert check_valid(f(1), 2)
assert check_valid(f(1), 2, 3)
assert check_valid(f(1), 2, 3, 4) is False
assert check_valid(f(1), x=2) is False
assert check_valid(f(1), y=2)
assert check_valid(f(x=1), 2) is False
assert check_valid(f(x=1), y=2)
assert check_valid(f(y=2), 1)
assert check_valid(f(y=2), 1, z=3)
assert check_valid(f(y=2), 1, 3) is False
f = aiotoolz.curry(make_func('x, y, z=0'), 1, x=1)
assert check_valid(f) is False
assert check_valid(f, z=3) is False
f = aiotoolz.curry(make_func('x, y, *args, z'))
assert check_valid(f)
assert check_valid(f, 0)
assert check_valid(f(1), 0)
assert check_valid(f(1, 2), 0)
assert check_valid(f(1, 2, 3), 0)
assert check_valid(f(1, 2, 3, 4), 0)
assert check_valid(f(1, 2, 3, 4), z=4)
assert check_valid(f(x=1))
assert check_valid(f(x=1), 1) is False
assert check_valid(f(x=1), y=2)
interleave,
isdistinct,
isiterable,
juxt,
last,
memoize,
merge_sorted,
peek,
pipe,
second,
thread_first,
thread_last,
)
from .exceptions import merge, merge_with
accumulate = aiotoolz.curry(aiotoolz.accumulate)
assoc = aiotoolz.curry(aiotoolz.assoc)
assoc_in = aiotoolz.curry(aiotoolz.assoc_in)
cons = aiotoolz.curry(aiotoolz.cons)
countby = aiotoolz.curry(aiotoolz.countby)
do = aiotoolz.curry(aiotoolz.do)
drop = aiotoolz.curry(aiotoolz.drop)
excepts = aiotoolz.curry(aiotoolz.excepts)
filter = aiotoolz.curry(aiotoolz.filter)
get = aiotoolz.curry(aiotoolz.get)
get_in = aiotoolz.curry(aiotoolz.get_in)
groupby = aiotoolz.curry(aiotoolz.groupby)
interpose = aiotoolz.curry(aiotoolz.interpose)
itemfilter = aiotoolz.curry(aiotoolz.itemfilter)
itemmap = aiotoolz.curry(aiotoolz.itemmap)
iterate = aiotoolz.curry(aiotoolz.iterate)