def __is_living(self, person):
"""
Check if a person is considered living.
Returns True if the person is considered living.
Returns False if the person is not considered living.
"""
person_handle = person.get_handle()
unfil_person = self.get_unfiltered_person(person_handle)
return probably_alive(unfil_person, self.db, self.current_date,
self.years_after_death)
def run(database, document, date):
"""
Display people probably alive and their ages on a particular date.
"""
# setup the simple access functions
sdb = SimpleAccess(database)
sdoc = SimpleDoc(document)
stab = SimpleTable(sdb)
if not date.get_valid():
sdoc.paragraph("Date is not a valid date.")
return
# display the title
if date.get_day_valid():
sdoc.title(
_("People and their ages the %s") %
DateHandler.displayer.display(date))
else:
sdoc.title(
_("People and their ages on %s") %
DateHandler.displayer.display(date))
stab.columns(_("Person"), _("Age"),
_("Status")) # Actual Date makes column unicode
alive_matches = 0
dead_matches = 0
for person in sdb.all_people():
alive, birth, death, explain, relative = \
probably_alive(person, database, date, return_range=True)
# Doesn't show people probably alive but no way of figuring an age:
if alive:
if birth:
diff_span = (date - birth)
stab.row(person, str(diff_span), _("Alive: %s") % explain)
stab.row_sort_val(1, int(diff_span))
else:
stab.row(person, "", _("Alive: %s") % explain)
stab.row_sort_val(1, 0)
alive_matches += 1
else:
if birth:
diff_span = (date - birth)
stab.row(person, str(diff_span), _("Deceased: %s") % explain)
stab.row_sort_val(1, int(diff_span))
else:
stab.row(person, "", _("Deceased: %s") % explain)
stab.row_sort_val(1, 1)
dead_matches += 1
document.has_data = (alive_matches + dead_matches) > 0
sdoc.paragraph(
_("\nLiving matches: %d, Deceased matches: %d\n") %
(alive_matches, dead_matches))
stab.write(sdoc)
sdoc.paragraph("")
def collect_data(self):
"""
This method runs through the data, and collects the relevant dates
and text.
"""
db = self.database
people = db.iter_person_handles()
self._user.begin_progress(_('Calendar Report'),
_('Applying Filter...'),
db.get_number_of_people())
people = self.filter.apply(self.database, people,
self._user.step_progress)
rel_calc = Relationship.get_relationship_calculator()
self._user.end_progress()
self._user.begin_progress(_('Calendar Report'),
_('Reading database...'), len(people))
for person_handle in people:
self._user.step_progress()
person = db.get_person_from_handle(person_handle)
birth_ref = person.get_birth_ref()
birth_date = None
if birth_ref:
birth_event = db.get_event_from_handle(birth_ref.ref)
birth_date = birth_event.get_date_object()
if (self.birthdays and birth_date is not None
and birth_date.is_valid()):
birth_date = gregorian(birth_date)
year = birth_date.get_year()
month = birth_date.get_month()
day = birth_date.get_day()
prob_alive_date = gen.lib.Date(self.year, month, day)
nyears = self.year - year
# add some things to handle maiden name:
father_lastname = None # husband, actually
if self.maiden_name in ['spouse_first', 'spouse_last'
]: # get husband's last name:
if person.get_gender() == gen.lib.Person.FEMALE:
family_list = person.get_family_handle_list()
if family_list:
if self.maiden_name == 'spouse_first':
fhandle = family_list[0]
else:
fhandle = family_list[-1]
fam = db.get_family_from_handle(fhandle)
father_handle = fam.get_father_handle()
mother_handle = fam.get_mother_handle()
if mother_handle == person_handle:
if father_handle:
father = db.get_person_from_handle(
father_handle)
if father:
father_lastname = father.get_primary_name(
).get_surname()
short_name = self.get_name(person, father_lastname)
alive = probably_alive(person, db, prob_alive_date)
if not self.alive or alive:
if nyears == 0:
text = _('%(person)s, birth%(relation)s') % {
'person': short_name,
'relation': ""
}
else:
text = (ngettext('%(person)s, %(age)d%(relation)s',
'%(person)s, %(age)d%(relation)s',
nyears) % {
'person': short_name,
'age': nyears,
'relation': ""
})
self.add_day_item(text, month, day)
if self.anniversaries:
family_list = person.get_family_handle_list()
for fhandle in family_list:
fam = db.get_family_from_handle(fhandle)
father_handle = fam.get_father_handle()
mother_handle = fam.get_mother_handle()
if father_handle == person.get_handle():
spouse_handle = mother_handle
else:
continue # with next person if the father is not "person"
# this will keep from duplicating the anniversary
if spouse_handle:
spouse = db.get_person_from_handle(spouse_handle)
if spouse:
spouse_name = self.get_name(spouse)
short_name = self.get_name(person)
# TEMP: this will handle ordered events
# GRAMPS 3.0 will have a new mechanism for start/stop events
are_married = None
for event_ref in fam.get_event_ref_list():
event = db.get_event_from_handle(event_ref.ref)
et = gen.lib.EventType
rt = gen.lib.EventRoleType
if event.type in [et.MARRIAGE,
et.MARR_ALT] and \
(event_ref.get_role() == rt.FAMILY or
event_ref.get_role() == rt.PRIMARY ):
are_married = event
elif event.type in [et.DIVORCE,
et.ANNULMENT,
et.DIV_FILING] and \
(event_ref.get_role() == rt.FAMILY or
event_ref.get_role() == rt.PRIMARY ):
are_married = None
if are_married is not None:
for event_ref in fam.get_event_ref_list():
event = db.get_event_from_handle(
event_ref.ref)
event_obj = event.get_date_object()
if event_obj.is_valid():
event_obj = gregorian(event_obj)
year = event_obj.get_year()
month = event_obj.get_month()
day = event_obj.get_day()
prob_alive_date = gen.lib.Date(
self.year, month, day)
nyears = self.year - year
if nyears == 0:
text = _(
'%(spouse)s and\n %(person)s, wedding'
) % {
'spouse': spouse_name,
'person': short_name,
}
else:
text = (ngettext(
"%(spouse)s and\n %(person)s, %(nyears)d",
"%(spouse)s and\n %(person)s, %(nyears)d",
nyears) % {
'spouse': spouse_name,
'person': short_name,
'nyears': nyears
})
alive1 = probably_alive(
person, self.database,
prob_alive_date)
alive2 = probably_alive(
spouse, self.database,
prob_alive_date)
if ((self.alive and alive1 and alive2)
or not self.alive):
self.add_day_item(text, month, day)
self._user.end_progress()
def _find_records(db, filter, callname):
today = datetime.date.today()
today_date = Date(today.year, today.month, today.day)
# Person records
person_youngestliving = []
person_oldestliving = []
person_youngestdied = []
person_oldestdied = []
person_youngestmarried = []
person_oldestmarried = []
person_youngestdivorced = []
person_oldestdivorced = []
person_youngestfather = []
person_youngestmother = []
person_oldestfather = []
person_oldestmother = []
person_handle_list = db.iter_person_handles()
if filter:
person_handle_list = filter.apply(db, person_handle_list)
for person_handle in person_handle_list:
person = db.get_person_from_handle(person_handle)
birth_ref = person.get_birth_ref()
if not birth_ref:
# No birth event, so we can't calculate any age.
continue
birth = db.get_event_from_handle(birth_ref.ref)
birth_date = birth.get_date_object()
death_date = _find_death_date(db, person)
if not _good_date(birth_date):
# Birth date unknown or incomplete, so we can't calculate any age.
continue
name = _Person_get_styled_primary_name(person, callname)
if death_date is None:
if probably_alive(person, db):
# Still living, look for age records
_record(person_youngestliving, person_oldestliving,
today_date - birth_date, name, 'Person', person_handle)
elif _good_date(death_date):
# Already died, look for age records
_record(person_youngestdied, person_oldestdied,
death_date - birth_date, name, 'Person', person_handle)
for family_handle in person.get_family_handle_list():
family = db.get_family_from_handle(family_handle)
marriage_date = None
divorce_date = None
for event_ref in family.get_event_ref_list():
event = db.get_event_from_handle(event_ref.ref)
if (event.get_type().is_marriage()
and (event_ref.get_role().is_family()
or event_ref.get_role().is_primary())):
marriage_date = event.get_date_object()
elif (event.get_type().is_divorce()
and (event_ref.get_role().is_family()
or event_ref.get_role().is_primary())):
divorce_date = event.get_date_object()
if _good_date(marriage_date):
_record(person_youngestmarried, person_oldestmarried,
marriage_date - birth_date, name, 'Person',
person_handle)
if _good_date(divorce_date):
_record(person_youngestdivorced, person_oldestdivorced,
divorce_date - birth_date, name, 'Person',
person_handle)
for child_ref in family.get_child_ref_list():
if person.get_gender() == person.MALE:
relation = child_ref.get_father_relation()
elif person.get_gender() == person.FEMALE:
relation = child_ref.get_mother_relation()
else:
continue
if relation != ChildRefType.BIRTH:
continue
child = db.get_person_from_handle(child_ref.ref)
child_birth_ref = child.get_birth_ref()
if not child_birth_ref:
continue
child_birth = db.get_event_from_handle(child_birth_ref.ref)
child_birth_date = child_birth.get_date_object()
if not _good_date(child_birth_date):
continue
if person.get_gender() == person.MALE:
_record(person_youngestfather, person_oldestfather,
child_birth_date - birth_date, name, 'Person',
person_handle)
elif person.get_gender() == person.FEMALE:
_record(person_youngestmother, person_oldestmother,
child_birth_date - birth_date, name, 'Person',
person_handle)
# Family records
family_mostchildren = []
family_youngestmarried = []
family_oldestmarried = []
family_shortest = []
family_longest = []
for family in db.iter_families():
#family = db.get_family_from_handle(family_handle)
father_handle = family.get_father_handle()
if not father_handle:
continue
mother_handle = family.get_mother_handle()
if not mother_handle:
continue
# Test if either father or mother are in filter
if filter:
if not filter.apply(db, [father_handle, mother_handle]):
continue
father = db.get_person_from_handle(father_handle)
mother = db.get_person_from_handle(mother_handle)
name = StyledText(_("%(father)s and %(mother)s")) % {
'father': _Person_get_styled_primary_name(father, callname),
'mother': _Person_get_styled_primary_name(mother, callname)
}
_record(None, family_mostchildren, len(family.get_child_ref_list()),
name, 'Family', family.handle)
marriage_date = None
divorce = None
divorce_date = None
for event_ref in family.get_event_ref_list():
event = db.get_event_from_handle(event_ref.ref)
if (event.get_type().is_marriage()
and (event_ref.get_role().is_family()
or event_ref.get_role().is_primary())):
marriage_date = event.get_date_object()
if (event and event.get_type().is_divorce()
and (event_ref.get_role().is_family()
or event_ref.get_role().is_primary())):
divorce = event
divorce_date = event.get_date_object()
father_death_date = _find_death_date(db, father)
mother_death_date = _find_death_date(db, mother)
if not _good_date(marriage_date):
# Not married or marriage date unknown
continue
if divorce is not None and not _good_date(divorce_date):
# Divorced but date unknown or inexact
continue
if not probably_alive(father,
db) and not _good_date(father_death_date):
# Father died but death date unknown or inexact
continue
if not probably_alive(mother,
db) and not _good_date(mother_death_date):
# Mother died but death date unknown or inexact
continue
if divorce_date is None and father_death_date is None and mother_death_date is None:
# Still married and alive
if probably_alive(father, db) and probably_alive(mother, db):
_record(family_youngestmarried, family_oldestmarried,
today_date - marriage_date, name, 'Family',
family.handle)
elif (_good_date(divorce_date) or _good_date(father_death_date)
or _good_date(mother_death_date)):
end = None
if _good_date(father_death_date) and _good_date(mother_death_date):
end = min(father_death_date, mother_death_date)
elif _good_date(father_death_date):
end = father_death_date
elif _good_date(mother_death_date):
end = mother_death_date
if _good_date(divorce_date):
if end:
end = min(end, divorce_date)
else:
end = divorce_date
duration = end - marriage_date
_record(family_shortest, family_longest, duration, name, 'Family',
family.handle)
return [(text, varname, locals()[varname])
for (text, varname, default) in RECORDS]
def apply(self, db, person):
return probably_alive(person, db, self.current_date)