def _get_percents(self):
"""Return percentages of translation status."""
return (
translation_percent(self.translated, self.total),
translation_percent(self.fuzzy, self.total),
translation_percent(self.failing_checks, self.total),
translation_percent(self.translated_words, self.total_words),
)
def _get_percents(self, lang=None):
"""Return percentages of translation status."""
return (
translation_percent(self.translated, self.total),
translation_percent(self.fuzzy, self.total),
translation_percent(self.failing_checks, self.total),
translation_percent(self.translated_words, self.total_words),
)
def show_project(request, project):
obj = get_project(request, project)
dict_langs = Language.objects.filter(dictionary__project=obj).annotate(
Count('dictionary'))
if request.method == 'POST' and can_edit_project(request.user, obj):
settings_form = ProjectSettingsForm(request.POST, instance=obj)
if settings_form.is_valid():
settings_form.save()
messages.success(request, _('Settings saved'))
return redirect(obj)
else:
messages.error(
request,
_('Invalid settings, please check the form for errors!'))
else:
settings_form = ProjectSettingsForm(instance=obj)
last_changes = Change.objects.for_project(obj)[:10]
language_stats = sort_unicode(get_per_language_stats(obj),
lambda tup: force_text(tup[0]))
language_stats = [(tup[0], translation_percent(tup[1], tup[2]),
translation_percent(tup[3], tup[4]))
for tup in language_stats]
return render(
request, 'project.html', {
'object':
obj,
'project':
obj,
'dicts':
dict_langs,
'last_changes':
last_changes,
'last_changes_url':
urlencode({'project': obj.slug}),
'add_user_form':
UserManageForm(),
'settings_form':
settings_form,
'language_stats':
language_stats,
'unit_count':
Unit.objects.filter(translation__subproject__project=obj).count(),
'words_count':
obj.get_total_words(),
'language_count':
Language.objects.filter(
translation__subproject__project=obj).distinct().count(),
'strings_count':
obj.get_total(),
'source_words_count':
obj.get_source_words(),
})
def _get_percents(self):
"""Returns percentages of translation status."""
# No units?
if self.total == 0:
return (100, 0, 0)
return (
translation_percent(self.translated, self.total),
translation_percent(self.fuzzy, self.total),
translation_percent(self.failing_checks, self.total),
)
def _get_percents(self):
"""Returns percentages of translation status."""
# No units?
if self.total == 0:
return (100, 0, 0)
return (
translation_percent(self.translated, self.total),
translation_percent(self.fuzzy, self.total),
translation_percent(self.failing_checks, self.total),
)
def show_project(request, project):
obj = get_project(request, project)
dict_langs = Language.objects.filter(
dictionary__project=obj
).annotate(Count('dictionary'))
last_changes = Change.objects.for_project(obj)[:10]
language_stats = sort_unicode(
get_per_language_stats(obj), lambda tup: force_text(tup[0])
)
language_stats = [
(
tup[0],
translation_percent(tup[1], tup[2]),
translation_percent(tup[3], tup[4])
)
for tup in language_stats
]
if can_translate(request.user, project=obj):
replace_form = ReplaceForm()
else:
replace_form = None
return render(
request,
'project.html',
{
'allow_index': True,
'object': obj,
'project': obj,
'dicts': dict_langs,
'last_changes': last_changes,
'last_changes_url': urlencode(
{'project': obj.slug}
),
'language_stats': language_stats,
'unit_count': Unit.objects.filter(
translation__subproject__project=obj
).count(),
'words_count': obj.get_total_words(),
'language_count': Language.objects.filter(
translation__subproject__project=obj
).distinct().count(),
'strings_count': obj.get_total(),
'source_words_count': obj.get_source_words(),
'search_form': SearchForm(),
'replace_form': replace_form,
}
)
def get_project_stats(project):
"""Return stats for project"""
return [{
'language': force_text(tup[0]),
'code': tup[0].code,
'total': tup[2],
'translated': tup[1],
'translated_percent': translation_percent(tup[1], tup[2]),
'total_words': tup[4],
'translated_words': tup[3],
'words_percent': translation_percent(tup[3], tup[4])
} for tup in get_per_language_stats(project)]
def get_project_stats(project):
"""Return stats for project"""
return [
{
'language': force_text(tup[0]),
'code': tup[0].code,
'total': tup[2],
'translated': tup[1],
'translated_percent': translation_percent(tup[1], tup[2]),
'total_words': tup[4],
'translated_words': tup[3],
'words_percent': translation_percent(tup[3], tup[4])
}
for tup in get_per_language_stats(project)
]
def get_percents(self, project=None, subproject=None, language=None):
"""
Returns tuple consting of status percents -
(translated, fuzzy, failing checks)
"""
# Filter translations
translations = self
if project is not None:
translations = translations.filter(subproject__project=project)
if subproject is not None:
translations = translations.filter(subproject=subproject)
if language is not None:
translations = translations.filter(language=language)
# Aggregate
translations = translations.aggregate(Sum("translated"), Sum("fuzzy"), Sum("failing_checks"), Sum("total"))
total = translations["total__sum"]
# Catch no translations (division by zero)
if total == 0 or total is None:
return (0, 0, 0)
# Fetch values
result = [translations["translated__sum"], translations["fuzzy__sum"], translations["failing_checks__sum"]]
# Calculate percent
return tuple([translation_percent(value, total) for value in result])
def calculate_percents(self, item):
"""Calculate percent value for given item."""
base = item[:-8]
if base.endswith('_words'):
total = self.all_words
else:
total = self.all
self.store(item, translation_percent(getattr(self, base), total))
def show_language(request, lang):
try:
obj = Language.objects.get(code=lang)
except Language.DoesNotExist:
obj = Language.objects.fuzzy_get(lang)
if isinstance(obj, Language):
return redirect(obj)
raise Http404('No Language matches the given query.')
last_changes = Change.objects.last_changes(request.user).filter(
translation__language=obj
)[:10]
projects = Project.objects.all_acl(request.user)
dicts = projects.filter(
dictionary__language=obj
).distinct()
projects = projects.filter(
subproject__translation__language=obj
).distinct()
for project in projects:
stats = get_per_language_stats(project, obj)
project.language_stats = (
translation_percent(stats[0][1], stats[0][2]),
translation_percent(stats[0][3], stats[0][4])
)
return render(
request,
'language.html',
{
'allow_index': True,
'object': obj,
'last_changes': last_changes,
'last_changes_url': urlencode({'lang': obj.code}),
'dicts': dicts,
'projects': projects,
}
)
def get_percents(self, project=None, subproject=None, language=None):
"""Return tuple consting of status percents:
(translated, fuzzy, failing checks)
"""
# Filter translations
translations = self
if project is not None:
translations = translations.filter(subproject__project=project)
if subproject is not None:
translations = translations.filter(subproject=subproject)
if language is not None:
translations = translations.filter(language=language)
# Aggregate
translations = translations.aggregate(
Sum('translated'),
Sum('fuzzy'),
Sum('failing_checks'),
Sum('total'),
Sum('translated_words'),
Sum('total_words'),
)
total = translations['total__sum']
words = translations['total_words__sum']
translated_words = translations['translated_words__sum']
# Fetch values
result = [
translations['translated__sum'],
translations['fuzzy__sum'],
translations['failing_checks__sum'],
]
# Calculate percent
return tuple(
[translation_percent(value, total) for value in result] +
[translation_percent(translated_words, words)]
)
def get_percents(self, project=None, subproject=None, language=None):
"""Return tuple consting of status percents:
(translated, fuzzy, failing checks)
"""
# Filter translations
translations = self
if project is not None:
translations = translations.filter(subproject__project=project)
if subproject is not None:
translations = translations.filter(subproject=subproject)
if language is not None:
translations = translations.filter(language=language)
# Aggregate
translations = translations.aggregate(
Sum('translated'),
Sum('fuzzy'),
Sum('failing_checks'),
Sum('total'),
Sum('translated_words'),
Sum('total_words'),
)
total = translations['total__sum']
words = translations['total_words__sum']
translated_words = translations['translated_words__sum']
# Fetch values
result = [
translations['translated__sum'],
translations['fuzzy__sum'],
translations['failing_checks__sum'],
]
# Calculate percent
return tuple(
[translation_percent(value, total) for value in result] +
[translation_percent(translated_words, words)]
)
def calculate_percents(self, item, total=None):
"""Calculate percent value for given item."""
base = item[:-8]
if total is None:
if base.endswith('_words'):
total = self.all_words
else:
total = self.all
if self.has_review:
completed = {'approved', 'approved_words'}
else:
completed = {'translated', 'translated_words'}
return translation_percent(getattr(self, base), total, base in completed)
def show_project(request, project):
obj = get_project(request, project)
dict_langs = Dictionary.objects.filter(project=obj).values_list(
'language', flat=True).distinct()
if request.method == 'POST' and can_edit_project(request.user, obj):
settings_form = ProjectSettingsForm(request.POST, instance=obj)
if settings_form.is_valid():
settings_form.save()
messages.success(request, _('Settings saved'))
return redirect(obj)
else:
messages.error(
request,
_('Invalid settings, please check the form for errors!'))
else:
settings_form = ProjectSettingsForm(instance=obj)
dicts = []
for language in Language.objects.filter(id__in=dict_langs):
dicts.append({
'language':
language,
'count':
Dictionary.objects.filter(language=language, project=obj).count(),
})
last_changes = Change.objects.prefetch().filter(
Q(translation__subproject__project=obj)
| Q(dictionary__project=obj))[:10]
language_stats = sort_unicode(get_per_language_stats(obj),
lambda tup: force_text(tup[0]))
language_stats = [(tup[0], translation_percent(tup[1], tup[2]))
for tup in language_stats]
return render(
request, 'project.html', {
'object': obj,
'project': obj,
'dicts': dicts,
'last_changes': last_changes,
'last_changes_url': urlencode({'project': obj.slug}),
'add_user_form': UserManageForm(),
'settings_form': settings_form,
'language_stats': language_stats,
})
def calculate_percents(self, item):
"""Calculate percent value for given item."""
base = item[:-8]
if base.endswith('_words'):
total = self.all_words
else:
total = self.all
if self.has_review:
completed = {'approved', 'approved_words'}
else:
completed = {'translated', 'translated_words'}
self.store(
item,
translation_percent(getattr(self, base), total, base in completed)
)
def calculate_percents(self, item):
"""Calculate percent value for given item."""
base = item[:-8]
if base.endswith('_words'):
total = self.all_words
else:
total = self.all
self.store(
item,
translation_percent(
getattr(self, base), total,
(base == 'approved') if self.has_review
else (base == 'translated')
)
)
def get_percents(self, project=None, subproject=None, language=None):
'''
Returns tuple consting of status percents -
(translated, fuzzy, failing checks)
'''
# Filter translations
translations = self
if project is not None:
translations = translations.filter(subproject__project=project)
if subproject is not None:
translations = translations.filter(subproject=subproject)
if language is not None:
translations = translations.filter(language=language)
# Aggregate
translations = translations.aggregate(
Sum('translated'),
Sum('fuzzy'),
Sum('failing_checks'),
Sum('total'),
)
total = translations['total__sum']
# Catch no translations (division by zero)
if total == 0 or total is None:
return (100, 0, 0)
# Fetch values
result = [
translations['translated__sum'],
translations['fuzzy__sum'],
translations['failing_checks__sum'],
]
# Calculate percent
return tuple([translation_percent(value, total) for value in result])
def get_percents(self, project=None, subproject=None, language=None):
'''
Returns tuple consting of status percents -
(translated, fuzzy, failing checks)
'''
# Filter translations
translations = self
if project is not None:
translations = translations.filter(subproject__project=project)
if subproject is not None:
translations = translations.filter(subproject=subproject)
if language is not None:
translations = translations.filter(language=language)
# Aggregate
translations = translations.aggregate(
Sum('translated'),
Sum('fuzzy'),
Sum('failing_checks'),
Sum('total'),
)
total = translations['total__sum']
# Catch no translations (division by zero)
if total == 0 or total is None:
return (100, 0, 0)
# Fetch values
result = [
translations['translated__sum'],
translations['fuzzy__sum'],
translations['failing_checks__sum'],
]
# Calculate percent
return tuple([translation_percent(value, total) for value in result])
def get_fuzzy_words_percent(self):
if self.total_words == 0:
return 0
return translation_percent(self.fuzzy_words, self.total_words)
def test_almost_translated_file(self):
self.assertAlmostEqual(translation_percent(99999999, 100000000), 99.9)
def test_translated_file(self):
self.assertAlmostEqual(translation_percent(100, 100), 100.0)
def test_almost_untranslated_file(self):
self.assertAlmostEqual(translation_percent(1, 10000000000), 0.1)
def test_none(self):
self.assertAlmostEqual(translation_percent(0, None), 0.0)
def get_fuzzy_words_percent(self):
if self.total_words == 0:
return 0
return translation_percent(self.fuzzy_words, self.total_words)
def show_project(request, project):
obj = get_project(request, project)
dict_langs = Dictionary.objects.filter(
project=obj
).values_list(
'language', flat=True
).distinct()
if request.method == 'POST' and can_edit_project(request.user, obj):
settings_form = ProjectSettingsForm(request.POST, instance=obj)
if settings_form.is_valid():
settings_form.save()
messages.success(request, _('Settings saved'))
return redirect(obj)
else:
messages.error(
request,
_('Invalid settings, please check the form for errors!')
)
else:
settings_form = ProjectSettingsForm(instance=obj)
dicts = []
for language in Language.objects.filter(id__in=dict_langs):
dicts.append(
{
'language': language,
'count': Dictionary.objects.filter(
language=language,
project=obj
).count(),
}
)
last_changes = Change.objects.for_project(obj)[:10]
language_stats = sort_unicode(
get_per_language_stats(obj), lambda tup: force_text(tup[0])
)
language_stats = [
(
tup[0],
translation_percent(tup[1], tup[2]),
translation_percent(tup[3], tup[4])
)
for tup in language_stats
]
return render(
request,
'project.html',
{
'object': obj,
'project': obj,
'dicts': dicts,
'last_changes': last_changes,
'last_changes_url': urlencode(
{'project': obj.slug}
),
'add_user_form': UserManageForm(),
'settings_form': settings_form,
'language_stats': language_stats,
}
)
def test_almost_translated_file(self):
self.assertAlmostEqual(translation_percent(99999999, 100000000), 99.9)
def test_translated_file(self):
self.assertAlmostEqual(translation_percent(100, 100), 100.0)
def test_almost_untranslated_file(self):
self.assertAlmostEqual(translation_percent(1, 10000000000), 0.1)
def test_none(self):
self.assertAlmostEqual(translation_percent(0, None), 0.0)
def test_empty(self):
self.assertAlmostEqual(translation_percent(0, 0), 100.0)
def test_common(self):
self.assertAlmostEqual(translation_percent(2, 4), 50.0)
def get_failing_checks_words_percent(self):
if self.total_words == 0:
return 0
return translation_percent(self.failing_checks_words, self.total_words)
def test_common(self):
self.assertAlmostEqual(translation_percent(2, 4), 50.0)
def test_empty(self):
self.assertAlmostEqual(translation_percent(0, 0), 100.0)
def show_project(request, project):
obj = get_project(request, project)
dict_langs = Language.objects.filter(
dictionary__project=obj
).annotate(Count('dictionary'))
if request.method == 'POST' and can_edit_project(request.user, obj):
settings_form = ProjectSettingsForm(request.POST, instance=obj)
if settings_form.is_valid():
settings_form.save()
messages.success(request, _('Settings saved'))
return redirect(obj)
else:
messages.error(
request,
_('Invalid settings, please check the form for errors!')
)
else:
settings_form = ProjectSettingsForm(instance=obj)
last_changes = Change.objects.for_project(obj)[:10]
language_stats = sort_unicode(
get_per_language_stats(obj), lambda tup: force_text(tup[0])
)
language_stats = [
(
tup[0],
translation_percent(tup[1], tup[2]),
translation_percent(tup[3], tup[4])
)
for tup in language_stats
]
if can_translate(request.user, project=obj):
replace_form = ReplaceForm()
else:
replace_form = None
return render(
request,
'project.html',
{
'allow_index': True,
'object': obj,
'project': obj,
'dicts': dict_langs,
'last_changes': last_changes,
'last_changes_url': urlencode(
{'project': obj.slug}
),
'settings_form': settings_form,
'language_stats': language_stats,
'unit_count': Unit.objects.filter(
translation__subproject__project=obj
).count(),
'words_count': obj.get_total_words(),
'language_count': Language.objects.filter(
translation__subproject__project=obj
).distinct().count(),
'strings_count': obj.get_total(),
'source_words_count': obj.get_source_words(),
'search_form': SearchForm(),
'replace_form': replace_form,
}
)
def get_failing_checks_words_percent(self):
if self.total_words == 0:
return 0
return translation_percent(self.failing_checks_words, self.total_words)
