def __init__(self, conn):
self.conn = conn
self.suitecursor = SuiteCursor(self.conn)
self.aptsrc = AptSourceHandler(self.conn)
self.main_path = None
self.profile = Profile(self.conn)
self.family = Family(self.conn)
def __init__(self, anno=1000, estimate_people=100):
# список всех людей в социуме, на данный момент включая мертвых (проверить)
self.roll_genome()
Socium.class_var_init(estimate_people)
Human.init_files()
Family.init_files()
FoodDistribution.init_files()
self.soc_list: List[Human] = list()
self.families: List[Family] = list()
self.stat = statistics.Soc_stat(self)
self.soc_food = FoodDistribution(self)
self.person_stat_file = open('./person_features_table.csv', 'w', encoding="UTF16")
self.person_stat = csv.writer(self.person_stat_file, delimiter='\t', lineterminator='\n')
pers_stat_header = list()
for i in genetics.GN:
pers_stat_header.append(i)
hextend = ['макс. возр. отца', 'возр. отца при рождении', 'макс. возр. матери', 'возр. матери при рождении', 'каким по счету родился', 'кол-во супругов', 'кол-во детей', 'возраст смерти']
pers_stat_header.extend(hextend)
self.person_stat.writerow(pers_stat_header)
# текущий год
self.anno: Anno = Anno(anno)
# локальный счетчик смертей, после появления чужака обнуляется
self.short_death_count: int = 0
# общий счетчик смертей
self.global_death_count: int = 0
# давно умершие родственники (чтобы зря не крутить большие циклы)
self.forgotten: List = []
self.people_alive: List = []
def test_married_date(self):
"""add married date 28 MAR 2001
"""
married_date = datetime.strptime("28 MAR 2001", '%d %b %Y')
fam = Family("@F01@")
fam.set_date("28 MAR 2001", "married")
self.assertEqual(married_date, fam.get_married_date())
def test_divorced_date(self):
"""add divorced date 1 APR 1970
"""
divorced_date = datetime.strptime("1 APR 1970", '%d %b %Y')
fam = Family("@F09@")
fam.set_date("1 APR 1970", "divorced")
self.assertEqual(divorced_date, fam.get_divorced_date())
def __init__(self, conn):
StatementCursor.__init__(self, conn)
self.conn = conn
self.set_table('profiles')
self._traits = ProfileTrait(conn)
self._env = ProfileEnvironment(conn)
self._pfam = StatementCursor(conn)
self._pfam.set_table('profile_family')
self._fam = Family(conn)
def test_add_son(self):
husband = Person('Evan', 'Male')
wife = Person('Diana', 'Female')
family = Family(husband, wife)
son_name = 'Alex'
family.add_son(son_name)
assert family.children[0].name == 'Alex'
assert family.children[0].gender == 'Male'
def test_add_daughter(self):
husband = Person('Evan', 'Male')
wife = Person('Diana', 'Female')
family = Family(husband, wife)
daughter_name = 'Nisha'
family.add_daughter(daughter_name)
assert family.children[0].name == 'Nisha'
assert family.children[0].gender == 'Female'
class PaellaDatabase(Element):
def __init__(self, conn, path='/'):
Element.__init__(self, 'paelladatabase')
self.conn = conn
self.stmt = StatementCursor(self.conn)
self._profile_traits_ = ProfileTrait(self.conn)
self.path = path
self.suites = SuitesElement()
self.appendChild(self.suites)
for row in self._suite_rows():
args = map(
str,
[row.suite, row.nonus, row.updates, row.local, row.common])
element = SuiteElement(*args)
self.suites.appendChild(element)
self.profiles = PaellaProfiles(self.conn)
self.family = Family(self.conn)
suites = [x.suite for x in self._suite_rows()]
for suite in suites:
self.appendChild(TraitsElement(self.conn, suite))
def _suite_rows(self):
return self.stmt.select(table='suites', order='suite')
def write(self, filename):
path = join(self.path, filename)
xmlfile = file(path, 'w')
self.writexml(xmlfile, indent='\t', newl='\n', addindent='\t')
def backup(self, path=None):
if path is None:
path = self.path
if not isdir(path):
raise Error, '%s not a directory' % path
dbfile = file(join(path, 'database.xml'), 'w')
self.writexml(dbfile, indent='\t', newl='\n', addindent='\t')
dbfile.close()
self.backup_profiles(path)
self.backup_families(path)
suites = [x.suite for x in self._suite_rows()]
for suite in suites:
makepaths(join(path, suite))
trait = Trait(self.conn, suite)
for t in trait.get_trait_list():
trait.set_trait(t)
trait.backup_trait(join(path, suite))
def backup_profiles(self, path=None):
profiles_dir = join(path, 'profiles')
makepaths(profiles_dir)
self.profiles.export_profiles(profiles_dir)
def backup_families(self, path=None):
fpath = join(path, 'families')
makepaths(fpath)
self.family.export_families(fpath)
class PaellaDatabase(Element):
def __init__(self, conn, path='/'):
Element.__init__(self, 'paelladatabase')
self.conn = conn
self.stmt = StatementCursor(self.conn)
self._profile_traits_ = ProfileTrait(self.conn)
self.path = path
self.suites = SuitesElement()
self.appendChild(self.suites)
for row in self._suite_rows():
args = map(str, [row.suite, row.nonus, row.updates, row.local, row.common])
element = SuiteElement(*args)
self.suites.appendChild(element)
self.profiles = PaellaProfiles(self.conn)
self.family = Family(self.conn)
suites = [x.suite for x in self._suite_rows()]
for suite in suites:
self.appendChild(TraitsElement(self.conn, suite))
def _suite_rows(self):
return self.stmt.select(table='suites', order='suite')
def write(self, filename):
path = join(self.path, filename)
xmlfile = file(path, 'w')
self.writexml(xmlfile, indent='\t', newl='\n', addindent='\t')
def backup(self, path=None):
if path is None:
path = self.path
if not isdir(path):
raise Error, '%s not a directory' % path
dbfile = file(join(path, 'database.xml'), 'w')
self.writexml(dbfile, indent='\t', newl='\n', addindent='\t')
dbfile.close()
self.backup_profiles(path)
self.backup_families(path)
suites = [x.suite for x in self._suite_rows()]
for suite in suites:
makepaths(join(path, suite))
trait = Trait(self.conn, suite)
for t in trait.get_trait_list():
trait.set_trait(t)
trait.backup_trait(join(path, suite))
def backup_profiles(self, path=None):
profiles_dir = join(path, 'profiles')
makepaths(profiles_dir)
self.profiles.export_profiles(profiles_dir)
def backup_families(self, path=None):
fpath = join(path, 'families')
makepaths(fpath)
self.family.export_families(fpath)
def test_marriedToSiblings(self):
self.famA = Family()
self.famA.addFamID('@F6@')
self.famA.addHusb('@I6@')
self.famA.addWife('@I7@')
self.famA.addMarr('5 OCT 1999')
self.assertTrue(marriedToSiblings(self.famA, self.individuals))
self.famB = Family()
self.famB.addFamID('@F6@')
self.famB.addHusb('@I6@')
self.famB.addWife('@I8@')
self.famB.addMarr('5 OCT 1999')
self.assertFalse(marriedToSiblings(self.famB, self.individuals))
def test_marriedToSiblings(self):
self.famA = Family()
self.famA.addFamID('@F6@')
self.famA.addHusb('@I6@')
self.famA.addWife('@I7@')
self.famA.addMarr('5 OCT 1999')
self.assertTrue(marriedToSiblings(self.famA, self.individuals))
self.famB = Family()
self.famB.addFamID('@F6@')
self.famB.addHusb('@I6@')
self.famB.addWife('@I8@')
self.famB.addMarr('5 OCT 1999')
self.assertFalse(marriedToSiblings(self.famB, self.individuals))
def setUp(self):
self.fam1 = Family()
self.fam1.addFamID('@F2@')
self.fam1.addHusb('@I1@')
self.fam1.addWife('@I2@')
self.fam1.addChil('@I4@')
self.fam1.addChil('@I5@')
self.fam1.addMarr('5 OCT 1999')
self.fam1.addDiv('12 JUN 2012')
self.fam2 = Family()
self.fam2.addFamID('@F3@')
self.fam2.addHusb('@I3@')
self.fam2.addWife('@I3@')
class OutputTest(unittest.TestCase):
def setUp(self):
self.indi = Individual()
self.indi.addID('@I2@')
self.indi.addName('John Rivas')
self.indi.addSex('M')
self.indi.addBirt('9 MAY 1978')
self.indi.addDeat('12 APR 2013')
self.indi.addFams('@F2@')
self.indi.addFamc('@F1@')
self.fam1 = Family()
self.fam1.addFamID('@F2@')
self.fam1.addHusb('@I2@')
self.fam1.addWife('@I2@')
self.fam1.addChil('@I2@')
self.fam1.addChil('@I2@')
self.individuals = dict()
self.individuals["one"] = self.indi
self.families = dict()
self.families["one"] = self.fam1
def test_outputIndiSummary(self):
outputIndiSummary(self.individuals)
def test_outputFamSummary(self):
outputFamSummary(self.families, self.individuals)
def test_add_children(self):
"""test adding children
"""
fam = Family("@F11@")
child_id_1 = "@I08@"
fam.add_child(child_id_1)
self.assertEqual(1, len(fam.get_children()))
self.assertEqual(child_id_1, fam.get_children()[0])
child_id_2 = "@I09@"
fam.add_child(child_id_2)
self.assertEqual(2, len(fam.get_children()))
self.assertEqual(child_id_2, fam.get_children()[1])
def process_line_data(self, data):
"""line data is a dict of the format:
{
"level": int,
"tag": string,
"args": string,
"valid": "Y" or "N"
}
"""
if data["valid"] == "N":
raise ValueError
if data["level"] < 2:
self._current_level_1 = None
if data["tag"] == "FAM":
self._curr_family = Family(data["args"])
# US22
if data["args"] in self.families:
self._msgs.add_message(self.CLASS_IDENTIFIER, "US22", data["args"], "NA",
"Not unique family ID " + data["args"] + " ")
self.families[data["args"]] = self._curr_family
if data["tag"] == "MARR":
self._current_level_1 = "MARR"
if data["tag"] == "DIV":
self._current_level_1 = "DIV"
if data["tag"] == "HUSB":
self._curr_family.set_husband_id(data["args"])
self._current_level_1 = "HUSB"
if data["tag"] == "WIFE":
self._curr_family.set_wife_id(data["args"])
self._current_level_1 = "WIFE"
if data["tag"] == "CHIL":
self._curr_family.add_child(data["args"])
self._current_level_1 = "CHIL"
if data["tag"] == "DATE":
if self._current_level_1 == "MARR":
self._curr_family.set_date(data["args"], "married")
if self._current_level_1 == "DIV":
self._curr_family.set_date(data["args"], "divorced")
def test_get_sisters(self):
husband = Person('Evan', 'Male')
wife = Person('Diana', 'Female')
family = Family(husband, wife)
family.add_son('John')
family.add_son('Alex')
family.add_son('Joe')
family.add_daughter('Nisha')
list_of_sisters = family.get_sisters('Joe')
assert 'Nisha' in list_of_sisters
assert 'Alex' not in list_of_sisters
def __set_suite_cursors__(self, suite):
self.traits = StatementCursor(self.conn, 'traits')
self.traits.set_table(ujoin(suite, 'traits'))
self.traitparent = TraitParent(self.conn, suite)
self.traitpackage = TraitPackage(self.conn, suite)
self.traittemplate = TraitTemplate(self.conn, suite)
self.family = Family(self.conn)
def main():
family = Family([
Person('Trillian', date(1970, 3, 14)),
Person('Arthur', date(1965, 7, 4)),
Person('Ford', date(1995, 2, 2)),
Person('Zaphod', date(1997, 5, 1)),
Person('Douglas', date(1999, 4, 2))
])
singles = [
Person('Marvin', date(1991, 1, 1)),
Person('Slarti', date(1993, 9, 9))
]
oldest = None
earliest_date = date.max
for m in family:
if m.birthdate < earliest_date:
oldest = m
earliest_date = m.birthdate
for s in singles:
if s.birthdate < earliest_date:
oldest = s
earliest_date = s.birthdate
max_age = (date.today() - earliest_date).days / 365.2425
print('Oldest person: {}; Age: {:6.2f}'.format(oldest.name, max_age))
def __init__(self, conn):
self.conn = conn
self.suitecursor = SuiteCursor(self.conn)
self.aptsrc = AptSourceHandler(self.conn)
self.main_path = None
self.profile = Profile(self.conn)
self.family = Family(self.conn)
def __init__(self, conn, path='/'):
Element.__init__(self, 'paelladatabase')
self.conn = conn
self.stmt = StatementCursor(self.conn)
self._profile_traits_ = ProfileTrait(self.conn)
self.path = path
self.aptsources = AptSourceListElement()
self.appendChild(self.aptsources)
if 'apt_sources' in self.stmt.tables():
for row in self.stmt.select(table='apt_sources', order=['apt_id']):
element = AptSourceElement(row.apt_id, row.uri, row.dist, row.sections,
row.local_path)
self.aptsources.appendChild(element)
self.suites = SuitesElement()
self.appendChild(self.suites)
for row in self._suite_rows():
args = map(str, [row.suite, row.nonus, row.updates, row.local, row.common])
element = SuiteElement(*args)
for suiteapt in self.stmt.select(table='suite_apt_sources', order=['ord'],
clause=Eq('suite', row.suite)):
element.appendChild(SuiteAptElement(row.suite,
suiteapt.apt_id, str(suiteapt.ord)))
self.suites.appendChild(element)
else:
print 'WARNING, apt_sources table does not exist, backing up anyway'
self.profiles = PaellaProfiles(self.conn)
self.family = Family(self.conn)
suites = [x.suite for x in self._suite_rows()]
for suite in suites:
self.appendChild(TraitsElement(self.conn, suite))
def __init__(self, conn, path='/'):
Element.__init__(self, 'paelladatabase')
self.conn = conn
self.stmt = StatementCursor(self.conn)
self._profile_traits_ = ProfileTrait(self.conn)
self.path = path
self.suites = SuitesElement()
self.appendChild(self.suites)
for row in self._suite_rows():
args = map(str, [row.suite, row.nonus, row.updates, row.local, row.common])
element = SuiteElement(*args)
self.suites.appendChild(element)
self.profiles = PaellaProfiles(self.conn)
self.family = Family(self.conn)
suites = [x.suite for x in self._suite_rows()]
for suite in suites:
self.appendChild(TraitsElement(self.conn, suite))
def test_tooManyChildren(self):
self.assertFalse(tooManyChildren(self.fam1))
famT = Family()
self.assertFalse(tooManyChildren(famT))
famT.addChil("1")
famT.addChil("2")
famT.addChil("3")
famT.addChil("4")
famT.addChil("5")
self.assertTrue(tooManyChildren(famT))
def test_default_data(self):
"""default init data, wife and husband ids
"""
fam_id = "@F01@"
husband_id = "@I01@"
wife_id = "@I02"
fam = Family(fam_id)
fam.set_husband_id(husband_id)
fam.set_wife_id(wife_id)
self.assertEqual(fam_id, fam.get_family_id())
self.assertEqual(husband_id, fam.get_husband_id())
self.assertEqual(wife_id, fam.get_wife_id())
def print_family():
from family import Family
fam1 = Family('Chaz Davis', '650 Sherard Circle', 'Lexington', 'Ky',
'40517', '35', '859-699-8820')
fam2 = Family('Charlie Davis', '650 Sherard Circle', 'Lexington', 'Ky',
'40517', '66', '859-699-8346')
fam3 = Family('Chris O\'Callaghan', '1760 Sandhurst Cv', 'Lexington', 'Ky',
'40509', '34', '859-619-6238')
print('Myself: ')
print(fam1)
print()
print('My Father: ')
print(fam2)
print()
print('My Best Friend: ')
print(fam3)
def compute_serializable_fields(cls, session, keys):
from family import Family
result = {'family': None}
## retrieve family object
if keys.get('ht-epithet'):
result['family'] = Family.retrieve_or_create(
session, {'epithet': keys['ht-epithet']}, create=True)
if result['family'] is None:
raise error.NoResultException()
return result
def test_family_init(self):
husband = Person('Evan', 'Male')
wife = Person('Diana', 'Female')
family = Family(husband, wife)
assert family.husband.name == 'Evan'
assert family.husband.gender == 'Male'
assert family.wife.name == 'Diana'
assert family.wife.gender == 'Female'
assert family.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 __init__(self, farm_count=100, rng=None):
self.activities = activity.Activities()
if rng is None:
rng = np.random.RandomState()
self.rng = rng
self.time = 0
self.farms = []
for i in range(farm_count):
farm = Farm(eutopia=self, area=100)
self.farms.append(farm)
self.families = []
for farm in self.farms:
family = Family(self)
family.add_farm(farm)
self.families.append(family)
self.govt_cost = 0
def __init__(self, farm_count=100, rng=None):
self.activities = activity.Activities()
if rng is None:
rng = np.random.RandomState()
self.rng = rng
self.time = 0
self.farms = []
for i in range(farm_count):
farm = Farm(eutopia=self, area=100)
self.farms.append(farm)
self.families = []
for farm in self.farms:
family = Family(self)
family.add_farm(farm)
self.families.append(family)
self.govt_cost = 0
def test_both_dates(self):
"""add both dates together
"""
fam = Family("@F01@")
married_date = datetime.strptime("28 MAR 2001", '%d %b %Y')
fam.set_date("28 MAR 2001", "married")
divorced_date = datetime.strptime("1 APR 1970", '%d %b %Y')
fam.set_date("1 APR 1970", "divorced")
self.assertEqual(married_date, fam.get_married_date())
self.assertEqual(divorced_date, fam.get_divorced_date())
def compute_serializable_fields(cls, session, keys):
from family import Family
result = {'family': None}
## retrieve family object
if keys.get('ht-epithet'):
result['family'] = Family.retrieve_or_create(
session, {'epithet': keys['ht-epithet']},
create=True)
if result['family'] is None:
raise error.NoResultException()
return result
def syn_cell_data_func(column, renderer, model, iter, data=None):
'''
'''
v = model[iter][0]
author = None
if v.author is None:
author = ''
else:
author = utils.xml_safe(unicode(v.author))
renderer.set_property('markup', '<i>%s</i> %s (<small>%s</small>)'
% (Genus.str(v), author, Family.str(v.family)))
def syn_cell_data_func(column, renderer, model, iter, data=None):
'''
'''
v = model[iter][0]
author = None
if v.author is None:
author = ''
else:
author = utils.xml_safe(unicode(v.author))
renderer.set_property('markup', '<i>%s</i> %s (<small>%s</small>)'
% (Genus.str(v), author, Family.str(v.family)))
def test_tooManyChildren(self):
self.assertFalse(tooManyChildren(self.fam1))
famT = Family()
self.assertFalse(tooManyChildren(famT))
famT.addChil("1")
famT.addChil("2")
famT.addChil("3")
famT.addChil("4")
famT.addChil("5")
self.assertTrue(tooManyChildren(famT))
def _syn_data_func(column, cell, model, iter, data=None):
v = model[iter][0]
syn = v.synonym
cell.set_property('markup', '<i>%s</i> %s (<small>%s</small>)'
% (Genus.str(syn),
utils.xml_safe(unicode(syn.author)),
Family.str(syn.family)))
# set background color to indicate it's new
if v.id is None:
cell.set_property('foreground', 'blue')
else:
cell.set_property('foreground', None)
def _syn_data_func(column, cell, model, iter, data=None):
v = model[iter][0]
syn = v.synonym
cell.set_property(
'markup', '<i>%s</i> %s (<small>%s</small>)' %
(Genus.str(syn), utils.xml_safe(unicode(
syn.author)), Family.str(syn.family)))
# set background color to indicate it's new
if v.id is None:
cell.set_property('foreground', 'blue')
else:
cell.set_property('foreground', None)
def test_marriedMoreThanOnePerson(self):
self.families = dict()
self.famA = Family()
self.famA.addFamID('@A1@')
self.famA.addHusb('@H1@')
self.famA.addWife('@W1@')
self.families['1'] = self.famA
self.assertFalse(marriedMoreThanOnePerson(self.families))
self.famB = Family()
self.famB.addFamID('@B1@')
self.famB.addHusb('@H2@')
self.famB.addWife('@W2@')
self.families['2'] = self.famB
self.assertFalse(marriedMoreThanOnePerson(self.families))
self.famB.addWife('@W1@')
self.assertTrue(marriedMoreThanOnePerson(self.families))
self.famA.addDiv('12 JUN 2012')
self.famB.addWife('@W1@')
self.assertFalse(marriedMoreThanOnePerson(self.families))
def createClass(part2, part3, individuals, families):
if part3 == "INDI":
tempID = int(re.sub(r'@+|I+', "", part2))
individuals[tempID] = Individual()
individuals[tempID].addID(part2)
return individuals[tempID]
elif part3 == "FAM":
tempFamID = int(re.sub(r'@+|F+', "", part2))
families[tempFamID] = Family()
families[tempFamID].addFamID(part2)
return families[tempFamID]
else:
return None
def grow_up(self):
""" upon reaching adulthood males start family and look for mate.
females go onto Prospects list.
can set profession manually.
"""
if self.gender == 'm':
prior_family = self.family
self.family = Family(self.village, self.family.house, dad=self)
prior_family.remove_kid(self)
elif self.gender == 'f':
pass
self.check_mate()
return self
def __init__(self, conn, path='/'):
Element.__init__(self, 'paelladatabase')
self.conn = conn
self.stmt = StatementCursor(self.conn)
self._profile_traits_ = ProfileTrait(self.conn)
self.path = path
self.suites = SuitesElement()
self.appendChild(self.suites)
for row in self._suite_rows():
args = map(str, [row.suite, row.nonus, row.updates, row.local, row.common])
element = SuiteElement(*args)
self.suites.appendChild(element)
self.profiles = PaellaProfiles(self.conn)
self.family = Family(self.conn)
suites = [x.suite for x in self._suite_rows()]
for suite in suites:
self.appendChild(TraitsElement(self.conn, suite))
def setUp(self):
self.indi = Individual()
self.indi.addID('@I2@')
self.indi.addName('John Rivas')
self.indi.addSex('M')
self.indi.addBirt('9 MAY 1978')
self.indi.addDeat('12 APR 2013')
self.indi.addFams('@F2@')
self.indi.addFamc('@F1@')
self.fam1 = Family()
self.fam1.addFamID('@F2@')
self.fam1.addHusb('@I2@')
self.fam1.addWife('@I2@')
self.fam1.addChil('@I2@')
self.fam1.addChil('@I2@')
self.individuals = dict()
self.individuals["one"] = self.indi
self.families = dict()
self.families["one"] = self.fam1
def test_addFamID(self):
fam = Family()
value = '@A1@'
fam.addFamID(value)
self.assertEqual(fam.getFamID(), value)
def test_addChil(self):
fam = Family()
value = '@A1@'
fam.addChil(value)
self.assertEqual(fam.getChil()[0], value)
def test_addHusb(self):
fam = Family()
value = '@A1@'
fam.addHusb(value)
self.assertEqual(fam.getHusb(), value)
def build_lists_from_file(filename):
"""Parses the Ged file and builds the Family and Individual objects.
Returns a touple of dictionaries, in the for ({},{}), where the first is
the list of families (indexed by family ID) and the second is the list of
individuals (indexed by the individual ID).
"""
load_valid_tags()
lines = open(filename, "r").readlines()
individuals = {}
families = {}
def generateUntilLevelZero(seq):
"""Creates a list of GedLine objects until the given sequence has a
GedLine with level zero. This is useful for retrieving a sequence of
lines of a single object (family of individual)
"""
for e in seq:
line = GedLine(e)
if line.level() != 0:
yield line
else:
break
index = 0 # line index
while index < len(lines)-1:
line = GedLine(lines[index])
if line.level() == 0 and line.content() == "INDI":
# Create Individual
ind = Individual(line.tag()) # Tag is the ID
individual_lines = generateUntilLevelZero(lines[index+1:])
for l in individual_lines:
if l.tag() == "NAME":
ind.name = l.content()
elif l.tag() == "GIVN":
ind.givenname = l.content()
elif l.tag() == "SURN":
ind.surname = l.content()
elif l.tag() == "SEX":
ind.sex = l.content()
elif l.tag() == "NOTE":
ind.note = l.content()
elif l.tag() == "BIRT":
ind.setbirthday(individual_lines.next().content())
elif l.tag() == "DEAT":
ind.setdeathday(individual_lines.next().content())
individuals[ind.id] = ind
elif line.level() == 0 and line.content() == "FAM":
# Create Family
fam = Family(line.tag()) # Tag is the ID
family_lines = generateUntilLevelZero(lines[index+1:])
for l in family_lines:
if l.tag() == "HUSB":
fam.husband = l.content()
elif l.tag() == "WIFE":
fam.wife = l.content()
elif l.tag() == "CHIL":
fam.children.append(l.content())
elif l.tag() == "MARR":
fam.setmarrydate(family_lines.next().content())
families[fam.id] = fam
index += 1
return families, individuals
def test_addWife(self):
fam = Family()
value = '@A1@'
fam.addWife(value)
self.assertEqual(fam.getWife(), value)
class FamilyTest(unittest.TestCase):
def setUp(self):
self.fam1 = Family()
self.fam1.addFamID('@F2@')
self.fam1.addHusb('@I1@')
self.fam1.addWife('@I2@')
self.fam1.addChil('@I4@')
self.fam1.addChil('@I5@')
self.fam1.addMarr('5 OCT 1999')
self.fam1.addDiv('12 JUN 2012')
self.fam2 = Family()
self.fam2.addFamID('@F3@')
self.fam2.addHusb('@I3@')
self.fam2.addWife('@I3@')
""" Test setters """
def test_addFamID(self):
fam = Family()
value = '@A1@'
fam.addFamID(value)
self.assertEqual(fam.getFamID(), value)
def test_addHusb(self):
fam = Family()
value = '@A1@'
fam.addHusb(value)
self.assertEqual(fam.getHusb(), value)
def test_addWife(self):
fam = Family()
value = '@A1@'
fam.addWife(value)
self.assertEqual(fam.getWife(), value)
def test_addChil(self):
fam = Family()
value = '@A1@'
fam.addChil(value)
self.assertEqual(fam.getChil()[0], value)
""" Test getters """
def test_getFamID(self):
FAMID = '@F2@'
self.assertEqual(self.fam1.getFamID(), FAMID)
fam = Family()
self.assertEqual(fam.getFamID(), None)
def test_getHusb(self):
HUSB = "@I1@"
self.assertEqual(self.fam1.getHusb(), HUSB)
fam = Family()
self.assertEqual(fam.getHusb(), None)
def test_getWife(self):
WIFE = "@I2@"
self.assertEqual(self.fam1.getWife(), WIFE)
fam = Family()
self.assertEqual(fam.getWife(), None)
def test_getChil(self):
CHIL = ['@I4@', '@I5@']
self.assertEqual(self.fam1.getChil(), CHIL)
fam = Family()
self.assertEqual(fam.getChil(), [])
def test_getMarr(self):
MARR = '5 OCT 1999'
self.assertEqual(self.fam1.getMarr(), MARR)
fam = Family()
self.assertEqual(fam.getMarr(), None)
def test_getDiv(self):
DIV = '12 JUN 2012'
self.assertEqual(self.fam1.getDiv(), DIV)
fam = Family()
self.assertEqual(fam.getDiv(), None)
def test_getHusb(self):
HUSB = "@I1@"
self.assertEqual(self.fam1.getHusb(), HUSB)
fam = Family()
self.assertEqual(fam.getHusb(), None)
def test_getFamID(self):
FAMID = '@F2@'
self.assertEqual(self.fam1.getFamID(), FAMID)
fam = Family()
self.assertEqual(fam.getFamID(), None)
def test_getChil(self):
CHIL = ['@I4@', '@I5@']
self.assertEqual(self.fam1.getChil(), CHIL)
fam = Family()
self.assertEqual(fam.getChil(), [])
def test_getWife(self):
WIFE = "@I2@"
self.assertEqual(self.fam1.getWife(), WIFE)
fam = Family()
self.assertEqual(fam.getWife(), None)
def test_getMarr(self):
MARR = '5 OCT 1999'
self.assertEqual(self.fam1.getMarr(), MARR)
fam = Family()
self.assertEqual(fam.getMarr(), None)
def test_getDiv(self):
DIV = '12 JUN 2012'
self.assertEqual(self.fam1.getDiv(), DIV)
fam = Family()
self.assertEqual(fam.getDiv(), None)
class PaellaExporter(object):
def __init__(self, conn):
self.conn = conn
self.cursor = self.conn.cursor(statement=True)
self.suitecursor = SuiteCursor(self.conn)
self.init_db_element()
if len(self.cursor.tables()):
self.setup_cursors()
def setup_cursors(self):
self.profile = Profile(self.conn)
self.family = Family(self.conn)
self.machines = MachineHandler(self.conn)
self.diskconfig = DiskConfigHandler(self.conn)
def init_db_element(self):
self.dbelement = PaellaDatabaseElement()
def make_complete_db_element(self):
self.init_db_element()
self._append_apt_sources_to_db_element()
fields = ['suite']
for suite in self.suitecursor.get_suites():
self._append_suite_to_db_element(suite)
def _append_apt_sources_to_db_element(self):
rows = self.cursor.select(table='apt_sources', order=['apt_id'])
for row in rows:
self.dbelement.append_apt_source(row.apt_id, row.uri, row.dist,
row.sections, row.local_path)
def _append_suite_to_db_element(self, suite):
self.dbelement.append_suite(suite)
rows = self.cursor.select(table='suite_apt_sources', order=['ord'],
clause=Eq('suite', suite))
for row in rows:
self.dbelement.append_suite_apt_source(row.suite, row.apt_id,
str(row.ord))
rows = self.cursor.select(fields=['trait'], table='%s_traits' % suite,
order=['trait'])
traits = [row.trait for row in rows]
self.dbelement.append_suite_traits(suite, traits=traits)
def set_db_export_path(self, dirname):
self.db_export_path = path(dirname)
def export_db_element(self, dirname=None, filename='database.xml'):
if dirname is None:
dirname = self.db_export_path
filename = path(dirname) / filename
dbfile = filename.open('w')
self.dbelement.writexml(dbfile, indent='\t', newl='\n', addindent='\t')
dbfile.close()
def _make_suite_export_path(self, suite):
suitedir = self.db_export_path / suite
makepaths(suitedir)
return suitedir
def export_all_profiles(self, dirname=None):
if dirname is None:
dirname = self.db_export_path / 'profiles'
makepaths(dirname)
profiles = self.profile.get_profile_list()
self.report_total_profiles(len(profiles))
env = self.profile.make_environment_object()
for profile in profiles:
env.set_profile(profile)
self.profile.export_profile(dirname, profile=profile, env=env)
self.report_profile_exported(profile)
def export_all_diskconfigs(self, dirname=None):
if dirname is None:
dirname = self.db_export_path / 'diskconfig'
makepaths(dirname)
for row in self.diskconfig.cursor.select():
filename = row.name
diskconfig = dirname / filename
diskconfig.write_text(row.content)
def export_all_families(self, dirname=None):
if dirname is None:
dirname = self.db_export_path / 'families'
makepaths(dirname)
self.family.export_families(dirname)
def export_trait(self, trait, suite=None, dirname=None, traitdb=None):
if traitdb is None:
if suite is None:
RuntimeError , "you must pass a suite if you don't pass a Trait object"
print "make new traitdb"
traitdb = Trait(self.conn, suite)
traitdb.set_trait(trait)
if suite is None:
suite = traitdb.suite
if dirname is None:
dirname = self._make_suite_export_path(suite)
traitdb.export_trait(dirname)
self.report_trait_exported(trait, dirname)
def export_all_traits(self, suite, dirname=None):
self.report_start_exporting_traits()
traitdb = Trait(self.conn, suite)
traits = traitdb.get_trait_list()
self.report_total_traits(len(traits))
for trait in traits:
self.export_trait(trait, dirname=dirname, traitdb=traitdb)
#self.report_all_traits_exported()
def export_suite(self, suite, dirname=None):
self.export_all_traits(suite, dirname=dirname)
def export_all_suites(self, dirname=None):
suites = self.suitecursor.get_suites()
self.report_total_suites(len(suites))
for suite in suites:
self.report_exporting_suite(suite)
self.export_suite(suite, dirname=dirname)
self.report_suite_exported(suite)
def export_machine_database(self, dirname=None):
if dirname is None:
dirname = self.db_export_path
else:
dirname = path(dirname)
self.machines.export_machine_database(dirname)
def _export_environment_common(self, dirname, envtype):
if dirname is None:
dirname = self.db_export_path
else:
dirname = path(dirname)
if envtype == 'default':
envclass = DefaultEnvironment
elif envtype == 'current':
envclass = CurrentEnvironment
else:
raise RuntimeError , 'bad envtype %s' % envtype
env = envclass(self.conn)
#filename = os.path.join(path, '%s-environment' % envtype)
#efile = file(filename, 'w')
#env.write(efile)
#efile.close()
filename = '%s-environment' % envtype
fullname = dirname / filename
envfile = fullname.open('w')
env.write(envfile)
envfile.close()
def export_default_environment(self, path=None):
self._export_environment_common(path, 'default')
def export_current_environment(self, path=None):
self._export_environment_common(path, 'common')
def perform_full_export(self, path):
self.make_complete_db_element()
self.set_db_export_path(path)
self.export_db_element()
self.export_all_suites()
self.export_all_profiles()
self.export_all_families()
self.export_all_diskconfigs()
self.export_machine_database()
self.export_default_environment()
###################
# reporting methods
####################
def report_total_suites(self, total):
print 'exporting %d suites' % total
def report_exporting_suite(self, suite):
print 'exporting suite %s' % suite
def report_suite_exported(self, suite):
print 'suite %s exported'
def report_total_traits(self, total):
print 'exporting %d traits' % total
def report_trait_exported(self, trait, path):
print 'trait %s exported to %s' % (trait, path)
def report_all_traits_exported(self, *args):
print 'all traits exported'
def report_start_exporting_traits(self):
print 'starting to export traits'
def report_total_profiles(self, total):
print 'exporting %d profiles' % total
def report_profile_exported(self, profile):
print 'profile %s exported' % profile
def setup_cursors(self):
self.profile = Profile(self.conn)
self.family = Family(self.conn)
self.machines = MachineHandler(self.conn)
self.diskconfig = DiskConfigHandler(self.conn)
class PaellaImporter(object):
def __init__(self, conn):
self.conn = conn
self.suitecursor = SuiteCursor(self.conn)
self.aptsrc = AptSourceHandler(self.conn)
self.main_path = None
self.profile = Profile(self.conn)
self.family = Family(self.conn)
def set_main_path(self, dirname):
self.main_path = path(dirname)
def parse_main_xml(self, filename=None):
if filename is None:
filename = self.main_path / 'database.xml'
parsed = PaellaParser(filename)
return parsed
def start_schema(self):
try:
start_schema(self.conn)
except AlreadyPresentError:
print "primary tables already present"
def import_all_families(self, dirname=None):
if dirname is None:
dirname = self.main_path / 'families'
xmlfiles = dirname.listdir('*.xml')
self.report_total_families(len(xmlfiles))
while xmlfiles:
familyxml = xmlfiles.pop(0)
try:
self.import_family(familyxml)
except UnbornError:
xmlfiles.append(familyxml)
print 'import families from', dirname
def import_family(self, filename):
self.family.import_family_xml(filename)
self.report_family_imported(filename.namebase)
def import_all_profiles(self, dirname=None):
if dirname is None:
dirname = self.main_path / 'profiles'
dirname = path(dirname)
xmlfiles = dirname.listdir('*.xml')
self.report_total_profiles(len(xmlfiles))
for xmlfile in xmlfiles:
self.profile.import_profile(xmlfile)
self.report_profile_imported(xmlfile.namebase)
def import_all_diskconfigs(self, dirname=None):
if dirname is None:
dirname = self.main_path / 'diskconfig'
dirname = path(dirname)
files = dirname.listdir()
cursor = self.conn.cursor(statement=True)
for diskconfig in files:
name= diskconfig.basename()
data = dict(name=name, content=file(diskconfig).read())
cursor.insert(table='diskconfig', data=data)
# here suite is a parsed xml object (find name)
def make_suite(self, suite):
current_suites = self.suitecursor.get_suites()
if suite.name not in current_suites:
apt_ids = [e.apt_id for e in suite.aptsources]
self.suitecursor.make_suite(suite.name, apt_ids)
else:
raise RuntimeError , 'suite %s already exists' % suite
# aptsources is the PaellaParser.aptsources attribute
def import_apt_sources(self, aptsources):
self.report_total_apt_sources(len(aptsources))
for apt in aptsources:
self.import_parsed_apt_source(apt)
# here apt is an AptSourceParser object
def import_parsed_apt_source(self, apt):
self.report_importing_aptsrc(apt.apt_id)
self.aptsrc.insert_apt_source_row(apt.apt_id, apt.uri, apt.dist,
apt.sections, apt.local_path)
self.aptsrc.insert_packages(apt.apt_id)
self.report_aptsrc_imported(apt.apt_id)
def _import_traits(self, suite, traitlist, dirname):
self.report_total_traits(len(traitlist))
missing = self._find_missing_packages(suite, traitlist, dirname)
if missing:
self.report_missing_packages(suite, missing)
raise MissingPackagesError, report_missing_packages(suite, missing)
else:
while len(traitlist):
trait = traitlist.pop(0)
try:
self._import_trait(suite, dirname / trait)
self.report_trait_imported(trait)
except UnbornError:
traitlist.append(trait)
# the dirname here must have the trait.xml and
# scripts and templates for the trait
def _import_trait(self, suite, dirname):
traitdb = Trait(self.conn, suite)
traitdb.insert_trait(dirname, suite)
def _find_missing_packages(self, suite, traits, dirname):
missing = dict()
traitdb = Trait(self.conn, suite)
for trait in traits:
tdir = dirname / trait
traitxml = traitdb.parse_trait_xml(tdir, suite=suite)
missing_list = traitdb.find_missing_packages(traitxml)
if missing_list:
missing[trait] = missing_list
return missing
def perform_full_import(self, dirname):
self.set_main_path(dirname)
dbdata = self.parse_main_xml()
self.start_schema()
self.import_apt_sources(dbdata.aptsources)
self.report_total_suites(len(dbdata.suites))
for suite in dbdata.suites:
self.make_suite(suite)
suitedir = self.main_path / suite.name
self._import_traits(suite.name, dbdata.get_traits(suite.name), suitedir)
self.report_suite_imported(suite.name)
self.import_all_families()
self.import_all_profiles()
self.import_all_diskconfigs()
machinedb = self.main_path / 'machine_database.xml'
if machinedb.isfile():
mh = MachineHandler(self.conn)
mh.import_machine_database(self.main_path)
default_environment_basename = 'default-environment'
filename = self.main_path / default_environment_basename
if filename.isfile():
# similar code exists in kde/environ.py
defenv = DefaultEnvironment(self.conn)
newcfg = RawConfigParser()
newcfg.read(filename)
defenv.update(newcfg)
###################
# reporting methods
####################
def report_missing_packages(self, suite, missing):
print report_missing_packages(suite, missing)
def report_total_apt_sources(self, total):
print 'importing %d apt sources' % total
def report_importing_aptsrc(self, apt_id):
print 'importing %s' % apt_id
def report_aptsrc_imported(self, apt_id):
print 'apt source %s imported' % apt_id
def report_total_suites(self, total):
print 'importing %d suites' % total
def report_importing_suite(self, suite):
print 'importing suite %s' % suite
def report_suite_imported(self, suite):
print 'suite %s imported' % suite
def report_total_traits(self, total):
print 'importing %d traits' % total
def report_importing_trait(self, trait, numtraits):
print 'importing trait', trait
def report_trait_imported(self, trait, numtraits):
print 'trait %s imported' % trait
def report_total_families(self, total):
print 'importing %d families' % total
def report_family_imported(self, family):
print 'family %s imported' % family
def report_total_profiles(self, total):
print 'importing %d profiles' % total
def report_profile_imported(self, profile):
print 'profile %s imported' % profile
