def test_exception_on_standard_verify(self): ''' Test that sandbox geni is not fixed ''' try: profile.profile("1149101") assert (False) except: assert (True)
def test_creating_a_child(self): ''' Test creation of a child profile ''' child_profile = gen_profile(ACTUAL_NAME, FATHER_SURNAME) child_profile.setCheckedGender("M") child_profile.set_name_2_show(ACTUAL_NAME) child_profile.setCheckedDate("birth_date", date(2017, 11, 20), "ABOUT") child_profile.setCheckedDate("death_date", date(2017, 12, 1), "EXACT") child_profile.add_nickname("my_nickname") profile.profile.create_as_a_child(child_profile, union=UNION_MAIN_PROFILE) data_id = child_profile.geni_specific_data['guid'] assert (child_profile.properly_executed) assert (child_profile.existing_in_geni) #Check input of data assert (child_profile.data["gender"] == "male") assert (child_profile.data["last_name"] == FATHER_SURNAME) #Checking dates assert (child_profile.data["birth"]["date"]["year"] == 2017) assert (child_profile.data["birth"]["date"]["circa"] == True) self.assertFalse("month" in child_profile.data["birth"]["date"].keys()) assert (child_profile.data["death"]["date"]["year"] == 2017) assert (child_profile.data["death"]["date"]["month"] == 12) assert (child_profile.data["death"]["date"]["day"] == 1) assert (child_profile.data["public"] == False) assert ("my_nickname" in child_profile.data["nicknames"]) prof_relations = profile.profile(MAIN_SANDBOX_PROFILE, type_geni="") assert (len(prof_relations.marriage_union) == 1) for dif_union in prof_relations.marriage_union: assert ("union-156" in dif_union.union_id) for dif_union in prof_relations.parent_union: assert ("union-155" in dif_union.union_id) #We introduce other 2 childs using different methods second_profile = gen_profile(ACTUAL_SECOND, FATHER_SURNAME) profile.profile.create_as_a_child(second_profile, profile=prof_relations) third_profile = gen_profile(ACTUAL_THIRD, FATHER_SURNAME) profile.profile.create_as_a_child(third_profile, geni_input=MAIN_SANDBOX_PROFILE, type_geni="") assert (second_profile.properly_executed) assert (third_profile.properly_executed) #We delete to avoid creation of data assert (child_profile.delete_profile()) assert (second_profile.delete_profile()) assert (third_profile.delete_profile()) self.assertFalse(child_profile.existing_in_geni) #We check is deleted existing = profile.profile(data_id) assert (existing.geni_specific_data['deleted'])
def test_different_geni_inptus(self): ''' Test different Geni inputs to profile ''' prof = profile.profile(SANDBOX_MAIN_ADDRESS) prof2 = profile.profile(SANDBOX_MAIN_API_G) prof3 = profile.profile(SANDBOX_MAIN_API_NOG) assert (prof.geni_specific_data["id"] == MAIN_SANDBOX_PROFILE_ID) assert (prof2.geni_specific_data["id"] == MAIN_SANDBOX_PROFILE_ID) assert (prof3.geni_specific_data["id"] == MAIN_SANDBOX_PROFILE_ID)
def create_profiles_in_Geni(self, geni_data): ''' This method will create the needed profiles directly in Geni ''' if not self.correct_execution: logging.error(NO_GENI_EXECUTION) return False else: connector = geni_calls() valid = connector.check_valid_genikey() if not valid: #Ok, it appears the call is not correct and we are getting an error message logging.error(NO_GENI_KEY) return False else: parent_data = profile.profile(geni_input=geni_data) other_parent = None #We only make it for a single partner if len(parent_data.partner) == 1: other_parent = profile.profile(geni_input=parent_data.partner[0]) #We need to understand if it is mother of father, and then the logic diverts if (parent_data.gen_data["gender"] == "M"): self.father_profile.merge_profile(parent_data, language = self.language, convention = self.naming_convention) if other_parent: self.mother_profile.merge_profile(other_parent, language = self.language, convention = self.naming_convention) else: self.mother_profile.merge_profile(parent_data, language = self.language, convention = self.naming_convention) if other_parent: self.father_profile.merge_profile(other_parent, language = self.language, convention = self.naming_convention) #Once parents have been read, we proceed to create the profiles. for profile_obtained in self.profiles: logging.info(profile_obtained.returnFullName()) profile.profile.create_as_a_child(profile_obtained, geni_input=geni_data ) self.geni_profiles.append(profile_obtained) logging.info(profile_obtained.geni_specific_data["url"]) if profile_obtained.gen_data.get("marriage_link", None) in self.related_profiles.keys(): id_of_marriage = profile_obtained.gen_data["marriage_link"] partner = self.related_profiles[id_of_marriage] profile.profile.create_as_a_partner(partner, geni_input=profile_obtained.geni_specific_data["id"], type_geni="" ) self.related_geni_profiles.append(partner) logging.info(partner.geni_specific_data["url"]) if id_of_marriage in self.parents_profiles.keys(): father = self.parents_profiles[id_of_marriage][0] mother = self.parents_profiles[id_of_marriage][1] profile.profile.create_as_a_parent(father, geni_input=partner.geni_specific_data["id"], type_geni="" ) profile.profile.create_as_a_parent(mother, geni_input=partner.geni_specific_data["id"], type_geni="" ) self.parents_geni_profiles.append(father) self.parents_geni_profiles.append(mother) logging.info(ENDED) return True
def test_error_adding_marriage(self): ''' Test no adding marriage data due to error ''' prof = profile.profile(GENI_TWO_MARRIAGES_PROFILE, type_geni="") self.assertFalse(prof.add_marriage_in_geni()) self.assertFalse(prof.delete_profile())
def get_several_profile_by_ID(self, ID_array): ''' Returns a dict of profiles from Geni ID_array is a list of profile IDs. ''' input_array = "" if (len(ID_array) ==1): return {ID_array[0] : self.get_profile_by_ID(ID_array[0])} #This variable is used to check the case all profiles are already available to avoid a call all_profiles_existing = True for id_one in ID_array: if id_one not in self.profiles.keys(): all_profiles_existing = False input_array = input_array + "," + id_one #We have 2 options, if all profiles are existing in the interface, we do not need to do the call... output_array = {} if all_profiles_existing: for id_one in ID_array: output_array[id_one] = self.get_profile_by_ID(id_one) else: #There is a bug in the API, apparently is not working.... DUMMY_INPUT = "profile-1" url = s.GENI_PLUS_PROFILES + input_array[1:]+ "," + DUMMY_INPUT + self.token_string() r = s.geni_request_get(url) data = r.json() for prof_data in data["results"]: if not ( prof_data["id"] == DUMMY_INPUT): output_array[prof_data["id"]] = profile(prof_data["id"], prof_data) return output_array
def test_reading_sandbox_profile(self): ''' Test reading a profile in sandbox ''' prof = profile.profile(MAIN_SANDBOX_PROFILE, type_geni="") assert ("Testing" in prof.nameLifespan()) assert (prof.properly_executed) assert (prof.gen_data["gender"] == "M") assert (prof.gen_data["surname"] == "Profile") assert (prof.gen_data["name"] == "Testing") #Testing using profile input prof = profile.profile(MAIN_SANDBOX_PROFILE_API) assert (prof.gen_data["name"] == "Testing") assert (prof.properly_executed)
def testGettingCorrectName(self): ''' This test checks that the name of philip the IV of Spain is properly detected ''' assert ("Philip" in self.philip.nameLifespan()) assert ("1605" in self.philip.nameLifespan()) assert ("1665" in self.philip.nameLifespan()) assert (self.philip.gen_data["birth"].get_date() == date(1605, 4, 8)) assert (self.philip.gen_data["baptism"].year == 1605) assert (self.philip.gen_data["baptism"].month == 5) assert (self.philip.gen_data["death"].get_date() == date(1665, 9, 17)) assert (self.philip.gen_data["burial"].get_date() == date(1665, 9, 20)) assert (self.philip.gen_data["birth"].location["city"] == 'Valladolid') assert (self.philip.gen_data["baptism"].location["place_name"] == 'Iglesia Conventual San Pablo') assert ( self.philip.gen_data["death"].location["city"] == 'El Escorial') assert (self.philip.gen_data["burial"].location["place_name"] == 'San Lorenzo de El Escorial') assert (self.philip.getLiving() == False) #Simplifies the previous file into only 1 test assert (self.philip.get_id() == PHILIPIVid) philip_bis = profile.profile(PHILIPIVget, "") assert (philip_bis.get_id() == self.philip.get_id())
def testCousinsExecution(self): ''' We will test the cousins execution in different way. Will be tested by number, not by person ''' #Database creation geni_db = geni_database_interface() philip = profile(COUSIN_PROFILE) generations = 2 climber = climb(geni_db) ancestors, anc_count, profiles = climber.get_cousins(philip, generations) total_center = 0 total_outside = 0 for i in range(0, generations+1): total_center = total_center + anc_count[i][i] for j in range(i+1, generations + 1): total_outside = total_outside + anc_count[i][j] assert(total_center == 7) assert(total_outside == 0) total_final = 0 #We are counting here the number of cousing of the generation selected. #However, I noticed that this number varies... I selected an historical person #Philip IV of Spain, but apparently hundreds of years after... still new cousins appear. #TODO: fix this with a more stable profile, potentially from sandbox. for i in range(0, generations+1): for j in range(0, generations + 1): total_final = total_final + anc_count[i][j] assert(total_final == 32) assert(len(profiles) == 32)
def test_parser_profile_input(self): ''' Tests that a profile inputs provide the right result ''' prof = profile.profile(GENI_TWO_MARRIAGES_PROFILE, type_geni="") example = profile.process_profile_input(profile=prof) assert (example == GENI_TWO_MARRIAGES_PROFILE_LINK)
def main(): logging.basicConfig(filename='GeniToools.log', level=logging.INFO) logging.info('Starting GeniTools\n' + "=" * 20 + "\n") #Firstly the Input File is Read data = reader_input.reader_input("INPUT") base_call = geni_calls(data.genikey) if (data.continue_execution and base_call.check_valid_genikey()): #We only continue if inputs are correct! test_profile = profile.profile(data.profile, data.genikey) if (data.climbancestors or data.climbcousins): climber = climb(test_profile) if (data.climbcousins): ancestors, matrix_count, included_profiles = climber.get_cousins( data.generations) print(matrix_count) if (data.climbancestors): ancestors, affected_profiles = climber.get_ancestors( data.generations) else: logging.error(ERROR_MISSING_DATA) logging.info('Finishing GeniTools' + "=" * 20 + "\n")
def test_delete_not_existing_profile(self): ''' Test deleting a not existing profile ''' prof3 = profile.profile(OLD_DELETED_SON, type_geni="") assert (prof3.geni_specific_data['deleted']) assert (prof3.delete_profile() == False)
def test_alternative_data_in_profile(self): ''' Test other data in the profile ''' prof = profile.profile(BROTHER_PROFILE_SANDBOX) assert (len(prof.gen_data["nicknames"]) == 2) assert ("brother" in prof.gen_data["nicknames"])
def testCousinsExecution(self): ''' We will test the cousins execution in different way. Will be tested by number, not by person ''' philip = profile(COUSIN_PROFILE) generations = 2 climber = climb(philip) ancestors, anc_count, profiles = climber.get_cousins(generations) total_center = 0 total_outside = 0 for i in range(0, generations+1): total_center = total_center + anc_count[i][i] for j in range(i+1, generations + 1): total_outside = total_outside + anc_count[i][j] assert(total_center == 7) assert(total_outside == 0) total_final = 0 for i in range(0, generations+1): for j in range(0, generations + 1): total_final = total_final + anc_count[i][j] assert(total_final == 36) assert(len(profiles) == 36)
def test_reading_sandbox_profile(self): ''' Test reading a profile in sandbox ''' prof = profile.profile(MAIN_SANDBOX_PROFILE, type_geni="") assert ("Testing" in prof.nameLifespan()) assert (prof.properly_executed) assert (prof.gen_data["gender"] == "M") assert (prof.gen_data["surname"] == "Profile") assert (prof.gen_data["name"] == "Testing") #Securing before is properly captured assert (prof.get_accuracy_event("baptism") == "BEFORE") prof = profile.profile(MAIN_SANDBOX_PROFILE_API) assert (prof.gen_data["name"] == "Testing") assert (prof.properly_executed)
def test_error_adding_marriage(self): ''' Test no adding marriage data due to error ''' prof = profile.profile(GENI_2_MARRIAGES_IN_GENI, type_geni="") assert (prof.get_specific_event("baptism").get_accuracy() == "ABOUT") self.assertFalse(prof.add_marriage_in_geni()) self.assertFalse(prof.delete_profile())
def test_geni_to_gedcom(self): ''' Test a geni profile to Gedcom ''' prof = profile.profile(MAIN_SANDBOX_PROFILE, type_geni="") assert ("Testing" in prof.nameLifespan()) gedcom_profile.convert_gedcom(prof) location = prof.get_location_event("baptism") #We crosscheck the value is properly included in the file assert ("STAE" in prof.individual["BAPM"]["ADDR"].keys()) assert (location["city"] == "La Mata")
def testStopWithNoAncestors(self): ''' If there are no longer ancestors, the ancestor climb should stop. Checking if that works! This profile has only one generation available ''' flavia = profile(FLAVIAg) climber = climb(flavia) ancestors = climber.get_ancestors(6) assert(len(ancestors) == 2)
def test_reading_sandbox_profile(self): ''' Test reading a profile in sandbox ''' prof = profile.profile(MAIN_SANDBOX_PROFILE, type_geni="") assert( "Testing" in prof.nameLifespan()) assert(prof.properly_executed) assert(prof.gen_data["gender"] == "M") assert(prof.gen_data["surname"] == "Profile") assert(prof.gen_data["name"] == "Testing") #Securing before is properly captured assert(prof.get_accuracy_event("baptism") == "BEFORE") #Be careful! If the profile gets changed, this checking might fail assert(prof.get_update_datetime().year == 2018) prof = profile.profile(MAIN_SANDBOX_PROFILE_API) assert(prof.gen_data["name"] == "Testing") assert(prof.properly_executed)
def get_profile_by_ID(self, id_profile): ''' Returns the profile by the input ID ''' if not ( (id_profile in self.profiles.keys()) or (id_profile in self.equivalence.keys()) ): prof = profile(id_profile) #We use an unique id with profile in front self.profiles[prof.get_id()] = prof if id_profile != prof.get_id(): self.equivalence[id_profile] = prof.get_id() if id_profile in self.profiles.keys(): return self.profiles[id_profile] else: return self.profiles[self.equivalence[id_profile]]
def test_geni_to_gedcom(self): ''' Test a geni profile to Gedcom ''' prof = profile.profile(MAIN_SANDBOX_PROFILE, type_geni="") assert ("Testing" in prof.nameLifespan()) gedcom_profile.convert_gedcom(prof) data_event = prof.get_event_element("birth") element_top = data_event[1] element_sub = element_top.child_elements[1] #We crosscheck the value is properly included in the file assert (element_sub.tag == "PLAC") assert ("Gallegos" in element_sub.value)
def test_adding_a_parent(self): ''' Test adding a parent in Geni ''' father_profile = gen_profile(ACTUAL_NAME, FATHER_SURNAME) father_profile.setCheckedGender("M") profile.profile.create_as_a_parent(father_profile, geni_input=FATHER_PROFILE_SANDBOX) prof3 = profile.profile(FATHER_PROFILE_SANDBOX) assert(father_profile.geni_specific_data["id"] in prof3.parents) assert(father_profile.delete_profile())
def testStopWithNoAncestors(self): ''' If there are no longer ancestors, the ancestor climb should stop. Checking if that works! This profile has only one generation available ''' #Database creation geni_db = geni_database_interface() flavia = profile(FLAVIAg) climber = climb(geni_db) ancestors = climber.get_ancestors(flavia, 6) assert(len(ancestors) == 2)
def testCountingOfAncestors(self): ''' Testing the right calculation of ancestors. We know Philip IV was having duplicated ancestors, so the number will be lower than the generation count. ''' #Database creation geni_db = geni_database_interface() philip = profile(PHILIPIVg) climber = climb(geni_db) ancest = climber.get_ancestors(philip, 4) assert (len(ancest[1].keys()) == 23)
def force_update_profile(self, profile_id): ''' It will force the update of the profile id used by functions which include new profiles inside database ''' #Profile data is updated self.profiles[profile_id] = profile(profile_id) id_prof = self.profiles[profile_id].get_id() #The link to the families is updated. self.inmediate[id_prof] = immediate_family(id_prof) #Update of families of the profile unions = list(self.inmediate[id_prof].parent_union) + list(self.inmediate[id_prof].marriage_union) for union_now in unions: self.families[union_now.get_id()] = union(union_now.get_id())
def testCountingOfAncestors(self): ''' Testing the right calculation of ancestors. We know Philip IV was having duplicated ancestors, so the number will be lower than the generation count. ''' philip = profile(PHILIPIVg) climber = climb(philip) ancestors, profiles = climber.get_ancestors(4) i = 0 for generation in ancestors: i = i + len(generation.values()) assert(i == 23) assert(len(profiles) == 23)
def test_get_gedcom(self): ''' Test to obtain a gedcom down a profile ''' file_ged = os.path.join(self.filelocation, "output_test_geni2gedcom.ged") if os.path.exists(file_ged): os.remove(file_ged) prof = profile.profile(GRANDFATHER_SANDBOX) tester = geni2gedcom.geni2gedcom(prof) geddb = tester.get_gedcom(file_ged) counts = 0 for person in geddb.get_all_profiles(): if GENI2GEDCOM_DUPLICATED in person.getName2Show(): counts += 1 assert(counts == 1) if os.path.exists(file_ged): os.remove(file_ged)
def test_get_gedcom(self): ''' Test to obtain a gedcom down a profile ''' file_ged = os.path.join(self.filelocation, "output_test_geni2gedcom.ged") if os.path.exists(file_ged): os.remove(file_ged) prof = profile.profile(GRANDFATHER_SANDBOX) tester = geni2gedcom.geni2gedcom(prof) gedcomfile = tester.get_gedcom(file_ged) #gedcomfile = gedcom.parse(file_ged) counts = 0 for person in gedcomfile.individuals: firstname, lastname = person.name if "Avoid Duplicate in Gedcom" in firstname: counts += 1 assert (counts == 1) if os.path.exists(file_ged): os.remove(file_ged)
def introduce_family(self, init_profile, gedcom_db): ''' Recursive function to introduce the family in the gedcom database ''' logging.info(NUMBER_OF_PROFILES + str(len(self.added_profiles.keys())) + PROCESSING + init_profile.nameLifespan()) #Let's take first the children children = init_profile.children prof_id = init_profile.geni_specific_data["id"] #For the first profile we check first if the profile has been generated first if not isinstance(init_profile, gedcom_profile): #Notice that we will only go through this one a single time, as all the others #will be generated in the next step gedcom_profile.convert_gedcom(init_profile) gedcom_db.add_profile(init_profile) self.added_profiles[prof_id] = init_profile #Firstly we will create the array with all the partners in it and also with their ids in the database children_matrix = {} children_ids = {} for id_partner in init_profile.partner: children_matrix[id_partner] = [] children_ids[id_partner] = [] for new_id in children: #First thing to check is if we have already added the profile, we might #be in the situation of double profiles in intermarriage of descendants. new_prof = None if not (new_id in self.added_profiles.keys()): #Ok, if really a new profile, so we create it, we transfor it and #also we add to the added profiles new_prof = profile.profile(new_id) gedcom_profile.convert_gedcom(new_prof) gedcom_db.add_profile(new_prof) self.added_profiles[new_id] = new_prof #And we investigate, obviously! self.introduce_family(new_prof, gedcom_db) else: new_prof = self.added_profiles[new_id] #To avoid removing data from the profile we create a temp array using #the method list to avoid a linked copy temp_parents = list(new_prof.parents) #When not having access to a profile in geni, the parents provided are empty if prof_id in temp_parents: temp_parents.remove(prof_id) #Notice that we might have the situation of a single parent! if (len(temp_parents) > 0): #Let's find the profile which is already included. correct_parent = None if temp_parents[0] in children_matrix.keys(): correct_parent = temp_parents[0] else: correct_parent = temp_parents[1] children_matrix[correct_parent].append(new_prof) children_ids[correct_parent].append(new_prof.get_id()) #Only in case there is a partner, we include him/her! if (len(init_profile.partner) > 0): #Now let's use the partner as well, we may have several partners for id_partner in children_matrix.keys(): prof_partner = None #First thing, we need to check the partner is already identified or not if (id_partner in self.added_profiles.keys()): #We take the previous so! prof_partner = self.added_profiles[id_partner] else: #We get the profile data prof_partner = profile.profile(id_partner) #We add the profile in! gedcom_profile.convert_gedcom(prof_partner) #Now goes to the gedcom gedcom_db.add_profile(prof_partner) #And we mark is already in added profiles self.added_profiles[id_partner] = prof_partner #We create here the family gedcom_db.add_family(father=init_profile.get_id(), mother=prof_partner.get_id(), children=children_ids[id_partner])
def setUp(self): set_token(os.environ['GENI_KEY']) profile.s.update_geni_address("https://www.geni.com") profile.s.VERIFY_INPUT = "standard" self.philip = profile.profile(PHILIPIVg)