def show_signup_progress (game):
status = game.signup_status()
# Signup has already closed
if status == 'complete':
message = _("Signup has closed.")
# Signup during the game
elif game.time_period() == game.signup_time_period():
message = _("Signup is open during the game.")
# If signup has yet to start
elif status == 'inactive':
message = _("Signup opens in {0} and closes {1} later").format(
timeuntil(game.signup_start_time),
timeuntil(game.signup_end_time, now=game.signup_start_time))
# Signup is active
else:
# Signup closes when the game *starts*
if game.signup_end_time == game.start_time:
message = _("Signup closes at the start of the game.")
# Signup closes when the game *ends*
elif game.signup_end_time == game.end_time:
message = _("Signup closes at the end of the game.")
# Signup has not closed yet
else:
message = _("Signup closes in {0}").format(timeuntil(game.signup_end_time))
return {'game': game, 'status': status, 'message': message}
def time_remaining(self):
if self.status == self.OPEN_STATUS:
return timeuntil(
self.bounties().aggregate(Min('ends'))['ends__min'],
datetime.datetime.now()).split(',')[0]
return timeuntil(self.modified + datetime.timedelta(days=3),
datetime.datetime.now()).split(',')[0]
def test_different_timezones(self):
""" When using two different timezones. """
now = datetime.datetime.now()
now_tz = timezone.make_aware(now, timezone.get_default_timezone())
now_tz_i = timezone.localtime(now_tz, timezone.get_fixed_timezone(195))
self.assertEqual(timesince(now), '0\xa0minutes')
self.assertEqual(timesince(now_tz), '0\xa0minutes')
self.assertEqual(timesince(now_tz_i), '0\xa0minutes')
self.assertEqual(timesince(now_tz, now_tz_i), '0\xa0minutes')
self.assertEqual(timeuntil(now), '0\xa0minutes')
self.assertEqual(timeuntil(now_tz), '0\xa0minutes')
self.assertEqual(timeuntil(now_tz_i), '0\xa0minutes')
self.assertEqual(timeuntil(now_tz, now_tz_i), '0\xa0minutes')
def get_timeuntil(self):
"""
Returns a string representing the time until the next
time this Job will be run (actually, the "string" returned
is really an instance of ``ugettext_lazy``).
>>> from chronograph.compatibility.dates import now
>>> job = Job(next_run=now())
>>> job.get_timeuntil().translate('en')
u'due'
"""
if self.disabled:
return _('never (disabled)')
delta = self.next_run - dates.now()
if delta.days < 0:
# The job is past due and should be run as soon as possible
if self.check_is_running():
return _('running')
return _('due')
elif delta.seconds < 60:
# Adapted from django.utils.timesince
count = lambda n: ungettext('second', 'seconds', n)
return ugettext('%(number)d %(type)s') % {'number': delta.seconds,
'type': count(delta.seconds)}
return timeuntil(self.next_run)
def locked_for(self, obj):
if obj.locked_until is None:
return u""
elif obj.locked_until < timezone.now():
return _(u"(expired)")
else:
return timeuntil(obj.locked_until)
def get(self, request, *args, **kwargs):
ctx = self.get_base_context()
if self.curl:
# the "API" version
ip = _get_client_ip(request)
address = kwargs["address"]
if kwargs.get("asset") is None:
return JsonResponse({"message": "You must specify an asset code to send"}, status=400)
for skip_header in settings.WHITELISTED_HEADERS:
header = "HTTP_%s" % skip_header.replace("-", "_")
if header in request.META:
cooldown_at = None
break
else:
cooldown_at = greylisted(address, ip)
if cooldown_at:
return JsonResponse(
{"message": "You are greylisted for another %s" % timeuntil(cooldown_at)}, status=403
)
else:
tx = ctx["faucet"].send(ctx["wallet"], address, ip)
amount = "%s%s" % (ctx["faucet"].sending_amount.normalize(), ctx["faucet"].asset_code)
return JsonResponse(
{
"message": "Request received successfully. %s will be sent to %s" % (amount, address),
"tx": tx.id,
},
status=200,
)
return render(request, "faucet.html", context=ctx)
def get_timeuntil(self):
"""
Returns a string representing the time until the next
time this Job will be run (actually, the "string" returned
is really an instance of ``ugettext_lazy``).
>>> from chronograph.compatibility.dates import now
>>> job = Job(next_run=now())
>>> job.get_timeuntil().translate('en')
u'due'
"""
if self.disabled:
return _('never (disabled)')
delta = self.next_run - dates.now()
if delta.days < 0:
# The job is past due and should be run as soon as possible
if self.check_is_running():
return _('running')
return _('due')
elif delta.seconds < 60:
# Adapted from django.utils.timesince
count = lambda n: ungettext('second', 'seconds', n)
return ugettext('%(number)d %(type)s') % {'number': delta.seconds,
'type': count(delta.seconds)}
return timeuntil(self.next_run)
def locked_for(self, obj):
if obj.locked_until is None:
return u""
elif obj.locked_until < timezone.now():
return _(u"(expired)")
else:
return timeuntil(obj.locked_until)
def timeuntil(value, *args):
if value is None or isinstance(value, Undefined):
return u''
from django.utils.timesince import timeuntil
value = template_localtime(value)
return timeuntil(value, *args)
def receive_transaction_hook_task(account_id, transaction):
account = Account.objects.get(pk=account_id)
if transaction['type'] != 'transaction.created':
return
transaction_utils.store_transaction(account, transaction['data'])
account.current_balance += transaction['data']['amount']
account.save()
if account.nearing_zero_balance():
mondo.insert_feed_item(
account.user,
account.mondo_account_id,
{
'title': "Top up your account in the next %s to avoid running out of money" % (
timeuntil(
account.time_of_zero_balance,
).replace(u'\xa0', u' ')
),
'image_url': settings.SITE_URL + staticfiles_storage.url(
'images/money-with-wings.png',
),
},
)
def test_depth(self):
t = self.t + self.oneyear + self.onemonth + self.oneweek + self.oneday + self.onehour
tests = [
(t, 1, '1\xa0year'),
(t, 2, '1\xa0year, 1\xa0month'),
(t, 3, '1\xa0year, 1\xa0month, 1\xa0week'),
(t, 4, '1\xa0year, 1\xa0month, 1\xa0week, 1\xa0day'),
(t, 5, '1\xa0year, 1\xa0month, 1\xa0week, 1\xa0day, 1\xa0hour'),
(t, 6, '1\xa0year, 1\xa0month, 1\xa0week, 1\xa0day, 1\xa0hour'),
(self.t + self.onehour, 5, '1\xa0hour'),
(self.t + (4 * self.oneminute), 3, '4\xa0minutes'),
(self.t + self.onehour + self.oneminute, 1, '1\xa0hour'),
(self.t + self.oneday + self.onehour, 1, '1\xa0day'),
(self.t + self.oneweek + self.oneday, 1, '1\xa0week'),
(self.t + self.onemonth + self.oneweek, 1, '1\xa0month'),
(self.t + self.oneyear + self.onemonth, 1, '1\xa0year'),
(self.t + self.oneyear + self.oneweek + self.oneday, 3,
'1\xa0year'),
]
for value, depth, expected in tests:
with self.subTest():
self.assertEqual(timesince(self.t, value, depth=depth),
expected)
self.assertEqual(timeuntil(value, self.t, depth=depth),
expected)
def get_timeuntil(self):
"""
Returns a string representing the time until the next
time this Job will be run.
"""
if self.adhoc_run:
return _('ASAP')
elif self.disabled:
return _('never (disabled)')
elif not self.next_run:
return "-"
delta = self.next_run - tz_now()
if delta.days < 0:
# The job is past due and should be run as soon as possible
return _('due')
elif delta.seconds < 60:
# Adapted from django.utils.timesince
count = lambda n: ungettext('second', 'seconds', n)
return ugettext('%(number)d %(type)s') % {
'number': delta.seconds,
'type': count(delta.seconds)
}
return timeuntil(self.next_run)
def handle(self, *args, **options):
unfired = EventFire.objects.filter(
fired=None).select_related("event").order_by("scheduled",
"id")[:50]
self.stdout.write(
"Fire | Event | Contact | Scheduled"
)
self.stdout.write(
"-----------|----------------------------------|------------|--------------"
)
now = timezone.now()
for fire in unfired:
event = truncate(f"{fire.event.id}: {fire.event.name}", 32)
contact = fire.contact_id
if fire.scheduled > now:
scheduled = timeuntil(fire.scheduled, now=now)
else:
scheduled = f"{timesince(fire.scheduled, now=now)} ago"
self.stdout.write(
f"{fire.id:10} | {event:<32} | {contact:10} | {scheduled}")
def get_timeuntil(self):
"""
Returns a string representing the time until the next
time this Job will be run (actually, the "string" returned
is really an instance of ``ugettext_lazy``).
>>> job = Job(next_run=datetime.now())
>>> job.get_timeuntil().translate('en')
u'due'
"""
if not self.enabled:
return _("never (disabled)")
if not self.next_run:
self.next_run = datetime.now()
delta = self.next_run.replace(tzinfo=None) - datetime.now().replace(tzinfo=None)
if delta.days < 0:
# The job is past due and should be run as soon as possible
if self.check_is_running():
return _("running")
return _("due")
elif delta.seconds < 60:
# Adapted from django.utils.timesince
count = lambda n: ungettext("second", "seconds", n)
return ugettext("%(number)d %(type)s") % {"number": delta.seconds, "type": count(delta.seconds)}
return timeuntil(self.next_run)
def post(self, request, *args, **kwargs):
address = request.POST.get("address")
faucet = get_object_or_404(
Faucet, asset_code__iexact=request.POST.get("asset"), visible=True)
faucets = Faucet.objects.filter(visible=True).order_by("asset_code")
ctx = {"address": address, "faucets": faucets, "faucet": faucet}
if not address:
messages.error(request, "You must supply a wallet address")
elif not WALLET_RE.match(address):
messages.error(request,
"That does not seem to be a valid wallet address")
else:
ip = _get_client_ip(request)
cooldown_at = greylisted(address, ip)
if cooldown_at:
messages.warning(
request, "You are greylisted for another %s" %
timeuntil(cooldown_at))
else:
tx = faucet.send(address, ip)
amount = "%s%s" % (faucet.sending_amount.normalize(),
faucet.asset_code)
messages.info(
request,
"Request received successfully. %s will be sent to %s" %
(amount, address))
ctx["tx"] = tx
return render(request, "faucet.html", context=ctx)
def timeuntil(value, *args):
if value is None or isinstance(value, Undefined):
return u""
from django.utils.timesince import timeuntil
value = template_localtime(value)
return timeuntil(value, *args)
def test_depth(self):
t = (self.t + self.oneyear + self.onemonth + self.oneweek +
self.oneday + self.onehour)
tests = [
(t, 1, "1\xa0year"),
(t, 2, "1\xa0year, 1\xa0month"),
(t, 3, "1\xa0year, 1\xa0month, 1\xa0week"),
(t, 4, "1\xa0year, 1\xa0month, 1\xa0week, 1\xa0day"),
(t, 5, "1\xa0year, 1\xa0month, 1\xa0week, 1\xa0day, 1\xa0hour"),
(t, 6, "1\xa0year, 1\xa0month, 1\xa0week, 1\xa0day, 1\xa0hour"),
(self.t + self.onehour, 5, "1\xa0hour"),
(self.t + (4 * self.oneminute), 3, "4\xa0minutes"),
(self.t + self.onehour + self.oneminute, 1, "1\xa0hour"),
(self.t + self.oneday + self.onehour, 1, "1\xa0day"),
(self.t + self.oneweek + self.oneday, 1, "1\xa0week"),
(self.t + self.onemonth + self.oneweek, 1, "1\xa0month"),
(self.t + self.oneyear + self.onemonth, 1, "1\xa0year"),
(self.t + self.oneyear + self.oneweek + self.oneday, 3,
"1\xa0year"),
]
for value, depth, expected in tests:
with self.subTest():
self.assertEqual(timesince(self.t, value, depth=depth),
expected)
self.assertEqual(timeuntil(value, self.t, depth=depth),
expected)
def test_naive_datetime_with_tzinfo_attribute(self):
class naive(datetime.tzinfo):
def utcoffset(self, dt):
return None
future = datetime.datetime(2080, 1, 1, tzinfo=naive())
self.assertEqual(timesince(future), '0\xa0minutes')
past = datetime.datetime(1980, 1, 1, tzinfo=naive())
self.assertEqual(timeuntil(past), '0\xa0minutes')
def timeuntil_filter(value, arg=None):
"""Format a date as the time until that date (i.e. "4 days, 6 hours")."""
if not value:
return ''
try:
return timeuntil(value, arg)
except (ValueError, TypeError):
return ''
def timeuntil_filter(value, arg=None):
"""Formats a date as the time until that date (i.e. "4 days, 6 hours")."""
if not value:
return ''
try:
return timeuntil(value, arg)
except (ValueError, TypeError):
return ''
def format_date(d):
if not d:
return ""
if d < datetime.now():
return timesince(d) + " ago"
else:
return "in " + timeuntil(d)
def format_date(d):
if not d:
return ""
if d < datetime.now():
return timesince(d) + " ago"
else:
return "in " + timeuntil(d)
def get_expired_event(self, instance): #check if the event is expired
start_date = instance.start_date
time_delta = timeuntil(
start_date) #even if it is a string, i can't compare it..
time_zero = timesince(start_date, start_date)
instance.expired_event = time_delta == time_zero # validated_data.get(True, instance.expired_event)
instance.save()
return time_delta == time_zero
def get(self, request, *args, **kwargs):
asset = kwargs.get("asset")
if asset is not None:
faucet = get_object_or_404(Faucet,
asset_code__iexact=asset,
visible=True)
else:
faucet = Faucet.objects.first()
if self.curl:
# the "API" version
ip = _get_client_ip(request)
address = kwargs["address"]
if asset is None:
return JsonResponse(
{"message": "You must specify an asset code to send"},
status=400)
for skip_header in settings.WHITELISTED_HEADERS:
header = "HTTP_%s" % skip_header.replace("-", "_")
if header in request.META:
cooldown_at = None
break
else:
cooldown_at = greylisted(address, ip)
if cooldown_at:
return JsonResponse(
{
"message":
"You are greylisted for another %s" %
timeuntil(cooldown_at)
},
status=403)
else:
tx = faucet.send(address, ip)
amount = "%s%s" % (faucet.sending_amount.normalize(),
faucet.asset_code)
return JsonResponse(
{
"message":
"Request received successfully. %s will be sent to %s"
% (amount, address),
"tx":
tx.txhash,
},
status=200,
)
# also list other faucets to get links to other assets other than the chosen one
faucets = Faucet.objects.filter(visible=True).order_by("asset_code")
return render(request,
"faucet.html",
context={
"faucets": faucets,
"faucet": faucet
})
def test_different_timezones(self):
""" When using two different timezones. """
now = datetime.datetime.now()
now_tz = datetime.datetime.now(LocalTimezone(now))
now_tz_i = datetime.datetime.now(FixedOffset((3 * 60) + 15))
self.assertEquals(timesince(now), u'0 minutes')
self.assertEquals(timesince(now_tz), u'0 minutes')
self.assertEquals(timeuntil(now_tz, now_tz_i), u'0 minutes')
def test_different_timezones(self):
""" Тестируем две различные таймзоны """
now = datetime.datetime.now()
now_tz = datetime.datetime.now(LocalTimezone())
now_tz_i = datetime.datetime.now(FixedOffset((3 * 60) + 15))
self.assertEqual(timesince(now), f'0\xa0минут')
self.assertEqual(timesince(now_tz), "0\xa0минут")
self.assertEqual(timeuntil(now_tz, now_tz_i), "0\xa0минут")
def timeuntil(value, arg=None):
"""Formats a date as the time until that date (i.e. "4 days, 6 hours")."""
from django.utils.timesince import timeuntil
if not value:
return u''
try:
return timeuntil(value, arg)
except (ValueError, TypeError):
return u''
def as_columns(self):
return (
"{:%a %H:%M:%S}".format(self.date.datetime()),
"{:%a %I:%M:%S %p}".format(ephem.localtime(self.date)),
"{}".format(timeuntil(ephem.localtime(self.date))),
"{0.key:^7}".format(self),
"{} {}".format(get_symbol(self.body), self.body.name),
"{0.azalt}°".format(self),
)
def test_different_timezones(self):
""" When using two different timezones. """
now = datetime.datetime.now()
now_tz = datetime.datetime.now(LocalTimezone(now))
now_tz_i = datetime.datetime.now(FixedOffset((3 * 60) + 15))
self.assertEqual(timesince(now), '0 minutes')
self.assertEqual(timesince(now_tz), '0 minutes')
self.assertEqual(timeuntil(now_tz, now_tz_i), '0 minutes')
def timeuntil(value, arg=None):
"""Formats a date as the time until that date (i.e. "4 days, 6 hours")."""
from django.utils.timesince import timeuntil
if not value:
return u''
try:
return timeuntil(value, arg)
except (ValueError, TypeError):
return u''
def remindme(self, command):
yield from command.send_typing()
try:
timestamp = self.parse_time(command.args.time)
except ValueError:
yield from command.reply("Could not parse the time \"{}\"".format(command.args.time))
return
member = Member.objects.from_message(command.message)
Message.objects.create(member=member, text=command.args.message, deliver_at=timestamp)
yield from command.reply("I'll do so in {}".format(timeuntil(timestamp)))
def card_text_from_machine_status(machine):
status = dict(machine.status_choices)[machine.get_status()]
next_reservation = machine.get_next_reservation()
# If the machine is free for less than a day, provide the number of hours/minutes until the next reservation.
if machine.get_status() == "F" and next_reservation is not None and (
next_reservation.start_time - timezone.now()).days < 1:
status = "{:} {:} {:}".format(status, _('for'),
timeuntil(next_reservation.start_time))
return status
def humanize_date(value):
today = date.today()
try:
if value > today:
return 'In ' + timeuntil(value)
elif value < today:
return timesince(value) + ' ago'
else:
return 'Today'
except (ValueError, TypeError):
return ''
def get_display(self):
if self.repeat_period == self.REPEAT_NEVER:
return _("in %(timeperiod)s") % {"timeperiod": timeuntil(self.next_fire)} if self.next_fire else ""
elif self.repeat_period == self.REPEAT_DAILY:
time_of_day = time(self.repeat_hour_of_day, self.repeat_minute_of_hour, 0).strftime("%H:%M")
return _("each day at %(time)s") % {"time": time_of_day}
elif self.repeat_period == self.REPEAT_WEEKLY:
days = [str(day) for day in self.get_repeat_days_display()]
return _("each week on %(daysofweek)s" % {"daysofweek": ", ".join(days)})
elif self.repeat_period == self.REPEAT_MONTHLY:
return _("each month on the %(dayofmonth)s" % {"dayofmonth": ordinal(self.repeat_day_of_month)})
def timediff_filter(value, arg=None):
"""Combines the functionality of timesince and timeuntil"""
if not value:
return ''
try:
if timesince(value, arg) == avoid_wrapping(ugettext('0 minutes')):
return 'In ' + timeuntil(value, arg)
else:
return timesince(value, arg) + ' ago'
except (ValueError, TypeError):
return ''
def cashdesk_session(session): try: cashdesk_pk = session["cashdesk"] cashdesk = Cashdesk.objects.get(pk=cashdesk_pk) cashdesk_session = cashdesk.active_session if (cashdesk_session.valid_until < datetime.datetime.now()): timeleft = timesince(cashdesk_session.valid_until) + " <span style=\"color:red\"><strong><u>overtime</u></strong></span>" else: timeleft = timeuntil(cashdesk_session.valid_until) return timeleft except: return "-"
def card_text_from_machine_status(machine):
status = machine.get_status_display()
next_reservation = machine.get_next_reservation()
# If the machine is free for less than a day, provide the number of hours/minutes until the next reservation.
if (machine.get_status() == Machine.AVAILABLE
and next_reservation is not None
and (next_reservation.start_time - timezone.now()).days < 1):
# Uses old format scheme due to gettext not having automatic detection of translations in f-strings
status = "{:} {:} {:}".format(status, _('for'),
timeuntil(next_reservation.start_time))
return status
def relative(when, include_span_tag=True):
if not when:
return ''
delta = (when - datetime.now(tz=when.tzinfo)).total_seconds()
if abs(delta) < 10: # 10 seconds threshold
text = ugettext(u"just now")
elif delta < 0:
text = ugettext(u"%s ago") % timesince(when)
else:
text = ugettext(u"in %s") % timeuntil(when)
if include_span_tag:
text = mark_safe(u"<span title='%(absolute)s'>%(relative)s</span>"
% {'relative': text, 'absolute': date(when, 'r')})
return text
def cashdesk_session(session):
try:
cashdesk_pk = session["cashdesk"]
cashdesk = Cashdesk.objects.get(pk=cashdesk_pk)
cashdesk_session = cashdesk.active_session
if (cashdesk_session.valid_until < datetime.datetime.now()):
timeleft = timesince(
cashdesk_session.valid_until
) + " <span style=\"color:red\"><strong><u>overtime</u></strong></span>"
else:
timeleft = timeuntil(cashdesk_session.valid_until)
return timeleft
except:
return "-"
def queue_estimate(self):
"""
One-line info for estimated remaining queue wait.
"""
now = datetime.now()
if self.priority > 0:
min_seconds = 60
max_seconds = 180
link = u'<a href="/priority/">%s</a>' % capfirst(_("priority"))
else:
self.preload_cache()
browsers = self.matching_browsers()
preload_foreign_keys(browsers, browser_group=True)
requests = self.request_set.filter(screenshot__isnull=True)
preload_foreign_keys(requests, browser_group=True)
elapsed = now - self.submitted
elapsed = elapsed.seconds + elapsed.days * 24 * 3600
estimates = []
for request in requests:
estimate = request.queue_estimate(browsers)
if estimate:
estimates.append(estimate - elapsed)
if not estimates:
return ''
min_seconds = max(180, min(estimates) + 30)
max_seconds = max(180, max(estimates) + 30)
link = u'<a href="%s">%s</a>' % (self.get_absolute_url(),
capfirst(_("details")))
if min_seconds == max_seconds:
estimate = timeuntil(now + timedelta(seconds=min_seconds))
else:
min_interval = timeuntil(now + timedelta(seconds=min_seconds))
max_interval = timeuntil(now + timedelta(seconds=max_seconds))
estimate = _("%(min_interval)s to %(max_interval)s") % locals()
return mark_safe(u'<li>%s: %s (%s)</li>' %
(capfirst(_("queue estimate")), estimate, link))
def time_until_waiting_period(self):
"""
Helper primarily used within templates whose sole purpose is to catch
and display a custom message for the localized "0 minutes" otherwise
returned by the built-in `timeuntil` template filter:
https://docs.djangoproject.com/en/dev/ref/templates/builtins/#timeuntil
"""
if not self.is_valid:
return "0"
now = timezone.now().date()
if self.start_at > now:
return "in_future"
if self.end_at == now:
return "0"
return timeuntil(self.end_at, now)
def queue_estimate(self):
"""
One-line info for estimated remaining queue wait.
"""
now = datetime.now()
if self.priority > 0:
min_seconds = 60
max_seconds = 180
link = u'<a href="/priority/">%s</a>' % capfirst(_("priority"))
else:
self.preload_cache()
browsers = self.matching_browsers()
preload_foreign_keys(browsers, browser_group=True)
requests = self.request_set.filter(screenshot__isnull=True)
preload_foreign_keys(requests, browser_group=True)
elapsed = now - self.submitted
elapsed = elapsed.seconds + elapsed.days * 24 * 3600
estimates = []
for request in requests:
estimate = request.queue_estimate(browsers)
if estimate:
estimates.append(estimate - elapsed)
if not estimates:
return ''
min_seconds = max(180, min(estimates) + 30)
max_seconds = max(180, max(estimates) + 30)
link = u'<a href="%s">%s</a>' % (
self.get_absolute_url(), capfirst(_("details")))
if min_seconds == max_seconds:
estimate = timeuntil(now + timedelta(seconds=min_seconds))
else:
min_interval = timeuntil(now + timedelta(seconds=min_seconds))
max_interval = timeuntil(now + timedelta(seconds=max_seconds))
estimate = _("%(min_interval)s to %(max_interval)s") % locals()
return mark_safe(u'<li>%s: %s (%s)</li>' % (
capfirst(_("queue estimate")), estimate, link))
def deadline(then):
if not then:
return ""
if now() < then:
return format_html(
'<span class="label label-{}">{}</span>',
deadline_color(then),
"dans {}".format(timeuntil(then)).split(",")[0],
)
else:
return format_html(
'<span class="label label-{}">{}</span>',
deadline_color(then),
"il y a {} !".format(timesince(then)).split(",")[0],
)
def get_timeuntil(self):
"""
Returns a string representing the time until the next
time this Job will be run.
"""
if self.disabled:
return _("never (disabled)")
delta = self.next_run - datetime.now()
if delta.days < 0:
# The job is past due and should be run as soon as possible
return _("due")
elif delta.seconds < 60:
# Adapted from django.utils.timesince
count = lambda n: ungettext("second", "seconds", n)
return ugettext("%(number)d %(type)s") % {"number": delta.seconds, "type": count(delta.seconds)}
return timeuntil(self.next_run)
def to_dict(self):
return {
'id': self.pk,
'title': self.title,
'description': self.description,
'start_date': self.start_date.strftime('%m-%d-%Y %H:%M'),
'end_date': self.end_date.strftime('%m-%d-%Y %H:%M'),
'duration': timeuntil(self.end_date, self.start_date),
'start_date_str': self.start_date.strftime('%d %b').lstrip("0"),
'team': self.team.to_dict(),
'members': [ {
'id': member.user.pk,
'name': member.user.get_name(),
'userpic': member.user.get_userpic_url(),
'is_owner': member.is_owner,
'url': reverse('user-page', kwargs={'user_id': member.user.pk})
} for member in self.member_set.all()]
}
def get_timeuntil(self):
"""
Returns a string representing the time until the next
time this Job will be run.
"""
if self.disabled:
return _('never (disabled)')
delta = self.next_run - datetime.now()
if delta.days < 0:
# The job is past due and should be run as soon as possible
return _('due')
elif delta.seconds < 60:
# Adapted from django.utils.timesince
count = lambda n: ungettext('second', 'seconds', n)
return ugettext('%(number)d %(type)s') % {'number': delta.seconds,
'type': count(delta.seconds)}
return timeuntil(self.next_run)
def get_timeuntil(self):
"""
Returns a string representing the time until the next
time this Job will be run.
"""
if self.adhoc_run:
return u'ASAP'
elif self.disabled:
return u'never (disabled)'
delta = self.next_run - tz_now()
if delta.days < 0:
# The job is past due and should be run as soon as possible
return u'due'
elif delta.seconds < 60:
return u'{} sec.'.format(delta.seconds)
return timeuntil(self.next_run)
def _post_clean(self):
super(locking_form, self)._post_clean()
# We were not passed a user, so we have no way of telling who is
# the owner of an object's lock; better not to raise
# ValidationError in that case
if not user:
return
# If this model doesn't have primary keys, don't continue
if not self._meta.model._meta.pk:
return
# If there are already errors, no point checking lock since save
# will be prevented
if self.errors:
return
# If we don't have a saved object yet, it could not have a lock
if not self.instance.pk:
return
try:
lock = Lock.objects.get_lock_for_object(self.instance)
except Lock.DoesNotExist:
return
# If either of these conditions are met, we don't have an error.
# If we pass beyond this point, we have a validation error because
# the object is locked by a user other than the current user.
if not lock.is_locked or lock.is_locked_by(user):
return
try:
raise forms.ValidationError(
("You cannot save this %(verbose_name)s because it is "
"locked by %(user)s. The lock will expire in "
"%(time_remaining)s if that user is idle.") %
{
'verbose_name': self._meta.model._meta.verbose_name,
'user': lock.locked_by.get_full_name(),
'time_remaining': timeuntil(lock.lock_expiration_time),
})
except forms.ValidationError as e:
self._update_errors({NON_FIELD_ERRORS: e.messages})
def getHorarios(self, ponto):
estimativas = []
for l in self.linhasQuePassamNoPonto(ponto):
prev = self.getPrevisao(l,ponto,False)
estimativas +=prev.estimativas
horarios ={}
for e in estimativas:
ee = formata_horario(e)
o={}
if ee == {}:
continue
if not horarios.has_key(ee['linha']):
horarios[ee['linha']] = []
o['data_estimada']="%s (%s)" % (ee['data_estimada'].strftime("%H:%M"),timeuntil(ee['data_estimada']))
o['data_horario']=ee['data_horario'].strftime("%H:%M")
o['data_pacote']=ee['data_pacote'].strftime("%H:%M")
horarios[ee['linha']].append(o)
return horarios
def get_eta_display(self):
import datetime
from django.models.aurora import fetchers
from django.utils.timesince import timeuntil
try:
if self.fetcher.download_rate:
seconds = (self.metainfo.total_bytes - self.downloaded) / self.fetcher.download_rate
days = seconds / (24 * 60 * 60)
seconds = seconds % (24 * 60 * 60)
now = datetime.datetime.now()
delta = datetime.timedelta(days=days, seconds=seconds)
return timeuntil(now + delta)
else:
return ''
except fetchers.FetcherDoesNotExist:
return ''
def time_until_expire(self):
"""
Human-readable formatting of interval before expiration.
"""
now = datetime.now()
remaining = self.expire - now
disabled = ''
if remaining >= timedelta(minutes=29, seconds=50):
remaining = timedelta(minutes=30)
disabled = ' disabled="disabled"'
interval = timeuntil(now + remaining, now)
expire = capfirst(_("expires in %(interval)s")) % \
{'interval': interval}
if self.same_user():
expire += '\n'.join(('',
'<input type="hidden" name="request_group_id" value="%d" />' % self.id,
'<input type="submit" name="extend" value="%s"%s />' % (
unicode(capfirst(_("extend"))), disabled),
'<input type="submit" name="cancel" value="%s" />' % (
unicode(capfirst(_("cancel"))))))
return mark_safe('<li>%s</li>' % (expire))
def resource_language_lock(request, project_slug, resource_slug, language_code):
"""
View to lock a resource language.
It uses a json response to be used with Ajax requests.
"""
response={}
if request.method == 'POST':
resource = get_object_or_404(Resource.objects.select_related('project'),
slug=resource_slug, project__slug=project_slug)
language = get_object_or_404(Language, code=language_code)
team = Team.objects.get_or_none(resource.project, language_code)
try:
lock = Lock.objects.create_update(resource, language, request.user)
response['status'] = "OK"
response['message'] = _("Lock created.")
response['timeuntil'] = timeuntil(lock.expires)
except LockError, e:
response['status'] = "FAILED"
response['message'] = e.message
def gametime(game):
if game.state == 'finished':
since_str = timesince(game.next_ending)
# only show the most significant part of
# the string
since_str, _, _ = since_str.partition(',')
return 'Finished %s ago' % since_str.strip()
elif game.state == 'invalid':
since_str = timesince(game.next_ending)
# only show the most significant part of
# the string
since_str, _, _ = since_str.partition(',')
return 'Cancelled %s ago' % since_str.strip()
until_str = timeuntil(game.next_ending)
# add "more" just after the first set of digits, so
# "1 hour, 15 minutes" becomes "1 more hour, 15 minutes"
num, _, rest = until_str.partition(' ')
state = game.state[0].upper() + game.state[1:]
return '%s for %s more %s' % (state, num, rest)
def tz_std_date_ago(value, user):
"""
This is a further simplification of the kinds of time stamps we
frequently use in our app framework. It is just like tz_std_date, except
we return the datetime string with ' (<timesince> ago)'
NOTE: We switch to 'timeuntil' if the date provided is in the
the future.
"""
if not isinstance(value, datetime):
return ""
# We need to see if the date is before or after now. If the date does
# not have a timezone set then we assume it is in the server's timezone.
#
now = datetime.utcnow().replace(tzinfo = pytz.UTC)
if value.tzinfo is None:
server_tz = pytz.timezone(settings.TIME_ZONE)
value = value.replace(tzinfo = server_tz)
if value < now:
return "%s (%s ago)" % (tz_std_date(value, user), timesince(value))
else:
return "%s (in %s)" % (tz_std_date(value, user), timeuntil(value))
def test_both_date_objects(self):
""" Timesince should work with both date objects (#9672) """
today = datetime.date.today()
self.assertEqual(timeuntil(today + self.oneday, today), '1\xa0day')
self.assertEqual(timeuntil(today - self.oneday, today), '0\xa0minutes')
self.assertEqual(timeuntil(today + self.oneweek, today), '1\xa0week')
def test_date_objects(self):
""" Both timesince and timeuntil should work on date objects (#17937). """
today = datetime.date.today()
self.assertEqual(timesince(today + self.oneday), '0\xa0minutes')
self.assertEqual(timeuntil(today - self.oneday), '0\xa0minutes')
def time_remaining(self):
if self.status == self.OPEN_STATUS:
return timeuntil(self.bounties().aggregate(Min('ends'))['ends__min'], datetime.datetime.now()).split(',')[0]
return timeuntil(self.modified + datetime.timedelta(days=3), datetime.datetime.now()).split(',')[0]
