def get_context_data(self, **kwargs):
context = super(LanguageTeamAdminFormView,
self).get_context_data(**kwargs)
form = context["form"]
context["tps"] = self.language.translationproject_set.exclude(
project__disabled=True)
stats = self.language.data_tool.get_stats(include_children=False,
user=self.request.user)
keys = ("total", "critical", "incomplete", "translated", "fuzzy",
"untranslated")
for k in keys:
if k in stats:
stats[k + "_display"] = formatter.number(stats[k])
context["stats"] = stats
context["suggestions"] = form.language_team.suggestions.count()
context["suggestions_display"] = formatter.number(
context["suggestions"])
context["language"] = self.language
context["page"] = "admin-team"
context["browse_url"] = reverse(
"pootle-language-browse",
kwargs=dict(language_code=self.language.code))
context["translate_url"] = reverse(
"pootle-language-translate",
kwargs=dict(language_code=self.language.code))
return context
def get_context_data(self, **kwargs):
context = super(LanguageTeamAdminFormView, self).get_context_data(**kwargs)
form = context["form"]
context["tps"] = self.language.translationproject_set.exclude(
project__disabled=True)
stats = self.language.data_tool.get_stats(
include_children=False,
user=self.request.user)
keys = ("total", "critical", "incomplete", "translated", "fuzzy",
"untranslated")
for k in keys:
if k in stats:
stats[k + "_display"] = formatter.number(stats[k])
context["stats"] = stats
context["suggestions"] = form.language_team.suggestions.count()
context["suggestions_display"] = formatter.number(
context["suggestions"])
context["language"] = self.language
context["page"] = "admin-team"
context["browse_url"] = reverse(
"pootle-language-browse",
kwargs=dict(language_code=self.language.code))
context["translate_url"] = reverse(
"pootle-language-translate",
kwargs=dict(language_code=self.language.code))
return context
def __iter__(self):
for score in self.top_scores:
score_data = dict(user=DisplayUser(score["user__username"],
score["user__full_name"],
score["user__email"]),
total_score=score["score__sum"],
public_total_score=formatter.number(
int(round(score["score__sum"]))))
for k in ["translated", "reviewed", "suggested"]:
score_data[k] = formatter.number(
int(round(score["%s__sum" % k])))
yield self.format_score(score_data)
def __iter__(self):
for score in self.top_scores:
score_data = dict(
user=DisplayUser(
score["user__username"],
score["user__full_name"],
score["user__email"]),
total_score=score["score__sum"],
public_total_score=formatter.number(
int(round(score["score__sum"]))))
for k in ["translated", "reviewed", "suggested"]:
score_data[k] = formatter.number(
int(round(score["%s__sum" % k])))
yield self.format_score(score_data)
def checks_by_category(self):
_checks = []
for check in self.check_schema:
if check["code"] not in self.check_data:
continue
check["count"] = self.check_data[check["code"]]
check["count_display"] = formatter.number(check["count"])
_checks.append(check)
return _checks
def checks_by_category(self):
_checks = []
for check in self.check_schema:
if check["code"] not in self.check_data:
continue
check["count"] = self.check_data[check["code"]]
check["count_display"] = formatter.number(check["count"])
_checks.append(check)
return _checks
def _test_scores(ns, context, score_data):
today = localdate()
assert score_data.context == context
assert (
score_data.get_daterange(30)
== (today - timedelta(days=30), today))
assert score_data.ns == "pootle.score.%s" % ns
assert score_data.sw_version == PootleScoreConfig.version
assert list(score_data.score_model.order_by("id")) == list(
UserTPScore.objects.exclude(
user__username__in=User.objects.META_USERS).order_by("id"))
assert (
list(score_data.scores_within_days(5))
== list(score_data.score_model.filter(
date__range=score_data.get_daterange(5))))
assert (
list(score_data.get_scores(5))
== list(score_data.filter_scores(score_data.scores_within_days(5))))
assert (
list(score_data.get_top_scorers(10))
== list(
score_data.get_scores(10).order_by("user__username").values(
"user__username", "user__email", "user__full_name").annotate(
Sum("score"),
Sum("suggested"),
Sum("reviewed"),
Sum("translated")).filter(
score__sum__gt=0).order_by("-score__sum")))
assert (
tuple(score_data.top_scorers)
== tuple(score_data.get_top_scorers(30)))
assert (
score_data.revision
== revision.get(context.directory.__class__)(
context.directory).get(key="stats"))
score_display = score_data.display()
assert isinstance(score_display, TopScoreDisplay)
for i, item in enumerate(score_display):
data = score_data.top_scorers[i]
assert item["public_total_score"] == formatter.number(
round(data["score__sum"]))
assert isinstance(item["user"], DisplayUser)
assert item["user"].username == data["user__username"]
assert item["user"].full_name == data["user__full_name"]
assert item["user"].email == data["user__email"]
score_display = score_data.display(limit=1)
assert len(list(score_display)) <= 1
def states(self):
states = get_translation_states(self.object)
stats = self.stats
for state in states:
if state["state"] == "untranslated":
if stats["total"]:
stats[state["state"]] = state["count"] = (
stats["total"] - stats["fuzzy"] - stats["translated"])
else:
stats[state["state"]] = state["count"] = stats[state["state"]]
if state.get("count"):
state["count_display"] = formatter.number(state["count"])
state["percent"] = round(
float(state["count"]) / stats["total"], 3)
state["percent_display"] = formatter.percent(
state["percent"], "#,##0.0%")
return states
def states(self):
states = get_translation_states(self.object)
stats = self.stats
for state in states:
if state["state"] == "untranslated":
if stats["total"]:
stats[state["state"]] = state["count"] = (
stats["total"] - stats["fuzzy"] - stats["translated"])
else:
stats[state["state"]] = state["count"] = stats[state["state"]]
if state.get("count"):
state["count_display"] = formatter.number(state["count"])
state["percent"] = round(
float(state["count"]) / stats["total"], 3)
state["percent_display"] = formatter.percent(
state["percent"], "#,##0.0%")
return states
def _test_scores(ns, context, score_data):
today = localdate()
assert score_data.context == context
assert (score_data.get_daterange(30) == (today - timedelta(days=30),
today))
assert score_data.ns == "pootle.score.%s" % ns
assert score_data.sw_version == PootleScoreConfig.version
assert list(score_data.score_model.order_by("id")) == list(
UserTPScore.objects.exclude(
user__username__in=User.objects.META_USERS).order_by("id"))
assert (list(score_data.scores_within_days(5)) == list(
score_data.score_model.filter(
date__range=score_data.get_daterange(5))))
assert (list(score_data.get_scores(5)) == list(
score_data.filter_scores(score_data.scores_within_days(5))))
assert (list(score_data.get_top_scorers(10)) == list(
score_data.get_scores(10).order_by("user__username").values(
"user__username", "user__email", "user__full_name").annotate(
Sum("score"), Sum("suggested"), Sum("reviewed"),
Sum("translated")).filter(
score__sum__gt=0).order_by("-score__sum")))
assert (tuple(score_data.top_scorers) == tuple(
score_data.get_top_scorers(30)))
assert (score_data.revision == revision.get(context.directory.__class__)(
context.directory).get(key="stats"))
score_display = score_data.display()
assert isinstance(score_display, TopScoreDisplay)
for i, item in enumerate(score_display):
data = score_data.top_scorers[i]
assert item["public_total_score"] == formatter.number(
round(data["score__sum"]))
assert isinstance(item["user"], DisplayUser)
assert item["user"].username == data["user__username"]
assert item["user"].full_name == data["user__full_name"]
assert item["user"].email == data["user__email"]
score_display = score_data.display(limit=1)
assert len(list(score_display)) <= 1
def localize_stats(self, stats):
for k in STAT_KEYS:
if k in stats and isinstance(stats[k], (int, long, float)):
stats[k + '_display'] = formatter.number(stats[k])
def public_score(self):
return formatter.number(round(self.score))
def top_scorers(cls, days=30, language=None, project=None, limit=5,
offset=0):
"""Returns users with the top scores.
:param days: period of days to account for scores.
:param language: limit results to the given language code.
:param project: limit results to the given project code.
:param limit: limit results to this number of users. Values other
than positive numbers will return the entire result set.
"""
cache_kwargs = {
'days': days,
'language': language,
'project': project,
'limit': limit,
'offset': offset,
}
cache_key = make_method_key(cls, 'top_scorers', cache_kwargs)
top_scorers = cache.get(cache_key, None)
if top_scorers is not None:
return top_scorers
now = timezone.now()
past = now + datetime.timedelta(-days)
lookup_kwargs = {
'creation_time__range': [past, now],
}
if language is not None:
lookup_kwargs.update({
'submission__translation_project__language__code':
language,
})
if project is not None:
lookup_kwargs.update({
'submission__translation_project__project__code':
project,
})
meta_user_ids = cls.objects.meta_users().values_list('id', flat=True)
top_scores = ScoreLog.objects.values("user").filter(
**lookup_kwargs
).exclude(
user__pk__in=meta_user_ids,
).annotate(
total_score=Sum('score_delta'),
suggested=Sum(
Case(
When(
action_code=TranslationActionCodes.SUGG_ADDED,
then='wordcount'
),
default=0,
output_field=models.IntegerField()
)
),
translated=Sum(
Case(
When(
translated_wordcount__isnull=False,
then='translated_wordcount'
),
default=0,
output_field=models.IntegerField()
)
),
reviewed=Sum(
Case(
When(
action_code__in=[
TranslationActionCodes.SUGG_REVIEWED_ACCEPTED,
TranslationActionCodes.REVIEWED,
TranslationActionCodes.EDITED,
],
translated_wordcount__isnull=True,
then='wordcount',
),
default=0,
output_field=models.IntegerField()
)
),
).order_by('-total_score')[offset:]
if isinstance(limit, (int, long)) and limit > 0:
top_scores = top_scores[:limit]
users = dict(
(user.id, user)
for user in cls.objects.filter(
pk__in=[item['user'] for item in top_scores]
)
)
top_scorers = []
for item in top_scores:
item['user'] = users[item['user']]
item['public_total_score'] = formatter.number(
round(item['total_score']))
top_scorers.append(item)
cache.set(cache_key, top_scorers, 60)
return top_scorers
def public_score(self):
return formatter.number(round(self.score))
def _format_numbers(numbers):
for k in numbers.keys():
numbers[k] = formatter.number(numbers[k])
def make_display_stat(d, keys=["total", "critical", "incomplete",
"suggestions", "fuzzy", "untranslated"]):
assert isinstance(d, dict)
for k in keys:
if k in d:
d[k + '_display'] = formatter.number(d[k])
def test_number(language, expected):
with override(language):
assert number('1000.5') == expected
def _format_numbers(numbers):
for k in numbers.keys():
numbers[k] = formatter.number(numbers[k])
def localize_stats(self, stats):
for k in STAT_KEYS:
if k in stats and isinstance(stats[k], (int, long, float)):
stats[k + '_display'] = formatter.number(stats[k])
