def is_today_day_of_week(day_of_week: list) -> bool:
day_of_week = list(map(lambda x: int(x), day_of_week))
if day_of_week == [0]:
return True
now = arrow.now()
today_day_of_week = now.weekday() + 1
if today_day_of_week in day_of_week:
return True
elif len(day_of_week) == 1:
value = day_of_week[0]
if value == 8 and ArrowUtil.is_weekday():
return True
elif value == 9 and not ArrowUtil.is_weekday():
return True
else:
return False
else:
return False
python类now()的实例源码
def timezones():
ct = datetime.datetime.now(pytz.utc)
timezones_by_country = [
(pytz.country_names[cc], [
(int(ct.astimezone(pytz.timezone(tzname)).strftime("%z")), tzname)
for tzname in timezones
])
for cc, timezones in pytz.country_timezones.iteritems()]
timezones_by_country.sort()
ret = []
for country, timezones in timezones_by_country:
ret.append(('- %s -' % (country,), None))
ret.extend(
("[UTC%+05d] %s" % (offset, tzname.replace('_', ' ')), tzname)
for offset, tzname in timezones)
return ret
def test_recently_popular(self):
owner = db_utils.create_user()
now = arrow.now()
sub1 = db_utils.create_submission(owner, rating=ratings.GENERAL.code, unixtime=now - datetime.timedelta(days=6))
sub2 = db_utils.create_submission(owner, rating=ratings.GENERAL.code, unixtime=now - datetime.timedelta(days=4))
sub3 = db_utils.create_submission(owner, rating=ratings.GENERAL.code, unixtime=now - datetime.timedelta(days=2))
sub4 = db_utils.create_submission(owner, rating=ratings.GENERAL.code, unixtime=now)
tag = db_utils.create_tag(u'tag')
for s in [sub1, sub2, sub3, sub4]:
db_utils.create_submission_tag(tag, s)
for i in range(100):
favoriter = db_utils.create_user()
db_utils.create_favorite(favoriter, sub2, 's', unixtime=now)
recently_popular = submission.select_recently_popular()
self.assertEqual(
[item['submitid'] for item in recently_popular],
[sub2, sub4, sub3, sub1])
def test_passwordInsecure_WeasylError_if_password_length_insufficient():
db_utils.create_user(email_addr=email_addr, username=user_name)
password = ''
form = Bag(email=email_addr, username=user_name, day=arrow.now().day,
month=arrow.now().month, year=arrow.now().year, token=token,
password=password, passcheck=password)
# Considered insecure...
for i in range(0, login._PASSWORD):
with pytest.raises(WeasylError) as err:
resetpassword.reset(form)
assert 'passwordInsecure' == err.value.value
password += 'a'
form.password = password
form.passcheck = password
# Considered secure...
password += 'a'
form.password = password
form.passcheck = password
# Success at WeasylError/forgotpasswordRecordMissing; we didn't make one yet
with pytest.raises(WeasylError) as err:
resetpassword.reset(form)
assert 'forgotpasswordRecordMissing' == err.value.value
def test_password_reset_fails_if_attempted_from_different_ip_address():
# Two parts: Set forgot password record; attempt reset with incorrect IP Address in forgotpassword table vs. requesting IP
# Requirement: Get token set from request()
user_id = db_utils.create_user(email_addr=email_addr, username=user_name)
password = '01234567890123'
form_for_request = Bag(email=email_addr, username=user_name, day=arrow.now().day,
month=arrow.now().month, year=arrow.now().year)
resetpassword.request(form_for_request)
pw_reset_token = d.engine.scalar("SELECT token FROM forgotpassword WHERE userid = %(id)s", id=user_id)
# Change IP detected when request was made (required for test)
d.engine.execute("UPDATE forgotpassword SET address = %(addr)s WHERE token = %(token)s",
addr="127.42.42.42", token=pw_reset_token)
# Force update link_time (required)
resetpassword.prepare(pw_reset_token)
form_for_reset = Bag(email=email_addr, username=user_name, day=arrow.now().day,
month=arrow.now().month, year=arrow.now().year, token=pw_reset_token,
password=password, passcheck=password)
with pytest.raises(WeasylError) as err:
resetpassword.reset(form_for_reset)
assert 'addressInvalid' == err.value.value
def test_verify_success_if_correct_information_supplied():
# Subtests:
# a) Verify 'authbcrypt' table has new hash
# b) Verify 'forgotpassword' row is removed.
# > Requirement: Get token set from request()
user_id = db_utils.create_user(email_addr=email_addr, username=user_name)
password = '01234567890123'
form_for_request = Bag(email=email_addr, username=user_name, day=arrow.now().day,
month=arrow.now().month, year=arrow.now().year)
resetpassword.request(form_for_request)
pw_reset_token = d.engine.scalar("SELECT token FROM forgotpassword WHERE userid = %(id)s", id=user_id)
# Force update link_time (required)
resetpassword.prepare(pw_reset_token)
form = Bag(email=email_addr, username=user_name, day=arrow.now().day,
month=arrow.now().month, year=arrow.now().year, token=pw_reset_token,
password=password, passcheck=password)
resetpassword.reset(form)
# 'forgotpassword' row should not exist after a successful reset
row_does_not_exist = d.engine.execute("SELECT token FROM forgotpassword WHERE userid = %(id)s", id=user_id)
assert row_does_not_exist.first() is None
bcrypt_hash = d.engine.scalar("SELECT hashsum FROM authbcrypt WHERE userid = %(id)s", id=user_id)
assert bcrypt.checkpw(password.encode('utf-8'), bcrypt_hash.encode('utf-8'))
def test_passwords_must_be_of_sufficient_length():
password = "tooShort"
form = Bag(username=user_name, password=password, passcheck=password,
email='foo', emailcheck='foo',
day='12', month='12', year=arrow.now().year - 19)
# Insecure length
with pytest.raises(WeasylError) as err:
login.create(form)
assert 'passwordInsecure' == err.value.value
# Secure length
password = "thisIsAcceptable"
form.passcheck = form.password = password
# emailInvalid is the next failure state after passwordInsecure, so it is a 'success' for this testcase
with pytest.raises(WeasylError) as err:
login.create(form)
assert 'emailInvalid' == err.value.value
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": "existing",
"login_name": "existing",
"hashpass": login.passhash(raw_password),
"email": email_addr,
"birthday": arrow.Arrow(2000, 1, 1),
"unixtime": arrow.now(),
})
form = Bag(username="test", password='0123456789', passcheck='0123456789',
email=email_addr, emailcheck=email_addr,
day='12', month='12', year=arrow.now().year - 19)
with pytest.raises(WeasylError) as err:
login.create(form)
assert 'emailExists' == err.value.value
def signin_2fa_auth_get_(request):
sess = define.get_weasyl_session()
# Only render page if the password has been authenticated (we have a UserID stored in the session)
if '2fa_pwd_auth_userid' not in sess.additional_data:
return Response(define.errorpage(request.userid, errorcode.permission))
tfa_userid = sess.additional_data['2fa_pwd_auth_userid']
# Maximum secondary authentication time: 5 minutes
session_life = arrow.now().timestamp - sess.additional_data['2fa_pwd_auth_timestamp']
if session_life > 300:
_cleanup_2fa_session()
return Response(define.errorpage(
request.userid,
errorcode.error_messages['TwoFactorAuthenticationAuthenticationTimeout'],
[["Sign In", "/signin"], ["Return to the Home Page", "/"]]))
else:
ref = request.params["referer"] if "referer" in request.params else "/"
return Response(define.webpage(
request.userid,
"etc/signin_2fa_auth.html",
[define.get_display_name(tfa_userid), ref, two_factor_auth.get_number_of_recovery_codes(tfa_userid),
None], title="Sign In - 2FA"))
def prune_databases(self):
for source in self.sources:
self.logger.log("Data Input/Pruner", "informative", "Pruning: " + source["news_api_name"])
db = source["articles_db"]
q = Query()
test_func = lambda at: arrow.get(at) < (arrow.now() - datetime.timedelta(days=1))
docs = db.search(q.at.test(test_func))
eids = [doc.eid for doc in docs]
db.remove(eids=eids)
# Entry point for process
def log(self, source, msg_type, message):
time = str(arrow.now())
message = ''.join(ch for ch in message if ch.isalnum() or ch == " ")
message_final = "[" + time + "] " + "[" + source + "] " + "[" + msg_type + "] " + "[" + message + "]"
self.message_queue.put(message_final)
def deteriorate(settings, logs):
last_entry = logs.load_last_entry()
if last_entry is None:
return
last_utc = last_entry.utc
utc_to_arrow = arrow.get(last_utc)
today = arrow.now()
deteriorate = today - utc_to_arrow
multiple_remove = int(deteriorate.days / 7)
if multiple_remove >= 1 and settings.xp * 0.8 > 199.20000000000002:
previous_xp = settings.xp
utcnow = arrow.utcnow().timestamp
for each in range(multiple_remove):
total_xp = int(settings.xp)
if total_xp >= 199.20000000000002:
total_lost = round(total_xp * 0.2)
settings.xp = round(total_xp * 0.8)
deter_entry = LogEntry()
deter_entry.average = 0
deter_entry.distance = 0
deter_entry.exercise = "DETERIORATE"
deter_entry.measuring = settings.measuring_type
deter_entry.points = 0
deter_entry.total = total_lost
deter_entry.utc = utcnow
logs.append_entry(deter_entry)
settings.commit()
xp_lost = previous_xp - settings.xp
print('Due to not logging anything for {0} days...'.format(
deteriorate.days))
print('You\'ve lost {0} XP. Your XP is now {1}'.format(
xp_lost, settings.xp))
def cardio_date_converter(raw_value, activity=None):
try:
initial_check_date = arrow.Arrow.strptime(raw_value.strip(),
'%Y-%m-%d')
check_date_strftime = arrow.Arrow.strptime(initial_check_date,
'%Y-%m-%d')
return check_date_strftime
except ValueError:
if raw_value.strip() == '':
return arrow.Arrow.strftime(arrow.now(), '%Y-%m-%d')
else:
raise ConversionFailed('Format is 1999-12-31')
def cardio_when_prompter(activity):
return Prompter(
'What time did you finish? (Format 20:30:15) (Enter for now)',
cardio_when_converter,
activity=None
)
def cardio_when_converter(raw_value, activity=None):
time_input = raw_value.strip()
time_split = time_input.split(':')
try:
if len(time_split) == 3:
hours_ = int(time_split[0])
minutes_ = int(time_split[1])
seconds_ = int(time_split[2])
when_seconds = hours_ * 3600 + minutes_ * 60 + seconds_
if when_seconds <= 86399:
log_divmod = divmod(when_seconds, 60)
when_hours = round(log_divmod[0] / 60)
when_minutes = round(log_divmod[0] % 60)
when_seconds = round(log_divmod[1])
when_time = ('{0:02d}, {1:02d}, {2:02d}'.format(when_hours,
when_minutes,
when_seconds))
return when_time
else:
raise ConversionFailed('There\'s only 24 hours in a day')
elif time_input == '':
current_time = arrow.now().time()
when_hours = current_time.hour
when_minutes = current_time.minute
when_seconds = current_time.second
when_time = ('{0:02d} {1:02d} {2:02d}'.format(when_hours,
when_minutes,
when_seconds))
return when_time
else:
raise ValueError
except ValueError:
raise ConversionFailed(
'Only digits and ":" can be used. (10:00:00)'
)
def version(inp):
"""
Output version info.
Shows bot's bio, version number, github link, and uptime.
"""
uptime = (arrow.now() - BOOTTIME)
m, s = divmod(uptime.seconds, 60)
h, m = divmod(m, 60)
return lex.version(
version=__version__, days=uptime.days, hours=h, minutes=m)
def _get_old_article(pages, scp=True):
"""Get random old tale or scp article."""
date = arrow.now().replace(days=-180).format('YYYY-MM-DD')
pages = [p for p in pages if p.created < date]
if scp:
pages = [p for p in pages if 'scp' in p.tags]
pages = [p for p in pages if p.rating >= 120]
else:
pages = [
p for p in pages if 'tale' in p.tags or 'goi-format' in p.tags]
pages = [p for p in pages if p.rating >= 60]
return random.choice(pages)
def autoban(inp, name, host):
inp.user = 'OP Alert'
if any(word in name.lower() for word in PROFANITY):
kick_user(inp, name, lex.autoban.kick.name)
ban_user(inp, host, 10)
ban_user(inp, name, 900)
return lex.autoban.name(user=name)
banlist = BANS.get(inp.channel)
if not banlist:
return
# find if the user is in the banlist
bans = [
b for b in banlist if name.lower() in b.names or
any(pat(host) for pat in b.hosts)]
for ban in bans:
try:
# check if the ban has expired
if arrow.get(ban.status, ['M/D/YYYY', 'YYYY-MM-DD']) < arrow.now():
continue
except arrow.parser.ParserError:
# if we can't parse the time, it's perma
pass
kick_user(inp, name, lex.autoban.kick.banlist(reason=ban.reason))
ban_user(inp, host, 900)
return lex.autoban.banlist(user=name, truename=ban.names[0])
