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

Improve pylint score of some new files

Browse Source 
The programming guidelines require that new files have a pylint
score of 9.0 or greater.
This commit is contained in:
Nick Hall
2016-05-17 22:23:36 +01:00
parent 7b22c6af1b
commit fe6c5895b2
8 changed files with 724 additions and 265 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
gramps/gen/filters/rules/family/_isancestorof.py
View File

@@ -19,6 +19,10 @@
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
# #
"""
Rule that checks for a family that is an ancestor of a specified family.
"""
#------------------------------------------------------------------------- #-------------------------------------------------------------------------
# #
# Gramps modules # Gramps modules
@@ -37,7 +41,7 @@ class IsAncestorOf(Rule):
""" """
Rule that checks for a family that is an ancestor of a specified family. Rule that checks for a family that is an ancestor of a specified family.
""" """
labels = [ _('ID:'), _('Inclusive:') ] labels = [_('ID:'), _('Inclusive:')]
name = _('Ancestor families of <family>') name = _('Ancestor families of <family>')
category = _('General filters') category = _('General filters')
description = _('Matches ancestor families of the specified family') description = _('Matches ancestor families of the specified family')
@@ -55,6 +59,9 @@ class IsAncestorOf(Rule):
return family.handle in self.map return family.handle in self.map
def init_list(self, db, family, first): def init_list(self, db, family, first):
"""
Initialise family handle list.
"""
if not family: if not family:
return return
if family.handle in self.map: if family.handle in self.map:

9
gramps/gen/filters/rules/family/_isdescendantof.py
View File

@@ -19,6 +19,10 @@
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
# #
"""
Rule that checks for a family that is a descendant of a specified family.
"""
#------------------------------------------------------------------------- #-------------------------------------------------------------------------
# #
# Gramps modules # Gramps modules
@@ -37,7 +41,7 @@ class IsDescendantOf(Rule):
""" """
Rule that checks for a family that is a descendant of a specified family. Rule that checks for a family that is a descendant of a specified family.
""" """
labels = [ _('ID:'), _('Inclusive:') ] labels = [_('ID:'), _('Inclusive:')]
name = _('Descendant families of <family>') name = _('Descendant families of <family>')
category = _('General filters') category = _('General filters')
description = _('Matches descendant families of the specified family') description = _('Matches descendant families of the specified family')
@@ -55,6 +59,9 @@ class IsDescendantOf(Rule):
return family.handle in self.map return family.handle in self.map
def init_list(self, db, family, first): def init_list(self, db, family, first):
"""
Initialise family handle list.
"""
if not family: if not family:
return return
if not first: if not first:

100
gramps/gen/filters/rules/test/event_rules_test.py
View File

@@ -27,42 +27,70 @@ from gramps.gen.merge.diff import import_as_dict
from gramps.cli.user import User from gramps.cli.user import User
from gramps.gen.filters import GenericFilterFactory from gramps.gen.filters import GenericFilterFactory
from gramps.gen.filters.rules.event import * from gramps.gen.filters.rules.event import (
AllEvents, HasType, HasIdOf, HasGallery, RegExpIdOf, HasCitation, HasNote,
HasNoteRegexp, HasReferenceCountOf, HasSourceCount, EventPrivate,
MatchesSourceConfidence, HasAttribute, HasData, ChangedSince, HasTag,
HasDayOfWeek)
GenericEventFilter = GenericFilterFactory('Event') GenericEventFilter = GenericFilterFactory('Event')
class BaseTest(unittest.TestCase): class BaseTest(unittest.TestCase):
"""
Event rule tests.
"""
@classmethod @classmethod
def setUpClass(cls): def setUpClass(cls):
"""
Import example database.
"""
cls.db = import_as_dict("example/gramps/example.gramps", User()) cls.db = import_as_dict("example/gramps/example.gramps", User())
def filter_with_rule(self, rule): def filter_with_rule(self, rule):
"""
Apply a filter with the given rule.
"""
filter_ = GenericEventFilter() filter_ = GenericEventFilter()
filter_.add_rule(rule) filter_.add_rule(rule)
results = filter_.apply(self.db) results = filter_.apply(self.db)
return set(results) return set(results)
def test_AllEvents(self): def test_allevents(self):
"""
Test AllEvents rule.
"""
rule = AllEvents([]) rule = AllEvents([])
self.assertEqual(len(self.filter_with_rule(rule)), self.assertEqual(len(self.filter_with_rule(rule)),
self.db.get_number_of_events()) self.db.get_number_of_events())
def test_HasType(self): def test_hastype(self):
"""
Test HasType rule.
"""
rule = HasType(['Burial']) rule = HasType(['Burial'])
self.assertEqual(len(self.filter_with_rule(rule)), 296) self.assertEqual(len(self.filter_with_rule(rule)), 296)
def test_HasIdOf(self): def test_hasidof(self):
"""
Test HasIdOf rule.
"""
rule = HasIdOf(['E0001']) rule = HasIdOf(['E0001'])
self.assertEqual(self.filter_with_rule(rule), self.assertEqual(self.filter_with_rule(rule),
set([b'a5af0eb696917232725'])) set([b'a5af0eb696917232725']))
def test_HasGallery(self): def test_hasgallery(self):
"""
Test HasGallery rule.
"""
rule = HasGallery(['0', 'greater than']) rule = HasGallery(['0', 'greater than'])
self.assertEqual(self.filter_with_rule(rule), self.assertEqual(self.filter_with_rule(rule),
set([b'a5af0ecb107303354a0'])) set([b'a5af0ecb107303354a0']))
def test_RegExpIdOf(self): def test_regexpidof(self):
"""
Test RegExpIdOf rule.
"""
rule = RegExpIdOf(['E000.'], use_regex=True) rule = RegExpIdOf(['E000.'], use_regex=True)
self.assertEqual(self.filter_with_rule(rule), set([ self.assertEqual(self.filter_with_rule(rule), set([
b'a5af0eb69cf2d3fb615', b'a5af0eb667015e355db', b'a5af0eb69cf2d3fb615', b'a5af0eb667015e355db',
@@ -71,63 +99,99 @@ class BaseTest(unittest.TestCase):
b'a5af0eb69f41bfb5a6a', b'a5af0eb69c40c179441', b'a5af0eb69f41bfb5a6a', b'a5af0eb69c40c179441',
b'a5af0eb6a3229544ba2', b'a5af0eb696917232725'])) b'a5af0eb6a3229544ba2', b'a5af0eb696917232725']))
def test_HasCitation(self): def test_hascitation(self):
"""
Test HasCitation rule.
"""
rule = HasCitation(['page 1', '', '']) rule = HasCitation(['page 1', '', ''])
self.assertEqual(self.filter_with_rule(rule), self.assertEqual(self.filter_with_rule(rule),
set([b'a5af0ecb107303354a0'])) set([b'a5af0ecb107303354a0']))
def test_HasNote(self): def test_hasnote(self):
"""
Test HasNote rule.
"""
rule = HasNote([]) rule = HasNote([])
self.assertEqual(self.filter_with_rule(rule), self.assertEqual(self.filter_with_rule(rule),
set([b'a5af0ecb11f5ac3110e'])) set([b'a5af0ecb11f5ac3110e']))
def test_HasNoteRegexp(self): def test_hasnoteregexp(self):
"""
Test HasNoteRegexp rule.
"""
rule = HasNoteRegexp(['.'], use_regex=True) rule = HasNoteRegexp(['.'], use_regex=True)
self.assertEqual(self.filter_with_rule(rule), self.assertEqual(self.filter_with_rule(rule),
set([b'a5af0ecb11f5ac3110e'])) set([b'a5af0ecb11f5ac3110e']))
def test_HasReferenceCountOf(self): def test_hasreferencecountof(self):
"""
Test HasReferenceCountOf rule.
"""
rule = HasReferenceCountOf(['greater than', '1']) rule = HasReferenceCountOf(['greater than', '1'])
self.assertEqual(self.filter_with_rule(rule), set([ self.assertEqual(self.filter_with_rule(rule), set([
b'cc8205d86fc4e9706a5', b'a5af0ed60de7a612b9e', b'cc8205d86fc4e9706a5', b'a5af0ed60de7a612b9e',
b'cc820604ef05cb67907'])) b'cc820604ef05cb67907']))
def test_HasSourceCount(self): def test_hassourcecount(self):
"""
Test HasSourceCount rule.
"""
rule = HasSourceCount(['1', 'greater than']) rule = HasSourceCount(['1', 'greater than'])
self.assertEqual(self.filter_with_rule(rule), self.assertEqual(self.filter_with_rule(rule),
set([b'a5af0ecb107303354a0'])) set([b'a5af0ecb107303354a0']))
def test_EventPrivate(self): def test_eventprivate(self):
"""
Test EventPrivate rule.
"""
rule = EventPrivate([]) rule = EventPrivate([])
self.assertEqual(self.filter_with_rule(rule), set([])) self.assertEqual(self.filter_with_rule(rule), set([]))
def test_MatchesSourceConfidence(self): def test_matchessourceconfidence(self):
"""
Test MatchesSourceConfidence rule.
"""
rule = MatchesSourceConfidence(['2']) rule = MatchesSourceConfidence(['2'])
self.assertEqual(self.filter_with_rule(rule), self.assertEqual(self.filter_with_rule(rule),
set([b'a5af0ecb107303354a0'])) set([b'a5af0ecb107303354a0']))
def test_HasAttribute(self): def test_hasattribute(self):
"""
Test HasAttribute rule.
"""
rule = HasAttribute(['Cause', '']) rule = HasAttribute(['Cause', ''])
self.assertEqual(self.filter_with_rule(rule), self.assertEqual(self.filter_with_rule(rule),
set([b'a5af0ecb11f5ac3110e'])) set([b'a5af0ecb11f5ac3110e']))
def test_HasData(self): def test_hasdata(self):
"""
Test HasData rule.
"""
rule = HasData(['Burial', 'before 1800', 'USA', '']) rule = HasData(['Burial', 'before 1800', 'USA', ''])
self.assertEqual(self.filter_with_rule(rule), set([ self.assertEqual(self.filter_with_rule(rule), set([
b'a5af0ed4211095487d2', b'a5af0ed36793c1d3e05', b'a5af0ed4211095487d2', b'a5af0ed36793c1d3e05',
b'a5af0ecfcc16ce7a96a'])) b'a5af0ecfcc16ce7a96a']))
def test_ChangedSince(self): def test_changedsince(self):
"""
Test ChangedSince rule.
"""
rule = ChangedSince(['2011-01-01', '2014-01-01']) rule = ChangedSince(['2011-01-01', '2014-01-01'])
self.assertEqual(self.filter_with_rule(rule), set([ self.assertEqual(self.filter_with_rule(rule), set([
b'a5af0ecb107303354a0', b'a5af0ecb11f5ac3110e', b'a5af0ecb107303354a0', b'a5af0ecb11f5ac3110e',
b'a5af0ed5df832ee65c1'])) b'a5af0ed5df832ee65c1']))
def test_HasTag(self): def test_hastag(self):
"""
Test HasTag rule.
"""
rule = HasTag(['ToDo']) rule = HasTag(['ToDo'])
self.assertEqual(self.filter_with_rule(rule), set([])) self.assertEqual(self.filter_with_rule(rule), set([]))
def test_HasDayOfWeek(self): def test_hasdayofweek(self):
"""
Test HasDayOfWeek rule.
"""
rule = HasDayOfWeek(['2']) rule = HasDayOfWeek(['2'])
self.assertEqual(len(self.filter_with_rule(rule)), 177) self.assertEqual(len(self.filter_with_rule(rule)), 177)

157
gramps/gen/filters/rules/test/family_rules_test.py
View File

