def validate_reservation(slots, slot_details):
city = utils.try_ex(lambda: slots['City'])
cuisine = utils.try_ex(lambda: slots['Cuisine'])
dinner_date = utils.try_ex(lambda: slots['Date'])
dinner_time = utils.try_ex(lambda: slots['Time'])
phone = utils.try_ex(lambda: slots['Phone'])
if city and not isvalid_city(city):
return utils.build_validation_result(
False, 'City', 'We currently only support new york. '.format(city))
if cuisine and not isvalid_cuisine(cuisine):
return utils.build_validation_result(
False, 'Cuisine',
'We currently do not support {} as a valid cuisine. Can you try a different cuisine?'
.format(cuisine))
if dinner_date:
if not isvalid_date(dinner_date):
return utils.build_validation_result(
False, 'Date', 'That is an invalid date. '
'On what date would you like to have dinner?')
if utils.get_date(dinner_date) < utils.get_today():
return utils.build_validation_result(
False, 'Date',
'Reservations must be scheduled at least one day in advance. '
'Can you try a different date?')
if dinner_time:
if utils.get_date(dinner_date) == utils.get_today(
) and not in_at_least_one_hour(dinner_time):
return utils.build_validation_result(
False, 'Time',
'Reservations must be scheduled at least one hour in advance. '
'Can you try a later hour?')
else:
if slot_details and 'Time' in slot_details.keys():
resolutions = slot_details['Time']['resolutions']
if len(resolutions) > 0:
first_resolution = resolutions[0]['value']
if first_resolution == "00:00":
slots['Time'] = "00:00"
else:
return utils.build_validation_result(
False, 'Time',
'Please let me know whether it is {}AM or {}PM. '.
format(first_resolution, first_resolution))
if phone and not isvalid_phone(phone):
return utils.build_validation_result(
False, 'Phone',
'The number you provided is invalid for a US phone. '
'Could you say your phone number again?')
return {'isValid': True}
def set_today_task(user_id, order):
table = db().Table('daily_task')
query_result = table.query(
IndexName='user_id-index',
KeyConditionExpression=Key('user_id').eq(user_id))
today = get_today()
resp = {
'exists': False,
'description': None,
}
for item in [
item for item in query_result['Items']
if item['date'] == today and item['order'] == order
]:
resp['exists'] = True
table.update_item(Key={
'daily_task_id': item['daily_task_id'],
},
UpdateExpression="set #status = :val",
ExpressionAttributeValues={
':val': 'done',
},
ExpressionAttributeNames={
"#status": "status",
})
resp['description'] = item['description']
return resp
def cal_halpha(self, stock_id):
stock_quote = StockAsset.get_stock(stock_id).quote
close = stock_quote.tcloseaf
close = close.replace(0.0, method='pad')
ret = close.pct_change()
sz = Asset.load_nav_series('120000016')
bret = sz.pct_change()
ret = ret.resample('m').sum().iloc[:-1]
bret = bret.resample('m').sum().iloc[:-1]
common_index = ret.index.intersection(bret.index)
ret = ret.loc[common_index]
bret = bret.loc[common_index]
ser = pd.Series()
if len(common_index) < 60:
return ser
for i in range(60, len(common_index)):
tmp_dates = common_index[i - 59:i + 1]
y = ret.loc[tmp_dates].values
x = bret.loc[tmp_dates].values.reshape(-1, 1)
mod = LinearRegression().fit(x, y)
ser.loc[tmp_dates[-1]] = mod.intercept_
today = get_today()
ser.loc[today] = np.nan
ser = ser.resample('d').last().fillna(method='pad')
return ser
def make_structure(blog_id, log_no, written_time, replies, crawler_version, encoding='utf-8'):
extract_crawlerTime = lambda: get_today().strftime("%Y-%m-%d %H:%M")
def reply_json(reply):
if reply.find("p") and reply.find("div", {"class":"dsc_id"}):
try:
blog_id = reply.find("div", {"class":"dsc_id"})\
.find("a")["href"].rsplit("blogId=", 1)[1]
except TypeError:
blog_id = None
return {u"content": reply.find("p").get_text(),
u"date": reply.find("span").get_text().encode("utf"),
u"blogId": blog_id}
def extract_reply(replies):
all_replies = []
for reply in range(0, len(replies)):
tmp = reply_json(replies[reply])
if tmp != None:
retmp = replies[reply].find_all("ul", {"class":"lst_repl_sub"})
re_replies = []
for re in range(0, len(retmp)):
if reply_json(retmp[re]) != None:
re_replies.append(reply_json(retmp[re]))
if re_replies != []:
tmp["reReply"] = re_replies
all_replies.append(tmp)
return all_replies
return {u"blogId": blog_id,
u"logNo": log_no,
u"crawlerVersion": crawler_version,
u"writtenTime": written_time,
u"comments": extract_reply(replies),
u"crawledTime": extract_crawlerTime()}
def Work(self,ktrName):
today = get_today();
try:
logging.info(u"正在处理ods抽取任务，执行的krs名称是"+ktrName)
#建议就把调度程序放到Kettle放到对应的文件夹下面。这样写死路径，在部署文档中标注清楚
os.system("~/Kettle/pan.sh -file=/home/python/ktr/"+ktrName+".ktr -param:NEWNAME="+ktrName+"_"+today)
except Exception as e :
logging.error(e)
self._errorResult=ktrName
def add_entry():
if not session.get('logged_in'):
return redirect(url_for('login'))
if request.method == 'POST':
new = models.News("",request.form['time'],request.form['text'], utils.get_today())
db.session.add(new)
db.session.commit()
return redirect(url_for('today_news'))
else:
return render_template('agregar.html')
def filter_candle():
global series_dict
today_df = utils.get_today()
code_list = list(today_df['code'])
series_dict = {}
# pool = Pool(20)
# pool.map(filter, code_list)
# pool.close()
# pool.join()
# utils.save_dict(series_dict, 'series_dict')
for code in code_list:
filter(code)
print series_dict
def Work(self,dw2Name):
cursor2 =get_dw2_conn.cursor()
today = get_today();
msg = cursor2.var(cx_Oracle.STRING)
ms = cursor2.callproc(dw2Name, [today, msg])
if ms[1] =="1":
self._result=dw2Name
logging.info(u" 存储过程相关依赖没有采集完成,等待采集,存储过程名称 "+dw2Name)
elif ms[1] =="3":
logging.error(u" 存储过程采集错误")
self._errorResult=dw2Name
else:
logging.info(u"successfully executed 执行成功")
def user():
content = request.json
user = User.query.filter_by(last_name=content.get('last_name')).first()
if user:
response = jsonify({'status': 302, 'message': f"Пользователь с фамилией {user.last_name} уже существует"})
response.status_code = 302
return response
db.session.add(User(**content))
db.session.commit()
new_month = Month(date=get_today(), user_last_name=content['last_name'])
db.session.add(new_month)
db.session.commit()
response = jsonify({'status': 201, 'message': "Created"})
response.status_code = 201
return response
def make_structure(blog_id,
log_no,
written_time,
replies,
crawler_version,
encoding='utf-8'):
extract_crawlerTime = lambda: get_today().strftime("%Y-%m-%d %H:%M")
def reply_json(reply):
if reply.find("p") and reply.find("div", {"class": "dsc_id"}):
try:
blog_id = reply.find("div", {"class":"dsc_id"})\
.find("a")["href"].rsplit("blogId=", 1)[1]
except TypeError:
blog_id = None
return {
u"content": reply.find("p").get_text(),
u"date": reply.find("span").get_text().encode("utf"),
u"blogId": blog_id
}
def extract_reply(replies):
all_replies = []
for reply in range(0, len(replies)):
tmp = reply_json(replies[reply])
if tmp != None:
retmp = replies[reply].find_all("ul",
{"class": "lst_repl_sub"})
re_replies = []
for re in range(0, len(retmp)):
if reply_json(retmp[re]) != None:
re_replies.append(reply_json(retmp[re]))
if re_replies != []:
tmp["reReply"] = re_replies
all_replies.append(tmp)
return all_replies
return {
u"blogId": blog_id,
u"logNo": log_no,
u"crawlerVersion": crawler_version,
u"writtenTime": written_time,
u"comments": extract_reply(replies),
u"crawledTime": extract_crawlerTime()
}
def get_today_task(user_id):
table = db().Table('daily_task')
result = table.query(IndexName='user_id-index',
KeyConditionExpression=Key('user_id').eq(user_id))
today = get_today()
today_task = []
for item in [item for item in result['Items'] if item['date'] == today]:
today_task.append({
'status': item['status'],
'description': item['description'],
'order': item['order'],
})
return today_task
def index():
if os.path.isfile("./credentials.json"):
yourcalendar = calendar_api()
day_data = yourcalendar.get_pie_chart_data_for_day()
week_data = yourcalendar.get_pie_chart_data_for_week()
column_chart = yourcalendar.get_column_chart_data_for_next_x_weeks(4)
today = get_today()
monday = get_monday_this_week_dt()
next_week_monday = get_one_week_from_dt(monday)
return render_template("index.html",
day_data=day_data,
week_data=week_data,
column_chart=column_chart,
today=today,
monday=monday,
next_week_monday=next_week_monday)
else:
return redirect(url_for("credential_form"))
def api():
token = request.headers.get('Authorization')
content = request.json
if token and token.startswith('Basic') and len(content):
fetched_content = content.pop()
parsed_key = base64.b64decode(token.split()[1]).decode('utf-8')
user = User.get_user(parsed_key)
if user and fetched_content:
payload = dict()
payload['user_last_name'] = user.last_name
payload_for_today = Payload.check_today(user.last_name)
current_month = Month.check_month(user.last_name)
if payload_for_today:
last_time = payload_for_today.last_time
current_time = get_time(fetched_content['time'])
delta = hms_to_m(make_delta(last_time, current_time))
if delta > 10:
payload_for_today.last_time = current_time
db.session.commit()
return Response(status='200')
current_day = Day.get_current_day(user.last_name)
payload['date'] = get_today()
payload['running_min'] = delta
if current_day:
current_day_running_min = current_day.running_min
current_day.running_min = current_day_running_min + delta
else:
db.session.add(Day(**payload))
if current_month:
current_month_running_min = current_month.running_min
current_month.running_min = current_month_running_min + delta
else:
db.session.add(Month(**payload))
payload_for_today.last_time = current_time
db.session.commit()
else:
payload['last_time'] = get_time(fetched_content['time'])
db.session.add(Payload(**payload))
db.session.commit()
return Response(status='200')
def sendETLEmail(p):
_user = "******"
_pwd = "nmtvjrlabeyeecdi"
_to = "*****@*****.**"
file_name = settings.addressee #附件名（带路径）
#如名字所示Multipart就是分多个部分
msg = MIMEMultipart()
msg["Subject"] = "ETL调度未跑完的任务"
msg["From"] = _user
msg["To"] = _to
today = get_today()
#---这是文字部分---
line1 = "您好："
line2 = "今天" + str(today) + "的统计内容，数据详情请看附件"
line3 = "武汉天喻教育大数据组"
part = MIMEText(
"<font><font size=3 color='#ff0000' >采集报警:</font><br >%s<br>%s<br float:right>%s<br></font>"
% (line1, line2, line3), "html", "utf-8")
msg.attach(part)
#---这是附件部分---
#xlsx类型附件
## 读入文件内容并格式化 [方式1]－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
data = open(file_name, 'rb')
ctype, encoding = mimetypes.guess_type(file_name)
if ctype is None or encoding is not None:
ctype = 'application/octet-stream'
maintype, subtype = ctype.split('/', 1)
file_msg = smtplib.email.MIMEBase.MIMEBase(maintype, subtype)
file_msg.set_payload(data.read())
data.close()
smtplib.email.Encoders.encode_base64(file_msg) #把附件编码
basename = os.path.basename(file_name)
file_msg.add_header('Content-Disposition', 'attachment',
filename=basename) #修改邮件头
msg.attach(file_msg)
s = smtplib.SMTP_SSL("smtp.qq.com") #连接smtp邮件服务器,端口默认是25
s.login(_user, _pwd) #登陆服务器
s.sendmail(_user, _to, msg.as_string()) #发送邮s件
s.close()
def lambda_handler(event, context):
print('event received', event)
# handle confirmation
today = utils.get_today()
leetcode_client = LeetCode('', COOKIE)
handle_ack(event, leetcode_client, today)
user, done, remaining = leetcode_client.get_problems(
category_slug=CATEGORY_SLUG)
# filter today's problems from done
today_probs = db.get_problems(today)
done = filter_today_probs(done, today_probs)
new, old = leetcode_client.get_next_problems(done, remaining)
user['problems'] = [{new[0]: new[1]}, {old[0]: old[1]}]
# print(user)
user['todayCount'] = len(today_probs)
payload = json.dumps(user)
print(payload)
client.publish(topic=IOT_TOPIC, payload=payload)
def cal_btsg(self, stock_id):
stock_quote = StockAsset.get_stock(stock_id).quote
close = stock_quote.tcloseaf
close = close.replace(0.0, method='pad')
ret = close.pct_change()
sz = Asset.load_nav_series('120000016')
bret = sz.pct_change()
ret = ret.resample('m').sum().iloc[:-1]
bret = bret.resample('m').sum().iloc[:-1]
common_index = ret.index.intersection(bret.index)
ret = ret.loc[common_index]
bret = bret.loc[common_index]
ser = pd.Series()
if len(common_index) < 60:
return ser
for i in range(60, len(common_index)):
tmp_dates = common_index[:i + 1]
y = ret.loc[tmp_dates].values
x = bret.loc[tmp_dates].values.reshape(-1, 1)
x = sm.add_constant(x)
mod = sm.OLS(y, x).fit()
beta = mod.params[1]
sigma = mod.resid.std()
btsg = pow(beta * sigma, 0.5)
ser.loc[tmp_dates[-1]] = btsg
today = get_today()
ser.loc[today] = np.nan
ser = ser.resample('d').last().fillna(method='pad')
return ser
def index():
today = get_today()
db = pickledb.load('/mubier/mubier/json.db', True, False)
movies = db.get(today)
if movies is False:
# serve cold data.
yesterday = get_yesterday()
movies = db.get(yesterday)
order = int(request.args.get('order', 0))
movie = movies[order]
try:
movies[order + 1]
next_url = f"/?order={order + 1}"
except IndexError:
next_url = "/"
movie["next_url"] = next_url
return render_template('index.html', **movie)
def home():
# return redirect(url_for('show_reportes'))
return redirect(url_for('show_news', fecha_raw= utils.get_today()))
from datetime import datetime
import pickledb
import time
from utils import fetch_movies_of_today, get_today
while True:
today = get_today()
db = pickledb.load('/mubier/mubier/json.db', True, False)
movies = db.get(today)
if movies is False:
movies = fetch_movies_of_today()
db.set(today, movies)
print(f"Sleeping for 15 minutes. ({datetime.now().isoformat()})")
time.sleep(60 * 15)
print(f"Waking up. ({datetime.now().isoformat()})")
def main():
# Make Google API object
sheets_api = utils.google_sheets_login()
# Set variables
spreadsheet_id = vrs.spreadsheet_id
room_mapping = vrs.room_mapping
sheet_options = vrs.sheet_options
full_range = vrs.full_range
lookahead = vrs.lookahead_days
# Determine which days to check for.
# Find index of today's date
today_date = utils.get_today(skip_weekends=True)
day_index = -1
for idx, date in enumerate(sheet_options):
if today_date in date:
day_index = idx
break
if day_index == -1:
raise IndexError("Today's date not found within sheet_options."
"If Mentor Madness has ended, please shut off this"
"update script.")
# Set the days to check, without worrying about going past the program end
sheet_names = [sheet_options[day_index]]
idx = 1
while lookahead > 0:
try:
sheet_names.append(sheet_options[day_index + idx])
idx += 1
lookahead -= 1
except IndexError:
break
# Create holding variables for adding and deleting messages
adding_msgs = []
deleting_msgs = []
for day in sheet_names:
# String formatting for API query and file saving
sheet_query = day + '!' + full_range
csv_name = utils.day_to_filename(day)
# Make request for sheet
sheet = sheets_api.spreadsheets().values().get(
spreadsheetId=spreadsheet_id, range=sheet_query).execute()
new_sheet = sheet['values']
for idx, new_sheet_row in enumerate(new_sheet):
if len(new_sheet_row) < vrs.row_length:
new_sheet[idx].extend([''] *
(vrs.row_length - len(new_sheet_row)))
# Load old sheet
old_sheet = open(csv_name, 'r')
reader = csv.reader(old_sheet)
row_counter = 0
for old_row in reader:
new_row = new_sheet[row_counter]
timeslot = new_row[0]
# Make rows the same length if they are not
if len(old_row) < len(new_row):
old_row.extend([''] * (len(new_row) - len(old_row)))
elif len(old_row) > len(new_row):
new_row.extend([''] * (len(old_row) - len(new_row)))
# Iterate over rooms
for room_num in range(1, len(room_mapping) + 1):
# Get descriptive variables of room
room_dict = room_mapping[room_num]
room_name = room_dict['name']
mentor_name = new_row[room_dict['mentor_col']]
for col_num in room_dict['check_range']:
old_name = old_row[col_num]
new_name = new_row[col_num]
if new_name != old_name:
new_event_dict = {
'time': timeslot,
'name': new_name,
'mentor': mentor_name,
'room_num': str(room_num),
'room_name': room_name,
'day': day
}
old_event_dict = {
'time': timeslot,
'name': old_name,
'mentor': mentor_name,
'room_num': str(room_num),
'room_name': room_name,
'day': day
}
if new_name and old_name:
# Someone was changed, assuming the names are different
if utils.process_name(
new_name) != utils.process_name(old_name):
deleting_msgs.append(old_event_dict)
adding_msgs.append(new_event_dict)
else:
continue
elif old_name:
# Someone was deleted
deleting_msgs.append(old_event_dict)
elif new_name:
# Someone was added
adding_msgs.append(new_event_dict)
row_counter += 1
# Save the sheet
old_sheet.close()
old_sheet = open(csv_name, 'w')
writer = csv.writer(old_sheet)
writer.writerows(new_sheet)
email_sender.send_update_mail(adding_msgs, deleting_msgs)
gcal_scheduler.add_cal_events(adding_msgs)
gcal_scheduler.delete_cal_events(deleting_msgs)
def main(team=None,
send_today=False,
specific_day=None,
send_emails=True,
create_calendar_events=False):
# Make Google API object
sheets_api = utils.google_sheets_login()
# Set variables
spreadsheet_id = vrs.spreadsheet_id
room_mapping = vrs.room_mapping
full_range = vrs.full_range
sheet_options = vrs.sheet_options
# Determine which day to send for
# The default is the following business day
if send_today:
match_day = utils.get_today(skip_weekends=True)
else:
match_day = utils.get_next_day()
if specific_day:
match_day = specific_day
# Pick out the appropriate sheet names from the list
sheet_names = [x for x in sheet_options if match_day in x]
if team is None:
name_dict = dr.empty_name_dict
else:
name_dict = {}
if isinstance(team, list):
for t in team:
name_dict[t] = []
else:
name_dict[team] = []
for day in sheet_names:
# String formatting for API query and file saving
sheet_query = day + '!' + full_range
# Make request for sheet
sheet = sheets_api.spreadsheets().values().get(
spreadsheetId=spreadsheet_id, range=sheet_query).execute()
new_sheet = sheet['values']
new_sheet = new_sheet[1:] # Get rid of the header row
for idx, new_sheet_row in enumerate(new_sheet):
if len(new_sheet_row) < vrs.row_length:
new_sheet[idx].extend([''] *
(vrs.row_length - len(new_sheet_row)))
# Add a spacer dict to separate days
spacer_dict = {
'time': None,
'mentor': None,
'room_num': None,
'room_name': None,
'day': day
}
for key, val in name_dict.items():
name_dict[key].append(spacer_dict)
for row in new_sheet:
timeslot = row[0]
# Iterate over rooms
for room_num in range(1, len(room_mapping) + 1):
# Get descriptive variables of room
room_dict = room_mapping[room_num]
room_name = room_dict['name']
mentor_name = row[room_dict['mentor_col']]
for col_num in room_dict['check_range']:
name = utils.process_name(row[col_num])
if name and name != 'not_found' and name in name_dict.keys(
):
new_event_dict = {
'time': timeslot,
'mentor': mentor_name,
'name': name,
'room_num': str(room_num),
'room_name': room_name,
'day': day
}
name_dict[name].append(new_event_dict)
print('Got info for ' + day)
try:
if create_calendar_events:
for name, event_list in name_dict.items():
# event_list['name'] = name
gcal_scheduler.add_cal_events(event_list)
except Exception:
traceback.print_exc()
if send_emails:
try:
email_sender.send_daily_mail(name_dict)
except Exception:
traceback.print_exc()
return None
else:
return name_dict
def today_news():
return redirect(url_for('show_news', fecha_raw= utils.get_today()))
def Reserve(self):
self.open_page2("https://jayurocc.com/Reservation/Reservation")
self.close_popup_class("pointBtn")
self.GoToReservation(utils.get_today(), utils.get_target(21))
def Reserve(self):
print("Reserve")
self.GoToReservation(utils.get_today(), utils.get_target(21))
#! /usr/bin/env python
# -*- coding: utf-8 -*-
import utils
# 活动列表时间类型
TIME_TYPE_TODAY = '1'
TIME_TYPE_TOMORROW = '2'
TIME_TYPE_WEEKS = '3'
TIME_TYPE_MONTH = '4'
# 时间类型映射
LIMIT_TIME = {
TIME_TYPE_TODAY: utils.get_today(),
TIME_TYPE_TOMORROW: utils.get_tomorrow(),
TIME_TYPE_WEEKS: utils.get_week(),
TIME_TYPE_MONTH: utils.get_month()
}
def get_tasks_for_day(self):
start, end = get_today(), get_tomorrow()
return self.get_tasks_between_start_and_end(start, end)