def main(args):
color_map = ColorMap('tft_colors.txt')
family_tree = FamilyTree('tree.txt', color_map)
family_tree.assignGenotypes(family_tree.root)
print family_tree.root
print family_tree.poss_geneotypes[family_tree.root]
def main(args):
color_map = ColorMap('tft_colors.txt')
family_tree = FamilyTree('tree.txt', color_map)
family_tree.assignGenotypes(family_tree.root)
print family_tree.root
print family_tree.poss_geneotypes[family_tree.root]
def __init__(self, database: str = None, program: str = None):
self.family_tree = FamilyTree()
if program is not None:
self.execute_file(program)
status = None
if database is not None:
status = self.parse_file(database)
if status != 'exit':
self.main_loop()
def test_add_husband(self):
person_name = 'Diana'
gender = 'Female'
familytree = FamilyTree(person_name, gender)
husband_name = 'Evan'
familytree.add_husband(person_name, husband_name)
assert familytree.list_of_families[0].husband.name == 'Evan'
assert familytree.list_of_families[0].wife.name == 'Diana'
assert familytree.list_of_families[0].children == []
def test_find_person(self):
familytree = FamilyTree('Diana', 'Female')
husband = Person('Evan', 'Male')
family = Family(husband, familytree.root_person)
familytree.list_of_families.append(family)
familytree.list_of_families[0].add_daughter('Nisha')
familytree.list_of_families[0].add_son('Joe')
actual_person = familytree.find_person('Joe')
assert actual_person.name == 'Joe'
def test_family_with_parent_name(self):
person_name = 'Evan'
gender = 'Male'
familytree = FamilyTree(person_name, gender)
familytree.add_wife('Evan', 'Diana')
familytree.list_of_families[0].add_daughter('Nisha')
familytree.add_husband('Nisha', 'Adam')
familytree.list_of_families[0].add_son('Joe')
familytree.add_wife('Joe', 'Niki')
family = familytree.find_family_with_parent_name('Joe')
assert family.children == []
def _initialize_tree(cls):
father = FamilyTreeNode("Father", FamilyTreeNode("Dad's Dad"),
FamilyTreeNode("Dad's Mom"))
mother = FamilyTreeNode("Mother", FamilyTreeNode("Mom's Dad"),
FamilyTreeNode("Mom's Mom"))
player = FamilyTreeNode('Me', father, mother)
return FamilyTree(player)
def test_initialize_familytree(self):
name = 'Ben'
gender = 'Male'
familytree = FamilyTree(name, gender)
assert familytree.root_person.name == 'Ben'
assert familytree.root_person.gender == 'Male'
assert familytree.list_of_families == []
def test_inorder(self):
root = FamilyTreeNode("Father", FamilyTreeNode("Dad's Dad"),
FamilyTreeNode("Dad's Mom"))
tree = FamilyTree(root)
expected = [
TraversalStates.START, TraversalStates.FATHER,
TraversalStates.ACTION, TraversalStates.CHILD,
TraversalStates.ACTION, TraversalStates.MOTHER,
TraversalStates.ACTION, TraversalStates.CHILD, TraversalStates.DONE
]
for i, state in enumerate(tree.inorder()):
self.assertEqual(state, expected[i])
root = FamilyTreeNode(
"Father", FamilyTreeNode("Dad's Dad"),
FamilyTreeNode("Dad's Mom", FamilyTreeNode("Dad's Mom's Dad")))
tree = FamilyTree(root)
expected = [
TraversalStates.START, TraversalStates.FATHER,
TraversalStates.ACTION, TraversalStates.CHILD,
TraversalStates.ACTION, TraversalStates.MOTHER,
TraversalStates.FATHER, TraversalStates.ACTION,
TraversalStates.CHILD, TraversalStates.ACTION,
TraversalStates.CHILD, TraversalStates.DONE
]
for i, state in enumerate(tree.inorder()):
self.assertEqual(state, expected[i])
def generate_tree(self, max_depth=10):
""":rtype FamilyTree"""
root_profile = self.base_profile
root = Node(name=root_profile['id'],
data=geni_to_person_data(root_profile))
ancestors_q = Queue()
ancestors_q.put(root)
processed_ancestors, descendants_q = self.process_queue(
ancestors_q, max_depth, processing_ancestors=True)
# processed_descendants, _ = self.process_queue(descendants_q, max_depth, processing_ancestors=False)
processed_descendants = {}
processed = {}
for k, v in processed_ancestors.items():
processed[k] = Person(data=v.data,
ancestors=v,
descendants=processed_descendants[k]
if k in processed_descendants else None)
for k, v in processed_descendants.items():
if k not in processed:
processed[k] = Person(data=v.data,
ancestors=None,
descendants=v)
return FamilyTree(root=root_profile['id'], people=processed)
import json
from family_tree import FamilyTree
with open("dark_dataset.json", mode="r") as f:
dataset = json.load(f)
ft = FamilyTree(dataset, "characters")
ft.color_mapping_list = [
(lambda n: n[0] in ft.parentage_edges.keys(), "blue"),
# This condition deals with descendants from the knot. Why start from Silja?
# We could start from Jonas & Martha's child, but them we would never be able
# to reach Silja and her descendents, because both her parents exist in the
# Origin World. However, because she was conceived through time travelling,
# which was never invented in Origin World, she can't exist there too.
(lambda n: n[0] in ft.get_descendants_from("Silja Tiedemann"), "red"),
# Bartosz is a special case because Regina exists in the Origin World
# and Boris Niewald probably does too. However, both them only met
# while Regina was being bullied by Katharina and Ulrich, the latter
# which doesn't exist in the Origin World. As we can't conclude his
# true status, he gets a special color here
(lambda n: n[0] == "Bartosz Tiedemann", "yellow"),
]
root_node = list(ft.persons_parentages_mapping["Silja Tiedemann"])[0]
ft.plot_graph(root_node=root_node)
def main():
input = raw_input(
"Welcome to familytree. Please enter input in the format Name<space>Gender of the person whose familytree you are creating.\n"
)
input_list = input.split(' ')
root_person_name = input_list[0]
root_person_gender = input_list[1]
familytree = FamilyTree(root_person_name, root_person_gender)
print "Welcome to", root_person_name, "'s familytree."
print "Find or Update relationships.\n"
while True:
command = raw_input("Input:")
pattern_existing_relation = "Person=(?P<name>[a-zA-Z]+) Relation=(?P<relation>[a-zA-Z]+)"
pattern_new_relation = "(?P<relation1>[a-zA-Z]+)=(?P<name1>[a-zA-Z]+) (?P<relation2>[a-zA-Z]+)=(?P<name2>[a-zA-Z]+)"
if command.startswith('Person'):
entry = re.match(pattern_existing_relation, command)
person_name = entry.group('name')
relation = entry.group('relation')
if relation == 'Sons':
family = familytree.find_family_with_parent_name(person_name)
sons_list = family.get_sons(person_name)
print "Sons=" + ','.join(sons_list)
elif relation == 'Daughters':
family = familytree.find_family_with_parent_name(person_name)
daughters_list = family.get_daughters(person_name)
print "Daughters=" + ','.join(daughters_list)
elif relation == 'Wife':
wife = familytree.get_spouse(person_name)
print "Wife=", wife
elif relation == 'Husband':
husband = familytree.get_spouse(person_name)
print "Husband=", husband
elif relation == 'Mother':
family = familytree.find_family_with_child_name(person_name)
mother = family.wife
print "Mother=", mother
elif relation == 'Father':
family = familytree.find_family_with_child_name(person_name)
father = family.husband
print "Father=", father
elif relation == 'Brothers':
family = familytree.find_family_with_child_name(person_name)
brothers_list = family.get_brothers(person_name)
print "Brothers=", ','.join(brothers_list)
elif relation == 'Sisters':
family = familytree.find_family_with_child_name(person_name)
sisters_list = family.get_sisters(person_name)
print "Sisters=", ','.join(sisters_list)
elif relation == 'Cousins':
cousins_list = familytree.get_cousins(person_name)
print "Cousins=", ','.join(cousins_list)
elif relation == 'Grandmothers':
grandmothers_list = familytree.get_grandmothers(person_name)
print "Grandmothers=", ','.join(grandmothers_list)
elif relation == 'Grandfathers':
grandfathers_list = familytree.get_grandfathers(person_name)
print "Grandfathers=", ','.join(grandfathers_list)
elif relation == 'Grandsons':
grandsons_list = familytree.get_grandsons(person_name)
print "Grandsons=", ','.join(grandsons_list)
elif relation == 'Granddaughters':
granddaughters_list = familytree.get_granddaughters(
person_name)
print "Granddaughters=", ','.join(granddaughters_list)
elif relation == 'Aunts':
aunts_list = familytree.get_aunts(person_name)
print "Aunts=", ','.join(aunts_list)
elif relation == 'Uncles':
uncles_list = familytree.get_uncles(person_name)
print "Uncles=", ','.join(uncles_list)
elif re.match(pattern_new_relation, command):
entry = re.match(pattern_new_relation, command)
relation1 = entry.group('relation1')
name1 = entry.group('name1')
relation2 = entry.group('relation2')
name2 = entry.group('name2')
if relation2 == 'Wife':
familytree.add_wife(name1, name2)
print "\nWelcome to the family,", name2
elif relation2 == 'Husband':
familytree.add_husband(name1, name2)
print "\nWelcome to the family,", name2
elif relation2 == 'Son':
family = familytree.find_family_with_parent_name(name1)
family.add_son(name2)
print "\nWelcome to the family,", name2
elif relation2 == 'Daughter':
family = familytree.find_family_with_parent_name(name1)
family.add_daughter(name2)
print "\nWelcome to the family,", name2
else:
print "Unknown command, please try again."
class Shell:
start_sign = '> '
exit_command = 'exit'
query_command = '?-'
cmd_pattern = '<subject> <predicate> [objects] | <?-> <query> | table | back | exit'
def __init__(self, database: str = None, program: str = None):
self.family_tree = FamilyTree()
if program is not None:
self.execute_file(program)
status = None
if database is not None:
status = self.parse_file(database)
if status != 'exit':
self.main_loop()
def parse_command(self, command: str):
command = command.strip('\n')
if not len(command):
return
if command == 'table':
self.family_tree.print_as_table()
return
if command == 'back':
self.family_tree.remove_last_predicate()
return
args = command.split()
if len(args) < 2:
raise ValueError(f'Incorrect format. Use follow pattern: {self.cmd_pattern}')
if args[0] == self.query_command:
self.family_tree.query(' '.join(args[1:]))
else:
self.family_tree.apply(args)
def parse_file(self, file):
with open(file) as f:
lines = f.readlines()
for command in lines:
if command == self.exit_command:
break
try:
self.parse_command(command)
except Exception as e:
print(f'[Error] {e}')
return command # return last executed command
def execute_file(self, file):
self.family_tree.consult(file)
def main_loop(self):
command = input(self.start_sign)
while command != self.exit_command:
try:
self.parse_command(command)
except Exception as e:
print(f'[Error] {e}')
command = input(self.start_sign)
print('Bye!')
def test_get_aunts(self):
familytree = FamilyTree('Evan', 'Male')
familytree.add_wife('Evan', 'Diana')
EvanDianasfamily = familytree.find_family_with_parent_name('Diana')
EvanDianasfamily.add_daughter('Nisha')
EvanDianasfamily.add_son('John')
EvanDianasfamily.add_son('Joe')
EvanDianasfamily.add_son('Alex')
familytree.add_wife('Alex', 'Nancy')
familytree.add_wife('Joe', 'Niki')
familytree.add_husband('Nisha', 'Adam')
AlexNancysfamily = familytree.find_family_with_parent_name('Alex')
AlexNancysfamily.add_son('Jacob')
AlexNancysfamily.add_son('Shaun')
JoeNikisfamily = familytree.find_family_with_parent_name('Niki')
JoeNikisfamily.add_son('Piers')
JoeNikisfamily.add_daughter('Sally')
aunts_list = familytree.get_aunts('Shaun')
assert len(aunts_list) == 2
def main():
file_content = InputReader().read_input()
family = FamilyTree(male_name="Shan", female_name="Anga") # Initializing with Kind and spouse.
family.do_operations_read_from_file(file_content)
