def __init__(self, parser, db):
"""Initializes the class with families and individuals"""
self.parser = parser
self.db = db
self.errors = []
self.tables = []
self.tables.append(TableHelpers.dataframe2table(self.db.individuals, "Individuals"))
self.tables.append(TableHelpers.dataframe2table(self.db.families, "Families"))
def two_pair_twins_two_families(self):
individuals = {
'CHILD1': Individual(id='CHILD1',
birth=date(2005, 3, 10),
famc='FAM1'),
'CHILD2': Individual(id='CHILD2',
birth=date(2006, 2, 23),
famc='FAM1'),
'CHILD3': Individual(id='CHILD3',
birth=date(2009, 7, 20),
famc='FAM1'),
'CHILD4': Individual(id='CHILD4',
birth=date(2009, 7, 20),
famc='FAM1'),
'CHILD5': Individual(id='CHILD5',
birth=date(2007, 5, 5),
famc='FAM2'),
'CHILD6': Individual(id='CHILD6',
birth=date(2007, 5, 5),
famc='FAM2')
}
families = {
'FAM1':
Family(id='FAM1',
child_ids=['CHILD1', 'CHILD2', 'CHILD3', 'CHILD4']),
'FAM2':
Family(id='FAM2', child_ids=['CHILD5', 'CHILD6'])
}
parser = TestParser(individuals, families)
db = TestDatabase(individuals, families)
pt_list = US32.list_multiple_births(parser, db)
self.assertEqual(len(pt_list), 1)
self.assertEqual(TableHelpers.get_row_count(pt_list[0]), 2)
def living_married(self):
individuals = {
"HUSB1": Individual(id="HUSB1", fams="FAM1"),
"WIFE1": Individual(id="WIFE1", fams="FAM1"),
"HUSB2": Individual(id="HUSB2", fams="FAM2"),
"WIFE2": Individual(id="WIFE2", fams="FAM2"),
"WIFE3": Individual(id="WIFE3", famc="FAM3"),
}
families = {
"FAM1":
Family(id="FAM1",
married=date(2012, 11, 12),
divorced=None,
husband_id="HUSB1",
wife_id="WIFE1"),
"FAM2":
Family(id="FAM2",
married=date(2012, 10, 16),
divorced=None,
husband_id="HUSB2",
wife_id="WIFE2"),
}
parser = TestParser(individuals, families)
db = TestDatabase(individuals, families)
pt_list = US30.list_living_married(parser, db)
#print(pt_list)
self.assertGreater(TableHelpers.get_row_count(pt_list[0]), 0)
def list_multiple_births(parser, db):
tables = []
multiple_birth_children = db.individuals.groupby(['famc','birth'])
multiple_births = DataFrame({'Children': multiple_birth_children.size()}).reset_index()
multiple_births = multiple_births[(multiple_births.Children > 1)].rename(columns={'famc':'FamID','birth':'Birthdate'})
pt = TableHelpers.dataframe2table(multiple_births, "US32: Multiple Births")
tables.append(pt)
return tables
def nullDeath(self):
individuals = {
"NULLBIRT": Individual(id="NULLBIRT", death=None)
}
parser = TestParser(individuals, {})
db = TestDatabase(individuals, {})
pt_list = US36.list_recent_deaths(parser, db)
self.assertEqual(TableHelpers.get_row_count(pt_list[0]), 0)
def recent(self):
individuals = {
"RECENT": Individual(id="RECENT", death=date.today()),
"OLD": Individual(id="OLD", death=date(1989,7,31))
}
parser = TestParser(individuals, {})
db = TestDatabase(individuals, {})
pt_list = US36.list_recent_deaths(parser, db)
self.assertEqual(TableHelpers.get_row_count(pt_list[0]), 1)
def list_deceased(parser, db):
tables = []
today = date.today()
individuals = db.individuals
individuals = individuals.loc[(
~individuals["death"].isnull())] # ~ is the loc equivalent of "not"
pt = TableHelpers.dataframe2table(individuals,
"US29 - Deceased Individuals")
tables.append(pt)
return tables
def noneRecent(self):
individuals = {
"OLD1": Individual(id="OLD1", death=date(1990,2,22)),
"OLD2": Individual(id="OLD2", death=date(1991,6,16))
}
parser = TestParser(individuals, {})
db = TestDatabase(individuals, {})
pt_list = US36.list_recent_deaths(parser, db)
self.assertEqual(TableHelpers.get_row_count(pt_list[0]), 0)
def two_anniversaries(self):
marriage = date(2001, self.today.month, self.today.day)
individuals = {}
families = {
"FAM1": Family(id="FAM1", married=DateHelpers.add_time(marriage, 15, "days")),
"FAM2": Family(id="FAM2", married=DateHelpers.add_time(marriage, 16, "days")),
"FAM3": Family(id="FAM3", married=DateHelpers.add_time(marriage, 100, "days")),
}
parser = TestParser(individuals, families)
pt_list = US39.upcoming_anniversaries(parser)
self.assertEqual(TableHelpers.get_row_count(pt_list[0]), 2)
def all_deceased(self):
individuals = {
"PERSON1": Individual(id="PERSON1", death=date(2005, 10, 5)),
"PERSON2": Individual(id="PERSON2", death=date(2005, 10, 15)),
"PERSON3": Individual(id="PERSON3", death=date(2006, 9, 5)),
}
families = {}
parser = TestParser(individuals, families)
db = TestDatabase(individuals, families)
pt_list = US29.list_deceased(parser, db)
self.assertEqual(TableHelpers.get_row_count(pt_list[0]), 3)
def none_deceased(self):
individuals = {
"PERSON1": Individual(id="PERSON1"),
"PERSON2": Individual(id="PERSON2"),
"PERSON3": Individual(id="PERSON3"),
}
families = {}
parser = TestParser(individuals, families)
db = TestDatabase(individuals, families)
pt_list = US29.list_deceased(parser, db)
self.assertEqual(TableHelpers.get_row_count(pt_list[0]), 0)
def large_age_differences(self):
individuals = {
"HUSB1": Individual(id="HUSB1", birth=date(1967,9,30),fams="FAM1"),
"WIFE1": Individual(id="WIFE1", birth=date(1989,7,31),fams="FAM1")
}
families = {
"FAM1": Family(id="FAM1", married=date(2009,10,31), divorced=None, husband_id="HUSB1", wife_id="WIFE1")
}
parser = TestParser(individuals, families)
db = TestDatabase(individuals, families)
pt_list = US34.list_large_age_differences(parser, db)
#print(pt_list[0])
self.assertEqual(TableHelpers.get_row_count(pt_list[0]), 2)
def older_siblings_by_age(parser, db):
tables = []
for _, row in db.families.iterrows():
famID = row["ID"]
children = db.individuals.loc[db.individuals["famc"] == famID]
children = children.sort_values(
by=["birth"], ascending=True) # Ascending birth dates
if children.shape[0] > 0: # if there are more than 0 rows
pt = TableHelpers.dataframe2table(
children,
"US28: Children in Family {} Descending - Oldest First".format(
famID))
tables.append(pt)
return tables
def list_recent_births(parser, db):
tables = []
recents = []
today = date.today()
for person in parser.individuals.values():
if person.birth is not None:
if (DateHelpers.dates_within(today, person.birth, 30, "days")):
recents.append(person)
tables.append(
TableHelpers.individuals2table(recents, "US35: Recent Births"))
return tables
def list_ages(parser, db):
tables = []
ages = []
for indiv in parser.individuals.values():
if indiv.birth is not None:
ages.append(DateHelpers.calculate_age(indiv.birth, None))
else:
ages.append(None)
individuals = db.individuals
individuals["Age"] = pd.Series(ages).values
newTable = TableHelpers.dataframe2table(individuals,
"US27: Individuals and Ages")
tables.append(newTable)
return tables
def not_large_age_differences(self):
individuals = {
"HUSB2": Individual(id="HUSB2", birth=date(1990,2,22),fams="FAM2"),
"WIFE2": Individual(id="WIFE2", birth=date(1991,6,16),fams="FAM2")
}
families = {
"FAM2": Family(id="FAM2", married=date(2012,10,16), divorced=None, husband_id="HUSB2", wife_id="WIFE2")
}
parser = TestParser(individuals, families)
db = TestDatabase(individuals, families)
pt_list = US34.list_large_age_differences(parser, db)
#print(pt_list[0])
self.assertEqual(TableHelpers.get_row_count(pt_list[0]), 0)
def list_orphans(parser):
'''List all children younger than 18 with both parents deceased'''
tables = []
orphans = []
for id in parser.families:
family = parser.families[id]
mother = parser.individuals[family.wife_id]
father = parser.individuals[family.husband_id]
if mother.death and father.death:
for child_id in family.child_ids:
child = parser.individuals[child_id]
if DateHelpers.calculate_age(child.birth, None) < 18:
orphans.append(child)
pt = TableHelpers.individuals2table(orphans, "US33: List Orphans")
tables.append(pt)
return tables
def living_single(self):
individuals = {
"HUSB": Individual(id="HUSB", birth=date(1900, 2, 11), famc="FAM1"),
"WIFE": Individual(id="WIFE", birth=date(1930, 4, 18), famc="FAM2"),
"HUSB2": Individual(id="HUSB2", birth=date(2000, 8, 17), fams="FAM2"),
"WIFE2": Individual(id="WIFE2", birth=date(1990, 9, 26), fams="FAM2"),
}
families = {
"FAM2": Family(id="FAM2", married=date(2012,10,16), divorced=None, husband_id="HUSB2", wife_id="WIFE2")
}
parser = TestParser(individuals, families)
db = TestDatabase(individuals, families)
pt_list = US31.list_living_single(parser, db)
#print(pt_list)
self.assertGreater(TableHelpers.get_row_count(pt_list[0]), 0)
def upcoming_anniversaries(parser):
tables = []
today = date.today()
upcoming_anniversaries = []
for family in parser.families.values():
updated = date(today.year, family.married.month, family.married.day)
# If we've passed the date, we check the next year
if updated < today:
updated = date(today.year + 1, family.married.month,
family.married.day)
if DateHelpers.date_diff(updated, today, "days") <= 30:
upcoming_anniversaries.append(family)
tables.append(
TableHelpers.families2table(upcoming_anniversaries,
"US39: Upcoming Anniversaries"))
return tables
def upcoming_birthdays(parser):
tables = []
today = date.today()
upcoming_people = []
for individual in parser.individuals.values():
updated = date(today.year, individual.birth.month,
individual.birth.day)
# If we've passed the date, we check the next year
if updated < today:
updated = date(today.year + 1, individual.birth.month,
individual.birth.day)
if DateHelpers.date_diff(updated, today, "days") <= 30:
upcoming_people.append(individual)
tables.append(
TableHelpers.individuals2table(upcoming_people,
"US38: Upcoming Birthdays"))
return tables
def two_birthdays(self):
birthday = date(2001, self.today.month, self.today.day)
individuals = {
"PERSON1":
Individual(id="PERSON1",
birth=DateHelpers.add_time(birthday, 25, "days")),
"PERSON2":
Individual(id="PERSON2",
birth=DateHelpers.add_time(birthday, 70, "days")),
"PERSON3":
Individual(id="PERSON3",
birth=DateHelpers.add_time(birthday, 15, "days")),
}
families = {}
parser = TestParser(individuals, families)
pt_list = US38.upcoming_birthdays(parser)
self.assertEqual(TableHelpers.get_row_count(pt_list[0]), 2)
def in_order(self):
individuals = {
"WIFE": Individual(id="WIFE", fams="FAM"),
"HUSB": Individual(id="HUSB", fams="FAM"),
"CHLD1": Individual(id="CHLD1", famc="FAM", birth=date(2001, 2,
1)),
"CHLD2": Individual(id="CHLD2", famc="FAM", birth=date(2001, 2,
2)),
}
families = {"FAM": Family(id="FAM")}
parser = TestParser(individuals, families)
db = TestDatabase(individuals, families)
pt_list = US28.older_siblings_by_age(parser, db)
for index, row in enumerate(pt_list[0]):
value = TableHelpers.get_row_field_value(row, "ID")
if index == 0:
self.assertEqual(value, "CHLD1")
elif index == 1:
self.assertEqual(value, "CHLD2")
def one_pair_twins(self):
individuals = {
'CHILD1': Individual(id='CHILD1',
birth=date(2006, 1, 15),
famc='FAM1'),
'CHILD2': Individual(id='CHILD2',
birth=date(2007, 6, 19),
famc='FAM1'),
'CHILD3': Individual(id='CHILD3',
birth=date(2007, 6, 19),
famc='FAM1')
}
families = {
'FAM1': Family(id='FAM1', child_ids=['CHILD1', 'CHILD2', 'CHILD3'])
}
parser = TestParser(individuals, families)
db = TestDatabase(individuals, families)
pt_list = US32.list_multiple_births(parser, db)
self.assertEqual(len(pt_list), 1)
self.assertEqual(TableHelpers.get_row_count(pt_list[0]), 1)
