def psql_insert(message):
csv_columns = [
'registration_dttm', 'id', 'first_name', 'last_name', 'email',
'gender', 'ip_address', 'cc', 'country', 'birthdate', 'salary',
'title', 'comments'
] #columns for csv_dump
if message['country'] == 'United States': #if country is US
connect(
message,
'leads') #send message and determined table name to db_connect.py
elif message['cc'] != '': #if no cc number
connect(message, 'high_priority'
) #send message and determined table name to db_connect.py
else:
try:
file_exists = os.path.isfile(
'leads_dump.csv') #check if file already exists
with open('leads_dump.csv',
'a') as csvfile: #open file for dumping rest of leads
writer = csv.DictWriter(csvfile, fieldnames=csv_columns)
if not file_exists:
writer.writeheader(
) # file doesn't exist yet, write a header
writer.writerow(
message) # append each message to file as a new row
except IOError:
print("I/O error")
def calculate_uniswap_state(
self, coin, block_num
): # This is O(infinity) and ugly, will come back to it later
with connect(rows='first_val') as c:
fetched_blocks = c.execute(
'SELECT DISTINCT block_number FROM uniswap').fetchall()
if block_num in fetched_blocks:
state = self.get_known_uniswap_state(coin, block_num)
print('Returning already stored Uniswap state for block {}'.format(
block_num))
return state
else:
state = self.get_current_uniswap_state(coin)
with connect(rows='first_val') as c:
amounts_in = c.execute(
'SELECT value FROM {} WHERE to_address LIKE "{}" AND block_number > {}'
.format(coin.name, coin.uni_exchange_address,
block_num)).fetchall()
amounts_out = c.execute(
'SELECT value FROM {} WHERE from_address LIKE "{}" AND block_number > {}'
.format(coin.name, coin.uni_exchange_address,
block_num)).fetchall()
sum_amounts_in = sum((float(a) for a in amounts_in))
sum_amounts_out = sum((float(a) for a in amounts_out))
token_reserve = float(
state['token_reserve']) - sum_amounts_in + sum_amounts_out
with connect(rows='first_val') as c:
amounts_in = c.execute(
'SELECT value FROM ETH WHERE to_address LIKE "{}" AND block_number > {}'
.format(coin.uni_exchange_address, block_num)).fetchall()
amounts_out = c.execute(
'SELECT value FROM ETH WHERE from_address LIKE "{}" AND block_number > {}'
.format(coin.uni_exchange_address, block_num)).fetchall()
sum_amounts_in = sum((float(a) for a in amounts_in))
sum_amounts_out = sum((float(a) for a in amounts_out))
eth_reserve = float(
state['eth_reserve']) - sum_amounts_in + sum_amounts_out
price = (eth_reserve / 10**18) / (token_reserve /
10**coin.decimals)
with connect() as c:
c.execute("INSERT INTO uniswap VALUES(?, ?, ?, ?, ?)",
(block_num, coin.name, str(token_reserve),
str(eth_reserve), str(price)))
print('Successfully got state for {}'.format(coin.name))
print(block_num, coin.name, str(token_reserve), str(eth_reserve),
str(price))
return {
'block_number': block_num,
'token': coin.name,
'token_reserve': token_reserve,
'eth_reserve': eth_reserve,
'price': price
}
def get_known_block_nums(self, table, block_range='all'):
if block_range == 'all':
with connect(rows='first_val') as c:
fetched_blocks = c.execute(
'SELECT DISTINCT block_number FROM {}'.format(
table)).fetchall()
elif len(block_range) == 2 and block_range[1] >= block_range[0]:
with connect(rows='first_val') as c:
fetched_blocks = c.execute(
"SELECT DISTINCT block_number FROM {} WHERE block_number >= ? AND block_number <= block_number ORDER BY block_number DESC LIMIT ?",
(block_range[0], block_range[1])).fetchall()
return fetched_blocks
def load_blocks(self, block_range='all'):
if block_range == 'all':
with connect(rows='as_dict') as c:
saved_transactions = c.execute(
'SELECT * FROM ether ORDER BY block_number DESC LIMIT ?',
(self.TX_LOAD_LIMIT, )).fetchall()
elif len(block_range) == 2 and block_range[1] >= block_range[0]:
with connect(rows='as_dict') as c:
saved_transactions = c.execute(
"SELECT * FROM ether WHERE block_number >= ? AND block_number <= ? ORDER BY block_number DESC LIMIT ?",
(block_range[0], block_range[1],
self.TX_LOAD_LIMIT)).fetchall()
return [Transaction(tx) for tx in saved_transactions if tx['tx_hash']]
def login_verify(args):
connection = connect()
username = args['username']
password = args['password']
command = """select * from user_login_details where username=%s;"""
try:
cur = connection.cursor()
cur.execute(command, (username, ))
result = cur.fetchone()
connection.commit()
if check_password_hash(result[1], password):
data = farmer_info(username)
return (data)
else:
return (False)
except (Exception, psycopg2.DatabaseError) as error:
print(error)
finally:
if connection is not None:
connection.close()
print("success")
def dead_user(user):
db, cur = db_connect.connect('Zzb7flWH2Ucblx8Ok5QqbkfzUKEyffRh')
cur.execute('select keyword from keywords where user_name="%s"' % (user))
data = cur.fetchall()
d = []
for i in data:
if i[0] not in d:
d += [i[0]]
l1, l2 = [], []
for i in d:
cur.execute('select count(keyword) from keywords where keyword="%s"' %
(i))
data = cur.fetchone()
l1 += [i]
l2 += [data[0]]
print l1, l2
m = 2
u = np.mean(data)
s = np.std(data)
filtered = [e for e in data if (u - 2 * s < e < u + 2 * s)]
for j, i in enumerate(l2):
if i not in list(set(data) - set(filtered)):
try:
cur.execute(
'insert into patterns(keyword,count,magnitude) values ("%s",0,0)'
% (l1[j]))
db.commit()
except:
pass
def get(type, img_name):
db, cursor = connect()
type_list = ['Shirts', 'Shoes', 'Pants', 'Accessory']
if type not in type_list:
db.close()
return {
"message": "{type} path에 Shirts, Shoes, Pants, Accessory 이외의 값을 줌",
"code": 410
}, 410
sql = f'SELECT * FROM {type}List WHERE Url = "Cloth/Image/{type}/{img_name}"'
cursor.execute(sql)
cloth_data = cursor.fetchone()
if cloth_data is None:
db.close()
return {"message": "존재하지 않는 상품입니다", "code": 411}, 411
return_dict = {}
return_dict['name'] = cloth_data[0]
return_dict['type'] = type_to_korea[type]
return_dict['image_url'] = cloth_data[1]
return_dict['title'] = cloth_data[2]
return_dict['description'] = cloth_data[3]
return_dict['price'] = cloth_data[4]
return_dict['size'] = cloth_data[5]
return_dict['first_date'] = cloth_data[6]
return_dict['sell_status'] = cloth_data[7]
return_dict['status'] = cloth_data[10]
db.close()
return return_dict
def __init__(self, test=False):
super(PostService, self).__init__()
self.app = Flask("Crushes")
self.mongo, self.crushes = db_connect.connect()
self.db = self.crushes.posts
self.CLIENT_ID = "686893277993623" if test else os.environ.get('fb_client_id')
self.CLIENT_SECRET = "518865db69daa46de95171f00a56fc25" if test else os.environ.get('fb_client_secret')
def put():
db, cursor = connect()
_user = get_jwt_identity()
rank = RequestParser.parser('rank')[0]
print(rank)
if rank is None:
db.close()
return {"message": "docs에서 나온데로 params를 달라!", "code": 410}
rank_list = ['Normal', 'VIP', 'VVIP']
if rank not in rank_list:
db.close()
return {
"message": "rank의 VALUE 값으로 [Normal, VIP, VVIP]만을 주세요",
"code": 411
}, 411
sql = f'SELECT * FROM UserRank WHERE name = "{_user}"'
cursor.execute(sql)
rank_data = cursor.fetchone()
if rank_data[1] == rank:
db.close()
return {"message": "이미 현재 등급인 상태 입니다.", "code": 412}, 412
sql = f'UPDATE UserRank SET rank = "{rank}" WHERE name = "{_user}"'
cursor.execute(sql)
db.commit()
db.close()
return {"message": "해당 회원 등급 바꾸기 성공", "code": 200}, 200
def post1():
'''
이메일 인증 요청을 위한 POST Method
:return: status code
410 - email에 공백이 포함됨
200 - 성공
'''
db, cursor = connect()
email = RequestParser.parser('email')[0]
if ' ' in email:
db.close()
return {"message": "이메일에 공백이 포함됨", "code": 410}, 410
num = random.randrange(10000, 100000)
s = smtplib.SMTP('smtp.gmail.com', 587)
s.starttls()
s.login('*****@*****.**', 'gzuviibjmmxeuoeo')
msg = MIMEText(f'인증번호: {num}')
msg['Subject'] = f'confirm your email to signup our Re-cycle service.'
s.sendmail("*****@*****.**", email, msg.as_string())
s.quit()
sql = f'DELETE FROM emailauth WHERE email = "{email}"'
cursor.execute(sql)
sql = f'INSERT INTO emailauth (email, random) VALUES("{email}", {num})'
cursor.execute(sql)
db.close()
return {"message": "이메일을 보냈으니 인증해 주세요", "code": 200}, 200
def data():
""" creating the instance to the database and retrieving the sample cropdata stored in the database """
dbInstance = connect()
crop_data = psql.read_sql("select * from andhra_crop_details", dbInstance)
return (crop_data)
def user_details(data):
""" user details process in db"""
conn = connect()
user_name = create_username(data['Name'], data['PhNo'])
pass_word = generate_password_hash(data['PhNo'])
# c=check_password_hash(password,data['PhNo'])
values = list(data.values())
for n, i in enumerate(values):
if i == "":
values[n] = None
print(values)
# print(len(values))
# # process1
user = table(conn, user_name, pass_word)
user.user_login_details()
user.user_personal_details(values[0:6])
user.user_agro_details(values[6:12])
user.user_crop_details(values[12:21])
# login_details=get_user_login_details(conn,user_name)
# print(user.get_user_crop_details())
# procss2
# user=table(conn,user_name,pass_word,values)
# user.insert_details()
# user.delete_details()
# process3
# insert_details(conn,user_name,pass_word,values)
# delete_details(conn)
return (user_name)
def get_current_uniswap_state(self, coin):
print(coin)
print(coin.name, coin.address)
block_number = self.w3.eth.blockNumber
exchange_address = self.uni_factory_contract.functions.getExchange(
coin.address).call(block_identifier=block_number)
token_reserve = coin.contract.functions.balanceOf(
exchange_address).call(block_identifier=block_number)
eth_reserve = self.w3.eth.getBalance(exchange_address,
block_identifier=block_number)
price = (eth_reserve / 10**18) / (token_reserve / 10**coin.decimals)
with connect() as c:
c.execute("INSERT INTO uniswap VALUES(?, ?, ?, ?, ?)",
(block_number, coin.name, str(token_reserve),
str(eth_reserve), str(price)))
print('Successfully got state for {}'.format(coin.name))
print(block_number, coin.name, str(token_reserve), str(eth_reserve),
str(price))
return {
'block_number': block_number,
'token': coin.name,
'token_reserve': token_reserve,
'eth_reserve': eth_reserve,
'price': price
}
def put():
'''
비밀번호 변경을 위한 PUT Method
:return: status code
401 - access_token을 headers에 포함하지 않았음
410 - 비밀번호 값이 서로 다름
422 - 잘못된 access_token을 줬음
200 - 성공
'''
db, cursor = connect()
_userName = get_jwt_identity()
print(_userName)
password, password_check = RequestParser.parser('password',
'password_check')
print(password, password_check)
if password_check != password:
db.close()
return {"message": "비밀번호와 비밀번호 확인 값이 서로 다름", "code": 410}, 410
sql = f'UPDATE userlog SET password = "******" WHERE name = "{_userName}"'
cursor.execute(sql)
db.close()
return {"message": "비밀번호 변경 성공", "code": 200}, 200
def get(input):
db, cursor = connect()
return_dict = {}
total_data = []
count = 1
type_list = ['Shirts', 'Pants', 'Shoes', 'Accessory']
for i in type_list:
sql = f'SELECT * FROM {i}List'
cursor.execute(sql)
total_data = total_data + list(cursor.fetchall())
for i in total_data:
if input in i[2] or input in i[3]:
specific_dict = {}
specific_dict['name'] = i[0]
specific_dict['type'] = type_to_korea[str(i[1]).split('/')[2]]
specific_dict['image_url'] = i[1]
specific_dict['title'] = i[2]
specific_dict['description'] = i[3]
specific_dict['price'] = i[4]
specific_dict['size'] = i[5]
specific_dict['first_date'] = i[6]
specific_dict['status'] = i[10]
return_dict[count] = specific_dict
count += 1
db.close()
return return_dict
def get():
db, cursor = connect()
_user = get_jwt_identity()
print(_user)
return_dict = {}
count = 1
sql = f'SELECT * FROM BasketData WHERE name = "{_user}"'
cursor.execute(sql)
for i in cursor.fetchall():
sql = f'SELECT * FROM {str(i[1]).split("/")[2]}List WHERE url = "{str(i[1])}"'
cursor.execute(sql)
data = cursor.fetchone()
specific_dict = {}
specific_dict['name'] = data[0]
specific_dict['type'] = type_to_korea[str(data[1]).split('/')[2]]
specific_dict['image_url'] = data[1]
specific_dict['title'] = data[2]
specific_dict['description'] = data[3]
specific_dict['price'] = data[4]
specific_dict['size'] = data[5]
specific_dict['first_date'] = data[6]
specific_dict['sell_status'] = data[7]
specific_dict['status'] = data[10]
return_dict[count] = specific_dict
count += 1
db.close()
return return_dict
def delete():
db, cursor = connect()
_user = get_jwt_identity()
url = str(RequestParser.parser('url')[0])
if url is None:
db.close()
return {"message": "docs에 주어진 대로 모든 params를 전달해 주세요", "code": 410}, 410
if url.split('/')[0] != 'Cloth' or url.split(
'/')[1] != 'Image' or url.split('/')[2] not in [
'Shirts', 'Shoes', 'Pants', 'Accessory'
]:
db.close()
return {
"message": "Cloth/Image/{type}/{filename} 형식의 URL을 주세요",
"code": 411
}, 411
sql = f'SELECT * FROM BasketData WHERE url = "{url}" AND name = "{_user}"'
cursor.execute(sql)
delete_data = cursor.fetchone()
if delete_data is None:
db.close()
return {"message": "해당 제품을 장바구니에 담지 않았습니다.", "code": 412}, 412
sql = f'DELETE FROM BasketData WHERE name = "{_user}" AND url = "{url}"'
cursor.execute(sql)
db.commit()
db.close()
return {"message": "제품 장바구니에서 꺼내기 완료", "code": 200}, 200
def get(cloth_type):
db, cursor = connect()
return_dict = {}
count = 1
type_list = ['Shirts', 'Shoes', 'Pants', 'Accessory']
if cloth_type not in type_list:
db.close()
return {
"message": "{type} path에 Shirts, Shoes, Pants, Accessory 이외의 값을 줌",
"code": 410
}, 410
sql = f'SELECT * FROM {cloth_type}List WHERE SellStatus = 0'
cursor.execute(sql)
total_data = list(cursor.fetchall())
index_list = []
random_list = []
for data in total_data:
index_list.append(data[8])
while True:
if not index_list:
break
random_data = random.choice(index_list)
random_list.append(random_data)
index_list.remove(random_data)
for term in range((len(random_list) - 1) // 5 + 1):
return_middle_dict = {}
for index in random_list[term * 5:term * 5 + 5]:
specific_dict = {}
data_list = []
for i in total_data:
if i[8] == index:
data_list = i
del i
break
specific_dict['name'] = data_list[0]
specific_dict['image_url'] = data_list[1]
specific_dict['title'] = data_list[2]
specific_dict['description'] = data_list[3]
specific_dict['price'] = data_list[4]
specific_dict['size'] = data_list[5]
specific_dict['first_date'] = data_list[6]
specific_dict['status'] = data_list[10]
return_middle_dict[count] = specific_dict
count += 1
return_dict[term + 1] = return_middle_dict
count = 1
db.close()
return return_dict
def post():
db, cursor = connect()
_user = get_jwt_identity()
url = str(RequestParser.parser('url')[0])
if url is None:
db.close()
return {"message": "docs에 주어진 대로 모든 params를 전달해 주세요", "code": 410}, 410
if url.split('/')[0] != 'Cloth' or url.split(
'/')[1] != 'Image' or url.split('/')[2] not in [
'Shirts', 'Shoes', 'Pants', 'Accessory'
]:
db.close()
return {
"message": "Cloth/Image/{type}/{filename} 형식의 URL을 주세요",
"code": 411
}, 411
sql = f'SELECT * FROM {url.split("/")[2]}List WHERE url = "{url}"'
cursor.execute(sql)
if cursor.fetchone() is None:
db.close()
return {"message": "해당 사진 URL에 관한 제품 정보가 존재하지 않습니다", "code": 412}, 412
sql = 'CREATE TABLE ReservationData (' \
' name TEXT NOT NULL,' \
' url TEXT NOT NULL,' \
' register_name TEXT NOT NULL,' \
' register_title TEXT NOT NULL' \
')'
try:
cursor.execute(sql)
except:
pass
sql = f'SELECT * FROM ReservationData WHERE name = "{_user}" AND url = "{url}"'
cursor.execute(sql)
if cursor.fetchone() is not None:
db.close()
return {"message": "이미 예매한 제품입니다.", "code": 413}, 413
sql = f'SELECT * FROM {str(url).split("/")[2]}List WHERE Url = "{url}"'
cursor.execute(sql)
data = cursor.fetchone()
register_name = data[0]
register_title = data[2]
sql = f'INSERT INTO ReservationData (name, url, register_name, register_title) VALUES("{_user}", "{url}", "{register_name}", "{register_title}")'
cursor.execute(sql)
db.commit()
db.close()
return {"message": "제품 찜하기에 성공하였습니다.", "code": 200}, 200
def delete(cloth_type):
'''
:param cloth_type:
:return: status code
200 - 제품 등록 취소 성공.
410 - {type} path에 Shirts, Shoes, Pants, Accessory 이외의 값을 줌
411 - swagger docs에 나와있는 대로 params을 전달해 주세요.
412 - 해당 url에 대해 제품이 존재하지 않거나 요청한 유저의 제품이 아님
'''
db, cursor = connect()
type_list = ['Shirts', 'Shoes', 'Pants', 'Accessory']
if cloth_type not in type_list:
return {
"message": "{type} path에 Shirts, Shoes, Pants, Accessory 이외의 값을 줌",
"code": 410
}, 410
ImageUrl = str(RequestParser.parser('url')[0])
user_name = get_jwt_identity()
sql = f'SELECT * FROM {cloth_type}List WHERE User = "******" AND Url = "{ImageUrl}"'
cursor.execute(sql)
select_data = cursor.fetchone()
print(select_data)
if select_data is None:
return {
"message": "해당 url에 대해 제품이 존재하지 않거나 요청한 유저의 제품이 아님",
"code": 412
}, 412
if int(select_data[7]) == 1:
return {"message": "해당 url에 대한 제품은 이미 판매된 제품임", "code": 413}, 413
sql = f'DELETE FROM {cloth_type}List WHERE User = "******" AND Url = "{ImageUrl}"'
cursor.execute(sql)
db.commit()
path = f'Data/Image/{cloth_type}/{ImageUrl.split("/")[3]}'
os.remove(path)
sql = f'SELECT * FROM ReservationData WHERE url = "{ImageUrl}"'
cursor.execute(sql)
cancle_data = list(cursor.fetchall())
for i in cancle_data:
sql = f'INSERT INTO ReservationCancelData (name, url, register_name, register_title) VALUES("{i[0]}", "{i[1]}", "{i[2]}", "{i[3]}")'
cursor.execute(sql)
db.commit()
sql = f'DELETE FROM ReservationData WHERE url = "{ImageUrl}"'
cursor.execute(sql)
db.commit()
return {"message": "제품 등록 취소 완료", "code": 200}, 200
def execute_mysql_command(instruction):
"""Execute mysql commands like DELETE and INSERT. Does not include
SELECT command.
"""
mydb = connect()
mycursor = mydb.cursor()
mycursor.execute(instruction)
mydb.commit()
mycursor.close()
return
def registersubmit():
c=request.form
# if "" not in dict(c).values():
print(c)
username=user_details(dict(c))
# username='******'
conn=connect()
details=after_register(conn,username)
flash(details,'success')
return redirect(url_for('register'))
def main():
logger.info("Connecting to DB ...")
cur, conn = connect()
logger.info("Dropping existing tables ...")
drop_tables(cur, conn)
logger.info("Creating tables ...")
create_tables(cur, conn)
close(cur, conn)
logger.info("All done. Database connection closed.")
def main():
logger.info("Connecting to DB ...")
cur, conn = connect()
logger.info("Loading staging tables ...")
load_staging_tables(cur, conn)
logger.info("Inserting anaytics tables ...")
insert_tables(cur, conn)
logger.info("Dropping staging tables ...")
drop_staging_tables(cur, conn)
close(cur, conn)
logger.info("All done. Database connection closed.")
def pattern_change(data, text, magnitude):
for i in data:
if i.lower() in text.lower():
db, cur = db_connect.connect('Zzb7flWH2Ucblx8Ok5QqbkfzUKEyffRh')
cur.execute('select magnitude from patterns where keyword="%s"' %
(i.lower()))
magnitude = (magnitude + float(cur.fetchone()[0])) / 2
cur.execute(
'update patterns set magnitude="%s",count=count+1 where keyword="%s"'
% (str(magnitude), i.lower()))
db.commit()
def crop_cost():
import json
conn = connect()
with open("datasets/crop_invest_per_acre.json") as f:
c = json.load(f)
# print(len(c))
command = """update crops set cost=%s where lower(crop)=lower(%s);"""
for i in c.keys():
val = c[i]
print(val, i)
cur = conn.cursor()
cur.execute(command, (val, i))
conn.commit()
def save_txs(txs):
if "tokenSymbol" not in txs[0]:
token = 'ETH'
else:
token = txs[0]['tokenSymbol']
txs_tuples = [(tx["blockNumber"], tx["hash"], tx["from"], tx["to"], tx["value"], tx["timeStamp"]) for tx in txs]
try:
with connect() as c:
c.executemany("INSERT OR IGNORE INTO {} VALUES (?, ?, ?, ?, ?, ?)".format(token),txs_tuples)
except Exception as e:
print(tx)
print(traceback.format_exc())
def read_trials():
cur, con = dbc.connect()
sqlcmd = """SELECT
a.surebet_port, a.lottery_port,
b.poke, b.reward,
a.lottery_mag, a.lottery_prob, a.sure_mag
FROM strattag_config AS a
JOIN strattag_pokereward AS b
ON a.trialid=b.trialid
"""
cur.execute(sqlcmd)
records = cur.fetchall()
con.close()
return records
def web3_fetch_blocks(self, block_range):
with connect(rows='first_val') as c:
fetched_blocks = c.execute(
'SELECT DISTINCT block_number FROM ether').fetchall()
missing_blocks = (
block_num for block_num in range(block_range[0], block_range[1])
if block_num not in fetched_blocks)
for block_num in missing_blocks:
try:
print('Fetching block number {}'.format(block_num))
block = self.w3.eth.getBlock(block_num, full_transactions=True)
inserted_tx = save_block_txs(block, self.coins)
if not inserted_tx:
with connect() as c:
c.execute(
"INSERT INTO transactions(block_number) VALUES(?)",
(str(block_num)))
except Exception as e:
print('Error with block {}'.format(block_num))
print(traceback.format_exc())
return False
return True
def log_sql(msg, reply, language):
data = {
"question": msg,
"answer": reply,
"language": language,
"date": datetime.datetime.now()
}
mydb = connect()
mycursor = mydb.cursor()
instruction = "INSERT INTO userBotInteraction (question, answer, language, date) VALUES (\"{question}\", \"{answer}\", \"{language}\", \"{date}\")".format(
**data)
mycursor.execute(instruction)
mydb.commit()
mycursor.close()
return
def add_pattern(keyword, magnitude):
db, cur = db_connect.connect('Zzb7flWH2Ucblx8Ok5QqbkfzUKEyffRh')
cur.execute('select magnitude from patterns where keyword="%s"' %
(keyword))
data = cur.fetchone()
if len(data) < 1:
cur.execute(
'insert into patterns(keyword,count,magnitude) values ("%s",1,"%s")'
% (keyword, magnitude))
db.commit()
cur.close()
else:
cur.execute(
'update patterns set count=count+1 , magitude="%s" where keyword="%s"'
% ((magnitude + float(data[0])) / 2, keyword))
db.commit()
cur.close()
def __init__(self, request):
self.request = request
self.handle = connect()
self.crash_helper = Crashhelpers()
self.match_helper = MatchHelpers()
def doTheBloodyWork(semsOperator="<6", spare=False):
'''does all the work to connect to db and get the data
semsOperator determines which semesters are going to be taken from database
for example: <6 will take semesters 1-5 (inclusive), =1 only first one and so on'''
global victims
global courses_names
global courses
victims = []
courses = []
courses_names = []
'''connect to db'''
connection = connect(pymysql.cursors.Cursor)
cursor = connection.cursor()
'''fetch courses'''
sems = semsOperator
cursor.execute("SELECT id_p FROM Przedmioty WHERE semestr" +
sems + " and kierunek like '%FT%'")
stuff = cursor.fetchall()
for x in stuff:
courses.append(x[0])
'''fetch physics students from 5 semesters'''
cursor.execute("select * from Studenci where grupa5 is not NULL and grupa1 is not NULL and grupa2 is not null and grupa3 is not null and grupa4 is not null and rocznik not like '%FOTO%'")
stuff = cursor.fetchall()
students = [[], [], []]
'''assuming only K, L, J are getting fetched'''
students[0] = [[], [], [], []]
students[1] = [[], [], [], []]
students[2] = [[], [], [], []]
for x in stuff:
try:
spec = x[-1][-2:]
if spec == 'PT':
spec = 'OE'
except TypeError:
spec = None
if spec is not None:
st_j = students[0]
st_k = students[1]
st_l = students[2]
if x[1] == 'K':
st_k[chooseList(spec)].append((x[0], spec, x[1]))
elif x[1] == 'L':
st_l[chooseList(spec)].append((x[0], spec, x[1]))
elif x[1] == 'J':
st_j[chooseList(spec)].append((x[0], spec, x[1]))
else:
print('Error: uknown year label')
nustuds = []
for cl in students:
for sp in cl:
for st in sp:
nustuds.append(st)
students = nustuds
'''make list of students as objects'''
for s in students:
st = Student(s[0], s[1], s[2])
victims.append(st)
for c in courses:
cursor.execute("select wynik from Oceny where id_s=" +
str(st.id) + " and id_p=" + str(c))
gr = cursor.fetchall()
if gr:
if gr[0][0] == 0:
gr = None
else:
gr = gr[0][0]
else:
gr = None
st.grades.append(gr)
'''get names of the courses'''
for c in courses:
cursor.execute("select nazwa from Przedmioty where id_p=" + str(c))
courses_names.append(cursor.fetchone()[0])
'''close connection with db'''
cursor.close()
connection.close()
if not spare:
'''delete students with average smaller than 3.0'''
for ii, x in enumerate(victims):
s = 0
l = len(x.grades)
for g in x.grades:
if g is not None:
s += g
else:
l -= 1
av = s / l
if av < 3.0:
del victims[ii]
'''if student have 'None' as a grade replace it with an average'''
for ii, c in enumerate(courses):
s = 0
l = 0
for st in victims:
if st.grades[ii] is not None:
s += st.grades[ii]
l += 1
else:
pass
av = s / l
for st in victims:
if st.grades[ii] is not None:
pass
else:
st.grades[ii] = av
global worksDone
if worksDone is not True:
worksDone = True
import db_connect as dbc
import numpy as np
import json
NUM_PORTS = 2
if __name__ == '__main__':
# generate configuration of the simulated trials
# fix_port is a constant, while lottery and surebet
# can alternate.
# NO poke to fix_port is allowed
cur, con = dbc.connect()
# reset the table
dbc.overwrite(cur, con, 'strattag_config')
sqlstr = """INSERT INTO strattag_config(
surebet_port,
lottery_port,
lottery_mag,
lottery_prob,
sure_mag,
alpha,
beta) VALUES(
"%d", "%d", "%f", "%f", "%f", "%f", "%f")"""
with open('inputs.json', 'r') as f:
para = json.load(f)
riskyVals = np.array(para['lottery_mag'])
riskyProb = np.array(para['lottery_prob'])
sure_mag = para['sure_mag']
def setUp(self):
self.app = Flask("Crushes")
self.mongo, self.db = db_connect.connect()
self.db = self.db.posts
self.ps = PostService(True)
import pymysql
import random
import collections
class Student:
'''contains student id and list vector of grades'''
def __init__(self, id_s, class_='FOTO'):
self.id = id_s
self.grades = []
self.class_ = class_
'''connect to db'''
connection = connect(pymysql.cursors.Cursor)
cursor = connection.cursor()
'''fetch courses'''
cursor.execute("SELECT id_p FROM Przedmioty WHERE semestr<6 and kierunek like '%FOTO%'")
stuff = cursor.fetchall()
courses = []
for x in stuff:
courses.append(x[0])
'''fetch photonics students from 5 semesters (currently only one class is available)'''
cursor.execute("select * from Studenci where grupa5 is not NULL and grupa1 is not NULL and grupa2 is not null and grupa3 is not null and grupa4 is not null and rocznik like '%FOTO%'")
stuff = cursor.fetchall()
students = []
def before_request(): g.connect = connect(app.config['DATABASE']) g.cur = g.connect.cursor()
def __init__(self):
self.handle = connect()
from flask import Flask, current_app
from flask.ext.pymongo import PyMongo
import postService
import db_connect
app = Flask("Crushes")
mongo, crushes = db_connect.connect()
db = crushes.posts
def setupIndexes():
with app.app_context():
db.ensure_index([("message", 'text' )], name="TextIndex")
db.ensure_index([("created", 1)])
setupIndexes()
#!/usr/bin/env python
from db_connect import connect
import MySQLdb
db_name = 'Users'
logins_table = 'Logins'
db = connect(db_name)
def insert(name, email, password):
try:
cur = db.cursor()
x = "INSERT INTO Logins (name, email, password) \
VALUES ('%s', '%s', '%s')" %(name, email, password)
cur.execute(x)
db.commit()
except Exception as e:
print e
db.rollback()
db.close()
if __name__ == "__main__":
pass
