alpcentaur
/
basabuuka_prototyp
1
0
Fork 0
Code Issues 0 Pull Requests 0 Projects 0 Releases 0 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
10 Commits
1 Branch
4.1 GiB
 
 
 
 
 
 
Tree: 9ed0e1f6e7
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '9ed0e1f6e7'
${ noResults }
basabuuka_prototyp/venv/lib/python3.5/site-packages/cytoolz/itertoolz.pyx

1779 lines
49 KiB
Raw Blame History

from cpython.dict cimport PyDict_GetItem, PyDict_SetItem
from cpython.exc cimport PyErr_Clear, PyErr_GivenExceptionMatches, PyErr_Occurred
from cpython.list cimport PyList_Append, PyList_GET_ITEM, PyList_GET_SIZE
from cpython.object cimport PyObject_RichCompareBool, Py_NE
from cpython.ref cimport PyObject, Py_INCREF, Py_XDECREF
from cpython.sequence cimport PySequence_Check
from cpython.set cimport PySet_Add, PySet_Contains
from cpython.tuple cimport PyTuple_GET_ITEM, PyTuple_GetSlice, PyTuple_New, PyTuple_SET_ITEM
# Locally defined bindings that differ from `cython.cpython` bindings
from cytoolz.cpython cimport PtrIter_Next, PtrObject_GetItem
from collections import deque
from heapq import heapify, heappop, heapreplace
from itertools import chain, islice
from operator import itemgetter
from random import Random
from cytoolz.compatibility import map, zip, zip_longest
from cytoolz.utils import no_default
__all__ = ['remove', 'accumulate', 'groupby', 'merge_sorted', 'interleave',
'unique', 'isiterable', 'isdistinct', 'take', 'drop', 'take_nth',
'first', 'second', 'nth', 'last', 'get', 'concat', 'concatv',
'mapcat', 'cons', 'interpose', 'frequencies', 'reduceby', 'iterate',
'sliding_window', 'partition', 'partition_all', 'count', 'pluck',
'join', 'tail', 'diff', 'topk', 'peek', 'random_sample']
cpdef object identity(object x):
return x
cdef class remove:
""" remove(predicate, seq)
Return those items of sequence for which predicate(item) is False
>>> def iseven(x):
... return x % 2 == 0
>>> list(remove(iseven, [1, 2, 3, 4]))
[1, 3]
"""
def __cinit__(self, object predicate, object seq):
self.predicate = predicate
self.iter_seq = iter(seq)
def __iter__(self):
return self
def __next__(self):
cdef object val
val = next(self.iter_seq)
while self.predicate(val):
val = next(self.iter_seq)
return val
cdef class accumulate:
""" accumulate(binop, seq, initial='__no__default__')
Repeatedly apply binary function to a sequence, accumulating results
>>> from operator import add, mul
>>> list(accumulate(add, [1, 2, 3, 4, 5]))
[1, 3, 6, 10, 15]
>>> list(accumulate(mul, [1, 2, 3, 4, 5]))
[1, 2, 6, 24, 120]
Accumulate is similar to ``reduce`` and is good for making functions like
cumulative sum:
>>> from functools import partial, reduce
>>> sum = partial(reduce, add)
>>> cumsum = partial(accumulate, add)
Accumulate also takes an optional argument that will be used as the first
value. This is similar to reduce.
>>> list(accumulate(add, [1, 2, 3], -1))
[-1, 0, 2, 5]
>>> list(accumulate(add, [], 1))
[1]
See Also:
itertools.accumulate : In standard itertools for Python 3.2+
"""
def __cinit__(self, object binop, object seq, object initial='__no__default__'):
self.binop = binop
self.iter_seq = iter(seq)
self.result = self # sentinel
self.initial = initial
def __iter__(self):
return self
def __next__(self):
if self.result is self:
if self.initial != no_default:
self.result = self.initial
else:
self.result = next(self.iter_seq)
else:
self.result = self.binop(self.result, next(self.iter_seq))
return self.result
cdef inline object _groupby_core(dict d, object key, object item):
cdef PyObject *obj = PyDict_GetItem(d, key)
if obj is NULL:
val = []
PyList_Append(val, item)
PyDict_SetItem(d, key, val)
else:
PyList_Append(<object>obj, item)
cpdef dict groupby(object key, object seq):
"""
Group a collection by a key function
>>> names = ['Alice', 'Bob', 'Charlie', 'Dan', 'Edith', 'Frank']
>>> groupby(len, names) # doctest: +SKIP
{3: ['Bob', 'Dan'], 5: ['Alice', 'Edith', 'Frank'], 7: ['Charlie']}
>>> iseven = lambda x: x % 2 == 0
>>> groupby(iseven, [1, 2, 3, 4, 5, 6, 7, 8]) # doctest: +SKIP
{False: [1, 3, 5, 7], True: [2, 4, 6, 8]}
Non-callable keys imply grouping on a member.
>>> groupby('gender', [{'name': 'Alice', 'gender': 'F'},
... {'name': 'Bob', 'gender': 'M'},
... {'name': 'Charlie', 'gender': 'M'}]) # doctest:+SKIP
{'F': [{'gender': 'F', 'name': 'Alice'}],
'M': [{'gender': 'M', 'name': 'Bob'},
{'gender': 'M', 'name': 'Charlie'}]}
See Also:
countby
"""
cdef dict d = {}
cdef object item, keyval
cdef Py_ssize_t i, N
if callable(key):
for item in seq:
keyval = key(item)
_groupby_core(d, keyval, item)
elif isinstance(key, list):
N = PyList_GET_SIZE(key)
for item in seq:
keyval = PyTuple_New(N)
for i in range(N):
val = <object>PyList_GET_ITEM(key, i)
val = item[val]
Py_INCREF(val)
PyTuple_SET_ITEM(keyval, i, val)
_groupby_core(d, keyval, item)
else:
for item in seq:
keyval = item[key]
_groupby_core(d, keyval, item)
return d
cdef object _merge_sorted_binary(object seqs):
mid = len(seqs) // 2
L1 = seqs[:mid]
if len(L1) == 1:
seq1 = iter(L1[0])
else:
seq1 = _merge_sorted_binary(L1)
L2 = seqs[mid:]
if len(L2) == 1:
seq2 = iter(L2[0])
else:
seq2 = _merge_sorted_binary(L2)
try:
val2 = next(seq2)
except StopIteration:
return seq1
return _merge_sorted(seq1, seq2, val2)
cdef class _merge_sorted:
def __cinit__(self, seq1, seq2, val2):
self.seq1 = seq1
self.seq2 = seq2
self.val1 = None
self.val2 = val2
self.loop = 0
def __iter__(self):
return self
def __next__(self):
if self.loop == 0:
try:
self.val1 = next(self.seq1)
except StopIteration:
self.loop = 2
return self.val2
if self.val2 < self.val1:
self.loop = 1
return self.val2
return self.val1
elif self.loop == 1:
try:
self.val2 = next(self.seq2)
except StopIteration:
self.loop = 3
return self.val1
if self.val2 < self.val1:
return self.val2
self.loop = 0
return self.val1
elif self.loop == 2:
return next(self.seq2)
return next(self.seq1)
cdef object _merge_sorted_binary_key(object seqs, object key):
mid = len(seqs) // 2
L1 = seqs[:mid]
if len(L1) == 1:
seq1 = iter(L1[0])
else:
seq1 = _merge_sorted_binary_key(L1, key)
L2 = seqs[mid:]
if len(L2) == 1:
seq2 = iter(L2[0])
else:
seq2 = _merge_sorted_binary_key(L2, key)
try:
val2 = next(seq2)
except StopIteration:
return seq1
return _merge_sorted_key(seq1, seq2, val2, key)
cdef class _merge_sorted_key:
def __cinit__(self, seq1, seq2, val2, key):
self.seq1 = seq1
self.seq2 = seq2
self.key = key
self.val1 = None
self.key1 = None
self.val2 = val2
self.key2 = key(val2)
self.loop = 0
def __iter__(self):
return self
def __next__(self):
if self.loop == 0:
try:
self.val1 = next(self.seq1)
except StopIteration:
self.loop = 2
return self.val2
self.key1 = self.key(self.val1)
if self.key2 < self.key1:
self.loop = 1
return self.val2
return self.val1
elif self.loop == 1:
try:
self.val2 = next(self.seq2)
except StopIteration:
self.loop = 3
return self.val1
self.key2 = self.key(self.val2)
if self.key2 < self.key1:
return self.val2
self.loop = 0
return self.val1
elif self.loop == 2:
return next(self.seq2)
return next(self.seq1)
cdef object c_merge_sorted(object seqs, object key=None):
if len(seqs) == 0:
return iter([])
elif len(seqs) == 1:
return iter(seqs[0])
elif key is None:
return _merge_sorted_binary(seqs)
return _merge_sorted_binary_key(seqs, key)
def merge_sorted(*seqs, **kwargs):
"""
Merge and sort a collection of sorted collections
This works lazily and only keeps one value from each iterable in memory.
>>> list(merge_sorted([1, 3, 5], [2, 4, 6]))
[1, 2, 3, 4, 5, 6]
>>> ''.join(merge_sorted('abc', 'abc', 'abc'))
'aaabbbccc'
The "key" function used to sort the input may be passed as a keyword.
>>> list(merge_sorted([2, 3], [1, 3], key=lambda x: x // 3))
[2, 1, 3, 3]
"""
if 'key' in kwargs:
return c_merge_sorted(seqs, kwargs['key'])
return c_merge_sorted(seqs)
cdef class interleave:
""" interleave(seqs)
Interleave a sequence of sequences
>>> list(interleave([[1, 2], [3, 4]]))
[1, 3, 2, 4]
>>> ''.join(interleave(('ABC', 'XY')))
'AXBYC'
Both the individual sequences and the sequence of sequences may be infinite
Returns a lazy iterator
"""
def __cinit__(self, seqs):
self.iters = [iter(seq) for seq in seqs]
self.newiters = []
self.i = 0
self.n = PyList_GET_SIZE(self.iters)
def __iter__(self):
return self
def __next__(self):
# This implementation is similar to what is done in `toolz` in that we
# construct a new list of iterators, `self.newiters`, when a value is
# successfully retrieved from an iterator from `self.iters`.
cdef PyObject *obj
cdef object val
if self.i == self.n:
self.n = PyList_GET_SIZE(self.newiters)
self.i = 0
if self.n == 0:
raise StopIteration
self.iters = self.newiters
self.newiters = []
val = <object>PyList_GET_ITEM(self.iters, self.i)
self.i += 1
obj = PtrIter_Next(val)
# TODO: optimization opportunity. Previously, it was possible to
# continue on given exceptions, `self.pass_exceptions`, which is
# why this code is structured this way. Time to clean up?
while obj is NULL:
obj = PyErr_Occurred()
if obj is not NULL:
val = <object>obj
PyErr_Clear()
raise val
if self.i == self.n:
self.n = PyList_GET_SIZE(self.newiters)
self.i = 0
if self.n == 0:
raise StopIteration
self.iters = self.newiters
self.newiters = []
val = <object>PyList_GET_ITEM(self.iters, self.i)
self.i += 1
obj = PtrIter_Next(val)
PyList_Append(self.newiters, val)
val = <object>obj
Py_XDECREF(obj)
return val
cdef class _unique_key:
def __cinit__(self, object seq, object key):
self.iter_seq = iter(seq)
self.key = key
self.seen = set()
def __iter__(self):
return self
def __next__(self):
cdef object item, tag
item = next(self.iter_seq)
tag = self.key(item)
while PySet_Contains(self.seen, tag):
item = next(self.iter_seq)
tag = self.key(item)
PySet_Add(self.seen, tag)
return item
cdef class _unique_identity:
def __cinit__(self, object seq):
self.iter_seq = iter(seq)
self.seen = set()
def __iter__(self):
return self
def __next__(self):
cdef object item
item = next(self.iter_seq)
while PySet_Contains(self.seen, item):
item = next(self.iter_seq)
PySet_Add(self.seen, item)
return item
cpdef object unique(object seq, object key=None):
"""
Return only unique elements of a sequence
>>> tuple(unique((1, 2, 3)))
(1, 2, 3)
>>> tuple(unique((1, 2, 1, 3)))
(1, 2, 3)
Uniqueness can be defined by key keyword
>>> tuple(unique(['cat', 'mouse', 'dog', 'hen'], key=len))
('cat', 'mouse')
"""
if key is None:
return _unique_identity(seq)
else:
return _unique_key(seq, key)
cpdef object isiterable(object x):
"""
Is x iterable?
>>> isiterable([1, 2, 3])
True
>>> isiterable('abc')
True
>>> isiterable(5)
False
"""
try:
iter(x)
return True
except TypeError:
pass
return False
cpdef object isdistinct(object seq):
"""
All values in sequence are distinct
>>> isdistinct([1, 2, 3])
True
>>> isdistinct([1, 2, 1])
False
>>> isdistinct("Hello")
False
>>> isdistinct("World")
True
"""
if iter(seq) is seq:
seen = set()
for item in seq:
if PySet_Contains(seen, item):
return False
seen.add(item)
return True
else:
return len(seq) == len(set(seq))
cpdef object take(Py_ssize_t n, object seq):
"""
The first n elements of a sequence
>>> list(take(2, [10, 20, 30, 40, 50]))
[10, 20]
See Also:
drop
tail
"""
return islice(seq, n)
cpdef object tail(Py_ssize_t n, object seq):
"""
The last n elements of a sequence
>>> tail(2, [10, 20, 30, 40, 50])
[40, 50]
See Also:
drop
take
"""
if PySequence_Check(seq):
return seq[-n:]
return tuple(deque(seq, n))
cpdef object drop(Py_ssize_t n, object seq):
"""
The sequence following the first n elements
>>> list(drop(2, [10, 20, 30, 40, 50]))
[30, 40, 50]
See Also:
take
tail
"""
if n < 0:
raise ValueError('n argument for drop() must be non-negative')
cdef Py_ssize_t i
cdef object iter_seq
iter_seq = iter(seq)
try:
for i in range(n):
next(iter_seq)
except StopIteration:
pass
return iter_seq
cpdef object take_nth(Py_ssize_t n, object seq):
"""
Every nth item in seq
>>> list(take_nth(2, [10, 20, 30, 40, 50]))
[10, 30, 50]
"""
return islice(seq, 0, None, n)
cpdef object first(object seq):
"""
The first element in a sequence
>>> first('ABC')
'A'
"""
return next(iter(seq))
cpdef object second(object seq):
"""
The second element in a sequence
>>> second('ABC')
'B'
"""
seq = iter(seq)
next(seq)
return next(seq)
cpdef object nth(Py_ssize_t n, object seq):
"""
The nth element in a sequence
>>> nth(1, 'ABC')
'B'
"""
if PySequence_Check(seq):
return seq[n]
if n < 0:
raise ValueError('"n" must be positive when indexing an iterator')
seq = iter(seq)
while n > 0:
n -= 1
next(seq)
return next(seq)
cpdef object last(object seq):
"""
The last element in a sequence
>>> last('ABC')
'C'
"""
cdef object val
if PySequence_Check(seq):
return seq[-1]
val = no_default
for val in seq:
pass
if val == no_default:
raise IndexError
return val
cpdef object rest(object seq):
seq = iter(seq)
next(seq)
return seq
cdef tuple _get_exceptions = (IndexError, KeyError, TypeError)
cdef tuple _get_list_exc = (IndexError, KeyError)
cpdef object get(object ind, object seq, object default='__no__default__'):
"""
Get element in a sequence or dict
Provides standard indexing
>>> get(1, 'ABC') # Same as 'ABC'[1]
'B'
Pass a list to get multiple values
>>> get([1, 2], 'ABC') # ('ABC'[1], 'ABC'[2])
('B', 'C')
Works on any value that supports indexing/getitem
For example here we see that it works with dictionaries
>>> phonebook = {'Alice': '555-1234',
... 'Bob': '555-5678',
... 'Charlie':'555-9999'}
>>> get('Alice', phonebook)
'555-1234'
>>> get(['Alice', 'Bob'], phonebook)
('555-1234', '555-5678')
Provide a default for missing values
>>> get(['Alice', 'Dennis'], phonebook, None)
('555-1234', None)
See Also:
pluck
"""
cdef Py_ssize_t i
cdef object val
cdef tuple result
cdef PyObject *obj
if isinstance(ind, list):
i = PyList_GET_SIZE(ind)
result = PyTuple_New(i)
# List of indices, no default
if default == no_default:
for i, val in enumerate(ind):
val = seq[val]
Py_INCREF(val)
PyTuple_SET_ITEM(result, i, val)
return result
# List of indices with default
for i, val in enumerate(ind):
obj = PtrObject_GetItem(seq, val)
if obj is NULL:
val = <object>PyErr_Occurred()
PyErr_Clear()
if not PyErr_GivenExceptionMatches(val, _get_list_exc):
raise val
Py_INCREF(default)
PyTuple_SET_ITEM(result, i, default)
else:
val = <object>obj
PyTuple_SET_ITEM(result, i, val)
return result
obj = PtrObject_GetItem(seq, ind)
if obj is NULL:
val = <object>PyErr_Occurred()
PyErr_Clear()
if default == no_default:
raise val
if PyErr_GivenExceptionMatches(val, _get_exceptions):
return default
raise val
val = <object>obj
Py_XDECREF(obj)
return val
cpdef object concat(object seqs):
"""
Concatenate zero or more iterables, any of which may be infinite.
An infinite sequence will prevent the rest of the arguments from
being included.
We use chain.from_iterable rather than ``chain(*seqs)`` so that seqs
can be a generator.
>>> list(concat([[], [1], [2, 3]]))
[1, 2, 3]
See also:
itertools.chain.from_iterable equivalent
"""
return chain.from_iterable(seqs)
def concatv(*seqs):
"""
Variadic version of concat
>>> list(concatv([], ["a"], ["b", "c"]))
['a', 'b', 'c']
See also:
itertools.chain
"""
return chain.from_iterable(seqs)
cpdef object mapcat(object func, object seqs):
"""
Apply func to each sequence in seqs, concatenating results.
>>> list(mapcat(lambda s: [c.upper() for c in s],
... [["a", "b"], ["c", "d", "e"]]))
['A', 'B', 'C', 'D', 'E']
"""
return concat(map(func, seqs))
cpdef object cons(object el, object seq):
"""
Add el to beginning of (possibly infinite) sequence seq.
>>> list(cons(1, [2, 3]))
[1, 2, 3]
"""
return chain((el,), seq)
cdef class interpose:
""" interpose(el, seq)
Introduce element between each pair of elements in seq
>>> list(interpose("a", [1, 2, 3]))
[1, 'a', 2, 'a', 3]
"""
def __cinit__(self, object el, object seq):
self.el = el
self.iter_seq = iter(seq)
self.do_el = False
try:
self.val = next(self.iter_seq)
except StopIteration:
self.do_el = True
def __iter__(self):
return self
def __next__(self):
if self.do_el:
self.val = next(self.iter_seq)
self.do_el = False
return self.el
else:
self.do_el = True
return self.val
cpdef dict frequencies(object seq):
"""
Find number of occurrences of each value in seq
>>> frequencies(['cat', 'cat', 'ox', 'pig', 'pig', 'cat']) #doctest: +SKIP
{'cat': 3, 'ox': 1, 'pig': 2}
See Also:
countby
groupby
"""
cdef dict d = {}
cdef PyObject *obj
cdef Py_ssize_t val
for item in seq:
obj = PyDict_GetItem(d, item)
if obj is NULL:
d[item] = 1
else:
val = <object>obj
d[item] = val + 1
return d
cdef inline object _reduceby_core(dict d, object key, object item, object binop,
object init, bint skip_init, bint call_init):
cdef PyObject *obj = PyDict_GetItem(d, key)
if obj is not NULL:
PyDict_SetItem(d, key, binop(<object>obj, item))
elif skip_init:
PyDict_SetItem(d, key, item)
elif call_init:
PyDict_SetItem(d, key, binop(init(), item))
else:
PyDict_SetItem(d, key, binop(init, item))
cpdef dict reduceby(object key, object binop, object seq, object init='__no__default__'):
"""
Perform a simultaneous groupby and reduction
The computation:
>>> result = reduceby(key, binop, seq, init) # doctest: +SKIP
is equivalent to the following:
>>> def reduction(group): # doctest: +SKIP
... return reduce(binop, group, init) # doctest: +SKIP
>>> groups = groupby(key, seq) # doctest: +SKIP
>>> result = valmap(reduction, groups) # doctest: +SKIP
But the former does not build the intermediate groups, allowing it to
operate in much less space. This makes it suitable for larger datasets
that do not fit comfortably in memory
The ``init`` keyword argument is the default initialization of the
reduction. This can be either a constant value like ``0`` or a callable
like ``lambda : 0`` as might be used in ``defaultdict``.
Simple Examples
---------------
>>> from operator import add, mul
>>> iseven = lambda x: x % 2 == 0
>>> data = [1, 2, 3, 4, 5]
>>> reduceby(iseven, add, data) # doctest: +SKIP
{False: 9, True: 6}
>>> reduceby(iseven, mul, data) # doctest: +SKIP
{False: 15, True: 8}
Complex Example
---------------
>>> projects = [{'name': 'build roads', 'state': 'CA', 'cost': 1000000},
... {'name': 'fight crime', 'state': 'IL', 'cost': 100000},
... {'name': 'help farmers', 'state': 'IL', 'cost': 2000000},
... {'name': 'help farmers', 'state': 'CA', 'cost': 200000}]
>>> reduceby('state', # doctest: +SKIP
... lambda acc, x: acc + x['cost'],
... projects, 0)
{'CA': 1200000, 'IL': 2100000}
Example Using ``init``
----------------------
>>> def set_add(s, i):
... s.add(i)
... return s
>>> reduceby(iseven, set_add, [1, 2, 3, 4, 1, 2, 3], set) # doctest: +SKIP
{True: set([2, 4]),
False: set([1, 3])}
"""
cdef dict d = {}
cdef object item, keyval
cdef Py_ssize_t i, N
cdef bint skip_init = init == no_default
cdef bint call_init = callable(init)
if callable(key):
for item in seq:
keyval = key(item)
_reduceby_core(d, keyval, item, binop, init, skip_init, call_init)
elif isinstance(key, list):
N = PyList_GET_SIZE(key)
for item in seq:
keyval = PyTuple_New(N)
for i in range(N):
val = <object>PyList_GET_ITEM(key, i)
val = item[val]
Py_INCREF(val)
PyTuple_SET_ITEM(keyval, i, val)
_reduceby_core(d, keyval, item, binop, init, skip_init, call_init)
else:
for item in seq:
keyval = item[key]
_reduceby_core(d, keyval, item, binop, init, skip_init, call_init)
return d
cdef class iterate:
""" iterate(func, x)
Repeatedly apply a function func onto an original input
Yields x, then func(x), then func(func(x)), then func(func(func(x))), etc..
>>> def inc(x): return x + 1
>>> counter = iterate(inc, 0)
>>> next(counter)
0
>>> next(counter)
1
>>> next(counter)
2
>>> double = lambda x: x * 2
>>> powers_of_two = iterate(double, 1)
>>> next(powers_of_two)
1
>>> next(powers_of_two)
2
>>> next(powers_of_two)
4
>>> next(powers_of_two)
8
"""
def __cinit__(self, object func, object x):
self.func = func
self.x = x
self.val = self # sentinel
def __iter__(self):
return self
def __next__(self):
if self.val is self:
self.val = self.x
else:
self.x = self.func(self.x)
return self.x
cdef class sliding_window:
""" sliding_window(n, seq)
A sequence of overlapping subsequences
>>> list(sliding_window(2, [1, 2, 3, 4]))
[(1, 2), (2, 3), (3, 4)]
This function creates a sliding window suitable for transformations like
sliding means / smoothing
>>> mean = lambda seq: float(sum(seq)) / len(seq)
>>> list(map(mean, sliding_window(2, [1, 2, 3, 4])))
[1.5, 2.5, 3.5]
"""
def __cinit__(self, Py_ssize_t n, object seq):
cdef Py_ssize_t i
self.iterseq = iter(seq)
self.prev = PyTuple_New(n)
for i in range(1, n):
seq = next(self.iterseq)
Py_INCREF(seq)
PyTuple_SET_ITEM(self.prev, i, seq)
self.n = n
def __iter__(self):
return self
def __next__(self):
cdef tuple current
cdef object item
cdef Py_ssize_t i
current = PyTuple_New(self.n)
for i in range(1, self.n):
item = self.prev[i]
Py_INCREF(item)
PyTuple_SET_ITEM(current, i-1, item)
item = next(self.iterseq)
Py_INCREF(item)
PyTuple_SET_ITEM(current, self.n-1, item)
self.prev = current
return current
no_pad = '__no__pad__'
cpdef object partition(Py_ssize_t n, object seq, object pad='__no__pad__'):
"""
Partition sequence into tuples of length n
>>> list(partition(2, [1, 2, 3, 4]))
[(1, 2), (3, 4)]
If the length of ``seq`` is not evenly divisible by ``n``, the final tuple
is dropped if ``pad`` is not specified, or filled to length ``n`` by pad:
>>> list(partition(2, [1, 2, 3, 4, 5]))
[(1, 2), (3, 4)]
>>> list(partition(2, [1, 2, 3, 4, 5], pad=None))
[(1, 2), (3, 4), (5, None)]
See Also:
partition_all
"""
args = [iter(seq)] * n
if pad == '__no__pad__':
return zip(*args)
else:
return zip_longest(*args, fillvalue=pad)
cdef class partition_all:
""" partition_all(n, seq)
Partition all elements of sequence into tuples of length at most n
The final tuple may be shorter to accommodate extra elements.
>>> list(partition_all(2, [1, 2, 3, 4]))
[(1, 2), (3, 4)]
>>> list(partition_all(2, [1, 2, 3, 4, 5]))
[(1, 2), (3, 4), (5,)]
See Also:
partition
"""
def __cinit__(self, Py_ssize_t n, object seq):
self.n = n
self.iterseq = iter(seq)
def __iter__(self):
return self
def __next__(self):
cdef tuple result
cdef object item
cdef Py_ssize_t i = 0
result = PyTuple_New(self.n)
for item in self.iterseq:
Py_INCREF(item)
PyTuple_SET_ITEM(result, i, item)
i += 1
if i == self.n:
return result
# iterable exhausted before filling the tuple
if i == 0:
raise StopIteration
return PyTuple_GetSlice(result, 0, i)
cpdef object count(object seq):
"""
Count the number of items in seq
Like the builtin ``len`` but works on lazy sequencies.
Not to be confused with ``itertools.count``
See also:
len
"""
if iter(seq) is not seq and hasattr(seq, '__len__'):
return len(seq)
cdef Py_ssize_t i = 0
for _ in seq:
i += 1
return i
cdef class _pluck_index:
def __cinit__(self, object ind, object seqs):
self.ind = ind
self.iterseqs = iter(seqs)
def __iter__(self):
return self
def __next__(self):
val = next(self.iterseqs)
return val[self.ind]
cdef class _pluck_index_default:
def __cinit__(self, object ind, object seqs, object default):
self.ind = ind
self.iterseqs = iter(seqs)
self.default = default
def __iter__(self):
return self
def __next__(self):
cdef PyObject *obj
cdef object val
val = next(self.iterseqs)
obj = PtrObject_GetItem(val, self.ind)
if obj is NULL:
val = <object>PyErr_Occurred()
PyErr_Clear()
if not PyErr_GivenExceptionMatches(val, _get_exceptions):
raise val
return self.default
val = <object>obj
Py_XDECREF(obj)
return val
cdef class _pluck_list:
def __cinit__(self, list ind not None, object seqs):
self.ind = ind
self.iterseqs = iter(seqs)
self.n = len(ind)
def __iter__(self):
return self
def __next__(self):
cdef Py_ssize_t i
cdef tuple result
cdef object val, seq
seq = next(self.iterseqs)
result = PyTuple_New(self.n)
for i, val in enumerate(self.ind):
val = seq[val]
Py_INCREF(val)
PyTuple_SET_ITEM(result, i, val)
return result
cdef class _pluck_list_default:
def __cinit__(self, list ind not None, object seqs, object default):
self.ind = ind
self.iterseqs = iter(seqs)
self.default = default
self.n = len(ind)
def __iter__(self):
return self
def __next__(self):
cdef Py_ssize_t i
cdef object val, seq
cdef tuple result
seq = next(self.iterseqs)
result = PyTuple_New(self.n)
for i, val in enumerate(self.ind):
obj = PtrObject_GetItem(seq, val)
if obj is NULL:
val = <object>PyErr_Occurred()
PyErr_Clear()
if not PyErr_GivenExceptionMatches(val, _get_list_exc):
raise val
Py_INCREF(self.default)
PyTuple_SET_ITEM(result, i, self.default)
else:
val = <object>obj
PyTuple_SET_ITEM(result, i, val)
return result
cpdef object pluck(object ind, object seqs, object default='__no__default__'):
"""
plucks an element or several elements from each item in a sequence.
``pluck`` maps ``itertoolz.get`` over a sequence and returns one or more
elements of each item in the sequence.
This is equivalent to running `map(curried.get(ind), seqs)`
``ind`` can be either a single string/index or a list of strings/indices.
``seqs`` should be sequence containing sequences or dicts.
e.g.
>>> data = [{'id': 1, 'name': 'Cheese'}, {'id': 2, 'name': 'Pies'}]
>>> list(pluck('name', data))
['Cheese', 'Pies']
>>> list(pluck([0, 1], [[1, 2, 3], [4, 5, 7]]))
[(1, 2), (4, 5)]
See Also:
get
map
"""
if isinstance(ind, list):
if default != no_default:
return _pluck_list_default(ind, seqs, default)
if PyList_GET_SIZE(ind) < 10:
return _pluck_list(ind, seqs)
return map(itemgetter(*ind), seqs)
if default == no_default:
return _pluck_index(ind, seqs)
return _pluck_index_default(ind, seqs, default)
cdef class _getter_index:
def __cinit__(self, object ind):
self.ind = ind
def __call__(self, object seq):
return seq[self.ind]
cdef class _getter_list:
def __cinit__(self, list ind not None):
self.ind = ind
self.n = len(ind)
def __call__(self, object seq):
cdef Py_ssize_t i
cdef tuple result
cdef object val
result = PyTuple_New(self.n)
for i, val in enumerate(self.ind):
val = seq[val]
Py_INCREF(val)
PyTuple_SET_ITEM(result, i, val)
return result
cdef class _getter_null:
def __call__(self, object seq):
return ()
# TODO: benchmark getters (and compare against itemgetter)
cpdef object getter(object index):
if isinstance(index, list):
if PyList_GET_SIZE(index) == 0:
return _getter_null()
elif PyList_GET_SIZE(index) < 10:
return _getter_list(index)
return itemgetter(*index)
return _getter_index(index)
cpdef object join(object leftkey, object leftseq,
object rightkey, object rightseq,
object left_default='__no__default__',
object right_default='__no__default__'):
"""
Join two sequences on common attributes
This is a semi-streaming operation. The LEFT sequence is fully evaluated
and placed into memory. The RIGHT sequence is evaluated lazily and so can
be arbitrarily large.
>>> friends = [('Alice', 'Edith'),
... ('Alice', 'Zhao'),
... ('Edith', 'Alice'),
... ('Zhao', 'Alice'),
... ('Zhao', 'Edith')]
>>> cities = [('Alice', 'NYC'),
... ('Alice', 'Chicago'),
... ('Dan', 'Syndey'),
... ('Edith', 'Paris'),
... ('Edith', 'Berlin'),
... ('Zhao', 'Shanghai')]
>>> # Vacation opportunities
>>> # In what cities do people have friends?
>>> result = join(second, friends,
... first, cities)
>>> for ((a, b), (c, d)) in sorted(unique(result)):
... print((a, d))
('Alice', 'Berlin')
('Alice', 'Paris')
('Alice', 'Shanghai')
('Edith', 'Chicago')
('Edith', 'NYC')
('Zhao', 'Chicago')
('Zhao', 'NYC')
('Zhao', 'Berlin')
('Zhao', 'Paris')
Specify outer joins with keyword arguments ``left_default`` and/or
``right_default``. Here is a full outer join in which unmatched elements
are paired with None.
>>> identity = lambda x: x
>>> list(join(identity, [1, 2, 3],
... identity, [2, 3, 4],
... left_default=None, right_default=None))
[(2, 2), (3, 3), (None, 4), (1, None)]
Usually the key arguments are callables to be applied to the sequences. If
the keys are not obviously callable then it is assumed that indexing was
intended, e.g. the following is a legal change
>>> # result = join(second, friends, first, cities)
>>> result = join(1, friends, 0, cities) # doctest: +SKIP
"""
if left_default == no_default and right_default == no_default:
if callable(rightkey):
return _inner_join_key(leftkey, leftseq, rightkey, rightseq,
left_default, right_default)
elif isinstance(rightkey, list):
return _inner_join_indices(leftkey, leftseq, rightkey, rightseq,
left_default, right_default)
else:
return _inner_join_index(leftkey, leftseq, rightkey, rightseq,
left_default, right_default)
elif left_default != no_default and right_default == no_default:
if callable(rightkey):
return _right_outer_join_key(leftkey, leftseq, rightkey, rightseq,
left_default, right_default)
elif isinstance(rightkey, list):
return _right_outer_join_indices(leftkey, leftseq, rightkey, rightseq,
left_default, right_default)
else:
return _right_outer_join_index(leftkey, leftseq, rightkey, rightseq,
left_default, right_default)
elif left_default == no_default and right_default != no_default:
if callable(rightkey):
return _left_outer_join_key(leftkey, leftseq, rightkey, rightseq,
left_default, right_default)
elif isinstance(rightkey, list):
return _left_outer_join_indices(leftkey, leftseq, rightkey, rightseq,
left_default, right_default)
else:
return _left_outer_join_index(leftkey, leftseq, rightkey, rightseq,
left_default, right_default)
else:
if callable(rightkey):
return _outer_join_key(leftkey, leftseq, rightkey, rightseq,
left_default, right_default)
elif isinstance(rightkey, list):
return _outer_join_indices(leftkey, leftseq, rightkey, rightseq,
left_default, right_default)
else:
return _outer_join_index(leftkey, leftseq, rightkey, rightseq,
left_default, right_default)
cdef class _join:
def __cinit__(self,
object leftkey, object leftseq,
object rightkey, object rightseq,
object left_default=no_default,
object right_default=no_default):
self.left_default = left_default
self.right_default = right_default
self._rightkey = rightkey
self.rightseq = iter(rightseq)
if isinstance(rightkey, list):
self.N = len(rightkey)
self.d = groupby(leftkey, leftseq)
self.seen_keys = set()
self.matches = []
self.right = None
self.is_rightseq_exhausted = False
def __iter__(self):
return self
cdef object rightkey(self):
pass
cdef class _right_outer_join(_join):
def __next__(self):
cdef PyObject *obj
if self.i == PyList_GET_SIZE(self.matches):
self.right = next(self.rightseq)
key = self.rightkey()
obj = PyDict_GetItem(self.d, key)
if obj is NULL:
return (self.left_default, self.right)
self.matches = <object>obj
self.i = 0
match = <object>PyList_GET_ITEM(self.matches, self.i) # skip error checking
self.i += 1
return (match, self.right)
cdef class _right_outer_join_key(_right_outer_join):
cdef object rightkey(self):
return self._rightkey(self.right)
cdef class _right_outer_join_index(_right_outer_join):
cdef object rightkey(self):
return self.right[self._rightkey]
cdef class _right_outer_join_indices(_right_outer_join):
cdef object rightkey(self):
keyval = PyTuple_New(self.N)
for i in range(self.N):
val = <object>PyList_GET_ITEM(self._rightkey, i)
val = self.right[val]
Py_INCREF(val)
PyTuple_SET_ITEM(keyval, i, val)
return keyval
cdef class _outer_join(_join):
def __next__(self):
cdef PyObject *obj
if not self.is_rightseq_exhausted:
if self.i == PyList_GET_SIZE(self.matches):
try:
self.right = next(self.rightseq)
except StopIteration:
self.is_rightseq_exhausted = True
self.keys = iter(self.d)
return next(self)
key = self.rightkey()
PySet_Add(self.seen_keys, key)
obj = PyDict_GetItem(self.d, key)
if obj is NULL:
return (self.left_default, self.right)
self.matches = <object>obj
self.i = 0
match = <object>PyList_GET_ITEM(self.matches, self.i) # skip error checking
self.i += 1
return (match, self.right)
else:
if self.i == PyList_GET_SIZE(self.matches):
key = next(self.keys)
while key in self.seen_keys:
key = next(self.keys)
obj = PyDict_GetItem(self.d, key)
self.matches = <object>obj
self.i = 0
match = <object>PyList_GET_ITEM(self.matches, self.i) # skip error checking
self.i += 1
return (match, self.right_default)
cdef class _outer_join_key(_outer_join):
cdef object rightkey(self):
return self._rightkey(self.right)
cdef class _outer_join_index(_outer_join):
cdef object rightkey(self):
return self.right[self._rightkey]
cdef class _outer_join_indices(_outer_join):
cdef object rightkey(self):
keyval = PyTuple_New(self.N)
for i in range(self.N):
val = <object>PyList_GET_ITEM(self._rightkey, i)
val = self.right[val]
Py_INCREF(val)
PyTuple_SET_ITEM(keyval, i, val)
return keyval
cdef class _left_outer_join(_join):
def __next__(self):
cdef PyObject *obj
if not self.is_rightseq_exhausted:
if self.i == PyList_GET_SIZE(self.matches):
obj = NULL
while obj is NULL:
try:
self.right = next(self.rightseq)
except StopIteration:
self.is_rightseq_exhausted = True
self.keys = iter(self.d)
return next(self)
key = self.rightkey()
PySet_Add(self.seen_keys, key)
obj = PyDict_GetItem(self.d, key)
self.matches = <object>obj
self.i = 0
match = <object>PyList_GET_ITEM(self.matches, self.i) # skip error checking
self.i += 1
return (match, self.right)
else:
if self.i == PyList_GET_SIZE(self.matches):
key = next(self.keys)
while key in self.seen_keys:
key = next(self.keys)
obj = PyDict_GetItem(self.d, key)
self.matches = <object>obj
self.i = 0
match = <object>PyList_GET_ITEM(self.matches, self.i) # skip error checking
self.i += 1
return (match, self.right_default)
cdef class _left_outer_join_key(_left_outer_join):
cdef object rightkey(self):
return self._rightkey(self.right)
cdef class _left_outer_join_index(_left_outer_join):
cdef object rightkey(self):
return self.right[self._rightkey]
cdef class _left_outer_join_indices(_left_outer_join):
cdef object rightkey(self):
keyval = PyTuple_New(self.N)
for i in range(self.N):
val = <object>PyList_GET_ITEM(self._rightkey, i)
val = self.right[val]
Py_INCREF(val)
PyTuple_SET_ITEM(keyval, i, val)
return keyval
cdef class _inner_join(_join):
def __next__(self):
cdef PyObject *obj = NULL
if self.i == PyList_GET_SIZE(self.matches):
while obj is NULL:
self.right = next(self.rightseq)
key = self.rightkey()
obj = PyDict_GetItem(self.d, key)
self.matches = <object>obj
self.i = 0
match = <object>PyList_GET_ITEM(self.matches, self.i) # skip error checking
self.i += 1
return (match, self.right)
cdef class _inner_join_key(_inner_join):
cdef object rightkey(self):
return self._rightkey(self.right)
cdef class _inner_join_index(_inner_join):
cdef object rightkey(self):
return self.right[self._rightkey]
cdef class _inner_join_indices(_inner_join):
cdef object rightkey(self):
keyval = PyTuple_New(self.N)
for i in range(self.N):
val = <object>PyList_GET_ITEM(self._rightkey, i)
val = self.right[val]
Py_INCREF(val)
PyTuple_SET_ITEM(keyval, i, val)
return keyval
cdef class _diff_key:
def __cinit__(self, object seqs, object key, object default=no_default):
self.N = len(seqs)
if self.N < 2:
raise TypeError('Too few sequences given (min 2 required)')
if default == no_default:
self.iters = zip(*seqs)
else:
self.iters = zip_longest(*seqs, fillvalue=default)
self.key = key
def __iter__(self):
return self
def __next__(self):
cdef object val, val2, items
cdef Py_ssize_t i
while True:
items = next(self.iters)
val = self.key(<object>PyTuple_GET_ITEM(items, 0))
for i in range(1, self.N):
val2 = self.key(<object>PyTuple_GET_ITEM(items, i))
if PyObject_RichCompareBool(val, val2, Py_NE):
return items
cdef class _diff_identity:
def __cinit__(self, object seqs, object default=no_default):
self.N = len(seqs)
if self.N < 2:
raise TypeError('Too few sequences given (min 2 required)')
if default == no_default:
self.iters = zip(*seqs)
else:
self.iters = zip_longest(*seqs, fillvalue=default)
def __iter__(self):
return self
def __next__(self):
cdef object val, val2, items
cdef Py_ssize_t i
while True:
items = next(self.iters)
val = <object>PyTuple_GET_ITEM(items, 0)
for i in range(1, self.N):
val2 = <object>PyTuple_GET_ITEM(items, i)
if PyObject_RichCompareBool(val, val2, Py_NE):
return items
cdef object c_diff(object seqs, object default=no_default, object key=None):
if key is None:
return _diff_identity(seqs, default=default)
else:
return _diff_key(seqs, key, default=default)
def diff(*seqs, **kwargs):
"""
Return those items that differ between sequences
>>> list(diff([1, 2, 3], [1, 2, 10, 100]))
[(3, 10)]
Shorter sequences may be padded with a ``default`` value:
>>> list(diff([1, 2, 3], [1, 2, 10, 100], default=None))
[(3, 10), (None, 100)]
A ``key`` function may also be applied to each item to use during
comparisons:
>>> list(diff(['apples', 'bananas'], ['Apples', 'Oranges'], key=str.lower))
[('bananas', 'Oranges')]
"""
N = len(seqs)
if N == 1 and isinstance(seqs[0], list):
seqs = seqs[0]
default = kwargs.get('default', no_default)
key = kwargs.get('key')
return c_diff(seqs, default=default, key=key)
cpdef object topk(Py_ssize_t k, object seq, object key=None):
"""
Find the k largest elements of a sequence
Operates lazily in ``n*log(k)`` time
>>> topk(2, [1, 100, 10, 1000])
(1000, 100)
Use a key function to change sorted order
>>> topk(2, ['Alice', 'Bob', 'Charlie', 'Dan'], key=len)
('Charlie', 'Alice')
See also:
heapq.nlargest
"""
cdef object item, val, top
cdef object it = iter(seq)
cdef object _heapreplace = heapreplace
cdef Py_ssize_t i = k
cdef list pq = []
if key is not None and not callable(key):
key = getter(key)
if k < 2:
if k < 1:
return ()
top = list(take(1, it))
if len(top) == 0:
return ()
it = concatv(top, it)
if key is None:
return (max(it),)
else:
return (max(it, key=key),)
for item in it:
if key is None:
PyList_Append(pq, (item, i))
else:
PyList_Append(pq, (key(item), i, item))
i -= 1
if i == 0:
break
if i != 0:
pq.sort(reverse=True)
k = 0 if key is None else 2
return tuple([item[k] for item in pq])
heapify(pq)
top = pq[0][0]
if key is None:
for item in it:
if top < item:
_heapreplace(pq, (item, i))
top = pq[0][0]
i -= 1
else:
for item in it:
val = key(item)
if top < val:
_heapreplace(pq, (val, i, item))
top = pq[0][0]
i -= 1
pq.sort(reverse=True)
k = 0 if key is None else 2
return tuple([item[k] for item in pq])
cpdef object peek(object seq):
"""
Retrieve the next element of a sequence
Returns the first element and an iterable equivalent to the original
sequence, still having the element retrieved.
>>> seq = [0, 1, 2, 3, 4]
>>> first, seq = peek(seq)
>>> first
0
>>> list(seq)
[0, 1, 2, 3, 4]
"""
iterator = iter(seq)
item = next(iterator)
return item, chain((item,), iterator)
cdef class random_sample:
""" random_sample(prob, seq, random_state=None)
Return elements from a sequence with probability of prob
Returns a lazy iterator of random items from seq.
``random_sample`` considers each item independently and without
replacement. See below how the first time it returned 13 items and the
next time it returned 6 items.
>>> seq = list(range(100))
>>> list(random_sample(0.1, seq)) # doctest: +SKIP
[6, 9, 19, 35, 45, 50, 58, 62, 68, 72, 78, 86, 95]
>>> list(random_sample(0.1, seq)) # doctest: +SKIP
[6, 44, 54, 61, 69, 94]
Providing an integer seed for ``random_state`` will result in
deterministic sampling. Given the same seed it will return the same sample
every time.
>>> list(random_sample(0.1, seq, random_state=2016))
[7, 9, 19, 25, 30, 32, 34, 48, 59, 60, 81, 98]
>>> list(random_sample(0.1, seq, random_state=2016))
[7, 9, 19, 25, 30, 32, 34, 48, 59, 60, 81, 98]
``random_state`` can also be any object with a method ``random`` that
returns floats between 0.0 and 1.0 (exclusive).
>>> from random import Random
>>> randobj = Random(2016)
>>> list(random_sample(0.1, seq, random_state=randobj))
[7, 9, 19, 25, 30, 32, 34, 48, 59, 60, 81, 98]
"""
def __cinit__(self, object prob, object seq, random_state=None):
float(prob)
self.prob = prob
self.iter_seq = iter(seq)
if not hasattr(random_state, 'random'):
random_state = Random(random_state)
self.random_func = random_state.random
def __iter__(self):
return self
def __next__(self):
while True:
if self.random_func() < self.prob:
return next(self.iter_seq)
next(self.iter_seq)