def udtPinStatus():
getPinId = request.form['pId']
getPinStatus = request.form['pinStatus']
Dao.udtPinStatus({"pinId": getPinId, "pinStatus": getPinStatus})
retData = {}
retData['result'] = 200
retData['err'] = ''
retData['data'] = ''
return json.dumps(retData)
def restDeviceManageRegistOk():
getDeviceName = request.form['deviceName']
getDeviceIp = request.form['deviceIp']
getDevicePort = request.form['devicePort']
getPinNo = request.form['pinNo']
Dao.insDevice({'uId': uuid.uuid4().get_hex(), 'userId':data['userId'], 'deviceName':getDeviceName, 'deviceIp':getDeviceIp, 'devicePort':getDevicePort, 'pinNo':getPinNo})
retData = {}
retData['result'] = 200
retData['err'] = ''
retData['data'] = ''
return json.dumps(retData)
def signonRegist():
session.clear()
getUserId = request.form['userId']
getUserPw = request.form['userPw']
getUserName = request.form['userName']
Dao.insUser({'userId': getUserId, 'userPw': getUserPw, 'userName': getUserName})
session['auth'] = getUserId
data["userId"] = getUserId
data["userName"] = getUserName
return json.dumps({'result':200, 'err':'', 'data':''})
def validUserCheck():
getUserId = request.form['userId']
duplChkRs = Dao.userDuplicateCheck({"userId": getUserId})
retData = {}
if ( duplChkRs[0] == 0 ):
retData['result'] = 200
else:
retData['result'] = 100
return json.dumps(retData)
def getDevice():
retData = {}
getUserId = request.form['userId']
retData['data'] = Dao.getDevice({'userId': getUserId})
if ( retData['data'] != None ):
retData['result'] = 200
retData['err'] = ''
else:
retData['result'] = 100
retData['err'] = 'no result'
return json.dumps(retData)
def auth():
getUserId = request.form['userId']
getUserPw = request.form['userPw']
retValidUser = Dao.userLoginCheck({"userId": getUserId, "userPw": getUserPw})
if ( retValidUser != None and len(retValidUser) > 0 ):
session['auth'] = retValidUser[0]
data["userId"] = retValidUser[0]
data["userName"] = retValidUser[1]
ret = {"result": 200, "err": ""} # success
else:
ret = {"result": 100, "err": ""} # failure
return json.dumps(ret)
def __init__(self):
self.client = HttpClient.HttpClient()
self.dao = Dao.Mysql()
pass
def delete(student_Id):
dao = Dao()
deleted=dao.delete(student_Id)
return deleted
def readingBreedById(searchById):
print("Read Breed record:")
d.readByIdBreed(searchById)
def func_get_user_food(user_info):
try:
return Dao.get_all_user_food(user_info["id"])
except:
print("exception provoked from function.func_get_user_food")
def get_code_price(datestr, timestr):
code_price = {}
code_pre_close = {}
code_open = {}
arrFromDB = dao.select(
"select code, price, pre_close, open from t_security_timepoint_price where datestr=%s and timestr=%s",
(datestr, timestr))
if arrFromDB.__len__() > 0:
for item in arrFromDB:
code_price.setdefault(item['code'], item['price'])
code_pre_close.setdefault(item['code'], item['pre_close'])
code_open.setdefault(item['code'], item['open'])
return {
'code_price': code_price,
'code_pre_close': code_pre_close,
'code_open': code_open
}
#dao.update("delete from t_security_timepoint_price where datestr=%s and timestr=%s", (datestr,timestr))
pre_open_date = util.preOpenDate(datestr)
str_datestr = str(int(datestr.split('-')[1])) + "." + str(
int(datestr.split('-')[2]))
str_pre_open_datestr = str(int(pre_open_date.split('-')[1])) + "." + str(
int(pre_open_date.split('-')[2]))
soups = cr.getSoupsFromWencai(str_datestr + "日" + timestr + "价格；" +
str_datestr + "日开盘价；" +
str_pre_open_datestr +
"日收盘价；a股；所属概念；所属同花顺行业；")
code_name = {}
for soup in soups:
es_code = soup.select(
'#resultWrap .static_con_outer .tbody_table tr td.item div.em')
index = 0
codes = []
while index < es_code.__len__():
o_str = es_code[index].text.strip()
if (o_str.isdigit()):
codes.append(o_str)
code = o_str
index = index + 1
o_str = es_code[index].text.strip()
code_name.setdefault(code, o_str)
index = index + 1
es_c0 = soup.select('#resultWrap .scroll_tbody_con .tbody_table tr')
count = 0
for el in es_c0:
a_el = el.select('td.item.sortCol div.em')[0]
code = codes[count]
if a_el.text.strip() == '--':
code_price.setdefault(code, 0)
print('Code: ' + code + '->Price: ' + str(0))
continue
price = float(a_el.text.strip())
code_price.setdefault(code, price)
print('Code: ' + code + '->Price: ' + str(price))
count = count + 1
es_c0 = soup.select('#resultWrap .scroll_tbody_con .tbody_table tr')
count = 0
for el in es_c0:
a_el = el.select('td[colnum="5"] div.em')[0]
code = codes[count]
if a_el.text.strip() == '--':
code_open.setdefault(code, 0)
print('Code: ' + code + '->Open: ' + str(0))
continue
open = float(a_el.text.strip())
code_open.setdefault(code, open)
print('Code: ' + code + '->Open: ' + str(open))
count = count + 1
es_c0 = soup.select('#resultWrap .scroll_tbody_con .tbody_table tr')
count = 0
for el in es_c0:
a_el = el.select('td[colnum="6"] div.em')[0]
code = codes[count]
if a_el.text.strip() == '--':
code_pre_close.setdefault(code, 0)
print('Code: ' + code + '->Pre_close: ' + str(0))
continue
pre_price = float(a_el.text.strip())
code_pre_close.setdefault(code, pre_price)
print('Code: ' + code + '->Pre_price: ' + str(pre_price))
count = count + 1
arr_values = []
for code in code_price.keys():
price = code_price[code]
pre_close = code_pre_close[code]
open = code_open[code]
arr_values.append((code, price, pre_close, open, datestr, timestr))
dao.updatemany(
"insert into t_security_timepoint_price(code, price, pre_close, open, datestr, timestr) values(%s,%s,%s,%s,%s,%s)",
arr_values)
return {
'code_price': code_price,
'code_pre_close': code_pre_close,
'code_open': code_open
}
#print(get_code_price('2018-08-03', '9:50'))
def deleteAll():
dao=Dao()
dao.deleteAll()
return
def get_by_id(product_Id):
dao = Dao()
product = dao.get_by_id(product_Id)
if not product:
return None
return Model(product)
def get_by_id(student_Id):
dao = Dao()
student = dao.get_by_id(student_Id)
if not student:
return None
return Model(student)
def __init__(self,
security='RB1901.XSGE',
status=Status(),
ctaTemplate=None,
enableTrade=False,
frequency='4m',
pricePosi_top=0,
pricePosi_bottom=1,
dayStartTime='09:00:20',
dayEndTime='10:14:00',
noonStartTime='10:30:00',
noonEndTime='11:29:00',
afternoonStartTime='13:30:00',
afternoonEndTime='14:59:00',
nightStartTime='21:00:00',
nightEndTime='22:59:00',
jqDataAccount='13268108673',
jqDataPassword='******'):
self.enableTrade = enableTrade
self.ctaTemplate = ctaTemplate
self.status = status
self.jqDataAccount = jqDataAccount
self.jqDataPassword = jqDataPassword
# self.jqDataAccount = '13824472562'
# self.jqDataPassword = '******'
self.frequency = frequency
self.dataRow = 200
self.pricePosi_top = pricePosi_top
self.pricePosi_bottom = pricePosi_bottom
self.lastExeTime = None
self.security = security
self.pricePositions = []
self.maxPosition = dao.readMaxPosition(security)
self.duo_position = dao.readDuoPosition(security) # 多单持仓手数
self.kong_position = dao.readKongPosition(security) # 空单持仓手数
self.writeCtaLog('########################jqdata账号：' +
str(self.jqDataAccount))
self.writeCtaLog('########################合约代码：' + str(self.security))
self.writeCtaLog('########################多单持仓：' +
str(self.duo_position))
self.writeCtaLog('########################空单持仓：' +
str(self.kong_position))
self.writeCtaLog('########################最大持仓：' +
str(self.maxPosition))
self.writeCtaLog('########################策略级别：' + str(self.frequency))
self.writeCtaLog('########################允许交易：' +
str(self.enableTrade))
self.writeCtaLog('########################单次获取数据行：' +
str(self.dataRow))
self.writeCtaLog('########################EMA5-Posi-top：' +
str(self.pricePosi_top))
self.writeCtaLog('########################EMA5-Posi-bottom：' +
str(self.pricePosi_bottom))
self.dayStartTime = dayStartTime
self.dayEndTime = dayEndTime
self.noonStartTime = noonStartTime
self.noonEndTime = noonEndTime
self.afternoonStartTime = afternoonStartTime
self.afternoonEndTime = afternoonEndTime
self.nightStartTime = nightStartTime
self.nightEndTime = nightEndTime
def restDeviceManageDeleteOk():
getDeviceUid = request.form.getlist('deviceUid')
Dao.delDevice({'uId':getDeviceUid})
return json.dumps({'result':200, 'err':'', 'data':''})
select = b.find('select')
if select != None:
options = select.findAll('option')
if len(options) > 0:
others = map(lambda x: x.get('value'), options)
resp['links'].extend(others)
# Look for other pages with links to listings
days = b.findAll('a', {'class': 'days_whch'})
resp['links'].extend(map(lambda day: day.get('href'), days))
# Look for properties pages
properties = b.findAll('td', {'class': 'addr_pcct'})
for prop in properties:
link = prop.find('a').get('href')
resp['links'].append(link)
return resp
################################################
# Instantiate Crawler and execute
################################################
dao = Dao.Dao(access_key, secret_key, bucket_name)
crawler = Crawler.Crawler(dao, expiration_rules, parse_detail_page,
process_content)
#rootpage = 'http://www.everyhome.com/Homes-For-Sale-By-Listing-Date/Mercer-County-New-Jersey'
def lambda_handler(event, context):
crawler.process_queue(event['queue'], verbose=True)
def readingPupperById(searchById):
print("Read Pupper record:")
d.readByIdPupper(searchById)
def func_get_target_protein(user_info):
try:
return Dao.get_target_protein(user_info["id"])
except:
print("exception provoked from function.func_get_target_protein")
def __init__(self):
self.dao = Dao()
from flask import Flask, jsonify, Response, request
import time
import requests
import json
import Dao as dao
from pykafka import KafkaClient
from pykafka.common import OffsetType
import json
dataBaseHelper = dao.DBHelper()
app = Flask(__name__)
@app.route('/registerNewSensorClass/<sensorDetails>')
def register_sensors(sensorDetails):
y = eval(sensorDetails)
#print("\n\n\nCHECKOUT SENSOR REGISTRATION", dataBaseHelper.registerNewSensorClass(y))
#print(str(json.dumps(dataBaseHelper.registerNewSensorClass(y))))
return str(json.dumps(dataBaseHelper.registerNewSensorClass(y)))
@app.route('/makeSensorInstances/<instanceDetails>')
def make_instances_of_sensors(instanceDetails):
y = eval(instanceDetails)
#print("\n\n\nCHECKOUT SENSOR INSTANCES", dataBaseHelper.makeSensorInstances(y))
return dataBaseHelper.makeSensorInstances(y)
@app.route('/getSensorIdByLocation/<sensorLocation>')
class DaoImpl:
TAG = "DaoImpl"
dao = None
def __init__(self):
self.dao = Dao()
def select_one_from_email(self, useremail):
user = User()
conn = self.dao.getConn()
cur = conn.cursor()
sql = "select * from users u where u.userEmail = %s"
param = (useremail, )
row_number = cur.execute(sql, param)
if row_number > 1:
Log.e(self.TAG, 'userEmail:%s is not unique' % useremail)
# acutally here cannot return None
return None
if row_number == 0:
Log.w(self.TAG, 'no rows is selected')
return None
# here the row_number should be 1
rows = cur.fetchall()
r = rows[0] # the first and the last record of the query set
user.setUsername(r[0])
user.setEmail(r[1])
user.setPassword(r[2])
user.setVip(r[3])
self.dao.closeAll(cur, conn)
return user
def insert_user(self, user):
sql = "insert into users values (%s,%s,%s,%s)"
param = (user.getUsername(), user.getEmail(), user.getPassword(),
user.getVip())
Log.i(self.TAG, str(param))
# print("inser Sql is "+ sql)
conn = self.dao.getConn()
cur = conn.cursor()
row_number = cur.execute(sql, param)
conn.commit()
self.dao.closeAll(cur, conn)
if row_number == 1:
return True
return False
def select_words(self,
number_of_words,
book_name,
pick_style,
from_word=""):
sql = ""
words_array = []
conn = self.dao.getConn()
cur = conn.cursor()
Log.i(self.TAG, 'get into select_words')
if pick_style == 'first':
# check if total words number is larger than the required number
# if less than, pick the rest words
total_row_number = self.get_row_number(book_name)
if total_row_number < number_of_words:
number_of_words = total_row_number
Log.w(
self.TAG,
"the required words number is larger than the total number of words!"
)
sql = "select * from words where words.book=%s limit %s"
param = (book_name, number_of_words)
row_number = cur.execute(sql % param)
Log.i(
self.TAG, "select %s words from book %s <style=first>" %
(number_of_words, book_name))
elif pick_style == 'random':
sql = "select * from words where words.book='%s' order by rand() limit %s"
param = (book_name, number_of_words)
row_number = cur.execute(sql % param)
Log.i(
self.TAG, "select %s words from book %s <style=random>" %
(number_of_words, book_name))
elif pick_style == 'continuous':
# check if rest words number is larger than the required number
# if less than, pick the rest words
rest_row_number = self.get_row_number(book_name, from_word)
if rest_row_number > number_of_words:
number_of_words = rest_row_number
Log.w(
self.TAG,
"the required words number is larger than the rest rows of number from %s"
% from_word)
sql = "select * from words where words.book=%s words.word>%s limit %s"
param = (book_name, from_word, number_of_words)
row_number = cur.execute(sql, param)
Log.i(
self.TAG, "select %s words from book %s <style=continuous>" %
(number_of_words, book_name))
elif pick_style == 'total':
# if pick all of the words in one book
sql = "select * from words where words.book=%s"
param = (book_name, )
row_number = cur.execute(sql, param)
Log.i(self.TAG, " select all words from the book %s" % book_name)
else:
Log.w(self.TAG, "Unknown pick_style %s" % pick_style)
rows = cur.fetchall()
for r in rows:
# print r
tmp_word = dict()
tmp_word['word'] = r[0]
tmp_word['phonetic'] = r[1]
tmp_word['interp'] = r[2]
tmp_word['book'] = r[3]
tmp_word['id'] = r[4]
tmp_word['r'] = r[5]
tmp_word['w'] = r[6]
words_array.append(json.dumps(tmp_word))
# print words_array
Log.i(self.TAG, "length" + str(len(words_array)))
self.dao.closeAll(cur, conn)
return words_array
def get_row_number(self, table_name, from_word=""):
"""
Get total number of the rows in the specific table after the 'from_word'.
If from_word = "", which means the total number of the rows in the table.
@param: from_word: from which word the count begins?
@param: table_name: book_name
"""
Log.w(self.TAG, 'from_word:' + from_word)
if from_word == "":
sql = "select count (*) from words where words.book=%s"
param = (table_name, )
else:
sql = "select count (*) from words where words.book=%s words.word>%s"
param = (table_name, from_word)
conn = self.dao.getConn()
cur = conn.cursor()
Log.i(self.TAG, 'execute sql:' + sql)
####### !!! attention!!! table name cannot use as the param!
row_number = cur.execute(sql, param)
rows = cur.fetchall()
# Log.i(self.TAG, 'row_number'+row_number)
if row_number > 1:
Log.e(self.TAG, 'Error in get number of row: multiple columns')
# acutally here cannot return None
return 0
# here only 1/0 column is influenced
r = rows[0]
row_number = r[0]
self.dao.closeAll(cur, conn)
return row_number
def readAllBreeds():
print("ALL BREEDS: ")
d.readBreed()
def addProduct(productInfo):
dao = Dao()
new= dao.addProduct(productInfo)
if not new:
return None
return Model(new)
def findItem(name):
print("Find Pupper By name:")
d.findPuppersByName(name)
def refresh_BaseConceptAndIndustryData():
print("refresh_BaseConceptAndIndustryData: 在网络上获取信息，保存证券、概念、行业关系信息")
dao.update("truncate table t_security_concept", ())
dao.update("truncate table t_security_industry", ())
soups = cr.getSoupsFromWencai("a股；所属概念；所属同花顺行业；")
code_concepts = {}
code_industrys = {}
industry_level = {}
code_name = {}
for soup in soups:
es_code = soup.select(
'#resultWrap .static_con_outer .tbody_table tr td.item div.em')
index = 0
codes = []
while index < es_code.__len__():
o_str = es_code[index].text.strip()
if (o_str.isdigit()):
codes.append(o_str)
code = o_str
code_concepts.setdefault(o_str, [])
index = index + 1
o_str = es_code[index].text.strip()
code_name.setdefault(code, o_str)
index = index + 1
# 概念获取
es_c0 = soup.select('#tableWrap .scroll_tbody_con .scroll_table tr')
count = 0
for el in es_c0:
a_els = el.select('td[colnum="5"] div span.fl a')
code = codes[count]
for a_el in a_els:
concept = a_el.text.strip()
code_concepts[code].append(concept)
print('Code: ' + code + '->Concept: ' + concept)
count = count + 1
# 行业获取
es_c1 = soup.select('#tableWrap .scroll_tbody_con .scroll_table tr')
count = 0
for el in es_c1:
a_els = el.select('td[colnum="6"] div span.fl a')
code = codes[count]
level = 1
for a_el in a_els:
industry = a_el.text.strip()
if code not in code_industrys.keys():
code_industrys.setdefault(code, [industry])
else:
code_industrys[code].append(industry)
if industry not in industry_level.keys():
industry_level.setdefault(industry, level)
print('Code: ' + code + '->industry: ' + industry +
'->Level: ' + str(level))
level = level + 1
count = count + 1
values = []
for code in code_concepts.keys():
concepts = code_concepts[code]
_values = [(code, code_name[code], concept) for concept in concepts]
values = values + _values
# for concept in concepts:
# name = code_name[code]
# values.append((code, name, concept))
dao.updatemany(
'insert into t_security_concept(code, name, concept) values(%s,%s,%s)',
values)
values = []
for code in code_industrys.keys():
industrys = code_industrys[code]
_values = [(code, code_name[code], industry, industry_level[industry])
for industry in industrys]
values = values + _values
# for industry in industrys:
# name = code_name[code]
# level = industry_level[industry]
# values.append((code, name, industry, level))
dao.updatemany(
'insert into t_security_industry(code, name, industry, level) values(%s,%s,%s,%s)',
values)
def insertBreedItem(breedObj):
print("Insert Breed Record: ")
d.addBreed(breedObj)
def reading(searchById):
d.readByIdBreed(searchById)
d.readByIdPupper()
def func_get_bmi(user_info):
try:
return Dao.get_bmi(user_info["id"])
except:
print("exception provoked from function.func_get_calories")
from Dao import *
d=Dao()
res=d.selectSmemory()
print dir(res)
for rec in res:
print rec
def covert_to_str(ts_stock):
res = ts_stock["ts_code"] + " "
res = res + "name:" + str(ts_stock["name"]) + " "
res = res + "industry:" + str(ts_stock["industry"]) + " "
res = res + "market:" + str(ts_stock["market"]) + " "
return res
def get_rsi_diff(rsi, i):
return rsi["RSI_6"][i] * 2 - rsi["RSI_12"][i] - rsi["RSI_24"][i]
if __name__ == "__main__":
engine = create_engine('mysql://*****:*****@127.0.0.1:3333/stock_db')
dao = Dao.sqldao(engine)
token_file = open("token.key", mode='r')
token = token_file.read()
ts = tsmodel.tsclass(token)
stock_list = ts.get_stock_list()
#todo update code_list when has new stock
if datetime.date.today().weekday() == 0:
stock_list.to_sql('stock_list_info', con=engine, if_exists="replace")
for code in stock_list["ts_code"]:
log("start " + code)
data = td.tsdata(ts, code)
rsi = data.rsi(engine)
if rsi.size < 30:
def readAllPuppers():
print("ALL PUPPERS: ")
d.readPupper()
#-*- coding:utf-8 -*-
#读取d2017.bin 用于对创新度的计算，将数据存入数据库中。
#需要三个关键字 ENTRY(入口词)、MN(树形路径)、AN(注释)
#ENTRY每个都有、MN（XXX.XXX.XXX）可能有几个、AN有些没有
import Dao
dao = Dao.Dao()
dao.connect()
#col_name = ''
MH_value = ''
MN_value = ''
ENTRY_value = ''
AN_value =''
#names=''
values=''
count = 0
wrong = 0
with open("d2017.bin", "r") as readMesh:
for line in readMesh:
line = line.strip()
if line == '':
# 到了结尾
# if AN_value == '':
# AN_value = 'null'
values = "'" + MH_value + "','" + ENTRY_value + "','" + MN_value + "','" + AN_value +"'"
sql = 'insert MeshStructure ' + " (MH , EN , MN , AN) " + \
"values " + " ( " + values + " ); "
try:
dao.insert(sql)
count += 1
def insertPupperItem(ppObj):
print("Insert Pupper Record: ")
d.addPupper(ppObj)
import urlparse
import urllib2 as url
from lxml import etree as et
import os
import re
from Dao import *
from LxmlExtractor import *
#def get1stLevel(cur,line):
# if True:
# cur.execute('select item from smemory where ref like ''%strong%'' ')
# cur.fetchone()
#------------------------
d=Dao()
d.resetDb()
#------------------------
lextractor=LxmlExtractor("https://opensource.com/business/15/7/five-open-source-nlp-tools")
textlines=lextractor.getTextLines()
#------------------------
for line in textlines:
#shortpath=re.sub(r'/div[\[\d+\]]*',"",tree.getpath(line.getparent()))
path=lextractor.getLinePath(line)
style=''
parent=''
if re.search(r'/em|/strong',path):
style='strong'
elif re.search(r'/h\d+',path):
def adoptPupperrec(delid):
print("Delete Pupper Record: ")
d.delPupper(delid)
"target_weight": 90,
"target_calories": 2700,
"target_protein": 200,
"target_fat": 50
}
if __name__ == "__main__":
# food_list = Dao.get_all_food()
# print(food_list)
# result_insert_food_id = Dao.get_or_insert_food(mock_food["name"], mock_food["weight"], mock_food["calories"],
# mock_food["protein"], mock_food["total_fat"], mock_food["carbs"],
# mock_food["water"])
# print(result_insert_food_id)
#
# result_insert_user = Dao.insert_user(mock_user["id"], mock_user["name"], mock_user["age"], mock_user["height"],
# mock_user["weight"], mock_user["gender"])
# print(result_insert_user)
#
# # def insert_user_target(user_id, target_weight, target_calories, target_protein, target_fat):
# result_user_target = Dao.insert_user_target(mock_target["id"], mock_target["target_weight"],
# mock_target["target_calories"],
# mock_target["target_protein"], mock_target["target_fat"])
# print(result_user_target)
#
# now = datetime.date.today()
# now = now.strftime('%Y-%m-%d')
#
# result_insert_or_incr = Dao.insert_or_increment_food_user(mock_user["id"], result_insert_food_id, now, 1)
# print(result_insert_or_incr)
print(Dao.get_all_user_id())
def findPupperMult(sex, weight):
print("Find Pupper by sex and weight: ")
d.selPupperMult(sex, weight)
def update(student_Id, studentInfo):
dao = Dao()
updated = dao.update(student_Id, studentInfo)
if not updated:
return None
return Model(updated)
