def test_init(self):
untyped = iter([1, 2, 3, 4])
typed = Result(untyped, list)
self.assertEqual(typed.evaluation_type, list)
typed = Result(iterable=untyped, evaluation_type=list)
self.assertEqual(typed.evaluation_type, list)
regex = 'evaluation_type must be a type, found instance of list'
with self.assertRaisesRegex(TypeError, regex):
typed = Result(untyped, [1, 2])
def test_unpacking_behavior(self):
data = [(1, 2), (1, 4), (1, 8)]
function = lambda x, y: x / y # <- function takes 2 args
result = _map_data(function, Result(data, list))
self.assertIsInstance(result, Result)
self.assertEqual(result.evaluation_type, list)
self.assertEqual(result.fetch(), [0.5, 0.25, 0.125])
function = lambda z: z[0] / z[1] # <- function takes 1 arg
result = _map_data(function, Result(data, list))
self.assertIsInstance(result, Result)
self.assertEqual(result.evaluation_type, list)
self.assertEqual(result.fetch(), [0.5, 0.25, 0.125])
def test_dict_iter_of_lists(self):
iterable = Result({'a': [1, 2], 'b': [3, 4]}, dict)
result = _apply_to_data(_sqlite_sum, iterable)
self.assertIsInstance(result, Result)
self.assertEqual(result.evaluation_type, dict)
self.assertEqual(result.fetch(), {'a': 3, 'b': 7})
def test_dataiter_dict_of_ints(self):
iterable = Result({'a': 2, 'b': 3}, dict)
result = _sqlite_distinct(iterable)
self.assertIsInstance(result, Result)
self.assertEqual(result.evaluation_type, dict)
self.assertEqual(result.fetch(), {'a': 2, 'b': 3})
def test_dict_iter_of_integers(self):
iterable = Result({'a': -5, 'b': None, 'c': 'xyz'}, dict)
result = _apply_to_data(_sqlite_count, iterable)
self.assertIsInstance(result, Result)
self.assertEqual(result.evaluation_type, dict)
self.assertEqual(result.fetch(), {'a': 1, 'b': 0, 'c': 1})
def test_dict_iter_of_integers(self):
iterable = Result({'a': 2, 'b': 3, 'c': None}, dict)
result = _apply_to_data(_sqlite_max, iterable)
self.assertIsInstance(result, Result)
self.assertEqual(result.evaluation_type, dict)
self.assertEqual(result.fetch(), {'a': 2, 'b': 3, 'c': None})
def test_dataiter_dict_of_containers(self):
iterable = Result({'a': [1, 2, 1, 2], 'b': (3, 4, 3)}, dict)
result = _sqlite_distinct(iterable)
self.assertIsInstance(result, Result)
self.assertEqual(result.evaluation_type, dict)
self.assertEqual(result.fetch(), {'a': [1, 2], 'b': (3, 4)})
def test_dict_iter_of_lists(self):
iterable = Result({'a': [1, None], 'b': ['x', None, 0]}, dict)
result = _apply_to_data(_sqlite_count, iterable)
self.assertIsInstance(result, Result)
self.assertEqual(result.evaluation_type, dict)
self.assertEqual(result.fetch(), {'a': 1, 'b': 2})
def test_dataiter_dict_of_containers(self):
iterable = Result({'a': [1, 2], 'b': (3, 4)}, dict)
function = lambda x: x * 2
result = _map_data(function, iterable)
self.assertIsInstance(result, Result)
self.assertEqual(result.evaluation_type, dict)
self.assertEqual(result.fetch(), {'a': [2, 4], 'b': (6, 8)})
def test_dataiter_dict_of_ints(self):
iterable = Result({'a': 2, 'b': 3}, dict)
function = lambda x: x * 2
result = _apply_data(function, iterable)
self.assertIsInstance(result, Result)
self.assertEqual(result.evaluation_type, dict)
self.assertEqual(result.fetch(), {'a': 4, 'b': 6})
def test_dataiter_dict_of_mixed_iterables(self):
iterable = Result({'a': iter([1, 2]), 'b': (3, 4)}, dict)
function = lambda itr: [x * 2 for x in itr]
result = _apply_data(function, iterable)
self.assertIsInstance(result, Result)
self.assertEqual(result.evaluation_type, dict)
self.assertEqual(result.fetch(), {'a': [2, 4], 'b': [6, 8]})
def test_dict_iter_of_integers(self):
iterable = Result({'a': 2, 'b': 3}, dict)
function = lambda x, y: x + y
result = _reduce_data(function, iterable)
self.assertIsInstance(result, Result)
self.assertEqual(result.evaluation_type, dict)
self.assertEqual(result.fetch(), {'a': 2, 'b': 3})
def test_dict_iter_of_lists(self):
iterable = Result({'a': [1, 3], 'b': [4, 5, 6]}, dict)
iseven = lambda x: x % 2 == 0
result = _filter_data(iseven, iterable)
self.assertIsInstance(result, Result)
self.assertEqual(result.evaluation_type, dict)
self.assertEqual(result.fetch(), {'a': [], 'b': [4, 6]})
def test_unchanged(self):
data = [1, 2, 3]
self.assertIs(_normalize_lazy(data), data, 'should return original object')
data = iter([1, 2, 3])
self.assertIs(_normalize_lazy(data), data, 'should return original object')
data = Result(iter([1, 2, 3]), evaluation_type=tuple)
self.assertIs(_normalize_lazy(data), data, 'should return original object')
def test_dataiter_list(self):
iterable = Result([1, 2, 3], list)
function = lambda x: x * 2
result = _map_data(function, iterable)
self.assertIsInstance(result, Result)
self.assertEqual(result.evaluation_type, list)
self.assertEqual(result.fetch(), [2, 4, 6])
def test_settype_to_list(self):
iterable = Result([1, 2, 3], set) # <- Starts as 'set'.
function = lambda x: x % 2
result = _map_data(function, iterable)
self.assertIsInstance(result, Result)
self.assertEqual(result.evaluation_type, list) # <- Now a 'list'.
self.assertEqual(result.fetch(), [1, 0, 1])
def test_dict_iter_of_lists(self):
iterable = Result(
{
'a': [1, 2, 3],
'b': [None, 1, 2, 3, 'xx'],
'c': [None, None]
}, dict)
result = _apply_to_data(_sqlite_max, iterable)
self.assertIsInstance(result, Result)
self.assertEqual(result.evaluation_type, dict)
self.assertEqual(result.fetch(), {'a': 3, 'b': 'xx', 'c': None})
def test_normalize_requirement(self):
requirement = [1, 2, 3]
self.assertIs(_normalize_requirement(requirement),
requirement,
msg='should return original object')
with self.assertRaises(TypeError, msg='cannot use generic iter'):
_normalize_requirement(iter([1, 2, 3]))
result_obj = Result(iter([1, 2, 3]), evaluation_type=tuple)
output = _normalize_requirement(result_obj)
self.assertIsInstance(output, tuple)
self.assertEqual(output, (1, 2, 3))
items = DictItems(iter([(0, 'x'), (1, 'y'), (2, 'z')]))
output = _normalize_requirement(items)
self.assertIsInstance(output, dict)
self.assertEqual(output, {0: 'x', 1: 'y', 2: 'z'})
def test_list_iter(self):
iterable = Result(['a', None, 3], list)
result = _sqlite_count(iterable)
self.assertEqual(result, 2)
def test_requirement(self):
result = Result(DictItems([('a', 1), ('b', 2)]), evaluation_type=dict)
normalized = _normalize_lazy(result)
self.assertIsInstance(normalized, IterItems)
def test_result_objects(self):
result_obj1 = Result(['2', '2'], evaluation_type=list)
result_obj2 = Result(['2', '2'], evaluation_type=list)
self.assertValid(result_obj1, result_obj2)
def test_result_object(self):
result_obj = Result(iter([1, 2, 3]), evaluation_type=tuple)
output = _normalize_eager(result_obj)
self.assertIsInstance(output, tuple)
self.assertEqual(output, (1, 2, 3))
def test_list_iter(self):
iterable = Result([-4, -1, 2, 3], list)
function = lambda x: x > 0
result = _filter_data(function, iterable)
self.assertEqual(result.fetch(), [2, 3])
def test_list_iter(self):
iterable = Result([1, 2, 3], list)
function = lambda x, y: x + y
result = _reduce_data(function, iterable)
self.assertEqual(result, 6)
def test_dict_iter_of_integers(self):
iterable = Result({'a': 2, 'b': 3}, dict)
iseven = lambda x: x % 2 == 0
with self.assertRaises(TypeError):
result = _filter_data(iseven, iterable)
def test_list_iter(self):
iterable = Result([1, 2, 1, 2, 3], list)
result = _sqlite_distinct(iterable)
self.assertEqual(result.fetch(), [1, 2, 3])
def test_dataiter_list(self):
iterable = Result([1, 2, 3], list)
function = lambda itr: [x * 2 for x in itr]
result = _apply_data(function, iterable)
self.assertEqual(result, [2, 4, 6])
def test_list_iter(self):
iterable = Result([1, 2, 3], list)
result = _sqlite_sum(iterable)
self.assertEqual(result, 6)
def test_list_iter(self):
iterable = Result([1, 2, 3, 4], list)
result = _sqlite_max(iterable)
self.assertEqual(result, 4)
def test_Result(self):
result = Result(DictItems([('a', 1), ('b', 2)]), evaluation_type=dict)
normalized = DictItems(result)
self.assertEqual(list(normalized), [('a', 1), ('b', 2)])