def test_get_templates_count(self):
key_1 = random.choice(keys.LEXICON_KEY.records)
key_2 = random.choice(keys.LEXICON_KEY.records)
utg_template_1 = utg_templates.Template()
utg_template_1.parse('some-text', externals=[v.value for v in key_1.variables])
utg_template_2 = utg_templates.Template()
utg_template_2.parse('some-text-2', externals=[v.value for v in key_2.variables])
template_1_1 = prototypes.TemplatePrototype.create(key=key_1, raw_template='template-1-1', utg_template=utg_template_1, verificators=[], author=None)
template_1_2 = prototypes.TemplatePrototype.create(key=key_1, raw_template='template-1-2', utg_template=utg_template_1, verificators=[], author=None)
template_2_1 = prototypes.TemplatePrototype.create(key=key_2, raw_template='template-2-1', utg_template=utg_template_2, verificators=[], author=None)
template_1_1.state = relations.TEMPLATE_STATE.IN_GAME
template_1_1.save()
template_1_2.state = relations.TEMPLATE_STATE.IN_GAME
template_1_2.save()
template_2_1.state = relations.TEMPLATE_STATE.IN_GAME
template_2_1.save()
groups_count, keys_count = logic.get_templates_count()
if key_1.group == key_2.group:
for group in groups_relations.LEXICON_GROUP.records:
if group == key_1.group:
self.assertEqual(groups_count[group], 3)
else:
self.assertEqual(groups_count[group], 0)
else:
for group in groups_relations.LEXICON_GROUP.records:
if group == key_1.group:
self.assertEqual(groups_count[group], 2)
elif group == key_2.group:
self.assertEqual(groups_count[group], 1)
else:
self.assertEqual(groups_count[group], 0)
if key_1 == key_2:
for key in keys.LEXICON_KEY.records:
if key == key_1:
self.assertEqual(keys_count[key], 3)
else:
self.assertEqual(keys_count[key], 0)
else:
for key in keys.LEXICON_KEY.records:
if key == key_1:
self.assertEqual(keys_count[key], 2)
elif key == key_2:
self.assertEqual(keys_count[key], 1)
else:
self.assertEqual(keys_count[key], 0)
def test_get_errors__verificators_errors(self):
key = keys.LEXICON_KEY.HERO_COMMON_JOURNAL_LEVEL_UP
TEXT = u'[hero|загл] [level] [неизвестное слово|hero|вн]'
template = utg_templates.Template()
template.parse(TEXT, externals=['hero'])
verificator_1 = prototypes.Verificator(text=u'абракадабра',
externals={
'hero': (u'героиня', u''),
'level': (1, u'')
})
verificator_2 = prototypes.Verificator(
text=u'Рыцари 5 w-1-полнприл,мн,вн,од,пол',
externals={
'hero': (u'рыцарь', u'мн'),
'level': (5, u'')
})
verificator_3 = prototypes.Verificator(text=u'Герой 2 w-1-ед,вн',
externals={
'hero': (u'герой', u''),
'level': (2, u'')
})
verificator_4 = prototypes.Verificator(text=u'',
externals={
'hero':
(u'привидение', u''),
'level': (5, u'')
})
dictionary = storage.game_dictionary.item
word = utg_words.Word.create_test_word(
type=utg_relations.WORD_TYPE.ADJECTIVE,
prefix=u'w-1-',
only_required=True)
word.forms[0] = u'неизвестное слово'
dictionary.add_word(word)
prototype = prototypes.TemplatePrototype.create(key=key,
utg_template=template,
raw_template=TEXT,
verificators=[
verificator_1,
verificator_2,
verificator_3,
verificator_4
],
author=self.account_1)
errors = prototype.get_errors()
self.assertEqual(errors, [
u'Проверочный текст не совпадает с интерпретацией шаблона<br/>Героиня 1 w-1-полнприл,ед,вн,жр,од,пол<br/>абракадабра',
u'Проверочный текст не совпадает с интерпретацией шаблона<br/>Герой 2 w-1-полнприл,ед,вн,мр,од,пол<br/>Герой 2 w-1-ед,вн',
u'Проверочный текст не совпадает с интерпретацией шаблона<br/>Привидение 5 w-1-полнприл,ед,вн,ср,од,пол<br/>'
])
def remove_technical_template_parts(apps, schema_editor):
from utg import templates as utg_templates
from the_tale.linguistics.lexicon import keys as linguistics_keys
Template = apps.get_model("linguistics", "Template")
for template in Template.objects.iterator():
data = json.loads(template.data)
template.raw_template = processor(template.raw_template)
key = linguistics_keys.LEXICON_KEY.index_value.get(template.key)
if key is None:
continue
utg_template = utg_templates.Template()
try:
utg_template.parse(template.raw_template,
externals=[v.value for v in key.variables])
except:
continue
for verificator in data['verificators']:
verificator['text'] = processor(verificator['text'])
data['template'] = utg_template.serialize()
template.data = json.dumps(data, ensure_ascii=False)
template.save()
def test_get_errors__no_errors(self):
key = keys.LEXICON_KEY.HERO_COMMON_JOURNAL_LEVEL_UP
TEXT = u'[hero|загл] [level] [неизвестное слово|hero|вн]'
template = utg_templates.Template()
template.parse(TEXT, externals=['hero'])
verificator_1 = prototypes.Verificator(
text=u'Героиня 1 w-1-полнприл,пол,од,ед,вн,жр',
externals={
'hero': (u'героиня', u''),
'level': (1, u'')
})
verificator_2 = prototypes.Verificator(
text=u'Рыцари 5 w-1-полнприл,пол,од,мн,вн',
externals={
'hero': (u'рыцарь', u'мн'),
'level': (5, u'')
})
verificator_3 = prototypes.Verificator(
text=u'Герой 2 w-1-полнприл,пол,од,ед,вн,мр',
externals={
'hero': (u'герой', u''),
'level': (2, u'')
})
verificator_4 = prototypes.Verificator(
text=u'Привидение 5 w-1-полнприл,пол,од,ед,вн,ср',
externals={
'hero': (u'привидение', u''),
'level': (5, u'')
})
dictionary = storage.game_dictionary.item
word = utg_words.Word.create_test_word(
type=utg_relations.WORD_TYPE.ADJECTIVE,
prefix=u'w-1-',
only_required=True)
word.forms[0] = u'неизвестное слово'
dictionary.add_word(word)
prototype = prototypes.TemplatePrototype.create(key=key,
raw_template=TEXT,
utg_template=template,
verificators=[
verificator_1,
verificator_2,
verificator_3,
verificator_4
],
author=self.account_1)
self.assertTrue(prototype.errors_status.is_NO_ERRORS)
errors = prototype.get_errors()
self.assertEqual(errors, [])
def test_get_undictionaried_words(self):
word_1 = words.Word.create_test_word(type=r.WORD_TYPE.NOUN,
prefix='w-',
properties=words.Properties(
r.GENDER.FEMININE,
r.ANIMALITY.INANIMATE,
r.NUMBER.PLURAL))
word_2 = words.Word.create_test_word(type=r.WORD_TYPE.NOUN,
prefix='x-',
properties=words.Properties(
r.GENDER.FEMININE,
r.ANIMALITY.INANIMATE))
word_3 = words.Word.create_test_word(type=r.WORD_TYPE.NOUN,
prefix='y-',
properties=words.Properties(
r.GENDER.FEMININE,
r.ANIMALITY.INANIMATE,
r.NUMBER.PLURAL))
dictionary = Dictionary()
dictionary.add_word(word_1)
dictionary.add_word(word_2)
dictionary.add_word(word_3)
TEXT = '[external_1|загл] 1 [x-нс,ед,тв|external_2|буд] 2 [слово|тв,ед] [бла-бла]'
template = templates.Template()
template.parse(TEXT, externals=['external_1', 'external_2'])
self.assertEqual(
template.get_undictionaried_words(
externals=['external_1', 'external_2'], dictionary=dictionary),
['слово', 'бла-бла'])
def test_parse(self):
TEXT = '[external_1|загл] 1 [ед3|external_2|буд] 2 [external_2|тв,ед]'
template = templates.Template()
template.parse(TEXT, externals=['external_1', 'external_2'])
self.assertEqual(template.template, '%s 1 %s 2 %s')
self.assertEqual(len(template._substitutions), 3)
substitution = template._substitutions[0]
self.assertEqual(substitution.id, 'external_1')
self.assertEqual(substitution.dependencies,
[words.Properties(r.WORD_CASE.UPPER)])
substitution = template._substitutions[1]
self.assertEqual(substitution.id, 'ед3')
self.assertEqual(
substitution.dependencies,
['external_2', words.Properties(r.TIME.FUTURE)])
substitution = template._substitutions[2]
self.assertEqual(substitution.id, 'external_2')
self.assertEqual(
substitution.dependencies,
[words.Properties(r.CASE.INSTRUMENTAL, r.NUMBER.SINGULAR)])
def create(self, key):
form = forms.TemplateForm(
key, prototypes.TemplatePrototype.get_start_verificatos(key=key),
self.request.POST)
if not form.is_valid():
return self.json_error('linguistics.templates.create.form_errors',
form.errors)
utg_template = utg_templates.Template()
utg_template.parse(form.c.template,
externals=[v.value for v in key.variables])
template = prototypes.TemplatePrototype.create(
key=key,
raw_template=form.c.template,
utg_template=utg_template,
verificators=form.verificators,
author=self.account,
restrictions=form.get_restrictions())
prototypes.ContributionPrototype.get_for_or_create(
type=relations.CONTRIBUTION_TYPE.TEMPLATE,
account_id=template.author_id,
entity_id=template.id,
source=relations.CONTRIBUTION_SOURCE.MODERATOR
if self.can_moderate_templates else
relations.CONTRIBUTION_SOURCE.PLAYER,
state=template.state.contribution_state)
return self.json_ok(
data={'next_url': url('linguistics:templates:show', template.id)})
def update(self):
if self._template.state.is_ON_REVIEW and not self.can_edit_templates and self._template.author_id != self.account.id:
return self.auto_error('linguistics.templates.update.can_not_edit_anothers_template',
u'Вы не можете редактировать вариант фразы, созданный другим игроком. Подождите пока его проверит модератор.')
if self._template.get_child():
return self.auto_error('linguistics.templates.update.template_has_child',
u'У этой фразы уже есть копия. Отредактируйте её или попросите автора копии сделать это.')
form = forms.TemplateForm(self._template.key,
self._template.get_all_verificatos(),
self.request.POST)
if not form.is_valid():
return self.json_error('linguistics.templates.update.form_errors', form.errors)
utg_template = utg_templates.Template()
utg_template.parse(form.c.template, externals=[v.value for v in self._template.key.variables])
if (form.verificators == self._template.get_all_verificatos() and
form.c.template == self._template.raw_template and
form.get_restrictions() == self._template.raw_restrictions):
return self.json_error('linguistics.templates.update.full_copy_restricted', u'Вы пытаетесь создать полную копию шаблона, в этом нет необходимости.')
if self.can_edit_templates or (self._template.author_id == self.account.id and self._template.state.is_ON_REVIEW):
self._template.update(raw_template=form.c.template,
utg_template=utg_template,
verificators=form.verificators,
restrictions=form.get_restrictions())
prototypes.ContributionPrototype.get_for_or_create(type=relations.CONTRIBUTION_TYPE.TEMPLATE,
account_id=self.account.id,
entity_id=self._template.id,
source=relations.CONTRIBUTION_SOURCE.MODERATOR if self.can_edit_templates else relations.CONTRIBUTION_SOURCE.PLAYER,
state=self._template.state.contribution_state)
return self.json_ok(data={'next_url': url('linguistics:templates:show', self._template.id)})
template = prototypes.TemplatePrototype.create(key=self._template.key,
raw_template=form.c.template,
utg_template=utg_template,
verificators=form.verificators,
restrictions=form.get_restrictions(),
author=self.account,
parent=self._template)
prototypes.ContributionPrototype.get_for_or_create(type=relations.CONTRIBUTION_TYPE.TEMPLATE,
account_id=template.author_id,
entity_id=template.id,
source=relations.CONTRIBUTION_SOURCE.MODERATOR if self.can_edit_templates else relations.CONTRIBUTION_SOURCE.PLAYER,
state=template.state.contribution_state)
return self.json_ok(data={'next_url': url('linguistics:templates:show', template.id)})
def test_parse__percent_symbol(self):
TEXT = '[external_1|загл] 1 [ед3|external_2|буд] 2% [external_2|тв,ед]'
template = templates.Template()
template.parse(TEXT, externals=['external_1', 'external_2'])
self.assertEqual(template.template, '%s 1 %s 2%% %s')
def test_serialization(self):
TEXT = '[external_1|загл] 1 [ед3|external_2|буд] 2 [external_2|тв,ед]'
template = templates.Template()
template.parse(TEXT, externals=['external_1', 'external_2'])
self.assertEqual(
template.serialize(),
templates.Template.deserialize(template.serialize()).serialize())
def test_update_words_usage_info__ignore_duplicates(self):
word_1 = prototypes.WordPrototype.create(utg_words.Word.create_test_word(type=utg_relations.WORD_TYPE.NOUN, prefix='w-1-', only_required=True))
word_2 = prototypes.WordPrototype.create(utg_words.Word.create_test_word(type=utg_relations.WORD_TYPE.NOUN, prefix='w-2-', only_required=True))
word_3 = prototypes.WordPrototype.create(utg_words.Word.create_test_word(type=utg_relations.WORD_TYPE.NOUN, prefix='w-3-', only_required=True))
key = keys.LEXICON_KEY.HERO_COMMON_JOURNAL_LEVEL_UP
word_1.utg_word.forms[1] = word_1.utg_word.forms[0]
word_1.save()
text_1 = '[w-1-нс,ед,им|hero]'
text_2 = '[w-1-нс,ед,им|hero] [w-2-нс,ед,им|hero]'
utg_template = utg_templates.Template()
utg_template.parse(text_1, externals=['hero', 'level'])
template = prototypes.TemplatePrototype.create(key=key, raw_template=text_1, utg_template=utg_template, verificators=[], author=None)
template.state = relations.TEMPLATE_STATE.IN_GAME
template.save()
utg_template = utg_templates.Template()
utg_template.parse(text_2, externals=['hero', 'level'])
template = prototypes.TemplatePrototype.create(key=key, raw_template=text_2, utg_template=utg_template, verificators=[], author=None)
self.assertTrue(template.state.is_ON_REVIEW)
utg_template = utg_templates.Template()
utg_template.parse(text_2, externals=['hero', 'level'])
template = prototypes.TemplatePrototype.create(key=key, raw_template=text_2, utg_template=utg_template, verificators=[], author=None)
self.assertTrue(template.state.is_ON_REVIEW)
logic.update_words_usage_info()
word_1.reload()
word_2.reload()
word_3.reload()
self.assertEqual(word_1.used_in_ingame_templates, 1)
self.assertEqual(word_1.used_in_onreview_templates, 2)
self.assertTrue(word_1.used_in_status.is_IN_INGAME_TEMPLATES)
self.assertEqual(word_2.used_in_ingame_templates, 0)
self.assertEqual(word_2.used_in_onreview_templates, 2)
self.assertTrue(word_2.used_in_status.is_IN_ONREVIEW_TEMPLATES)
self.assertEqual(word_3.used_in_ingame_templates, 0)
self.assertEqual(word_3.used_in_onreview_templates, 0)
self.assertTrue(word_3.used_in_status.is_NOT_USED)
def create_template(self, key, word):
text = '[%(external)s|загл] 1 [%(word)s|%(external)s|буд,вн]' % {'external': key.variables[0].value, 'word': word}
template = utg_templates.Template()
template.parse(text, externals=[v.value for v in key.variables])
return text, template
def test_get_text__linguistics_variables(self):
key = keys.LEXICON_KEY.HERO_COMMON_JOURNAL_LEVEL_UP
dictionary = storage.game_dictionary.item
word_1 = utg_words.Word.create_test_word(
type=utg_relations.WORD_TYPE.NOUN,
prefix='w-3-',
only_required=True)
word_1.forms[3] = 'дубль'
self.assertEqual(word_1.form(utg_relations.CASE.ACCUSATIVE), 'дубль')
dictionary.add_word(word_1)
TEXT = '[hero|загл] [level] [дубль|hero|дт]'
template = utg_templates.Template()
template.parse(TEXT, externals=['hero', 'level'])
prototypes.TemplatePrototype.create(key=key,
raw_template=TEXT,
utg_template=template,
verificators=[],
author=None)
# update template errors_status and state to enshure, that it will be loaded in game lexicon
prototypes.TemplatePrototype._db_all().update(
errors_status=relations.TEMPLATE_ERRORS_STATUS.NO_ERRORS,
state=relations.TEMPLATE_STATE.IN_GAME)
storage.game_lexicon.refresh()
weapon_restrictions = [
storage.restrictions_storage.all()[0].id,
storage.restrictions_storage.all()[100].id
]
weapon_mock = mock.Mock(
utg_name_form=lexicon_dictinonary.DICTIONARY.get_word('меч'),
linguistics_restrictions=lambda: weapon_restrictions)
hero_mock = mock.Mock(
utg_name_form=lexicon_dictinonary.DICTIONARY.get_word('герой'),
linguistics_restrictions=lambda: [],
linguistics_variables=lambda: [('weapon', weapon_mock)])
lexicon_key, externals, restrictions = logic.prepair_get_text(
key.name, args={
'hero': hero_mock,
'level': 1
})
self.assertEqual(externals['hero.weapon'],
lexicon_dictinonary.DICTIONARY.get_word('меч'))
self.assertIn(('hero.weapon', weapon_restrictions[0]), restrictions)
self.assertIn(('hero.weapon', weapon_restrictions[1]), restrictions)
def clean_template(self):
data = self.cleaned_data['template'].strip()
# TODO: test exceptions
try:
template = utg_templates.Template()
template.parse(data, externals=[v.value for v in self.key.variables])
except utg_exceptions.WrongDependencyFormatError, e:
raise django_forms.ValidationError(u'Ошибка в формате подстановки: %s' % e.arguments['dependency'])
def create_removed_template(self):
TEXT = '[hero|загл] [level] [дубль|hero|дт]'
utg_template = utg_templates.Template()
utg_template.parse(TEXT, externals=['hero', 'level'])
template = prototypes.TemplatePrototype.create(key=keys.LEXICON_KEY.random(),
raw_template=TEXT,
utg_template=utg_template,
verificators=[],
author=None,
state=relations.TEMPLATE_STATE.REMOVED)
return template
def update_templates_errors(self):
key = keys.LEXICON_KEY.HERO_COMMON_JOURNAL_LEVEL_UP
TEXT = '[hero|загл] [level] [неизвестное слово|hero|вн]'
template = utg_templates.Template()
template.parse(TEXT, externals=['hero'])
verificator_1 = prototypes.Verificator(text='Героиня 1 w-1-ед,вн,жр,од,пол', externals={'hero': ('героиня', ''), 'level': (1, '')})
verificator_2 = prototypes.Verificator(text='Рыцари 5 w-1-мн,вн,од,пол', externals={'hero': ('рыцарь', 'мн'), 'level': (5, '')})
verificator_3 = prototypes.Verificator(text='Герой 2 w-1-ед,вн,мр,од,пол', externals={'hero': ('герой', ''), 'level': (2, '')})
verificator_4 = prototypes.Verificator(text='Привидение 5 w-1-ед,вн,ср,од,пол', externals={'hero': ('привидение', ''), 'level': (5, '')})
dictionary = storage.game_dictionary.item
word = utg_words.Word.create_test_word(type=utg_relations.WORD_TYPE.ADJECTIVE, prefix='w-1-', only_required=True)
word.forms[0] = 'неизвестное слово'
dictionary.add_word(word)
prototype_1 = prototypes.TemplatePrototype.create(key=key,
raw_template=TEXT,
utg_template=template,
verificators=[verificator_1, verificator_2, verificator_3, verificator_4],
author=self.account_1)
prototype_2 = prototypes.TemplatePrototype.create(key=key,
raw_template=TEXT,
utg_template=template,
verificators=[],
author=self.account_1)
prototypes.TemplatePrototype._db_filter(id=prototype_1.id).update(errors_status=relations.TEMPLATE_ERRORS_STATUS.HAS_ERRORS)
prototypes.TemplatePrototype._db_filter(id=prototype_2.id).update(errors_status=relations.TEMPLATE_ERRORS_STATUS.NO_ERRORS)
prototype_1.reload()
prototype_2.reload()
self.assertTrue(prototype_1.errors_status.is_HAS_ERRORS)
self.assertTrue(prototype_2.errors_status.is_NO_ERRORS)
logic.update_templates_errors()
prototype_1.reload()
prototype_2.reload()
self.assertTrue(prototype_1.errors_status.is_NO_ERRORS)
self.assertTrue(prototype_2.errors_status.is_HAS_ERRORS)
def test_add_word_restrictions_into_variable_restrictions(self):
key = keys.LEXICON_KEY.HERO_COMMON_JOURNAL_LEVEL_UP
TEXT = '[hero|загл] [level] [дубль|hero|дт]'
template = utg_templates.Template()
template.parse(TEXT, externals=['hero', 'level'])
prototypes.TemplatePrototype.create(key=key,
raw_template=TEXT,
utg_template=template,
verificators=[],
author=None)
# update template errors_status and state to enshure, that it will be loaded in game lexicon
prototypes.TemplatePrototype._db_all().update(errors_status=relations.TEMPLATE_ERRORS_STATUS.NO_ERRORS,
state=relations.TEMPLATE_STATE.IN_GAME)
storage.game_lexicon.refresh()
normal_noun = utg_words.WordForm(utg_words.Word.create_test_word(type=utg_relations.WORD_TYPE.NOUN, prefix='w-1-', only_required=True))
singular_noun = utg_words.WordForm(utg_words.Word.create_test_word(type=utg_relations.WORD_TYPE.NOUN, prefix='w-1-', only_required=True,
properties=utg_words.Properties(utg_relations.NUMBER.SINGULAR)))
plural_noun = utg_words.WordForm(utg_words.Word.create_test_word(type=utg_relations.WORD_TYPE.NOUN, prefix='w-1-', only_required=True,
properties=utg_words.Properties(utg_relations.NUMBER.PLURAL)))
hero_mock = mock.Mock(utg_name_form=normal_noun, linguistics_restrictions=lambda: [])
lexicon_key, externals, restrictions = logic.prepair_get_text(key.name, args={'hero': hero_mock, 'level': 1})
self.assertIn(('hero', storage.restrictions_storage.get_restriction(relations.TEMPLATE_RESTRICTION_GROUP.PLURAL_FORM,
relations.WORD_HAS_PLURAL_FORM.HAS.value).id), restrictions)
self.assertNotIn(('hero', storage.restrictions_storage.get_restriction(relations.TEMPLATE_RESTRICTION_GROUP.PLURAL_FORM,
relations.WORD_HAS_PLURAL_FORM.HAS_NO.value).id), restrictions)
hero_mock = mock.Mock(utg_name_form=singular_noun, linguistics_restrictions=lambda: [])
lexicon_key, externals, restrictions = logic.prepair_get_text(key.name, args={'hero': hero_mock, 'level': 1})
self.assertNotIn(('hero', storage.restrictions_storage.get_restriction(relations.TEMPLATE_RESTRICTION_GROUP.PLURAL_FORM,
relations.WORD_HAS_PLURAL_FORM.HAS.value).id), restrictions)
self.assertIn(('hero', storage.restrictions_storage.get_restriction(relations.TEMPLATE_RESTRICTION_GROUP.PLURAL_FORM,
relations.WORD_HAS_PLURAL_FORM.HAS_NO.value).id), restrictions)
hero_mock = mock.Mock(utg_name_form=plural_noun, linguistics_restrictions=lambda: [])
lexicon_key, externals, restrictions = logic.prepair_get_text(key.name, args={'hero': hero_mock, 'level': 1})
self.assertIn(('hero', storage.restrictions_storage.get_restriction(relations.TEMPLATE_RESTRICTION_GROUP.PLURAL_FORM,
relations.WORD_HAS_PLURAL_FORM.HAS.value).id), restrictions)
self.assertNotIn(('hero', storage.restrictions_storage.get_restriction(relations.TEMPLATE_RESTRICTION_GROUP.PLURAL_FORM,
relations.WORD_HAS_PLURAL_FORM.HAS_NO.value).id), restrictions)
def test_get_text__real(self):
key = keys.LEXICON_KEY.HERO_COMMON_JOURNAL_LEVEL_UP
dictionary = storage.game_dictionary.item
word_1 = utg_words.Word.create_test_word(type=utg_relations.WORD_TYPE.NOUN, prefix=u'w-3-', only_required=True)
word_1.forms[3] = u'дубль'
self.assertEqual(word_1.form(utg_relations.CASE.ACCUSATIVE), u'дубль')
dictionary.add_word(word_1)
TEXT = u'[hero|загл] [level] [дубль|hero|дт]'
template = utg_templates.Template()
template.parse(TEXT, externals=['hero', 'level'])
prototypes.TemplatePrototype.create(key=key,
raw_template=TEXT,
utg_template=template,
verificators=[],
author=None)
# update template errors_status and state to enshure, that it will be loaded in game lexicon
prototypes.TemplatePrototype._db_all().update(errors_status=relations.TEMPLATE_ERRORS_STATUS.NO_ERRORS,
state=relations.TEMPLATE_STATE.IN_GAME)
storage.game_lexicon.refresh()
hero_mock = mock.Mock(utg_name_form=lexicon_dictinonary.DICTIONARY.get_word(u'герой'), linguistics_restrictions=lambda: [])
lexicon_key, externals, restrictions = logic.prepair_get_text(key.name, args={'hero': hero_mock, 'level': 1})
self.assertEqual(logic.render_text(lexicon_key, externals, restrictions),
u'Герой 1 w-3-нс,ед,дт')
word_2 = utg_words.Word.create_test_word(type=utg_relations.WORD_TYPE.NOUN, prefix=u'w-2-', only_required=True)
word_2.forms[1] = u'дубль'
self.assertEqual(word_2.form(utg_relations.CASE.GENITIVE), u'дубль')
dictionary.add_word(word_2)
lexicon_key, externals, restrictions = logic.prepair_get_text(key.name, args={'hero': hero_mock, 'level': 1})
self.assertEqual(logic.render_text(lexicon_key, externals, restrictions),
u'Герой 1 w-2-нс,ед,дт')
def test_get_errors__no_word_errors(self):
key = keys.LEXICON_KEY.HERO_COMMON_JOURNAL_LEVEL_UP
TEXT = u'[hero|загл] [level] [неизвестное слово|hero|вн]'
template = utg_templates.Template()
template.parse(TEXT, externals=['hero'])
# verificators with error that would not be returned becouse of words_errors
verificator_1 = prototypes.Verificator(text=u'абракадабра',
externals={
'hero': (u'героиня', u''),
'level': (1, u'')
})
verificator_2 = prototypes.Verificator(text=u'Рыцарь 5 w-1-ед,вн',
externals={
'hero': (u'рыцарь', u'мн'),
'level': (5, u'')
})
verificator_3 = prototypes.Verificator(text=u'Герой 2 w-1-ед,вн',
externals={
'hero': (u'герой', u''),
'level': (2, u'')
})
verificator_4 = prototypes.Verificator(text=u'',
externals={
'hero':
(u'привидение', u''),
'level': (5, u'')
})
prototype = prototypes.TemplatePrototype.create(key=key,
raw_template=TEXT,
utg_template=template,
verificators=[
verificator_1,
verificator_2,
verificator_3,
verificator_4
],
author=self.account_1)
errors = prototype.get_errors()
self.assertEqual(errors, [u'Неизвестное слово: «неизвестное слово»'])
def clean_template(self):
data = self.cleaned_data['template'].strip()
# TODO: test exceptions
try:
template = utg_templates.Template()
template.parse(data,
externals=[v.value for v in self.key.variables])
except utg_exceptions.WrongDependencyFormatError as e:
raise django_forms.ValidationError(
'Ошибка в формате подстановки: %s' % e.arguments['dependency'])
except utg_exceptions.UnknownVerboseIdError as e:
raise django_forms.ValidationError('Неизвестная форма слова: %s' %
e.arguments['verbose_id'])
except utg_exceptions.ExternalDependecyNotFoundError as e:
raise django_forms.ValidationError('Неизвестная переменная: %s' %
e.arguments['dependency'])
return data
def test_substitute__percent_symbol(self):
TEXT = '[external_1|загл] 1 [w-нс,ед,тв|external_2|буд] 2% [external_2|тв,ед]'
# TEXT = u'[external_2|тв,ед]'
word_1 = words.Word.create_test_word(type=r.WORD_TYPE.NOUN,
prefix='w-',
properties=words.Properties(
r.GENDER.FEMININE,
r.ANIMALITY.INANIMATE))
word_2 = words.Word.create_test_word(type=r.WORD_TYPE.NOUN,
prefix='x-',
properties=words.Properties(
r.GENDER.FEMININE,
r.ANIMALITY.INANIMATE))
word_3 = words.Word.create_test_word(type=r.WORD_TYPE.NOUN,
prefix='y-',
properties=words.Properties(
r.GENDER.FEMININE,
r.ANIMALITY.INANIMATE,
r.NUMBER.PLURAL))
dictionary = Dictionary()
dictionary.add_word(word_1)
dictionary.add_word(word_2)
dictionary.add_word(word_3)
template = templates.Template()
template.parse(TEXT, externals=['external_1', 'external_2'])
result = template.substitute(externals={
'external_1':
dictionary.get_word('x-нс,ед,им'),
'external_2':
dictionary.get_word('y-нс,мн,им'),
},
dictionary=dictionary)
self.assertEqual(result, 'X-нс,ед,им 1 w-нс,мн,им 2% y-нс,мн,тв')
def test_templates_query(self):
key = keys.LEXICON_KEY.HERO_COMMON_JOURNAL_LEVEL_UP
text = '[w-1-ед,им|hero]'
utg_template = utg_templates.Template()
utg_template.parse(text, externals=['hero', 'level'])
template_1 = prototypes.TemplatePrototype.create(
key=key,
raw_template=text,
utg_template=utg_template,
verificators=[],
author=None)
template_2 = prototypes.TemplatePrototype.create(
key=key,
raw_template=text,
utg_template=utg_template,
verificators=[],
author=None)
template_3 = prototypes.TemplatePrototype.create(
key=key,
raw_template=text,
utg_template=utg_template,
verificators=[],
author=None)
prototypes.TemplatePrototype._db_filter(
id__in=[template_1.id, template_2.id]).update(
state=relations.TEMPLATE_STATE.IN_GAME)
self.assertEqual(storage.game_lexicon._templates_query().count(), 0)
prototypes.TemplatePrototype._db_filter(id=template_2.id).update(
errors_status=relations.TEMPLATE_ERRORS_STATUS.NO_ERRORS)
self.assertEqual(storage.game_lexicon._templates_query().count(), 1)
prototypes.TemplatePrototype._db_filter(id=template_3.id).update(
errors_status=relations.TEMPLATE_ERRORS_STATUS.NO_ERRORS)
self.assertEqual(storage.game_lexicon._templates_query().count(), 1)
def fill_empty_keys_with_fake_phrases(prefix):
from utg import templates as utg_templates
models.Template.objects.filter(raw_template__startswith=prefix).delete()
for i, key in enumerate(keys.LEXICON_KEY.records):
if key not in game_lexicon._item:
text = '%s-%d' % (prefix, i)
template = utg_templates.Template()
template.parse(text, externals=[v.value for v in key.variables])
prototype = prototypes.TemplatePrototype.create(key=key,
raw_template=text,
utg_template=template,
verificators=[],
state=relations.TEMPLATE_STATE.IN_GAME,
author=None)
verifiactos = prototype.get_all_verificatos()
for verificator in verifiactos:
verificator.text = text
prototype.update(verificators=verifiactos)
game_lexicon.refresh()
def test_get_errors__duplicate_word(self):
key = keys.LEXICON_KEY.HERO_COMMON_JOURNAL_LEVEL_UP
dictionary = storage.game_dictionary.item
word_1 = utg_words.Word.create_test_word(type=utg_relations.WORD_TYPE.NOUN, prefix='w-1-', only_required=True)
word_1.forms[2] = 'дубль'
self.assertEqual(word_1.form(utg_relations.CASE.DATIVE), 'дубль')
word_2 = utg_words.Word.create_test_word(type=utg_relations.WORD_TYPE.NOUN, prefix='w-2-', only_required=True)
word_2.forms[2] = 'дубль'
self.assertEqual(word_2.form(utg_relations.CASE.DATIVE), 'дубль')
dictionary.add_word(word_1)
dictionary.add_word(word_2)
TEXT = '[hero|загл] [level] [дубль|hero|дт]'
template = utg_templates.Template()
template.parse(TEXT, externals=['hero'])
# verificators with error that would not be returned becouse of words_errors
verificator_1 = prototypes.Verificator(text='Героиня 1 дубль', externals={'hero': ('героиня', ''), 'level': (1, '')})
verificator_2 = prototypes.Verificator(text='Рыцари 5 w-1-нс,мн,дт', externals={'hero': ('рыцарь', 'мн'), 'level': (5, '')})
verificator_3 = prototypes.Verificator(text='Герой 2 дубль', externals={'hero': ('герой', ''), 'level': (2, '')})
verificator_4 = prototypes.Verificator(text='Привидение 5 дубль', externals={'hero': ('привидение', ''), 'level': (5, '')})
prototype = prototypes.TemplatePrototype.create(key=key,
raw_template=TEXT,
utg_template=template,
verificators=[verificator_1, verificator_2, verificator_3, verificator_4],
author=self.account_1)
errors = prototype.get_errors()
self.assertEqual(errors, [])
u'играми', u'играх', u'игры', u'игр', u'играм',
u'игры', u'играми', u'играх'
],
properties=words.Properties(r.ANIMALITY.INANIMATE,
r.GENDER.FEMININE))
action_word = words.Word(
type=r.WORD_TYPE.VERB,
forms=[u'дать', u'дал', u'дало', u'дала', u'дали'] + [u''] *
(len(data.WORDS_CACHES[r.WORD_TYPE.VERB]) - 5),
properties=words.Properties(r.ASPECT.PERFECTIVE, r.VOICE.DIRECT))
action_word.autofill_missed_forms()
test_dictionary = dictionary.Dictionary(words=[games_word, action_word])
template = templates.Template()
template.parse(u'[Npc] [дал|npc] [hero|дт] [games] [игра|games|вн].',
externals=('hero', 'npc', 'games'))
hero = words.WordForm(
words.Word(type=r.WORD_TYPE.NOUN,
forms=[
u'герой', u'героя', u'герою', u'героя', u'героем', u'герое',
u'герои', u'героев', u'героям', u'героев', u'героями',
u'героях', u'герои', u'героев', u'героям', u'героев',
u'героями', u'героях'
],
properties=words.Properties(r.ANIMALITY.ANIMATE,
r.GENDER.MASCULINE)))
def test_init(self):
template = templates.Template()
self.assertEqual(template._substitutions, [])
self.assertEqual(template.template, None)
def setUp(self):
super(GiveRewardForTemplateTests, self).setUp()
create_test_map()
self.account_1 = self.accounts_factory.create_account()
self.account_2 = self.accounts_factory.create_account()
self.account_3 = self.accounts_factory.create_account()
self.account_4 = self.accounts_factory.create_account()
cards_tt_api.debug_clear_service()
pm_tt_api.debug_clear_service()
logic.sync_static_restrictions()
storage.game_dictionary.refresh()
storage.game_lexicon.refresh()
TEXT = '[hero|загл] [level] [дубль|hero|дт]'
utg_template = utg_templates.Template()
utg_template.parse(TEXT, externals=['hero', 'level'])
self.template_1 = prototypes.TemplatePrototype.create(
key=keys.LEXICON_KEY.random(),
raw_template=TEXT,
utg_template=utg_template,
verificators=[],
author=None,
state=relations.TEMPLATE_STATE.REMOVED)
self.template_2 = prototypes.TemplatePrototype.create(
key=keys.LEXICON_KEY.random(),
raw_template=TEXT,
utg_template=utg_template,
verificators=[],
author=self.account_2,
state=relations.TEMPLATE_STATE.REMOVED)
prototypes.ContributionPrototype.create(
type=relations.CONTRIBUTION_TYPE.TEMPLATE,
account_id=self.account_2.id,
entity_id=self.template_2.id,
source=relations.CONTRIBUTION_SOURCE.PLAYER,
state=relations.CONTRIBUTION_STATE.IN_GAME)
self.template_3 = prototypes.TemplatePrototype.create(
key=keys.LEXICON_KEY.random(),
raw_template=TEXT,
utg_template=utg_template,
verificators=[],
author=self.account_3,
state=relations.TEMPLATE_STATE.REMOVED)
prototypes.ContributionPrototype.create(
type=relations.CONTRIBUTION_TYPE.TEMPLATE,
account_id=self.account_3.id,
entity_id=self.template_3.id,
source=relations.CONTRIBUTION_SOURCE.PLAYER,
state=relations.CONTRIBUTION_STATE.IN_GAME)
self.non_author_contribution = prototypes.ContributionPrototype.create(
type=relations.CONTRIBUTION_TYPE.TEMPLATE,
account_id=self.account_4.id,
entity_id=self.template_2.id,
source=relations.CONTRIBUTION_SOURCE.PLAYER,
state=relations.CONTRIBUTION_STATE.IN_GAME)
properties=words.Properties(r.ANIMALITY.ANIMATE,
r.GENDER.FEMININE)))
eleph = words.WordForm(
words.Word(type=r.WORD_TYPE.NOUN,
forms=[
u'слон', u'слона', u'слону', u'слона', u'слоном', u'слоне',
u'слоны', u'слонов', u'слонам', u'слонов', u'слонами',
u'слонах', u'слоны', u'слонов', u'слонам', u'слонов',
u'слонами', u'слонах'
],
properties=words.Properties(r.ANIMALITY.ANIMATE,
r.GENDER.MASCULINE)))
#создаем шаблон
template1 = templates.Template()
template2 = templates.Template()
template3 = templates.Template()
template1.parse(
u'[fairy] [подарил|fairy] [hero|дт] [coins] [монета|coins|вн].',
externals=('hero', 'fairy', 'coins'))
result1 = template1.substitute(externals={
'hero': hero,
'fairy': fairy,
'coins': constructors.construct_integer(125)
},
dictionary=test_dictionary)
template2.parse(
u'[fairy] и [eleph] [подарил|мн] [hero|дт] [coins] [монета|coins|вн].',
externals=('hero', 'eleph', 'fairy', 'coins'))
def test_full_usage(self):
# описываем существительное для словаря
coins_word = words.Word(
type=r.WORD_TYPE.NOUN,
forms=[
'монета',
'монеты',
'монете',
'монету',
'монетой',
'монете', # единственнео число
'монеты',
'монет',
'монетам',
'монеты',
'монетами',
'монетах', # множественное число
'монеты',
'монет',
'монетам',
'монеты',
'монетами',
'монетах'
], # счётное число (заполнено для пример, может быть заполнено методом autofill_missed_forms)
properties=words.Properties(
r.ANIMALITY.INANIMATE,
r.GENDER.FEMININE)) # свойства: неодушевлённое, женский род
# описываем глагол для словаря
action_word = words.Word(
type=r.WORD_TYPE.VERB,
# описываем только нужны нам формы слова (порядок важен и определён в utg.data.WORDS_CACHES[r.WORD_TYPE.VERB])
forms=['подарить', 'подарил', 'подарило', 'подарила', 'подарили'] +
[''] * (len(data.WORDS_CACHES[r.WORD_TYPE.VERB]) - 5),
properties=words.Properties(r.ASPECT.PERFECTIVE, r.VOICE.DIRECT))
action_word.autofill_missed_forms(
) # заполняем пропущенные формы на основе введённых (выбираются наиболее близкие)
# создаём словарь для использования в шаблонах
test_dictionary = dictionary.Dictionary(
words=[coins_word, action_word])
# создаём шаблон
template = templates.Template()
# externals — внешние переменные, не обязаны быть в словаре
template.parse(
'[Npc] [подарил|npc] [hero|дт] [coins] [монета|coins|вн].',
externals=('hero', 'npc', 'coins'))
# описываем внешние переменные
hero = words.WordForm(
words.Word(type=r.WORD_TYPE.NOUN,
forms=[
'герой', 'героя', 'герою', 'героя', 'героем',
'герое', 'герои', 'героев', 'героям', 'героев',
'героями', 'героях', 'герои', 'героев', 'героям',
'героев', 'героями', 'героях'
],
properties=words.Properties(r.ANIMALITY.ANIMATE,
r.GENDER.MASCULINE)))
npc = words.WordForm(
words.Word(type=r.WORD_TYPE.NOUN,
forms=[
'русалка', 'русалки', 'русалке', 'русалку',
'русалкой', 'русалке', 'русалки', 'русалок',
'русалкам', 'русалок', 'русалками', 'русалках',
'русалки', 'русалок', 'русалкам', 'русалок',
'русалками', 'русалках'
],
properties=words.Properties(r.ANIMALITY.ANIMATE,
r.GENDER.FEMININE)))
# осуществляем подстановку
result = template.substitute(externals={
'hero':
hero,
'npc':
npc,
'coins':
constructors.construct_integer(125)
},
dictionary=test_dictionary)
self.assertEqual(result, 'Русалка подарила герою 125 монет.')
