def sort_formset(formsets):
"""
Sort formset for template view appropriately.
Returns a list of dicts
[
(rowname, {A:.., S:...}),
(rowname, {A:.., S:...}),
(rowname, {A:.., S:...}),
]
"""
ptypes = dict([
(p['sequence'], p) for p in PronounType.objects.all().values()
])
rows = {}
empty = dict(zip(
[x[0] for x in ALIGNMENT_CHOICES],
[None for x in ALIGNMENT_CHOICES]
))
# use decorate-sort-undecorate pattern to loop over pronoun and formset
# in formsets. The sort key is the pronountype.sequence + 3 / 4
# add three to get the grouping right (1-4), (5-8), (9-12) etc
for pronoun, formset in formsets:
pt = ptypes[pronoun.pronountype.sequence]
row = full_repr_row(pt)
sortkey = (pronoun.pronountype.sequence + 3) / 4
rows[(sortkey, row)] = rows.get((sortkey, row), empty.copy())
rows[(sortkey, row)][pt['alignment']] = formset
return [(key, rows[(_, key)]) for (_, key) in sorted(rows)]
def sort_formset(formsets):
"""
Sort formset for template view appropriately.
Returns a list of dicts
[
(rowname, {A:.., S:...}),
(rowname, {A:.., S:...}),
(rowname, {A:.., S:...}),
]
"""
ptypes = dict([(p['sequence'], p) for p in PronounType.objects.all().values()])
rows = {}
empty = dict(zip([x[0] for x in ALIGNMENT_CHOICES],
[None for x in ALIGNMENT_CHOICES])
)
# use decorate-sort-undecorate pattern to loop over pronoun and formset
# in formsets. The sort key is the pronountype.sequence + 3 / 4
# add three to get the grouping right (1-4), (5-8), (9-12) etc
for pronoun, formset in formsets:
pt = ptypes[pronoun.pronountype.sequence]
row = full_repr_row(pt)
sortkey = (pronoun.pronountype.sequence + 3) / 4
rows[(sortkey, row)] = rows.get((sortkey, row), empty.copy())
rows[(sortkey, row)][pt['alignment']] = formset
return [(key, rows[(_, key)]) for (_, key) in sorted(rows)]
def setUpTestData(cls):
"""Note, this requires the full pronoun complement."""
cls.editor = User.objects.create_user('admin', '*****@*****.**',
"test")
cls.lang = Language.objects.create(language='A',
slug='langa',
information='i.1',
classification='a, b',
isocode='aaa',
editor=cls.editor)
cls.source = Source.objects.create(year="1991",
author='Smith',
slug='Smith1991',
reference='S2',
comment='c1',
editor=cls.editor)
# Load all pronoun combinations
for i, p in enumerate(PronounCombinations, 1):
# create word
w = short_repr_row(p)
this_word = Word.objects.create(word=w,
slug=w.lower().replace(" ", "_"),
full=full_repr_row(p),
editor=cls.editor)
this_word.save()
gender = p['gender'] if p['gender'] is None else p['gender'][0]
ptype = PronounType.objects.create(alignment=p['alignment'][0],
person=p['person'][0],
number=p['number'][0],
gender=gender,
sequence=i,
word=this_word,
editor=cls.editor)
ptype.save()
# change the paradigm, man
cls.fullpdm = Paradigm.objects.create(language=cls.lang,
source=cls.source,
editor=cls.editor,
comment="full paradigm")
cls.fullpdm.save()
# add some lexicon...
for p in cls.fullpdm.pronoun_set.all():
lex = Lexicon.objects.create(editor=cls.editor,
language=cls.lang,
source=cls.source,
word=p.pronountype.word,
entry='%d' % p.id)
lex.save()
p.entries.add(lex)
cls.url = reverse('pronouns:edit',
kwargs={'paradigm_id': cls.fullpdm.id})
cls.detail_url = reverse('pronouns:detail',
kwargs={'paradigm_id': cls.fullpdm.id})
def test_dict_no_gender(self):
d = {
'number': ('sg', 'Singular'),
'alignment': ('A', 'A'),
'person': ('1', '1st (excl) Person'),
'gender': ('M', 'Masculine'),
}
assert full_repr_row(d) == "1st (excl) Person Singular Masculine"
def test_dict(self):
d = {
'number': ('sg', 'Singular'),
'alignment': ('A', 'A'),
'person': ('1', '1st (excl) Person'),
'gender': None,
}
assert full_repr_row(d) == "1st (excl) Person Singular"
def test_dict_no_gender(self):
d = {
'number': ('sg', 'Singular'),
'alignment': ('A', 'A'),
'person': ('1', '1st (excl) Person'),
'gender': ('M', 'Masculine'),
}
assert full_repr_row(d) == "1st (excl) Person Singular Masculine"
def test_dict(self):
d = {
'number': ('sg', 'Singular'),
'alignment': ('A', 'A'),
'person': ('1', '1st (excl) Person'),
'gender': None,
}
assert full_repr_row(d) == "1st (excl) Person Singular"
def test_obj(self):
pt = PronounType(number='sg',
alignment="A",
person="1",
gender=None,
sequence=10,
editor=self.editor,
word=self.word)
p = Pronoun(paradigm=self.pdm, editor=self.editor, pronountype=pt)
assert full_repr_row(p) == "1st (excl) Person Singular"
def test_form_load(self):
for formid, formdict in self.response.context['pronouns']:
for alignment in ("A", "S", "O", "P"):
assert alignment in formdict
formset = formdict[alignment]
assert len(formset.forms) == 1
obj = formset.forms[0].instance
# want to find pronoun type for this obj.
pron = obj.pronoun_set.all()[0]
assert full_repr_row(pron) == formid
assert alignment == pron.pronountype.alignment
def test_form_load(self):
for formid, formdict in self.response.context['pronouns']:
for alignment in ("A", "S", "O", "P"):
assert alignment in formdict
formset = formdict[alignment]
assert len(formset.forms) == 1
obj = formset.forms[0].instance
# want to find pronoun type for this obj.
pron = obj.pronoun_set.all()[0]
assert full_repr_row(pron) == formid
assert alignment == pron.pronountype.alignment
def test_no_errors(self):
for row in PronounType._generate_all_combinations():
full_repr_row(row)
def test_obj_no_gender(self):
pt = PronounType.objects.create(number='sg', alignment="A", person="1", sequence=11,
gender="M", editor=self.editor, word=self.word)
p = Pronoun.objects.create(paradigm=self.pdm, editor=self.editor, pronountype=pt)
assert full_repr_row(p) == "1st (excl) Person Singular Gender 1"
def setUp(self):
"""Note, this requires the full pronoun complement."""
self.editor = User.objects.create_user('admin', '*****@*****.**', "test")
self.lang = Language.objects.create(language='A', slug='langa',
information='i.1',
classification='a, b',
isocode='aaa', editor=self.editor)
self.source = Source.objects.create(year="1991", author='Smith',
slug='Smith1991', reference='S2',
comment='c1', editor=self.editor)
# Load all pronoun combinations
for i, p in enumerate(PronounCombinations, 1):
# create word
w = short_repr_row(p)
this_word = Word.objects.create(
word = w,
slug = w.lower().replace(" ", "_"),
full = full_repr_row(p),
editor=self.editor
)
this_word.save()
if p['gender'] is None:
gender = None
else:
gender = p['gender'][0]
ptype = PronounType.objects.create(
alignment = p['alignment'][0],
person = p['person'][0],
number = p['number'][0],
gender = gender,
sequence = i,
word=this_word,
editor=self.editor
)
ptype.save()
# change the paradigm, man
self.fullpdm = Paradigm.objects.create(language=self.lang,
source=self.source,
editor=self.editor,
comment="full paradigm")
self.fullpdm.save()
assert self.fullpdm.pronoun_set.count() == len(PronounCombinations), \
"Expected %d pronouns not %d" % (len(PronounCombinations), self.fullpdm.pronoun_set.count())
# add some lexicon...
for p in self.fullpdm.pronoun_set.all():
lex = Lexicon.objects.create(
editor=self.editor,
language=self.lang,
source=self.source,
word=p.pronountype.word,
entry='%d' % p.id
)
lex.save()
p.entries.add(lex)
self.url = reverse('pronouns:edit', kwargs={'paradigm_id': self.fullpdm.id})
self.client = Client()
self.client.login(username='******', password='******')
self.response = self.client.get(self.url)
def test_no_errors(self):
for row in PronounType._generate_all_combinations():
full_repr_row(row)
def test_content_rows(self):
for p in self.pdm.pronoun_set.all():
self.assertContains(self.response, full_repr_row(p))
