def test_zone_to_zone(self):
dt_1 = datetime.utcnow() + timedelta(hours=-2)
dt_2 = datetime.utcnow() + timedelta(hours=2)
arr_1 = Arrow(dt_1, timedelta(hours=-2))
arr_2 = Arrow(dt_2, timedelta(hours=2))
result_1 = arr_1.to(timedelta(hours=2))
result_2 = arr_2.to(timedelta(hours=-2))
self.assert_dt_equal(result_1.datetime, arr_2.datetime)
self.assert_dt_equal(result_2.datetime, arr_1.datetime)
def test_zone_to_zone(self):
dt_1 = datetime.utcnow() + timedelta(hours=-2)
dt_2 = datetime.utcnow() + timedelta(hours=2)
arr_1 = Arrow(dt_1, timedelta(hours=-2))
arr_2 = Arrow(dt_2, timedelta(hours=2))
result_1 = arr_1.to(timedelta(hours=2))
result_2 = arr_2.to(timedelta(hours=-2))
self.assert_dt_equal(result_1.datetime, arr_2.datetime)
self.assert_dt_equal(result_2.datetime, arr_1.datetime)
def should_2020_04_mega_pay(utc: Arrow) -> bool:
"""Should return True it is 4/20/2020 4:20 AM/PM in Texas"""
central = utc.to('America/Chicago')
return (central.month == 4 and central.day == 20 and central.year == 2020
and is_payable(utc))
def blacklist_project(self, project: db.Project, reset_time: arrow.Arrow):
"""
Add specified project to `self.ratelimit_queue`, add backend to
`self.blacklist_dict` and increment `self.ratelimit_counter`.
Args:
project: Project to blacklist
reset_time: Time when the ratelimit will be reset
"""
with self.blacklist_dict_lock:
if project.backend not in self.blacklist_dict:
_log.debug(
"Rate limit threshold reached. Adding {} to blacklist.".format(
project.backend
)
)
self.blacklist_dict[project.backend] = reset_time.to("utc").datetime
with self.ratelimit_queue_lock:
if project.backend not in self.ratelimit_queue:
self.ratelimit_queue[project.backend] = []
self.ratelimit_queue[project.backend].append(project.id)
with self.ratelimit_counter_lock:
self.ratelimit_counter += 1
def DailyCallback(self, schedule_time: arrow.Arrow, fn: Callable, *args,
**kwargs) -> Job:
"""Schedules fn to be run once a day at schedule_time.
The actual scheduled time is perturbed randomly +/-30s unless the kwarg
'_jitter' is set to False.
Args:
schedule_time: An Arrow object specifying when to run fn.
fn: The function to be run.
*args: Arguments to pass to fn.
**kwargs: Keyworded arguments to pass to fn. Special kwargs listed below:
_jitter - {int} How many seconds to perturb scheduling time by, in
both directions. Defaults to 30s.
Returns:
APScheduler Job.
"""
if self._local_tz:
schedule_time = schedule_time.to(self._local_tz)
jitter = kwargs.get('_jitter', 30)
if jitter:
jitter_secs = random.randint(-jitter, jitter)
schedule_time = schedule_time.shift(seconds=jitter_secs)
kwargs.pop('_jitter', None)
# APScheduler 2.1.2 doesn't understand timezones.
return self._scheduler.add_interval_job(fn,
args=args,
kwargs=kwargs,
start_date=schedule_time.naive,
days=1)
def check_status(cls, service_name: str, check_date: arrow.Arrow):
"""Check service scheduled status. The check date should be UTC datetime format."""
current_status = 'None'
up_time = 0
response = {
'service': service_name,
'current_status': current_status,
'next_up_time': up_time
}
if not service_name or not check_date:
return response
check_date_local = check_date.to(LOCAL_TIMEZONE)
service_schedule = cls.get_schedules(service_name)
if service_schedule:
current_app.logger.debug(f'check date: {check_date_local}')
current_status = 'True'
outage_times = cls.get_outage_schedules(service_schedule)
available_times = cls.get_available_schedules(
service_schedule, check_date_local)
for outage in outage_times:
if check_date_local.date() >= outage[0].date() and (
outage[0] < check_date_local < outage[1]):
current_app.logger.debug(
f'outage date: start {outage[0]} end {outage[1]}')
current_status = 'False'
up_time = outage[1].timestamp
if current_status == 'True':
if 'available' in service_schedule[0]:
for available in available_times:
if check_date_local.date() == available[0].date() \
and (check_date_local < available[0] or check_date_local > available[1]):
current_app.logger.debug(
f'available date: from {available[0]} to {available[1]}'
)
current_status = 'False'
up_time = available[0].timestamp
# Add any custom message is provided
custom = service_schedule[0].get('custom', None)
if custom is not None:
if (Status._get_local_outage_time(custom['start']) <=
check_date_local < Status._get_local_outage_time(
custom['end'])):
response['custom_message'] = custom['message']
response['current_status'] = current_status
if up_time:
response['next_up_time'] = up_time
response['message'] = current_app.config.get(
'PAYBC_OUTAGE_MESSAGE')
return response
def blacklist_project(self, project: db.Project, reset_time: arrow.Arrow):
"""
Add specified project to `self.ratelimit_queue`, add backend to
`self.blacklist_dict` and increment `self.ratelimit_counter`.
Args:
project: Project to blacklist
reset_time: Time when the ratelimit will be reset
"""
with self.blacklist_dict_lock:
if project.backend not in self.blacklist_dict:
_log.debug(
"Rate limit threshold reached. Adding {} to blacklist.".format(
project.backend
)
)
self.blacklist_dict[project.backend] = reset_time.to("utc").datetime
with self.ratelimit_queue_lock:
if project.backend not in self.ratelimit_queue:
self.ratelimit_queue[project.backend] = []
self.ratelimit_queue[project.backend].append(project.id)
with self.ratelimit_counter_lock:
self.ratelimit_counter += 1
def test_local_to_utc(self):
arr = Arrow(datetime.now(), tz='local')
result = arr.to('UTC')
self.assert_dt_equal(result.datetime, datetime.utcnow())
self.assert_ts_equal(result.timestamp, time.time())
def test_local_to_utc(self):
arr = Arrow(datetime.now(), tz='local')
result = arr.to('UTC')
self.assert_dt_equal(result.datetime, datetime.utcnow())
self.assert_ts_equal(result.timestamp, time.time())
def test_eq_utc_converstions(self):
arr = Arrow(datetime(11, 1, 1))
utc_1 = arr.utc()
utc_2 = arr.to('UTC')
self.assertEqual(utc_1.datetime, utc_2.datetime)
self.assertEqual(utc_1, utc_2)
def test_eq_utc_converstions(self):
arr = Arrow(datetime(11, 1, 1))
utc_1 = arr.utc()
utc_2 = arr.to('UTC')
self.assertEqual(utc_1.datetime, utc_2.datetime)
self.assertEqual(utc_1, utc_2)
def _format_dates(date: arrow.Arrow) -> list[str]:
"""
Return a list of date strings formatted according to the discord timestamp styles.
These are used in the description of each style in the dropdown
"""
date = date.to('utc')
formatted = [str(int(date.timestamp()))]
formatted += [
date.format(format[1]) for format in list(STYLES.values())[1:7]
]
formatted.append(date.humanize())
return formatted
def check_status(cls, service_name: str, check_date: arrow.Arrow):
"""Check service scheduled status. The check date should be UTC datetime format."""
current_status = 'None'
up_time = 0
response = {
'service': service_name,
'current_status': current_status,
'next_up_time': up_time
}
if not service_name or not check_date:
return response
check_date_local = check_date.to(LOCAL_TIMEZONE)
service_schedule = cls.get_schedules(service_name)
if service_schedule:
current_app.logger.debug(f'check date: {check_date_local}')
current_status = 'True'
outage_times = cls.get_outage_schedules(service_schedule)
available_times = cls.get_available_schedules(
service_schedule, check_date_local)
for outage in outage_times:
if check_date_local.date() >= outage[0].date() and (
outage[0] < check_date_local < outage[1]):
current_app.logger.debug(
f'outage date: start {outage[0]} end {outage[1]}')
current_status = 'False'
up_time = outage[1].timestamp
if current_status == 'True':
if 'available' in service_schedule[0]:
for available in available_times:
if check_date_local.date() == available[0].date() \
and (check_date_local < available[0] or check_date_local > available[1]):
current_app.logger.debug(
f'available date: from {available[0]} to {available[1]}'
)
current_status = 'False'
up_time = available[0].timestamp
response['current_status'] = current_status
if up_time:
response['next_up_time'] = up_time
return response
def is_payable(utc: Arrow) -> bool:
"""Should return True if time is 4:20AM or 4:20PM in Texas"""
central = utc.to('America/Chicago')
hour = central.hour
minute = central.minute
if minute != 20:
return False
if hour not in [4, 16]:
return False
return True
def format_dt_filter(dt: Arrow, fmt):
return dt.to('Europe/Prague').strftime(fmt)
def quickembed(name: str, desc: str, begin: Arrow, end: Arrow) -> Embed:
return Embed(title=name, description=html2md(desc)).add_field(
name="Start",
value=begin.to('local').format(arrow.FORMAT_COOKIE)).add_field(
name="End", value=end.to('local').format(arrow.FORMAT_COOKIE))
class ArrowTests(BaseArrowTests):
def setUp(self):
super(ArrowTests, self).setUp()
self.arrow = Arrow(datetime.utcnow(), tz=tz.tzutc())
def test_str(self):
expected = '{0} UTC'.format(self.arrow._datetime.isoformat())
self.assertEqual(self.arrow.__str__(), expected)
def test_repr(self):
expected = '<Arrow({0} UTC)>'.format(self.arrow._datetime.isoformat())
self.assertEqual(self.arrow.__repr__(), expected)
def test_tz(self):
self.arrow._timezone = self.utc
self.assertEqual(self.arrow.tz, self.utc)
def test_to(self):
self.arrow._datetime = datetime.utcnow().replace(tzinfo=self.utc.tzinfo)
self.arrow._timezone = self.utc
result = self.arrow.to('local')
self.assert_dt_equal(result.datetime, self.arrow._datetime.astimezone(self.local.tzinfo))
def test_utc_utc(self):
self.arrow._datetime = datetime.now().replace(tzinfo=self.local.tzinfo)
self.arrow._timezone = self.local
result = self.arrow.utc()
self.assert_dt_equal(result.datetime, self.arrow._datetime.astimezone(self.utc.tzinfo))
def test_utc_local(self):
self.arrow._datetime = datetime.utcnow().replace(tzinfo=self.utc.tzinfo)
self.arrow._timezone = self.utc
result = self.arrow.utc()
self.assert_dt_equal(result.datetime, self.arrow._datetime.astimezone(self.utc.tzinfo))
def test_datetime(self):
dt = datetime.utcnow().replace(tzinfo=tz.tzutc())
self.arrow._datetime = dt
self.arrow._timezone = self.utc
result = self.arrow.datetime
self.assertEqual(result, dt)
def test_timestamp(self):
dt = datetime.utcnow()
self.arrow._datetime = dt
self.arrow._timezone = self.utc
result = self.arrow.timestamp
self.assertEqual(result, calendar.timegm(dt.timetuple()))
def test_parse_int(self):
dt, timezone = self.arrow._parse(int(time.time()), self.utc)
self.assert_dt_equal(dt, datetime.utcnow())
def test_parse_float_utc(self):
dt, timezone = self.arrow._parse(time.time(), self.utc)
self.assert_dt_equal(dt, datetime.utcnow())
def test_parse_float_local(self):
dt, timezone = self.arrow._parse(time.time(), self.local)
self.assert_dt_equal(dt, datetime.now())
def test_parse_str_float_utc(self):
dt, timezone = self.arrow._parse(str(time.time()), self.utc)
self.assert_dt_equal(dt, datetime.utcnow())
def test_parse_str_int_utc(self):
dt, timezone = self.arrow._parse(str(int(time.time())), self.utc)
self.assert_dt_equal(dt, datetime.utcnow())
def test_parse_str_float_local(self):
dt, timezone = self.arrow._parse(str(time.time()), self.local)
self.assert_dt_equal(dt, datetime.now())
def test_parse_str_int_local(self):
dt, timezone = self.arrow._parse(str(int(time.time())), self.local)
self.assert_dt_equal(dt, datetime.now())
def test_parse_parse_str(self):
with self.assertRaises(ValueError):
self.arrow._parse('abcdefg', self.utc)
def test_parse_unrecognized(self):
with self.assertRaises(ValueError):
self.arrow._parse(object, self.utc)
def change_dt_utc_to_local(dt: arrow.Arrow) -> arrow.Arrow:
"""
change UTC date time to local time zone Europe/Paris
"""
return dt.to('Europe/Paris')
def format_dt_filter(dt: Arrow, fmt):
return dt.to('Europe/Prague').strftime(fmt)
def format_dt_iso_filter(dt: Arrow):
return dt.to('Europe/Prague').isoformat()
class ArrowTests(BaseArrowTests):
def setUp(self):
super(ArrowTests, self).setUp()
self.arrow = Arrow(datetime.utcnow(), tz='UTC')
def test_str(self):
expected = '{0}.{1} +00:00 (UTC)'.format(
time.strftime('%x %X', self.arrow.datetime.timetuple()),
self.arrow.datetime.microsecond)
self.assertEqual(self.arrow.__str__(), expected)
def test_repr(self):
expected = 'Arrow({0}.{1} +00:00 (UTC))'.format(
time.strftime('%x %X', self.arrow.datetime.timetuple()),
self.arrow.datetime.microsecond)
self.assertEqual(self.arrow.__repr__(), expected)
def test_tz(self):
self.arrow._timezone = self.utc
self.assertEqual(self.arrow.tz, self.utc)
def test_to(self):
self.arrow._datetime = datetime.utcnow().replace(
tzinfo=self.utc.tzinfo)
self.arrow._timezone = self.utc
result = self.arrow.to('local')
self.assert_dt_equal(
result.datetime,
self.arrow._datetime.astimezone(self.local.tzinfo))
def test_utc_utc(self):
self.arrow._datetime = datetime.now().replace(tzinfo=self.local.tzinfo)
self.arrow._timezone = self.local
result = self.arrow.utc()
self.assert_dt_equal(result.datetime,
self.arrow._datetime.astimezone(self.utc.tzinfo))
def test_utc_local(self):
self.arrow._datetime = datetime.utcnow().replace(
tzinfo=self.utc.tzinfo)
self.arrow._timezone = self.utc
result = self.arrow.utc()
self.assert_dt_equal(result.datetime,
self.arrow._datetime.astimezone(self.utc.tzinfo))
def test_datetime(self):
dt = datetime.utcnow().replace(tzinfo=tz.tzutc())
self.arrow._datetime = dt
self.arrow._timezone = self.utc
result = self.arrow.datetime
self.assertEqual(result, dt)
def test_timestamp_utc(self):
dt = datetime.utcnow()
self.arrow._datetime = dt
self.arrow._timezone = self.utc
result = self.arrow.timestamp
self.assertEqual(result, calendar.timegm(dt.timetuple()))
def test_timestamp_local(self):
dt = datetime.now()
self.arrow._datetime = dt
self.arrow._timezone = self.local
result = self.arrow.timestamp
self.assertEqual(result, time.mktime(dt.timetuple()))
def test_get_datetime_int(self):
result = self.arrow._get_datetime(int(time.time()), self.utc)
self.assert_dt_equal(result, datetime.utcnow())
def test_get_datetime_float_utc(self):
result = self.arrow._get_datetime(time.time(), self.utc)
self.assert_dt_equal(result, datetime.utcnow())
def test_get_datetime_float_local(self):
result = self.arrow._get_datetime(time.time(), self.local)
self.assert_dt_equal(result, datetime.now())
def test_get_datetime_str_float_utc(self):
result = self.arrow._get_datetime(str(time.time()), self.utc)
self.assert_dt_equal(result, datetime.utcnow())
def test_get_datetime_str_int_utc(self):
result = self.arrow._get_datetime(str(int(time.time())), self.utc)
self.assert_dt_equal(result, datetime.utcnow())
def test_get_datetime_str_float_local(self):
result = self.arrow._get_datetime(str(time.time()), self.local)
self.assert_dt_equal(result, datetime.now())
def test_get_datetime_str_int_local(self):
result = self.arrow._get_datetime(str(int(time.time())), self.local)
self.assert_dt_equal(result, datetime.now())
def test_get_datetime_datetime(self):
dt = datetime.utcnow()
result = self.arrow._get_datetime(dt, self.utc)
self.assert_dt_equal(result, dt)
def test_get_datetime_parse_str(self):
with self.assertRaises(RuntimeError):
self.arrow._get_datetime('abcdefg', self.utc)
def test_get_datetime_unrecognized(self):
with self.assertRaises(RuntimeError):
self.arrow._get_datetime(object, self.utc)
def format_dt_iso_filter(dt: Arrow):
return dt.to('Europe/Prague').isoformat()
