def run_mother(database, document, person):
""" Function writing the mother lineage quick report
"""
sa = SimpleAccess(database)
sd = SimpleDoc(document)
# display the results
# feature request 2356: avoid genitive form
sd.title(_("Mother lineage for %s") % sa.name(person))
sd.paragraph("")
sd.paragraph(
_(""
"This report shows the mother lineage, also called matronymic lineage "
"mtDNA lineage."
" People in this lineage all share the same Mitochondrial DNA (mtDNA)."
))
sd.paragraph("")
stab = SimpleTable(sa)
stab.columns(_("Name Mother"), _("Birth"), _("Death Date"), _("Remark"))
make_details(gen.lib.Person.FEMALE, person, sa, sd, database, stab)
stab.write(sd)
sd.paragraph("")
if person.gender == gen.lib.Person.MALE:
return
sd.header2((_("Direct line female descendants")))
sd.paragraph("")
make_details_child(gen.lib.Person.FEMALE, person, sa, sd, database)
def run(database, document, object, item, trans):
"""
Display back-references for this object.
"""
# setup the simple access functions
sdb = SimpleAccess(database)
sdoc = SimpleDoc(document)
stab = SimpleTable(sdb)
# display the title
sdoc.title(_("References for this %s") % trans)
sdoc.paragraph("\n")
stab.columns(_("Type"), _("Reference"))
for (objclass, handle) in database.find_backlink_handles(object.handle):
ref = get_ref(database, objclass, handle)
stab.row(_(objclass), ref) # translation are explicit (above)
if stab.get_row_count() > 0:
document.has_data = True
stab.write(sdoc)
else:
document.has_data = False
sdoc.paragraph(_("No references for this %s") % trans)
sdoc.paragraph("")
sdoc.paragraph("")
def run(database, document, person):
"""
Loops through the families that the person is a child in, and display
the information about the other children.
"""
# setup the simple access functions
sdb = SimpleAccess(database)
sdoc = SimpleDoc(document)
stab = SimpleTable(sdb)
rel_class = Relationship.get_relationship_calculator()
# display the title
# feature request 2356: avoid genitive form
sdoc.title(_("Siblings of %s") % sdb.name(person))
sdoc.paragraph("")
stab.columns(_("Sibling"), _("Gender"), _("Birth Date"), _("Type"))
# grab our current id (self):
gid = sdb.gid(person)
# loop through each family in which the person is a child
document.has_data = False
for family in sdb.child_in(person):
# loop through each child in the family
for child in sdb.children(family):
# only display if this child is not the active person
if sdb.gid(child) != gid:
rel_str = rel_class.get_sibling_relationship_string(
rel_class.get_sibling_type(database, person, child),
person.get_gender(), child.get_gender())
else:
rel_str = _('self')
# pass row the child object to make link:
stab.row(child, sdb.gender(child), sdb.birth_or_fallback(child),
rel_str)
document.has_data = True
stab.write(sdoc)
def run(database, document, person):
"""
Loops through the person events and the family events of any family
in which the person is a parent (to catch Marriage events), displaying
the basic details of the event
"""
sdb = SimpleAccess(database)
sdoc = SimpleDoc(document)
stab = SimpleTable(sdb)
# get the personal events
event_list = sdb.events(person)
# get the events of each family in which the person is
# a parent
for family in sdb.parent_in(person):
event_list += sdb.events(family)
# Sort the events by their date
event_list.sort(by_date)
# display the results
# feature request 2356: avoid genitive form
sdoc.title(_("Sorted events of %s") % sdb.name(person))
sdoc.paragraph("")
stab.columns(_("Event Type"), _("Event Date"), _("Event Place"))
document.has_data = False
for event in event_list:
stab.row(event, sdb.event_date_obj(event), sdb.event_place(event))
document.has_data = True
stab.write(sdoc)
def run_fam(database, document, family):
"""
Loops through the family events and the events of all parents, displaying
the basic details of the event
"""
sdb = SimpleAccess(database)
sdoc = SimpleDoc(document)
stab = SimpleTable(sdb)
# get the family events
event_list = [(_('Family'), x) for x in sdb.events(family)]
# get the events of father and mother
#fathername = sdb.first_name(sdb.father(family))
event_list += [(sdb.father(family), x)
for x in sdb.events(sdb.father(family))]
#mothername = sdb.first_name(sdb.mother(family))
event_list += [(sdb.mother(family), x)
for x in sdb.events(sdb.mother(family))]
# children events
event_list_children = []
for child in sdb.children(family):
#name = sdb.first_name(child)
event_list_children += [(child, x) for x in sdb.events(child)]
# Sort the events by their date
event_list.sort(fam_sort)
event_list_children.sort(fam_sort)
# display the results
sdoc.title(
_("Sorted events of family\n %(father)s - %(mother)s") % {
'father': sdb.name(sdb.father(family)),
'mother': sdb.name(sdb.mother(family))
})
sdoc.paragraph("")
document.has_data = False
stab.columns(_("Family Member"), _("Event Type"), _("Event Date"),
_("Event Place"))
for (person, event) in event_list:
stab.row(person, sdb.event_type(event), sdb.event_date_obj(event),
sdb.event_place(event))
document.has_data = True
stab.write(sdoc)
stab = SimpleTable(sdb)
sdoc.header1(_("Personal events of the children"))
stab.columns(_("Family Member"), _("Event Type"), _("Event Date"),
_("Event Place"))
for (person, event) in event_list_children:
stab.row(person, sdb.event_type(event), sdb.event_date_obj(event),
sdb.event_place(event))
document.has_data = True
stab.write(sdoc)
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 run(database, document, obj):
"""
Display link references for this note.
"""
# setup the simple access functions
sdb = SimpleAccess(database)
sdoc = SimpleDoc(document)
stab = SimpleTable(sdb)
# display the title
sdoc.title(_("Link References for this note"))
sdoc.paragraph("\n")
stab.columns(_("Type"), _("Reference"), _("Link check"))
tags = obj.text.get_tags()
for styledtext_tag in tags:
if int(styledtext_tag.name) == StyledTextTagType.LINK:
if styledtext_tag.value.startswith("gramps://"):
object_class, prop, value = styledtext_tag.value[9:].split(
"/", 2)
tagtype = _(object_class)
ref_obj = sdb.get_link(object_class, prop, value)
if ref_obj:
tagvalue = ref_obj
tagcheck = _("Ok")
else:
tagvalue = styledtext_tag.value
tagcheck = _("Failed: missing object")
else:
tagtype = _("Internet")
tagvalue = styledtext_tag.value
tagcheck = ""
stab.row(tagtype, tagvalue, tagcheck)
if stab.get_row_count() > 0:
stab.write(sdoc)
document.has_data = True
else:
sdoc.paragraph(_("No link references for this note"))
sdoc.paragraph("")
document.has_data = False
sdoc.paragraph("")
def run(database, document, repo):
"""
Display back-references (sources) for this repository.
"""
# setup the simple access functions
sdb = SimpleAccess(database)
sdoc = SimpleDoc(document)
stab = SimpleTable(sdb)
# First we find repository and add its text
sdoc.title('%s\n' % repo.get_name())
# Go over all the sources that refer to this repository
repo_handle = repo.handle
source_list = [
item[1]
for item in database.find_backlink_handles(repo_handle, ['Source'])
]
stab.columns(_("Source"), _("Type of media"), _("Call number"))
document.has_data = False
for source_handle in source_list:
src = database.get_source_from_handle(source_handle)
# Get the list of references from this source to our repo
# (can be more than one, technically)
for reporef in src.get_reporef_list():
if reporef.ref == repo_handle:
# Determine the text for this source
media = str(reporef.get_media_type())
call = reporef.get_call_number()
stab.row(src.get_title(), media, call)
document.has_data = True
stab.write(sdoc)
def run(database, document, person):
"""
Loops through the families that the person is a child in, and displays
the information about the other children.
"""
# setup the simple access functions
sdb = SimpleAccess(database)
sdoc = SimpleDoc(document)
stab = SimpleTable(sdb)
if isinstance(person, gen.lib.Person):
surname = sdb.surname(person)
rsurname = person.get_primary_name().get_group_name()
else:
surname = person
rsurname = person
# display the title
sdoc.title(_("People sharing the surname '%s'") % surname)
sdoc.paragraph("")
stab.columns(_("Person"), _("Birth Date"), _("Name type"))
filter = GenericFilterFactory('Person')()
if rsurname != '':
rule = SameSurname([rsurname])
else:
rule = IncompleteSurname([])
filter.add_rule(rule)
people = filter.apply(database, database.iter_person_handles())
matches = 0
for person_handle in people:
person = database.get_person_from_handle(person_handle)
stab.row(person, sdb.birth_or_fallback(person),
str(person.get_primary_name().get_type()))
matches += 1
document.has_data = matches > 0
sdoc.paragraph(
ngettext(
"There is %d person with a matching name, or alternate name.\n",
"There are %d people with a matching name, or alternate name.\n",
matches) % matches)
stab.write(sdoc)
def run(database, document, attribute, value=None):
sdb = SimpleAccess(database)
sdoc = SimpleDoc(document)
stab = SimpleTable(sdb)
sdoc.title(_("People who have the '%s' Attribute") % attribute)
sdoc.paragraph("")
stab.columns(_("Person"), str(attribute))
matches = 0
for person_handle in database.iter_person_handles():
person = database.get_person_from_handle(person_handle)
matched = False
for attr in person.attribute_list:
if str(attr.type) == attribute:
stab.row(person, str(attr.get_value()))
matched = True
if matched:
matches += 1
document.has_data = matches > 0
sdoc.paragraph(
_("There are %d people with a matching attribute name.\n") % matches)
stab.write(sdoc)
def run(database, document, filter_name, *args, **kwargs):
"""
Loops through the families that the person is a child in, and display
the information about the other children.
"""
# setup the simple access functions
sdb = SimpleAccess(database)
sdoc = SimpleDoc(document)
stab = SimpleTable(sdb)
if (filter_name == 'all'):
sdoc.title(_("Summary counts of current selection"))
sdoc.paragraph("")
sdoc.paragraph(
_("Right-click row (or press ENTER) to see selected items."))
sdoc.paragraph("")
stab.columns(_("Object"), _("Count/Total"))
stab.row([_("People"), "Filter", "Person"],
"%d/%d" % (len(database.get_person_handles()),
len(database.basedb.get_person_handles())))
stab.row([_("Families"), "Filter", "Family"],
"%d/%d" % (len(database.get_family_handles()),
len(database.basedb.get_family_handles())))
stab.row([_("Events"), "Filter", "Event"],
"%d/%d" % (len(database.get_event_handles()),
len(database.basedb.get_event_handles())))
stab.row([_("Places"), "Filter", "Place"],
"%d/%d" % (len(database.get_place_handles()),
len(database.basedb.get_place_handles())))
stab.row([_("Sources"), "Filter", "Source"],
"%d/%d" % (len(database.get_source_handles()),
len(database.basedb.get_source_handles())))
stab.row([_("Repositories"), "Filter", "Repository"],
"%d/%d" % (len(database.get_repository_handles()),
len(database.basedb.get_repository_handles())))
stab.row([_("Media"), "Filter", "MediaObject"],
"%d/%d" % (len(database.get_media_object_handles()),
len(database.basedb.get_media_object_handles())))
stab.row([_("Notes"), "Filter", "Note"],
"%d/%d" % (len(database.get_note_handles()),
len(database.basedb.get_note_handles())))
sdoc.paragraph("")
stab.write(sdoc)
return
# display the title
if filter_name in fname_map:
sdoc.title(_("Filtering on %s") %
fname_map[filter_name]) # listed above
else:
sdoc.title(_("Filtering on %s") % _(filter_name))
sdoc.paragraph("")
matches = 0
if (filter_name == 'Inverse Person'):
sdb.dbase = database.db
stab.columns(_("Person"), _("Gramps ID"), _("Birth Date"))
proxy_handles = set(database.iter_person_handles())
for person in database.db.iter_people():
if person.handle not in proxy_handles:
stab.row(person, person.gramps_id,
sdb.birth_or_fallback(person))
matches += 1
elif (filter_name == 'Inverse Family'):
sdb.dbase = database.db
stab.columns(_("Family"), _("Gramps ID"))
proxy_handles = set(database.iter_family_handles())
for family in database.db.iter_families():
if family.handle not in proxy_handles:
stab.row(family, family.gramps_id)
matches += 1
elif (filter_name == 'Inverse Event'):
sdb.dbase = database.db
stab.columns(_("Event"), _("Gramps ID"))
proxy_handles = set(database.iter_event_handles())
for event in database.db.iter_events():
if event.handle not in proxy_handles:
stab.row(event, event.gramps_id)
matches += 1
elif (filter_name == 'Inverse Place'):
sdb.dbase = database.db
stab.columns(_("Place"), _("Gramps ID"))
proxy_handles = set(database.iter_place_handles())
for place in database.db.iter_places():
if place.handle not in proxy_handles:
stab.row(place, place.gramps_id)
matches += 1
elif (filter_name == 'Inverse Source'):
sdb.dbase = database.db
stab.columns(_("Source"), _("Gramps ID"))
proxy_handles = set(database.iter_source_handles())
for source in database.db.iter_sources():
if source.handle not in proxy_handles:
stab.row(source, source.gramps_id)
matches += 1
elif (filter_name == 'Inverse Repository'):
sdb.dbase = database.db
stab.columns(_("Repository"), _("Gramps ID"))
proxy_handles = set(database.iter_repository_handles())
for repository in database.db.iter_repositories():
if repository.handle not in proxy_handles:
stab.row(repository, repository.gramps_id)
matches += 1
elif (filter_name == 'Inverse MediaObject'):
sdb.dbase = database.db
stab.columns(_("Media"), _("Gramps ID"))
proxy_handles = set(database.iter_media_object_handles())
for media in database.db.iter_media_objects():
if media.handle not in proxy_handles:
stab.row(media, media.gramps_id)
matches += 1
elif (filter_name == 'Inverse Note'):
sdb.dbase = database.db
stab.columns(_("Note"), _("Gramps ID"))
proxy_handles = set(database.iter_note_handles())
for note in database.db.iter_notes():
if note.handle not in proxy_handles:
stab.row(note, note.gramps_id)
matches += 1
elif (filter_name in ['all people', 'Person']):
stab.columns(_("Person"), _("Gramps ID"), _("Birth Date"))
for person in database.iter_people():
stab.row(person, person.gramps_id, sdb.birth_or_fallback(person))
matches += 1
elif (filter_name in ['all families', 'Family']):
stab.columns(_("Family"), _("Gramps ID"))
for family in database.iter_families():
stab.row(family, family.gramps_id)
matches += 1
elif (filter_name in ['all events', 'Event']):
stab.columns(_("Event"), _("Gramps ID"))
for obj in database.iter_events():
stab.row(obj, obj.gramps_id)
matches += 1
elif (filter_name in ['all places', 'Place']):
stab.columns(_("Place"), _("Gramps ID"))
for obj in database.iter_places():
stab.row(obj, obj.gramps_id)
matches += 1
elif (filter_name in ['all sources', 'Source']):
stab.columns(_("Source"), _("Gramps ID"))
for obj in database.iter_sources():
stab.row(obj, obj.gramps_id)
matches += 1
elif (filter_name in ['all repositories', 'Repository']):
stab.columns(_("Repository"), _("Gramps ID"))
for obj in database.iter_repositories():
stab.row(obj, obj.gramps_id)
matches += 1
elif (filter_name in ['all media', 'MediaObject']):
stab.columns(_("Media"), _("Gramps ID"))
for obj in database.iter_media_objects():
stab.row(obj, obj.gramps_id)
matches += 1
elif (filter_name in ['all notes', 'Note']):
stab.columns(_("Note"), _("Gramps ID"))
for obj in database.iter_notes():
stab.row(obj, obj.gramps_id)
matches += 1
elif (filter_name == 'males'):
stab.columns(_("Person"), _("Birth Date"), _("Name type"))
for person in database.iter_people():
if person.gender == Person.MALE:
stab.row(person, sdb.birth_or_fallback(person),
str(person.get_primary_name().get_type()))
matches += 1
elif (filter_name == 'females'):
stab.columns(_("Person"), _("Birth Date"), _("Name type"))
for person in database.iter_people():
if person.gender == Person.FEMALE:
stab.row(person, sdb.birth_or_fallback(person),
str(person.get_primary_name().get_type()))
matches += 1
elif (filter_name == 'people with unknown gender'):
stab.columns(_("Person"), _("Birth Date"), _("Name type"))
for person in database.iter_people():
if person.gender not in [Person.FEMALE, Person.MALE]:
stab.row(person, sdb.birth_or_fallback(person),
str(person.get_primary_name().get_type()))
matches += 1
elif (filter_name == 'people with incomplete names'):
stab.columns(_("Person"), _("Birth Date"), _("Name type"))
for person in database.iter_people():
for name in [person.get_primary_name()
] + person.get_alternate_names():
if name.get_group_name() == "" or name.get_first_name() == "":
stab.row(person, sdb.birth_or_fallback(person),
str(person.get_primary_name().get_type()))
matches += 1
elif (filter_name == 'people with missing birth dates'):
stab.columns(_("Person"), _("Type"))
for person in database.iter_people():
birth_ref = person.get_birth_ref()
if birth_ref:
birth = database.get_event_from_handle(birth_ref.ref)
if not DateHandler.get_date(birth):
stab.row(person, _("birth event but no date"))
matches += 1
else:
stab.row(person, _("missing birth event"))
matches += 1
elif (filter_name == 'disconnected people'):
stab.columns(_("Person"), _("Birth Date"), _("Name type"))
for person in database.iter_people():
if ((not person.get_main_parents_family_handle())
and (not len(person.get_family_handle_list()))):
stab.row(person, sdb.birth_or_fallback(person),
str(person.get_primary_name().get_type()))
matches += 1
elif (filter_name == 'unique surnames'):
namelist = defaultdict(int)
for person in database.iter_people():
names = [person.get_primary_name()] + person.get_alternate_names()
surnames = list(set([name.get_group_name() for name in names]))
for surname in surnames:
namelist[surname] += 1
stab.columns(_("Surname"), _("Count"))
for name in sorted(namelist):
stab.row(name, namelist[name])
matches += 1
stab.set_callback(
"leftdouble", lambda name: run_quick_report_by_name_direct(
"samesurnames", database, document, name))
elif (filter_name == 'people with media'):
stab.columns(_("Person"), _("Media count"))
for person in database.iter_people():
length = len(person.get_media_list())
if length > 0:
stab.row(person, length)
matches += 1
elif (filter_name == 'media references'):
stab.columns(_("Person"), _("Reference"))
for person in database.iter_people():
medialist = person.get_media_list()
for item in medialist:
stab.row(person, _("media"))
matches += 1
elif (filter_name == 'unique media'):
stab.columns(_("Unique Media"))
for photo in database.iter_media_objects():
fullname = media_path_full(database, photo.get_path())
stab.row(fullname)
matches += 1
elif (filter_name == 'missing media'):
stab.columns(_("Missing Media"))
for photo in database.iter_media_objects():
fullname = media_path_full(database, photo.get_path())
try:
posixpath.getsize(fullname)
except:
stab.row(fullname)
matches += 1
elif (filter_name == 'media by size'):
stab.columns(_("Media"), _("Size in bytes"))
for photo in database.iter_media_objects():
fullname = media_path_full(database, photo.get_path())
try:
bytes = posixpath.getsize(fullname)
stab.row(fullname, bytes)
matches += 1
except:
pass
elif (filter_name == 'list of people'):
stab.columns(_("Person"), _("Birth Date"), _("Name type"))
handles = kwargs["handles"]
for person_handle in handles:
person = database.get_person_from_handle(person_handle)
stab.row(person, sdb.birth_or_fallback(person),
str(person.get_primary_name().get_type()))
matches += 1
else:
raise AttributeError, ("invalid filter name: '%s'" % filter_name)
sdoc.paragraph(
ngettext("Filter matched %d record.", "Filter matched %d records.",
matches) % matches)
sdoc.paragraph("")
document.has_data = matches > 0
if matches > 0:
stab.write(sdoc)
def run(database, document, main_event):
"""
Displays events on a specific date of an event (or date)
Takes an Event or Date object
"""
if isinstance(main_event, gen.lib.Date):
main_date = main_event
else:
main_date = main_event.get_date_object()
cal = main_date.get_calendar()
# setup the simple access functions
sdb = SimpleAccess(database)
sdoc = SimpleDoc(document)
stab = SimpleTable(sdb)
stab.set_link_col(3)
yeartab = SimpleTable(sdb)
yeartab.set_link_col(3)
histab = SimpleTable(sdb)
histab.set_link_col(3)
# display the title
sdoc.title(_("Events of %(date)s") % {"date": sdb.date_string(main_date)})
sdoc.paragraph("")
stab.columns(_("Date"), _("Type"), _("Place"), _("Reference"))
yeartab.columns(_("Date"), _("Type"), _("Place"), _("Reference"))
histab.columns(_("Date"), _("Type"), _("Place"), _("Reference"))
for event in database.iter_events():
date = event.get_date_object()
date.convert_calendar(cal)
if date.get_year() == 0:
continue
if (date.get_year() == main_date.get_year()
and date.get_month() == main_date.get_month()
and date.get_day() == main_date.get_day()):
for (objclass,
handle) in database.find_backlink_handles(event.handle):
ref = get_ref(database, objclass, handle)
stab.row(date, sdb.event_type(event), sdb.event_place(event),
ref)
elif (date.get_month() == main_date.get_month()
and date.get_day() == main_date.get_day()
and date.get_month() != 0):
for (objclass,
handle) in database.find_backlink_handles(event.handle):
ref = get_ref(database, objclass, handle)
histab.row(date, sdb.event_type(event), sdb.event_place(event),
ref)
elif (date.get_year() == main_date.get_year()):
for (objclass,
handle) in database.find_backlink_handles(event.handle):
ref = get_ref(database, objclass, handle)
yeartab.row(date, sdb.event_type(event),
sdb.event_place(event), ref)
document.has_data = False
if stab.get_row_count() > 0:
document.has_data = True
sdoc.paragraph(_("Events on this exact date"))
stab.write(sdoc)
else:
sdoc.paragraph(_("No events on this exact date"))
sdoc.paragraph("")
sdoc.paragraph("")
if histab.get_row_count() > 0:
document.has_data = True
sdoc.paragraph(_("Other events on this month/day in history"))
histab.write(sdoc)
else:
sdoc.paragraph(_("No other events on this month/day in history"))
sdoc.paragraph("")
sdoc.paragraph("")
if yeartab.get_row_count() > 0:
document.has_data = True
sdoc.paragraph(
_("Other events in %(year)d") % {"year": main_date.get_year()})
yeartab.write(sdoc)
else:
sdoc.paragraph(
_("No other events in %(year)d") % {"year": main_date.get_year()})
sdoc.paragraph("")
sdoc.paragraph("")