Cyclone-Team/gramps
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Complete refactoring of the Extract class

Browse Source 
svn: r3946
This commit is contained in:
Eero Tamminen 2005-01-22 21:46:55 +00:00
parent cd047ba03a
commit 961426c030
2 changed files with 194 additions and 142 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
gramps2/ChangeLog
View File

@ -1,3 +1,13 @@
2005-01-23 Eero Tamminen <eerot@sf>
* src/plugins/StatisticsChart.py:
- Complete refactoring of Extract class. There are now separate
methods for Gramp type extraction and data extraction from types
+ db is stored to self.db. This makes code much more flexible
- Added charts for person age, death and birth places, death cause
- Changed _Extract.extractors accesses accordingly
- Better chart title localization (use keywords)
- Fix two minor bugs in yesterday's code
2005-01-22 Eero Tamminen <eerot@sf> 2005-01-22 Eero Tamminen <eerot@sf>
* src/plugins/StatisticsChart.py: * src/plugins/StatisticsChart.py:
- Move data item options to separate tab in report GUI - Move data item options to separate tab in report GUI

326
gramps2/src/plugins/StatisticsChart.py
View File

@ -46,14 +46,13 @@ import gtk
# GRAMPS modules # GRAMPS modules
# #
#------------------------------------------------------------------------ #------------------------------------------------------------------------
from ReportUtils import pt2cm
import const # gender and report type names import const # gender and report type names
from RelLib import Person # need Person internals for getting gender / gender name from RelLib import Person # need Person internals for getting gender / gender name
import Utils
import Report
import BaseDoc import BaseDoc
import GenericFilter import Report
import ReportUtils
import ReportOptions import ReportOptions
import GenericFilter
from DateHandler import displayer as _dd from DateHandler import displayer as _dd
#------------------------------------------------------------------------ #------------------------------------------------------------------------
@ -95,137 +94,61 @@ class Extract:
def __init__(self): def __init__(self):
"""Methods for extracting statistical data from the database""" """Methods for extracting statistical data from the database"""
# key, non-localized name, localized name, type method, data method
self.extractors = { self.extractors = {
'data_title': (self.title, "Titles", _("Titles")), 'data_title': ("Titles", _("Titles"),
'data_fname': (self.forename, "Forenames", _("Forenames")), self.get_person, self.get_title),
'data_byear': (self.birth_year, "Birth years", _("Birth years")), 'data_fname': ("Forenames", _("Forenames"),
'data_dyear': (self.death_year, "Death years", _("Death years")), self.get_person, self.get_forename),
'data_bmonth': (self.birth_month, "Birth months", _("Birth months")), 'data_gender': ("Genders", _("Genders"),
'data_dmonth': (self.death_month, "Death months", _("Death months")), self.get_person, self.get_gender),
'data_dage': (self.death_age, "Estimated ages at death", _("Estimated ages at death")), 'data_byear': ("Birth years", _("Birth years"),
#'data_mage': (self.marriage_age, "Estimated (first) marriage ages", _("Estimated (first) marriage ages")), self.get_birth, self.get_year),
'data_dyear': ("Death years", _("Death years"),
self.get_death, self.get_year),
'data_bmonth': ("Birth months", _("Birth months"),
self.get_birth, self.get_month),
'data_dmonth': ("Death months", _("Death months"),
self.get_death, self.get_month),
'data_dcause': ("Causes of death", _("Causes of death"),
self.get_death, self.get_cause),
'data_bplace': ("Birth places", _("Birth places"),
self.get_birth, self.get_place),
'data_dplace': ("Death places", _("Death places"),
self.get_death, self.get_place),
#'data_mplace': (self.marriage_place, "Marriage place", _("Marriage place")),
#'data_fchild': (self.first_child_age, "Estimated ages for bearing the first child", _("Estimated ages for bearing the first child")), #'data_fchild': (self.first_child_age, "Estimated ages for bearing the first child", _("Estimated ages for bearing the first child")),
#'data_lchild': (self.last_child_age, "Estimated Ages for bearing the last child", _("Estimated Ages for bearing the last child")), #'data_lchild': (self.last_child_age, "Estimated Ages for bearing the last child", _("Estimated Ages for bearing the last child")),
#'data_ccount': (self.child_count, "Number of children", _("Number of children")), #'data_ccount': (self.child_count, "Number of children", _("Number of children")),
#'data_dcause': (self.death_cause, "Cause of death", _("Cause of death")), #'data_mage': (self.marriage_age, "Estimated (first) marriage ages", _("Estimated (first) marriage ages")),
#'data_bplace': (self.birth_place, "Birth place", _("Birth place")), 'data_dage': ("Estimated ages at death", _("Estimated ages at death"),
#'data_mplace': (self.marriage_place, "Marriage place", _("Marriage place")), self.get_person, self.get_death_age),
#'data_dplace': (self.death_place, "Death place", _("Death place")), 'data_age': ("Estimated ages", _("Estimated ages"),
'data_gender': (self.gender, "Genders", _("Genders")) self.get_person, self.get_person_age)
} }
def estimate_age(self, db, person, date): # ----------------- data extraction methods --------------------
"""Utility method to estimate person's age at given date: # take an object and return a list of strings
person -- person whose age is to be estimated
date -- date at which the age should be estimated
This expects that Person's birth and the date argument are
using the same calendar and that between those two dates
there haven't been any calendar discontinuations."""
birth_handle = person.get_birth_handle()
if birth_handle:
birth = db.get_event_from_handle(birth_handle).get_date_object()
if not (date.get_year_valid() and birth.get_year_valid()):
return _("Missing date(s)")
else:
return _("Missing date(s)")
age = date.get_year() - birth.get_year() def get_title(self, person):
if date.get_month_valid() and birth.get_month_valid(): "return title for given person"
if date.get_month() < birth.get_month():
age -= 1
elif (date.get_month() == birth.get_month() and
date.get_day_valid() and birth.get_day_valid() and
date.get_day() < birth.get_day()):
age -= 1
if age >= 0:
return str(age)
else:
return _("Invalid date(s)")
def title(self, db, person):
title = person.get_primary_name().get_title() title = person.get_primary_name().get_title()
if title: if title:
return [title] return [title]
else: else:
return [_("Person's missing (preferred) title")] return [_("(Preferred) title missing")]
def forename(self, db, person): def get_forename(self, person):
"return forenames for given person"
# because this returns list, other methods return list too # because this returns list, other methods return list too
firstnames = person.get_primary_name().get_first_name().strip() firstnames = person.get_primary_name().get_first_name().strip()
if firstnames: if firstnames:
return [name.capitalize() for name in firstnames.split()] return [name.capitalize() for name in firstnames.split()]
else: else:
return [_("Person's missing (preferred) forename")] return [_("(Preferred) forename missing")]
def birth_year(self, db, person):
birth_handle = person.get_birth_handle()
if birth_handle:
birth = db.get_event_from_handle(birth_handle).get_date_object()
year = birth.get_year()
if year:
return [str(year)]
return [_("Person's missing birth year")]
def death_year(self, db, person):
death_handle = person.get_death_handle()
if death_handle:
death = db.get_event_from_handle(death_handle).get_date_object()
year = death.get_year()
if year:
return [str(year)]
return [_("Person's missing death year")]
def birth_month(self, db, person): def get_gender(self, person):
birth_handle = person.get_birth_handle() "return gender for given person"
if birth_handle:
birth = db.get_event_from_handle(birth_handle).get_date_object()
month = birth.get_month()
if month:
_dd._months[month]
return [_dd._months[month]]
return [_("Person's missing birth month")]
def death_month(self, db, person):
death_handle = person.get_death_handle()
if death_handle:
death = db.get_event_from_handle(death_handle).get_date_object()
month = death.get_month()
if month:
return [_dd._months[month]]
return [_("Person's missing death month")]
def death_age(self, db, person):
death_handle = person.get_death_handle()
if death_handle:
death = db.get_event_from_handle(death_handle).get_date_object()
return [self.estimate_age(db, person, death)]
return [_("Missing date(s)")]
def marriage_age(self, db, person):
return "Marriage age stat unimplemented"
def marriage_place(self, db, person):
return "Marriage place stat unimplemented"
def first_child_age(self, db, person):
return "First child bearing age stat unimplemented"
def last_child_age(self, db, person):
return "Last child bearing age stat unimplemented"
def child_count(self, db, person):
return "Child count stat unimplemented"
def death_cause(self, db, person):
return "Death cause stat unimplemented"
def death_place(self, db, person):
return "Death place stat unimplemented"
def birth_place(self, db, person):
return "Birth place stat unimplemented"
def gender(self, db, person):
# TODO: why there's no Person.getGenderName? # TODO: why there's no Person.getGenderName?
# It could be used by getDisplayInfo & this... # It could be used by getDisplayInfo & this...
if person.gender == Person.male: if person.gender == Person.male:
@ -236,14 +159,120 @@ class Extract:
gender = const.unknown gender = const.unknown
return [gender] return [gender]
def get_person_data(self, db, person, collect): def get_year(self, event):
"return year for given event"
date = event.get_date_object()
if date:
year = date.get_year()
if year:
return [str(year)]
return [_("Date missing/inaccurate")]
def get_month(self, event):
"return month for given event"
date = event.get_date_object()
if date:
month = date.get_month()
if month:
return [_dd._months[month]]
return [_("Date missing/inaccurate")]
def get_cause(self, event):
"return cause for given event"
cause = event.get_cause()
if cause:
return [cause]
return [_("Cause missing")]
def get_place(self, event):
"return place for given event"
place_handle = event.get_place_handle()
if place_handle:
place = self.db.get_place_from_handle(place_handle).get_title()
if place:
return [place]
return [_("Place missing")]
def get_person_age(self, person):
"return age for given person, if alive"
death = self.get_death(person)
if not death:
return self.estimate_age(person)
return [_("Dead")]
def get_death_age(self, person):
"return age at death for given person, if dead"
death = self.get_death(person)
if death:
return self.estimate_age(person)
return [_("Alive")]
def marriage_age(self, person):
return "TODO: Marriage age stat unimplemented"
def marriage_place(self, person):
return "TODO: Marriage place stat unimplemented"
def first_child_age(self, person):
return "TODO: First child bearing age stat unimplemented"
def last_child_age(self, person):
return "TODO: Last child bearing age stat unimplemented"
def child_count(self, person):
return "TODO: Child count stat unimplemented"
# ------------------- utility methods -------------------------
def estimate_age(self, person):
"return estimated age (range) for given person or error message"
age = ReportUtils.estimate_age(self.db, person)
if age[0] < 0 or age[1] < 0:
# inadequate information
return [_("Missing information")]
if age[0] == age[1]:
# exact year
return [str(age[0])]
else:
# minimum and maximum
return [str(age[0]) + "-" + str(age[1])]
# ------------------- type methods -------------------------
# take db and person and return suitable gramps object(s)
def get_person(self, person):
"return person"
return person
def get_birth(self, person):
"return birth event for given person or None"
birth_handle = person.get_birth_handle()
if birth_handle:
return self.db.get_event_from_handle(birth_handle)
return None
def get_death(self, person):
"return death event for given person or None"
death_handle = person.get_death_handle()
if death_handle:
return self.db.get_event_from_handle(death_handle)
return None
# ----------------- data collection methods --------------------
def get_person_data(self, person, collect):
"""Adds data from the database to 'collect' for the given person, """Adds data from the database to 'collect' for the given person,
using methods rom the 'collect' data dict tuple using methods rom the 'collect' data dict tuple
""" """
for chart in collect: for chart in collect:
# get the information # get the information
extract_func = chart[2] type_func = chart[2]
value = extract_func(db, person) data_func = chart[3]
obj = type_func(person) # e.g. get_date()
if obj:
value = data_func(obj) # e.g. get_year()
else:
value = [_("Information missing")]
# list of information found # list of information found
for key in value: for key in value:
if key in chart[1].keys(): if key in chart[1].keys():
@ -270,14 +299,15 @@ class Extract:
- Dict of values with their counts - Dict of values with their counts
(- Method) (- Method)
""" """
self.db = db # store for methods
data = [] data = []
ext = self.extractors ext = self.extractors
# initialize data # initialize data
for key in options: for key in options:
if options[key] and key in self.extractors: if options[key] and key in self.extractors:
# localized data title, value dict and method # localized data title, value dict and method
data.append((ext[key][2], {}, ext[key][0])) data.append((ext[key][1], {}, ext[key][2], ext[key][3]))
# go through the people and collect data # go through the people and collect data
for person_handle in filter_func.apply(db, db.get_person_handles(sort_handles=False)): for person_handle in filter_func.apply(db, db.get_person_handles(sort_handles=False)):
@ -288,25 +318,23 @@ class Extract:
continue continue
# check whether birth year is within required range # check whether birth year is within required range
birth_handle = person.get_birth_handle() birth = self.get_birth(person).get_date_object()
if birth_handle: if birth:
birth = db.get_event_from_handle(birth_handle).get_date_object()
if birth.get_year_valid(): if birth.get_year_valid():
year = birth.get_year() year = birth.get_year()
if not (year >= year_from and year <= year_to): if not (year >= year_from and year <= year_to):
continue continue
else: else:
# if death before range, person's out of range too... # if death before range, person's out of range too...
death_handle = person.get_death_handle() death = self.get_death(person).get_date_object()
if death_handle: if death:
death = db.get_event_from_handle(death_handle).get_date_object()
if death.get_year_valid() and death.get_year() < year_from: if death.get_year_valid() and death.get_year() < year_from:
continue continue
if not no_years: if not no_years:
# do not accept people who are not known to be in range # do not accept people who are not known to be in range
continue continue
self.get_person_data(db, person, data) self.get_person_data(person, data)
return data return data
# GLOBAL: required so that we get access to _Extract.extractors[] # GLOBAL: required so that we get access to _Extract.extractors[]
@ -347,11 +375,18 @@ class StatisticsChart(Report.Report):
# title needs both data extraction method name + gender name # title needs both data extraction method name + gender name
if gender == Person.male: if gender == Person.male:
genderstr = _("men") genders = _("men")
elif gender == Person.female: elif gender == Person.female:
genderstr = _("women") genders = _("women")
else: else:
genderstr = None genders = None
# needed for keyword based localization
mapping = {
'genders': genders,
'year_from': year_from,
'year_to': year_to
}
# extract requested items from the database and count them # extract requested items from the database and count them
tables = _Extract.collect_data(database, filterfun, options, tables = _Extract.collect_data(database, filterfun, options,
@ -364,14 +399,15 @@ class StatisticsChart(Report.Report):
# generate sorted item lookup index index # generate sorted item lookup index index
lookup = self.index_items(table[1], sortby, reverse) lookup = self.index_items(table[1], sortby, reverse)
# document heading # document heading
if genderstr: mapping['title'] = table[0]
heading = "%s (%s): %04d-%04d" % (table[0], genderstr, year_from, year_to) if genders:
heading = "%(genders)s born %(year_from)04d-%(year_to)04d: %(title)s" % mapping
else: else:
heading = "%s: %04d-%04d" % (table[0], year_from, year_to) heading = "Persons born %(year_from)04d-%(year_to)04d: %(title)s" % mapping
self.data.append((heading, table[1], lookup)) self.data.append((heading, table[1], lookup))
# DEBUG
print heading print heading
print table[1] print table[1]
print lookup
self.setup() self.setup()
@ -437,13 +473,14 @@ class StatisticsChart(Report.Report):
self.doc.start_page() self.doc.start_page()
for data in self.data: for data in self.data:
self.output_chart(data[0], data[1], data[3]) self.output_chart(data[0], data[1], data[2])
self.doc.end_page() self.doc.end_page()
def output_chart(self, title, data, lookup): def output_chart(self, title, data, lookup):
pt2cm = ReportUtils.pt2cm
font = self.doc.style_list['SC-Text'].get_font() font = self.doc.style_list['SC-Text'].get_font()
# set layout variables # set layout variables
@ -536,16 +573,18 @@ class StatisticsChartOptions(ReportOptions.ReportOptions):
["Do not include", "Include"], True) ["Do not include", "Include"], True)
} }
for key in _Extract.extractors: for key in _Extract.extractors:
self.options_help[key] = ("=0/1", _Extract.extractors[key][1], self.options_help[key] = ("=0/1", _Extract.extractors[key][0],
["Leave this data out", "Include chart with this data"], ["Leave char with this data out", "Include chart with this data"],
True) True)
def enable_options(self): def enable_options(self):
# Semi-common options that should be enabled for this report # Semi-common options that should be enabled for this report
self.enable_dict = { self.enable_dict = {
'filter' : 0, 'filter' : 0,
} }
def make_default_style(self, default_style): def make_default_style(self, default_style):
"""Make the default output style for the Statistics report.""" """Make the default output style for the Statistics report."""
f = BaseDoc.FontStyle() f = BaseDoc.FontStyle()
@ -566,6 +605,7 @@ class StatisticsChartOptions(ReportOptions.ReportOptions):
p.set_description(_("The style used for the title of the page.")) p.set_description(_("The style used for the title of the page."))
default_style.add_style("SC-Title",p) default_style.add_style("SC-Title",p)
def get_report_filters(self, person): def get_report_filters(self, person):
"""Set up the list of possible content filters.""" """Set up the list of possible content filters."""
@ -594,6 +634,7 @@ class StatisticsChartOptions(ReportOptions.ReportOptions):
return [all, des, ans, com] return [all, des, ans, com]
def add_user_options(self, dialog): def add_user_options(self, dialog):
""" """
Override the base class add_user_options task to add Override the base class add_user_options task to add
@ -649,12 +690,12 @@ class StatisticsChartOptions(ReportOptions.ReportOptions):
# List of available charts on a separate option tab # List of available charts on a separate option tab
idx = 0 idx = 0
half = len(_Extract.extractors)/2 half = (len(_Extract.extractors)+1)/2
hbox = gtk.HBox() hbox = gtk.HBox()
vbox = gtk.VBox() vbox = gtk.VBox()
self.charts = {} self.charts = {}
for key in _Extract.extractors: for key in _Extract.extractors:
check = gtk.CheckButton(_Extract.extractors[key][2]) check = gtk.CheckButton(_Extract.extractors[key][1])
check.set_active(self.options_dict[key]) check.set_active(self.options_dict[key])
self.charts[key] = check self.charts[key] = check
vbox.add(check) vbox.add(check)
@ -667,6 +708,7 @@ class StatisticsChartOptions(ReportOptions.ReportOptions):
dialog.add_frame_option("Chart Selection", "", hbox, tip) dialog.add_frame_option("Chart Selection", "", hbox, tip)
hbox.show_all() hbox.show_all()
def parse_user_options(self, dialog): def parse_user_options(self, dialog):
""" """
Parses the custom options that we have added. Parses the custom options that we have added.