def test_marriage_before_birth():
parsetree = (lark.Lark.open('gedcom/gedcom.lark', parser='earley').parse(TEST_GEDCOM_1))
tree = GedcomTransformer().transform(parsetree)
families = [f for f in tree.children if isinstance(f, Family)]
individuals = [i for i in tree.children if isinstance(i, Individual)]
assert_equals(True, validate_marriage_before_birth(individuals, families))
def test_divorce_after_death():
parsetree = (lark.Lark.open('gedcom/gedcom.lark',
parser='earley').parse(TEST_GEDCOM))
tree = GedcomTransformer().transform(parsetree)
families = [f for f in tree.children if isinstance(f, Family)]
individuals = [i for i in tree.children if isinstance(i, Individual)]
assert_equals(False, validate_divorce_after_death(individuals, families))
def test_return_true_for_normal_couples():
# Parse the TEST_GEDCOM_1
parsetree = (lark.Lark.open('gedcom/gedcom.lark',
parser='earley').parse(TEST_GEDCOM_1))
tree = GedcomTransformer().transform(parsetree)
families = [f for f in tree.children if isinstance(f, Family)]
individuals = [i for i in tree.children if isinstance(i, Individual)]
assert_equals(True, validate_incest(individuals, families))
def test_erroneous_input():
# Parse the TEST_GEDCOM_2
parsetree = (lark.Lark.open('gedcom/gedcom.lark',
parser='earley').parse(''))
tree = GedcomTransformer().transform(parsetree)
families = [f for f in tree.children if isinstance(f, Family)]
individuals = [i for i in tree.children if isinstance(i, Individual)]
assert_equals(True, validate_check_if_gay(individuals, families))
def test_detect_gay_couple():
# Parse the TEST_GEDCOM_1
parsetree = (lark.Lark.open('gedcom/gedcom.lark',
parser='earley').parse(TEST_GEDCOM_1))
tree = GedcomTransformer().transform(parsetree)
families = [f for f in tree.children if isinstance(f, Family)]
individuals = [i for i in tree.children if isinstance(i, Individual)]
assert_equals(False, validate_check_if_gay(individuals, families))
def test_parser():
# Create a Note using models only
note = Note(content=' Test Note')
# Create Individuals using models only
individual1 = Individual('11')
individual1.birth = Birth(datetime.date(1945, 4, 23))
individual1.death = Death(datetime.date(1995, 3, 26))
individual1.name = Name('Leandro', 'Ritter')
individual1.sex = Sex('M')
individual1.spouse_to = [
FamilySpouse('11'),
]
individual2 = Individual('12')
individual2.birth = Birth(datetime.date(1950, 12, 24))
individual2.name = Name('Alyssia', 'Holcomb')
individual2.sex = Sex('F')
individual2.spouse_to = [
FamilySpouse('11'),
]
individual3 = Individual('21')
individual3.birth = Birth(datetime.date(1960, 5, 13))
individual3.name = Name('Anita', 'Ritter')
individual3.sex = Sex('F')
individual3.child_to = [
FamilyChild('11'),
]
# Create a Family using models only
family = Family('11')
family.marriages = [
Marriage(datetime.date(1968, 9, 1)),
]
family.husbands = [
Husband('11'),
]
family.wives = [
Wife('12'),
]
family.children = [
Child('21'),
]
# Put them into a list in order
expected_output = [note, individual1, individual2, individual3, family]
# Parse the TEST_GEDCOM to get the AST
parsetree = (lark.Lark.open('gedcom/gedcom.lark',
parser='earley').parse(TEST_GEDCOM))
tree = GedcomTransformer().transform(parsetree)
# Test that the AST and models are equivalent
assert_equals(expected_output, tree.children)
def test_multiple_marriage():
flag = True
parsetree = (lark.Lark.open('gedcom/gedcom.lark',
parser='earley').parse(TEST_GEDCOM_1))
tree = GedcomTransformer().transform(parsetree)
families = [f for f in tree.children if isinstance(f, Family)]
individuals = [i for i in tree.children if isinstance(i, Individual)]
assert_true(flag)
def test_dates_before_current():
""" Unit test for dates_before_current"""
parsetree = (lark.Lark.open('gedcom/gedcom.lark',
parser='earley').parse(TEST_GEDCOM_1))
tree = GedcomTransformer().transform(parsetree)
if os.path.exists('fail_file') and os.path.exists('pass_file'):
individuals, families = parse_ged(pass_file)
self.assert_true(dates_before_current(individuals, families))
individuals, families = parse_ged(fail_file)
self.assert_false(dates_before_current(individuals, families))
else:
print("!!test_date_before_current acceptance file not found")
def test_table_fail_empty():
parsetree = (lark.Lark.open('gedcom/gedcom.lark', parser='earley')
.parse(""))
tree = GedcomTransformer().transform(parsetree)
families = {m.id: m for m in tree.children if isinstance(m, Family)}
individuals = {m.id: m for m in tree.children
if isinstance(m, Individual)}
# Create tables from parsing the TEST_GEDCOM
family_table = create_family_table(families, individuals)
individual_table = create_individual_table(individuals)
# Create a table manually and get the string of it
manual_family_table = PrettyTable()
manual_family_table.field_names = [
'ID',
'Married',
'Divorced',
'Husband ID',
'Husband Name',
'Wife ID',
'Wife Name',
'Children',
]
manual_individual_table = PrettyTable()
manual_individual_table.field_names = [
'ID',
'Name',
'Gender',
'Birthday',
'Age',
'Alive',
'Death',
'Child',
'Spouse',
]
# They should be equal
assert_equals(str(manual_family_table), str(family_table))
assert_equals(str(manual_individual_table), str(individual_table))
def main():
parser = argparse.ArgumentParser('Gedcom file evaluator')
parser.add_argument('gedcom_file',
type=argparse.FileType('r'),
help='Gedcom file')
parser.add_argument('-o',
'--output',
type=argparse.FileType('w'),
help='Output file')
args = parser.parse_args()
with args.gedcom_file as f:
# Parse the given gedcom file based on the gedcom.lark grammar
lark_parser = lark.Lark.open('gedcom/gedcom.lark', parser='earley')
parsetree = lark_parser.parse(f.read())
# Build the AST from the parsetree
tree = GedcomTransformer().transform(parsetree)
# We now have a list of all the individuals, families, and notes
# Isolate Family and Individual models into dictionaries
families = {m.id: m for m in tree.children if isinstance(m, Family)}
individuals = {
m.id: m
for m in tree.children if isinstance(m, Individual)
}
# Create and print the individual table
individual_table = create_individual_table(individuals)
print('Individuals')
print(individual_table)
# Create and print the family table
family_table = create_family_table(families, individuals)
print('Families')
print(family_table)
print('Validation')
for _, func in validators.items():
func(individuals.values(), families.values())
def test_parser_fail_empty():
parsetree = (lark.Lark.open('gedcom/gedcom.lark',
parser='earley').parse(""))
tree = GedcomTransformer().transform(parsetree)
assert_equals(tree.children, [])
def test_parser_fail():
parsetree = (lark.Lark.open('gedcom/gedcom.lark',
parser='earley').parse(TEST_GEDCOM_FAIL))
tree = GedcomTransformer().transform(parsetree)
def test_table():
parsetree = (lark.Lark.open('gedcom/gedcom.lark',
parser='earley').parse(TEST_GEDCOM))
tree = GedcomTransformer().transform(parsetree)
families = {m.id: m for m in tree.children if isinstance(m, Family)}
individuals = {m.id: m for m in tree.children if isinstance(m, Individual)}
# Create tables from parsing the TEST_GEDCOM
family_table = create_family_table(families, individuals)
individual_table = create_individual_table(individuals)
# Create a table manually and get the string of it
manual_family_table = PrettyTable()
manual_family_table.field_names = [
'ID',
'Married',
'Divorced',
'Husband ID',
'Husband Name',
'Wife ID',
'Wife Name',
'Children',
]
manual_family_table.add_row([
'11', '1968-09-01', None, '11', 'Leandro /Ritter/', '12',
'Alyssia /Holcomb/', [
'21',
]
])
manual_individual_table = PrettyTable()
manual_individual_table.field_names = [
'ID',
'Name',
'Gender',
'Birthday',
'Age',
'Alive',
'Death',
'Child',
'Spouse',
]
manual_individual_table.add_row([
'11', 'Leandro /Ritter/', 'M', '1945-04-23', '73', False, '1995-03-26',
[], [
'11',
]
])
manual_individual_table.add_row([
'12', 'Alyssia /Holcomb/', 'F', '1950-12-24', '68', True, None, [],
[
'11',
]
])
manual_individual_table.add_row([
'21', 'Anita /Ritter/', 'F', '1960-05-13', '58', True, None, [
'11',
], []
])
# They should be equal
assert_equals(str(manual_family_table), str(family_table))
assert_equals(str(manual_individual_table), str(individual_table))
