def setUp(self):
self.path = './tests/'
# self.path = ''
project_name = 'Example Data (A)'
# Load Example Data (A) data and meta into self
name_data = '%s.csv' % (project_name)
path_data = '%s%s' % (self.path, name_data)
self.example_data_A_data = pd.read_csv(path_data)
self.example_data_A_data = dataframe_fix_string_types(
self.example_data_A_data)
name_meta = '%s.json' % (project_name)
path_meta = '%s%s' % (self.path, name_meta)
self.example_data_A_meta = load_json(path_meta)
# Variables by type for Example Data A
self.int = [
'record_number', 'unique_id', 'age', 'birth_day', 'birth_month'
]
self.float = ['weight', 'weight_a', 'weight_b']
self.single = ['gender', 'locality', 'ethnicity', 'religion', 'q1']
self.delimited_set = ['q2', 'q3', 'q8', 'q9']
self.string = ['q8a', 'q9a']
self.date = ['start_time', 'end_time']
self.time = ['duration']
self.array = ['q5', 'q6', 'q7']
# The minimum list of variables required to populate a stack with all single*delimited set variations
self.minimum = ['Wave', 'ethnicity', 'q2', 'gender']
# Set up the expected weight iterations
self.weights = [None, 'weight_a']
# # Set up example stack
# self.setup_stack_Example_Data_A()
# Set up the net views ViewMapper
self.net_views = ViewMapper(
template={
'method': QuantipyViews().frequency,
'kwargs': {
'axis': 'x',
'groups': ['Nets'],
'iterators': {
'rel_to': [None, 'y'],
'weights': self.weights
}
}
})
def test__custom_methods(self):
views = ViewMapper()
views.add_method('minus_x', 'x', {'key': 'value'})
views.add_method('minus_y', 'y')
views.add_method('minus_z', 'z')
for view in ['minus_x', 'minus_y', 'minus_z']:
self.assertIn(view, views._custom_methods())
for view in ['X', 'Y', 'Z']:
self.assertNotIn(view, views._custom_methods())
def test__custom_methods(self):
views = ViewMapper()
views.add_method('minus_x', 'x', {'key': 'value'})
views.add_method('minus_y', 'y')
views.add_method('minus_z', 'z')
for view in ['minus_x', 'minus_y', 'minus_z']:
self.assertIn(view, views._custom_methods())
for view in ['X', 'Y', 'Z']:
self.assertNotIn(view, views._custom_methods())
def test_add_method(self):
views = ViewMapper()
#At first there should not be method 'plus' in views
self.assertRaises(KeyError, lambda: views['plus'])
self.assertNotIn('plus', views.keys())
#Plus method added:
views.add_method('plus', lambda x: 2)
#Checked for the existance of the plus method
self.assertIsNotNone(views['plus']['method'])
self.assertIsNotNone(views['plus']['kwargs'])
self.assertIn('plus', views.keys())
#Check to see wether a method is overridden properly
views.add_method('plus', 'me')
#The method should have changed from lambda x:2 to me
self.assertEqual(views['plus']['method'], 'me')
# Check to see wether a method is overridden properly
views.add_method('minus', 'x', {'key': 'value'})
self.assertEqual(views['minus']['method'], 'x')
def setUp(self):
self.path = './tests/'
# self.path = ''
project_name = 'Example Data (A)'
# Load Example Data (A) data and meta into self
name_data = '%s.csv' % (project_name)
path_data = '%s%s' % (self.path, name_data)
self.example_data_A_data = pd.DataFrame.from_csv(path_data)
name_meta = '%s.json' % (project_name)
path_meta = '%s%s' % (self.path, name_meta)
self.example_data_A_meta = load_json(path_meta)
# Variables by type for Example Data A
self.int = ['record_number', 'unique_id', 'age', 'birth_day', 'birth_month']
self.float = ['weight', 'weight_a', 'weight_b']
self.single = ['gender', 'locality', 'ethnicity', 'religion', 'q1']
self.delimited_set = ['q2', 'q3', 'q8', 'q9']
self.string = ['q8a', 'q9a']
self.date = ['start_time', 'end_time']
self.time = ['duration']
self.array = ['q5', 'q6', 'q7']
# The minimum list of variables required to populate a stack with all single*delimited set variations
self.minimum = ['Wave', 'ethnicity', 'q2', 'gender']
# Set up the expected weight iterations
self.weights = [None, 'weight_a']
# # Set up example stack
# self.setup_stack_Example_Data_A()
# Set up the net views ViewMapper
self.net_views = ViewMapper(
template={
'method': QuantipyViews().frequency,
'kwargs': {
'axis': 'x',
'groups': ['Nets'],
'iterators': {
'rel_to': [None, 'y'],
'weights': self.weights
}
}
})
def test_add_method(self):
views = ViewMapper()
#At first there should not be method 'plus' in views
self.assertRaises(KeyError, lambda: views['plus'])
self.assertNotIn('plus', views.keys())
#Plus method added:
views.add_method('plus', lambda x: 2)
#Checked for the existance of the plus method
self.assertIsNotNone(views['plus']['method'])
self.assertIsNotNone(views['plus']['kwargs'])
self.assertIn('plus', views.keys())
#Check to see wether a method is overridden properly
views.add_method('plus', 'me')
#The method should have changed from lambda x:2 to me
self.assertEqual(views['plus']['method'], 'me')
# Check to see wether a method is overridden properly
views.add_method('minus', 'x', {'key': 'value'})
self.assertEqual(views['minus']['method'], 'x')
def get_stack(self, meta, data, xks, yks, views, weights):
stack = Stack('test')
stack.add_data('test', data, meta)
stack.add_link(x=xks, y=yks, views=views, weights=weights)
# Add two basic net
net_views = ViewMapper(
template={
'method': QuantipyViews().frequency,
'kwargs': {
'iterators': {
'rel_to': [None, 'y']
}
}
})
net_views.add_method(name='Net 1-3',
kwargs={
'logic': [1, 2, 3],
'axis': 'x',
'text': {
'en-GB': '1-3'
}
})
net_views.add_method(name='Net 4-6',
kwargs={
'logic': [4, 5, 6],
'axis': 'x',
'text': {
'en-GB': '4-6'
}
})
stack.add_link(x=xks, y=yks, views=net_views, weights=weights)
# Add block net
net_views.add_method(name='Block net',
kwargs={
'logic': [{
'bn1': [1, 2]
}, {
'bn2': [2, 3]
}, {
'bn3': [1, 3]
}],
'axis':
'x'
})
stack.add_link(x=xks,
y=yks,
views=net_views.subset(['Block net']),
weights=weights)
# Add NPS
## TO DO
# Add standard deviation
desc_views = ViewMapper(
template={
'method': QuantipyViews().descriptives,
'kwargs': {
'axis': 'x',
'iterators': {
'stats': ['mean', 'median', 'stddev']
}
}
})
desc_views.add_method(name='descriptives')
stack.add_link(x=xks, y=yks, views=desc_views, weights=weights)
# Add tests
test_views = ViewMapper(
template={
'method': QuantipyViews().coltests,
'kwargs': {
'mimic': 'askia',
'iterators': {
'metric': ['props', 'means'],
'level': ['low', 'mid', 'high']
}
}
})
test_views.add_method('askia tests')
stack.add_link(x=xks, y=yks, views=test_views, weights=weights)
return stack
class TestViewObject(unittest.TestCase):
def setUp(self):
self.path = './tests/'
# self.path = ''
project_name = 'Example Data (A)'
# Load Example Data (A) data and meta into self
name_data = '%s.csv' % (project_name)
path_data = '%s%s' % (self.path, name_data)
self.example_data_A_data = pd.DataFrame.from_csv(path_data)
name_meta = '%s.json' % (project_name)
path_meta = '%s%s' % (self.path, name_meta)
self.example_data_A_meta = load_json(path_meta)
# Variables by type for Example Data A
self.int = [
'record_number', 'unique_id', 'age', 'birth_day', 'birth_month'
]
self.float = ['weight', 'weight_a', 'weight_b']
self.single = ['gender', 'locality', 'ethnicity', 'religion', 'q1']
self.delimited_set = ['q2', 'q3', 'q8', 'q9']
self.string = ['q8a', 'q9a']
self.date = ['start_time', 'end_time']
self.time = ['duration']
self.array = ['q5', 'q6', 'q7']
# The minimum list of variables required to populate a stack with all single*delimited set variations
self.minimum = ['Wave', 'ethnicity', 'q2', 'gender']
# Set up the expected weight iterations
self.weights = [None, 'weight_a']
# # Set up example stack
# self.setup_stack_Example_Data_A()
# Set up the net views ViewMapper
self.net_views = ViewMapper(
template={
'method': QuantipyViews().frequency,
'kwargs': {
'axis': 'x',
'groups': ['Nets'],
'iterators': {
'rel_to': [None, 'y'],
'weights': self.weights
}
}
})
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 verify_net_values_single_x(self, stack, xk, yks, values, relation,
method_name):
dk = 'Example Data (A)'
fk = 'no_filter'
dvk = 'x|default|:|||default'
dvkw = 'x|default|:||weight_a|default'
for yk in yks:
if yk == '@':
yk = xk
# Get comparison figures
def_df = stack[dk][fk][xk][yk][dvk].dataframe[yk]
defw_df = stack[dk][fk][xk][yk][dvkw].dataframe[yk]
# Get the figures to be tested
vk = 'x|f|%s|||%s' % (relation, method_name)
vkw = 'x|f|%s||weight_a|%s' % (relation, method_name)
df = stack[dk][fk][xk][yk][vk].dataframe[yk]
dfw = stack[dk][fk][xk][yk][vkw].dataframe[yk]
# Verify all crosstab net figures
for y_val in def_df.columns.intersection(df.columns):
net = 0
netw = 0
for x_val in values:
net += def_df.xs([xk, x_val])[y_val]
netw += defw_df.xs([xk, x_val])[y_val]
# if np.round(net, 10) != np.round(df.xs([xk, method_name])[y_val], 10):
# print ''
self.assertTrue(
np.allclose(net,
df.xs([xk, method_name])[y_val]))
self.assertTrue(
np.allclose(netw,
dfw.xs([xk, method_name])[y_val]))
def setup_stack_Example_Data_A(self, **kwargs):
self.stack = self.get_stack_Example_Data_A(**kwargs)
def get_stack_Example_Data_A(self,
name=None,
fk=None,
xk=None,
yk=None,
views=None,
weights=None):
if name is None:
name = 'Example Data (A)'
if fk is None:
fk = ['no_filter']
if xk is None:
xk = self.minimum
if yk is None:
yk = ['@'] + self.minimum
if views is None:
views = ['default', 'counts']
if weights is None:
weights = self.weights
stack = Stack(name=name)
stack.add_data(data_key=stack.name,
meta=self.example_data_A_meta,
data=self.example_data_A_data)
for weight in weights:
stack.add_link(data_keys=stack.name,
filters=fk,
x=xk,
y=yk,
views=QuantipyViews(views),
weights=weights)
return stack
class TestViewObject(unittest.TestCase):
def setUp(self):
self.path = './tests/'
# self.path = ''
project_name = 'Example Data (A)'
# Load Example Data (A) data and meta into self
name_data = '%s.csv' % (project_name)
path_data = '%s%s' % (self.path, name_data)
self.example_data_A_data = pd.DataFrame.from_csv(path_data)
name_meta = '%s.json' % (project_name)
path_meta = '%s%s' % (self.path, name_meta)
self.example_data_A_meta = load_json(path_meta)
# Variables by type for Example Data A
self.int = ['record_number', 'unique_id', 'age', 'birth_day', 'birth_month']
self.float = ['weight', 'weight_a', 'weight_b']
self.single = ['gender', 'locality', 'ethnicity', 'religion', 'q1']
self.delimited_set = ['q2', 'q3', 'q8', 'q9']
self.string = ['q8a', 'q9a']
self.date = ['start_time', 'end_time']
self.time = ['duration']
self.array = ['q5', 'q6', 'q7']
# The minimum list of variables required to populate a stack with all single*delimited set variations
self.minimum = ['Wave', 'ethnicity', 'q2', 'gender']
# Set up the expected weight iterations
self.weights = [None, 'weight_a']
# # Set up example stack
# self.setup_stack_Example_Data_A()
# Set up the net views ViewMapper
self.net_views = ViewMapper(
template={
'method': QuantipyViews().frequency,
'kwargs': {
'axis': 'x',
'groups': ['Nets'],
'iterators': {
'rel_to': [None, 'y'],
'weights': self.weights
}
}
})
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 verify_net_values_single_x(self, stack, xk, yks, values, relation, method_name):
dk = 'Example Data (A)'
fk = 'no_filter'
dvk = 'x|default|x:y|||default'
dvkw = 'x|default|x:y||weight_a|default'
for yk in yks:
if yk == '@':
yk = xk
# Get comparison figures
def_df = stack[dk][fk][xk][yk][dvk].dataframe[yk]
defw_df = stack[dk][fk][xk][yk][dvkw].dataframe[yk]
# Get the figures to be tested
vk = 'x|frequency|%s|||%s' % (relation, method_name)
vkw = 'x|frequency|%s||weight_a|%s' % (relation, method_name)
df = stack[dk][fk][xk][yk][vk].dataframe[yk]
dfw = stack[dk][fk][xk][yk][vkw].dataframe[yk]
# Verify all crosstab net figures
for y_val in def_df.columns.intersection(df.columns):
net = 0
netw = 0
for x_val in values:
net += def_df.xs([xk, x_val])[y_val]
netw += defw_df.xs([xk, x_val])[y_val]
# if np.round(net, 10) != np.round(df.xs([xk, method_name])[y_val], 10):
# print ''
self.assertTrue(
np.allclose(net, df.xs([xk, method_name])[y_val])
)
self.assertTrue(
np.allclose(netw, dfw.xs([xk, method_name])[y_val])
)
def setup_stack_Example_Data_A(self, **kwargs):
self.stack = self.get_stack_Example_Data_A(**kwargs)
def get_stack_Example_Data_A(self, name=None, fk=None, xk=None, yk=None, views=None, weights=None):
if name is None:
name = 'Example Data (A)'
if fk is None:
fk = ['no_filter']
if xk is None:
xk = self.minimum
if yk is None:
yk = ['@'] + self.minimum
if views is None:
views = ['default', 'counts']
if weights is None:
weights = self.weights
stack = Stack(name=name)
stack.add_data(
data_key=stack.name,
meta=self.example_data_A_meta,
data=self.example_data_A_data
)
for weight in weights:
stack.add_link(
data_keys=stack.name,
filters=fk,
x=xk,
y=yk,
views=QuantipyViews(views),
weights=weights
)
return stack
def test_iterations_object(self):
# Set up path to example files
path_tests = self.path
project_name = 'Example Data (A)'
# Load Example Data (A) data and meta
name_data = '%s.csv' % (project_name)
path_data = '%s%s' % (path_tests, name_data)
example_data_A_data = pd.DataFrame.from_csv(path_data)
name_meta = '%s.json' % (project_name)
path_meta = '%s%s' % (path_tests, name_meta)
example_data_A_meta = load_json(path_meta)
# Variables by type for Example Data A
eda_int = ['record_number', 'unique_id', 'age', 'birth_day', 'birth_month']
eda_float = ['weight', 'weight_a', 'weight_b']
eda_single = ['gender', 'locality', 'ethnicity', 'religion', 'q1']
eda_delimited_set = ['q2', 'q3', 'q8', 'q9']
eda_string = ['q8a', 'q9a']
eda_date = ['start_time', 'end_time']
eda_time = ['duration']
eda_array = ['q5', 'q6', 'q7']
eda_minimum = ['q2b', 'Wave', 'q2', 'q3', 'q5_1']
# Create basic stack
stack = Stack(name=project_name)
stack.add_data(project_name, example_data_A_data, example_data_A_meta)
stack.add_link(
data_keys=project_name,
filters=['no_filter'],
x=eda_minimum,
y=['@'],
views=QuantipyViews(['default', 'cbase', 'counts', 'c%']),
weights=[None, 'weight_a', 'weight_b']
)
# Get list of views created
views_present = stack.describe(index=['view'])
# Test that weighted an unweighted versions of all basic views
# were created
self.assertIn('x|default|x:y|||default', views_present)
self.assertIn('x|default|x:y||weight_a|default', views_present)
self.assertIn('x|default|x:y||weight_b|default', views_present)
self.assertIn('x|frequency|x:y|||cbase', views_present)
self.assertIn('x|frequency|x:y||weight_a|cbase', views_present)
self.assertIn('x|frequency|x:y||weight_b|cbase', views_present)
self.assertIn('x|frequency||y||c%', views_present)
self.assertIn('x|frequency||y|weight_a|c%', views_present)
self.assertIn('x|frequency||y|weight_b|c%', views_present)
self.assertIn('x|frequency||||counts', views_present)
self.assertIn('x|frequency|||weight_a|counts', views_present)
self.assertIn('x|frequency|||weight_b|counts', views_present)
# Create a ViewMapper using the iterator object in a template
xnets = ViewMapper(
template={
'method': QuantipyViews().frequency,
'kwargs': {
'axis': 'x',
'groups': ['Nets'],
'iterators': {
'rel_to': [None, 'y'],
'weights': [None, 'weight_a']
}
}
})
# Add a method to the xnets ViewMapper, then use it to generate additional
# views which include N/c% and unweighted/weighted
xnets.add_method(name='ever', kwargs={'text': 'Ever', 'logic': [1, 2]})
stack.add_link(x='q2b', y=['@'], views=xnets.subset(['ever']))
# Get list of views created
views_present = stack.describe(index=['view'])
# Test that the expected views were all created
self.assertIn('x|frequency|x[(1,2)]:y|||ever', views_present)
self.assertIn('x|frequency|x[(1,2)]:y|y||ever', views_present)
self.assertIn('x|frequency|x[(1,2)]:y||weight_a|ever', views_present)
self.assertIn('x|frequency|x[(1,2)]:y|y|weight_a|ever', views_present)
# Add another method to the xnets ViewMapper, but then override the weights
# in the iterator object using the stack.add_link(weights) parameter
stack.add_link(x='q2b', y=['@'], views=xnets.subset(['ever']), weights='weight_b')
# Get list of views created
views_present = stack.describe(index=['view'])
# Test that the expected views were all created
self.assertIn('x|frequency|x[(1,2)]:y||weight_b|ever', views_present)
self.assertIn('x|frequency|x[(1,2)]:y|y|weight_b|ever', views_present)
# Add two methods and apply them at the same time, make sure all expected iterations
# of both were created
xnets.add_method(name='ever (multi test)', kwargs={'text': 'Ever', 'logic': [1, 2]})
xnets.add_method(name='never (multi test)', kwargs={'text': 'Never', 'logic': [2, 3]})
stack.add_link(x='q2b', y=['@'], views=xnets.subset(['ever (multi test)', 'never (multi test)']))
# Get list of views created
views_present = stack.describe(index=['view'])
# Test that the expected views were all created
self.assertIn('x|frequency|x[(1,2)]:y|||ever (multi test)', views_present)
self.assertIn('x|frequency|x[(1,2)]:y|y||ever (multi test)', views_present)
self.assertIn('x|frequency|x[(1,2)]:y||weight_a|ever (multi test)', views_present)
self.assertIn('x|frequency|x[(1,2)]:y|y|weight_a|ever (multi test)', views_present)
self.assertIn('x|frequency|x[(2,3)]:y|||never (multi test)', views_present)
self.assertIn('x|frequency|x[(2,3)]:y|y||never (multi test)', views_present)
self.assertIn('x|frequency|x[(2,3)]:y||weight_a|never (multi test)', views_present)
self.assertIn('x|frequency|x[(2,3)]:y|y|weight_a|never (multi test)', views_present)
# Add two methods and apply them at the same time, make sure all expected iterations
# of both were created, in this case that the weights arg for stack.add_link() overrides
# what the iterator object is asking for
xnets.add_method(name='ever (weights test)', kwargs={'text': 'Ever', 'logic': [1, 2]})
xnets.add_method(name='never (weights test)', kwargs={'text': 'Never', 'logic': [2, 3]})
stack.add_link(
x='q2b', y=['@'],
views=xnets.subset(['ever (weights test)', 'never (weights test)']),
weights=['weight_b']
)
# Get list of views created
views_present = stack.describe(index=['view'])
# Test that the expected views were all created
self.assertNotIn('x|frequency|x[(1,2)]:y|||ever (weights test)', views_present)
self.assertNotIn('x|frequency|x[(1,2)]:y|y||ever (weights test)', views_present)
self.assertIn('x|frequency|x[(1,2)]:y||weight_b|ever (weights test)', views_present)
self.assertIn('x|frequency|x[(1,2)]:y|y|weight_b|ever (weights test)', views_present)
self.assertNotIn('x|frequency|x[(2,3)]:y|||never (weights test)', views_present)
self.assertNotIn('x|frequency|x[(2,3)]:y|y||never (weights test)', views_present)
self.assertIn('x|frequency|x[(2,3)]:y||weight_b|never (weights test)', views_present)
self.assertIn('x|frequency|x[(2,3)]:y|y|weight_b|never (weights test)', views_present)
def test_iterations_object(self):
# Set up path to example files
path_tests = self.path
project_name = 'Example Data (A)'
# Load Example Data (A) data and meta
name_data = '%s.csv' % (project_name)
path_data = '%s%s' % (path_tests, name_data)
example_data_A_data = pd.DataFrame.from_csv(path_data)
name_meta = '%s.json' % (project_name)
path_meta = '%s%s' % (path_tests, name_meta)
example_data_A_meta = load_json(path_meta)
# Variables by type for Example Data A
eda_int = [
'record_number', 'unique_id', 'age', 'birth_day', 'birth_month'
]
eda_float = ['weight', 'weight_a', 'weight_b']
eda_single = ['gender', 'locality', 'ethnicity', 'religion', 'q1']
eda_delimited_set = ['q2', 'q3', 'q8', 'q9']
eda_string = ['q8a', 'q9a']
eda_date = ['start_time', 'end_time']
eda_time = ['duration']
eda_array = ['q5', 'q6', 'q7']
eda_minimum = ['q2b', 'Wave', 'q2', 'q3', 'q5_1']
# Create basic stack
stack = Stack(name=project_name)
stack.add_data(project_name, example_data_A_data, example_data_A_meta)
stack.add_link(data_keys=project_name,
filters=['no_filter'],
x=eda_minimum,
y=['@'],
views=QuantipyViews(
['default', 'cbase', 'counts', 'c%']),
weights=[None, 'weight_a', 'weight_b'])
# Get list of views created
views_present = stack.describe(index=['view'])
# Test that weighted an unweighted versions of all basic views
# were created
self.assertIn('x|default|x:y|||default', views_present)
self.assertIn('x|default|x:y||weight_a|default', views_present)
self.assertIn('x|default|x:y||weight_b|default', views_present)
self.assertIn('x|frequency|x:y|||cbase', views_present)
self.assertIn('x|frequency|x:y||weight_a|cbase', views_present)
self.assertIn('x|frequency|x:y||weight_b|cbase', views_present)
self.assertIn('x|frequency||y||c%', views_present)
self.assertIn('x|frequency||y|weight_a|c%', views_present)
self.assertIn('x|frequency||y|weight_b|c%', views_present)
self.assertIn('x|frequency||||counts', views_present)
self.assertIn('x|frequency|||weight_a|counts', views_present)
self.assertIn('x|frequency|||weight_b|counts', views_present)
# Create a ViewMapper using the iterator object in a template
xnets = ViewMapper(
template={
'method': QuantipyViews().frequency,
'kwargs': {
'axis': 'x',
'groups': ['Nets'],
'iterators': {
'rel_to': [None, 'y'],
'weights': [None, 'weight_a']
}
}
})
# Add a method to the xnets ViewMapper, then use it to generate additional
# views which include N/c% and unweighted/weighted
xnets.add_method(name='ever', kwargs={'text': 'Ever', 'logic': [1, 2]})
stack.add_link(x='q2b', y=['@'], views=xnets.subset(['ever']))
# Get list of views created
views_present = stack.describe(index=['view'])
# Test that the expected views were all created
self.assertIn('x|frequency|x[(1,2)]:y|||ever', views_present)
self.assertIn('x|frequency|x[(1,2)]:y|y||ever', views_present)
self.assertIn('x|frequency|x[(1,2)]:y||weight_a|ever', views_present)
self.assertIn('x|frequency|x[(1,2)]:y|y|weight_a|ever', views_present)
# Add another method to the xnets ViewMapper, but then override the weights
# in the iterator object using the stack.add_link(weights) parameter
stack.add_link(x='q2b',
y=['@'],
views=xnets.subset(['ever']),
weights='weight_b')
# Get list of views created
views_present = stack.describe(index=['view'])
# Test that the expected views were all created
self.assertIn('x|frequency|x[(1,2)]:y||weight_b|ever', views_present)
self.assertIn('x|frequency|x[(1,2)]:y|y|weight_b|ever', views_present)
# Add two methods and apply them at the same time, make sure all expected iterations
# of both were created
xnets.add_method(name='ever (multi test)',
kwargs={
'text': 'Ever',
'logic': [1, 2]
})
xnets.add_method(name='never (multi test)',
kwargs={
'text': 'Never',
'logic': [2, 3]
})
stack.add_link(x='q2b',
y=['@'],
views=xnets.subset(
['ever (multi test)', 'never (multi test)']))
# Get list of views created
views_present = stack.describe(index=['view'])
# Test that the expected views were all created
self.assertIn('x|frequency|x[(1,2)]:y|||ever (multi test)',
views_present)
self.assertIn('x|frequency|x[(1,2)]:y|y||ever (multi test)',
views_present)
self.assertIn('x|frequency|x[(1,2)]:y||weight_a|ever (multi test)',
views_present)
self.assertIn('x|frequency|x[(1,2)]:y|y|weight_a|ever (multi test)',
views_present)
self.assertIn('x|frequency|x[(2,3)]:y|||never (multi test)',
views_present)
self.assertIn('x|frequency|x[(2,3)]:y|y||never (multi test)',
views_present)
self.assertIn('x|frequency|x[(2,3)]:y||weight_a|never (multi test)',
views_present)
self.assertIn('x|frequency|x[(2,3)]:y|y|weight_a|never (multi test)',
views_present)
# Add two methods and apply them at the same time, make sure all expected iterations
# of both were created, in this case that the weights arg for stack.add_link() overrides
# what the iterator object is asking for
xnets.add_method(name='ever (weights test)',
kwargs={
'text': 'Ever',
'logic': [1, 2]
})
xnets.add_method(name='never (weights test)',
kwargs={
'text': 'Never',
'logic': [2, 3]
})
stack.add_link(x='q2b',
y=['@'],
views=xnets.subset(
['ever (weights test)', 'never (weights test)']),
weights=['weight_b'])
# Get list of views created
views_present = stack.describe(index=['view'])
# Test that the expected views were all created
self.assertNotIn('x|frequency|x[(1,2)]:y|||ever (weights test)',
views_present)
self.assertNotIn('x|frequency|x[(1,2)]:y|y||ever (weights test)',
views_present)
self.assertIn('x|frequency|x[(1,2)]:y||weight_b|ever (weights test)',
views_present)
self.assertIn('x|frequency|x[(1,2)]:y|y|weight_b|ever (weights test)',
views_present)
self.assertNotIn('x|frequency|x[(2,3)]:y|||never (weights test)',
views_present)
self.assertNotIn('x|frequency|x[(2,3)]:y|y||never (weights test)',
views_present)
self.assertIn('x|frequency|x[(2,3)]:y||weight_b|never (weights test)',
views_present)
self.assertIn('x|frequency|x[(2,3)]:y|y|weight_b|never (weights test)',
views_present)
