def test_nested_logic_list(self):
q2 = self.example_data_A_data['q2']
test_logic = intersection(
[union([has_all([1, 2]), has_any([3, 4])]),
has_count([3])])
idx, vkey = get_logic_index(q2, test_logic)
idx1, vkey1 = get_logic_index(q2, has_all([1, 2]))
idx2, vkey2 = get_logic_index(q2, has_any([3, 4]))
idx3, vkey3 = get_logic_index(q2, has_count([3]))
self.assertItemsEqual(idx, idx1.union(idx2).intersection(idx3))
self.assertEqual(vkey, 'x[(({1&2},{3,4})&{3})]:y')
def test_logic_list(self):
q2 = self.example_data_A_data['q2']
test_logic = union([has_all([1, 2]), has_any([3, 4]), has_count([3])])
idx, vkey = get_logic_index(q2, test_logic)
idx1, vkey1 = get_logic_index(q2, test_logic[1][0])
idx2, vkey2 = get_logic_index(q2, test_logic[1][1])
idx3, vkey3 = get_logic_index(q2, test_logic[1][2])
self.assertCountEqual(idx, idx1.union(idx2).union(idx3))
self.assertEqual(vkey, 'x[({1&2},{3,4},{3})]:y')
q2 = self.example_data_A_data['q2']
test_logic = intersection(
[has_all([1, 2]), has_any([3, 4]),
has_count([3])])
idx, vkey = get_logic_index(q2, test_logic)
idx1, vkey1 = get_logic_index(q2, test_logic[1][0])
idx2, vkey2 = get_logic_index(q2, test_logic[1][1])
idx3, vkey3 = get_logic_index(q2, test_logic[1][2])
self.assertCountEqual(idx, idx1.intersection(idx2).intersection(idx3))
self.assertEqual(vkey, 'x[({1&2}&{3,4}&{3})]:y')
q2 = self.example_data_A_data['q2']
test_logic = difference(
[has_all([1, 2]), has_any([3, 4]),
has_count([3])])
idx, vkey = get_logic_index(q2, test_logic)
idx1, vkey1 = get_logic_index(q2, test_logic[1][0])
idx2, vkey2 = get_logic_index(q2, test_logic[1][1])
idx3, vkey3 = get_logic_index(q2, test_logic[1][2])
self.assertCountEqual(idx, idx1.difference(idx2).difference(idx3))
self.assertEqual(vkey, 'x[({1&2}~{3,4}~{3})]:y')
q2 = self.example_data_A_data['q2']
test_logic = symmetric_difference(
[has_all([1, 2]), has_any([3, 4]),
has_count([3])])
idx, vkey = get_logic_index(q2, test_logic)
idx1, vkey1 = get_logic_index(q2, test_logic[1][0])
idx2, vkey2 = get_logic_index(q2, test_logic[1][1])
idx3, vkey3 = get_logic_index(q2, test_logic[1][2])
if pd.__version__ == '0.19.2':
self.assertCountEqual(
idx,
idx1.symmetric_difference(idx2).symmetric_difference(idx3))
else:
self.assertCountEqual(
idx,
idx1.symmetric_difference(idx2).symmetric_difference(idx3))
self.assertEqual(vkey, 'x[({1&2}^{3,4}^{3})]:y')
def test_logic_list(self):
q2 = self.example_data_A_data['q2']
test_logic = union([has_all([1, 2]), has_any([3, 4]), has_count([3])])
idx, vkey = get_logic_index(q2, test_logic)
idx1, vkey1 = get_logic_index(q2, test_logic[1][0])
idx2, vkey2 = get_logic_index(q2, test_logic[1][1])
idx3, vkey3 = get_logic_index(q2, test_logic[1][2])
self.assertItemsEqual(idx, idx1.union(idx2).union(idx3))
self.assertEqual(vkey, 'x[((1&2),(3,4),{3})]:y')
q2 = self.example_data_A_data['q2']
test_logic = intersection(
[has_all([1, 2]), has_any([3, 4]),
has_count([3])])
idx, vkey = get_logic_index(q2, test_logic)
idx1, vkey1 = get_logic_index(q2, test_logic[1][0])
idx2, vkey2 = get_logic_index(q2, test_logic[1][1])
idx3, vkey3 = get_logic_index(q2, test_logic[1][2])
self.assertItemsEqual(idx, idx1.intersection(idx2).intersection(idx3))
self.assertEqual(vkey, 'x[((1&2)&(3,4)&{3})]:y')
q2 = self.example_data_A_data['q2']
test_logic = difference(
[has_all([1, 2]), has_any([3, 4]),
has_count([3])])
idx, vkey = get_logic_index(q2, test_logic)
idx1, vkey1 = get_logic_index(q2, test_logic[1][0])
idx2, vkey2 = get_logic_index(q2, test_logic[1][1])
idx3, vkey3 = get_logic_index(q2, test_logic[1][2])
self.assertItemsEqual(idx, idx1.difference(idx2).difference(idx3))
self.assertEqual(vkey, 'x[((1&2)~(3,4)~{3})]:y')
q2 = self.example_data_A_data['q2']
test_logic = sym_diff(
[has_all([1, 2]), has_any([3, 4]),
has_count([3])])
idx, vkey = get_logic_index(q2, test_logic)
idx1, vkey1 = get_logic_index(q2, test_logic[1][0])
idx2, vkey2 = get_logic_index(q2, test_logic[1][1])
idx3, vkey3 = get_logic_index(q2, test_logic[1][2])
self.assertItemsEqual(idx, idx1.sym_diff(idx2).sym_diff(idx3))
self.assertEqual(vkey, 'x[((1&2)^(3,4)^{3})]:y')
def test_nested_logic_list(self):
q2 = self.example_data_A_data['q2']
test_logic = intersection([
union([
has_all([1, 2]),
has_any([3, 4])
]),
has_count([3])
])
idx, vkey = get_logic_index(q2, test_logic)
idx1, vkey1 = get_logic_index(q2, has_all([1, 2]))
idx2, vkey2 = get_logic_index(q2, has_any([3, 4]))
idx3, vkey3 = get_logic_index(q2, has_count([3]))
self.assertItemsEqual(
idx,
idx1.union(idx2).intersection(idx3)
)
self.assertEqual(
vkey,
'x[(((1&2),(3,4))&{3})]:y'
)
def test_simple_or(self):
# Test single x stored as int64 and float64
for xk in ['Wave', 'ethnicity']:
# Initial setup
values = [1, 2, 3]
yks = ['@', 'ethnicity', 'q2', 'gender']
# Set up basic stack
self.setup_stack_Example_Data_A()
# Test net created using an OR list with 'codes'
method_name = 'codes_list'
self.net_views.add_method(
name=method_name,
kwargs={'text': 'Ever', 'logic': values, 'axis': 'x'}
)
self.stack.add_link(x=xk, views=self.net_views.subset([method_name]))
relation = 'x[{1,2,3}]:'
self.verify_net_values_single_x(self.stack, xk, yks, values, relation, method_name)
# Test net created using an OR list with 'logic'
method_name = 'logic_list'
self.net_views.add_method(
name=method_name,
kwargs={'text': 'Ever', 'logic': values, 'axis': 'x'}
)
self.stack.add_link(x=xk, views=self.net_views.subset([method_name]))
relation = 'x[{1,2,3}]:'
self.verify_net_values_single_x(self.stack, xk, yks, values, relation, method_name)
# Test net created using has_any() logic
method_name = 'has_any'
self.net_views.add_method(
name=method_name,
kwargs={'text': 'Ever', 'logic': has_any([1,2,3]), 'axis': 'x'}
)
self.stack.add_link(x=xk, views=self.net_views.subset([method_name]))
relation = 'x[{1,2,3}]:'
self.verify_net_values_single_x(self.stack, xk, yks, values, relation, method_name)
# Test net created using has_count() logic
method_name = 'has_count'
self.net_views.add_method(
name=method_name,
kwargs={'text': 'Ever',
'logic': has_count([is_ge(1), [1,2,3]]), 'axis': 'x'}
)
self.stack.add_link(x=xk, views=self.net_views.subset([method_name]))
relation = 'x[(1,2,3){>=1}]:'
self.verify_net_values_single_x(self.stack, xk, yks, values, relation, method_name)
def test_simple_or(self):
# Test single x stored as int64 and float64
for xk in ['Wave', 'ethnicity']:
# Initial setup
values = [1, 2, 3]
yks = ['@', 'ethnicity', 'q2', 'gender']
# Set up basic stack
self.setup_stack_Example_Data_A()
# Test net created using an OR list with 'codes'
method_name = 'codes_list'
self.net_views.add_method(
name=method_name,
kwargs={'text': 'Ever', 'logic': values}
)
self.stack.add_link(x=xk, views=self.net_views.subset([method_name]))
relation = 'x[(1,2,3)]:y'
self.verify_net_values_single_x(self.stack, xk, yks, values, relation, method_name)
# Test net created using an OR list with 'logic'
method_name = 'logic_list'
self.net_views.add_method(
name=method_name,
kwargs={'text': 'Ever', 'logic': values}
)
self.stack.add_link(x=xk, views=self.net_views.subset([method_name]))
relation = 'x[(1,2,3)]:y'
self.verify_net_values_single_x(self.stack, xk, yks, values, relation, method_name)
# Test net created using has_any() logic
method_name = 'has_any'
self.net_views.add_method(
name=method_name,
kwargs={'text': 'Ever', 'logic': has_any([1,2,3])}
)
self.stack.add_link(x=xk, views=self.net_views.subset([method_name]))
relation = 'x[(1,2,3)]:y'
self.verify_net_values_single_x(self.stack, xk, yks, values, relation, method_name)
# Test net created using has_count() logic
method_name = 'has_count'
self.net_views.add_method(
name=method_name,
kwargs={'text': 'Ever', 'logic': has_count([is_ge(1), [1,2,3]])}
)
self.stack.add_link(x=xk, views=self.net_views.subset([method_name]))
relation = 'x[(1,2,3){>=1}]:y'
self.verify_net_values_single_x(self.stack, xk, yks, values, relation, method_name)
def test_get_logic_key(self):
logic = has_all([1, 2, 3], True)
self.assertEqual(
get_logic_key(logic),
'x[e{1&2&3}]:y'
)
logic = has_count([is_ge(1), [5, 6, 7, 8, 9]])
self.assertEqual(
get_logic_key(logic),
'x[(5,6,7,8,9){>=1}]:y'
)
logic = not_count([is_ge(1), [5, 6, 7, 8, 9]])
self.assertEqual(
get_logic_key(logic),
'x[(5,6,7,8,9)~{>=1}]:y'
)
logic = union([
has_any([1, 2]),
has_all([3, 4]),
not_any([5, 6])
])
self.assertEqual(
get_logic_key(logic),
'x[({1,2},{3&4},~{5,6})]:y'
)
logic = union([
intersection([
has_any([1, 2]),
not_any([3])
]),
{'Wave': has_any([1,2])}
])
self.assertEqual(
get_logic_key(logic, self.example_data_A_data),
'x[(({1,2}&~{3}),Wave={1,2})]:y'
)
def test_get_logic_key(self):
logic = has_all([1, 2, 3], True)
self.assertEqual(
get_logic_key(logic),
'x[e(1&2&3)]:y'
)
logic = has_count([is_ge(1), [5, 6, 7, 8, 9]])
self.assertEqual(
get_logic_key(logic),
'x[(5,6,7,8,9){>=1}]:y'
)
logic = not_count([is_ge(1), [5, 6, 7, 8, 9]])
self.assertEqual(
get_logic_key(logic),
'x[(5,6,7,8,9)~{>=1}]:y'
)
logic = union([
has_any([1, 2]),
has_all([3, 4]),
not_any([5, 6])
])
self.assertEqual(
get_logic_key(logic),
'x[((1,2),(3&4),~(5,6))]:y'
)
logic = union([
intersection([
has_any([1, 2]),
not_any([3])
]),
{'Wave': has_any([1,2])}
])
self.assertEqual(
get_logic_key(logic, self.example_data_A_data),
'x[(((1,2)&~(3)),Wave=(1,2))]:y'
)
def test_get_logic_key(self):
logic = has_all([1, 2, 3], True)
self.assertEqual(get_logic_key(logic), 'x[e(1&2&3)]:y')
logic = has_count([is_ge(1), [5, 6, 7, 8, 9]])
self.assertEqual(get_logic_key(logic), 'x[(5,6,7,8,9){>=1}]:y')
logic = not_count([is_ge(1), [5, 6, 7, 8, 9]])
self.assertEqual(get_logic_key(logic), 'x[(5,6,7,8,9)~{>=1}]:y')
logic = union([has_any([1, 2]), has_all([3, 4]), not_any([5, 6])])
self.assertEqual(get_logic_key(logic), 'x[((1,2),(3&4),~(5,6))]:y')
logic = union([
intersection([has_any([1, 2]), not_any([3])]), {
'Wave': has_any([1, 2])
}
])
self.assertEqual(get_logic_key(logic, self.example_data_A_data),
'x[(((1,2)&~(3)),Wave=(1,2))]:y')
def test_has_not_count_errors(self):
responses_tests = [
[],
[1, 2, 3, 4],
]
for responses in responses_tests:
# Test has version
with self.assertRaises(IndexError) as error:
func, values, exclusive = has_count(responses)
self.assertEqual(
error.exception.message[:85],
"The responses list given to has_count() must have "
"either 1, 2 or 3 items in the form:"
)
# Test not version
with self.assertRaises(IndexError) as error:
# Test _has_all raises TypeError
func, values, exclusive = not_count(responses)
self.assertEqual(
error.exception.message[:85],
"The responses list given to not_count() must have "
"either 1, 2 or 3 items in the form:"
)
responses_tests = [
'1',
None,
1.5,
['1'],
]
for responses in responses_tests:
# Test has version
with self.assertRaises(TypeError) as error:
func, values = has_count(responses)
self.assertEqual(
error.exception.message[:59],
"The count target given to has_count() is "
"incorrectly typed."
)
# Test not version
with self.assertRaises(TypeError) as error:
func, values = not_count(responses)
self.assertEqual(
error.exception.message[:59],
"The count target given to not_count() is "
"incorrectly typed."
)
responses_tests = [
['1', 2],
[1, '2'],
[None, 2],
[2, None],
[1.5, 2],
[1, 2.5],
[lambda x: x, 2],
[1, is_lt]
]
for responses in responses_tests:
# Test has version
with self.assertRaises(TypeError) as error:
func, values = has_count(responses)
self.assertEqual(
error.exception.message[:63],
"The values subset given to has_count() are "
"not correctly typed."
)
# Test not version
with self.assertRaises(TypeError) as error:
func, values = not_count(responses)
self.assertEqual(
error.exception.message[:63],
"The values subset given to not_count() are "
"not correctly typed."
)
values_tests = copy.copy(responses_tests)
[r.append([1, 2, 3]) for r in values_tests]
for responses in values_tests:
# Test has version
with self.assertRaises(TypeError) as error:
func, values = has_count(responses)
self.assertEqual(
error.exception.message[:63],
"The values subset given to has_count() are "
"not correctly typed."
)
# Test not version
with self.assertRaises(TypeError) as error:
func, values = not_count(responses)
self.assertEqual(
error.exception.message[:63],
"The values subset given to not_count() are "
"not correctly typed."
)
values_tests = [
[1, 2, ['1', 2, 3]],
[1, 2, [1, '2', 3]],
[1, 2, [1, 2, '3']],
[1, 2, [1.5, 2, 3]],
[1, 2, [1, 2.5, 3]],
[1, 2, [1, 2, 3.5]],
[1, 2, [None, 2, 3]],
[1, 2, [1, None, 3]],
[1, 2, [1, 2, None]],
]
for responses in values_tests:
# Test has version
with self.assertRaises(TypeError) as error:
func, values = has_count(responses)
self.assertEqual(
error.exception.message[:63],
"The values subset given to has_count() are"
" not correctly typed."
)
# Test not version
with self.assertRaises(TypeError) as error:
func, values = not_count(responses)
self.assertEqual(
error.exception.message[:63],
"The values subset given to not_count() are"
" not correctly typed."
)
def test_has_not_count(self):
# Test has versions
func, values, exclusive = has_count(1)
self.assertEqual(func, _has_count)
self.assertEqual(values, [1])
self.assertEqual(exclusive, False)
func, values, exclusive = has_count([1])
self.assertEqual(func, _has_count)
self.assertEqual(values, [1])
self.assertEqual(exclusive, False)
test_values = [1, 3]
func, values, exclusive = has_count(test_values)
self.assertEqual(func, _has_count)
self.assertEqual(values, test_values)
self.assertEqual(exclusive, False)
test_values = [1, 3, [1, 2, 3]]
func, values, exclusive = has_count(test_values)
self.assertEqual(func, _has_count)
self.assertEqual(values, test_values)
self.assertEqual(exclusive, False)
test_values = [1, 3]
func, values, exclusive = has_count(test_values)
self.assertEqual(func, _has_count)
self.assertEqual(values, test_values)
self.assertEqual(exclusive, False)
test_values = [1, 3, [1, 2, 3]]
func, values, exclusive = has_count(test_values)
self.assertEqual(func, _has_count)
self.assertEqual(values, test_values)
self.assertEqual(exclusive, False)
for op_func in [is_lt, is_le, is_eq, is_ne, is_ge, is_gt]:
test_values = [op_func(3)]
func, values, exclusive = has_count(test_values)
self.assertEqual(func, _has_count)
self.assertEqual(values, test_values)
self.assertEqual(exclusive, False)
test_values = [op_func(3), [1, 2, 3]]
func, values, exclusive = has_count(test_values)
self.assertEqual(func, _has_count)
self.assertEqual(values, test_values)
self.assertEqual(exclusive, False)
# Test not versions
func, values, exclusive = not_count(1)
self.assertEqual(func, _not_count)
self.assertEqual(values, [1])
self.assertEqual(exclusive, False)
func, values, exclusive = not_count([1])
self.assertEqual(func, _not_count)
self.assertEqual(values, [1])
self.assertEqual(exclusive, False)
test_values = [1, 3]
func, values, exclusive = not_count(test_values)
self.assertEqual(func, _not_count)
self.assertEqual(values, test_values)
self.assertEqual(exclusive, False)
test_values = [1, 3, [1, 2, 3]]
func, values, exclusive = not_count(test_values)
self.assertEqual(func, _not_count)
self.assertEqual(values, test_values)
self.assertEqual(exclusive, False)
test_values = [1, 3]
func, values, exclusive = not_count(test_values)
self.assertEqual(func, _not_count)
self.assertEqual(values, test_values)
self.assertEqual(exclusive, False)
test_values = [1, 3, [1, 2, 3]]
func, values, exclusive = not_count(test_values)
self.assertEqual(func, _not_count)
self.assertEqual(values, test_values)
self.assertEqual(exclusive, False)
for op_func in [is_lt, is_le, is_eq, is_ne, is_ge, is_gt]:
test_values = [op_func(3)]
func, values, exclusive = not_count(test_values)
self.assertEqual(func, _not_count)
self.assertEqual(values, test_values)
self.assertEqual(exclusive, False)
test_values = [op_func(3), [1, 2, 3]]
func, values, exclusive = not_count(test_values)
self.assertEqual(func, _not_count)
self.assertEqual(values, test_values)
self.assertEqual(exclusive, False)
def test_has_not_count_errors(self):
responses_tests = [
[],
[1, 2, 3, 4],
]
for responses in responses_tests:
# Test has version
with self.assertRaises(IndexError) as error:
func, values, exclusive = has_count(responses)
self.assertEqual(
error.exception.message[:85],
"The responses list given to has_count() must have "
"either 1, 2 or 3 items in the form:"
)
# Test not version
with self.assertRaises(IndexError) as error:
# Test _has_all raises TypeError
func, values, exclusive = not_count(responses)
self.assertEqual(
error.exception.message[:85],
"The responses list given to not_count() must have "
"either 1, 2 or 3 items in the form:"
)
responses_tests = [
'1',
None,
1.5,
['1'],
]
for responses in responses_tests:
# Test has version
with self.assertRaises(TypeError) as error:
func, values = has_count(responses)
self.assertEqual(
error.exception.message[:59],
"The count target given to has_count() is "
"incorrectly typed."
)
# Test not version
with self.assertRaises(TypeError) as error:
func, values = not_count(responses)
self.assertEqual(
error.exception.message[:59],
"The count target given to not_count() is "
"incorrectly typed."
)
responses_tests = [
['1', 2],
[1, '2'],
[None, 2],
[2, None],
[1.5, 2],
[1, 2.5],
[lambda x: x, 2],
[1, is_lt]
]
for responses in responses_tests:
# Test has version
with self.assertRaises(TypeError) as error:
func, values = has_count(responses)
self.assertEqual(
error.exception.message[:63],
"The values subset given to has_count() are "
"not correctly typed."
)
# Test not version
with self.assertRaises(TypeError) as error:
func, values = not_count(responses)
self.assertEqual(
error.exception.message[:63],
"The values subset given to not_count() are "
"not correctly typed."
)
values_tests = copy.copy(responses_tests)
[r.append([1, 2, 3]) for r in values_tests]
for responses in values_tests:
# Test has version
with self.assertRaises(TypeError) as error:
func, values = has_count(responses)
self.assertEqual(
error.exception.message[:63],
"The values subset given to has_count() are "
"not correctly typed."
)
# Test not version
with self.assertRaises(TypeError) as error:
func, values = not_count(responses)
self.assertEqual(
error.exception.message[:63],
"The values subset given to not_count() are "
"not correctly typed."
)
values_tests = [
[1, 2, ['1', 2, 3]],
[1, 2, [1, '2', 3]],
[1, 2, [1, 2, '3']],
[1, 2, [1.5, 2, 3]],
[1, 2, [1, 2.5, 3]],
[1, 2, [1, 2, 3.5]],
[1, 2, [None, 2, 3]],
[1, 2, [1, None, 3]],
[1, 2, [1, 2, None]],
]
for responses in values_tests:
# Test has version
with self.assertRaises(TypeError) as error:
func, values = has_count(responses)
self.assertEqual(
error.exception.message[:63],
"The values subset given to has_count() are"
" not correctly typed."
)
# Test not version
with self.assertRaises(TypeError) as error:
func, values = not_count(responses)
self.assertEqual(
error.exception.message[:63],
"The values subset given to not_count() are"
" not correctly typed."
)
def test_has_not_count(self):
# Test has versions
func, values, exclusive = has_count(1)
self.assertEqual(func, _has_count)
self.assertEqual(values, [1])
self.assertEqual(exclusive, False)
func, values, exclusive = has_count([1])
self.assertEqual(func, _has_count)
self.assertEqual(values, [1])
self.assertEqual(exclusive, False)
test_values = [1, 3]
func, values, exclusive = has_count(test_values)
self.assertEqual(func, _has_count)
self.assertEqual(values, test_values)
self.assertEqual(exclusive, False)
test_values = [1, 3, [1, 2, 3]]
func, values, exclusive = has_count(test_values)
self.assertEqual(func, _has_count)
self.assertEqual(values, test_values)
self.assertEqual(exclusive, False)
test_values = [1, 3]
func, values, exclusive = has_count(test_values)
self.assertEqual(func, _has_count)
self.assertEqual(values, test_values)
self.assertEqual(exclusive, False)
test_values = [1, 3, [1, 2, 3]]
func, values, exclusive = has_count(test_values)
self.assertEqual(func, _has_count)
self.assertEqual(values, test_values)
self.assertEqual(exclusive, False)
for op_func in [is_lt, is_le, is_eq, is_ne, is_ge, is_gt]:
test_values = [op_func(3)]
func, values, exclusive = has_count(test_values)
self.assertEqual(func, _has_count)
self.assertEqual(values, test_values)
self.assertEqual(exclusive, False)
test_values = [op_func(3), [1, 2, 3]]
func, values, exclusive = has_count(test_values)
self.assertEqual(func, _has_count)
self.assertEqual(values, test_values)
self.assertEqual(exclusive, False)
# Test not versions
func, values, exclusive = not_count(1)
self.assertEqual(func, _not_count)
self.assertEqual(values, [1])
self.assertEqual(exclusive, False)
func, values, exclusive = not_count([1])
self.assertEqual(func, _not_count)
self.assertEqual(values, [1])
self.assertEqual(exclusive, False)
test_values = [1, 3]
func, values, exclusive = not_count(test_values)
self.assertEqual(func, _not_count)
self.assertEqual(values, test_values)
self.assertEqual(exclusive, False)
test_values = [1, 3, [1, 2, 3]]
func, values, exclusive = not_count(test_values)
self.assertEqual(func, _not_count)
self.assertEqual(values, test_values)
self.assertEqual(exclusive, False)
test_values = [1, 3]
func, values, exclusive = not_count(test_values)
self.assertEqual(func, _not_count)
self.assertEqual(values, test_values)
self.assertEqual(exclusive, False)
test_values = [1, 3, [1, 2, 3]]
func, values, exclusive = not_count(test_values)
self.assertEqual(func, _not_count)
self.assertEqual(values, test_values)
self.assertEqual(exclusive, False)
for op_func in [is_lt, is_le, is_eq, is_ne, is_ge, is_gt]:
test_values = [op_func(3)]
func, values, exclusive = not_count(test_values)
self.assertEqual(func, _not_count)
self.assertEqual(values, test_values)
self.assertEqual(exclusive, False)
test_values = [op_func(3), [1, 2, 3]]
func, values, exclusive = not_count(test_values)
self.assertEqual(func, _not_count)
self.assertEqual(values, test_values)
self.assertEqual(exclusive, False)
def test_logic_list(self):
q2 = self.example_data_A_data['q2']
test_logic = union([
has_all([1, 2]),
has_any([3, 4]),
has_count([3])
])
idx, vkey = get_logic_index(q2, test_logic)
idx1, vkey1 = get_logic_index(q2, test_logic[1][0])
idx2, vkey2 = get_logic_index(q2, test_logic[1][1])
idx3, vkey3 = get_logic_index(q2, test_logic[1][2])
self.assertItemsEqual(
idx,
idx1.union(idx2).union(idx3)
)
self.assertEqual(
vkey,
'x[((1&2),(3,4),{3})]:y'
)
q2 = self.example_data_A_data['q2']
test_logic = intersection([
has_all([1, 2]),
has_any([3, 4]),
has_count([3])
])
idx, vkey = get_logic_index(q2, test_logic)
idx1, vkey1 = get_logic_index(q2, test_logic[1][0])
idx2, vkey2 = get_logic_index(q2, test_logic[1][1])
idx3, vkey3 = get_logic_index(q2, test_logic[1][2])
self.assertItemsEqual(
idx,
idx1.intersection(idx2).intersection(idx3)
)
self.assertEqual(
vkey,
'x[((1&2)&(3,4)&{3})]:y'
)
q2 = self.example_data_A_data['q2']
test_logic = difference([
has_all([1, 2]),
has_any([3, 4]),
has_count([3])
])
idx, vkey = get_logic_index(q2, test_logic)
idx1, vkey1 = get_logic_index(q2, test_logic[1][0])
idx2, vkey2 = get_logic_index(q2, test_logic[1][1])
idx3, vkey3 = get_logic_index(q2, test_logic[1][2])
self.assertItemsEqual(
idx,
idx1.difference(idx2).difference(idx3)
)
self.assertEqual(
vkey,
'x[((1&2)~(3,4)~{3})]:y'
)
q2 = self.example_data_A_data['q2']
test_logic = sym_diff([
has_all([1, 2]),
has_any([3, 4]),
has_count([3])
])
idx, vkey = get_logic_index(q2, test_logic)
idx1, vkey1 = get_logic_index(q2, test_logic[1][0])
idx2, vkey2 = get_logic_index(q2, test_logic[1][1])
idx3, vkey3 = get_logic_index(q2, test_logic[1][2])
self.assertItemsEqual(
idx,
idx1.sym_diff(idx2).sym_diff(idx3)
)
self.assertEqual(
vkey,
'x[((1&2)^(3,4)^{3})]:y'
)
