Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
def itersplitdown(table, field, pattern, maxsplit, flags):
prog = re.compile(pattern, flags)
it = iter(table)
hdr = next(it)
flds = list(map(text_type, hdr))
if isinstance(field, int) and field < len(hdr):
field_index = field
field = hdr[field_index]
elif field in flds:
field_index = flds.index(field)
else:
raise ArgumentError('field invalid: must be either field name or index')
yield tuple(hdr)
for row in it:
value = row[field_index]
for v in prog.split(value, maxsplit):
yield tuple(v if i == field_index else row[i] for i in range(len(hdr)))
def itercomplement(ta, tb, strict):
# coerce rows to tuples to ensure hashable and comparable
ita = (tuple(row) for row in iter(ta))
itb = (tuple(row) for row in iter(tb))
ahdr = tuple(next(ita))
next(itb) # ignore b fields
yield ahdr
try:
a = next(ita)
except StopIteration:
pass
else:
try:
b = next(itb)
except StopIteration:
yield a
for row in ita:
yield row
else:
# we want the elements in a that are not in b
while True:
def iterintersection(a, b):
ita = iter(a)
itb = iter(b)
ahdr = next(ita)
next(itb) # ignore b header
yield tuple(ahdr)
try:
a = tuple(next(ita))
b = tuple(next(itb))
while True:
if Comparable(a) < Comparable(b):
a = tuple(next(ita))
elif a == b:
yield a
a = tuple(next(ita))
b = tuple(next(itb))
else:
b = tuple(next(itb))
except StopIteration:
pass
def iterfillleft(table, missing):
it = iter(table)
hdr = next(it)
yield tuple(hdr)
for row in it:
outrow = list(reversed(row))
for i, _ in enumerate(outrow):
if i > 0 and outrow[i] == missing and outrow[i-1] != missing:
outrow[i] = outrow[i-1]
yield tuple(reversed(outrow))
def itercut(source, spec, missing=None):
it = iter(source)
spec = tuple(spec) # make sure no-one can change midstream
# convert field selection into field indices
hdr = next(it)
indices = asindices(hdr, spec)
# define a function to transform each row in the source data
# according to the field selection
transform = rowgetter(*indices)
# yield the transformed header
yield transform(hdr)
# construct the transformed data
for row in it:
try:
yield transform(row)
except IndexError:
# row is short, let's be kind and fill in any missing fields
yield tuple(row[i] if i < len(row) else missing for i in indices)
if reverse:
op = max
else:
op = min
if key is not None:
opkwargs = {'key': key}
else:
opkwargs = dict()
# populate initial shortlist
# (remember some iterables might be empty)
iterators = list()
shortlist = list()
for iterable in iterables:
it = iter(iterable)
try:
first = next(it)
iterators.append(it)
shortlist.append(first)
except StopIteration:
pass
# do the mergesort
while iterators:
nxt = op(shortlist, **opkwargs)
yield nxt
nextidx = shortlist.index(nxt)
try:
shortlist[nextidx] = next(iterators[nextidx])
except StopIteration:
del shortlist[nextidx]
del iterators[nextidx]
def itervalues(table, field, **kwargs):
missing = kwargs.get('missing', None)
it = iter(table)
hdr = next(it)
indices = asindices(hdr, field)
assert len(indices) > 0, 'no field selected'
getvalue = operator.itemgetter(*indices)
for row in it:
try:
value = getvalue(row)
yield value
except IndexError:
if len(indices) > 1:
# try one at a time
value = list()
for i in indices:
if i < len(row):
value.append(row[i])
else:
except StopIteration:
break
elif a == b:
debug('advance both')
try:
a = next(ita)
except StopIteration:
break
try:
b = next(itb)
except StopIteration:
b = None
else:
debug('advance b')
try:
b = next(itb)
except StopIteration:
b = None
for row in joinrows(lrowgrp, None):
yield tuple(row)
# advance left
lkval, lrowgrp = next(lgit)
elif lkval > rkval:
if rightouter:
for row in joinrows(None, rrowgrp):
yield tuple(row)
# advance right
rkval, rrowgrp = next(rgit)
else:
for row in joinrows(lrowgrp, rrowgrp):
yield tuple(row)
# advance both
lkval, lrowgrp = next(lgit)
rkval, rrowgrp = next(rgit)
except StopIteration:
pass
# make sure any left rows remaining are yielded
if leftouter:
if lkval > rkval:
# yield anything that got left hanging
for row in joinrows(lrowgrp, None):
yield tuple(row)
# yield the rest
for lkval, lrowgrp in lgit:
for row in joinrows(lrowgrp, None):
yield tuple(row)
# make sure any right rows remaining are yielded
def header(table):
"""
Return the header row for the given table. E.g.::
>>> from petl import header
>>> table = [['foo', 'bar'], ['a', 1], ['b', 2]]
>>> header(table)
['foo', 'bar']
See also :func:`fieldnames`.
"""
it = iter(table)
return tuple(next(it))