@@ -27,52 +27,88 @@ from gramps.gen.merge.diff import import_as_dict
from gramps.cli.user import User from gramps.cli.user import User
from gramps.gen.filters import GenericFilterFactory from gramps.gen.filters import GenericFilterFactory
from gramps.gen.filters.rules.family import * from gramps.gen.filters.rules.family import (
AllFamilies, HasRelType, HasGallery, HasIdOf, HasLDS, HasNote, RegExpIdOf,
HasNoteRegexp, HasReferenceCountOf, HasSourceCount, HasSourceOf,
HasCitation, FamilyPrivate, HasEvent, HasAttribute, IsBookmarked,
MatchesSourceConfidence, FatherHasNameOf, FatherHasIdOf, MotherHasNameOf,
MotherHasIdOf, ChildHasNameOf, ChildHasIdOf, ChangedSince, HasTag,
HasTwins, IsAncestorOf, IsDescendantOf)
GenericFamilyFilter = GenericFilterFactory('Family') GenericFamilyFilter = GenericFilterFactory('Family')
class BaseTest(unittest.TestCase): class BaseTest(unittest.TestCase):
"""
Family rule tests.
"""
@classmethod @classmethod
def setUpClass(cls): def setUpClass(cls):
"""
Import example database.
"""
cls.db = import_as_dict("example/gramps/example.gramps", User()) cls.db = import_as_dict("example/gramps/example.gramps", User())
def filter_with_rule(self, rule): def filter_with_rule(self, rule):
"""
Apply a filter with the given rule.
"""
filter_ = GenericFamilyFilter() filter_ = GenericFamilyFilter()
filter_.add_rule(rule) filter_.add_rule(rule)
results = filter_.apply(self.db) results = filter_.apply(self.db)
return set(results) return set(results)
def test_AllFamilies(self): def test_allfamilies(self):
"""
Test AllFamilies rule.
"""
rule = AllFamilies([]) rule = AllFamilies([])
self.assertEqual(len(self.filter_with_rule(rule)), self.assertEqual(len(self.filter_with_rule(rule)),
self.db.get_number_of_families()) self.db.get_number_of_families())
def test_HasRelType(self): def test_hasreltype(self):
"""
Test HasRelType rule.
"""
rule = HasRelType(['Married']) rule = HasRelType(['Married'])
self.assertEqual(len(self.filter_with_rule(rule)), 738) self.assertEqual(len(self.filter_with_rule(rule)), 738)
def test_HasGallery(self): def test_hasgallery(self):
"""
Test HasGallery rule.
"""
rule = HasGallery(['0', 'greater than']) rule = HasGallery(['0', 'greater than'])
self.assertEqual(self.filter_with_rule(rule), self.assertEqual(self.filter_with_rule(rule),
set([b'9OUJQCBOHW9UEK9CNV'])) set([b'9OUJQCBOHW9UEK9CNV']))
def test_HasIdOf(self): def test_hasidof(self):
"""
Test HasIdOf rule.
"""
rule = HasIdOf(['F0001']) rule = HasIdOf(['F0001'])
self.assertEqual(self.filter_with_rule(rule), self.assertEqual(self.filter_with_rule(rule),
set([b'48TJQCGNNIR5SJRCAK'])) set([b'48TJQCGNNIR5SJRCAK']))
def test_HasLDS(self): def test_haslds(self):
"""
Test HasLDS rule.
"""
rule = HasLDS(['0', 'greater than']) rule = HasLDS(['0', 'greater than'])
self.assertEqual(self.filter_with_rule(rule), self.assertEqual(self.filter_with_rule(rule),
set([b'9OUJQCBOHW9UEK9CNV'])) set([b'9OUJQCBOHW9UEK9CNV']))
def test_HasNote(self): def test_hasnote(self):
"""
Test HasNote rule.
"""
rule = HasNote([]) rule = HasNote([])
self.assertEqual(self.filter_with_rule(rule), self.assertEqual(self.filter_with_rule(rule),
set([b'9OUJQCBOHW9UEK9CNV'])) set([b'9OUJQCBOHW9UEK9CNV']))
def test_RegExpIdOf(self): def test_regexpidof(self):
"""
Test RegExpIdOf rule.
"""
rule = RegExpIdOf(['F000.'], use_regex=True) rule = RegExpIdOf(['F000.'], use_regex=True)
self.assertEqual(self.filter_with_rule(rule), set([ self.assertEqual(self.filter_with_rule(rule), set([
b'LOTJQC78O5B4WQGJRP', b'UPTJQC4VPCABZUDB75', b'NBTJQCIX49EKOCIHBP', b'LOTJQC78O5B4WQGJRP', b'UPTJQC4VPCABZUDB75', b'NBTJQCIX49EKOCIHBP',
@@ -80,12 +116,18 @@ class BaseTest(unittest.TestCase):
b'48TJQCGNNIR5SJRCAK', b'4YTJQCTEH7PQUU4AD', b'MTTJQC05LKVFFLN01A', b'48TJQCGNNIR5SJRCAK', b'4YTJQCTEH7PQUU4AD', b'MTTJQC05LKVFFLN01A',
])) ]))
def test_HasNoteRegexp(self): def test_hasnoteregexp(self):
"""
Test HasNoteRegexp rule.
"""
rule = HasNoteRegexp(['.'], use_regex=True) rule = HasNoteRegexp(['.'], use_regex=True)
self.assertEqual(self.filter_with_rule(rule), self.assertEqual(self.filter_with_rule(rule),
set([b'9OUJQCBOHW9UEK9CNV'])) set([b'9OUJQCBOHW9UEK9CNV']))
def test_HasReferenceCountOf(self): def test_hasreferencecountof(self):
"""
Test HasReferenceCountOf rule.
"""
rule = HasReferenceCountOf(['greater than', '12']) rule = HasReferenceCountOf(['greater than', '12'])
self.assertEqual(self.filter_with_rule(rule), set([ self.assertEqual(self.filter_with_rule(rule), set([
b'29IKQCMUNFTIBV653N', b'8OUJQCUVZ0XML7BQLF', b'UPTJQC4VPCABZUDB75', b'29IKQCMUNFTIBV653N', b'8OUJQCUVZ0XML7BQLF', b'UPTJQC4VPCABZUDB75',
@@ -93,69 +135,108 @@ class BaseTest(unittest.TestCase):
b'MTTJQC05LKVFFLN01A', b'C2VJQC71TNHO7RBBMX', b'QIDKQCJQ37SIUQ3UFU', b'MTTJQC05LKVFFLN01A', b'C2VJQC71TNHO7RBBMX', b'QIDKQCJQ37SIUQ3UFU',
b'DV4KQCX9OBVQ74H77F'])) b'DV4KQCX9OBVQ74H77F']))
def test_HasSourceCount(self): def test_hassourcecount(self):
"""
Test HasSourceCount rule.
"""
rule = HasSourceCount(['1', 'greater than']) rule = HasSourceCount(['1', 'greater than'])
self.assertEqual(self.filter_with_rule(rule), self.assertEqual(self.filter_with_rule(rule),
set([b'9OUJQCBOHW9UEK9CNV'])) set([b'9OUJQCBOHW9UEK9CNV']))
def test_HasSourceOf(self): def test_hassourceof(self):
"""
Test HasSourceOf rule.
"""
rule = HasSourceOf(['S0001']) rule = HasSourceOf(['S0001'])
self.assertEqual(self.filter_with_rule(rule), self.assertEqual(self.filter_with_rule(rule),
set([b'9OUJQCBOHW9UEK9CNV'])) set([b'9OUJQCBOHW9UEK9CNV']))
def test_HasCitation(self): def test_hascitation(self):
"""
Test HasCitation rule.
"""
rule = HasCitation(['page 10', '', '2']) rule = HasCitation(['page 10', '', '2'])
self.assertEqual(self.filter_with_rule(rule), self.assertEqual(self.filter_with_rule(rule),
set([b'9OUJQCBOHW9UEK9CNV'])) set([b'9OUJQCBOHW9UEK9CNV']))
def test_FamilyPrivate(self): def test_familyprivate(self):
"""
Test FamilyPrivate rule.
"""
rule = FamilyPrivate([]) rule = FamilyPrivate([])
self.assertEqual(self.filter_with_rule(rule), set([])) self.assertEqual(self.filter_with_rule(rule), set([]))
def test_HasEvent(self): def test_hasevent(self):
"""
Test HasEvent rule.
"""
rule = HasEvent(['Marriage', 'before 1900', 'USA', '', 'Garner']) rule = HasEvent(['Marriage', 'before 1900', 'USA', '', 'Garner'])
self.assertEqual(self.filter_with_rule(rule), set([ self.assertEqual(self.filter_with_rule(rule), set([
b'KSFKQCP4V0YXGM1LR9', b'8ZFKQC3FRSHACOJBOU', b'3XFKQCE7QUDJ99AVNV', b'KSFKQCP4V0YXGM1LR9', b'8ZFKQC3FRSHACOJBOU', b'3XFKQCE7QUDJ99AVNV',
b'OVFKQC51DX0OQUV3JB', b'9OUJQCBOHW9UEK9CNV'])) b'OVFKQC51DX0OQUV3JB', b'9OUJQCBOHW9UEK9CNV']))
def test_HasAttribute(self): def test_hasattribute(self):
"""
Test HasAttribute rule.
"""
rule = HasAttribute(['Number of Children', '']) rule = HasAttribute(['Number of Children', ''])
self.assertEqual(self.filter_with_rule(rule), self.assertEqual(self.filter_with_rule(rule),
set([b'9OUJQCBOHW9UEK9CNV'])) set([b'9OUJQCBOHW9UEK9CNV']))
def test_IsBookmarked(self): def test_isbookmarked(self):
"""
Test IsBookmarked rule.
"""
rule = IsBookmarked([]) rule = IsBookmarked([])
self.assertEqual(self.filter_with_rule(rule), self.assertEqual(self.filter_with_rule(rule),
set([b'9OUJQCBOHW9UEK9CNV'])) set([b'9OUJQCBOHW9UEK9CNV']))
def test_MatchesSourceConfidence(self): def test_matchessourceconfidence(self):
"""
Test MatchesSourceConfidence rule.
"""
rule = MatchesSourceConfidence(['0']) rule = MatchesSourceConfidence(['0'])
self.assertEqual(len(self.filter_with_rule(rule)), 734) self.assertEqual(len(self.filter_with_rule(rule)), 734)
def test_FatherHasNameOf(self): def test_fatherhasnameof(self):
"""
Test FatherHasNameOf rule.
"""
rule = FatherHasNameOf(['', '', 'Dr.', '', '', '', '', '', '', '', rule = FatherHasNameOf(['', '', 'Dr.', '', '', '', '', '', '', '',
'']) ''])
self.assertEqual(self.filter_with_rule(rule), self.assertEqual(self.filter_with_rule(rule),
set([b'9OUJQCBOHW9UEK9CNV'])) set([b'9OUJQCBOHW9UEK9CNV']))
def test_FatherHasIdOf(self): def test_fatherhasidof(self):
"""
Test FatherHasIdOf rule.
"""
rule = FatherHasIdOf(['I0106']) rule = FatherHasIdOf(['I0106'])
self.assertEqual(self.filter_with_rule(rule), self.assertEqual(self.filter_with_rule(rule),
set([b'8OUJQCUVZ0XML7BQLF'])) set([b'8OUJQCUVZ0XML7BQLF']))
def test_MotherHasNameOf(self): def test_motherhasnameof(self):
"""
Test MotherHasNameOf rule.
"""
rule = MotherHasNameOf(['', 'Alvarado', '', '', '', '', '', '', '', '', rule = MotherHasNameOf(['', 'Alvarado', '', '', '', '', '', '', '', '',
'']) ''])
self.assertEqual(self.filter_with_rule(rule), set([ self.assertEqual(self.filter_with_rule(rule), set([
b'EM3KQC48HFLA02TF8D', b'K9NKQCBG105ECXZ48D', b'EM3KQC48HFLA02TF8D', b'K9NKQCBG105ECXZ48D',
b'2QMKQC5YWNAWZMG6VO', b'6JUJQCCAXGENRX990K'])) b'2QMKQC5YWNAWZMG6VO', b'6JUJQCCAXGENRX990K']))
def test_MotherHasIdOf(self): def test_motherhasidof(self):
"""
Test MotherHasIdOf rule.
"""
rule = MotherHasIdOf(['I0107']) rule = MotherHasIdOf(['I0107'])
self.assertEqual(self.filter_with_rule(rule), self.assertEqual(self.filter_with_rule(rule),
set([b'8OUJQCUVZ0XML7BQLF'])) set([b'8OUJQCUVZ0XML7BQLF']))
def test_ChildHasNameOf(self): def test_childhasnameof(self):
"""
Test ChildHasNameOf rule.
"""
rule = ChildHasNameOf(['Eugene', '', '', '', '', '', '', '', '', '', rule = ChildHasNameOf(['Eugene', '', '', '', '', '', '', '', '', '',
'']) ''])
self.assertEqual(self.filter_with_rule(rule), set([ self.assertEqual(self.filter_with_rule(rule), set([
@@ -163,29 +244,44 @@ class BaseTest(unittest.TestCase):
b'7CTJQCFJVBQSY076A6', b'9OUJQCBOHW9UEK9CNV', b'9IXJQCX18AHUFPQHEZ', b'7CTJQCFJVBQSY076A6', b'9OUJQCBOHW9UEK9CNV', b'9IXJQCX18AHUFPQHEZ',
b'9NWJQCJGLXUR3AQSFJ'])) b'9NWJQCJGLXUR3AQSFJ']))
def test_ChildHasIdOf(self): def test_childhasidof(self):
"""
Test ChildHasIdOf rule.
"""
rule = ChildHasIdOf(['I0001']) rule = ChildHasIdOf(['I0001'])
self.assertEqual(self.filter_with_rule(rule), self.assertEqual(self.filter_with_rule(rule),
set([b'48TJQCGNNIR5SJRCAK'])) set([b'48TJQCGNNIR5SJRCAK']))
def test_ChangedSince(self): def test_changedsince(self):
"""
Test ChangedSince rule.
"""
rule = ChangedSince(['2008-01-01', '2014-01-01']) rule = ChangedSince(['2008-01-01', '2014-01-01'])
self.assertEqual(self.filter_with_rule(rule), self.assertEqual(self.filter_with_rule(rule),
set([b'9OUJQCBOHW9UEK9CNV'])) set([b'9OUJQCBOHW9UEK9CNV']))
def test_HasTag(self): def test_hastag(self):
"""
Test HasTag rule.
"""
rule = HasTag(['ToDo']) rule = HasTag(['ToDo'])
self.assertEqual(self.filter_with_rule(rule), self.assertEqual(self.filter_with_rule(rule),
set([b'9OUJQCBOHW9UEK9CNV'])) set([b'9OUJQCBOHW9UEK9CNV']))
def test_HasTwins(self): def test_hastwins(self):
"""
Test HasTwins rule.
"""
rule = HasTwins([]) rule = HasTwins([])
self.assertEqual(self.filter_with_rule(rule), set([ self.assertEqual(self.filter_with_rule(rule), set([
b'SD6KQC7LB8MYGA7F5W', b'8OUJQCUVZ0XML7BQLF', b'1BVJQCNTFAGS8273LJ', b'SD6KQC7LB8MYGA7F5W', b'8OUJQCUVZ0XML7BQLF', b'1BVJQCNTFAGS8273LJ',
b'5IUJQCRJY47YQ8PU7N', b'ZLUJQCPDV93OR8KHB7', b'4U2KQCBXG2VTPH6U1F', b'5IUJQCRJY47YQ8PU7N', b'ZLUJQCPDV93OR8KHB7', b'4U2KQCBXG2VTPH6U1F',
])) ]))
def test_IsAncestorOf(self): def test_isancestorof(self):
"""
Test IsAncestorOf rule.
"""
rule = IsAncestorOf(['F0031', '0']) rule = IsAncestorOf(['F0031', '0'])
self.assertEqual(self.filter_with_rule(rule), set([ self.assertEqual(self.filter_with_rule(rule), set([
b'4AXJQC96KTN3WGPTVE', b'1RUJQCYX9QL1V45YLD', b'5GTJQCXVYVAIQTBVKA', b'4AXJQC96KTN3WGPTVE', b'1RUJQCYX9QL1V45YLD', b'5GTJQCXVYVAIQTBVKA',
@@ -194,7 +290,10 @@ class BaseTest(unittest.TestCase):
b'57WJQCTBJKR5QYPS6K', b'8OUJQCUVZ0XML7BQLF', b'7PUJQC4PPS4EDIVMYE' b'57WJQCTBJKR5QYPS6K', b'8OUJQCUVZ0XML7BQLF', b'7PUJQC4PPS4EDIVMYE'
])) ]))
def test_IsDescendantOf(self): def test_isdescendantof(self):
"""
Test IsDescendantOf rule.
"""
rule = IsDescendantOf(['F0031', '0']) rule = IsDescendantOf(['F0031', '0'])
self.assertEqual(self.filter_with_rule(rule), set([ self.assertEqual(self.filter_with_rule(rule), set([
b'SFXJQCLE8PIG7PH38J', b'UCXJQCC5HS8VXDKWBM', b'IIEKQCRX89WYBHKB7R', b'SFXJQCLE8PIG7PH38J', b'UCXJQCC5HS8VXDKWBM', b'IIEKQCRX89WYBHKB7R',

473
gramps/gen/filters/rules/test/person_rules_test.py
View File

@@ -27,337 +27,520 @@ from gramps.gen.merge.diff import import_as_dict
from gramps.cli.user import User from gramps.cli.user import User
from gramps.gen.filters import GenericFilter from gramps.gen.filters import GenericFilter
from gramps.gen.filters.rules.person import * from gramps.gen.filters.rules.person import (
Disconnected, Everyone, FamilyWithIncompleteEvent, HasAlternateName,
HasCommonAncestorWith, HasNickname, HasUnknownGender, HasSourceOf,
HaveAltFamilies, HaveChildren, IncompleteNames, IsBookmarked,
IsDuplicatedAncestorOf, IsRelatedWith, HasIdOf, IsDefaultPerson, IsFemale,
IsMale, MissingParent, MultipleMarriages, NeverMarried, NoBirthdate,
NoDeathdate, PeoplePrivate, PeoplePublic, PersonWithIncompleteEvent,
RelationshipPathBetweenBookmarks)
class BaseTest(unittest.TestCase): class BaseTest(unittest.TestCase):
"""
Person rule tests.
"""
@classmethod @classmethod
def setUpClass(cls): def setUpClass(cls):
"""
Import example database.
"""
cls.db = import_as_dict("example/gramps/example.gramps", User()) cls.db = import_as_dict("example/gramps/example.gramps", User())
def filter_with_rule(self, rule): def filter_with_rule(self, rule):
"""
Apply a filter with the given rule.
"""
filter_ = GenericFilter() filter_ = GenericFilter()
filter_.add_rule(rule) filter_.add_rule(rule)
results = filter_.apply(self.db) results = filter_.apply(self.db)
return set(results) return set(results)
def test_Disconnected(self): def test_disconnected(self):
"""
Test Disconnected rule.
"""
rule = Disconnected([]) rule = Disconnected([])
self.assertEqual(self.filter_with_rule(rule), set([ self.assertEqual(self.filter_with_rule(rule), set([
b'0PBKQCXHLAEIB46ZIA', b'QEVJQC04YO01UAWJ2N', b'UT0KQCMN7PC9XURRXJ', b'MZAKQCKAQLIQYWP5IW', b'0PBKQCXHLAEIB46ZIA', b'QEVJQC04YO01UAWJ2N', b'UT0KQCMN7PC9XURRXJ',
b'Y7BKQC9CUXWQLGLPQM', b'OBBKQC8NJM5UYBO849', b'NPBKQCKEF0G7T4H312', b'423KQCGLT8UISDUM1Q', b'MZAKQCKAQLIQYWP5IW', b'Y7BKQC9CUXWQLGLPQM', b'OBBKQC8NJM5UYBO849',
b'8S0KQCNORIWDL0X8SB', b'AP5KQC0LBXPM727OWB', b'AREKQC0VPBHNZ5R3IO', b'KU0KQCJ0RUTJTIUKSA', b'NPBKQCKEF0G7T4H312', b'423KQCGLT8UISDUM1Q', b'8S0KQCNORIWDL0X8SB',
b'VC4KQC7L7KKH9RLHXN', b'0P3KQCRSIVL1A4VJ19', b'PK6KQCGEL4PTE720BL', b'YIKKQCSD2Z85UHJ8LX', b'AP5KQC0LBXPM727OWB', b'AREKQC0VPBHNZ5R3IO', b'KU0KQCJ0RUTJTIUKSA',
b'KY8KQCMIH2HUUGLA3R', b'RD7KQCQ24B1N3OEC5X', b'NV0KQC7SIEH3SVDPP1', b'KIKKQCU2CJ543TLM5J', b'VC4KQC7L7KKH9RLHXN', b'0P3KQCRSIVL1A4VJ19', b'PK6KQCGEL4PTE720BL',
b'AT0KQC4P3MMUCHI3BK', b'J6BKQC1PMNBAYSLM9U', b'IXXJQCLKOUAJ5RSQY4', b'U4ZJQC5VR0QBIE8DU', b'YIKKQCSD2Z85UHJ8LX', b'KY8KQCMIH2HUUGLA3R', b'RD7KQCQ24B1N3OEC5X',
b'F7BKQC4NXO9R7XOG2W', b'7U0KQC6PGZBNQATNOT', b'78AKQCI05U36T3E82O', b'H1GKQCWOUJHFSHXABA', b'NV0KQC7SIEH3SVDPP1', b'KIKKQCU2CJ543TLM5J', b'AT0KQC4P3MMUCHI3BK',
b'ZWGKQCRFZAPC5PYJZ1', b'EZ0KQCF3LSM9PRSG0K', b'FHKKQC963NGSY18ZDZ', b'FJ9KQCRJ3RGHNBWW4S', b'J6BKQC1PMNBAYSLM9U', b'IXXJQCLKOUAJ5RSQY4', b'U4ZJQC5VR0QBIE8DU',
b'S2EKQC9F4UR4R71IC3', b'1XBKQCX019BKJ0M9IH', b'Z62KQC706L0B0WTN3Q', b'O7EKQCEVZ7FBEWMNWE', b'F7BKQC4NXO9R7XOG2W', b'7U0KQC6PGZBNQATNOT', b'78AKQCI05U36T3E82O',
b'XY8KQCULFPN4SR915Q', b'WQDKQCEULSD5G9XNFI', b'2Z0KQCSWKVFG7RPFD8', b'26BKQC0SJIJOH02H2A', b'H1GKQCWOUJHFSHXABA', b'ZWGKQCRFZAPC5PYJZ1', b'EZ0KQCF3LSM9PRSG0K',
b'262KQCH2RQKN0CBRLF', b'P5ZJQCMKO7EYV4HFCL', b'KXBKQC52JO3AP4GMLF', b'9IFKQC60JTDBV57N6S', b'FHKKQC963NGSY18ZDZ', b'FJ9KQCRJ3RGHNBWW4S', b'S2EKQC9F4UR4R71IC3',
b'TQ0KQCZ8LA7X9DIEAN', b'BAXJQCORQA5Q46FCDG', b'VR0KQC7LVANO83AL35', b'75CKQC4T617U2E5T5Y', b'1XBKQCX019BKJ0M9IH', b'Z62KQC706L0B0WTN3Q', b'O7EKQCEVZ7FBEWMNWE',
b'LCTKQCZU3F94CEFSOM', b'WJYJQCPNJJI5JN07SD', b'3N6KQC6BE5EIXTRMDL', b'CM5KQCD57I15GKLAMB', b'XY8KQCULFPN4SR915Q', b'WQDKQCEULSD5G9XNFI', b'2Z0KQCSWKVFG7RPFD8',
b'cccbffffd3e69819cd8', b'BJKKQCVDA66528PDAU', b'QS0KQCLMIZFI8ZDLM3', b'UW0KQCRHBIYMA8LPZD', b'26BKQC0SJIJOH02H2A', b'262KQCH2RQKN0CBRLF', b'P5ZJQCMKO7EYV4HFCL',
b'GJ7KQC7APJSAMHEK5Q', b'711KQCDXOQWB3KDWEP', b'PY0KQC77AJ3457A6C2', b'WZ0KQCYVMEJHDR4MV2', b'KXBKQC52JO3AP4GMLF', b'9IFKQC60JTDBV57N6S', b'TQ0KQCZ8LA7X9DIEAN',
b'28EKQCQGM6NLLWFRG7', b'E33KQCRREJALRA715H', b'8HKKQCTEJAOBVH410L', b'IO6KQC70PMBQUDNB3L', b'BAXJQCORQA5Q46FCDG', b'VR0KQC7LVANO83AL35', b'75CKQC4T617U2E5T5Y',
b'1YBKQCWRBNB433NEMH', b'M01KQCF7KUWCDY67JD', b'CR0KQCOMV2QPPC90IF', b'85ZJQCMG38N7Q2WKIK', b'LCTKQCZU3F94CEFSOM', b'WJYJQCPNJJI5JN07SD', b'3N6KQC6BE5EIXTRMDL',
b'I9GKQCERACL8UZF2PY', b'BY0KQCOZUK47R2JZDE', b'7W0KQCYDMD4LTSY5JL', b'A0YJQC3HONEKD1JCPK', b'CM5KQCD57I15GKLAMB', b'cccbffffd3e69819cd8',
b'BJKKQCVDA66528PDAU', b'QS0KQCLMIZFI8ZDLM3', b'UW0KQCRHBIYMA8LPZD',
b'GJ7KQC7APJSAMHEK5Q', b'711KQCDXOQWB3KDWEP', b'PY0KQC77AJ3457A6C2',
b'WZ0KQCYVMEJHDR4MV2', b'28EKQCQGM6NLLWFRG7', b'E33KQCRREJALRA715H',
b'8HKKQCTEJAOBVH410L', b'IO6KQC70PMBQUDNB3L', b'1YBKQCWRBNB433NEMH',
b'M01KQCF7KUWCDY67JD', b'CR0KQCOMV2QPPC90IF', b'85ZJQCMG38N7Q2WKIK',
b'I9GKQCERACL8UZF2PY', b'BY0KQCOZUK47R2JZDE', b'7W0KQCYDMD4LTSY5JL',
b'A0YJQC3HONEKD1JCPK',
])) ]))
def test_Everyone(self): def test_everyone(self):
"""
Test Everyone rule.
"""
rule = Everyone([]) rule = Everyone([])
self.assertEqual(len(self.filter_with_rule(rule)), self.db.get_number_of_people()) self.assertEqual(len(self.filter_with_rule(rule)),
self.db.get_number_of_people())
def test_FamilyWithIncompleteEvent(self): def test_familywithincompleteevent(self):
"""
Test FamilyWithIncompleteEvent rule.
"""
rule = FamilyWithIncompleteEvent([]) rule = FamilyWithIncompleteEvent([])
# too many to list out to test explicitly # too many to list out to test explicitly
self.assertEqual(len(self.filter_with_rule(rule)), 775) self.assertEqual(len(self.filter_with_rule(rule)), 775)
def test_HasAlternateName(self): def test_hasalternatename(self):
"""
Test HasAlternateName rule.
"""
rule = HasAlternateName([]) rule = HasAlternateName([])
self.assertEqual(self.filter_with_rule(rule), set([ self.assertEqual(self.filter_with_rule(rule), set([
b'46WJQCIOLQ0KOX2XCC', b'GNUJQCL9MD64AM56OH', b'46WJQCIOLQ0KOX2XCC', b'GNUJQCL9MD64AM56OH',
])) ]))
def test_HasCommonAncestorWith_empty(self): def test_commonancestor_empty(self):
"""
Test empty HasCommonAncestorWith rule.
"""
rule = HasCommonAncestorWith(['']) rule = HasCommonAncestorWith([''])
self.assertEqual(self.filter_with_rule(rule), set([ self.assertEqual(self.filter_with_rule(rule), set([
])) ]))
def test_HasCommonAncestorWith_nonmatching(self): def test_commonancestor_nonmatching(self):
"""
Test non-matching HasCommonAncestorWith rule.
"""
rule = HasCommonAncestorWith(['I0000']) rule = HasCommonAncestorWith(['I0000'])
self.assertEqual(self.filter_with_rule(rule), set([ self.assertEqual(self.filter_with_rule(rule), set([
])) ]))
def test_HasCommonAncestorWith_irregular(self): def test_commonancestor_irregular(self):
"""
Test irregular HasCommonAncestorWith rule.
"""
rule = HasCommonAncestorWith(['ABCDEFG']) rule = HasCommonAncestorWith(['ABCDEFG'])
self.assertEqual(self.filter_with_rule(rule), set([ self.assertEqual(self.filter_with_rule(rule), set([
])) ]))
def test_HasCommonAncestorWith_matching(self): def test_commonancestor_matching(self):
"""
Test matching HasCommonAncestorWith rule.
"""
rule = HasCommonAncestorWith(['I0044']) rule = HasCommonAncestorWith(['I0044'])
self.assertEqual(self.filter_with_rule(rule), set([ self.assertEqual(self.filter_with_rule(rule), set([
b'GNUJQCL9MD64AM56OH', b'SOFKQCBYAO18OWC0CS', b'EMEKQC02EOUF8H0SHM', b'3EXJQCVWOSQFGLYB6H', b'GNUJQCL9MD64AM56OH', b'SOFKQCBYAO18OWC0CS', b'EMEKQC02EOUF8H0SHM',
b'EMTJQCQU6TL4WAVSE4', b'QUEKQCZL61S8BJJ388', b'MKEKQCSBQGAVHAPCQT', b'MUFKQCMXUJ07MCDUNI', b'3EXJQCVWOSQFGLYB6H', b'EMTJQCQU6TL4WAVSE4', b'QUEKQCZL61S8BJJ388',
b'DBXJQCJCEZMO17WZ89', b'ORFKQC4KLWEGTGR19L', b'MG5KQC6ZKSVO4A63G2', b'N26KQCF3ASHMZ0HEW6', b'MKEKQCSBQGAVHAPCQT', b'MUFKQCMXUJ07MCDUNI', b'DBXJQCJCEZMO17WZ89',
b'GNWJQC9NLVF2MZLHU9', b'ZFXJQCHAD8SLZZ7KRP', b'44WJQCLCQIPZUB0UH', b'B8TJQC53HJXOGXK8F7', b'ORFKQC4KLWEGTGR19L', b'MG5KQC6ZKSVO4A63G2', b'N26KQCF3ASHMZ0HEW6',
b'D3WJQCCGV58IP8PNHZ', b'3LEKQCRF3FD2E1H73I', b'F06KQCZY1I4H4IFZM', b'VMTJQC49IGKLG2EQ5', b'GNWJQC9NLVF2MZLHU9', b'ZFXJQCHAD8SLZZ7KRP', b'44WJQCLCQIPZUB0UH',
b'9BXKQC1PVLPYFMD6IX', b'H1DKQC4YGZ5A61FGS', b'1GWJQCGOOZ8FJW3YK9', b'S16KQCX8XUO3EEL85N', b'B8TJQC53HJXOGXK8F7', b'D3WJQCCGV58IP8PNHZ', b'3LEKQCRF3FD2E1H73I',
b'OREKQCF34YE89RL8S6', b'RU5KQCQTPC9SJ5Q1JN', b'GYFKQCPH8Q0JDN94GR', b'9QFKQC54ET79K2SD57', b'F06KQCZY1I4H4IFZM', b'VMTJQC49IGKLG2EQ5', b'9BXKQC1PVLPYFMD6IX',
b'MLEKQCH64557K610VR', b'AWFKQCJELLUWDY2PD3', b'ZDWJQC7TMS2AWAVF2Y', b'VJFKQCFO7WESWPNKHE', b'H1DKQC4YGZ5A61FGS', b'1GWJQCGOOZ8FJW3YK9', b'S16KQCX8XUO3EEL85N',
b'LV5KQCJCCR0S3DN5WW', b'CDTJQCVTVX7CNMY9YU', b'OX5KQCKE3I94MEPDC', b'JF5KQC2L6ABI0MVD3E', b'OREKQCF34YE89RL8S6', b'RU5KQCQTPC9SJ5Q1JN', b'GYFKQCPH8Q0JDN94GR',
b'CH5KQCIEXSN1J5UEHB', b'4JEKQC22K5UTH9QHCU', b'EPFKQCETTDTEL3PYIR', b'D16KQCIZS56HVPW6DA', b'9QFKQC54ET79K2SD57', b'MLEKQCH64557K610VR', b'AWFKQCJELLUWDY2PD3',
b'2TEKQCTSCRL4Z2AUHE', b'3WEKQCHXRH61E3CIKB', b'TDTJQCGYRS2RCCGQN3', b'SMWJQCXQ6I2GEXSPK9', b'ZDWJQC7TMS2AWAVF2Y', b'VJFKQCFO7WESWPNKHE', b'LV5KQCJCCR0S3DN5WW',
b'PXFKQCXEHJX3W1Q1IV', b'Q9TJQCXDL1599L2B2Z', b'BFXJQCF1JBOXPRW2OS', b'6TFKQCUTO94WB2NHN', b'CDTJQCVTVX7CNMY9YU', b'OX5KQCKE3I94MEPDC', b'JF5KQC2L6ABI0MVD3E',
b'FNEKQCO239QSNK0R78', b'3RFKQCNKMX9HVLNSLW', b'W2DKQCV4H3EZUJ35DX', b'5IEKQCN37EFBK9EBUD', b'CH5KQCIEXSN1J5UEHB', b'4JEKQC22K5UTH9QHCU', b'EPFKQCETTDTEL3PYIR',
b'LW5KQCXSXRC2XV3T3D', b'ZNEKQCULV911DIXBK3', b'35WJQC1B7T7NPV8OLV', b'MPEKQC6TIP3SP1YF7I', b'D16KQCIZS56HVPW6DA', b'2TEKQCTSCRL4Z2AUHE', b'3WEKQCHXRH61E3CIKB',
b'DMFKQC5MHGYC6503F2', b'3KEKQC45RL87D4ZG86', b'KLTJQC70XVZJSPQ43U', b'LVEKQCP09W7JNFDAFC', b'TDTJQCGYRS2RCCGQN3', b'SMWJQCXQ6I2GEXSPK9', b'PXFKQCXEHJX3W1Q1IV',
b'DPUJQCUYKKDPT78JJV', b'JDXJQCR5L0NTR21SQA', b'UAXJQC6HC354V7Q6JA', b'XBXJQCS4QY316ZGHRN', b'Q9TJQCXDL1599L2B2Z', b'BFXJQCF1JBOXPRW2OS', b'6TFKQCUTO94WB2NHN',
b'HCXJQCRKB4K65V1C07', b'66TJQC6CC7ZWL9YZ64', b'XNFKQC6DN59LACS9IU', b'LL5KQCG687Y165GL5P', b'FNEKQCO239QSNK0R78', b'3RFKQCNKMX9HVLNSLW', b'W2DKQCV4H3EZUJ35DX',
b'7X5KQC9ABK4T6AW7QF', b'HKTJQCIJD8RK9RJFO1', b'1LTJQCYQI1DXBLG6Z', b'0FWJQCLYEP736P3YZK', b'5IEKQCN37EFBK9EBUD', b'LW5KQCXSXRC2XV3T3D', b'ZNEKQCULV911DIXBK3',
b'0DXJQC1T8P3CQKZIUO', b'ISEKQC97YI74A9VKWC', b'KGXJQCBQ39ON9VB37T', b'BZ5KQCD4KFI3BTIMZU', b'35WJQC1B7T7NPV8OLV', b'MPEKQC6TIP3SP1YF7I', b'DMFKQC5MHGYC6503F2',
b'0HEKQCLINMQS4RB7B8', b'BBTJQCNT6N1H4X6TL4', b'COFKQCUXC2H4G3QBYT', b'DI5KQC3CLKWQI3I0CC', b'3KEKQC45RL87D4ZG86', b'KLTJQC70XVZJSPQ43U', b'LVEKQCP09W7JNFDAFC',
b'T8TJQCWWI8RY57YNTQ', b'46WJQCIOLQ0KOX2XCC', b'OEXJQCQJHF2BLSAAIS', b'GNFKQCH8AFJRJO9V4Y', b'DPUJQCUYKKDPT78JJV', b'JDXJQCR5L0NTR21SQA', b'UAXJQC6HC354V7Q6JA',
b'8LFKQCQWXTJQJR4CXV', b'IGWJQCSVT8NXTFXOFJ', b'3PEKQC8ZDCYTSSIKZ9', b'5UEKQC8N8NEPSWU1QQ', b'XBXJQCS4QY316ZGHRN', b'HCXJQCRKB4K65V1C07', b'66TJQC6CC7ZWL9YZ64',
b'NK5KQC1MAOU2BP35ZV', b'UZFKQCIHVT44DC9KGH', b'JJ5KQC83DT7VDMUYRQ', b'626KQC7C08H3UTM38E', b'XNFKQC6DN59LACS9IU', b'LL5KQCG687Y165GL5P', b'7X5KQC9ABK4T6AW7QF',
b'XIFKQCLQOY645QTGP7', b'HEWJQCWQQ3K4BNRLIO', b'HDWJQCT361VOV2PQLP', b'XFKKQCGA4DVECEB48E', b'HKTJQCIJD8RK9RJFO1', b'1LTJQCYQI1DXBLG6Z', b'0FWJQCLYEP736P3YZK',
b'0DXJQC1T8P3CQKZIUO', b'ISEKQC97YI74A9VKWC', b'KGXJQCBQ39ON9VB37T',
b'BZ5KQCD4KFI3BTIMZU', b'0HEKQCLINMQS4RB7B8', b'BBTJQCNT6N1H4X6TL4',
b'COFKQCUXC2H4G3QBYT', b'DI5KQC3CLKWQI3I0CC', b'T8TJQCWWI8RY57YNTQ',
b'46WJQCIOLQ0KOX2XCC', b'OEXJQCQJHF2BLSAAIS', b'GNFKQCH8AFJRJO9V4Y',
b'8LFKQCQWXTJQJR4CXV', b'IGWJQCSVT8NXTFXOFJ', b'3PEKQC8ZDCYTSSIKZ9',
b'5UEKQC8N8NEPSWU1QQ', b'NK5KQC1MAOU2BP35ZV', b'UZFKQCIHVT44DC9KGH',
b'JJ5KQC83DT7VDMUYRQ', b'626KQC7C08H3UTM38E', b'XIFKQCLQOY645QTGP7',
b'HEWJQCWQQ3K4BNRLIO', b'HDWJQCT361VOV2PQLP', b'XFKKQCGA4DVECEB48E',
b'KWEKQCTNIIV9BROFFG', b'KWEKQCTNIIV9BROFFG',
])) ]))
def test_HasNickname(self): def test_hasnickname(self):
"""
Test HasNickname rule.
"""
rule = HasNickname([]) rule = HasNickname([])
self.assertEqual(self.filter_with_rule(rule), set([ self.assertEqual(self.filter_with_rule(rule), set([
b'cc8205d883763f02abd', b'GNUJQCL9MD64AM56OH', b'Q8HKQC3VMRM1M6M7ES', b'cc8205d883763f02abd', b'GNUJQCL9MD64AM56OH',
b'Q8HKQC3VMRM1M6M7ES',
])) ]))
def test_HasUnknownGender(self): def test_hasunknowngender(self):
"""
Test HasUnknownGender rule.
"""
rule = HasUnknownGender([]) rule = HasUnknownGender([])
self.assertEqual(self.filter_with_rule(rule), set([ self.assertEqual(self.filter_with_rule(rule), set([
b'OJOKQC83Y1EDBIMLJ6', b'8BHKQCFK9UZFRJYC2Y', b'PGFKQC1TUQMXFAMLMB', b'IHOKQCECRZYQDKW6KF', b'OJOKQC83Y1EDBIMLJ6', b'8BHKQCFK9UZFRJYC2Y', b'PGFKQC1TUQMXFAMLMB',
b'8HKKQCTEJAOBVH410L', b'AGFKQCO358R18LNJYV', b'1ENKQCBPFZTAQJSP4O', b'NUWKQCO7TVAOH0CHLV', b'IHOKQCECRZYQDKW6KF', b'8HKKQCTEJAOBVH410L', b'AGFKQCO358R18LNJYV',
b'P5IKQC88STY3FNTFZ3', b'7GXKQCMVFU8WR1LKZL', b'LGXKQCJ5OP6MKF9QLN', b'XNFKQC6DN59LACS9IU', b'1ENKQCBPFZTAQJSP4O', b'NUWKQCO7TVAOH0CHLV', b'P5IKQC88STY3FNTFZ3',
b'7IOKQC1NVGUI1E55CQ', b'57PKQCFAWY7AM3JS4M', b'BNXKQCEBXC1RCOGJNF', b'TFFKQC1RMG8RRADKDH', b'7GXKQCMVFU8WR1LKZL', b'LGXKQCJ5OP6MKF9QLN', b'XNFKQC6DN59LACS9IU',
b'FHKKQC963NGSY18ZDZ', b'WMXKQCDUJ4JKQQYCR7', b'PBHKQCHOAGTECRKT9L', b'OFXKQC8W0N3N6JP6YQ', b'7IOKQC1NVGUI1E55CQ', b'57PKQCFAWY7AM3JS4M', b'BNXKQCEBXC1RCOGJNF',
b'TFFKQC1RMG8RRADKDH', b'FHKKQC963NGSY18ZDZ', b'WMXKQCDUJ4JKQQYCR7',
b'PBHKQCHOAGTECRKT9L', b'OFXKQC8W0N3N6JP6YQ',
])) ]))
def test_HasSourceOf_empty(self): def test_hassourceof_empty(self):
# this rule run with an empty string finds people with no source citations """
Test empty HasSourceOf rule.
"""
# when run with an empty string finds people with no sourc citations
rule = HasSourceOf(['']) rule = HasSourceOf([''])
self.assertEqual(self.filter_with_rule(rule), set([ self.assertEqual(self.filter_with_rule(rule), set([
b'cc82060512042f67e2c', b'cc8205d87831c772e87', b'cc82060516c6c141500', b'cc8205d87fd529000ff', b'cc82060512042f67e2c', b'cc8205d87831c772e87',
b'cc82060504445ab6deb', b'cc8205d887376aacba2', b'cccbffffd3e69819cd8', b'cc8205d87c20350420b', b'cc82060516c6c141500', b'cc8205d87fd529000ff',
b'cc8206050e541f79f92', b'cc8205d883763f02abd', b'cc8206050980ea622d0', b'cc8205d872f532ab14e', b'cc82060504445ab6deb', b'cc8205d887376aacba2',
b'cccbffffd3e69819cd8', b'cc8205d87c20350420b',
b'cc8206050e541f79f92', b'cc8205d883763f02abd',
b'cc8206050980ea622d0', b'cc8205d872f532ab14e',
])) ]))
def test_HasSourceOf_nonmatching(self): def test_hassourceof_nonmatching(self):
"""
Test non-matching HasSourceOf rule.
"""
rule = HasSourceOf(['S0004']) rule = HasSourceOf(['S0004'])
self.assertEqual(self.filter_with_rule(rule), set([ self.assertEqual(self.filter_with_rule(rule), set([
])) ]))
def test_HasSourceOf_irregular(self): def test_hassourceof_irregular(self):
"""
Test irregular HasSourceOf rule.
"""
rule = HasSourceOf(['ABCDEFG']) rule = HasSourceOf(['ABCDEFG'])
self.assertEqual(self.filter_with_rule(rule), set([ self.assertEqual(self.filter_with_rule(rule), set([
])) ]))
def test_HasSourceOf_matching(self): def test_hassourceof_matching(self):
"""
Test matching HasSourceOf rule.
"""
rule = HasSourceOf(['S0000']) rule = HasSourceOf(['S0000'])
self.assertEqual(self.filter_with_rule(rule), set([ self.assertEqual(self.filter_with_rule(rule), set([
b'GNUJQCL9MD64AM56OH', b'GNUJQCL9MD64AM56OH',
])) ]))
def test_HaveAltFamilies(self): def test_havealtfamilies(self):
"""
Test HaveAltFamilies rule.
"""
rule = HaveAltFamilies([]) rule = HaveAltFamilies([])
self.assertEqual(self.filter_with_rule(rule), set([ self.assertEqual(self.filter_with_rule(rule), set([
b'CH5KQCIEXSN1J5UEHB', b'MG5KQC6ZKSVO4A63G2', b'CH5KQCIEXSN1J5UEHB', b'MG5KQC6ZKSVO4A63G2',
])) ]))
def test_HaveChildren(self): def test_havechildren(self):
"""
Test HaveChildren rule.
"""
rule = HaveChildren([]) rule = HaveChildren([])
# too many to list out to test explicitly # too many to list out to test explicitly
self.assertEqual(len(self.filter_with_rule(rule)), 895) self.assertEqual(len(self.filter_with_rule(rule)), 895)
def test_IncompleteNames(self): def test_incompletenames(self):
"""
Test IncompleteNames rule.
"""
rule = IncompleteNames([]) rule = IncompleteNames([])
self.assertEqual(self.filter_with_rule(rule), set([ self.assertEqual(self.filter_with_rule(rule), set([
b'IHOKQCECRZYQDKW6KF', b'cc82060504445ab6deb', b'LCXKQCQZH5EH56NTCD', b'cc8205d87831c772e87', b'IHOKQCECRZYQDKW6KF', b'cc82060504445ab6deb',
b'3RFKQCNKMX9HVLNSLW', b'cc8205d87fd529000ff', b'B1UKQCBR49WB3134PN', b'0TTKQCXXY59OCDPLV3', b'LCXKQCQZH5EH56NTCD', b'cc8205d87831c772e87',
b'F3UKQC7ZV3EYVWTZ8O', b'1MXKQCJ2BR43910ZYX', b'cc8206050e541f79f92', b'FHKKQC963NGSY18ZDZ', b'3RFKQCNKMX9HVLNSLW', b'cc8205d87fd529000ff',
b'R5HKQCIEPOY1DMQOWX', b'ZHMKQC50PFVAPI8PZ6', b'T4UKQCYGECXGVNBWMY', b'cc82060516c6c141500', b'B1UKQCBR49WB3134PN', b'0TTKQCXXY59OCDPLV3',
b'UPWKQCYVFH7RZOSZ29', b'2AMKQCE67YOH3TBVYI', b'2CUKQCFDVN3EZE2E4C', b'7IOKQC1NVGUI1E55CQ', b'F3UKQC7ZV3EYVWTZ8O', b'1MXKQCJ2BR43910ZYX',
b'KSTKQC018GNA7HDCAS', b'WIVKQC4Q4FCQJT5M63', b'A4YKQCRYSI5FT5T38', b'BUNKQCO4HZHZP70F3K', b'cc8206050e541f79f92', b'FHKKQC963NGSY18ZDZ',
b'YRTKQCNDP343OD5OQJ', b'7VEKQCV05EDK0625KI', b'cc8205d872f532ab14e', b'TPXKQCEGL04KHGMO2X', b'R5HKQCIEPOY1DMQOWX', b'ZHMKQC50PFVAPI8PZ6', b'T4UKQCYGECXGVNBWMY',
b'L9LKQCQ8KJRKHM4D2E', b'8QXKQCHJ2EUC7OV8EQ', b'W0XKQCKSFWWJWQ2OSN', b'I6QKQCFRDTV2LDC8M2', b'cc82060516c6c141500', b'UPWKQCYVFH7RZOSZ29',
b'XTUKQC7WCIVA5F0NC4', b'F4UKQCPK572VWU2YZQ', b'JKDKQCF4ND92A088J2', b'COFKQCUXC2H4G3QBYT', b'2AMKQCE67YOH3TBVYI', b'2CUKQCFDVN3EZE2E4C', b'7IOKQC1NVGUI1E55CQ',
b'BNXKQCEBXC1RCOGJNF', b'Q42KQCKJZGS4IZWHF5', b'P5IKQC88STY3FNTFZ3', b'7CXKQC59NSZFXIG1UE', b'KSTKQC018GNA7HDCAS', b'WIVKQC4Q4FCQJT5M63', b'A4YKQCRYSI5FT5T38',
b'cc8205d87c20350420b', b'FQUKQCWEHOAWUP4QWS', b'3YTKQCK2W63W0MQBJE', b'8HKKQCTEJAOBVH410L', b'BUNKQCO4HZHZP70F3K', b'YRTKQCNDP343OD5OQJ', b'7VEKQCV05EDK0625KI',
b'HLQKQC0BJIZL0V4EK4', b'B0UKQC9A54F1GUB7NR', b'EPXKQCQRZP2PNPN7BE', b'cc82060512042f67e2c', b'cc8205d872f532ab14e', b'TPXKQCEGL04KHGMO2X',
b'XZLKQCRQA9EHPBNZPT', b'OQXKQC2Y5FVH9PK0JL', b'AXLKQC0YTFAWQ234YD', b'OFXKQC8W0N3N6JP6YQ', b'L9LKQCQ8KJRKHM4D2E', b'8QXKQCHJ2EUC7OV8EQ', b'W0XKQCKSFWWJWQ2OSN',
b'MWUKQCD2ZSCECQOCLG', b'1ENKQCBPFZTAQJSP4O', b'N7XKQCYD3VSCSZREGJ', b'2LQKQC62GJUQCJIOK8', b'I6QKQCFRDTV2LDC8M2', b'XTUKQC7WCIVA5F0NC4', b'F4UKQCPK572VWU2YZQ',
b'QXXKQC9PT5FWNT140K', b'VAXKQC19HIFPX61J28', b'0PXKQCJ9S1M3NNASET', b'K8XKQCDSVLSK422A3K', b'JKDKQCF4ND92A088J2', b'COFKQCUXC2H4G3QBYT', b'BNXKQCEBXC1RCOGJNF',
b'52UKQCFYXMFTKIGNBS', b'7GXKQCMVFU8WR1LKZL', b'4UMKQCF07KL2K92CI5', b'LGXKQCJ5OP6MKF9QLN', b'Q42KQCKJZGS4IZWHF5', b'P5IKQC88STY3FNTFZ3', b'7CXKQC59NSZFXIG1UE',
b'FZTKQCSTPIQ3C9JC46', b'WMXKQCDUJ4JKQQYCR7', b'R6UKQC939L9FV62UGE', b'OIUKQCBHUWDGL7DNTI', b'cc8205d87c20350420b', b'FQUKQCWEHOAWUP4QWS',
b'FRTKQC3G6JBJAR2ZPX', b'PIEKQCKUL6OAMS8Q9R', b'cc8205d887376aacba2', b'LGMKQCQP5M5L18FVTN', b'3YTKQCK2W63W0MQBJE', b'8HKKQCTEJAOBVH410L', b'HLQKQC0BJIZL0V4EK4',
b'8HUKQCRV8B3J2LLQ3B', b'LOUKQC45HUN532HOOM', b'cc8205d883763f02abd', b'TBXKQC7OHIN28PVCS3', b'B0UKQC9A54F1GUB7NR', b'EPXKQCQRZP2PNPN7BE',
b'cc82060512042f67e2c', b'XZLKQCRQA9EHPBNZPT',
b'OQXKQC2Y5FVH9PK0JL', b'AXLKQC0YTFAWQ234YD', b'OFXKQC8W0N3N6JP6YQ',
b'MWUKQCD2ZSCECQOCLG', b'1ENKQCBPFZTAQJSP4O', b'N7XKQCYD3VSCSZREGJ',
b'2LQKQC62GJUQCJIOK8', b'QXXKQC9PT5FWNT140K', b'VAXKQC19HIFPX61J28',
b'0PXKQCJ9S1M3NNASET', b'K8XKQCDSVLSK422A3K', b'52UKQCFYXMFTKIGNBS',
b'7GXKQCMVFU8WR1LKZL', b'4UMKQCF07KL2K92CI5', b'LGXKQCJ5OP6MKF9QLN',
b'FZTKQCSTPIQ3C9JC46', b'WMXKQCDUJ4JKQQYCR7', b'R6UKQC939L9FV62UGE',
b'OIUKQCBHUWDGL7DNTI', b'FRTKQC3G6JBJAR2ZPX', b'PIEKQCKUL6OAMS8Q9R',
b'cc8205d887376aacba2', b'LGMKQCQP5M5L18FVTN',
b'8HUKQCRV8B3J2LLQ3B', b'LOUKQC45HUN532HOOM',
b'cc8205d883763f02abd', b'TBXKQC7OHIN28PVCS3',
])) ]))
def test_IsBookmarked(self): def test_isbookmarked(self):
"""
Test IsBookmarked rule.
"""
rule = IsBookmarked([]) rule = IsBookmarked([])
self.assertEqual(self.filter_with_rule(rule), set([ self.assertEqual(self.filter_with_rule(rule), set([
b'35WJQC1B7T7NPV8OLV', b'AWFKQCJELLUWDY2PD3', b'Q8HKQC3VMRM1M6M7ES', b'35WJQC1B7T7NPV8OLV', b'AWFKQCJELLUWDY2PD3', b'Q8HKQC3VMRM1M6M7ES',
])) ]))
def test_IsDuplicatedAncestorOf_empty(self): def test_dupancestor_empty(self):
"""
Test empty IsDuplicatedAncestorOf rule.
"""
rule = IsDuplicatedAncestorOf(['']) rule = IsDuplicatedAncestorOf([''])
self.assertEqual(self.filter_with_rule(rule), set([ self.assertEqual(self.filter_with_rule(rule), set([
])) ]))
def test_IsDuplicatedAncestorOf_nonmatching(self): def test_dupancestor_nonmatching(self):
"""
Test non-matching IsDuplicatedAncestorOf rule.
"""
rule = IsDuplicatedAncestorOf(['I0000']) rule = IsDuplicatedAncestorOf(['I0000'])
self.assertEqual(self.filter_with_rule(rule), set([ self.assertEqual(self.filter_with_rule(rule), set([
])) ]))
def test_IsDuplicatedAncestorOf_irregular(self): def test_dupancestor_irregular(self):
"""
Test irregular IsDuplicatedAncestorOf rule.
"""
rule = IsDuplicatedAncestorOf(['ABCDEFG']) rule = IsDuplicatedAncestorOf(['ABCDEFG'])
self.assertEqual(self.filter_with_rule(rule), set([ self.assertEqual(self.filter_with_rule(rule), set([
])) ]))
def test_IsDuplicatedAncestorOf_matching(self): def test_dupancestor_matching(self):
"""
Test matching IsDuplicatedAncestorOf rule.
"""
rule = IsDuplicatedAncestorOf(['I1631']) rule = IsDuplicatedAncestorOf(['I1631'])
self.assertEqual(self.filter_with_rule(rule), set([ self.assertEqual(self.filter_with_rule(rule), set([
b'I3VJQCUY5I6UR92507', b'D4VJQC09STQCWD393E', b'I3VJQCUY5I6UR92507', b'D4VJQC09STQCWD393E',
])) ]))
def test_IsRelatedWith_empty(self): def test_isrelatedwith_empty(self):
"""
Test empty IsRelatedWith rule.
"""
rule = IsRelatedWith(['']) rule = IsRelatedWith([''])
self.assertEqual(self.filter_with_rule(rule), set([ self.assertEqual(self.filter_with_rule(rule), set([
])) ]))
def test_IsRelatedWith_nonmatching(self): def test_isrelatedwith_nonmatching(self):
"""
Test non-matching IsRelatedWith rule.
"""
rule = IsRelatedWith(['I0000']) rule = IsRelatedWith(['I0000'])
self.assertEqual(self.filter_with_rule(rule), set([ self.assertEqual(self.filter_with_rule(rule), set([
])) ]))
def test_IsRelatedWith_irregular(self): def test_isrelatedwith_irregular(self):
"""
Test irregular IsRelatedWith rule.
"""
rule = IsRelatedWith(['ABCDEFG']) rule = IsRelatedWith(['ABCDEFG'])
self.assertEqual(self.filter_with_rule(rule), set([ self.assertEqual(self.filter_with_rule(rule), set([
])) ]))
def test_IsRelatedWith_matching(self): def test_isrelatedwith_matching(self):
"""
Test matching IsRelatedWith rule.
"""
rule = IsRelatedWith(['I1844']) rule = IsRelatedWith(['I1844'])
self.assertEqual(self.filter_with_rule(rule), set([ self.assertEqual(self.filter_with_rule(rule), set([
b'HWTKQCSM28EI6WFDHP', b'T4UKQCYGECXGVNBWMY', b'YOTKQCEX2PLG03LZQS', b'X8UKQCIDY21QIQBDVI', b'HWTKQCSM28EI6WFDHP', b'T4UKQCYGECXGVNBWMY', b'YOTKQCEX2PLG03LZQS',
b'F3UKQC7ZV3EYVWTZ8O', b'0TTKQCXXY59OCDPLV3', b'EVTKQCHV2E2PODFD7C', b'BBUKQC5GPRPDJHJAWU', b'X8UKQCIDY21QIQBDVI', b'F3UKQC7ZV3EYVWTZ8O', b'0TTKQCXXY59OCDPLV3',
b'FRTKQC3G6JBJAR2ZPX', b'NDTKQCN95VFLGJ21L', b'SFTKQC26EJ2BYQCRIA', b'MYTKQCVCFOFM32H9GB', b'EVTKQCHV2E2PODFD7C', b'BBUKQC5GPRPDJHJAWU', b'FRTKQC3G6JBJAR2ZPX',
b'B0UKQC9A54F1GUB7NR', b'PTTKQCYN0JR3ZZJNWR', b'F4UKQCPK572VWU2YZQ', b'LLTKQCX39KCXFSX0U4', b'NDTKQCN95VFLGJ21L', b'SFTKQC26EJ2BYQCRIA', b'MYTKQCVCFOFM32H9GB',
b'IXTKQC1BAU1F1WNXKB', b'3YTKQCK2W63W0MQBJE', b'TQTKQCO897BNA1H93B', b'DOTKQCP1MG3VC8D7V2', b'B0UKQC9A54F1GUB7NR', b'PTTKQCYN0JR3ZZJNWR', b'F4UKQCPK572VWU2YZQ',
b'3NTKQCZKLMIM6HYFE1', b'WUTKQCVQCUPFFOGUT8', b'GETKQCPRC2W5YDUYM6', b'YRTKQCNDP343OD5OQJ', b'LLTKQCX39KCXFSX0U4', b'IXTKQC1BAU1F1WNXKB', b'3YTKQCK2W63W0MQBJE',
b'U0UKQCBZS0R6WW7LBS', b'J2UKQC897I42M9VHDD', b'7MTKQC1QNE4H5RF35S', b'5FTKQCKT9SDZ8TB03C', b'TQTKQCO897BNA1H93B', b'DOTKQCP1MG3VC8D7V2', b'3NTKQCZKLMIM6HYFE1',
b'O1UKQCJD5YHDRW887V', b'EUTKQCFATXRU431YY6', b'UHTKQCORH3NTZ0FYL3', b'2CUKQCFDVN3EZE2E4C', b'WUTKQCVQCUPFFOGUT8', b'GETKQCPRC2W5YDUYM6', b'YRTKQCNDP343OD5OQJ',
b'RNTKQCMLGRRKQVKDPR', b'CGTKQC4WO8W3WSQRCX', b'WAUKQCOQ91QCJZWQ9U', b'FZTKQCSTPIQ3C9JC46', b'U0UKQCBZS0R6WW7LBS', b'J2UKQC897I42M9VHDD', b'7MTKQC1QNE4H5RF35S',
b'AHTKQCM2YFRW3AGSRL', b'WBTKQCC775IAAGIWZD', b'8KTKQC407A8CN5O68H', b'8QTKQCN8ZKY5OWWJZF', b'5FTKQCKT9SDZ8TB03C', b'O1UKQCJD5YHDRW887V', b'EUTKQCFATXRU431YY6',
b'UKTKQCSL3AUJIWTD2A', b'HAUKQCM3GYGVTREGZS', b'52UKQCFYXMFTKIGNBS', b'U3UKQCO30PWAK6JQBA', b'UHTKQCORH3NTZ0FYL3', b'2CUKQCFDVN3EZE2E4C', b'RNTKQCMLGRRKQVKDPR',
b'R6UKQC939L9FV62UGE', b'TZTKQCR39A060AQ63C', b'X9UKQCFELSDAQ2TDP1', b'B1UKQCBR49WB3134PN', b'CGTKQC4WO8W3WSQRCX', b'WAUKQCOQ91QCJZWQ9U', b'FZTKQCSTPIQ3C9JC46',
b'KSTKQC018GNA7HDCAS', b'FJTKQCJCMAHJOA9NHI', b'HITKQCWJSCZX2AN6NP', b'WVTKQCZC91I63LHEE7', b'AHTKQCM2YFRW3AGSRL', b'WBTKQCC775IAAGIWZD', b'8KTKQC407A8CN5O68H',
b'0DTKQC6KBOS69LQJ35', b'8QTKQCN8ZKY5OWWJZF', b'UKTKQCSL3AUJIWTD2A', b'HAUKQCM3GYGVTREGZS',
b'52UKQCFYXMFTKIGNBS', b'U3UKQCO30PWAK6JQBA', b'R6UKQC939L9FV62UGE',
b'TZTKQCR39A060AQ63C', b'X9UKQCFELSDAQ2TDP1', b'B1UKQCBR49WB3134PN',
b'KSTKQC018GNA7HDCAS', b'FJTKQCJCMAHJOA9NHI', b'HITKQCWJSCZX2AN6NP',
b'WVTKQCZC91I63LHEE7', b'0DTKQC6KBOS69LQJ35',
])) ]))
def test_HasIdOf_empty(self): def test_hasidof_empty(self):
"""
Test empty HasIdOf rule.
"""
rule = HasIdOf(['']) rule = HasIdOf([''])
self.assertEqual(self.filter_with_rule(rule), set([ self.assertEqual(self.filter_with_rule(rule), set([
])) ]))
def test_HasIdOf_nonmatching(self): def test_hasidof_nonmatching(self):
"""
Test non-matching HasIdOf rule.
"""
rule = HasIdOf(['I0000']) rule = HasIdOf(['I0000'])
self.assertEqual(self.filter_with_rule(rule), set([ self.assertEqual(self.filter_with_rule(rule), set([
])) ]))
def test_HasIdOf_irregular(self): def test_hasidof_irregular(self):
"""
Test irregular HasIdOf rule.
"""
rule = HasIdOf(['ABCDEFG']) rule = HasIdOf(['ABCDEFG'])
self.assertEqual(self.filter_with_rule(rule), set([ self.assertEqual(self.filter_with_rule(rule), set([
])) ]))
def test_HasIdOf_matching(self): def test_hasidof_matching(self):
"""
Test matching HasIdOf rule.
"""
rule = HasIdOf(['I0044']) rule = HasIdOf(['I0044'])
self.assertEqual(self.filter_with_rule(rule), set([ self.assertEqual(self.filter_with_rule(rule), set([
b'GNUJQCL9MD64AM56OH', b'GNUJQCL9MD64AM56OH',
])) ]))
def test_IsDefaultPerson(self): def test_isdefaultperson(self):
"""
Test IsDefaultPerson rule.
"""
rule = IsDefaultPerson([]) rule = IsDefaultPerson([])
self.assertEqual(self.filter_with_rule(rule), set([ self.assertEqual(self.filter_with_rule(rule), set([
b'GNUJQCL9MD64AM56OH', b'GNUJQCL9MD64AM56OH',
])) ]))
def test_IsFemale(self): def test_isfemale(self):
"""
Test IsFemale rule.
"""
rule = IsFemale([]) rule = IsFemale([])
# too many to list out to test explicitly # too many to list out to test explicitly
self.assertEqual(len(self.filter_with_rule(rule)), 928) self.assertEqual(len(self.filter_with_rule(rule)), 928)
def test_IsMale(self): def test_ismale(self):
"""
Test IsMale rule.
"""
rule = IsMale([]) rule = IsMale([])
# too many to list out to test explicitly # too many to list out to test explicitly
self.assertEqual(len(self.filter_with_rule(rule)), 1154) self.assertEqual(len(self.filter_with_rule(rule)), 1154)
def test_MissingParent(self): def test_missingparent(self):
"""
Test MissingParent rule.
"""
rule = MissingParent([]) rule = MissingParent([])
# too many to list out to test explicitly # too many to list out to test explicitly
self.assertEqual(len(self.filter_with_rule(rule)), 849) self.assertEqual(len(self.filter_with_rule(rule)), 849)
def test_MultipleMarriages(self): def test_multiplemarriages(self):
"""
Test MultipleMarriages rule.
"""
rule = MultipleMarriages([]) rule = MultipleMarriages([])
self.assertEqual(self.filter_with_rule(rule), set([ self.assertEqual(self.filter_with_rule(rule), set([
b'R1VKQCJWNP24VN7BO', b'ZTVJQCTSMI85EGMXFM', b'ENTJQCZXQV1IRKJXUL', b'44WJQCLCQIPZUB0UH', b'R1VKQCJWNP24VN7BO', b'ZTVJQCTSMI85EGMXFM', b'ENTJQCZXQV1IRKJXUL',
b'SMWJQCXQ6I2GEXSPK9', b'DN3KQC1URTED410L3R', b'5FYJQC86G8EZ0L4E4B', b'5F4KQCJRU8ZKL6SILT', b'44WJQCLCQIPZUB0UH', b'SMWJQCXQ6I2GEXSPK9', b'DN3KQC1URTED410L3R',
b'0YNKQC5U4EQGVNUZD8', b'YRYJQCE3RF4U8A59UB', b'APWKQCI6YXAXBLC33I', b'XSKKQC6GGKLAYANWAF', b'5FYJQC86G8EZ0L4E4B', b'5F4KQCJRU8ZKL6SILT', b'0YNKQC5U4EQGVNUZD8',
b'0FQKQCOQD0VRVJPTSD', b'B3UJQCZHDXII99AWW4', b'cc8205d872f532ab14e', b'SS1KQCWWF9488Q330U', b'YRYJQCE3RF4U8A59UB', b'APWKQCI6YXAXBLC33I', b'XSKKQC6GGKLAYANWAF',
b'OCYJQCS8YT7JO8KIMO', b'I6HKQCQF72V2N56JQ5', b'6YWJQC86FBVN0J6JS', b'KYNKQCVA6FE65ONFIQ', b'0FQKQCOQD0VRVJPTSD', b'B3UJQCZHDXII99AWW4',
b'SHAKQCNY5IXO30GUAB', b'O5XKQC3V6BPJI13J24', b'ZN7KQC3RLB82EXF1QF', b'CIYJQCF3UK12DL0S2Y', b'cc8205d872f532ab14e', b'SS1KQCWWF9488Q330U',
b'H3XJQCFJ4FP4U2WGZC', b'cc82060504445ab6deb', b'4E4KQC1K4XUEX29IJO', b'0XVJQCJUNJY40WDSMA', b'OCYJQCS8YT7JO8KIMO', b'I6HKQCQF72V2N56JQ5', b'6YWJQC86FBVN0J6JS',
b'1WUJQCHNH76G6YD3A', b'IH3KQCM1VZPRKLBLK7', b'242KQCBALBOD8ZK5VI', b'8G4KQCS6C1AOM6ZGR3', b'KYNKQCVA6FE65ONFIQ', b'SHAKQCNY5IXO30GUAB', b'O5XKQC3V6BPJI13J24',
b'I1EKQCGGDSUD8ILUW4', b'X8BKQCSFF4AET5MY23', b'RJWJQCN1XKXRN5KMCP', b'ZWNKQC9DAZ3C6UHUAV', b'ZN7KQC3RLB82EXF1QF', b'CIYJQCF3UK12DL0S2Y', b'H3XJQCFJ4FP4U2WGZC',
b'9QUJQCCSWRZNSAPCR', b'HI0KQCG9TGT5AAIPU', b'DI4KQC3S1AO27VWOLN', b'QBDKQCH2IU6N8IXMFE', b'cc82060504445ab6deb', b'4E4KQC1K4XUEX29IJO',
b'DK2KQCJYW14VXUJ85', b'117KQCBB32RMTTV4G6', b'0QLKQCFTQMNVGCV4GM', b'D2OKQCGDNPT3BH4WH', b'0XVJQCJUNJY40WDSMA', b'1WUJQCHNH76G6YD3A', b'IH3KQCM1VZPRKLBLK7',
b'CAYJQCKOL49OF7XWB3', b'ZQGKQCGHS67Q4IMHEG', b'OEXJQCQJHF2BLSAAIS', b'UKYJQC70LIZQ11BP89', b'242KQCBALBOD8ZK5VI', b'8G4KQCS6C1AOM6ZGR3', b'I1EKQCGGDSUD8ILUW4',
b'X8BKQCSFF4AET5MY23', b'RJWJQCN1XKXRN5KMCP', b'ZWNKQC9DAZ3C6UHUAV',
b'9QUJQCCSWRZNSAPCR', b'HI0KQCG9TGT5AAIPU', b'DI4KQC3S1AO27VWOLN',
b'QBDKQCH2IU6N8IXMFE', b'DK2KQCJYW14VXUJ85', b'117KQCBB32RMTTV4G6',
b'0QLKQCFTQMNVGCV4GM', b'D2OKQCGDNPT3BH4WH', b'CAYJQCKOL49OF7XWB3',
b'ZQGKQCGHS67Q4IMHEG', b'OEXJQCQJHF2BLSAAIS', b'UKYJQC70LIZQ11BP89',
b'FF2KQCRBSPCG1QY97', b'L6EKQCO8QYL2UO2MQO', b'FF2KQCRBSPCG1QY97', b'L6EKQCO8QYL2UO2MQO',
])) ]))
def test_NeverMarried(self): def test_nevermarried(self):
"""
Test NeverMarried rule.
"""
rule = NeverMarried([]) rule = NeverMarried([])
# too many to list out to test explicitly # too many to list out to test explicitly
self.assertEqual(len(self.filter_with_rule(rule)), 749) self.assertEqual(len(self.filter_with_rule(rule)), 749)
def test_NoBirthdate(self): def test_nobirthdate(self):
"""
Test NoBirthdate rule.
"""
rule = NoBirthdate([]) rule = NoBirthdate([])
# too many to list out to test explicitly # too many to list out to test explicitly
self.assertEqual(len(self.filter_with_rule(rule)), 966) self.assertEqual(len(self.filter_with_rule(rule)), 966)
def test_NoDeathdate(self): def test_nodeathdate(self):
"""
Test NoDeathdate rule.
"""
rule = NoDeathdate([]) rule = NoDeathdate([])
# too many to list out to test explicitly # too many to list out to test explicitly
self.assertEqual(len(self.filter_with_rule(rule)), 1581) self.assertEqual(len(self.filter_with_rule(rule)), 1581)
def test_PeoplePrivate(self): def test_peopleprivate(self):
"""
Test PeoplePrivate rule.
"""
# TODO: example.gramps has no people marked private # TODO: example.gramps has no people marked private
rule = PeoplePrivate([]) rule = PeoplePrivate([])
self.assertEqual(self.filter_with_rule(rule), set([ self.assertEqual(self.filter_with_rule(rule), set([]))
]))
def test_PeoplePublic(self): def test_peoplepublic(self):
"""
Test PeoplePublic rule.
"""
rule = PeoplePublic([]) rule = PeoplePublic([])
# too many to list out to test explicitly # too many to list out to test explicitly
self.assertEqual(len(self.filter_with_rule(rule)), 2102) self.assertEqual(len(self.filter_with_rule(rule)), 2102)
def test_PersonWithIncompleteEvent(self): def test_personwithincompleteevent(self):
"""
Test PersonWithIncompleteEvent rule.
"""
rule = PersonWithIncompleteEvent([]) rule = PersonWithIncompleteEvent([])
# too many to list out to test explicitly # too many to list out to test explicitly
self.assertEqual(len(self.filter_with_rule(rule)), 740) self.assertEqual(len(self.filter_with_rule(rule)), 740)
def test_RelationshipPathBetweenBookmarks(self): def test_relationshipbookmarks(self):
"""
Test RelationshipPathBetweenBookmarks rule.
"""
rule = RelationshipPathBetweenBookmarks([]) rule = RelationshipPathBetweenBookmarks([])
self.assertEqual(self.filter_with_rule(rule), set([ self.assertEqual(self.filter_with_rule(rule), set([
b'44WJQCLCQIPZUB0UH', b'35WJQC1B7T7NPV8OLV', b'AWFKQCJELLUWDY2PD3', b'D3WJQCCGV58IP8PNHZ', b'44WJQCLCQIPZUB0UH', b'35WJQC1B7T7NPV8OLV', b'AWFKQCJELLUWDY2PD3',
b'Q8HKQC3VMRM1M6M7ES', b'D3WJQCCGV58IP8PNHZ', b'Q8HKQC3VMRM1M6M7ES',
])) ]))

110
gramps/gen/filters/rules/test/place_rules_test.py
View File

@@ -27,43 +27,71 @@ from gramps.gen.merge.diff import import_as_dict
from gramps.cli.user import User from gramps.cli.user import User
from gramps.gen.filters import GenericFilterFactory from gramps.gen.filters import GenericFilterFactory
from gramps.gen.filters.rules.place import * from gramps.gen.filters.rules.place import (
AllPlaces, HasCitation, HasGallery, HasIdOf, RegExpIdOf, HasNote,
HasNoteRegexp, HasReferenceCountOf, HasSourceCount, HasSourceOf,
PlacePrivate, MatchesSourceConfidence, HasData, HasNoLatOrLon,
InLatLonNeighborhood, ChangedSince, HasTag, HasTitle, IsEnclosedBy)
GenericPlaceFilter = GenericFilterFactory('Place') GenericPlaceFilter = GenericFilterFactory('Place')
class BaseTest(unittest.TestCase): class BaseTest(unittest.TestCase):
"""
Place rule tests.
"""
@classmethod @classmethod
def setUpClass(cls): def setUpClass(cls):
"""
Import example database.
"""
cls.db = import_as_dict("example/gramps/example.gramps", User()) cls.db = import_as_dict("example/gramps/example.gramps", User())
def filter_with_rule(self, rule): def filter_with_rule(self, rule):
"""
Apply a filter with the given rule.
"""
filter_ = GenericPlaceFilter() filter_ = GenericPlaceFilter()
filter_.add_rule(rule) filter_.add_rule(rule)
results = filter_.apply(self.db) results = filter_.apply(self.db)
return set(results) return set(results)
def test_AllPlaces(self): def test_allplaces(self):
"""
Test AllPlaces rule.
"""
rule = AllPlaces([]) rule = AllPlaces([])
self.assertEqual(len(self.filter_with_rule(rule)), self.assertEqual(len(self.filter_with_rule(rule)),
self.db.get_number_of_places()) self.db.get_number_of_places())
def test_HasCitation(self): def test_hascitation(self):
"""
Test HasCitation rule.
"""
rule = HasCitation(['page 23', '', '']) rule = HasCitation(['page 23', '', ''])
self.assertEqual(self.filter_with_rule(rule), self.assertEqual(self.filter_with_rule(rule),
set([b'YNUJQC8YM5EGRG868J'])) set([b'YNUJQC8YM5EGRG868J']))
def test_HasGallery(self): def test_hasgallery(self):
"""
Test HasGallery rule.
"""
rule = HasGallery(['0', 'greater than']) rule = HasGallery(['0', 'greater than'])
self.assertEqual(self.filter_with_rule(rule), self.assertEqual(self.filter_with_rule(rule),
set([b'YNUJQC8YM5EGRG868J'])) set([b'YNUJQC8YM5EGRG868J']))
def test_HasIdOf(self): def test_hasidof(self):
"""
Test HasIdOf rule.
"""
rule = HasIdOf(['P0001']) rule = HasIdOf(['P0001'])
self.assertEqual(self.filter_with_rule(rule), self.assertEqual(self.filter_with_rule(rule),
set([b'c96587262e91149933fcea5f20a'])) set([b'c96587262e91149933fcea5f20a']))
def test_RegExpIdOf(self): def test_regexpidof(self):
"""
Test RegExpIdOf rule.
"""
rule = RegExpIdOf(['P000.'], use_regex=True) rule = RegExpIdOf(['P000.'], use_regex=True)
self.assertEqual(self.filter_with_rule(rule), set([ self.assertEqual(self.filter_with_rule(rule), set([
b'c96587262e91149933fcea5f20a', b'c96587262ff262aaac31f6db7af', b'c96587262e91149933fcea5f20a', b'c96587262ff262aaac31f6db7af',
@@ -73,70 +101,112 @@ class BaseTest(unittest.TestCase):
b'c96587262f4a44183c65ff1e52', b'c96587262ed43fdb37bf04bdb7f', b'c96587262f4a44183c65ff1e52', b'c96587262ed43fdb37bf04bdb7f',
])) ]))
def test_HasNote(self): def test_hasnote(self):
"""
Test HasNote rule.
"""
rule = HasNote([]) rule = HasNote([])
self.assertEqual(self.filter_with_rule(rule), set([])) self.assertEqual(self.filter_with_rule(rule), set([]))
def test_HasNoteRegexp(self): def test_hasnoteregexp(self):
"""
Test HasNoteRegexp rule.
"""
rule = HasNoteRegexp(['.'], use_regex=True) rule = HasNoteRegexp(['.'], use_regex=True)
self.assertEqual(self.filter_with_rule(rule), set([])) self.assertEqual(self.filter_with_rule(rule), set([]))
def test_HasReferenceCountOf(self): def test_hasreferencecountof(self):
"""
Test HasReferenceCountOf rule.
"""
rule = HasReferenceCountOf(['greater than', '35']) rule = HasReferenceCountOf(['greater than', '35'])
self.assertEqual(self.filter_with_rule(rule), set([ self.assertEqual(self.filter_with_rule(rule), set([
b'c96587262e566596a225682bf53', b'MATJQCJYH8ULRIRYTH', b'c96587262e566596a225682bf53', b'MATJQCJYH8ULRIRYTH',
b'5HTJQCSB91P69HY731', b'4ECKQCWCLO5YIHXEXC', b'5HTJQCSB91P69HY731', b'4ECKQCWCLO5YIHXEXC',
b'c965872630a68ebd32322c4a30a'])) b'c965872630a68ebd32322c4a30a']))
def test_HasSourceCount(self): def test_hassourcecount(self):
"""
Test HasSourceCount rule.
"""
rule = HasSourceCount(['1', 'equal to']) rule = HasSourceCount(['1', 'equal to'])
self.assertEqual(self.filter_with_rule(rule), self.assertEqual(self.filter_with_rule(rule),
set([b'YNUJQC8YM5EGRG868J'])) set([b'YNUJQC8YM5EGRG868J']))
def test_HasSourceOf(self): def test_hassourceof(self):
"""
Test HasSourceOf rule.
"""
rule = HasSourceOf(['S0001']) rule = HasSourceOf(['S0001'])
self.assertEqual(self.filter_with_rule(rule), self.assertEqual(self.filter_with_rule(rule),
set([b'YNUJQC8YM5EGRG868J'])) set([b'YNUJQC8YM5EGRG868J']))
def test_PlacePrivate(self): def test_placeprivate(self):
"""
Test PlacePrivate rule.
"""
rule = PlacePrivate([]) rule = PlacePrivate([])
self.assertEqual(self.filter_with_rule(rule), set([])) self.assertEqual(self.filter_with_rule(rule), set([]))
def test_MatchesSourceConfidence(self): def test_matchessourceconfidence(self):
"""
Test MatchesSourceConfidence rule.
"""
rule = MatchesSourceConfidence(['2']) rule = MatchesSourceConfidence(['2'])
self.assertEqual(self.filter_with_rule(rule), self.assertEqual(self.filter_with_rule(rule),
set([b'YNUJQC8YM5EGRG868J'])) set([b'YNUJQC8YM5EGRG868J']))
def test_HasData(self): def test_hasdata(self):
"""
Test HasData rule.
"""
rule = HasData(['Albany', 'County', '']) rule = HasData(['Albany', 'County', ''])
self.assertEqual(self.filter_with_rule(rule), self.assertEqual(self.filter_with_rule(rule),
set([b'c9658726d602acadb74e330116a'])) set([b'c9658726d602acadb74e330116a']))
def test_HasNoLatOrLon(self): def test_hasnolatorlon(self):
"""
Test HasNoLatOrLon rule.
"""
rule = HasNoLatOrLon([]) rule = HasNoLatOrLon([])
self.assertEqual(len(self.filter_with_rule(rule)), 915) self.assertEqual(len(self.filter_with_rule(rule)), 915)
def test_InLatLonNeighborhood(self): def test_inlatlonneighborhood(self):
"""
Test InLatLonNeighborhood rule.
"""
rule = InLatLonNeighborhood(['30N', '90W', '2', '2']) rule = InLatLonNeighborhood(['30N', '90W', '2', '2'])
self.assertEqual(self.filter_with_rule(rule), set([ self.assertEqual(self.filter_with_rule(rule), set([
b'C6WJQC0GDYP3HZDPR3', b'N88LQCRB363ES5WJ83', b'C6WJQC0GDYP3HZDPR3', b'N88LQCRB363ES5WJ83',
b'03EKQCC2KTNLHFLDRJ', b'M9VKQCJV91X0M12J8'])) b'03EKQCC2KTNLHFLDRJ', b'M9VKQCJV91X0M12J8']))
def test_ChangedSince(self): def test_changedsince(self):
"""
Test ChangedSince rule.
"""
rule = ChangedSince(['2013-01-01', '2014-01-01']) rule = ChangedSince(['2013-01-01', '2014-01-01'])
self.assertEqual(len(self.filter_with_rule(rule)), 435) self.assertEqual(len(self.filter_with_rule(rule)), 435)
def test_HasTag(self): def test_hastag(self):
"""
Test HasTag rule.
"""
rule = HasTag(['ToDo']) rule = HasTag(['ToDo'])
self.assertEqual(self.filter_with_rule(rule), set([])) self.assertEqual(self.filter_with_rule(rule), set([]))
def test_HasTitle(self): def test_hastitle(self):
"""
Test HasTitle rule.
"""
rule = HasTitle(['Albany']) rule = HasTitle(['Albany'])
self.assertEqual(self.filter_with_rule(rule), set([ self.assertEqual(self.filter_with_rule(rule), set([
b'51VJQCXUP61H9JRL66', b'9XBKQCE1LZ7PMJE56G', b'51VJQCXUP61H9JRL66', b'9XBKQCE1LZ7PMJE56G',
b'c9658726d602acadb74e330116a', b'P9MKQCT08Z3YBJV5UB'])) b'c9658726d602acadb74e330116a', b'P9MKQCT08Z3YBJV5UB']))
def test_IsEnclosedBy(self): def test_isenclosedby(self):
"""
Test IsEnclosedBy rule.
"""
rule = IsEnclosedBy(['P0001']) rule = IsEnclosedBy(['P0001'])
self.assertEqual(self.filter_with_rule(rule), set([ self.assertEqual(self.filter_with_rule(rule), set([
b'EAFKQCR0ED5QWL87EO', b'S22LQCLUZM135LVKRL', b'VDUJQCFP24ZV3O4ID2', b'EAFKQCR0ED5QWL87EO', b'S22LQCLUZM135LVKRL', b'VDUJQCFP24ZV3O4ID2',

37
gramps/gen/utils/test/file_test.py
View File

@@ -21,13 +21,16 @@
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
# #
"""
File tests.
"""
#------------------------------------------------------------------------- #-------------------------------------------------------------------------
# #
# Standard python modules # Standard python modules
# #
#------------------------------------------------------------------------- #-------------------------------------------------------------------------
import os import os
import shutil
import unittest import unittest
#------------------------------------------------------------------------- #-------------------------------------------------------------------------
@@ -36,7 +39,6 @@ import unittest
# #
#------------------------------------------------------------------------- #-------------------------------------------------------------------------
from gramps.gen.const import TEMP_DIR, USER_HOME, USER_PLUGINS, VERSION from gramps.gen.const import TEMP_DIR, USER_HOME, USER_PLUGINS, VERSION
from gramps.gen.constfunc import get_env_var
from gramps.gen.utils.file import media_path, get_empty_tempdir from gramps.gen.utils.file import media_path, get_empty_tempdir
from gramps.gen.dbstate import DbState from gramps.gen.dbstate import DbState
@@ -46,8 +48,14 @@ from gramps.gen.dbstate import DbState
# #
#------------------------------------------------------------------------- #-------------------------------------------------------------------------
class FileTest(unittest.TestCase): class FileTest(unittest.TestCase):
"""
File tests.
"""
def test_mediapath(self): def test_mediapath(self):
"""
Test media path variables.
"""
# Create database # Create database
dbstate = DbState() dbstate = DbState()
@@ -58,36 +66,45 @@ class FileTest(unittest.TestCase):
dbstate.change_database(db) dbstate.change_database(db)
# Test without db.mediapath set # Test without db.mediapath set
self.assertEqual(media_path(db), os.path.normcase(os.path.normpath(os.path.abspath(USER_HOME)))) self.assertEqual(media_path(db), os.path.normcase(os.path.normpath(
os.path.abspath(USER_HOME))))
self.assertTrue(os.path.exists(media_path(db))) self.assertTrue(os.path.exists(media_path(db)))
# Test with absolute db.mediapath # Test with absolute db.mediapath
db.set_mediapath(os.path.abspath(USER_HOME) + "/test_abs") db.set_mediapath(os.path.abspath(USER_HOME) + "/test_abs")
self.assertEqual(media_path(db), os.path.normcase(os.path.normpath(os.path.abspath(USER_HOME + "/test_abs")))) self.assertEqual(media_path(db), os.path.normcase(os.path.normpath(
os.path.abspath(USER_HOME + "/test_abs"))))
# Test with relative db.mediapath # Test with relative db.mediapath
db.set_mediapath("test_rel") db.set_mediapath("test_rel")
self.assertEqual(media_path(db), os.path.normcase(os.path.normpath(os.path.abspath(TEMP_DIR + "/utils_file_test/test_rel")))) self.assertEqual(media_path(db), os.path.normcase(os.path.normpath(
os.path.abspath(TEMP_DIR + "/utils_file_test/test_rel"))))
# Test with environment variable # Test with environment variable
db.set_mediapath("/test/{VERSION}/test_var") db.set_mediapath("/test/{VERSION}/test_var")
self.assertEqual(media_path(db), os.path.normcase(os.path.normpath(os.path.abspath("/test/" + VERSION + "/test_var")))) self.assertEqual(media_path(db), os.path.normcase(os.path.normpath(
os.path.abspath("/test/" + VERSION + "/test_var"))))
db.set_mediapath("{USER_PLUGINS}/test_var") db.set_mediapath("{USER_PLUGINS}/test_var")
self.assertEqual(media_path(db), os.path.normcase(os.path.normpath(os.path.abspath(USER_PLUGINS + "/test_var")))) self.assertEqual(media_path(db), os.path.normcase(os.path.normpath(
os.path.abspath(USER_PLUGINS + "/test_var"))))
db.set_mediapath("{VERSION}/test_var") db.set_mediapath("{VERSION}/test_var")
self.assertEqual(media_path(db), os.path.normcase(os.path.normpath(os.path.abspath(TEMP_DIR + "/utils_file_test/" + VERSION + "/test_var")))) self.assertEqual(media_path(db), os.path.normcase(os.path.normpath(
os.path.abspath(TEMP_DIR + "/utils_file_test/" + VERSION +
"/test_var"))))
# Test with $GRAMPSHOME environment variable not set # Test with $GRAMPSHOME environment variable not set
old_env = os.environ.copy() old_env = os.environ.copy()
if 'GRAMPSHOME' in os.environ: if 'GRAMPSHOME' in os.environ:
del os.environ['GRAMPSHOME'] del os.environ['GRAMPSHOME']
db.set_mediapath("{GRAMPSHOME}/test_var") db.set_mediapath("{GRAMPSHOME}/test_var")
self.assertEqual(media_path(db), os.path.normcase(os.path.normpath(os.path.abspath(USER_HOME + "/test_var")))) self.assertEqual(media_path(db), os.path.normcase(os.path.normpath(
os.path.abspath(USER_HOME + "/test_var"))))
# Test with $GRAMPSHOME environment variable set # Test with $GRAMPSHOME environment variable set
os.environ['GRAMPSHOME'] = "/this/is/a/test" os.environ['GRAMPSHOME'] = "/this/is/a/test"
db.set_mediapath("{GRAMPSHOME}/test_var") db.set_mediapath("{GRAMPSHOME}/test_var")
self.assertEqual(media_path(db), os.path.normcase(os.path.normpath(os.path.abspath("/this/is/a/test/test_var")))) self.assertEqual(media_path(db), os.path.normcase(os.path.normpath(
os.path.abspath("/this/is/a/test/test_var"))))
# Restore environment # Restore environment
os.environ = old_env os.environ = old_env

84
gramps/plugins/tool/findloop.py
View File

@@ -34,20 +34,18 @@ from gi.repository import GObject
# Gramps modules # Gramps modules
# #
#------------------------------------------------------------------------ #------------------------------------------------------------------------
from gramps.gen.const import GRAMPS_LOCALE as glocale
_ = glocale.translation.sgettext
ngettext = glocale.translation.ngettext # else "nearby" comments are ignored
from gramps.gen.const import URL_MANUAL_PAGE from gramps.gen.const import URL_MANUAL_PAGE
from gramps.gui.plug import tool from gramps.gui.plug import tool
from gramps.gen.plug.report import utils as ReportUtils from gramps.gui.editors import EditFamily
from gramps.gui.editors import EditPerson, EditFamily from gramps.gen.errors import WindowActiveError
from gramps.gui.managedwindow import ManagedWindow from gramps.gui.managedwindow import ManagedWindow
from gramps.gui.utils import ProgressMeter from gramps.gui.utils import ProgressMeter
from gramps.gui.display import display_help from gramps.gui.display import display_help
from gramps.gui.glade import Glade from gramps.gui.glade import Glade
from gramps.gen.lib import Tag
from gramps.gen.db import DbTxn
from gramps.gen.display.name import displayer as _nd from gramps.gen.display.name import displayer as _nd
from gramps.gen.const import GRAMPS_LOCALE as glocale
_ = glocale.translation.sgettext
ngettext = glocale.translation.ngettext # else "nearby" comments are ignored
#------------------------------------------------------------------------- #-------------------------------------------------------------------------
# #
@@ -62,8 +60,10 @@ WIKI_HELP_SEC = _('manual|Find_database_loop')
# FindLoop class # FindLoop class
# #
#------------------------------------------------------------------------ #------------------------------------------------------------------------
class FindLoop(ManagedWindow) : class FindLoop(ManagedWindow):
"""
Find loops in the family tree.
"""
def __init__(self, dbstate, user, options_class, name, callback=None): def __init__(self, dbstate, user, options_class, name, callback=None):
uistate = user.uistate uistate = user.uistate
@@ -73,20 +73,20 @@ class FindLoop(ManagedWindow) :
self.uistate = uistate self.uistate = uistate
self.db = dbstate.db self.db = dbstate.db
topDialog = Glade() top_dialog = Glade()
topDialog.connect_signals({ top_dialog.connect_signals({
"destroy_passed_object" : self.close, "destroy_passed_object" : self.close,
"on_help_clicked" : self.on_help_clicked, "on_help_clicked" : self.on_help_clicked,
"on_delete_event" : self.close, "on_delete_event" : self.close,
}) })
window = topDialog.toplevel window = top_dialog.toplevel
title = topDialog.get_object("title") title = top_dialog.get_object("title")
self.set_window(window, title, self.title) self.set_window(window, title, self.title)
# start the progress indicator # start the progress indicator
self.progress = ProgressMeter(self.title,_('Starting'), self.progress = ProgressMeter(self.title, _('Starting'),
parent=self.window) parent=self.window)
self.progress.set_pass(_('Looking for possible loop for each person'), self.progress.set_pass(_('Looking for possible loop for each person'),
self.db.get_number_of_people()) self.db.get_number_of_people())
@@ -98,13 +98,18 @@ class FindLoop(ManagedWindow) :
GObject.TYPE_STRING, # 3==son GObject.TYPE_STRING, # 3==son
GObject.TYPE_STRING) # 4==family gid GObject.TYPE_STRING) # 4==family gid
self.treeView = topDialog.get_object("treeview") self.treeview = top_dialog.get_object("treeview")
self.treeView.set_model(self.model) self.treeview.set_model(self.model)
col1 = Gtk.TreeViewColumn(_('Gramps ID'), Gtk.CellRendererText(), text=0) col1 = Gtk.TreeViewColumn(_('Gramps ID'),
col2 = Gtk.TreeViewColumn(_('Ancestor'), Gtk.CellRendererText(), text=1) Gtk.CellRendererText(), text=0)
col3 = Gtk.TreeViewColumn(_('Gramps ID'), Gtk.CellRendererText(), text=2) col2 = Gtk.TreeViewColumn(_('Ancestor'),
col4 = Gtk.TreeViewColumn(_('Descendant'), Gtk.CellRendererText(), text=3) Gtk.CellRendererText(), text=1)
col5 = Gtk.TreeViewColumn(_('Family ID'), Gtk.CellRendererText(), text=4) col3 = Gtk.TreeViewColumn(_('Gramps ID'),
Gtk.CellRendererText(), text=2)
col4 = Gtk.TreeViewColumn(_('Descendant'),
Gtk.CellRendererText(), text=3)
col5 = Gtk.TreeViewColumn(_('Family ID'),
Gtk.CellRendererText(), text=4)
col1.set_resizable(True) col1.set_resizable(True)
col2.set_resizable(True) col2.set_resizable(True)
col3.set_resizable(True) col3.set_resizable(True)
@@ -120,14 +125,15 @@ class FindLoop(ManagedWindow) :
col3.set_sort_column_id(2) col3.set_sort_column_id(2)
col4.set_sort_column_id(3) col4.set_sort_column_id(3)
col5.set_sort_column_id(4) col5.set_sort_column_id(4)
self.treeView.append_column(col1) self.treeview.append_column(col1)
self.treeView.append_column(col2) self.treeview.append_column(col2)
self.treeView.append_column(col3) self.treeview.append_column(col3)
self.treeView.append_column(col4) self.treeview.append_column(col4)
self.treeView.append_column(col5) self.treeview.append_column(col5)
self.treeSelection = self.treeView.get_selection() self.treeselection = self.treeview.get_selection()
self.treeView.connect('row-activated', self.rowactivated) self.treeview.connect('row-activated', self.rowactivated_cb)
self.curr_fam = None
people = self.db.get_person_handles() people = self.db.get_person_handles()
count = 0 count = 0
for person_handle in people: for person_handle in people:
@@ -145,6 +151,9 @@ class FindLoop(ManagedWindow) :
self.show() self.show()
def descendants(self, person_handle, new_list): def descendants(self, person_handle, new_list):
"""
Find the descendants of a given person.
"""
person = self.db.get_person_from_handle(person_handle) person = self.db.get_person_from_handle(person_handle)
pset = set() pset = set()
for item in new_list: for item in new_list:
@@ -182,13 +191,14 @@ class FindLoop(ManagedWindow) :
self.parent = person self.parent = person
self.descendants(child_handle, pset) self.descendants(child_handle, pset)
def rowactivated(self, treeView, path, column) : def rowactivated_cb(self, treeview, path, column):
"""
Called when a row is activated.
"""
# first we need to check that the row corresponds to a person # first we need to check that the row corresponds to a person
iter = self.model.get_iter(path) iter_ = self.model.get_iter(path)
From_id = self.model.get_value(iter, 0) fam_id = self.model.get_value(iter_, 4)
To_id = self.model.get_value(iter, 2) fam = self.dbstate.db.get_family_from_gramps_id(fam_id)
Fam_id = self.model.get_value(iter, 4)
fam = self.dbstate.db.get_family_from_gramps_id(Fam_id)
if fam: if fam:
try: try:
EditFamily(self.dbstate, self.uistate, [], fam) EditFamily(self.dbstate, self.uistate, [], fam)
@@ -198,11 +208,13 @@ class FindLoop(ManagedWindow) :
return False return False
def on_help_clicked(self, obj): def on_help_clicked(self, obj):
"""Display the relevant portion of GRAMPS manual""" """
Display the relevant portion of Gramps manual.
"""
display_help(webpage=WIKI_HELP_PAGE, section=WIKI_HELP_SEC) display_help(webpage=WIKI_HELP_PAGE, section=WIKI_HELP_SEC)
def close(self, *obj): def close(self, *obj):
ManagedWindow.close(self,*obj) ManagedWindow.close(self, *obj)
#------------------------------------------------------------------------ #------------------------------------------------------------------------
# #