def on_filters_changed(self, name_space):
if name_space == 'Person':
all_filter = GenericFilter()
all_filter.set_name(_("None"))
all_filter.add_rule(rules.person.Everyone([]))
self.generic.set_model(build_filter_model('Person', [all_filter]))
self.generic.set_active(0)
def on_filters_changed(self, name_space):
if name_space == 'Person':
all_filter = GenericFilter()
all_filter.set_name(_("None"))
all_filter.add_rule(rules.person.Everyone([]))
self.generic.set_model(build_filter_model('Person', [all_filter]))
self.generic.set_active(0)
def on_filters_changed(self, name_space):
if name_space == "Person":
all_filter = GenericFilter()
all_filter.set_name(_("Entire Database"))
all_filter.add_rule(rules.person.Everyone([]))
self.filter_model = build_filter_model("Person", [all_filter])
self.filters.set_model(self.filter_model)
self.filters.set_active(0)
def filter_with_rule(self, rule):
"""
Apply a filter with the given rule.
"""
filter_ = GenericFilter()
filter_.add_rule(rule)
results = filter_.apply(self.db)
return set(results)
def filter_with_rule(self, rule):
"""
Apply a filter with the given rule.
"""
filter_ = GenericFilter()
filter_.add_rule(rule)
results = filter_.apply(self.db)
return set(results)
def __define_person_filters(self):
"""Add person filters if the active person is defined."""
name = name_displayer.display(self.person)
gramps_id = self.person.get_gramps_id()
des = GenericFilter()
# feature request 2356: avoid genitive form
des.set_name(_("Descendants of %s") % name)
des.add_rule(rules.person.IsDescendantOf([gramps_id, 1]))
df = GenericFilter()
# feature request 2356: avoid genitive form
df.set_name(_("Descendant Families of %s") % name)
df.add_rule(rules.person.IsDescendantFamilyOf([gramps_id, 1]))
ans = GenericFilter()
# feature request 2356: avoid genitive form
ans.set_name(_("Ancestors of %s") % name)
ans.add_rule(rules.person.IsAncestorOf([gramps_id, 1]))
com = GenericFilter()
com.set_name(_("People with common ancestor with %s") % name)
com.add_rule(rules.person.HasCommonAncestorWith([gramps_id]))
return [des, df, ans, com]
def __define_person_filters(self):
"""Add person filters if the active person is defined."""
name = name_displayer.display(self.person)
gramps_id = self.person.get_gramps_id()
des = GenericFilter()
# feature request 2356: avoid genitive form
des.set_name(_("Descendants of %s") % name)
des.add_rule(rules.person.IsDescendantOf([gramps_id, 1]))
df = GenericFilter()
# feature request 2356: avoid genitive form
df.set_name(_("Descendant Families of %s") % name)
df.add_rule(rules.person.IsDescendantFamilyOf([gramps_id, 1]))
ans = GenericFilter()
# feature request 2356: avoid genitive form
ans.set_name(_("Ancestors of %s") % name)
ans.add_rule(rules.person.IsAncestorOf([gramps_id, 1]))
com = GenericFilter()
com.set_name(_("People with common ancestor with %s") % name)
com.add_rule(rules.person.HasCommonAncestorWith([gramps_id]))
return [des, df, ans, com]
def test_filter_1(self):
from gramps.gen.filters.rules.person import (IsDescendantOf,
IsAncestorOf)
from gramps.gen.filters import GenericFilter
filter = GenericFilter()
filter.set_logical_op("or")
filter.add_rule(IsDescendantOf(["I0057", True]))
filter.add_rule(IsAncestorOf(["I0057", True]))
result = self.db.Person.filter(filter).count()
self.assertTrue(result == 14, result)
filter.where = lambda person: person.private == True
result = self.db.Person.filter(filter).count()
self.assertTrue(result == 1, result)
filter.where = lambda person: person.private != True
result = self.db.Person.filter(filter).count()
self.assertTrue(result == 13, result)
def test_filter_1(self):
from gramps.gen.filters.rules.person import (IsDescendantOf,
IsAncestorOf)
from gramps.gen.filters import GenericFilter
filter = GenericFilter()
filter.set_logical_op("or")
filter.add_rule(IsDescendantOf(["I0057", True]))
filter.add_rule(IsAncestorOf(["I0057", True]))
result = self.db.Person.filter(filter).count()
self.assertTrue(result == 14, result)
filter.where = lambda person: person.private == True
result = self.db.Person.filter(filter).count()
self.assertTrue(result == 1, result)
filter.where = lambda person: person.private != True
result = self.db.Person.filter(filter).count()
self.assertTrue(result == 13, result)
def get_filter(self):
"""
Extracts the text strings from the sidebar, and uses them to build up
a new filter.
"""
# extract text values from the entry widgets
name = extract_text(self.filter_name)
gid = extract_text(self.filter_id)
birth = extract_text(self.filter_birth)
death = extract_text(self.filter_death)
note = extract_text(self.filter_note)
# extract remaining data from the menus
etype = self.filter_event.get_type().xml_str()
gender = self.filter_gender.get_active()
regex = self.filter_regex.get_active()
tag = self.tag.get_active() > 0
generic = self.generic.get_active() > 0
# check to see if the filter is empty. If it is empty, then
# we don't build a filter
empty = not (name or gid or birth or death or etype or note or gender
or regex or tag or generic)
if empty:
generic_filter = None
else:
# build a GenericFilter
generic_filter = GenericFilter()
# if the name is not empty, choose either the regular expression
# version or the normal text match
if name:
rule = RegExpName([name], use_regex=regex)
generic_filter.add_rule(rule)
# if the id is not empty, choose either the regular expression
# version or the normal text match
if gid:
rule = RegExpIdOf([gid], use_regex=regex)
generic_filter.add_rule(rule)
# check the gender, and select the right rule based on gender
if gender > 0:
if gender == 1:
generic_filter.add_rule(IsMale([]))
elif gender == 2:
generic_filter.add_rule(IsFemale([]))
else:
generic_filter.add_rule(HasUnknownGender([]))
# Build an event filter if needed
if etype:
rule = HasEvent([etype, '', '', '', '', True], use_regex=regex)
generic_filter.add_rule(rule)
# Build birth event filter if needed
# Arguments for the HasBirth filter are Date, Place, and Description
# Since the value we extracted to the "birth" variable is the
# request date, we pass it as the first argument
if birth:
rule = HasBirth([birth, '', ''])
generic_filter.add_rule(rule)
# Build death event filter if needed
if death:
rule = HasDeath([death, '', ''])
generic_filter.add_rule(rule)
# Build note filter if needed
if note:
rule = HasNoteRegexp([note], use_regex=regex)
generic_filter.add_rule(rule)
# check the Tag
if tag:
model = self.tag.get_model()
node = self.tag.get_active_iter()
attr = model.get_value(node, 0)
rule = HasTag([attr])
generic_filter.add_rule(rule)
if self.generic.get_active() != 0:
model = self.generic.get_model()
node = self.generic.get_active_iter()
obj = str(model.get_value(node, 0))
rule = MatchesFilter([obj])
generic_filter.add_rule(rule)
return generic_filter
def get_filter(self):
"""
Extracts the text strings from the sidebar, and uses them to build up
a new filter.
"""
# extract text values from the entry widgets
name = extract_text(self.filter_name)
gid = extract_text(self.filter_id)
birth = extract_text(self.filter_birth)
death = extract_text(self.filter_death)
note = extract_text(self.filter_note)
# extract remaining data from the menus
etype = self.filter_event.get_type().xml_str()
gender = self.filter_gender.get_active()
regex = self.filter_regex.get_active()
tag = self.tag.get_active() > 0
generic = self.generic.get_active() > 0
# check to see if the filter is empty. If it is empty, then
# we don't build a filter
empty = not (name or gid or birth or death or etype
or note or gender or regex or tag or generic)
if empty:
generic_filter = None
else:
# build a GenericFilter
generic_filter = GenericFilter()
# if the name is not empty, choose either the regular expression
# version or the normal text match
if name:
name_parts = name.split(sep=" ")
for name_part in name_parts:
rule = RegExpName([name_part], use_regex=regex)
generic_filter.add_rule(rule)
# if the id is not empty, choose either the regular expression
# version or the normal text match
if gid:
rule = RegExpIdOf([gid], use_regex=regex)
generic_filter.add_rule(rule)
# check the gender, and select the right rule based on gender
if gender > 0:
if gender == 1:
generic_filter.add_rule(IsMale([]))
elif gender == 2:
generic_filter.add_rule(IsFemale([]))
else:
generic_filter.add_rule(HasUnknownGender([]))
# Build an event filter if needed
if etype:
rule = HasEvent([etype, '', '', '', '', '1'], use_regex=regex)
generic_filter.add_rule(rule)
# Build birth event filter if needed
# Arguments for the HasBirth filter are Date, Place, and Description
# Since the value we extracted to the "birth" variable is the
# request date, we pass it as the first argument
if birth:
rule = HasBirth([birth, '', ''])
generic_filter.add_rule(rule)
# Build death event filter if needed
if death:
rule = HasDeath([death, '', ''])
generic_filter.add_rule(rule)
# Build note filter if needed
if note:
rule = HasNoteRegexp([note], use_regex=regex)
generic_filter.add_rule(rule)
# check the Tag
if tag:
model = self.tag.get_model()
node = self.tag.get_active_iter()
attr = model.get_value(node, 0)
rule = HasTag([attr])
generic_filter.add_rule(rule)
if self.generic.get_active() != 0:
model = self.generic.get_model()
node = self.generic.get_active_iter()
obj = str(model.get_value(node, 0))
rule = MatchesFilter([obj])
generic_filter.add_rule(rule)
return generic_filter
def filter_with_rule(self, rule):
filter_ = GenericFilter()
filter_.add_rule(rule)
results = filter_.apply(self.db)
return set(results)
