def test_get_view_iterations(self):
views = QuantipyViews(['default'])
iterators = {'A': [1, 2], 'B': [3, 4, 5], 'C': [6, 7, 8, 9]}
iterations = views.__get_view_iterations__(iterators)
# Test that iterations has the anticipated number of items
# It should be the multiplication of the len of all of
# iterators lists, in this case 2x3x4=24
self.assertEqual(len(iterations), 24)
self.assertEqual(iterations[0], {'A': 1, 'B': 3, 'C': 6})
self.assertEqual(iterations[1], {'A': 1, 'B': 4, 'C': 6})
self.assertEqual(iterations[2], {'A': 1, 'B': 5, 'C': 6})
self.assertEqual(iterations[3], {'A': 1, 'B': 3, 'C': 7})
self.assertEqual(iterations[4], {'A': 1, 'B': 4, 'C': 7})
self.assertEqual(iterations[5], {'A': 1, 'B': 5, 'C': 7})
self.assertEqual(iterations[6], {'A': 1, 'B': 3, 'C': 8})
self.assertEqual(iterations[7], {'A': 1, 'B': 4, 'C': 8})
self.assertEqual(iterations[8], {'A': 1, 'B': 5, 'C': 8})
self.assertEqual(iterations[9], {'A': 1, 'B': 3, 'C': 9})
self.assertEqual(iterations[10], {'A': 1, 'B': 4, 'C': 9})
self.assertEqual(iterations[11], {'A': 1, 'B': 5, 'C': 9})
self.assertEqual(iterations[12], {'A': 2, 'B': 3, 'C': 6})
self.assertEqual(iterations[13], {'A': 2, 'B': 4, 'C': 6})
self.assertEqual(iterations[14], {'A': 2, 'B': 5, 'C': 6})
self.assertEqual(iterations[15], {'A': 2, 'B': 3, 'C': 7})
self.assertEqual(iterations[16], {'A': 2, 'B': 4, 'C': 7})
self.assertEqual(iterations[17], {'A': 2, 'B': 5, 'C': 7})
self.assertEqual(iterations[18], {'A': 2, 'B': 3, 'C': 8})
self.assertEqual(iterations[19], {'A': 2, 'B': 4, 'C': 8})
self.assertEqual(iterations[20], {'A': 2, 'B': 5, 'C': 8})
self.assertEqual(iterations[21], {'A': 2, 'B': 3, 'C': 9})
self.assertEqual(iterations[22], {'A': 2, 'B': 4, 'C': 9})
self.assertEqual(iterations[23], {'A': 2, 'B': 5, 'C': 9})
def test_get_view_iterations(self):
views = QuantipyViews(['default'])
iterators = {'A': [1, 2], 'B': [3, 4, 5], 'C': [6, 7, 8, 9]}
iterations = views.__get_view_iterations__(iterators)
# Test that iterations has the anticipated number of items
# It should be the multiplication of the len of all of
# iterators lists, in this case 2x3x4=24
self.assertEqual(len(iterations), 24)
self.assertEqual(iterations[0], {'A': 1, 'B': 3, 'C': 6})
self.assertEqual(iterations[1], {'A': 1, 'B': 4, 'C': 6})
self.assertEqual(iterations[2], {'A': 1, 'B': 5, 'C': 6})
self.assertEqual(iterations[3], {'A': 1, 'B': 3, 'C': 7})
self.assertEqual(iterations[4], {'A': 1, 'B': 4, 'C': 7})
self.assertEqual(iterations[5], {'A': 1, 'B': 5, 'C': 7})
self.assertEqual(iterations[6], {'A': 1, 'B': 3, 'C': 8})
self.assertEqual(iterations[7], {'A': 1, 'B': 4, 'C': 8})
self.assertEqual(iterations[8], {'A': 1, 'B': 5, 'C': 8})
self.assertEqual(iterations[9], {'A': 1, 'B': 3, 'C': 9})
self.assertEqual(iterations[10], {'A': 1, 'B': 4, 'C': 9})
self.assertEqual(iterations[11], {'A': 1, 'B': 5, 'C': 9})
self.assertEqual(iterations[12], {'A': 2, 'B': 3, 'C': 6})
self.assertEqual(iterations[13], {'A': 2, 'B': 4, 'C': 6})
self.assertEqual(iterations[14], {'A': 2, 'B': 5, 'C': 6})
self.assertEqual(iterations[15], {'A': 2, 'B': 3, 'C': 7})
self.assertEqual(iterations[16], {'A': 2, 'B': 4, 'C': 7})
self.assertEqual(iterations[17], {'A': 2, 'B': 5, 'C': 7})
self.assertEqual(iterations[18], {'A': 2, 'B': 3, 'C': 8})
self.assertEqual(iterations[19], {'A': 2, 'B': 4, 'C': 8})
self.assertEqual(iterations[20], {'A': 2, 'B': 5, 'C': 8})
self.assertEqual(iterations[21], {'A': 2, 'B': 3, 'C': 9})
self.assertEqual(iterations[22], {'A': 2, 'B': 4, 'C': 9})
self.assertEqual(iterations[23], {'A': 2, 'B': 5, 'C': 9})
def setup_stack_Example_Data_A(self,
fk=None,
xk=None,
yk=None,
views=None,
weights=None):
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', 'cbase', 'counts', 'c%']
if not isinstance(weights, list):
weights = [weights]
self.stack = Stack(name="Example Data (A)")
self.stack.add_data(data_key=self.stack.name,
meta=self.example_data_A_meta,
data=self.example_data_A_data)
for weight in weights:
self.stack.add_link(data_keys=self.stack.name,
filters=fk,
x=xk,
y=yk,
views=QuantipyViews(views),
weights=weight)
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__get_method_types(self):
#not checked - time & string - need to implemented
#examples: time - "endtime"
# string - "name"
views = QuantipyViews(['default'])
self.stack.add_link(data_keys="Jan",
x=self.x_names,
y=self.y_names,
views=views)
for x_type, x_name in zip(self.x_types, self.x_names):
link = self.stack['Jan']['no_filter'][x_name]['profile_gender']
self.assertEqual(x_type, views._get_method_types(link)[0])
def test__get_method_types(self):
#not checked - time & string - need to implemented
#examples: time - "endtime"
# string - "name"
views = QuantipyViews(['default'])
self.stack.add_link(data_keys="Jan",
x=self.x_names,
y=self.y_names,
views=views)
for x_type, x_name in zip(self.x_types, self.x_names):
link = self.stack['Jan']['no_filter'][x_name]['profile_gender']
self.assertEqual(x_type, views._get_method_types(link)[0])
def test__apply_to(self):
#not checked - time & string - need to implemented
#examples: time - "endtime"
# string - "name"
views = QuantipyViews(['cbase', 'counts', 'mean'])
# This matches the view method names to their resulting view key
# based on the new view notation
notation = {
'default': 'x|default|x:y|||default',
'cbase': 'x|frequency|x:y|||cbase',
'counts': 'x|frequency||||counts',
'mean': 'x|mean|x:y|||mean'
}
x_names = ['profile_gender', 'age_group', 'q4']
y_names = x_names
self.stack.add_link(data_keys="Jan", x=x_names, y=y_names)
for a_x in self.stack['Jan']['no_filter'].keys():
for a_y in self.stack['Jan']['no_filter'][a_x].keys():
link = self.stack['Jan']['no_filter'][a_x][a_y]
if not link.y == "@":
views._apply_to(link)
for view in views.keys():
for a_x in self.stack['Jan']['no_filter'].keys():
for a_y in self.stack['Jan']['no_filter'][a_x].keys():
if views[view]['method'] == 'descriptives':
if a_x == 'q4':
self.assertNotIn(
notation[view], self.stack['Jan']['no_filter']
[a_x][a_y].keys())
else:
self.assertIn(
notation[view], self.stack['Jan']['no_filter']
[a_x][a_y].keys())
else:
self.assertIn(
notation[view],
self.stack['Jan']['no_filter'][a_x][a_y].keys())
def test__apply_to(self):
#not checked - time & string - need to implemented
#examples: time - "endtime"
# string - "name"
views = QuantipyViews(['cbase', 'counts', 'mean'])
# This matches the view method names to their resulting view key
# based on the new view notation
notation = {
'default': 'x|default|x:y|||default',
'cbase': 'x|frequency|x:y|||cbase',
'counts': 'x|frequency||||counts',
'mean': 'x|mean|x:y|||mean'
}
x_names = ['profile_gender', 'age_group', 'q4']
y_names = x_names
self.stack.add_link(data_keys="Jan",
x=x_names,
y=y_names)
for a_x in self.stack['Jan']['no_filter'].keys():
for a_y in self.stack['Jan']['no_filter'][a_x].keys():
link = self.stack['Jan']['no_filter'][a_x][a_y]
if not link.y == "@":
views._apply_to(link)
for view in views.keys():
for a_x in self.stack['Jan']['no_filter'].keys():
for a_y in self.stack['Jan']['no_filter'][a_x].keys():
if views[view]['method'] == 'descriptives':
if a_x == 'q4':
self.assertNotIn(notation[view], self.stack['Jan']['no_filter'][a_x][a_y].keys())
else:
self.assertIn(notation[view], self.stack['Jan']['no_filter'][a_x][a_y].keys())
else:
self.assertIn(notation[view], self.stack['Jan']['no_filter'][a_x][a_y].keys())
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 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
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)
