14710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmimport unittest 24710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmfrom test import test_support 34710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmfrom itertools import * 44710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmfrom weakref import proxy 54710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmfrom decimal import Decimal 64710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmfrom fractions import Fraction 74710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmimport sys 84710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmimport operator 94710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmimport random 104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmimport copy 114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmimport pickle 124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmfrom functools import reduce 134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmmaxsize = test_support.MAX_Py_ssize_t 144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmminsize = -maxsize-1 154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmdef onearg(x): 174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 'Test function of one argument' 184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 2*x 194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmdef errfunc(*args): 214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 'Test function that raises an error' 224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm raise ValueError 234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmdef gen3(): 254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 'Non-restartable source sequence' 264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for i in (0, 1, 2): 274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm yield i 284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmdef isEven(x): 304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 'Test predicate' 314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return x%2==0 324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmdef isOdd(x): 344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 'Test predicate' 354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return x%2==1 364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmclass StopNow: 384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 'Class emulating an empty iterable.' 394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __iter__(self): 404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return self 414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def next(self): 424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm raise StopIteration 434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmdef take(n, seq): 454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 'Convenience function for partially consuming a long of infinite iterable' 464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return list(islice(seq, n)) 474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmdef prod(iterable): 494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return reduce(operator.mul, iterable, 1) 504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmdef fact(n): 524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 'Factorial' 534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return prod(range(1, n+1)) 544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmclass TestBasicOps(unittest.TestCase): 564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_chain(self): 574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def chain2(*iterables): 594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 'Pure python version in the docs' 604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for it in iterables: 614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for element in it: 624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm yield element 634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for c in (chain, chain2): 654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(c('abc', 'def')), list('abcdef')) 664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(c('abc')), list('abc')) 674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(c('')), []) 684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(take(4, c('abc', 'def')), list('abcd')) 694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, list,c(2, 3)) 704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_chain_from_iterable(self): 724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(chain.from_iterable(['abc', 'def'])), list('abcdef')) 734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(chain.from_iterable(['abc'])), list('abc')) 744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(chain.from_iterable([''])), []) 754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(take(4, chain.from_iterable(['abc', 'def'])), list('abcd')) 764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, list, chain.from_iterable([2, 3])) 774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_combinations(self): 794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, combinations, 'abc') # missing r argument 804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, combinations, 'abc', 2, 1) # too many arguments 814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, combinations, None) # pool is not iterable 824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, combinations, 'abc', -2) # r is negative 834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(combinations('abc', 32)), []) # r > n 844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(combinations(range(4), 3)), 854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm [(0,1,2), (0,1,3), (0,2,3), (1,2,3)]) 864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def combinations1(iterable, r): 884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 'Pure python version shown in the docs' 894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pool = tuple(iterable) 904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm n = len(pool) 914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if r > n: 924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm indices = range(r) 944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm yield tuple(pool[i] for i in indices) 954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm while 1: 964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for i in reversed(range(r)): 974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if indices[i] != i + n - r: 984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break 994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else: 1004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 1014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm indices[i] += 1 1024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for j in range(i+1, r): 1034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm indices[j] = indices[j-1] + 1 1044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm yield tuple(pool[i] for i in indices) 1054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def combinations2(iterable, r): 1074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 'Pure python version shown in the docs' 1084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pool = tuple(iterable) 1094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm n = len(pool) 1104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for indices in permutations(range(n), r): 1114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if sorted(indices) == list(indices): 1124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm yield tuple(pool[i] for i in indices) 1134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def combinations3(iterable, r): 1154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 'Pure python version from cwr()' 1164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pool = tuple(iterable) 1174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm n = len(pool) 1184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for indices in combinations_with_replacement(range(n), r): 1194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if len(set(indices)) == r: 1204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm yield tuple(pool[i] for i in indices) 1214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for n in range(7): 1234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm values = [5*x-12 for x in range(n)] 1244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for r in range(n+2): 1254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm result = list(combinations(values, r)) 1264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(len(result), 0 if r>n else fact(n) // fact(r) // fact(n-r)) # right number of combs 1274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(len(result), len(set(result))) # no repeats 1284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(result, sorted(result)) # lexicographic order 1294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for c in result: 1304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(len(c), r) # r-length combinations 1314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(len(set(c)), r) # no duplicate elements 1324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(c), sorted(c)) # keep original ordering 1334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(all(e in values for e in c)) # elements taken from input iterable 1344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(c), 1354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm [e for e in values if e in c]) # comb is a subsequence of the input iterable 1364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(result, list(combinations1(values, r))) # matches first pure python version 1374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(result, list(combinations2(values, r))) # matches second pure python version 1384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(result, list(combinations3(values, r))) # matches second pure python version 1394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Test implementation detail: tuple re-use 1414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(len(set(map(id, combinations('abcde', 3)))), 1) 1424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertNotEqual(len(set(map(id, list(combinations('abcde', 3))))), 1) 1434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_combinations_with_replacement(self): 1454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm cwr = combinations_with_replacement 1464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, cwr, 'abc') # missing r argument 1474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, cwr, 'abc', 2, 1) # too many arguments 1484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, cwr, None) # pool is not iterable 1494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, cwr, 'abc', -2) # r is negative 1504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(cwr('ABC', 2)), 1514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm [('A','A'), ('A','B'), ('A','C'), ('B','B'), ('B','C'), ('C','C')]) 1524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def cwr1(iterable, r): 1544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 'Pure python version shown in the docs' 1554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # number items returned: (n+r-1)! / r! / (n-1)! when n>0 1564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pool = tuple(iterable) 1574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm n = len(pool) 1584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if not n and r: 1594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 1604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm indices = [0] * r 1614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm yield tuple(pool[i] for i in indices) 1624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm while 1: 1634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for i in reversed(range(r)): 1644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if indices[i] != n - 1: 1654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break 1664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else: 1674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 1684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm indices[i:] = [indices[i] + 1] * (r - i) 1694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm yield tuple(pool[i] for i in indices) 1704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def cwr2(iterable, r): 1724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 'Pure python version shown in the docs' 1734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pool = tuple(iterable) 1744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm n = len(pool) 1754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for indices in product(range(n), repeat=r): 1764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if sorted(indices) == list(indices): 1774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm yield tuple(pool[i] for i in indices) 1784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def numcombs(n, r): 1804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if not n: 1814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 0 if r else 1 1824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return fact(n+r-1) // fact(r) // fact(n-1) 1834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for n in range(7): 1854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm values = [5*x-12 for x in range(n)] 1864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for r in range(n+2): 1874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm result = list(cwr(values, r)) 1884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(len(result), numcombs(n, r)) # right number of combs 1904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(len(result), len(set(result))) # no repeats 1914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(result, sorted(result)) # lexicographic order 1924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm regular_combs = list(combinations(values, r)) # compare to combs without replacement 1944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if n == 0 or r <= 1: 1954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(result, regular_combs) # cases that should be identical 1964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else: 1974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(set(result) >= set(regular_combs)) # rest should be supersets of regular combs 1984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for c in result: 2004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(len(c), r) # r-length combinations 2014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm noruns = [k for k,v in groupby(c)] # combo without consecutive repeats 2024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(len(noruns), len(set(noruns))) # no repeats other than consecutive 2034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(c), sorted(c)) # keep original ordering 2044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(all(e in values for e in c)) # elements taken from input iterable 2054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(noruns, 2064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm [e for e in values if e in c]) # comb is a subsequence of the input iterable 2074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(result, list(cwr1(values, r))) # matches first pure python version 2084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(result, list(cwr2(values, r))) # matches second pure python version 2094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Test implementation detail: tuple re-use 2114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(len(set(map(id, cwr('abcde', 3)))), 1) 2124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertNotEqual(len(set(map(id, list(cwr('abcde', 3))))), 1) 2134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_permutations(self): 2154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, permutations) # too few arguments 2164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, permutations, 'abc', 2, 1) # too many arguments 2174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, permutations, None) # pool is not iterable 2184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, permutations, 'abc', -2) # r is negative 2194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(permutations('abc', 32)), []) # r > n 2204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, permutations, 'abc', 's') # r is not an int or None 2214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(permutations(range(3), 2)), 2224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm [(0,1), (0,2), (1,0), (1,2), (2,0), (2,1)]) 2234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def permutations1(iterable, r=None): 2254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 'Pure python version shown in the docs' 2264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pool = tuple(iterable) 2274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm n = len(pool) 2284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm r = n if r is None else r 2294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if r > n: 2304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 2314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm indices = range(n) 2324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm cycles = range(n, n-r, -1) 2334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm yield tuple(pool[i] for i in indices[:r]) 2344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm while n: 2354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for i in reversed(range(r)): 2364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm cycles[i] -= 1 2374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if cycles[i] == 0: 2384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm indices[i:] = indices[i+1:] + indices[i:i+1] 2394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm cycles[i] = n - i 2404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else: 2414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm j = cycles[i] 2424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm indices[i], indices[-j] = indices[-j], indices[i] 2434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm yield tuple(pool[i] for i in indices[:r]) 2444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break 2454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else: 2464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 2474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def permutations2(iterable, r=None): 2494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 'Pure python version shown in the docs' 2504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pool = tuple(iterable) 2514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm n = len(pool) 2524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm r = n if r is None else r 2534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for indices in product(range(n), repeat=r): 2544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if len(set(indices)) == r: 2554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm yield tuple(pool[i] for i in indices) 2564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for n in range(7): 2584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm values = [5*x-12 for x in range(n)] 2594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for r in range(n+2): 2604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm result = list(permutations(values, r)) 2614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(len(result), 0 if r>n else fact(n) // fact(n-r)) # right number of perms 2624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(len(result), len(set(result))) # no repeats 2634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(result, sorted(result)) # lexicographic order 2644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for p in result: 2654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(len(p), r) # r-length permutations 2664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(len(set(p)), r) # no duplicate elements 2674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(all(e in values for e in p)) # elements taken from input iterable 2684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(result, list(permutations1(values, r))) # matches first pure python version 2694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(result, list(permutations2(values, r))) # matches second pure python version 2704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if r == n: 2714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(result, list(permutations(values, None))) # test r as None 2724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(result, list(permutations(values))) # test default r 2734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Test implementation detail: tuple re-use 2754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(len(set(map(id, permutations('abcde', 3)))), 1) 2764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertNotEqual(len(set(map(id, list(permutations('abcde', 3))))), 1) 2774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_combinatorics(self): 2794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Test relationships between product(), permutations(), 2804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # combinations() and combinations_with_replacement(). 2814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for n in range(6): 2834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm s = 'ABCDEFG'[:n] 2844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for r in range(8): 2854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm prod = list(product(s, repeat=r)) 2864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm cwr = list(combinations_with_replacement(s, r)) 2874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm perm = list(permutations(s, r)) 2884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm comb = list(combinations(s, r)) 2894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Check size 2914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(len(prod), n**r) 2924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(len(cwr), (fact(n+r-1) // fact(r) // fact(n-1)) if n else (not r)) 2934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(len(perm), 0 if r>n else fact(n) // fact(n-r)) 2944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(len(comb), 0 if r>n else fact(n) // fact(r) // fact(n-r)) 2954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Check lexicographic order without repeated tuples 2974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(prod, sorted(set(prod))) 2984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(cwr, sorted(set(cwr))) 2994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(perm, sorted(set(perm))) 3004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(comb, sorted(set(comb))) 3014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Check interrelationships 3034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(cwr, [t for t in prod if sorted(t)==list(t)]) # cwr: prods which are sorted 3044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(perm, [t for t in prod if len(set(t))==r]) # perm: prods with no dups 3054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(comb, [t for t in perm if sorted(t)==list(t)]) # comb: perms that are sorted 3064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(comb, [t for t in cwr if len(set(t))==r]) # comb: cwrs without dups 3074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(comb, filter(set(cwr).__contains__, perm)) # comb: perm that is a cwr 3084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(comb, filter(set(perm).__contains__, cwr)) # comb: cwr that is a perm 3094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(comb, sorted(set(cwr) & set(perm))) # comb: both a cwr and a perm 3104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_compress(self): 3124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(compress(data='ABCDEF', selectors=[1,0,1,0,1,1])), list('ACEF')) 3134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(compress('ABCDEF', [1,0,1,0,1,1])), list('ACEF')) 3144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(compress('ABCDEF', [0,0,0,0,0,0])), list('')) 3154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(compress('ABCDEF', [1,1,1,1,1,1])), list('ABCDEF')) 3164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(compress('ABCDEF', [1,0,1])), list('AC')) 3174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(compress('ABC', [0,1,1,1,1,1])), list('BC')) 3184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm n = 10000 3194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm data = chain.from_iterable(repeat(range(6), n)) 3204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm selectors = chain.from_iterable(repeat((0, 1))) 3214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(compress(data, selectors)), [1,3,5] * n) 3224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, compress, None, range(6)) # 1st arg not iterable 3234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, compress, range(6), None) # 2nd arg not iterable 3244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, compress, range(6)) # too few args 3254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, compress, range(6), None) # too many args 3264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_count(self): 3284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(zip('abc',count()), [('a', 0), ('b', 1), ('c', 2)]) 3294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(zip('abc',count(3)), [('a', 3), ('b', 4), ('c', 5)]) 3304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(take(2, zip('abc',count(3))), [('a', 3), ('b', 4)]) 3314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(take(2, zip('abc',count(-1))), [('a', -1), ('b', 0)]) 3324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(take(2, zip('abc',count(-3))), [('a', -3), ('b', -2)]) 3334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, count, 2, 3, 4) 3344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, count, 'a') 3354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(islice(count(maxsize-5), 10)), range(maxsize-5, maxsize+5)) 3364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(islice(count(-maxsize-5), 10)), range(-maxsize-5, -maxsize+5)) 3374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm c = count(3) 3384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(repr(c), 'count(3)') 3394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm c.next() 3404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(repr(c), 'count(4)') 3414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm c = count(-9) 3424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(repr(c), 'count(-9)') 3434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm c.next() 3444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(repr(count(10.25)), 'count(10.25)') 3454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(c.next(), -8) 3464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for i in (-sys.maxint-5, -sys.maxint+5 ,-10, -1, 0, 10, sys.maxint-5, sys.maxint+5): 3474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Test repr (ignoring the L in longs) 3484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm r1 = repr(count(i)).replace('L', '') 3494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm r2 = 'count(%r)'.__mod__(i).replace('L', '') 3504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(r1, r2) 3514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # check copy, deepcopy, pickle 3534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for value in -3, 3, sys.maxint-5, sys.maxint+5: 3544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm c = count(value) 3554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(next(copy.copy(c)), value) 3564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(next(copy.deepcopy(c)), value) 3574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(next(pickle.loads(pickle.dumps(c))), value) 3584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_count_with_stride(self): 3604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(zip('abc',count(2,3)), [('a', 2), ('b', 5), ('c', 8)]) 3614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(zip('abc',count(start=2,step=3)), 3624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm [('a', 2), ('b', 5), ('c', 8)]) 3634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(zip('abc',count(step=-1)), 3644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm [('a', 0), ('b', -1), ('c', -2)]) 3654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(zip('abc',count(2,0)), [('a', 2), ('b', 2), ('c', 2)]) 3664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(zip('abc',count(2,1)), [('a', 2), ('b', 3), ('c', 4)]) 3674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(take(20, count(maxsize-15, 3)), take(20, range(maxsize-15, maxsize+100, 3))) 3684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(take(20, count(-maxsize-15, 3)), take(20, range(-maxsize-15,-maxsize+100, 3))) 3694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(take(3, count(2, 3.25-4j)), [2, 5.25-4j, 8.5-8j]) 3704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(take(3, count(Decimal('1.1'), Decimal('.1'))), 3714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm [Decimal('1.1'), Decimal('1.2'), Decimal('1.3')]) 3724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(take(3, count(Fraction(2,3), Fraction(1,7))), 3734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm [Fraction(2,3), Fraction(17,21), Fraction(20,21)]) 3744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(repr(take(3, count(10, 2.5))), repr([10, 12.5, 15.0])) 3754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm c = count(3, 5) 3764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(repr(c), 'count(3, 5)') 3774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm c.next() 3784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(repr(c), 'count(8, 5)') 3794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm c = count(-9, 0) 3804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(repr(c), 'count(-9, 0)') 3814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm c.next() 3824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(repr(c), 'count(-9, 0)') 3834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm c = count(-9, -3) 3844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(repr(c), 'count(-9, -3)') 3854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm c.next() 3864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(repr(c), 'count(-12, -3)') 3874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(repr(c), 'count(-12, -3)') 3884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(repr(count(10.5, 1.25)), 'count(10.5, 1.25)') 3894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(repr(count(10.5, 1)), 'count(10.5)') # suppress step=1 when it's an int 3904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(repr(count(10.5, 1.00)), 'count(10.5, 1.0)') # do show float values lilke 1.0 3914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for i in (-sys.maxint-5, -sys.maxint+5 ,-10, -1, 0, 10, sys.maxint-5, sys.maxint+5): 3924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for j in (-sys.maxint-5, -sys.maxint+5 ,-10, -1, 0, 1, 10, sys.maxint-5, sys.maxint+5): 3934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Test repr (ignoring the L in longs) 3944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm r1 = repr(count(i, j)).replace('L', '') 3954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if j == 1: 3964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm r2 = ('count(%r)' % i).replace('L', '') 3974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else: 3984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm r2 = ('count(%r, %r)' % (i, j)).replace('L', '') 3994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(r1, r2) 4004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_cycle(self): 4024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(take(10, cycle('abc')), list('abcabcabca')) 4034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(cycle('')), []) 4044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, cycle) 4054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, cycle, 5) 4064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(islice(cycle(gen3()),10)), [0,1,2,0,1,2,0,1,2,0]) 4074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_groupby(self): 4094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Check whether it accepts arguments correctly 4104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual([], list(groupby([]))) 4114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual([], list(groupby([], key=id))) 4124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, list, groupby('abc', [])) 4134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, groupby, None) 4144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, groupby, 'abc', lambda x:x, 10) 4154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Check normal input 4174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm s = [(0, 10, 20), (0, 11,21), (0,12,21), (1,13,21), (1,14,22), 4184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (2,15,22), (3,16,23), (3,17,23)] 4194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm dup = [] 4204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for k, g in groupby(s, lambda r:r[0]): 4214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for elem in g: 4224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(k, elem[0]) 4234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm dup.append(elem) 4244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(s, dup) 4254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Check nested case 4274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm dup = [] 4284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for k, g in groupby(s, lambda r:r[0]): 4294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for ik, ig in groupby(g, lambda r:r[2]): 4304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for elem in ig: 4314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(k, elem[0]) 4324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(ik, elem[2]) 4334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm dup.append(elem) 4344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(s, dup) 4354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Check case where inner iterator is not used 4374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm keys = [k for k, g in groupby(s, lambda r:r[0])] 4384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm expectedkeys = set([r[0] for r in s]) 4394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(set(keys), expectedkeys) 4404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(len(keys), len(expectedkeys)) 4414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Exercise pipes and filters style 4434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm s = 'abracadabra' 4444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # sort s | uniq 4454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm r = [k for k, g in groupby(sorted(s))] 4464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(r, ['a', 'b', 'c', 'd', 'r']) 4474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # sort s | uniq -d 4484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm r = [k for k, g in groupby(sorted(s)) if list(islice(g,1,2))] 4494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(r, ['a', 'b', 'r']) 4504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # sort s | uniq -c 4514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm r = [(len(list(g)), k) for k, g in groupby(sorted(s))] 4524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(r, [(5, 'a'), (2, 'b'), (1, 'c'), (1, 'd'), (2, 'r')]) 4534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # sort s | uniq -c | sort -rn | head -3 4544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm r = sorted([(len(list(g)) , k) for k, g in groupby(sorted(s))], reverse=True)[:3] 4554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(r, [(5, 'a'), (2, 'r'), (2, 'b')]) 4564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # iter.next failure 4584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class ExpectedError(Exception): 4594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pass 4604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def delayed_raise(n=0): 4614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for i in range(n): 4624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm yield 'yo' 4634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm raise ExpectedError 4644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def gulp(iterable, keyp=None, func=list): 4654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return [func(g) for k, g in groupby(iterable, keyp)] 4664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # iter.next failure on outer object 4684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ExpectedError, gulp, delayed_raise(0)) 4694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # iter.next failure on inner object 4704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ExpectedError, gulp, delayed_raise(1)) 4714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # __cmp__ failure 4734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class DummyCmp: 4744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __cmp__(self, dst): 4754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm raise ExpectedError 4764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm s = [DummyCmp(), DummyCmp(), None] 4774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # __cmp__ failure on outer object 4794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ExpectedError, gulp, s, func=id) 4804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # __cmp__ failure on inner object 4814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ExpectedError, gulp, s) 4824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # keyfunc failure 4844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def keyfunc(obj): 4854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if keyfunc.skip > 0: 4864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm keyfunc.skip -= 1 4874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return obj 4884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else: 4894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm raise ExpectedError 4904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # keyfunc failure on outer object 4924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm keyfunc.skip = 0 4934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ExpectedError, gulp, [None], keyfunc) 4944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm keyfunc.skip = 1 4954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ExpectedError, gulp, [None, None], keyfunc) 4964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_ifilter(self): 4984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(ifilter(isEven, range(6))), [0,2,4]) 4994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(ifilter(None, [0,1,0,2,0])), [1,2]) 5004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(ifilter(bool, [0,1,0,2,0])), [1,2]) 5014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(take(4, ifilter(isEven, count())), [0,2,4,6]) 5024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, ifilter) 5034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, ifilter, lambda x:x) 5044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, ifilter, lambda x:x, range(6), 7) 5054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, ifilter, isEven, 3) 5064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, ifilter(range(6), range(6)).next) 5074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_ifilterfalse(self): 5094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(ifilterfalse(isEven, range(6))), [1,3,5]) 5104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(ifilterfalse(None, [0,1,0,2,0])), [0,0,0]) 5114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(ifilterfalse(bool, [0,1,0,2,0])), [0,0,0]) 5124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(take(4, ifilterfalse(isEven, count())), [1,3,5,7]) 5134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, ifilterfalse) 5144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, ifilterfalse, lambda x:x) 5154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, ifilterfalse, lambda x:x, range(6), 7) 5164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, ifilterfalse, isEven, 3) 5174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, ifilterfalse(range(6), range(6)).next) 5184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_izip(self): 5204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ans = [(x,y) for x, y in izip('abc',count())] 5214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(ans, [('a', 0), ('b', 1), ('c', 2)]) 5224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(izip('abc', range(6))), zip('abc', range(6))) 5234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(izip('abcdef', range(3))), zip('abcdef', range(3))) 5244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(take(3,izip('abcdef', count())), zip('abcdef', range(3))) 5254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(izip('abcdef')), zip('abcdef')) 5264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(izip()), zip()) 5274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, izip, 3) 5284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, izip, range(3), 3) 5294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Check tuple re-use (implementation detail) 5304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual([tuple(list(pair)) for pair in izip('abc', 'def')], 5314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm zip('abc', 'def')) 5324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual([pair for pair in izip('abc', 'def')], 5334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm zip('abc', 'def')) 5344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ids = map(id, izip('abc', 'def')) 5354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(min(ids), max(ids)) 5364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ids = map(id, list(izip('abc', 'def'))) 5374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(len(dict.fromkeys(ids)), len(ids)) 5384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_iziplongest(self): 5404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for args in [ 5414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ['abc', range(6)], 5424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm [range(6), 'abc'], 5434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm [range(1000), range(2000,2100), range(3000,3050)], 5444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm [range(1000), range(0), range(3000,3050), range(1200), range(1500)], 5454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm [range(1000), range(0), range(3000,3050), range(1200), range(1500), range(0)], 5464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ]: 5474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # target = map(None, *args) <- this raises a py3k warning 5484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # this is the replacement: 5494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm target = [tuple([arg[i] if i < len(arg) else None for arg in args]) 5504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for i in range(max(map(len, args)))] 5514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(izip_longest(*args)), target) 5524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(izip_longest(*args, **{})), target) 5534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm target = [tuple((e is None and 'X' or e) for e in t) for t in target] # Replace None fills with 'X' 5544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(izip_longest(*args, **dict(fillvalue='X'))), target) 5554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(take(3,izip_longest('abcdef', count())), zip('abcdef', range(3))) # take 3 from infinite input 5574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(izip_longest()), zip()) 5594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(izip_longest([])), zip([])) 5604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(izip_longest('abcdef')), zip('abcdef')) 5614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(izip_longest('abc', 'defg', **{})), 5634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm zip(list('abc') + [None], 'defg')) # empty keyword dict 5644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, izip_longest, 3) 5654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, izip_longest, range(3), 3) 5664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for stmt in [ 5684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "izip_longest('abc', fv=1)", 5694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "izip_longest('abc', fillvalue=1, bogus_keyword=None)", 5704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ]: 5714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm try: 5724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm eval(stmt, globals(), locals()) 5734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm except TypeError: 5744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pass 5754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else: 5764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.fail('Did not raise Type in: ' + stmt) 5774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Check tuple re-use (implementation detail) 5794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual([tuple(list(pair)) for pair in izip_longest('abc', 'def')], 5804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm zip('abc', 'def')) 5814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual([pair for pair in izip_longest('abc', 'def')], 5824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm zip('abc', 'def')) 5834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ids = map(id, izip_longest('abc', 'def')) 5844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(min(ids), max(ids)) 5854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ids = map(id, list(izip_longest('abc', 'def'))) 5864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(len(dict.fromkeys(ids)), len(ids)) 5874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_bug_7244(self): 5894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class Repeater(object): 5914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # this class is similar to itertools.repeat 5924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __init__(self, o, t, e): 5934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.o = o 5944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.t = int(t) 5954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.e = e 5964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __iter__(self): # its iterator is itself 5974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return self 5984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def next(self): 5994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if self.t > 0: 6004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.t -= 1 6014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return self.o 6024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else: 6034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm raise self.e 6044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Formerly this code in would fail in debug mode 6064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # with Undetected Error and Stop Iteration 6074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm r1 = Repeater(1, 3, StopIteration) 6084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm r2 = Repeater(2, 4, StopIteration) 6094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def run(r1, r2): 6104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm result = [] 6114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for i, j in izip_longest(r1, r2, fillvalue=0): 6124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm with test_support.captured_output('stdout'): 6134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm print (i, j) 6144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm result.append((i, j)) 6154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return result 6164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(run(r1, r2), [(1,2), (1,2), (1,2), (0,2)]) 6174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Formerly, the RuntimeError would be lost 6194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # and StopIteration would stop as expected 6204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm r1 = Repeater(1, 3, RuntimeError) 6214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm r2 = Repeater(2, 4, StopIteration) 6224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm it = izip_longest(r1, r2, fillvalue=0) 6234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(next(it), (1, 2)) 6244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(next(it), (1, 2)) 6254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(next(it), (1, 2)) 6264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(RuntimeError, next, it) 6274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_product(self): 6294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for args, result in [ 6304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ([], [()]), # zero iterables 6314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (['ab'], [('a',), ('b',)]), # one iterable 6324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ([range(2), range(3)], [(0,0), (0,1), (0,2), (1,0), (1,1), (1,2)]), # two iterables 6334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ([range(0), range(2), range(3)], []), # first iterable with zero length 6344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ([range(2), range(0), range(3)], []), # middle iterable with zero length 6354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ([range(2), range(3), range(0)], []), # last iterable with zero length 6364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ]: 6374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(product(*args)), result) 6384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for r in range(4): 6394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(product(*(args*r))), 6404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm list(product(*args, **dict(repeat=r)))) 6414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(len(list(product(*[range(7)]*6))), 7**6) 6424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, product, range(6), None) 6434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def product1(*args, **kwds): 6454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pools = map(tuple, args) * kwds.get('repeat', 1) 6464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm n = len(pools) 6474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if n == 0: 6484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm yield () 6494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 6504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if any(len(pool) == 0 for pool in pools): 6514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 6524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm indices = [0] * n 6534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm yield tuple(pool[i] for pool, i in zip(pools, indices)) 6544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm while 1: 6554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for i in reversed(range(n)): # right to left 6564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if indices[i] == len(pools[i]) - 1: 6574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm continue 6584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm indices[i] += 1 6594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for j in range(i+1, n): 6604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm indices[j] = 0 6614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm yield tuple(pool[i] for pool, i in zip(pools, indices)) 6624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break 6634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else: 6644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 6654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def product2(*args, **kwds): 6674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 'Pure python version used in docs' 6684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pools = map(tuple, args) * kwds.get('repeat', 1) 6694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm result = [[]] 6704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for pool in pools: 6714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm result = [x+[y] for x in result for y in pool] 6724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for prod in result: 6734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm yield tuple(prod) 6744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm argtypes = ['', 'abc', '', xrange(0), xrange(4), dict(a=1, b=2, c=3), 6764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm set('abcdefg'), range(11), tuple(range(13))] 6774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for i in range(100): 6784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm args = [random.choice(argtypes) for j in range(random.randrange(5))] 6794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm expected_len = prod(map(len, args)) 6804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(len(list(product(*args))), expected_len) 6814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(product(*args)), list(product1(*args))) 6824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(product(*args)), list(product2(*args))) 6834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm args = map(iter, args) 6844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(len(list(product(*args))), expected_len) 6854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Test implementation detail: tuple re-use 6874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(len(set(map(id, product('abc', 'def')))), 1) 6884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertNotEqual(len(set(map(id, list(product('abc', 'def'))))), 1) 6894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_repeat(self): 6914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(repeat(object='a', times=3)), ['a', 'a', 'a']) 6924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(zip(xrange(3),repeat('a')), 6934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm [(0, 'a'), (1, 'a'), (2, 'a')]) 6944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(repeat('a', 3)), ['a', 'a', 'a']) 6954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(take(3, repeat('a')), ['a', 'a', 'a']) 6964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(repeat('a', 0)), []) 6974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(repeat('a', -3)), []) 6984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, repeat) 6994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, repeat, None, 3, 4) 7004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, repeat, None, 'a') 7014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm r = repeat(1+0j) 7024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(repr(r), 'repeat((1+0j))') 7034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm r = repeat(1+0j, 5) 7044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(repr(r), 'repeat((1+0j), 5)') 7054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm list(r) 7064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(repr(r), 'repeat((1+0j), 0)') 7074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_imap(self): 7094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(imap(operator.pow, range(3), range(1,7))), 7104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm [0**1, 1**2, 2**3]) 7114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(imap(None, 'abc', range(5))), 7124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm [('a',0),('b',1),('c',2)]) 7134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(imap(None, 'abc', count())), 7144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm [('a',0),('b',1),('c',2)]) 7154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(take(2,imap(None, 'abc', count())), 7164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm [('a',0),('b',1)]) 7174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(imap(operator.pow, [])), []) 7184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, imap) 7194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, imap, operator.neg) 7204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, imap(10, range(5)).next) 7214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, imap(errfunc, [4], [5]).next) 7224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, imap(onearg, [4], [5]).next) 7234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_starmap(self): 7254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(starmap(operator.pow, zip(range(3), range(1,7)))), 7264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm [0**1, 1**2, 2**3]) 7274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(take(3, starmap(operator.pow, izip(count(), count(1)))), 7284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm [0**1, 1**2, 2**3]) 7294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(starmap(operator.pow, [])), []) 7304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(starmap(operator.pow, [iter([4,5])])), [4**5]) 7314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, list, starmap(operator.pow, [None])) 7324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, starmap) 7334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, starmap, operator.pow, [(4,5)], 'extra') 7344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, starmap(10, [(4,5)]).next) 7354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, starmap(errfunc, [(4,5)]).next) 7364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, starmap(onearg, [(4,5)]).next) 7374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_islice(self): 7394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for args in [ # islice(args) should agree with range(args) 7404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (10, 20, 3), 7414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (10, 3, 20), 7424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (10, 20), 7434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (10, 3), 7444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (20,) 7454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ]: 7464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(islice(xrange(100), *args)), range(*args)) 7474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for args, tgtargs in [ # Stop when seqn is exhausted 7494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ((10, 110, 3), ((10, 100, 3))), 7504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ((10, 110), ((10, 100))), 7514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ((110,), (100,)) 7524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ]: 7534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(islice(xrange(100), *args)), range(*tgtargs)) 7544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Test stop=None 7564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(islice(xrange(10), None)), range(10)) 7574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(islice(xrange(10), None, None)), range(10)) 7584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(islice(xrange(10), None, None, None)), range(10)) 7594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(islice(xrange(10), 2, None)), range(2, 10)) 7604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(islice(xrange(10), 1, None, 2)), range(1, 10, 2)) 7614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Test number of items consumed SF #1171417 7634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm it = iter(range(10)) 7644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(islice(it, 3)), range(3)) 7654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(it), range(3, 10)) 7664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Test invalid arguments 7684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, islice, xrange(10)) 7694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, islice, xrange(10), 1, 2, 3, 4) 7704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, islice, xrange(10), -5, 10, 1) 7714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, islice, xrange(10), 1, -5, -1) 7724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, islice, xrange(10), 1, 10, -1) 7734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, islice, xrange(10), 1, 10, 0) 7744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, islice, xrange(10), 'a') 7754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, islice, xrange(10), 'a', 1) 7764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, islice, xrange(10), 1, 'a') 7774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, islice, xrange(10), 'a', 1, 1) 7784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, islice, xrange(10), 1, 'a', 1) 7794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(len(list(islice(count(), 1, 10, maxsize))), 1) 7804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Issue #10323: Less islice in a predictable state 7824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm c = count() 7834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(islice(c, 1, 3, 50)), [1]) 7844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(next(c), 3) 7854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_takewhile(self): 7874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm data = [1, 3, 5, 20, 2, 4, 6, 8] 7884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm underten = lambda x: x<10 7894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(takewhile(underten, data)), [1, 3, 5]) 7904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(takewhile(underten, [])), []) 7914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, takewhile) 7924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, takewhile, operator.pow) 7934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, takewhile, operator.pow, [(4,5)], 'extra') 7944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, takewhile(10, [(4,5)]).next) 7954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, takewhile(errfunc, [(4,5)]).next) 7964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm t = takewhile(bool, [1, 1, 1, 0, 0, 0]) 7974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(t), [1, 1, 1]) 7984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(StopIteration, t.next) 7994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_dropwhile(self): 8014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm data = [1, 3, 5, 20, 2, 4, 6, 8] 8024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm underten = lambda x: x<10 8034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(dropwhile(underten, data)), [20, 2, 4, 6, 8]) 8044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(dropwhile(underten, [])), []) 8054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, dropwhile) 8064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, dropwhile, operator.pow) 8074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, dropwhile, operator.pow, [(4,5)], 'extra') 8084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, dropwhile(10, [(4,5)]).next) 8094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, dropwhile(errfunc, [(4,5)]).next) 8104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_tee(self): 8124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm n = 200 8134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def irange(n): 8144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for i in xrange(n): 8154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm yield i 8164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a, b = tee([]) # test empty iterator 8184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(a), []) 8194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(b), []) 8204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a, b = tee(irange(n)) # test 100% interleaved 8224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(zip(a,b), zip(range(n),range(n))) 8234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a, b = tee(irange(n)) # test 0% interleaved 8254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(a), range(n)) 8264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(b), range(n)) 8274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a, b = tee(irange(n)) # test dealloc of leading iterator 8294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for i in xrange(100): 8304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(a.next(), i) 8314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm del a 8324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(b), range(n)) 8334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a, b = tee(irange(n)) # test dealloc of trailing iterator 8354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for i in xrange(100): 8364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(a.next(), i) 8374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm del b 8384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(a), range(100, n)) 8394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for j in xrange(5): # test randomly interleaved 8414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm order = [0]*n + [1]*n 8424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm random.shuffle(order) 8434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm lists = ([], []) 8444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm its = tee(irange(n)) 8454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for i in order: 8464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm value = its[i].next() 8474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm lists[i].append(value) 8484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(lists[0], range(n)) 8494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(lists[1], range(n)) 8504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # test argument format checking 8524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, tee) 8534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, tee, 3) 8544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, tee, [1,2], 'x') 8554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, tee, [1,2], 3, 'x') 8564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # tee object should be instantiable 8584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a, b = tee('abc') 8594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm c = type(a)('def') 8604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(c), list('def')) 8614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # test long-lagged and multi-way split 8634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a, b, c = tee(xrange(2000), 3) 8644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for i in xrange(100): 8654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(a.next(), i) 8664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(b), range(2000)) 8674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual([c.next(), c.next()], range(2)) 8684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(a), range(100,2000)) 8694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(c), range(2,2000)) 8704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # test values of n 8724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, tee, 'abc', 'invalid') 8734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, tee, [], -1) 8744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for n in xrange(5): 8754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm result = tee('abc', n) 8764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(type(result), tuple) 8774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(len(result), n) 8784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(map(list, result), [list('abc')]*n) 8794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # tee pass-through to copyable iterator 8814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a, b = tee('abc') 8824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm c, d = tee(a) 8834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(a is c) 8844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # test tee_new 8864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm t1, t2 = tee('abc') 8874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm tnew = type(t1) 8884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, tnew) 8894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, tnew, 10) 8904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm t3 = tnew(t1) 8914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(list(t1) == list(t2) == list(t3) == list('abc')) 8924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # test that tee objects are weak referencable 8944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a, b = tee(xrange(10)) 8954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm p = proxy(a) 8964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(getattr(p, '__class__'), type(b)) 8974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm del a 8984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ReferenceError, getattr, p, '__class__') 8994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_StopIteration(self): 9014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(StopIteration, izip().next) 9024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for f in (chain, cycle, izip, groupby): 9044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(StopIteration, f([]).next) 9054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(StopIteration, f(StopNow()).next) 9064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(StopIteration, islice([], None).next) 9084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(StopIteration, islice(StopNow(), None).next) 9094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm p, q = tee([]) 9114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(StopIteration, p.next) 9124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(StopIteration, q.next) 9134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm p, q = tee(StopNow()) 9144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(StopIteration, p.next) 9154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(StopIteration, q.next) 9164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(StopIteration, repeat(None, 0).next) 9184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for f in (ifilter, ifilterfalse, imap, takewhile, dropwhile, starmap): 9204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(StopIteration, f(lambda x:x, []).next) 9214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(StopIteration, f(lambda x:x, StopNow()).next) 9224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmclass TestExamples(unittest.TestCase): 9244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_chain(self): 9264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(''.join(chain('ABC', 'DEF')), 'ABCDEF') 9274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_chain_from_iterable(self): 9294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(''.join(chain.from_iterable(['ABC', 'DEF'])), 'ABCDEF') 9304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_combinations(self): 9324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(combinations('ABCD', 2)), 9334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm [('A','B'), ('A','C'), ('A','D'), ('B','C'), ('B','D'), ('C','D')]) 9344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(combinations(range(4), 3)), 9354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm [(0,1,2), (0,1,3), (0,2,3), (1,2,3)]) 9364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_combinations_with_replacement(self): 9384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(combinations_with_replacement('ABC', 2)), 9394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm [('A','A'), ('A','B'), ('A','C'), ('B','B'), ('B','C'), ('C','C')]) 9404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_compress(self): 9424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(compress('ABCDEF', [1,0,1,0,1,1])), list('ACEF')) 9434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_count(self): 9454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(islice(count(10), 5)), [10, 11, 12, 13, 14]) 9464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_cycle(self): 9484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(islice(cycle('ABCD'), 12)), list('ABCDABCDABCD')) 9494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_dropwhile(self): 9514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(dropwhile(lambda x: x<5, [1,4,6,4,1])), [6,4,1]) 9524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_groupby(self): 9544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual([k for k, g in groupby('AAAABBBCCDAABBB')], 9554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm list('ABCDAB')) 9564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual([(list(g)) for k, g in groupby('AAAABBBCCD')], 9574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm [list('AAAA'), list('BBB'), list('CC'), list('D')]) 9584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_ifilter(self): 9604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(ifilter(lambda x: x%2, range(10))), [1,3,5,7,9]) 9614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_ifilterfalse(self): 9634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(ifilterfalse(lambda x: x%2, range(10))), [0,2,4,6,8]) 9644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_imap(self): 9664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(imap(pow, (2,3,10), (5,2,3))), [32, 9, 1000]) 9674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_islice(self): 9694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(islice('ABCDEFG', 2)), list('AB')) 9704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(islice('ABCDEFG', 2, 4)), list('CD')) 9714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(islice('ABCDEFG', 2, None)), list('CDEFG')) 9724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(islice('ABCDEFG', 0, None, 2)), list('ACEG')) 9734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_izip(self): 9754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(izip('ABCD', 'xy')), [('A', 'x'), ('B', 'y')]) 9764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_izip_longest(self): 9784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(izip_longest('ABCD', 'xy', fillvalue='-')), 9794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm [('A', 'x'), ('B', 'y'), ('C', '-'), ('D', '-')]) 9804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_permutations(self): 9824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(permutations('ABCD', 2)), 9834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm map(tuple, 'AB AC AD BA BC BD CA CB CD DA DB DC'.split())) 9844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(permutations(range(3))), 9854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm [(0,1,2), (0,2,1), (1,0,2), (1,2,0), (2,0,1), (2,1,0)]) 9864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_product(self): 9884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(product('ABCD', 'xy')), 9894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm map(tuple, 'Ax Ay Bx By Cx Cy Dx Dy'.split())) 9904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(product(range(2), repeat=3)), 9914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm [(0,0,0), (0,0,1), (0,1,0), (0,1,1), 9924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (1,0,0), (1,0,1), (1,1,0), (1,1,1)]) 9934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_repeat(self): 9954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(repeat(10, 3)), [10, 10, 10]) 9964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_stapmap(self): 9984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(starmap(pow, [(2,5), (3,2), (10,3)])), 9994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm [32, 9, 1000]) 10004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_takewhile(self): 10024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(takewhile(lambda x: x<5, [1,4,6,4,1])), [1,4]) 10034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmclass TestGC(unittest.TestCase): 10064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def makecycle(self, iterator, container): 10084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm container.append(iterator) 10094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm iterator.next() 10104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm del container, iterator 10114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_chain(self): 10134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a = [] 10144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.makecycle(chain(a), a) 10154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_chain_from_iterable(self): 10174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a = [] 10184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.makecycle(chain.from_iterable([a]), a) 10194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_combinations(self): 10214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a = [] 10224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.makecycle(combinations([1,2,a,3], 3), a) 10234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_combinations_with_replacement(self): 10254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a = [] 10264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.makecycle(combinations_with_replacement([1,2,a,3], 3), a) 10274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_compress(self): 10294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a = [] 10304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.makecycle(compress('ABCDEF', [1,0,1,0,1,0]), a) 10314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_count(self): 10334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a = [] 10344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Int = type('Int', (int,), dict(x=a)) 10354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.makecycle(count(Int(0), Int(1)), a) 10364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_cycle(self): 10384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a = [] 10394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.makecycle(cycle([a]*2), a) 10404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_dropwhile(self): 10424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a = [] 10434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.makecycle(dropwhile(bool, [0, a, a]), a) 10444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_groupby(self): 10464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a = [] 10474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.makecycle(groupby([a]*2, lambda x:x), a) 10484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_issue2246(self): 10504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Issue 2246 -- the _grouper iterator was not included in GC 10514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm n = 10 10524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm keyfunc = lambda x: x 10534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for i, j in groupby(xrange(n), key=keyfunc): 10544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm keyfunc.__dict__.setdefault('x',[]).append(j) 10554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_ifilter(self): 10574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a = [] 10584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.makecycle(ifilter(lambda x:True, [a]*2), a) 10594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_ifilterfalse(self): 10614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a = [] 10624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.makecycle(ifilterfalse(lambda x:False, a), a) 10634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_izip(self): 10654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a = [] 10664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.makecycle(izip([a]*2, [a]*3), a) 10674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_izip_longest(self): 10694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a = [] 10704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.makecycle(izip_longest([a]*2, [a]*3), a) 10714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b = [a, None] 10724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.makecycle(izip_longest([a]*2, [a]*3, fillvalue=b), a) 10734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_imap(self): 10754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a = [] 10764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.makecycle(imap(lambda x:x, [a]*2), a) 10774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_islice(self): 10794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a = [] 10804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.makecycle(islice([a]*2, None), a) 10814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_permutations(self): 10834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a = [] 10844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.makecycle(permutations([1,2,a,3], 3), a) 10854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_product(self): 10874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a = [] 10884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.makecycle(product([1,2,a,3], repeat=3), a) 10894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_repeat(self): 10914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a = [] 10924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.makecycle(repeat(a), a) 10934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_starmap(self): 10954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a = [] 10964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.makecycle(starmap(lambda *t: t, [(a,a)]*2), a) 10974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_takewhile(self): 10994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a = [] 11004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.makecycle(takewhile(bool, [1, 0, a, a]), a) 11014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 11024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmdef R(seqn): 11034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 'Regular generator' 11044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for i in seqn: 11054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm yield i 11064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 11074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmclass G: 11084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 'Sequence using __getitem__' 11094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __init__(self, seqn): 11104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.seqn = seqn 11114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __getitem__(self, i): 11124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return self.seqn[i] 11134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 11144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmclass I: 11154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 'Sequence using iterator protocol' 11164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __init__(self, seqn): 11174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.seqn = seqn 11184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.i = 0 11194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __iter__(self): 11204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return self 11214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def next(self): 11224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if self.i >= len(self.seqn): raise StopIteration 11234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = self.seqn[self.i] 11244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.i += 1 11254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return v 11264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 11274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmclass Ig: 11284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 'Sequence using iterator protocol defined with a generator' 11294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __init__(self, seqn): 11304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.seqn = seqn 11314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.i = 0 11324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __iter__(self): 11334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for val in self.seqn: 11344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm yield val 11354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 11364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmclass X: 11374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 'Missing __getitem__ and __iter__' 11384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __init__(self, seqn): 11394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.seqn = seqn 11404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.i = 0 11414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def next(self): 11424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if self.i >= len(self.seqn): raise StopIteration 11434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = self.seqn[self.i] 11444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.i += 1 11454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return v 11464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 11474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmclass N: 11484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 'Iterator missing next()' 11494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __init__(self, seqn): 11504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.seqn = seqn 11514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.i = 0 11524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __iter__(self): 11534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return self 11544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 11554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmclass E: 11564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 'Test propagation of exceptions' 11574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __init__(self, seqn): 11584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.seqn = seqn 11594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.i = 0 11604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __iter__(self): 11614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return self 11624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def next(self): 11634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3 // 0 11644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 11654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmclass S: 11664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 'Test immediate stop' 11674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __init__(self, seqn): 11684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pass 11694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __iter__(self): 11704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return self 11714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def next(self): 11724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm raise StopIteration 11734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 11744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmdef L(seqn): 11754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 'Test multiple tiers of iterators' 11764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return chain(imap(lambda x:x, R(Ig(G(seqn))))) 11774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 11784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 11794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmclass TestVariousIteratorArgs(unittest.TestCase): 11804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 11814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_chain(self): 11824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for s in ("123", "", range(1000), ('do', 1.2), xrange(2000,2200,5)): 11834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for g in (G, I, Ig, S, L, R): 11844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(chain(g(s))), list(g(s))) 11854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(chain(g(s), g(s))), list(g(s))+list(g(s))) 11864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, list, chain(X(s))) 11874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, list, chain(N(s))) 11884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ZeroDivisionError, list, chain(E(s))) 11894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 11904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_compress(self): 11914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for s in ("123", "", range(1000), ('do', 1.2), xrange(2000,2200,5)): 11924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm n = len(s) 11934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for g in (G, I, Ig, S, L, R): 11944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(compress(g(s), repeat(1))), list(g(s))) 11954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, compress, X(s), repeat(1)) 11964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, list, compress(N(s), repeat(1))) 11974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ZeroDivisionError, list, compress(E(s), repeat(1))) 11984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 11994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_product(self): 12004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for s in ("123", "", range(1000), ('do', 1.2), xrange(2000,2200,5)): 12014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, product, X(s)) 12024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, product, N(s)) 12034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ZeroDivisionError, product, E(s)) 12044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 12054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_cycle(self): 12064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for s in ("123", "", range(1000), ('do', 1.2), xrange(2000,2200,5)): 12074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for g in (G, I, Ig, S, L, R): 12084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm tgtlen = len(s) * 3 12094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm expected = list(g(s))*3 12104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm actual = list(islice(cycle(g(s)), tgtlen)) 12114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(actual, expected) 12124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, cycle, X(s)) 12134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, list, cycle(N(s))) 12144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ZeroDivisionError, list, cycle(E(s))) 12154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 12164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_groupby(self): 12174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for s in (range(10), range(0), range(1000), (7,11), xrange(2000,2200,5)): 12184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for g in (G, I, Ig, S, L, R): 12194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual([k for k, sb in groupby(g(s))], list(g(s))) 12204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, groupby, X(s)) 12214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, list, groupby(N(s))) 12224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ZeroDivisionError, list, groupby(E(s))) 12234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 12244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_ifilter(self): 12254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for s in (range(10), range(0), range(1000), (7,11), xrange(2000,2200,5)): 12264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for g in (G, I, Ig, S, L, R): 12274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(ifilter(isEven, g(s))), filter(isEven, g(s))) 12284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, ifilter, isEven, X(s)) 12294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, list, ifilter(isEven, N(s))) 12304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ZeroDivisionError, list, ifilter(isEven, E(s))) 12314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 12324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_ifilterfalse(self): 12334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for s in (range(10), range(0), range(1000), (7,11), xrange(2000,2200,5)): 12344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for g in (G, I, Ig, S, L, R): 12354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(ifilterfalse(isEven, g(s))), filter(isOdd, g(s))) 12364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, ifilterfalse, isEven, X(s)) 12374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, list, ifilterfalse(isEven, N(s))) 12384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ZeroDivisionError, list, ifilterfalse(isEven, E(s))) 12394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 12404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_izip(self): 12414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for s in ("123", "", range(1000), ('do', 1.2), xrange(2000,2200,5)): 12424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for g in (G, I, Ig, S, L, R): 12434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(izip(g(s))), zip(g(s))) 12444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(izip(g(s), g(s))), zip(g(s), g(s))) 12454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, izip, X(s)) 12464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, list, izip(N(s))) 12474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ZeroDivisionError, list, izip(E(s))) 12484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 12494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_iziplongest(self): 12504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for s in ("123", "", range(1000), ('do', 1.2), xrange(2000,2200,5)): 12514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for g in (G, I, Ig, S, L, R): 12524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(izip_longest(g(s))), zip(g(s))) 12534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(izip_longest(g(s), g(s))), zip(g(s), g(s))) 12544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, izip_longest, X(s)) 12554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, list, izip_longest(N(s))) 12564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ZeroDivisionError, list, izip_longest(E(s))) 12574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 12584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_imap(self): 12594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for s in (range(10), range(0), range(100), (7,11), xrange(20,50,5)): 12604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for g in (G, I, Ig, S, L, R): 12614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(imap(onearg, g(s))), map(onearg, g(s))) 12624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(imap(operator.pow, g(s), g(s))), map(operator.pow, g(s), g(s))) 12634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, imap, onearg, X(s)) 12644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, list, imap(onearg, N(s))) 12654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ZeroDivisionError, list, imap(onearg, E(s))) 12664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 12674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_islice(self): 12684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for s in ("12345", "", range(1000), ('do', 1.2), xrange(2000,2200,5)): 12694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for g in (G, I, Ig, S, L, R): 12704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(islice(g(s),1,None,2)), list(g(s))[1::2]) 12714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, islice, X(s), 10) 12724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, list, islice(N(s), 10)) 12734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ZeroDivisionError, list, islice(E(s), 10)) 12744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 12754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_starmap(self): 12764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for s in (range(10), range(0), range(100), (7,11), xrange(20,50,5)): 12774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for g in (G, I, Ig, S, L, R): 12784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ss = zip(s, s) 12794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(starmap(operator.pow, g(ss))), map(operator.pow, g(s), g(s))) 12804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, starmap, operator.pow, X(ss)) 12814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, list, starmap(operator.pow, N(ss))) 12824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ZeroDivisionError, list, starmap(operator.pow, E(ss))) 12834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 12844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_takewhile(self): 12854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for s in (range(10), range(0), range(1000), (7,11), xrange(2000,2200,5)): 12864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for g in (G, I, Ig, S, L, R): 12874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm tgt = [] 12884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for elem in g(s): 12894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if not isEven(elem): break 12904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm tgt.append(elem) 12914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(takewhile(isEven, g(s))), tgt) 12924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, takewhile, isEven, X(s)) 12934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, list, takewhile(isEven, N(s))) 12944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ZeroDivisionError, list, takewhile(isEven, E(s))) 12954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 12964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_dropwhile(self): 12974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for s in (range(10), range(0), range(1000), (7,11), xrange(2000,2200,5)): 12984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for g in (G, I, Ig, S, L, R): 12994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm tgt = [] 13004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for elem in g(s): 13014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if not tgt and isOdd(elem): continue 13024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm tgt.append(elem) 13034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(dropwhile(isOdd, g(s))), tgt) 13044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, dropwhile, isOdd, X(s)) 13054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, list, dropwhile(isOdd, N(s))) 13064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ZeroDivisionError, list, dropwhile(isOdd, E(s))) 13074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 13084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_tee(self): 13094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for s in ("123", "", range(1000), ('do', 1.2), xrange(2000,2200,5)): 13104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for g in (G, I, Ig, S, L, R): 13114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm it1, it2 = tee(g(s)) 13124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(it1), list(g(s))) 13134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(it2), list(g(s))) 13144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, tee, X(s)) 13154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, list, tee(N(s))[0]) 13164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ZeroDivisionError, list, tee(E(s))[0]) 13174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 13184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmclass LengthTransparency(unittest.TestCase): 13194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 13204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_repeat(self): 13214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm from test.test_iterlen import len 13224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(len(repeat(None, 50)), 50) 13234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, len, repeat(None)) 13244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 13254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmclass RegressionTests(unittest.TestCase): 13264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 13274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_sf_793826(self): 13284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Fix Armin Rigo's successful efforts to wreak havoc 13294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 13304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def mutatingtuple(tuple1, f, tuple2): 13314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # this builds a tuple t which is a copy of tuple1, 13324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # then calls f(t), then mutates t to be equal to tuple2 13334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # (needs len(tuple1) == len(tuple2)). 13344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def g(value, first=[1]): 13354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if first: 13364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm del first[:] 13374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f(z.next()) 13384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return value 13394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm items = list(tuple2) 13404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm items[1:1] = list(tuple1) 13414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm gen = imap(g, items) 13424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm z = izip(*[gen]*len(tuple1)) 13434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm z.next() 13444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 13454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def f(t): 13464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm global T 13474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm T = t 13484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm first[:] = list(T) 13494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 13504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm first = [] 13514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm mutatingtuple((1,2,3), f, (4,5,6)) 13524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm second = list(T) 13534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(first, second) 13544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 13554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 13564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_sf_950057(self): 13574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Make sure that chain() and cycle() catch exceptions immediately 13584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # rather than when shifting between input sources 13594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 13604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def gen1(): 13614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm hist.append(0) 13624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm yield 1 13634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm hist.append(1) 13644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm raise AssertionError 13654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm hist.append(2) 13664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 13674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def gen2(x): 13684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm hist.append(3) 13694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm yield 2 13704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm hist.append(4) 13714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if x: 13724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm raise StopIteration 13734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 13744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm hist = [] 13754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(AssertionError, list, chain(gen1(), gen2(False))) 13764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(hist, [0,1]) 13774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 13784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm hist = [] 13794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(AssertionError, list, chain(gen1(), gen2(True))) 13804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(hist, [0,1]) 13814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 13824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm hist = [] 13834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(AssertionError, list, cycle(gen1())) 13844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(hist, [0,1]) 13854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 13864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmclass SubclassWithKwargsTest(unittest.TestCase): 13874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_keywords_in_subclass(self): 13884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # count is not subclassable... 13894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for cls in (repeat, izip, ifilter, ifilterfalse, chain, imap, 13904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm starmap, islice, takewhile, dropwhile, cycle, compress): 13914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class Subclass(cls): 13924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __init__(self, newarg=None, *args): 13934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm cls.__init__(self, *args) 13944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm try: 13954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Subclass(newarg=1) 13964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm except TypeError, err: 13974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # we expect type errors because of wrong argument count 13984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertNotIn("does not take keyword arguments", err.args[0]) 13994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 14004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 14014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmlibreftest = """ Doctest for examples in the library reference: libitertools.tex 14024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 14034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 14044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm>>> amounts = [120.15, 764.05, 823.14] 14054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm>>> for checknum, amount in izip(count(1200), amounts): 14064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm... print 'Check %d is for $%.2f' % (checknum, amount) 14074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm... 14084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmCheck 1200 is for $120.15 14094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmCheck 1201 is for $764.05 14104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmCheck 1202 is for $823.14 14114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 14124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm>>> import operator 14134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm>>> for cube in imap(operator.pow, xrange(1,4), repeat(3)): 14144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm... print cube 14154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm... 14164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm1 14174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm8 14184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm27 14194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 14204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm>>> reportlines = ['EuroPython', 'Roster', '', 'alex', '', 'laura', '', 'martin', '', 'walter', '', 'samuele'] 14214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm>>> for name in islice(reportlines, 3, None, 2): 14224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm... print name.title() 14234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm... 14244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmAlex 14254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmLaura 14264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmMartin 14274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmWalter 14284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmSamuele 14294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 14304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm>>> from operator import itemgetter 14314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm>>> d = dict(a=1, b=2, c=1, d=2, e=1, f=2, g=3) 14324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm>>> di = sorted(sorted(d.iteritems()), key=itemgetter(1)) 14334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm>>> for k, g in groupby(di, itemgetter(1)): 14344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm... print k, map(itemgetter(0), g) 14354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm... 14364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm1 ['a', 'c', 'e'] 14374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm2 ['b', 'd', 'f'] 14384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm3 ['g'] 14394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 14404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm# Find runs of consecutive numbers using groupby. The key to the solution 14414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm# is differencing with a range so that consecutive numbers all appear in 14424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm# same group. 14434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm>>> data = [ 1, 4,5,6, 10, 15,16,17,18, 22, 25,26,27,28] 14444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm>>> for k, g in groupby(enumerate(data), lambda t:t[0]-t[1]): 14454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm... print map(operator.itemgetter(1), g) 14464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm... 14474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm[1] 14484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm[4, 5, 6] 14494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm[10] 14504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm[15, 16, 17, 18] 14514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm[22] 14524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm[25, 26, 27, 28] 14534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 14544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm>>> def take(n, iterable): 14554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm... "Return first n items of the iterable as a list" 14564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm... return list(islice(iterable, n)) 14574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 14584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm>>> def enumerate(iterable, start=0): 14594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm... return izip(count(start), iterable) 14604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 14614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm>>> def tabulate(function, start=0): 14624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm... "Return function(0), function(1), ..." 14634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm... return imap(function, count(start)) 14644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 14654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm>>> def nth(iterable, n, default=None): 14664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm... "Returns the nth item or a default value" 14674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm... return next(islice(iterable, n, None), default) 14684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 14694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm>>> def quantify(iterable, pred=bool): 14704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm... "Count how many times the predicate is true" 14714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm... return sum(imap(pred, iterable)) 14724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 14734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm>>> def padnone(iterable): 14744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm... "Returns the sequence elements and then returns None indefinitely" 14754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm... return chain(iterable, repeat(None)) 14764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 14774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm>>> def ncycles(iterable, n): 14784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm... "Returns the sequence elements n times" 14794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm... return chain(*repeat(iterable, n)) 14804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 14814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm>>> def dotproduct(vec1, vec2): 14824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm... return sum(imap(operator.mul, vec1, vec2)) 14834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 14844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm>>> def flatten(listOfLists): 14854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm... return list(chain.from_iterable(listOfLists)) 14864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 14874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm>>> def repeatfunc(func, times=None, *args): 14884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm... "Repeat calls to func with specified arguments." 14894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm... " Example: repeatfunc(random.random)" 14904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm... if times is None: 14914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm... return starmap(func, repeat(args)) 14924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm... else: 14934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm... return starmap(func, repeat(args, times)) 14944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 14954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm>>> def pairwise(iterable): 14964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm... "s -> (s0,s1), (s1,s2), (s2, s3), ..." 14974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm... a, b = tee(iterable) 14984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm... for elem in b: 14994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm... break 15004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm... return izip(a, b) 15014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 15024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm>>> def grouper(n, iterable, fillvalue=None): 15034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm... "grouper(3, 'ABCDEFG', 'x') --> ABC DEF Gxx" 15044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm... args = [iter(iterable)] * n 15054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm... return izip_longest(fillvalue=fillvalue, *args) 15064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 15074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm>>> def roundrobin(*iterables): 15084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm... "roundrobin('ABC', 'D', 'EF') --> A D E B F C" 15094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm... # Recipe credited to George Sakkis 15104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm... pending = len(iterables) 15114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm... nexts = cycle(iter(it).next for it in iterables) 15124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm... while pending: 15134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm... try: 15144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm... for next in nexts: 15154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm... yield next() 15164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm... except StopIteration: 15174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm... pending -= 1 15184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm... nexts = cycle(islice(nexts, pending)) 15194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 15204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm>>> def powerset(iterable): 15214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm... "powerset([1,2,3]) --> () (1,) (2,) (3,) (1,2) (1,3) (2,3) (1,2,3)" 15224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm... s = list(iterable) 15234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm... return chain.from_iterable(combinations(s, r) for r in range(len(s)+1)) 15244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 15254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm>>> def unique_everseen(iterable, key=None): 15264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm... "List unique elements, preserving order. Remember all elements ever seen." 15274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm... # unique_everseen('AAAABBBCCDAABBB') --> A B C D 15284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm... # unique_everseen('ABBCcAD', str.lower) --> A B C D 15294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm... seen = set() 15304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm... seen_add = seen.add 15314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm... if key is None: 15324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm... for element in iterable: 15334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm... if element not in seen: 15344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm... seen_add(element) 15354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm... yield element 15364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm... else: 15374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm... for element in iterable: 15384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm... k = key(element) 15394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm... if k not in seen: 15404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm... seen_add(k) 15414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm... yield element 15424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 15434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm>>> def unique_justseen(iterable, key=None): 15444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm... "List unique elements, preserving order. Remember only the element just seen." 15454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm... # unique_justseen('AAAABBBCCDAABBB') --> A B C D A B 15464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm... # unique_justseen('ABBCcAD', str.lower) --> A B C A D 15474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm... return imap(next, imap(itemgetter(1), groupby(iterable, key))) 15484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 15494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmThis is not part of the examples but it tests to make sure the definitions 15504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmperform as purported. 15514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 15524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm>>> take(10, count()) 15534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 15544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 15554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm>>> list(enumerate('abc')) 15564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm[(0, 'a'), (1, 'b'), (2, 'c')] 15574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 15584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm>>> list(islice(tabulate(lambda x: 2*x), 4)) 15594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm[0, 2, 4, 6] 15604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 15614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm>>> nth('abcde', 3) 15624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm'd' 15634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 15644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm>>> nth('abcde', 9) is None 15654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmTrue 15664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 15674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm>>> quantify(xrange(99), lambda x: x%2==0) 15684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm50 15694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 15704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm>>> a = [[1, 2, 3], [4, 5, 6]] 15714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm>>> flatten(a) 15724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm[1, 2, 3, 4, 5, 6] 15734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 15744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm>>> list(repeatfunc(pow, 5, 2, 3)) 15754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm[8, 8, 8, 8, 8] 15764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 15774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm>>> import random 15784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm>>> take(5, imap(int, repeatfunc(random.random))) 15794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm[0, 0, 0, 0, 0] 15804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 15814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm>>> list(pairwise('abcd')) 15824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm[('a', 'b'), ('b', 'c'), ('c', 'd')] 15834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 15844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm>>> list(pairwise([])) 15854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm[] 15864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 15874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm>>> list(pairwise('a')) 15884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm[] 15894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 15904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm>>> list(islice(padnone('abc'), 0, 6)) 15914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm['a', 'b', 'c', None, None, None] 15924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 15934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm>>> list(ncycles('abc', 3)) 15944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm['a', 'b', 'c', 'a', 'b', 'c', 'a', 'b', 'c'] 15954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 15964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm>>> dotproduct([1,2,3], [4,5,6]) 15974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm32 15984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 15994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm>>> list(grouper(3, 'abcdefg', 'x')) 16004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm[('a', 'b', 'c'), ('d', 'e', 'f'), ('g', 'x', 'x')] 16014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 16024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm>>> list(roundrobin('abc', 'd', 'ef')) 16034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm['a', 'd', 'e', 'b', 'f', 'c'] 16044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 16054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm>>> list(powerset([1,2,3])) 16064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm[(), (1,), (2,), (3,), (1, 2), (1, 3), (2, 3), (1, 2, 3)] 16074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 16084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm>>> all(len(list(powerset(range(n)))) == 2**n for n in range(18)) 16094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmTrue 16104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 16114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm>>> list(powerset('abcde')) == sorted(sorted(set(powerset('abcde'))), key=len) 16124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmTrue 16134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 16144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm>>> list(unique_everseen('AAAABBBCCDAABBB')) 16154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm['A', 'B', 'C', 'D'] 16164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 16174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm>>> list(unique_everseen('ABBCcAD', str.lower)) 16184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm['A', 'B', 'C', 'D'] 16194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 16204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm>>> list(unique_justseen('AAAABBBCCDAABBB')) 16214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm['A', 'B', 'C', 'D', 'A', 'B'] 16224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 16234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm>>> list(unique_justseen('ABBCcAD', str.lower)) 16244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm['A', 'B', 'C', 'A', 'D'] 16254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 16264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm""" 16274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 16284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm__test__ = {'libreftest' : libreftest} 16294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 16304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmdef test_main(verbose=None): 16314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm test_classes = (TestBasicOps, TestVariousIteratorArgs, TestGC, 16324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm RegressionTests, LengthTransparency, 16334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm SubclassWithKwargsTest, TestExamples) 16344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm test_support.run_unittest(*test_classes) 16354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 16364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # verify reference counting 16374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if verbose and hasattr(sys, "gettotalrefcount"): 16384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm import gc 16394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm counts = [None] * 5 16404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for i in xrange(len(counts)): 16414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm test_support.run_unittest(*test_classes) 16424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm gc.collect() 16434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm counts[i] = sys.gettotalrefcount() 16444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm print counts 16454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 16464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # doctest the examples in the library reference 16474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm test_support.run_doctest(sys.modules[__name__], verbose) 16484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 16494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmif __name__ == "__main__": 16504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm test_main(verbose=True) 1651