def test_weights(self):
weights = get_weights(self.answer_pattern_count)
self.assertEqual(weights, self.weights)
def test_tolerable_difference_weighted(self):
tolerance = 1
weights = get_weights(self.answer_pattern_count)
weighted_tolerance_matrix = get_tolerance_matrix(self.answer_pattern_crosstabs, tolerance, weights)
self.assertEqual(weighted_tolerance_matrix, self.weighted_tolerance_matrix)
def run_dict_diagnostics(data_dict):
#Analyzes possible answers for each field
possible_answers = diagnostic_tools.get_answers(data_dict)
#This analysis shows 4 dictionary keys associated with only 1 type of response
del_keys = diagnostic_tools.find_delete_keys(possible_answers)
#And removes these dictionary entries
data_dict = cleaning_tools.remove_single_answers(del_keys, data_dict)
#Also removes variables that will not be used in the analysis
data_dict = cleaning_tools.remove_single_answers(['numemps'], data_dict)
#Finds the answer sets for each question
possible_answers = diagnostic_tools.get_answers(data_dict)
#Counts the occurence of answer types and prints out an ordered list of them
#diagnostic_tools.count_answer_types(possible_answers)
#This analysis points out that there are three common answer types that correspond to no data.
#THese are "No answer", "Not applicable", "Don't know", and "Dont know"
#In this case note that often more than one of these answer types will appear as responses to a given question
#As a result, it will appear that the number of Nan responses is lower than it ought to be
nan_replace = ["No answer","Not applicable", "Don't know", "Dont know", "Not available","Cant choose","Can t choose","No car, dont drive"]
for answer in nan_replace:
data_dict = cleaning_tools.replace_with_nan(answer, data_dict)
#Prints new list of answers
possible_answers=diagnostic_tools.get_answers(data_dict)
#diagnostic_tools.count_answer_types(possible_answers)
#Answer types removes doubles from possible_answers
answer_types = diagnostic_tools.get_answer_types(possible_answers)
#Creates an id number for each dictionary type and places it in a dictionary with the id as the key
#and the list of responses as a value and returns answers_dict. Also creates answer_type_vars
#which makes a dictionary with the answer type id as key and a list of vars with that
#answer type as values
answers_dict, answer_type_vars = diagnostic_tools.get_var_answer_types(answer_types, possible_answers)
pp = pprint.PrettyPrinter()
pp.pprint(answers_dict)
pp.pprint(answer_type_vars)
#Creates a dictionary where the key is the variable name and the value is the id number of the answer type
#Takes in a dictionary where the keys are the id numbers and the values are lists containing questions with that question format
question_answer_map = diagnostic_tools.generate_question_answer_map(answer_type_vars)
#Recodes all data values with their numerical alternatives. Makes sure that all relevant values are recoded properly
ignore = ['topprob1','topprob2','busgrn','pubdecid','enprbfam','race','enprbus','peopgrn','sex','caremost','busdecid','age','genegen']
unmatched_dict, data_dict = dictionary_conversion.recode_data(question_answer_map, data_dict, ignore)
#Recodes all data in age to int
data_dict = dictionary_conversion.recode_to_int(data_dict,'age')
#Graphs NaNs in a question by respondent matrix
#graphics.plot_NaNs(data_dict)
#Prints the ratio of answers that are NaN for each person
#respondent_NaN_dict = diagnostic_tools.get_NaN_ratio(data_dict)
#pp.pprint(respondent_NaN_dict)
#Prints the ratio of people that didn't answer each question
#question_NaN_dict = diagnostic_tools.get_question_NaN_ratio(data_dict)
#pp.pprint(question_NaN_dict)
#Prints different types of answer patterns
answer_patterns = diagnostic_tools.answer_patterns(data_dict)
#print pp.pprint(answer_patterns)
#Counts the occurence of answer patterns in respondents
answer_patterns_count, answer_patterns_id = diagnostic_tools.count_answer_patterns(answer_patterns,data_dict)
#Creates a matrix showing how similar answer patterns are to each other
answer_patterns_matrix = diagnostic_tools.answer_pattern_crosstab(answer_patterns_id)
#Gets weights for the next function
weights = diagnostic_tools.get_weights(answer_patterns_count)
#Creates a matrix describing the number of answer patterns that are within "tolerance" of every other answer
tolerance = 15
tolerance_matrix = diagnostic_tools.get_tolerance_matrix(answer_patterns_matrix,tolerance,weights)
#print pp.pprint(tolerance_matrix)
#Determines which answer pattern is most similar to most other answer patterns
#collapsed_matrix = diagnostic_tools.collapse_tolerance_matrix(tolerance_matrix)
#print pp.pprint(collapsed_matrix)
#Filters data for data with similar answer patterns to minimize missing values
#1087 is the answer type with the most common answer types
answer_type = 1087
filtered_data_dict = cleaning_tools.filter_data_dict(data_dict, answer_type, tolerance, answer_patterns_id)
#Final function to ensure that index numbers for respondents have not changed
for respondent in filtered_data_dict:
if data_dict[respondent] != filtered_data_dict[respondent]:
print "ERROR"
else:
pass
return filtered_data_dict