def get_start_time_for_period(period):
# Using now() from datetime instead of arrow for mocking compatibility.
now = arrow.Arrow.fromdatetime(datetime.datetime.now())
date = now.date()
day = date.day
month = date.month
year = date.year
weekday = now.weekday()
if period == "day":
start_time = arrow.Arrow(year, month, day)
elif period == "week":
start_time = arrow.Arrow.fromdate(now.shift(days=-weekday).date())
elif period == "month":
start_time = arrow.Arrow(year, month, 1)
elif period == "year":
start_time = arrow.Arrow(year, 1, 1)
elif period == "full":
start_time = arrow.get(0)
else:
raise ValueError("Unsupported period value: {}".format(period))
return start_time
def get_start_time_for_period(period):
# Using now() from datetime instead of arrow for mocking compatibility.
now = arrow.Arrow.fromdatetime(datetime.datetime.now())
date = now.date()
day = date.day
month = date.month
year = date.year
weekday = now.weekday()
if period == 'day':
start_time = arrow.Arrow(year, month, day)
elif period == 'week':
start_time = arrow.Arrow.fromdate(now.replace(days=-weekday).date())
elif period == 'month':
start_time = arrow.Arrow(year, month, 1)
elif period == 'year':
start_time = arrow.Arrow(year, 1, 1)
elif period == 'all':
# approximately timestamp `0`
start_time = arrow.Arrow(1970, 1, 1)
else:
raise ValueError(u'Unsupported period value: {}'.format(period))
return start_time
def test_invalid_ranges():
fail = arrow.Arrow(1970, 1, 1)
fail2 = arrow.Arrow(2100, 5, 5)
with pytest.raises(ValueError):
get_last_full_moon(fail)
with pytest.raises(ValueError):
get_last_full_moon(fail2)
def test_window_simple_no_published_events(
event_generator,
set_strategy,
mock_arrow_now,
):
"Testing that if no event is published, the function takes the first available unpublished event"
unpublished_events = [
event_generator(
published=False,
begin_date=arrow.Arrow(year=2021,
month=1,
day=5,
hour=11,
minute=30),
),
event_generator(
published=False,
begin_date=arrow.Arrow(year=2021,
month=1,
day=5,
hour=11,
minute=50),
),
]
selected_event = select_event_to_publish([], unpublished_events)
assert selected_event is unpublished_events[0]
def testCancelledFromBuildbot(self, fake_now):
self.buildbot_db.execute(
sa.text("""
INSERT INTO buildrequests
(id, buildsetid, buildername, submitted_at, complete)
VALUES (3, 0, "foo", 30, 1);
"""))
processed_date = arrow.Arrow(2015, 4, 1)
fake_now.return_value = arrow.Arrow(2015, 4, 1).replace(minutes=7)
self.tasks.insert().execute(
buildrequestId=3,
taskId=makeTaskId(),
runId=0,
createdDate=20,
processedDate=processed_date.timestamp,
takenUntil=None,
)
self.reflector.reflectTasks()
# Tasks that are cancelled from Buildbot should have that reflected
# in TC, and be removed from our DB.
self.assertEqual(self.reflector.tc_queue.cancelTask.call_count, 1)
bbb_state = self.tasks.select().execute().fetchall()
self.assertEqual(len(bbb_state), 0)
def test_trade_close(limit_buy_order_usdt, limit_sell_order_usdt, fee):
trade = Trade(
pair='ADA/USDT',
stake_amount=60.0,
open_rate=2.0,
amount=30.0,
is_open=True,
fee_open=fee.return_value,
fee_close=fee.return_value,
open_date=arrow.Arrow(2020, 2, 1, 15, 5, 1).datetime,
exchange='binance',
)
assert trade.close_profit is None
assert trade.close_date is None
assert trade.is_open is True
trade.close(2.2)
assert trade.is_open is False
assert trade.close_profit == round(0.0945137157107232, 8)
assert trade.close_date is not None
new_date = arrow.Arrow(2020, 2, 2, 15, 6, 1).datetime,
assert trade.close_date != new_date
# Close should NOT update close_date if the trade has been closed already
assert trade.is_open is False
trade.close_date = new_date
trade.close(2.2)
assert trade.close_date == new_date
def test_trade_close(limit_buy_order, limit_sell_order, fee):
trade = Trade(
pair='ETH/BTC',
stake_amount=0.001,
open_rate=0.01,
amount=5,
is_open=True,
fee_open=fee.return_value,
fee_close=fee.return_value,
open_date=arrow.Arrow(2020, 2, 1, 15, 5, 1).datetime,
exchange='bittrex',
)
assert trade.close_profit is None
assert trade.close_date is None
assert trade.is_open is True
trade.close(0.02)
assert trade.is_open is False
assert trade.close_profit == 0.99002494
assert trade.close_date is not None
new_date = arrow.Arrow(2020, 2, 2, 15, 6, 1).datetime,
assert trade.close_date != new_date
# Close should NOT update close_date if the trade has been closed already
assert trade.is_open is False
trade.close_date = new_date
trade.close(0.02)
assert trade.close_date == new_date
def test_window_simple_event_too_recent(
event_generator,
set_strategy,
mock_arrow_now,
):
"Testing that if an event has been published too recently, no event is selected for publication"
unpublished_events = [
event_generator(
published=False,
begin_date=arrow.Arrow(year=2021,
month=1,
day=5,
hour=11,
minute=30),
),
event_generator(
published=False,
begin_date=arrow.Arrow(year=2021,
month=1,
day=5,
hour=11,
minute=50),
),
]
published_events = [
event_generator(
published=True,
publication_time={"telegram": arrow.now().shift(minutes=-5)},
)
]
selected_event = select_event_to_publish(published_events,
unpublished_events)
assert selected_event is None
def convert_date_specific_to_timezone(timezone, start_date, end_date):
'''
USE CASE: Date is converted to timezone specific.
:param start_date = datetime object
:param end_date = datetime object
The start_date is taken as reference for converting to timezone specific dates.
start_date is converted to UTC then to subscriber timezone specific.
Now the converted date is utilized to fetch the hour difference w.r.t UTC.(i.e. +05.30, -11.30)
start_date is reduced by "-XX:YY" if the tm is "+XX:YY" and vice versa, same for end_date as well.
At last the end_date is incremented by a day for fetching data in the mentioned date range.
'''
date_to_utc = arrow.Arrow(start_date.year,
start_date.month,
start_date.day,
start_date.hour,
tzinfo=pytz.timezone('UTC'))
converted_date = arrow.Arrow(date_to_utc.year,
date_to_utc.month,
date_to_utc.day,
date_to_utc.hour,
tzinfo=pytz.timezone(timezone))
tm = converted_date.format('ZZ')
converted_hours = int(tm[1:3]) + 1 if int(tm[4:]) > 0 else int(tm[1:3])
start_date -= timedelta(hours=eval(tm[0] + str(converted_hours)))
end_date -= timedelta(hours=eval(tm[0] + str(converted_hours)))
end_date += timedelta(hours=23)
return start_date, end_date
def testLocalDtFillTimesDailyOneTz(self):
key = (2016, 5, 3)
test_section_list = []
test_section_list.append(
self._createTestSection(
arrow.Arrow(2016, 5, 3, 6, tzinfo=tz.gettz(PST)), PST))
test_section_list.append(
self._createTestSection(
arrow.Arrow(2016, 5, 3, 10, tzinfo=tz.gettz(PST)), PST))
test_section_list.append(
self._createTestSection(
arrow.Arrow(2016, 5, 3, 23, tzinfo=tz.gettz(PST)), PST))
section_group_df = self.ts.to_data_df(
eac.get_section_key_for_analysis_results(), test_section_list)
logging.debug("First row of section_group_df = %s" %
section_group_df.iloc[0])
self.assertEqual(earmt._get_tz(section_group_df), PST)
ms = ecwms.ModeStatTimeSummary()
earmt.local_dt_fill_times_daily(key, section_group_df, ms)
logging.debug("before starting checks, ms = %s" % ms)
self.assertEqual(ms.ts, 1462258800)
self.assertEqual(ms.local_dt.day, 3)
self.assertEqual(ms.local_dt.timezone, PST)
def test_get_curr_time_diff(self):
start = arrow.Arrow(2017, 8, 14, 12, 0)
end = arrow.Arrow(2017, 8, 14, 13, 0)
self.assertEqual(ArrowUtil.get_curr_time_diff(start=start, stop=end), 60)
self.assertEqual(
ArrowUtil.get_curr_time_diff(start=start, stop=end, base_hour=True), 1
)
def test_elapsed_string_over_month_boundary(self):
started = RaceStatus.objects.create(status='started', )
started.created = arrow.Arrow(2019, 7, 28)
# number of seconds in ten hours, ten minutes, ten seconds = 36000 + 600 + 10 = 36610
with mock.patch('tcr_tracker.tracker.models.arrow.now',
return_value=arrow.Arrow(2019, 8, 1, 10, 10, 10)):
self.assertEquals(started.elapsed_time_string,
'4 Days 10 Hours 10 Minutes')
def test_with_known_date():
aniceday = arrow.Arrow(2018, 7, 27, 10, 51)
aniceday_lastMoon = arrow.Arrow(2018, 6, 28, 4, 55)
aniceday_result = get_last_full_moon(aniceday)
assert aniceday_result == aniceday_lastMoon
thenextday = aniceday.shift(days=1)
thenextday_lastMoon = arrow.Arrow(2018, 7, 27, 20, 22)
thenextday_result = get_last_full_moon(thenextday)
assert thenextday_result == thenextday_lastMoon
def test7():
''' Testing in 52 weeks. '''
# the time when this code was written
right_now = arrow.Arrow(2018, 4, 16)
# in less than a week
week_to = arrow.Arrow(2019, 4, 16)
assert(week_to.humanize(right_now, granularity="week") == "in 52 weeks")
print("test7 passed!!")
def test6():
''' Testing 52 weeks ago. '''
# the time when this code was written
right_now = arrow.Arrow(2018, 4, 16)
# less than a week ago
week_ago = arrow.Arrow(2017, 4, 16)
assert(week_ago.humanize(right_now, granularity="week") == "52 weeks ago")
print("test6 passed!!")
class Timestamps(cst.TContainerMixin):
time_int8: arrow.Arrow = cst.sfield(
cs.Timestamp(cs.Int8ul, unit=1, epoch=arrow.Arrow(2020, 1, 1))
)
time_int16: arrow.Arrow = cst.sfield(
cs.Timestamp(cs.Int16ul, unit=1, epoch=arrow.Arrow(2019, 1, 1))
)
time_int32: arrow.Arrow = cst.sfield(
cs.Timestamp(cs.Int32ul, unit=1, epoch=arrow.Arrow(2080, 1, 1))
)
def _build_timerange(period):
try:
yran = period.split('-')
except IndexError:
print("Damn! No - symbols exist!")
startdate = rrow.Arrow(int(yran[0]), 1, 1)
enddate = rrow.Arrow(int(yran[1]), 12, 31)
Timerange = namedtuple('Timerange', 'start end range')
timerange = Timerange(startdate, enddate,
rrow.Arrow.span_range('year', startdate, enddate))
return timerange
def leap_mondays(year=2016):
"""Yield leap Mondays."""
yield arrow.Arrow(year, 2, 29)
while True:
year += 4
try:
leap_day = arrow.Arrow(year, 2, 29)
except ValueError:
continue
if leap_day.format('dddd') == 'Monday':
yield leap_day
def testAutomaticRewardActiveTransportation(self):
#Create test data -- code copied from TestTimeGrouping
key = (2016, 5, 3)
test_section_list = []
#
# Since PST is UTC-7, all of these will be in the same UTC day
# 13:00, 17:00, 21:00
# so we expect the local date and UTC bins to be the same
test_section_list.append(
self._createTestSection(
arrow.Arrow(2016, 5, 3, 6, tzinfo=tz.gettz(PST)), PST))
test_section_list.append(
self._createTestSection(
arrow.Arrow(2016, 5, 3, 10, tzinfo=tz.gettz(PST)), PST))
test_section_list.append(
self._createTestSection(
arrow.Arrow(2016, 5, 3, 14, tzinfo=tz.gettz(PST)), PST))
self._fillModeDistanceDuration(test_section_list)
#logging.debug("durations = %s" % [s.data.duration for s in test_section_list])
summary_ts = earmt.group_by_timestamp(
self.testUUID,
arrow.Arrow(2016, 5, 1).timestamp,
arrow.Arrow(2016, 6, 1).timestamp, None, earmts.get_distance)
logging.debug(
"in testAutomaticRewardActiveTransportation, result = %s" %
summary_ts)
#Get user data before scoring
user_before = list(edb.get_habitica_db().find(
{'user_id': self.testUUID}))[0]['metrics_data']
self.assertEqual(int(user_before['bike_count']), 0)
habits_before = proxy.habiticaProxy(self.testUUID, 'GET',
"/api/v3/tasks/user?type=habits",
None).json()
bike_pts_before = [
habit['history'] for habit in habits_before['data']
if habit['text'] == "Bike"
]
#Score points
autocheck.reward_active_transportation(self.testUUID)
#Get user data after scoring and check results
user_after = list(edb.get_habitica_db().find(
{'user_id': self.testUUID}))[0]['metrics_data']
self.assertEqual(int(user_after['bike_count']), 1500)
habits_after = proxy.habiticaProxy(self.testUUID, 'GET',
"/api/v3/tasks/user?type=habits",
None).json()
bike_pts_after = [
habit['history'] for habit in habits_after['data']
if habit['text'] == "Bike"
]
self.assertTrue(len(bike_pts_after[0]) - len(bike_pts_before[0]) == 2)
def event(self, e):
"""
:return:
"""
if self.arrowLeft:
if self.arrowLeft.rect.collidepoint(e.pos):
del self.arrowLeft
del self.arrowRight
self.arrowLeft = None
self.arrowRight = None
# player_turn
self.chessboard.scorePlayer += self.turn(aiTurn=False,
isLeft=True)
# ai_turn
self.idxed, isLeft = self.runAlgorithm()
print 'idxed, isLeft =', self.idxed, isLeft
self.chessboard.scoreAI += self.turn(aiTurn=True,
isLeft=isLeft)
if self.arrowRight:
if self.arrowRight.rect.collidepoint(e.pos):
del self.arrowLeft
del self.arrowRight
self.arrowLeft = None
self.arrowRight = None
# player_turn
self.turn(aiTurn=False, isLeft=False)
# ai_turn
self.idxed, isLeft = self.runAlgorithm()
self.turn(aiTurn=True, isLeft=isLeft)
begin = len(self.chessqs) / 2 # 12 / 2 = 6
end = begin * 2 - 1 # 6 * 2 - 1 = 11
for i in range(begin, end, 1):
if i == dist.QUAN_1_INDEX or i == dist.QUAN_2_INDEX:
continue
if self.chessqs[i].rect.collidepoint(e.pos):
self.idxed = i
x1 = 250 + i * dist.SQUARE_WIDTH - dist.SQUARE_WIDTH / 3
x2 = 250 - dist.SQUARE_WIDTH / 3 + (4 -
i % 6) * dist.SQUARE_WIDTH
x = x1 if i < 6 else x2
y = 180 + i / 6 * dist.SQUARE_HEIGHT + dist.SQUARE_HEIGHT / 3
self.arrowLeft = arrow.Arrow(x, y, is_left=True)
self.arrowRight = arrow.Arrow(x + 1.45 * dist.SQUARE_WIDTH,
y,
is_left=False)
return self.chessboard.event(e)
def day_of_water_year(year, month, day):
eval_date = arrow.Arrow(year, month, day)
if month >= 10:
eval_year = year
else:
eval_year = year - 1 # if we're in Jan-Sep, the start of the water year was last year
water_year_start = arrow.Arrow(eval_year, 10, 1)
return (
eval_date - water_year_start
).days + 1 # add one because otherwise everything would be zero-indexed
def step_impl(context):
start = arrow.Arrow(2018, 7, 2, tzinfo="US/Eastern")
end = arrow.Arrow(2018, 7, 7, tzinfo="US/Eastern")
timestamps = [
datetime[0].timestamp
for datetime in arrow.Arrow.span_range("day", start, end)
]
context.canvas = toyplot.Canvas(width=800, height=200)
numberline = context.canvas.numberline()
numberline.axis.ticks.locator = toyplot.locator.Timestamp(
timezone="US/Eastern")
numberline.axis.ticks.show = True
numberline.scatterplot(timestamps, marker="|", size=15)
def test3():
''' Fourth test. Using the year frame spanning ~3 years. '''
# should be april 5th 2016
begin = datetime.datetime(2016, 4, 5)
# should be april 1st 2018
end = datetime.datetime(2018, 4, 1)
interval = arrow.Arrow.span_range('year', begin, end, None, None, True)
expected_interval = [
(arrow.Arrow(2016, 4, 5), arrow.Arrow(2017, 4, 4, 23, 59, 59, 999999)),
(arrow.Arrow(2017, 4, 5), arrow.Arrow(2018, 3, 31, 23, 59, 59, 999999))
]
compare_intervals(interval, expected_interval)
print('test3 passed!')
def test2():
''' Third test. Using the hour frame spanning two different days. '''
# should be april 5th 11:03 pm
begin = datetime.datetime(2018, 4, 5, 23, 3)
# should be april 6th at 1:01 am
end = datetime.datetime(2018, 4, 6, 1, 1)
interval = arrow.Arrow.span_range('hour', begin, end, None, None, True)
expected_interval = [(arrow.Arrow(2018, 4, 5, 23, 3),
arrow.Arrow(2018, 4, 6, 0, 2, 59, 999999)),
(arrow.Arrow(2018, 4, 6, 0, 3),
arrow.Arrow(2018, 4, 6, 1, 0, 59, 999999))]
compare_intervals(interval, expected_interval)
print("test2 passed!")
def test1():
''' Second test. Just one hour to another. '''
# should be april 5th 1 am
begin = datetime.datetime(2018, 4, 5, 1)
# should be april 5th 3 am
end = datetime.datetime(2018, 4, 5, 3)
interval = arrow.Arrow.span_range('hour', begin, end, None, None, True)
expected_interval = [(arrow.Arrow(2018, 4, 5, 1),
arrow.Arrow(2018, 4, 5, 1, 59, 59, 999999)),
(arrow.Arrow(2018, 4, 5, 2),
arrow.Arrow(2018, 4, 5, 2, 59, 59, 999999))]
compare_intervals(interval, expected_interval)
print("test1 passed!")
def test5():
''' Sixth test. Using the week frame spanning ~3 weeks. '''
# should be March 25th 2018 at noon
begin = datetime.datetime(2018, 3, 25, 12)
# should be April 5th 2018 at 11 am
end = datetime.datetime(2018, 4, 5, 11)
interval = arrow.Arrow.span_range('week', begin, end, None, None, True)
expected_interval = [(arrow.Arrow(2018, 3, 25, 12),
arrow.Arrow(2018, 4, 1, 11, 59, 59, 999999)),
(arrow.Arrow(2018, 4, 1, 12),
arrow.Arrow(2018, 4, 5, 10, 59, 59, 999999))]
compare_intervals(interval, expected_interval)
print('test5 passed!')
def __init__(self):
self.x_arrow = arrow.Arrow(color=[1.0, 0.0, 0.0],
vector=[1.0, 0.0, 0.0],
length=2.0,
tail=2.0)
self.y_arrow = arrow.Arrow(color=[1.0, 1.0, 0.0],
vector=[0.0, 1.0, 0.0],
length=2.0,
tail=2.0)
self.z_arrow = arrow.Arrow(color=[1.0, 1.0, 1.0],
vector=[0.0, 0.0, 1.0],
length=2.0,
tail=2.0)
def test_create_fails_if_pending_account_has_same_email():
"""
Test checks to see if an email is tied to a pending account creation entry
in logincreate. If so, login.create() will not permit another account to be
made for the same address.
"""
d.engine.execute(
d.meta.tables["logincreate"].insert(), {
"token": 40 * "a",
"username": "******",
"login_name": "existing",
"hashpass": login.passhash(raw_password),
"email": email_addr,
"birthday": arrow.Arrow(2000, 1, 1),
"unixtime": arrow.now(),
})
form = Bag(username="******",
password='******',
passcheck='0123456789',
email=email_addr,
emailcheck=email_addr,
day='12',
month='12',
year=arrow.now().year - 19)
login.create(form)
query = d.engine.scalar("""
SELECT username FROM logincreate WHERE username = %(username)s AND invalid IS TRUE
""",
username=form.username)
assert query == "test"
def parse_date(datestr):
""" Parse a date expression into a tuple of:
(start_date, span_type, span_format)
Arguments:
datestr -- A date specification, in the format of YYYY-MM-DD (dashes optional)
"""
match = re.match(r'([0-9]{4})(-?([0-9]{1,2}))?(-?([0-9]{1,2}))?(_w)?$',
datestr)
if not match:
return (arrow.get(
datestr, tzinfo=config.timezone).replace(tzinfo=config.timezone),
'day', 'YYYY-MM-DD')
year, month, day, week = match.group(1, 3, 5, 6)
start = arrow.Arrow(year=int(year),
month=int(month or 1),
day=int(day or 1),
tzinfo=config.timezone)
if week:
return start.span('week')[0], 'week', WEEK_FORMAT
if day:
return start, 'day', DAY_FORMAT
if month:
return start, 'month', MONTH_FORMAT
if year:
return start, 'year', YEAR_FORMAT
raise ValueError("Could not parse date: {}".format(datestr))
def get_gold_statistics(self):
from apps.statistics.models import Statistics
now = arrow.utcnow().to(settings.TIME_ZONE)
end = now.replace(days=1)
end = arrow.Arrow(end.year, end.month, end.day, hour=0, minute=0, second=0, microsecond=0, tzinfo=end.tzinfo)
start = end.replace(days=-7)
days = [start.replace(days=i) for i in range(1, 8)]
income = [0] * len(days)
expense = [0] * len(days)
condition = Q(char_id=self.char_id) & Q(create_at__gte=start.format("YYYY-MM-DD HH:mm:ssZ")) & Q(
create_at__lte=end.format("YYYY-MM-DD HH:mm:ssZ"))
for s in Statistics.objects.filter(condition).order_by('create_at'):
create_at = arrow.get(s.create_at).to(settings.TIME_ZONE)
# 找到这个记录应该属于哪一天
for i in range(len(days)):
if create_at < days[i]:
index = i
break
else:
index = len(days) - 1
if s.club_gold > 0:
income[index] += s.club_gold
else:
expense[index] += abs(s.club_gold)
return income, expense
