def test_contributors_get_aware_datetime(): """Get an aware datetime from a valid string.""" iso_datetime = make_aware(parse_datetime("2016-01-24T23:15:22+0000"), tz=pytz.utc) # Test ISO 8601 datetime. assert iso_datetime == get_aware_datetime("2016-01-24T23:15:22+0000", tz=pytz.utc) # Test git-like datetime. assert iso_datetime == get_aware_datetime("2016-01-24 23:15:22 +0000", tz=pytz.utc) # Test just an ISO 8601 date. iso_datetime = make_aware(parse_datetime("2016-01-24T00:00:00+0000"), tz=pytz.utc) assert iso_datetime == get_aware_datetime("2016-01-24", tz=pytz.utc) # Test None. assert get_aware_datetime(None) is None # Test empty string. assert get_aware_datetime("") is None # Test non-empty string. with pytest.raises(ArgumentTypeError): get_aware_datetime("THIS FAILS") # Test blank string. with pytest.raises(ArgumentTypeError): get_aware_datetime(" ")
def test_cmd_contributors(capfd, dummy_contributors, default_contributors_kwargs, contributors_kwargs): """Contributors across the site.""" result_kwargs = default_contributors_kwargs.copy() result_kwargs.update(contributors_kwargs) cmd_args = [] for k in ["project", "language"]: if result_kwargs["%s_codes" % k]: for arg in result_kwargs["%s_codes" % k]: cmd_args.extend(["--%s" % k, arg]) for k in ["since", "until"]: if result_kwargs[k]: cmd_args.extend( ["--%s" % k, result_kwargs[k]]) result_kwargs[k] = make_aware(parse_datetime(result_kwargs[k])) if result_kwargs["sort_by"]: cmd_args.extend(["--sort-by", result_kwargs["sort_by"]]) call_command('contributors', *cmd_args) out, err = capfd.readouterr() assert out.strip() == str( "\n".join( "%s (%s contributions)" % (k, v) for k, v in result_kwargs.items()))
def _get_revision_from_since(self, since): from pootle.core.dateparse import parse_datetime from pootle.core.utils.timezone import make_aware from pootle_statistics.models import Submission if " " in since: since = "%sT%s%s" % tuple(since.split(" ")) since = make_aware(parse_datetime(since)) submissions_qs = Submission.objects.filter(creation_time__lt=since) if self.projects: submissions_qs = submissions_qs.filter( translation_project__project__code__in=self.projects, ) if self.languages: submissions_qs = submissions_qs.filter( translation_project__language__code__in=self.languages, ) submission = submissions_qs.last() if submission is None: return 0 return submission.unit.revision
def toggle_qualitycheck(self, check_id, false_positive, user): check = self.qualitycheck_set.get(id=check_id) if check.false_positive == false_positive: return self.revision = Revision.incr() self.save( reviewed_by=user) check.false_positive = false_positive check.save() # create submission old_value = MUTED new_value = UNMUTED if false_positive: old_value = UNMUTED new_value = MUTED update_time = make_aware(timezone.now()) sub = Submission( creation_time=update_time, translation_project=self.store.translation_project, submitter=user, field=SubmissionFields.NONE, unit=self, type=SubmissionTypes.WEB, old_value=old_value, new_value=new_value, quality_check=check) sub.save()
def get_file_mtime(self): disk_mtime = datetime.datetime.fromtimestamp(self.file.getpomtime()[0]) # set microsecond to 0 for comparing with a time value without # microseconds disk_mtime = make_aware(disk_mtime.replace(microsecond=0)) return disk_mtime
def save(self): comment = self.comment comment.submit_date = make_aware(datetime.now()) comment.save() comment_was_saved.send( sender=comment.__class__, comment=comment)
def add(self, unit, translation, user=None): """Adds a new suggestion to the unit. :param translation: suggested translation text :param user: user who is making the suggestion. If it's ``None``, the ``system`` user will be used. :return: a tuple ``(suggestion, created)`` where ``created`` is a boolean indicating if the suggestion was successfully added. If the suggestion already exists it's returned as well. """ dont_add = ( not filter(None, translation) or translation == unit.target) if dont_add: return (None, False) user = user or User.objects.get_system_user() pending = SuggestionState.objects.get(name="pending") try: suggestion = Suggestion.objects.pending().get( unit=unit, user=user, target_f=translation) return (suggestion, False) except Suggestion.DoesNotExist: suggestion = Suggestion.objects.create( unit=unit, user=user, state_id=pending.id, target=translation, creation_time=make_aware(timezone.now())) return (suggestion, True)
def get_date_interval(month): from pootle.core.utils.timezone import make_aware now = start = end = timezone.now() default_month = start.strftime('%Y-%m') if month is None: month = default_month try: month_datetime = datetime.strptime(month, '%Y-%m') except ValueError: month_datetime = datetime.strptime(default_month, '%Y-%m') start = make_aware(month_datetime) if start < now: if start.month != now.month or start.year != now.year: end = get_max_month_datetime(start) else: end = start start = start.replace(hour=0, minute=0, second=0) end = end.replace(hour=23, minute=59, second=59, microsecond=999999) return [start, end]
def toggle_qualitycheck(self, check_id, false_positive, user): check = self.qualitycheck_set.get(id=check_id) if check.false_positive == false_positive: return check.false_positive = false_positive check.save() self._log_user = user if false_positive: self._save_action = MUTE_QUALITYCHECK else: self._save_action = UNMUTE_QUALITYCHECK # create submission if false_positive: sub_type = SubmissionTypes.MUTE_CHECK else: sub_type = SubmissionTypes.UNMUTE_CHECK sub = Submission(creation_time=make_aware(timezone.now()), translation_project=self.store.translation_project, submitter=user, field=SubmissionFields.NONE, unit=self, store=self.store, type=sub_type, quality_check=check) sub.save() # update timestamp # log user action self.save()
def test_make_aware_use_tz_false(settings): """Tests datetimes are left intact if `USE_TZ` is not in effect.""" settings.USE_TZ = False datetime_object = datetime(2016, 1, 2, 21, 52, 25) assert timezone.is_naive(datetime_object) datetime_aware = make_aware(datetime_object) assert timezone.is_naive(datetime_aware)
def accept_suggestion(self, suggestion, update_unit): accepted = SuggestionState.objects.get(name="accepted") suggestion.state_id = accepted.id suggestion.reviewer = self.reviewer suggestion.review_time = make_aware(timezone.now()) if update_unit: self.update_unit_on_accept(suggestion) suggestion.save()
def test_make_aware(settings): """Tests datetimes can be made aware of timezones.""" settings.USE_TZ = True datetime_object = datetime(2016, 1, 2, 21, 52, 25) assert timezone.is_naive(datetime_object) datetime_aware = make_aware(datetime_object) assert timezone.is_aware(datetime_aware)
def to_datetime(possible_dt): if possible_dt is None: return if isinstance(possible_dt, datetime): return possible_dt if isinstance(possible_dt, date): return make_aware( datetime.combine( possible_dt, datetime.min.time()))
def get_context_data(self, **kwargs): ctx = super().get_context_data(**kwargs) now = make_aware(datetime.now()) ctx.update({"now": now.strftime("%Y-%m-%d %H:%M:%S")}) if self.object.rate > 0: ctx.update({ "paid_task_form": PaidTaskForm(user=self.object), "paid_task_types": PaidTaskTypes, }) return ctx
def test_make_aware_explicit_tz(settings): """Tests datetimes are made aware of the given timezone.""" settings.USE_TZ = True given_timezone = pytz.timezone("Asia/Bangkok") datetime_object = datetime(2016, 1, 2, 21, 52, 25) assert timezone.is_naive(datetime_object) datetime_aware = make_aware(datetime_object, tz=given_timezone) assert timezone.is_aware(datetime_aware) assert datetime_aware.tzinfo.zone == given_timezone.zone
def test_make_aware_explicit_tz(settings): """Tests datetimes are made aware of the given timezone.""" settings.USE_TZ = True given_timezone = pytz.timezone('Asia/Bangkok') datetime_object = datetime(2016, 1, 2, 21, 52, 25) assert timezone.is_naive(datetime_object) datetime_aware = make_aware(datetime_object, tz=given_timezone) assert timezone.is_aware(datetime_aware) assert datetime_aware.tzinfo.zone == given_timezone.zone
def test_make_aware_default_tz(settings): """Tests datetimes are made aware of the configured timezone.""" settings.USE_TZ = True datetime_object = datetime(2016, 1, 2, 21, 52, 25) assert timezone.is_naive(datetime_object) datetime_aware = make_aware(datetime_object) assert timezone.is_aware(datetime_aware) # Not comparing `tzinfo` directly because that depends on the combination of # actual date+times assert datetime_aware.tzinfo.zone == timezone.get_default_timezone().zone
def test_make_aware_default_tz(settings): """Tests datetimes are made aware of the configured timezone.""" settings.USE_TZ = True datetime_object = datetime(2016, 1, 2, 21, 52, 25) assert timezone.is_naive(datetime_object) datetime_aware = make_aware(datetime_object) assert timezone.is_aware(datetime_aware) # Not comparing `tzinfo` directly because that depends on the combination of # actual date+times assert datetime_aware.tzinfo.zone == timezone.get_default_timezone().zone
def sub_unmute_qc(self, **kwargs): quality_check = kwargs["quality_check"] submitter = kwargs["submitter"] _kwargs = dict(creation_time=make_aware(timezone.now()), submitter=submitter, field=SubmissionFields.CHECK, type=SubmissionTypes.WEB, old_value=MUTED, new_value=UNMUTED, quality_check=quality_check) _kwargs.update(kwargs) return self.create_submission(**_kwargs)
def calculate(self, start=None, end=None): if start is None: start = make_aware( datetime.combine( date.today(), datetime.min.time())) calculated_scores = {} scored_events = self.logs.get_events( user=self.user, start=start, end=end) for event in scored_events: self.score_event(event, calculated_scores) return calculated_scores
def get_aware_datetime(dt_string): """Return an aware datetime parsed from a datetime or date string. Datetime or date string can be any format parsable by dateutil.parser.parse """ if not dt_string: return None try: return make_aware(parse_datetime(dt_string)) except ValueError: raise ArgumentTypeError('The provided datetime/date string is not ' 'valid: "%s"' % dt_string)
def get_aware_datetime(dt_string): """Return an aware datetime parsed from a datetime or date string. Datetime or date string can be any format parsable by dateutil.parser.parse """ if not dt_string: return None try: return make_aware(parse_datetime(dt_string)) except ValueError: raise ArgumentTypeError('The provided datetime/date string is not ' 'valid: "%s"' % dt_string)
def get_context_data(self, **kwargs): ctx = super(UserStatsView, self).get_context_data(**kwargs) now = make_aware(datetime.now()) ctx.update({ 'now': now.strftime('%Y-%m-%d %H:%M:%S'), }) if self.object.rate > 0: ctx.update({ 'paid_task_form': PaidTaskForm(user=self.object), 'paid_task_types': PaidTaskTypes, }) return ctx
def sub_unmute_qc(self, **kwargs): quality_check = kwargs["quality_check"] submitter = kwargs["submitter"] _kwargs = dict( creation_time=make_aware(timezone.now()), submitter=submitter, field=SubmissionFields.CHECK, type=SubmissionTypes.WEB, old_value=MUTED, new_value=UNMUTED, quality_check=quality_check) _kwargs.update(kwargs) return self.create_submission(**_kwargs)
def get_context_data(self, **kwargs): ctx = super(UserStatsView, self).get_context_data(**kwargs) now = make_aware(datetime.now()) ctx.update({ 'now': now.strftime('%Y-%m-%d %H:%M:%S'), }) if self.object.rate > 0: ctx.update({ 'paid_task_form': PaidTaskForm(user=self.object), 'paid_task_types': PaidTaskTypes, }) return ctx
def reject_suggestion(self, suggestion): store = suggestion.unit.store suggestion.state_id = self.states["rejected"] suggestion.review_time = make_aware(timezone.now()) suggestion.reviewer = self.reviewer suggestion.save() unit = suggestion.unit if unit.changed: # if the unit is translated and suggestion was rejected # set the reviewer info unit.change.reviewed_by = self.reviewer unit.change.reviewed_on = suggestion.review_time unit.change.save() update_data.send(store.__class__, instance=store)
def get_aware_datetime(dt_string, tz=None): """Return an aware datetime parsed from a datetime or date string. :param dt_string: datetime or date string can be any format parsable by dateutil.parser.parse. :param tz: timezone in which `dt_string` should be considered. """ if not dt_string: return None try: return make_aware(parse_datetime(dt_string), tz=tz) except ValueError: raise ArgumentTypeError('The provided datetime/date string is not ' 'valid: "%s"' % dt_string)
def reject_suggestion(self, suggestion): store = suggestion.unit.store rejected = SuggestionState.objects.get(name="rejected") suggestion.state_id = rejected.id suggestion.review_time = make_aware(timezone.now()) suggestion.reviewer = self.reviewer suggestion.save() unit = suggestion.unit if unit.changed: # if the unit is translated and suggestion was rejected # set the reviewer info unit.change.reviewed_by = self.reviewer unit.change.reviewed_on = suggestion.review_time unit.change.save() update_data.send(store.__class__, instance=store)
def get_aware_datetime(dt_string, tz=None): """Return an aware datetime parsed from a datetime or date string. :param dt_string: datetime or date string can be any format parsable by dateutil.parser.parse. :param tz: timezone in which `dt_string` should be considered. """ if not dt_string: return None try: return make_aware(parse_datetime(dt_string), tz=tz) except ValueError: raise ArgumentTypeError('The provided datetime/date string is not ' 'valid: "%s"' % dt_string)
def get_date_interval(month): now = start = end = timezone.now() if month is None: month = start.strftime('%Y-%m') start = make_aware(datetime.strptime(month, '%Y-%m')) if start < now: if start.month != now.month or start.year != now.year: end = get_max_month_datetime(start) else: end = start start = start.replace(hour=0, minute=0, second=0) end = end.replace(hour=23, minute=59, second=59, microsecond=999999) return [start, end]
def test_score_store_updater_event(store0, admin, member): unit0 = store0.units[0] unit1 = store0.units[1] today = date.today() yesterday = today - timedelta(days=1) class DummyLogs(object): _start = None _end = None _user = None @property def _events(self): return [ LogEvent(unit0, admin, today, "action0", 0), LogEvent(unit0, admin, yesterday, "action1", 1), LogEvent(unit1, member, today, "action2", 2)] def get_events(self, start=None, end=None, user=None, **kwargs): self._start = start self._end = end self._user = user for event in self._events: yield event class DummyScoreUpdater(StoreScoreUpdater): @cached_property def logs(self): return DummyLogs() updater = DummyScoreUpdater(store0) result = updater.calculate() assert updater.logs._start == make_aware( datetime.combine(today, datetime.min.time())) assert updater.logs._end is None assert updater.logs._user is None # no score adapters assert result == {} result = updater.calculate(start=yesterday, end=today) assert updater.logs._start == yesterday assert updater.logs._end == today assert result == {} updater = DummyScoreUpdater(store0, user=admin) updater.calculate() assert updater.logs._user == admin
def get_activity_data(request, user, month): [start, end] = get_date_interval(month) json = {} user_dict = ( { "id": user.id, "username": user.username, "formatted_name": user.formatted_name, "currency": user.currency if user.currency else CURRENCIES[0][0], "rate": user.rate, "review_rate": user.review_rate, "hourly_rate": user.hourly_rate, } if user != "" else user ) now = make_aware(datetime.now()) json["meta"] = { "user": user_dict, "month": month, "now": now.strftime("%Y-%m-%d %H:%M:%S"), "start": start.strftime("%Y-%m-%d"), "end": end.strftime("%Y-%m-%d"), "utc_offset": start.strftime("%z"), "admin_permalink": request.build_absolute_uri(reverse("pootle-reports")), } if user != "": scores = ScoreLog.objects.for_user_in_range(user, start, end) scores = list(scores.order_by("submission__translation_project")) json["grouped"] = get_grouped_word_stats(scores, user, month) scores.sort(key=lambda x: x.creation_time) json["daily"] = get_daily_activity(user, scores, start, end) json["summary"] = get_summary(scores, start, end) tasks = get_paid_tasks(user, start, end) for task in tasks: if settings.USE_TZ: task["datetime"] = timezone.localtime(task["datetime"]) task["datetime"] = task["datetime"].strftime("%Y-%m-%d %H:%M:%S") json["paid_tasks"] = tasks return json
def evernote_reports(request): User = get_user_model() now = make_aware(datetime.now()) ctx = { 'users': jsonify(map( lambda x: {'id': x.username, 'text': escape(x.formatted_name)}, User.objects.hide_meta() )), 'user_rates_form': UserRatesForm(), 'paid_task_form': PaidTaskForm(), 'now': now.strftime('%Y-%m-%d %H:%M:%S'), 'admin_report': True, 'paid_task_types': PaidTaskTypes, } return render_to_response('admin/reports.html', ctx, context_instance=RequestContext(request))
def reports(request): User = get_user_model() now = make_aware(datetime.now()) ctx = { "page": "admin-reports", "users": [ {"id": x.username, "text": x.formatted_name} for x in User.objects.hide_meta() ], "user_rates_form": UserRatesForm(), "paid_task_form": PaidTaskForm(), "now": now.strftime("%Y-%m-%d %H:%M:%S"), "admin_report": True, "paid_task_types": PaidTaskTypes, } return render(request, "admin/reports.html", ctx)
def evernote_reports(request): User = get_user_model() now = make_aware(datetime.now()) ctx = { 'users': jsonify(map( lambda x: {'id': x.username, 'text': escape(x.formatted_name)}, User.objects.hide_meta() )), 'user_rates_form': UserRatesForm(), 'paid_task_form': PaidTaskForm(), 'now': now.strftime('%Y-%m-%d %H:%M:%S'), 'admin_report': True, 'paid_task_types': PaidTaskTypes, } return render_to_response('admin/reports.html', ctx, context_instance=RequestContext(request))
def reject_suggestion(self, suggestion): store = suggestion.unit.store suggestion.state = SuggestionStates.REJECTED suggestion.review_time = make_aware(timezone.now()) suggestion.reviewer = self.reviewer suggestion.save() self.create_submission(suggestion, SubmissionTypes.SUGG_REJECT, self.reviewer, creation_time=suggestion.review_time).save() unit = suggestion.unit if unit.changed: # if the unit is translated and suggestion was rejected # set the reviewer info unit.change.reviewed_by = self.reviewer unit.change.reviewed_on = suggestion.review_time unit.change.save() update_data.send(store.__class__, instance=store)
def get_activity_data(request, user, month): [start, end] = get_date_interval(month) json = {} user_dict = { 'id': user.id, 'username': user.username, 'formatted_name': user.formatted_name, 'currency': user.currency if user.currency else CURRENCIES[0][0], 'rate': user.rate, 'review_rate': user.review_rate, 'hourly_rate': user.hourly_rate, } if user != '' else user now = make_aware(datetime.now()) json['meta'] = { 'user': user_dict, 'month': month, 'now': now.strftime('%Y-%m-%d %H:%M:%S'), 'start': start.strftime('%Y-%m-%d'), 'end': end.strftime('%Y-%m-%d'), 'utc_offset': start.strftime("%z"), 'admin_permalink': request.build_absolute_uri( reverse('pootle-reports')), } if user != '': scores = get_scores(user, start, end) scores = list(scores.order_by(SCORE_TRANSLATION_PROJECT)) json['grouped'] = get_grouped_word_stats(scores, user, month) scores.sort(key=lambda x: x.creation_time) json['daily'] = get_daily_activity(user, scores, start, end) json['summary'] = get_summary(scores, start, end) tasks = get_paid_tasks(user, start, end) for task in tasks: if settings.USE_TZ: task['datetime'] = timezone.localtime(task['datetime']) task['datetime'] = task['datetime'].strftime('%Y-%m-%d %H:%M:%S') json['paid_tasks'] = tasks return json
def save_unit(self): user = self.request_user current_time = make_aware(timezone.now()) updated = [] target = multistring(self.cleaned_data["target_f"] or [u'']) if target != self.unit.target: self.unit.submitted_by = user self.unit.submitted_on = current_time self.unit.reviewed_by = None self.unit.reviewed_on = None updated.append( (SubmissionFields.TARGET, self.unit.target_f, self.cleaned_data["target_f"])) self.unit.target = self.cleaned_data["target_f"] if self.unit.target: if self.cleaned_data["is_fuzzy"]: self.unit.state = FUZZY else: self.unit.state = TRANSLATED else: self.unit.state = UNTRANSLATED self.unit.save( submitted_on=current_time, submitted_by=user, changed_with=SubmissionTypes.WEB) if self.unit.state_updated: updated.append( (SubmissionFields.STATE, self.unit._frozen.state, self.unit.state)) translation_project = self.unit.store.translation_project for field, old_value, new_value in updated: sub = Submission( creation_time=current_time, translation_project=translation_project, submitter=user, unit=self.unit, field=field, type=SubmissionTypes.WEB, old_value=old_value, new_value=new_value) sub.save()
def get_activity_data(request, user, month): [start, end] = get_date_interval(month) json = {} user_dict = { 'id': user.id, 'username': user.username, 'formatted_name': user.formatted_name, 'currency': user.currency if user.currency else CURRENCIES[0][0], 'rate': user.rate, 'review_rate': user.review_rate, 'hourly_rate': user.hourly_rate, } if user != '' else user now = make_aware(datetime.now()) json['meta'] = { 'user': user_dict, 'month': month, 'now': now.strftime('%Y-%m-%d %H:%M:%S'), 'start': start.strftime('%Y-%m-%d'), 'end': end.strftime('%Y-%m-%d'), 'utc_offset': start.strftime("%z"), 'admin_permalink': request.build_absolute_uri( reverse('pootle-reports')), } if user != '': scores = ScoreLog.objects.for_user_in_range(user, start, end) scores = list(scores.order_by(SCORE_TRANSLATION_PROJECT)) json['grouped'] = get_grouped_word_stats(scores, user, month) scores.sort(key=lambda x: x.creation_time) json['daily'] = get_daily_activity(user, scores, start, end) json['summary'] = get_summary(scores, start, end) tasks = get_paid_tasks(user, start, end) for task in tasks: if settings.USE_TZ: task['datetime'] = timezone.localtime(task['datetime']) task['datetime'] = task['datetime'].strftime('%Y-%m-%d %H:%M:%S') json['paid_tasks'] = tasks return json
def test_cmd_contributors(capfd, dummy_contributors, default_contributors_kwargs, contributors_kwargs): """Contributors across the site.""" result_kwargs = default_contributors_kwargs.copy() result_kwargs.update(contributors_kwargs) cmd_args = [] for k in ["project", "language"]: if result_kwargs["%s_codes" % k]: for arg in result_kwargs["%s_codes" % k]: cmd_args.extend(["--%s" % k, arg]) for k in ["since", "until"]: if result_kwargs[k]: cmd_args.extend(["--%s" % k, result_kwargs[k]]) result_kwargs[k] = make_aware(parse_datetime(result_kwargs[k])) if result_kwargs["sort_by"]: cmd_args.extend(["--sort-by", result_kwargs["sort_by"]]) call_command('contributors', *cmd_args) out, err = capfd.readouterr() assert out.strip() == str("\n".join("%s (%s contributions)" % (k, v) for k, v in result_kwargs.items()))
def save_unit(self): current_time = make_aware(timezone.now()) updated = [] if self.cleaned_data["target_f"]: self.unit.target = self.cleaned_data["target_f"] self.unit.save( submitted_on=current_time, submitted_by=self.target_object.user, reviewed_on=current_time, reviewed_by=self.request_user, changed_with=SubmissionTypes.WEB) updated.append( (SubmissionFields.TARGET, self.unit._frozen.target, self.unit.target)) if self.unit.state_updated: updated.append( (SubmissionFields.STATE, self.unit._frozen.state, self.unit.state)) translation_project = self.unit.store.translation_project for field, old_value, new_value in updated: sub = Submission( creation_time=current_time, translation_project=translation_project, suggestion=self.target_object, submitter=self.target_object.user, unit=self.unit, field=field, type=SubmissionTypes.WEB, old_value=old_value, new_value=new_value) sub.save() self.suggestion_review.accept( update_unit=( False if self.cleaned_data["target_f"] else True))
def test_score_event_state_updated(store0, admin, settings): unit = store0.units.first() scoring = event_score.gather(LogEvent) scorer = scoring["state_updated"] assert scorer == scores.StateUpdatedScore sub = Submission.objects.create( unit=unit, submitter=admin, translation_project=unit.store.translation_project, creation_time=make_aware(timezone.now()), old_value=UNTRANSLATED, new_value=TRANSLATED) event = LogEvent( unit, admin, datetime.now(), "example", sub) score = scorer(event) assert score.event == event assert score.unit == unit assert score.submission == sub assert ( score.score == (unit.unit_source.source_wordcount * settings.POOTLE_SCORES["state_translated"])) assert score.translated == unit.unit_source.source_wordcount assert score.reviewed == 0 assert score.suggested == 0 assert ( score.get_score() == dict( score=score.score, translated=unit.unit_source.source_wordcount, reviewed=0, suggested=0)) sub = Submission.objects.create( unit=unit, submitter=admin, translation_project=unit.store.translation_project, creation_time=make_aware(timezone.now()), old_value=FUZZY, new_value=TRANSLATED) event = LogEvent( unit, admin, datetime.now(), "example", sub) score = scorer(event) assert score.event == event assert score.unit == unit assert score.submission == sub assert ( score.score == (unit.unit_source.source_wordcount * settings.POOTLE_SCORES["state_unfuzzy"])) assert score.translated == 0 assert score.reviewed == unit.unit_source.source_wordcount assert score.suggested == 0 assert ( score.get_score() == dict( score=score.score, translated=0, reviewed=unit.unit_source.source_wordcount, suggested=0)) sub = Submission.objects.create( unit=unit, submitter=admin, translation_project=unit.store.translation_project, creation_time=make_aware(timezone.now()), old_value=TRANSLATED, new_value=FUZZY) event = LogEvent( unit, admin, datetime.now(), "example", sub) score = scorer(event) assert score.event == event assert score.unit == unit assert score.submission == sub assert ( score.score == (unit.unit_source.source_wordcount * settings.POOTLE_SCORES["state_fuzzy"])) assert score.translated == 0 assert score.reviewed == unit.unit_source.source_wordcount assert score.suggested == 0 assert ( score.get_score() == dict( score=score.score, translated=0, reviewed=unit.unit_source.source_wordcount, suggested=0))
def save(self): comment = self.comment comment.user = self.cleaned_data["user"] comment.submit_date = make_aware(datetime.now()) comment.save() comment_was_saved.send(sender=comment.__class__, comment=comment)
def handle_unit_pre_save(**kwargs): unit = kwargs["instance"] auto_translated = False was_fuzzy = unit._frozen.state == FUZZY sysuser = get_user_model().objects.get_system_user() if unit.source_updated: # update source related fields unit.source_hash = md5(unit.source_f.encode("utf-8")).hexdigest() unit.source_length = len(unit.source_f) wc = unit.update_wordcount() if not wc and not bool(filter(None, unit.target_f.strings)): # auto-translate untranslated strings unit.target = unit.source unit.state = FUZZY auto_translated = True if unit.target_updated: # update target related fields unit.target_wordcount = unit.counter.count_words( unit.target_f.strings) unit.target_length = len(unit.target_f) if filter(None, unit.target_f.strings): if unit.state == UNTRANSLATED: unit.state = TRANSLATED else: # if it was TRANSLATED then set to UNTRANSLATED if unit.state > FUZZY: unit.state = UNTRANSLATED if was_fuzzy: # set reviewer data if FUZZY has been removed only and # translation hasn't been updated unit.reviewed_on = make_aware(timezone.now()) unit.reviewed_by = unit.reviewed_by or sysuser elif unit.state == FUZZY: # clear reviewer data if unit has been marked as FUZZY unit.reviewed_on = None unit.reviewed_by = None elif unit.state == UNTRANSLATED: # clear reviewer and translator data if translation # has been deleted unit.reviewed_on = None unit.reviewed_by = None unit.submitted_by = None unit.submitted_on = None # Updating unit from the .po file set its revision property to # a new value (the same for all units during its store updated) # since that change doesn't require further sync but note that # auto_translated units require further sync update_revision = ( unit.revision is None or (not unit.revision_updated and (unit.updated and not auto_translated))) if update_revision: unit.revision = Revision.incr() if unit.index is None: unit.index = unit.store.max_index() + 1 unitid = uniqueid.get(unit.__class__)(unit) if unitid.changed: unit.setid(unitid.getid())
def save(self): comment = self.comment comment.user = self.request_user comment.submit_date = make_aware(datetime.now()) comment.save() comment_was_saved.send(sender=comment.__class__, comment=comment)
def dt_yesterday(yesterday): return make_aware(datetime.combine(yesterday, datetime.min.time())).astimezone( pytz.timezone("UTC"))
def test_score_event_state_updated(store0, admin, settings): unit = store0.units.first() scoring = event_score.gather(LogEvent) scorer = scoring["state_updated"] assert scorer == scores.StateUpdatedScore sub = Submission.objects.create( unit=unit, submitter=admin, translation_project=unit.store.translation_project, creation_time=make_aware(timezone.now()), old_value=UNTRANSLATED, new_value=TRANSLATED) event = LogEvent( unit, admin, datetime.now(), "example", sub) score = scorer(event) assert score.event == event assert score.unit == unit assert score.submission == sub assert ( score.score == (unit.source_wordcount * settings.POOTLE_SCORES["state_translated"])) assert score.translated == unit.source_wordcount assert score.reviewed == 0 assert score.suggested == 0 assert ( score.get_score() == dict( score=score.score, translated=unit.source_wordcount, reviewed=0, suggested=0)) sub = Submission.objects.create( unit=unit, submitter=admin, translation_project=unit.store.translation_project, creation_time=make_aware(timezone.now()), old_value=FUZZY, new_value=TRANSLATED) event = LogEvent( unit, admin, datetime.now(), "example", sub) score = scorer(event) assert score.event == event assert score.unit == unit assert score.submission == sub assert ( score.score == (unit.source_wordcount * settings.POOTLE_SCORES["state_unfuzzy"])) assert score.translated == 0 assert score.reviewed == unit.source_wordcount assert score.suggested == 0 assert ( score.get_score() == dict( score=score.score, translated=0, reviewed=unit.source_wordcount, suggested=0)) sub = Submission.objects.create( unit=unit, submitter=admin, translation_project=unit.store.translation_project, creation_time=make_aware(timezone.now()), old_value=TRANSLATED, new_value=FUZZY) event = LogEvent( unit, admin, datetime.now(), "example", sub) score = scorer(event) assert score.event == event assert score.unit == unit assert score.submission == sub assert ( score.score == (unit.source_wordcount * settings.POOTLE_SCORES["state_fuzzy"])) assert score.translated == 0 assert score.reviewed == unit.source_wordcount assert score.suggested == 0 assert ( score.get_score() == dict( score=score.score, translated=0, reviewed=unit.source_wordcount, suggested=0))
class ScoreLogFactory(factory.django.DjangoModelFactory): creation_time = make_aware(timezone.now()) class Meta(object): model = "pootle_statistics.ScoreLog"
class SubmissionFactory(factory.django.DjangoModelFactory): creation_time = make_aware(timezone.now()) class Meta(object): model = 'pootle_statistics.Submission'
def test_score_store_updater_event_score(store0, admin, member, member2): unit0 = store0.units[0] unit1 = store0.units[1] today = localdate() import pytz from pootle.core.utils.timezone import make_aware dt_today = make_aware( datetime.combine( today, datetime.min.time())).astimezone( pytz.timezone("UTC")) yesterday = today - timedelta(days=1) dt_yesterday = make_aware( datetime.combine( yesterday, datetime.min.time())).astimezone( pytz.timezone("UTC")) class DummyLogs(object): _start = None _end = None @cached_property def _events(self): return [ LogEvent(unit0, admin, dt_yesterday, "action0", 0), LogEvent(unit0, admin, dt_yesterday, "action1", 1), LogEvent(unit0, admin, dt_today, "action0", 0), LogEvent(unit0, member2, dt_today, "action1", 1), LogEvent(unit0, member, dt_today, "action2", 2), LogEvent(unit1, member, dt_today, "action2", 3)] def get_events(self, start=None, end=None, **kwargs): self._start = start self._end = end for event in self._events: yield event class DummyScoreUpdater(StoreScoreUpdater): @cached_property def logs(self): return DummyLogs() updater = DummyScoreUpdater(store0) result = updater.calculate() assert result == {} class DummyScore(object): def __init__(self, event): self.event = event def get_score(self): return dict( score=(self.event.value * self.base_score), translated=(7 * self.base_score), reviewed=(23 * self.base_score), suggested=(108 * self.base_score)) class Action0Score(DummyScore): base_score = 0 class Action1Score(DummyScore): base_score = 1 class Action2Score(DummyScore): base_score = 2 def get_score(self): score = super(Action2Score, self).get_score() score["reviewed"] = 0 return score @provider(event_score, sender=LogEvent) def dummy_event_score_provider(**kwargs_): return dict( action0=Action0Score, action1=Action1Score, action2=Action2Score) updater = DummyScoreUpdater(store0) result = updater.calculate() assert len(result) == 2 assert len(result[today]) == 2 assert result[today][member.id] == { 'suggested': 432, 'score': 10, 'translated': 28} assert result[today][member2.id] == { 'suggested': 108, 'score': 1, 'translated': 7, 'reviewed': 23} assert len(result[yesterday]) == 1 assert result[yesterday][admin.id] == { 'suggested': 108, 'score': 1, 'translated': 7, 'reviewed': 23} store0.user_scores.all().delete() updater.update() mem_score = UserStoreScore.objects.filter( store=store0, user=member) assert mem_score.get(date=today).suggested == 432 assert mem_score.get(date=today).score == 10 assert mem_score.get(date=today).translated == 28 assert mem_score.get(date=today).reviewed == 0 today_score = mem_score.get(date=today) today_score.reviewed = 99999 today_score.score = 0 today_score.save() updater.update() assert mem_score.get(date=today).suggested == 432 assert mem_score.get(date=today).score == 10 assert mem_score.get(date=today).translated == 28 assert mem_score.get(date=today).reviewed == 0