def test_date_structure(self):
'''
Test creation of geni date structure
'''
my_event = event_profile("birth")
#my_event.setDate(year, month, day, accuracy, year_end, month_end, day_end)
my_event.setDate(2017, 11, 20, "EXACT")
output = profile.getDateStructureGeni(my_event)
assert (output["year"] == 2017)
assert (output["month"] == 11)
assert (output["day"] == 20)
#Testing about
my_event.setDate(2017, accuracy="ABOUT")
output2 = profile.getDateStructureGeni(my_event)
assert (output2["year"] == 2017)
self.assertFalse("month" in output2.keys())
self.assertFalse("day" in output2.keys())
assert (output2["circa"] == True)
my_event.setDate(2017, accuracy="ABOUT")
#Testing the data before
my_event.setDate(2017, accuracy="BEFORE")
output3 = profile.getDateStructureGeni(my_event)
assert (output3["range"] == "before")
#Testing the data before
my_event.setDate(2017, accuracy="AFTER")
output4 = profile.getDateStructureGeni(my_event)
assert (output4["range"] == "after")
my_other_event = event_profile("birth")
self.assertFalse(profile.getDateStructureGeni(my_other_event))
def test_date_checker(self):
'''
It will check 2 dates to confirm which one is the smaller
'''
new_event = event_profile("birth")
self.assertFalse(
is_first_date_lower(2012, None, None, 2010, None, None))
assert (is_first_date_lower(1910, None, None, 1912, None, None))
assert (is_first_date_lower(2010, 1, None, 2010, None, None) == None)
assert (is_first_date_lower(2010, 1, None, 2010, 2, None))
self.assertFalse(is_first_date_lower(2012, 5, None, 2012, 1, None))
assert (is_first_date_lower(2010, 1, None, 2010, 1, None) == None)
assert (is_first_date_lower(2010, 2, 12, 2010, 2, 22))
self.assertFalse(is_first_date_lower(2012, 5, 12, 2012, 5, 5))
assert (is_first_date_lower(2010, 1, 2, 2010, 1, 2) == "Equal")
#Testing that the event is smaller or not
new_event1 = event_profile("birth")
new_event1.setDate(2013, month=2, accuracy="AFTER")
new_event2 = event_profile("death")
new_event2.setDate(2012, day=3, accuracy="ABOUT")
self.assertFalse(
new_event1.is_this_event_earlier_or_simultaneous_to_this(
new_event2))
assert (new_event2.is_this_event_earlier_or_simultaneous_to_this(
new_event1))
assert (
new_event1.is_this_event_later_or_simultaneous_to_this(new_event2))
self.assertFalse(
new_event2.is_this_event_later_or_simultaneous_to_this(new_event1))
def test_basic_event(self):
'''
Testing basic usage of common_event class
'''
event1 = event_profile("birth")
assert (event1.setDate(2011, accuracy="EXACT"))
assert (event1.setDate(2013, month=2, accuracy="ABOUT"))
assert (event1.setDate(2013, month=2, accuracy="BEFORE"))
assert (event1.setDate(2013, month=2, accuracy="AFTER"))
assert (event1.setDate(2013,
month=2,
accuracy="BETWEEN",
year_end=2013))
self.assertFalse(event1.setDate(2013, month=2, accuracy="BETWEEN"))
self.assertFalse(event1.setDate(2013, month=2, accuracy="LALA"))
self.assertFalse(
event1.setDate(2013, month=2, accuracy="ABOUT", month_end=2))
assert (event1)
#Introducing wrong data
self.assertRaises(ValueError, lambda: event_profile("wrong_data"))
event1.setLocation("Madrid, Spain")
assert (event1.location["place_name"] == "Madrid")
#Let's check introducing a lower date in the end day
assert (event1.setDate(2015,
month=2,
day=1,
accuracy="BETWEEN",
year_end=2013,
month_end=2,
day_end=5))
assert (event1.year == 2013)
def test_date_differences(self):
'''
Will test the differences between 2 events
'''
event1 = event_profile("birth")
event1.setDate(2013, 2, 13, "EXACT")
event2 = event_profile("birth")
event2.setDate(2013, 6, 26, "EXACT")
assert (event1.get_difference_in_days(event2) == 133)
event2.setDate(2013, accuracy="EXACT")
print(event1.get_difference_in_days(event2) == 43)
def test_common_init_functions(self):
'''
This test will be testing those functions included in init file
'''
my_event = event_profile("birth")
assert (return_date_from_event(my_event) == None)
my_event.setDate(2019, 5, 3, "EXACT")
#D.+20190503..+00000000..
assert (return_date_from_event(my_event) == "D.+20190503..+00000000..")
my_event.setDate(1970, accuracy="BEFORE")
#DB+19700000..+00000000..
assert (return_date_from_event(my_event) == "DB+19700000..+00000000..")
my_event.setDate(1890, accuracy="AFTER")
#DA+18900000..+00000000..
assert (return_date_from_event(my_event) == "DA+18900000..+00000000..")
my_event.setDate(1820, accuracy="BETWEEN", year_end=1821, month_end=3)
#DR+18200000..+18210300..
assert (return_date_from_event(my_event) == "DR+18200000..+18210300..")
my_event.setDate(1910, accuracy="ABOUT")
#D.+19100000.C+00000000..
assert (return_date_from_event(my_event) == "D.+19100000.A+00000000..")
def setCheckedDate(self,
event_name,
year,
month=None,
day=None,
accuracy="EXACT",
year_end=None,
month_end=None,
day_end=None):
'''
This function will introduce an event with the data related to the dates of the event
'''
if (event_name not in EVENT_TYPE) or (accuracy not in VALUES_ACCURACY):
raise NameError(INITIAL_PART_EVENT_ERROR + event_name + " or " +
accuracy + END_PART_EVENT_ERROR)
new_event = event_profile(event_name)
new_event.setDate(year, month, day, accuracy, year_end, month_end,
day_end)
if (not self.selfcheckDateConsistency(new_event)):
return False
else:
if event_name in ARRAY_EVENTS:
self.gen_data[event_name].append(new_event)
elif event_name in self.gen_data.keys():
self.gen_data[event_name].setDate(year, month, day, accuracy,
year_end, month_end, day_end)
else:
self.gen_data[event_name] = new_event
return True
def test_family(self):
'''
This test will check the basic operation of family classes
'''
father = gen_profile("Father", "Profile")
mother = gen_profile("Mother", "Profile")
child1 = gen_profile("Child", "First")
child2 = gen_profile("Child", "Second")
event1 = event_profile("birth")
assert (event1.setDate(2013, month=2, accuracy="ABOUT"))
family1 = family_profile(child=3)
assert (len(family1.getChildren()) == 1)
family2 = family_profile(child=[1, 2])
assert (len(family2.getChildren()) == 2)
family3 = family_profile(child=[1, 2],
father=3,
mother=4,
marriage=event1)
assert (family3.father and family3.mother and family3.children
and family3.marriage)
assert (family3.getFather() == 3)
assert (family3.getMother() == 4)
def get_date(self, event_type, data_dict, previous_event=None):
'''
Get date from the Geni standard, used in unions and profiles
'''
if previous_event:
my_event = previous_event
else:
my_event = event_profile(event_type)
accuracy = None
year = None
month = None
day = None
year_end = None
month_end = None
day_end = None
if (data_dict.get("year", None) is not None):
year = data_dict.get("year")
month = data_dict.get("month", None)
day = data_dict.get("day", None)
#TODO: get and handle BETWEEN dates
if (data_dict.get("circa", "false") is True): accuracy = "ABOUT"
elif (data_dict.get("range", "") == "before"): accuracy = "BEFORE"
elif (data_dict.get("range", "") == "after"): accuracy = "AFTER"
elif (data_dict.get("range", "") == "between"):
accuracy = "BETWEEN"
year_end = data_dict.get("end_year", None)
month_end = data_dict.get("end_month", None)
day_end = data_dict.get("end_day", None)
else:
accuracy = "EXACT"
#Now we transfer everything to the profile
my_event.setDate(year, month, day, accuracy, year_end, month_end,
day_end)
return my_event
def get_specific_event(self, event_name):
'''
It will return an specific event or None if not present
'''
if EQUIVALENCE[event_name] in self.individual:
new_event = event_profile(event_name)
geddate = self.individual.get(EQUIVALENCE[event_name]).get(
"DATE", {}).get("VALUE")
if geddate:
year, month, day, accuracy, year_end, month_end, day_end = get_date_info_from_ged(
geddate)
new_event.setDate(year, month, day, accuracy, year_end,
month_end, day_end)
if self.individual.get(EQUIVALENCE[event_name]).get(
"PLAC", {}).get("VALUE"):
new_event.setParameterInLocation(
"place_name",
self.individual.get(EQUIVALENCE[event_name]).get(
"PLAC", {}).get("VALUE"))
for key in LOCATION_EQUIVALENCE:
if self.individual.get(EQUIVALENCE[event_name]).get(
"ADDR", {}).get(LOCATION_EQUIVALENCE[key],
{}).get("VALUE"):
new_event.setParameterInLocation(
key,
self.individual.get(EQUIVALENCE[event_name]).get(
"ADDR", {}).get(LOCATION_EQUIVALENCE[key],
{}).get("VALUE"))
if event_name in common_profile.ARRAY_EVENTS: return [new_event]
else: return new_event
else:
if event_name in common_profile.ARRAY_EVENTS: return []
else: return None
def setCheckedDate(self,
event_name,
year,
month=None,
day=None,
accuracy="EXACT",
year_end=None,
month_end=None,
day_end=None):
'''
This function will introduce an event with the data related to the dates of the event
'''
if (not event_name in EVENT_TYPE) or (not accuracy in VALUES_ACCURACY):
return False
new_event = event_profile(event_name)
new_event.setDate(year, month, day, accuracy, year_end, month_end,
day_end)
if (not self.selfcheckDateConsistency(new_event)):
return False
else:
if event_name in self.gen_data.keys():
self.gen_data[event_name].setDate(year, month, day, accuracy,
year_end, month_end, day_end)
else:
self.gen_data[event_name] = new_event
return True
def return_event_from_database_info(self, event_in_database):
'''
This function is used to get info about all events
'''
if not str(event_in_database[1]) in DATE_EVENT_ID.values(): return None
event_output = event_profile(
list(DATE_EVENT_ID.keys())[list(DATE_EVENT_ID.values()).index(
str(event_in_database[1]))])
if not ((event_in_database[7] in ["."])
or event_in_database[7].startswith("T")):
#This means that the event has a date, as might be empty
year_end = None
month_end = None
day_end = None
accuracy_value = "EXACT"
if event_in_database[7][1] == "B":
accuracy_value = "BEFORE"
elif event_in_database[7][1] == "A":
accuracy_value = "AFTER"
elif event_in_database[7][1] == "R":
#Only in the case of dates between is when we analyze and define the dates after
accuracy_value = "BETWEEN"
year_end = int(event_in_database[7][14:18])
month_end = int(event_in_database[7][18:20])
day_end = int(event_in_database[7][20:22])
if year_end == 0: year_end = None
if month_end == 0: month_end = None
if day_end == 0: day_end = None
elif event_in_database[7][12] == "A":
accuracy_value = "ABOUT"
year = int(event_in_database[7][3:7])
month = int(event_in_database[7][7:9])
day = int(event_in_database[7][9:11])
if month == 0: month = None
if day == 0: day = None
event_output.setDate(year, month, day, accuracy_value, year_end,
month_end, day_end)
if not event_in_database[5] == 0:
#The only valid place is actually when is an entry in the PlaceTbale
place_input = "SELECT * FROM PlaceTable WHERE PlaceID=?"
place = self.database.execute(place_input,
(str(event_in_database[5]), ))
place_info = place.fetchone()
#We extract the geolocated string from the profile
geo_string = place_info[2]
#If was extracted before, we should avoid another geolocation call
if get_geolocated_before(geo_string):
event_output.setLocationAlreadyProcessed(
get_geolocated_before(geo_string))
else:
event_output.setLocation(place_info[2])
#We store the geolocation in the database for future use
set_geolocated(geo_string, event_output.get_location())
if int(place_info[5]) != 0 and int(place_info[6]) != 0:
event_output.set_geo_location(
int(place_info[5]) / 10000000,
int(place_info[6]) / 10000000)
return event_output
def setPlaces(self, event_name, location, language="en"):
'''
This function will introduce the location related to each event
'''
if event_name in ARRAY_EVENTS:
new_event = event_profile(event_name)
new_event.setLocation(location, language)
self.gen_data[event_name].append(new_event)
return True
if event_name in EVENT_TYPE:
new_event = self.gen_data.get(event_name,
event_profile(event_name))
new_event.setLocation(location, language)
self.gen_data[event_name] = new_event
return True
else:
raise NameError(INITIAL_PART_EVENT_ERROR + event_name +
END_PART_EVENT_ERROR)
def setPlaces(self, event_name, location, language="en" ):
'''
This function will introduce the location related to each event
'''
if event_name in EVENT_TYPE:
new_event = self.gen_data.get(event_name, event_profile(event_name))
new_event.setLocation(location, language)
self.gen_data[event_name] = new_event
return True
else:
return False
def test_score_birth_death(self):
'''
Test the scoring for birth and death
'''
birth1 = event_profile("birth")
birth1.setDate(1900)
residence1 = event_profile("residence")
residence1.setDate(1901)
death1 = event_profile("death")
death1.setDate(2090)
score1, factor1 = score_factor_birth_and_death(birth1,residence1, [death1])
assert(score1 == 0)
assert(factor1 == 0)
score2, factor2 = score_factor_birth_and_death(birth1,residence1, [])
assert(score2 == 0)
assert(factor2 == 1)
score3, factor3 = score_factor_birth_and_death(None,None,[])
assert(score3 == 0)
assert(factor3 == 1)
def test_date_for_gedcom(self):
'''
Testing the output for gedcom
'''
new_event = event_profile("birth")
new_event.setDate(2013, month=2)
assert (new_event.get_gedcom_date() == "FEB 2013")
new_event.setDate(2013)
assert (new_event.get_gedcom_date() == "2013")
new_event.setDate(2013, 6, 1)
assert (new_event.get_gedcom_date() == "01 JUN 2013")
new_event.setDate(2013, 12, 18)
assert (new_event.get_gedcom_date() == "18 DEC 2013")
def test_adding_a_partner(self):
'''
Testing adding a parent to a profile
'''
partner_profile = gen_profile(ACTUAL_NAME, FATHER_SURNAME)
my_event = event_profile("marriage")
my_event.setDate(2017, 11, 20)
partner_profile.setCheckedDate("marriage", 2017, 10, 20)
partner_profile.setPlaces("marriage",GENERIC_PLACE_STRING , language="es")
profile.profile.create_as_a_partner(partner_profile, geni_input = BROTHER_PROFILE_SANDBOX)
#TODO: add checking of marriage data once is included
assert(partner_profile.properly_executed)
assert(partner_profile.delete_profile())
def set_research_item(self, log_id, repository = "", source = "", result = ""):
'''
This will introduce a new research item inside the given research log
log_id is the id of the research log that will contain the research item
repository is the location of the research, like a webpage
source is the source of hte information
result is the final outcome
'''
#Get the date of today in the form of RootsMagic
new_event = event_profile("residence")
today = date.today()
new_event.setDate(today.year, today.month, today.day, "EXACT")
date_of_research = return_date_from_event(new_event)
new_item = "INSERT INTO ResearchItemTable(LogID,Date,Repository,Source,Result) VALUES(?,?,?,?,?)"
self.database.execute( new_item, (str(log_id), date_of_research, repository, source, result, ) )
self.database.commit()
def get_specific_event(self, event_name):
'''
This function will provide the date and related event data of the date
by looking to the database for this specific data
'''
events = self.database.execute("SELECT * FROM EventTable WHERE OwnerId=" + str(self.owner_id) + " AND EventType=" +
DATE_EVENT_ID[event_name])
date_data = events.fetchone()
if date_data:
event_output = event_profile(event_name)
year_end = None
month_end = None
day_end = None
#TODO: everything down here will require update with the new data model
accuracy_value = "EXACT"
if date_data[7][1] == "B":
accuracy_value = "BEFORE"
elif date_data[7][1] == "A":
accuracy_value = "AFTER"
elif date_data[7][1] == "R":
#Only in the case of dates between is when we analyze and define the dates after
accuracy_value = "BETWEEN"
year_end = int(date_data[7][14:18])
month_end = int(date_data[7][18:20])
day_end = int(date_data[7][20:22])
if year_end == 0 : year_end = None
if month_end == 0 : month_end = None
if day_end == 0 : day_end = None
elif date_data[7][12] == "C":
accuracy_value = "ABOUT"
year = int(date_data[7][3:7])
month = int(date_data[7][7:9])
day = int(date_data[7][9:11])
if month == 0: month = None
if day == 0: day = None
event_output.setDate(year, month, day, accuracy_value, year_end, month_end, day_end)
return event_output
else:
return None
def testName(self):
'''
Testing basic introduction of new profiles and families.
'''
db = gen_database()
assert (db.get_db_kind() == "COMMON")
person1 = gen_profile("Name", "Surname")
person2 = gen_profile("Name2", "Surname2")
person3 = gen_profile("Chid", "Surname2")
assert (db.add_profile(person1) == "I1")
assert (db.add_profile(person2) == "I2")
assert (db.add_profile(person3) == "I3")
assert (db.add_family(father="I1", mother="I2",
children=["I3"]) == "F1")
assert (db.get_profile_by_ID("I1").getName() == "Name")
assert (len(db.get_several_profile_by_ID(["I1", "I2"])) == 2)
assert (db.get_family_by_ID("F1").getFather() == "I1")
assert (db.get_family_by_ID("F1").get_id() == "F1")
assert (db.get_family_by_ID("xxx1") == None)
assert (db.get_profile_by_ID("xxx1") == None)
id_fam, fam = db.get_family_from_child("I3")
assert (id_fam == "F1")
assert (fam.getMother() == "I2")
marriage_event = event_profile("marriage")
fam.setMarriage(marriage_event)
assert (fam.getMarriage() == marriage_event)
id_fam2, fam2 = db.get_family_from_child("I1")
assert (id_fam2 == None)
#Get father of profile
assert (db.get_father_from_child("I3")[0] == "I1")
#Get mother of profile
assert (db.get_mother_from_child("I3")[0] == "I2")
#Get Children function
assert ("I3" in db.get_all_children("I1"))
assert ("I2" in db.get_partners_from_profile("I1"))
def test_compare_date(self):
'''
Test comparison of dates with scoring
'''
date1 = date(2018, 1, 1)
date2 = date(2018, 2, 6)
event1 = event_profile("birth")
event1.setDate(2018, 1, 1)
event2 = event_profile("birth")
event3 = event_profile("birth")
event3.setDate(2018, 2, 6)
#No difference score
score, factor = get_score_compare_dates(event1, event1)
assert (score == 2.0)
assert (factor == 1.0)
#1 day of different
event2.setDate(2018, 1, 2)
score, factor = get_score_compare_dates(event1, event2)
assert (score > 1.8)
assert (factor > 0.9)
#One week of different
event2.setDate(2018, 1, 8)
score, factor = get_score_compare_dates(event1, event2)
assert (score > 1.4)
assert (factor > 0.7)
#One month of difference
event2.setDate(2018, 2, 6)
score, factor = get_score_compare_dates(event1, event2)
assert (score > 0.8)
assert (factor > 0.4)
#one year of different
event2.setDate(2019, 1, 1)
score, factor = get_score_compare_dates(event1, event2)
assert (score > 0.08)
assert (factor > 0.04)
#About parameters
event2.setDate(2017, accuracy="ABOUT")
score, factor = get_score_compare_dates(event3, event2)
assert (score == 1.0)
assert (factor == 1.0)
#A little bith more than one year
event2.setDate(2016, accuracy="ABOUT")
score, factor = get_score_compare_dates(event3, event2)
assert (score > 0.95)
assert (factor == 1.0)
#Several years
event2.setDate(2013, accuracy="ABOUT")
score, factor = get_score_compare_dates(event3, event2)
assert (score > 0.2)
assert (factor > 0.4)
#Far beyond....
event2.setDate(2010, accuracy="ABOUT")
score, factor = get_score_compare_dates(event3, event2)
assert (score < 0.1)
assert (factor > 0.1)
#Let's check the dates
event2.setDate(2010, accuracy="ABOUT")
event3.setDate(2010, accuracy="ABOUT")
score, factor = get_score_compare_dates(event2, event3)
assert (score == 1.0)
assert (factor == 1.0)
#4 years with about different
event2.setDate(2014, accuracy="ABOUT")
event3.setDate(2010, accuracy="ABOUT")
score, factor = get_score_compare_dates(event2, event3)
assert (score > 0.499)
assert (factor > 0.799)
#7 years with about different
event2.setDate(2017, accuracy="ABOUT")
event3.setDate(2010, accuracy="ABOUT")
score, factor = get_score_compare_dates(event2, event3)
assert (score > 0.37999)
assert (factor > 0.41999)
#20 years with about different
event2.setDate(2030, accuracy="ABOUT")
event3.setDate(2010, accuracy="ABOUT")
score, factor = get_score_compare_dates(event2, event3)
assert (score > 0.04999)
assert (factor > 0.074999)
#Befores become irrelevant
event2.setDate(2040, accuracy="BEFORE")
event3.setDate(2030, accuracy="BEFORE")
score, factor = get_score_compare_dates(event2, event3)
assert (score == 0.0)
assert (factor == 1.0)
#Befores become irrelevant
event2.setDate(2040, accuracy="BEFORE")
event3.setDate(2030, accuracy="ABOUT")
score, factor = get_score_compare_dates(event2, event3)
assert (score == 0.0)
assert (factor == 1.0)
#Inconsistentcy gives null
event2.setDate(2040, accuracy="BEFORE")
event3.setDate(2050, accuracy="EXACT")
score, factor = get_score_compare_dates(event2, event3)
assert (score == 0.0)
assert (factor == 0.0)
#After becomes irrelevant
event2.setDate(2040, accuracy="AFTER")
event3.setDate(2030, accuracy="AFTER")
score, factor = get_score_compare_dates(event2, event3)
assert (score == 0.0)
assert (factor == 1.0)
#After becomes irrelevant
event2.setDate(2020, accuracy="AFTER")
event3.setDate(2030, accuracy="ABOUT")
score, factor = get_score_compare_dates(event2, event3)
assert (score == 0.0)
assert (factor == 1.0)
#After becomes irrelevant
event2.setDate(2040, accuracy="AFTER")
event3.setDate(2020, accuracy="EXACT")
score, factor = get_score_compare_dates(event2, event3)
assert (score == 0.0)
assert (factor == 0.0)
#After becomes irrelevant
event2.setDate(2030, accuracy="ABOUT")
event3.setDate(2040, accuracy="BEFORE")
score, factor = get_score_compare_dates(event2, event3)
assert (score == 0.0)
assert (factor == 1.0)
#After becomes irrelevant
event2.setDate(2030, accuracy="ABOUT")
event3.setDate(2020, accuracy="BEFORE")
score, factor = get_score_compare_dates(event2, event3)
assert (score == 0.0)
assert (factor == 0.0)
#After becomes irrelevant
event2.setDate(2030, accuracy="ABOUT")
event3.setDate(2020, accuracy="AFTER")
score, factor = get_score_compare_dates(event2, event3)
assert (score == 0.0)
assert (factor == 1.0)
#After becomes irrelevant
event2.setDate(2030, accuracy="ABOUT")
event3.setDate(2040, accuracy="AFTER")
score, factor = get_score_compare_dates(event2, event3)
assert (score == 0.0)
assert (factor == 0.0)
def __init__(self, union_id):
'''
Constructor it takes the union id from Geni
'''
#We initiate the base classes
geni_calls.__init__(self)
family_profile.__init__(self)
data = ""
if (union_id in geni.GENI_CALLED_UNIONS):
#In order to save calls we try to save the different calls
data = geni.GENI_CALLED_UNIONS[union_id]
else:
url = geni.GENI_API + union_id + geni.GENI_SINGLE_TOKEN + geni.get_token(
)
r = geni.geni_request_get(url)
data = r.json()
geni.GENI_CALLED_UNIONS[union_id] = data
self.union_data = {}
#Initiating values of the parametrs
self.union_data["partners"] = []
for key_value in data.keys():
if key_value == "id": self.union_data["id"] = data[key_value]
if key_value == "url": self.union_data["url"] = data[key_value]
if key_value == "guid": self.union_data["guid"] = data[key_value]
if key_value == "marriage_date":
#We might have an existing marriage in the file
self.union_data["marriage"] = self.get_date(
"marriage",
data["marriage_date"],
previous_event=self.union_data.get("marriage", None))
if key_value == "marriage_location":
place_data = {}
for location_key in data["marriage_location"].keys():
if location_key == "city":
place_data[location_key] = data["marriage_location"][
location_key]
if location_key == "county":
place_data[location_key] = data["marriage_location"][
location_key]
if location_key == "state":
place_data[location_key] = data["marriage_location"][
location_key]
if location_key == "country":
place_data[location_key] = data["marriage_location"][
location_key]
if location_key == "country_code":
place_data[location_key] = data["marriage_location"][
location_key]
if location_key == "latitude":
place_data[location_key] = data["marriage_location"][
location_key]
if location_key == "longitude":
place_data[location_key] = data["marriage_location"][
location_key]
if location_key == "formatted_location":
place_data[location_key] = data["marriage_location"][
location_key]
if not ("marriage" in self.union_data.keys()):
self.union_data["marriage"] = event_profile("marriage")
self.union_data["marriage"].setLocationAlreadyProcessed(
place_data)
if key_value == "status":
self.union_data["status"] = data[key_value]
if key_value == "partners":
#The union stores the partner as a full address, but we are looking for the profile ID which is stored
for partner in data[key_value]:
self.union_data["partners"].append(partner.split("/")[-1])
self.setFather(
geni.get_profile_id_from_address(data[key_value][0]))
if len(data.get(key_value, None)) > 1:
self.setMother(
geni.get_profile_id_from_address(data[key_value][1]))
if key_value == "children":
self.union_data["children"] = data[key_value]
children = []
for child in data[key_value]:
children.append(geni.get_profile_id_from_address(child))
self.setChild(children)
def test_date_check(self):
'''
Test of the function for date check
'''
event4end = event_profile("death")
event4end.setDate(2014,accuracy = "ABOUT")
event2bend = event_profile("burial")
event2bend.setDate(2014,month = 2 , day = 1, accuracy = "BEFORE")
#Test bug of burial and death
assert(checkDateConsistency([event4end, event2bend]))
#Going events onebyone
event1 = event_profile("residence")
event1.setDate(2017, 1, 1)
event4 = event_profile("birth")
event4.setDate(2014, 1, 1)
assert(checkDateConsistency( [event1] ))
assert(checkDateConsistency([event4]))
event1b = event_profile("burial")
event1b.setDate(2017, 1, 1)
assert(checkDateConsistency([event4, event1b]))
event1d = event_profile("death")
event1d.setDate(2017, 1, 1)
event2 = event_profile("marriage")
event2.setDate(2016, 1, 1)
event3 = event_profile("baptism")
event3.setDate(2015, 1, 1)
assert(checkDateConsistency([event3, event2,event1d, event4 ]))
event1bi = event_profile("birth")
event1bi.setDate(2017, 1, 1)
event4b = event_profile("burial")
event4b.setDate(2014, 1, 1)
assert(not checkDateConsistency([event1bi, event4b]))
event1ba = event_profile("baptism")
event1ba.setDate(2017, 1, 1)
event4d = event_profile("death")
event4d.setDate(2014, 1, 1)
assert(not checkDateConsistency([event4d, event1ba]))
event4bap = event_profile("baptism")
event4bap.setDate(2014, 1, 1)
assert(not checkDateConsistency([event4bap, event1bi]))
#Checking that about dates are ok although the date2b is later than date4
event2btest = event_profile("birth")
event2btest.setDate(2014, 2, 1)
event4test = event_profile("burial")
event4test.setDate(2014,accuracy = "ABOUT")
event5test = event_profile("death")
event5test.setDate(2014,accuracy = "ABOUT")
assert(checkDateConsistency([event2btest, event4test, event5test ]))
event4end = event_profile("death")
event4end.setDate(2014,accuracy = "ABOUT")
event2bend = event_profile("burial")
event2bend.setDate(2014,month = 2 , day = 1, accuracy = "BEFORE")
#Test bug of burial and death
assert(checkDateConsistency([event4end, event2bend]))
#Checking some other methods
assert(is_this_date_earlier_or_simultaneous_to_this(1912, 12, 1, None, 12, 1) == True)
assert(is_this_date_earlier_or_simultaneous_to_this(None, 12, 1, 1914, 12, 1) == False)
assert(is_this_date_earlier_or_simultaneous_to_this(None, 12, 1, None, 12, 1) == None)
def test_compare_date(self):
'''
Test comparison of dates with scoring
'''
event1 = event_profile("birth")
event1.setDate(2018,1,1)
event2 = event_profile("birth")
event3 = event_profile("birth")
event3.setDate(2018,2,6)
event4 = event_profile("birth")
event4.setDate(2018)
#Case of no data available
score, factor = get_score_compare_dates(event3, event4)
assert(score*factor > 1.8)
#No difference score
score, factor = get_score_compare_dates(event1, event1)
assert(score == 2.0)
assert(factor == 1.0)
#1 day of different
event2.setDate(2018,1,2)
score, factor = get_score_compare_dates(event1, event2)
assert(score >1.8)
assert(factor > 0.9)
#One week of different
event2.setDate(2018,1,8)
score, factor = get_score_compare_dates(event1, event2)
assert(score >1.4)
assert(factor > 0.7)
#One month of difference
event2.setDate(2018,2,6)
score, factor = get_score_compare_dates(event1, event2)
assert(score >0.8)
assert(factor > 0.4)
#one year of different
event2.setDate(2019,1,1)
score, factor = get_score_compare_dates(event1, event2)
assert(score >0.08)
assert(factor > 0.04)
#About parameters
event2.setDate(2017, accuracy="ABOUT")
score, factor = get_score_compare_dates(event3, event2)
assert(score == 1.0)
assert(factor == 1.0)
#A little bith more than one year
event2.setDate(2016, accuracy="ABOUT")
score, factor = get_score_compare_dates(event3, event2)
assert(score >0.95)
assert(factor == 1.0)
#Several years
event2.setDate(2013, accuracy="ABOUT")
score, factor = get_score_compare_dates(event3, event2)
assert(score >0.2)
assert(factor > 0.4)
#Far beyond....
event2.setDate(2010, accuracy="ABOUT")
score, factor = get_score_compare_dates(event3, event2)
assert(score < 0.1)
assert(factor > 0.1)
#Let's check the dates
event2.setDate(2010, accuracy="EXACT")
event3.setDate(1910, accuracy="EXACT")
score, factor = get_score_compare_dates(event2, event3)
assert(score < 0.003)
assert(factor < 0.002)
#Let's check the dates
event2.setDate(2010, accuracy="ABOUT")
event3.setDate(2010, accuracy="ABOUT")
score, factor = get_score_compare_dates(event2, event3)
assert(score == 1.0)
assert(factor == 1.0)
#4 years with about different
event2.setDate(2014, accuracy="ABOUT")
event3.setDate(2010, accuracy="ABOUT")
score, factor = get_score_compare_dates(event2, event3)
assert(score > 0.499)
assert(factor > 0.799)
#7 years with about different
event2.setDate(2017, accuracy="ABOUT")
event3.setDate(2010, accuracy="ABOUT")
score, factor = get_score_compare_dates(event2, event3)
assert(score > 0.37999)
assert(factor > 0.41999)
#20 years with about different
event2.setDate(2030, accuracy="ABOUT")
event3.setDate(2010, accuracy="ABOUT")
score, factor = get_score_compare_dates(event2, event3)
assert(score > 0.04999)
assert(factor > 0.074999)
#Befores become irrelevant
event2.setDate(2040, accuracy="BEFORE")
event3.setDate(2030, accuracy="BEFORE")
score, factor = get_score_compare_dates(event2, event3)
assert(score == 0.0)
assert(factor == 1.0)
#Befores become irrelevant
event2.setDate(2040, accuracy="BEFORE")
event3.setDate(2030, accuracy="ABOUT")
score, factor = get_score_compare_dates(event2, event3)
assert(score == 0.0)
assert(factor == 1.0)
#Inconsistentcy gives null
event2.setDate(2040, accuracy="BEFORE")
event3.setDate(2050, accuracy="EXACT")
score, factor = get_score_compare_dates(event2, event3)
assert(score == 0.0)
assert(factor == 0.0)
#After becomes irrelevant
event2.setDate(2040, accuracy="AFTER")
event3.setDate(2030, accuracy="AFTER")
score, factor = get_score_compare_dates(event2, event3)
assert(score == 0.0)
assert(factor == 1.0)
#After becomes irrelevant
event2.setDate(2020, accuracy="AFTER")
event3.setDate(2030, accuracy="ABOUT")
score, factor = get_score_compare_dates(event2, event3)
assert(score == 0.0)
assert(factor == 1.0)
#After becomes irrelevant
event2.setDate(2040, accuracy="AFTER")
event3.setDate(2020, accuracy="EXACT")
score, factor = get_score_compare_dates(event2, event3)
assert(score == 0.0)
assert(factor == 0.0)
#After becomes irrelevant
event2.setDate(2030, accuracy="ABOUT")
event3.setDate(2040, accuracy="BEFORE")
score, factor = get_score_compare_dates(event2, event3)
assert(score == 0.0)
assert(factor == 1.0)
#After becomes irrelevant
event2.setDate(2030, accuracy="ABOUT")
event3.setDate(2020, accuracy="BEFORE")
score, factor = get_score_compare_dates(event2, event3)
assert(score == 0.0)
assert(factor == 1.0)
#After becomes irrelevant
event2.setDate(2030, accuracy="ABOUT")
event3.setDate(2020, accuracy="AFTER")
score, factor = get_score_compare_dates(event2, event3)
assert(score == 0.0)
assert(factor == 1.0)
#After becomes irrelevant
event2.setDate(2030, accuracy="ABOUT")
event3.setDate(2040, accuracy="AFTER")
score, factor = get_score_compare_dates(event2, event3)
assert(score == 0.0)
assert(factor == 0.0)
#Comparing between dates
event2.setDate(2030, 5, 23, accuracy="EXACT")
event3.setDate(2030,2,21, accuracy="BETWEEN", year_end = 2031)
score, factor = get_score_compare_dates(event2, event3)
assert(score == 1.2)
assert(factor == 1.0)
event2.setDate(2030, accuracy="EXACT")
event3.setDate(2029, accuracy="BETWEEN", year_end = 2031)
score, factor = get_score_compare_dates(event2, event3)
assert(score == 1.0)
assert(factor == 1.0)
event2.setDate(2030, accuracy="EXACT")
event3.setDate(2029, accuracy="BETWEEN", year_end = 2033)
score, factor = get_score_compare_dates(event2, event3)
assert(score == 0.5)
assert(factor == 1.0)
event2.setDate(2030, accuracy="EXACT")
event3.setDate(2029, accuracy="BETWEEN", year_end = 2036)
score, factor = get_score_compare_dates(event2, event3)
assert(score< 0.45)
assert(factor == 1.0)
event2.setDate(2030, accuracy="EXACT")
event3.setDate(2029, accuracy="BETWEEN", year_end = 2046)
score, factor = get_score_compare_dates(event2, event3)
assert(score < 0.12)
assert(factor == 1.0)
event2.setDate(2025, accuracy="EXACT")
event3.setDate(2029, accuracy="BETWEEN", year_end = 2033)
score, factor = get_score_compare_dates(event2, event3)
assert(score == 0.0)
assert(factor == 0.0)
event2.setDate(2033, accuracy="BETWEEN")
event3.setDate(2029, accuracy="EXACT", year_end = 2031)
score, factor = get_score_compare_dates(event2, event3)
assert(score == 0.0)
assert(factor == 0.0)
event2.setDate(2030, accuracy="BEFORE")
event3.setDate(2029, accuracy="BETWEEN", year_end = 2031)
score, factor = get_score_compare_dates(event2, event3)
assert(score == 0.0)
assert(factor == 1.0)
event2.setDate(2028, accuracy="BEFORE")
event3.setDate(2029, accuracy="BETWEEN", year_end = 2031)
score, factor = get_score_compare_dates(event2, event3)
assert(score == 0.0)
assert(factor == 0.0)
event2.setDate(2029, accuracy="BETWEEN", year_end = 2031)
event3.setDate(2032, accuracy="BEFORE")
score, factor = get_score_compare_dates(event2, event3)
assert(score == 0.0)
assert(factor == 1.0)
event2.setDate(2030, accuracy="AFTER")
event3.setDate(2029, accuracy="BETWEEN", year_end = 2031)
score, factor = get_score_compare_dates(event2, event3)
assert(score == 0.0)
assert(factor == 1.0)
event2.setDate(2033, accuracy="AFTER")
event3.setDate(2029, accuracy="BETWEEN", year_end = 2031)
score, factor = get_score_compare_dates(event2, event3)
assert(score == 0.0)
assert(factor == 0.0)
event2.setDate(2029, accuracy="BETWEEN", year_end = 2031)
event3.setDate(2028, accuracy="AFTER")
score, factor = get_score_compare_dates(event2, event3)
assert(score == 0.0)
assert(factor == 1.0)
event2.setDate(2028, accuracy="BETWEEN", year_end = 2036)
event3.setDate(2029, accuracy="BETWEEN", year_end = 2031)
score, factor = get_score_compare_dates(event2, event3)
assert(score < 0.32)
assert(factor == 1.0)
event2.setDate(2028, accuracy="BETWEEN", year_end = 2031)
event3.setDate(2034, accuracy="BETWEEN", year_end = 2037)
score, factor = get_score_compare_dates(event2, event3)
assert(score == 0.0)
assert(factor == 0.0)
event2.setDate(2028, accuracy="BETWEEN", year_end = 2031)
event3.setDate(2024, accuracy="BETWEEN", year_end = 2027)
score, factor = get_score_compare_dates(event2, event3)
assert(score == 0.0)
assert(factor == 0.0)
event2.setDate(2030, accuracy="ABOUT")
event3.setDate(2029, accuracy="BETWEEN", year_end = 2032)
score, factor = get_score_compare_dates(event2, event3)
assert(score == 0.5)
assert(factor > 0.99)
event2.setDate(2033, accuracy="ABOUT")
event3.setDate(2029, accuracy="BETWEEN", year_end = 2031)
score, factor = get_score_compare_dates(event2, event3)
assert(score == 1.0)
assert(factor > 0.71)
event2.setDate(2028, accuracy="BETWEEN", year_end = 2031)
event3.setDate(2010, accuracy="ABOUT", year_end = 2027)
score, factor = get_score_compare_dates(event2, event3)
assert(score == 0.5)
assert(factor > 0.39)
def __init__(self, union_id):
'''
Constructor it takes the union id from Geni
'''
#We initiate the base classes
geni_calls.__init__(self)
data = ""
if (union_id in geni.GENI_CALLED_UNIONS):
#In order to save calls we try to save the different calls
data = geni.GENI_CALLED_UNIONS[union_id]
else:
url = geni.GENI_API + union_id + geni.GENI_SINGLE_TOKEN + geni.get_token(
)
r = geni.geni_request_get(url)
data = r.json()
geni.GENI_CALLED_UNIONS[union_id] = data
self.union_data = {}
for key_value in data.keys():
if key_value == "id": self.union_data["id"] = data[key_value]
if key_value == "url": self.union_data["url"] = data[key_value]
if key_value == "guid": self.union_data["guid"] = data[key_value]
if key_value == "marriage_date":
#We might have an existing marriage in the file
self.union_data["marriage"] = self.get_date(
"marriage",
data["marriage_date"],
previous_event=self.union_data.get("marriage", None))
if key_value == "marriage_location":
place_data = {}
for location_key in data["marriage_location"].keys():
if location_key == "city":
place_data[location_key] = data["marriage_location"][
location_key]
if location_key == "county":
place_data[location_key] = data["marriage_location"][
location_key]
if location_key == "state":
place_data[location_key] = data["marriage_location"][
location_key]
if location_key == "country":
place_data[location_key] = data["marriage_location"][
location_key]
if location_key == "country_code":
place_data[location_key] = data["marriage_location"][
location_key]
if location_key == "latitude":
place_data[location_key] = data["marriage_location"][
location_key]
if location_key == "longitude":
place_data[location_key] = data["marriage_location"][
location_key]
if location_key == "formatted_location":
place_data[location_key] = data["marriage_location"][
location_key]
if not ("marriage" in self.union_data.keys()):
self.union_data["marriage"] = event_profile("marriage")
self.union_data["marriage"].setLocationAlreadyProcessed(
place_data)
if key_value == "status":
self.union_data["status"] = data[key_value]
if key_value == "partners":
self.union_data["partners"] = data[key_value]
if key_value == "children":
self.union_data["children"] = data[key_value]
def test_merge_profile(self):
'''
Test merge of profiles
'''
profile = gen_profile("Juana", "Bargas")
profile2 = gen_profile("Juana", "de Bargas Gómez")
profile.add_nickname("Juana de Bargas")
assert (profile.get_nicknames() == ["Juana de Bargas"])
profile.setCheckedDate("birth", 2016, 4, 23, "EXACT")
date1 = date(2016, 1, 1)
date2 = date(2018, 8, 25)
date3 = date(2018, 8, 27)
profile2.setCheckedDateWithDates("birth", date1, accuracy="ABOUT")
profile.setCheckedDate("death", 2018, 1, 1, "ABOUT")
profile2.setCheckedDate("death", 2018, 8, 24, "EXACT")
profile2.setCheckedDate("baptism", 2017, 1, 1, "ABOUT")
profile2.setCheckedDateWithDates("burial",
date2,
accuracy="BETWEEN",
date2=date3)
event_fail = event_profile("residence")
event_fail.setDate(1800, 2, 1)
assert (not profile2.setNewEvent(event_fail))
event_fail.setDate(2017, 11, 1)
assert (profile2.setNewEvent(event_fail))
profile.setComments("comment1")
profile2.setComments("comment2")
profile.setWebReference("THIS")
profile2.setWebReference("OTHER")
profile.gen_data["birth_place"] = {}
profile.gen_data["birth_place"]["raw"] = "a"
profile.set_accessible(True)
profile.set_main_language("es")
profile2.setPlaces("birth", GENERIC_PLACE_WITH_PLACE)
result = profile.merge_profile(profile2,
language="es",
convention="spanish_surname")
assert (result)
assert (profile.gen_data["name"] == "Juana")
assert (profile.gen_data["surname"] == "de Bargas Gómez")
assert (profile.gen_data["birth"].get_date() == date(2016, 4, 23))
assert (profile.gen_data["birth"].get_accuracy() == "EXACT")
assert (profile.gen_data["comments"] == "comment1\ncomment2")
assert ("THIS" in profile.get_all_urls())
assert ("OTHER" in profile.get_all_urls())
assert (len(profile.get_all_webs()) == 2)
assert (profile2.get_specific_event("death").get_date() == date(
2018, 8, 24))
assert (profile2.get_specific_event("death").get_accuracy() == "EXACT")
assert (
profile2.get_specific_event("burial").get_accuracy() == "BETWEEN")
assert (profile2.get_specific_event("burial").get_year_end() == 2018)
assert (profile2.get_specific_event("baptism").get_date() == date(
2017, 1, 1))
assert (
profile2.get_specific_event("baptism").get_accuracy() == "ABOUT")
assert (profile2.get_specific_event("birth").get_location()
["place_name"] == "Calle Nuestra Señora De Los Remedios")
assert (profile2.get_this_profile_url() == None)
#From the moment, the common profile class provides only the date of today as common date, to be improved in the future
assert (profile.get_update_datetime().day == datetime.now().day)
profile3 = gen_profile("Juana", "Bargas")
profile4 = gen_profile("Facundo", "Smith")
result2 = profile3.merge_profile(profile4,
language="es",
convention="spanish_surname")
self.assertFalse(result2)
def test_insert_methods(self):
'''
Testing insert methods inside RootsMagic
'''
initial_file = os.path.join(self.filelocation, "Rootstest.rmgc")
working_file = os.path.join(self.filelocation, "Rootstest_insert.rmgc")
if os.path.exists(working_file): os.remove(working_file)
copyfile(initial_file, working_file)
db = database_rm(working_file)
prof = db.get_profile_by_ID(5)
prof.setWebReference([TEST_GOOGLE, TEST_FACEBOOK])
prof.setWebReference(TEST_WIKIPEDIA,
name="Wikipedia",
notes="introduced")
webs = prof.get_all_webs()
google_found = False
for web in webs:
if web["url"] == "http://www.google.com":
if web["name"] == "": google_found = True
assert (google_found)
assert (prof.update_web_ref(TEST_GOOGLE, "Google", "A note"))
google_found = False
webs = prof.get_all_webs()
for web in webs:
if web["name"] == "Google": google_found = True
assert (google_found)
assert (TEST_GOOGLE in prof.get_all_urls())
assert (TEST_WIKIPEDIA in prof.get_all_urls())
assert (prof.get_specific_web("Google"))
assert (not prof.get_specific_web("Not existing"))
prof.del_web_ref(TEST_WIKIPEDIA)
assert (not (TEST_WIKIPEDIA in prof.get_all_urls()))
#It does not essent
assert (prof.update_web_ref("DOES NOT EXISTS", "Googles", "A note") is
None)
prof.set_task("TEST", details="HAHA")
#Introduce a research log
row_id = prof.set_task("TEST_OF_LOG", task_type=2)
assert (prof.get_specific_research_log("TEST_OF_LOG"))
assert (prof.get_specific_research_log("TEST_NOT_EXISTING") == None)
prof.set_research_item(row_id,
repository="www.google.com",
source="GOOGLE",
result="GOOD")
prof.update_research_item(row_id,
"www.google.com",
source="GOOGLE2",
result="BAD")
#Error when 2 research logs of the same name in the same profile.
profb = db.get_profile_by_ID(6)
with self.assertLogs("rootsmagic", level="WARNING") as cm:
profb.get_specific_research_log("TWICE")
assert ("TWICE" in cm.output[0])
prof2 = db.get_profile_by_ID(1)
assert (len(prof2.get_all_research_item()) == 2)
prof3 = db.get_profile_by_ID(3)
assert (len(prof3.get_all_research_item()) == 0)
#Setting up the sources
assert (prof2.get_source_id_ref("TESTING") == None)
prof2.set_source_id("TESTING")
prof2.setWebReference("http//here.com", "NEW_URL")
assert (prof2.get_source_id_ref("TESTING") == 1)
assert (prof2.get_citation_with_comments("http://test.com") == None)
prof2.set_citation(1, details="http://test.com")
assert (prof2.get_citation_with_comments("http://test.com") == 1)
#Testing the insert of the profiles
insert_profile = gen_profile("RootsMagic", "Adding")
insert_profile.setCheckedGender("M")
insert_profile.setCheckedDate("birth", 1820, accuracy="ABOUT")
event_both = event_profile("birth")
event_both.setLocationAlreadyProcessed(
{"formatted_location": "Gallegos, Segovia"})
event_both.setDate(1820, accuracy="ABOUT")
event_date = event_profile("death")
event_date.setDate(1902, month=2, day=1, accuracy="EXACT")
event_location = event_profile("burial")
event_location.setLocation("Aldealaguna, Segovia, Spain")
insert_profile.setNewEvent(event_both)
insert_profile.setNewEvent(event_date)
insert_profile.setNewEvent(event_location)
prof_id = db.add_profile(insert_profile)
#Check the results
prof_entered = db.get_profile_by_ID(prof_id)
assert (prof_entered.getName() == "RootsMagic")
assert (prof_entered.get_specific_event("birth").get_year() == 1820)
assert (
prof_entered.get_specific_event("birth").get_accuracy() == "ABOUT")
assert (prof_entered.get_specific_event("birth").get_location()["raw"]
== "Gallegos, Segovia")
assert (prof_entered.get_specific_event("death").get_year() == 1902)
assert (
prof_entered.get_specific_event("death").get_accuracy() == "EXACT")
assert (
prof_entered.get_specific_event("death").get_location() == None)
assert (prof_entered.get_specific_event("burial").get_year() == None)
assert (prof_entered.get_specific_event("burial").get_location()["raw"]
== 'Aldealaguna, Segovia, Spain')
#Now, let's also create a family for this profile
insert_wife = gen_profile("RootsMagic", "Wife")
insert_wife.setCheckedGender("F")
wife_id = db.add_profile(insert_wife)
prof_wife = db.get_profile_by_ID(wife_id)
event_marriage = event_profile("marriage")
event_marriage.setDate(1815, accuracy="ABOUT")
assert (prof_wife.get_specific_event("marriage") == [])
fam_id = db.add_family(father=prof_id,
mother=wife_id,
children=[6],
marriage=event_marriage)
assert (prof_wife.get_specific_event("marriage")[0].get_year() == 1815)
assert (db.get_family_from_child(6)[0] == fam_id)
#Methods for updating the family of RootsMagic
assert (not db.update_family(fam_id))
new_husband = gen_profile("New", "Husband")
new_wife = gen_profile("New", "Wife")
new_child = gen_profile("New", "Child")
new_husband_id = db.add_profile(new_husband)
new_wife_id = db.add_profile(new_wife)
new_child_id = db.add_profile(new_child)
marriage = event_profile("marriage")
marriage.setDate(1900)
fam3 = db.get_family_by_ID(3)
assert (fam3.getMother() == None)
db.update_family(3,
mother_id=new_wife_id,
children=[new_child_id],
marriage=marriage)
assert (fam3.getMother() == new_wife_id)
fam4 = db.get_family_by_ID(4)
assert (fam4.getFather() == None)
db.update_family(4, father_id=new_husband_id, marriage=marriage)
assert (fam4.getFather() == new_husband_id)
new_child2 = gen_profile("Newer", "Child")
new_child3 = gen_profile("Older", "Child")
previous_len = len(fam4.getChildren())
db.add_child(4, [new_child2, new_child3])
assert (len(fam4.getChildren()) - previous_len == 2)
new_partner1 = gen_profile("New", "Partner")
new_marriage = event_profile("birth")
new_marriage.set_year("2019")
previous_partners = len(db.get_partners_from_profile(4))
db.add_partner(4, new_partner1, new_marriage)
assert (len(db.get_partners_from_profile(4)) - previous_partners == 1)
db.close_db()
if os.path.exists(working_file): os.remove(working_file)
'''
Created on 8 oct. 2017
@author: Val
This example will show how to use several common genealogical tools that can be used.
All these functionalities are independent of the rest of the code
'''
from pyGenealogy.gen_utils import checkDateConsistency, getBestDate, get_formatted_location, get_name_surname_from_complete_name
from datetime import date
from pyGenealogy.common_event import event_profile
all_events = []
birth_event = event_profile("birth")
birth_event.setDate(1900, 1, 1)
all_events.append(birth_event)
residence_event = event_profile("residence")
residence_event.setDate(1910, 1, 1)
all_events.append(residence_event)
baptism_event = event_profile("baptism")
baptism_event.setDate(1901, 1, 12)
all_events.append(baptism_event)
marriage_event = event_profile("marriage")
marriage_event.setDate(1930, 6, 1)
all_events.append(marriage_event)
death_event = event_profile("death")
death_event.setDate(1970, 1, 1)
all_events.append(death_event)
burial_event = event_profile("burial")
def __get_profiles__(self):
'''
This function will take all different profiles included inside the excel file
'''
current_sheet = self.loaded_data[self.sheet_title]
#Iterator of missing inptus
number_missing = 0
#The id number to be used
id_profiles = 0
#Temporal variable checking the correct reading
correct_introduction = True
#Intermediate variables for potential parent surnames in the input file
potential_father_surname = []
potential_father_surname_repetitions = []
potential_mother_surname = []
potential_mother_surname_repetitions = []
#Intermediate variables for potential parent names in the input file
potential_father_name = []
potential_father_name_repetitions = []
potential_mother_name = []
potential_mother_name_repetitions = []
#We firstly detect the surnames of the parents of the profile,we cannot avoid the double
#iteration
for row in range(self.initial_row + 1,
self.loaded_data[self.sheet_title].max_row + 1):
for column_index in range(
self.initial_column,
self.loaded_data[self.sheet_title].max_column):
column_criteria = current_sheet.cell(row=self.initial_row,
column=column_index).value
cell_value = current_sheet.cell(row=row,
column=column_index).value
if (column_criteria
in ["father_full_name", "mother_full_name"]):
#If the cell_value is null we shall avoid continuing
if (cell_value is not None):
name_data = get_name_surname_from_complete_name(
cell_value,
convention=self.naming_convention,
language=self.language)
#We have two surnames or one?
surname_cand = name_data[1]
if (name_data[2] == 2):
surname_cand = name_data[1].split()[0]
if (column_criteria == "father_full_name"):
if (surname_cand not in potential_father_surname):
potential_father_surname.append(surname_cand)
potential_father_surname_repetitions.append(1)
else:
index = potential_father_surname.index(
surname_cand)
potential_father_surname_repetitions[
index] = potential_father_surname_repetitions[
index] + 1
if (not name_data[0] in potential_father_name):
potential_father_name.append(name_data[0])
potential_father_name_repetitions.append(1)
else:
index = potential_father_name.index(
name_data[0])
potential_father_name_repetitions[
index] = potential_father_name_repetitions[
index] + 1
elif (column_criteria == "mother_full_name"):
if (surname_cand not in potential_mother_surname):
potential_mother_surname.append(surname_cand)
potential_mother_surname_repetitions.append(1)
else:
index = potential_mother_surname.index(
surname_cand)
potential_mother_surname_repetitions[
index] = potential_mother_surname_repetitions[
index] + 1
if (not name_data[0] in potential_mother_name):
potential_mother_name.append(name_data[0])
potential_mother_name_repetitions.append(1)
else:
index = potential_mother_name.index(
name_data[0])
potential_mother_name_repetitions[
index] = potential_mother_name_repetitions[
index] + 1
index_father_surname = potential_father_surname_repetitions.index(
max(potential_father_surname_repetitions))
index_mother_surname = potential_mother_surname_repetitions.index(
max(potential_mother_surname_repetitions))
father_surname = potential_father_surname[index_father_surname]
mother_surname = potential_mother_surname[index_mother_surname]
index_father_name = potential_father_name_repetitions.index(
max(potential_father_name_repetitions))
index_mother_name = potential_mother_name_repetitions.index(
max(potential_mother_name_repetitions))
father_name = potential_father_name[index_father_name]
mother_name = potential_mother_name[index_mother_name]
self.father_profile = gen_profile(father_name, father_surname)
self.mother_profile = gen_profile(mother_name, mother_surname)
children_surname = get_children_surname(father_surname, mother_surname,
self.naming_convention)
#Now we read the complete file
for row in range(self.initial_row + 1,
self.loaded_data[self.sheet_title].max_row + 1):
included_profile = gen_profile("TBD", children_surname)
event_marriage = event_profile("marriage")
is_marriage = False
event_residence = event_profile("residence")
is_residence = False
included_right = True
for column_index in range(
self.initial_column,
self.loaded_data[self.sheet_title].max_column):
column_criteria = current_sheet.cell(row=self.initial_row,
column=column_index).value
cell_value = current_sheet.cell(row=row,
column=column_index).value
#We are ignoring all those cells that are empty.
if (cell_value):
this_introduction = True
#Ok, now we go one by one each of the different values
if (column_criteria == "gender"):
this_introduction = included_profile.setCheckedGender(
cell_value)
elif (column_criteria == "marriage_place_text"):
event_marriage.setLocation(cell_value, self.language)
is_marriage = True
elif (column_criteria == "residence_place_text"):
event_residence.setLocation(cell_value, self.language)
is_residence = True
elif (column_criteria == "marriage_date"):
mar_date = datetime.strptime(cell_value,
"%d %b %Y").date()
event_marriage.setDate(mar_date.year,
mar_date.month,
mar_date.day,
accuracy="EXACT")
elif (column_criteria == "residence_date"):
if (is_year(cell_value)):
event_residence.setDate(datetime.strptime(
str(cell_value.replace(" ", "")),
"%Y").date().year,
accuracy="ABOUT")
is_residence = True
elif (column_criteria in LOCATION_EQUIVALENCE.keys()):
included_profile.setPlaces(
LOCATION_EQUIVALENCE[column_criteria], cell_value,
self.language)
elif (column_criteria == "person_url"):
included_profile.setWebReference(
"https://familysearch.org/" + cell_value)
elif (column_criteria in date_fields.keys()):
#Notice that we shall detect if the given date is a year or a specific date
#we will make the different using "about" and using datetime in the background
if (is_year(cell_value)):
this_introduction = self.__include_a_date__(
column_criteria, included_profile,
datetime.strptime(
str(cell_value.replace(" ", "")),
"%Y").date(), "ABOUT")
else:
this_introduction = self.__include_a_date__(
column_criteria, included_profile,
datetime.strptime(cell_value,
"%d %b %Y").date(), "EXACT")
elif (column_criteria == "full_name"):
included_profile.set_name(
get_name_from_fullname(cell_value,
potential_father_surname,
potential_mother_surname,
language=self.language))
#In the case the name if not the same, we create it as nickname
if (cell_value != included_profile.returnFullName()):
included_profile.add_nickname(cell_value)
elif (column_criteria == "spouse_full_name"):
#Here we create a new profile using the surname of the guy
names = get_name_surname_from_complete_name(
cell_value,
convention=self.naming_convention,
language=self.language)
partner = gen_profile(names[0], names[1])
partner.set_id(id_profiles)
#If the surname is changed we shall include the previous surname in the nicknames
if (cell_value != partner.returnFullName()):
partner.add_nickname(cell_value)
#Now we link the profiles
included_profile.set_marriage_id_link(id_profiles)
self.related_profiles[id_profiles] = partner
elif (column_criteria == "other_full_names"):
#The separator provided by family search is semicolumn
parents = cell_value.split(";")
#We obtain firstly the different names
father_name, father_surname, _ = get_name_surname_from_complete_name(
parents[0],
convention=self.naming_convention,
language=self.language)
if (len(parents) == 2):
mother_name, mother_surname, _ = get_name_surname_from_complete_name(
parents[1],
convention=self.naming_convention,
language=self.language)
#The algorithm provides an empty surname, we fill it with not known
if (father_surname == ""):
father_surname = NOT_KNOWN_VALUE
if (mother_surname == ""):
mother_surname = NOT_KNOWN_VALUE
#Create the standard profiles
father = gen_profile(father_name, father_surname)
mother = gen_profile(mother_name, mother_surname)
#If the surname is changed we shall include the previous surname in the nicknames
if (parents[0] != father.returnFullName()):
father.add_nickname(parents[0])
if (len(parents) == 2) and (parents[1] !=
mother.returnFullName()):
mother.add_nickname(parents[1])
#add gender
father.setCheckedGender("M")
mother.setCheckedGender("F")
self.parents_profiles[id_profiles] = [father, mother]
elif (column_criteria in ignored_fields):
pass
else:
number_missing = number_missing + 1
logging.warning(COLUMN_NOT_FOUND + column_criteria)
if (not this_introduction): included_right = False
#This is a way to later on identify the link between the profiles
if is_marriage: included_profile.setNewEvent(event_marriage)
if is_residence: included_profile.setNewEvent(event_residence)
id_profiles += 1
if (not included_right): correct_introduction = False
self.profiles.append(included_profile)
#Now we know the data we fix some with the proper logic
for profile_obtained in self.profiles:
#If the baptism and birth are close enough we assign the birth place to the baptism place
birth_event = profile_obtained.gen_data.get("birth", None)
bapt_event = profile_obtained.gen_data.get("baptism", None)
if birth_event and bapt_event:
difference = bapt_event.get_date() - birth_event.get_date()
if abs(difference.days) < DIFFERNCE_BIRTH_BAPT:
place_birth = None
place_baptism = None
if profile_obtained.gen_data.get(
"birth", None) and profile_obtained.gen_data.get(
"birth", None).get_location():
place_birth = profile_obtained.gen_data.get(
"birth", None).get_location().get("raw", None)
if profile_obtained.gen_data.get(
"baptism", None) and profile_obtained.gen_data.get(
"baptism", None).get_location():
place_birth = profile_obtained.gen_data.get(
"baptism", None).get_location().get("raw", None)
if place_baptism and not place_birth:
profile_obtained.setPlaces(
"birth",
get_location_standard(
profile_obtained.gen_data["baptism"].
get_location()), self.language)
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]
partner.setWebReference(profile_obtained.get_all_urls())
#It is a partner so we add as opposite sex!
partner.setCheckedGender(
get_partner_gender(profile_obtained.gen_data["gender"]))
partner.setNewEvent(profile_obtained.gen_data["marriage"][0])
partner.setPlaces("marriage",
profile_obtained.gen_data["marriage"]
[0].get_location()["raw"],
language=self.language)
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]
father.setWebReference(profile_obtained.get_all_urls())
mother.setWebReference(profile_obtained.get_all_urls())
surnames = get_splitted_name_from_complete_name(
partner.gen_data["surname"], language=self.language)[0]
if (father.gen_data["surname"] == NOT_KNOWN_VALUE):
#It might be the case that the surname is empty
#Ok the data was not including the right data, but we know the surname
if (self.naming_convention == "spanish_surname"
and len(surnames) != 0):
father.gen_data["surname"] = surnames[0]
else:
father.gen_data["surname"] = partner.gen_data[
"surname"]
if (mother.gen_data["surname"] == NOT_KNOWN_VALUE) and (
self.naming_convention
== "spanish_surname") and (len(surnames) == 2):
mother.gen_data["surname"] = surnames[1]
if (self.naming_convention == "spanish_surname"):
#We need to ensure 2 surnames in spanish naming conventions
if not (mother.gen_data["surname"]
in partner.gen_data["surname"]) or (len(
partner.gen_data["surname"].split()) == 1):
#In the case we have 2 surnames, we try to eliminate the second surnames.
partner_surname_data = get_splitted_name_from_complete_name(
partner.gen_data["surname"],
language=self.language)
mother_surname_data = get_splitted_name_from_complete_name(
mother.gen_data["surname"],
language=self.language)
if len(partner.gen_data["nicknames"]) == 0:
partner.add_nickname(partner.returnFullName())
partner.gen_data["surname"] = " ".join([
partner_surname_data[0][0],
mother_surname_data[0][0]
])
#Finally, let's merge those profiles that are the same!
indexes_to_remove = []
iterating_list = list(self.profiles)
for i in range(len(iterating_list)):
#We are going one by one all the different profiles
if i not in indexes_to_remove:
for j, other_prof in enumerate(iterating_list[i + 1:]):
merged = self.profiles[i].merge_profile(
other_prof,
language=self.language,
convention=self.naming_convention)
if merged:
indexes_to_remove.append(i + j + 1)
new_values = list(set(indexes_to_remove))
new_values.sort()
for deletion in reversed(new_values):
del self.profiles[deletion]
return correct_introduction
def test_wrong_event(self):
'''
Test introducing a wrong event
'''
event = event_profile("birth")
assert (get_gedcom_formatted_date(event) == None)