def exists(self):
conn, cur = db.get_conn()
cur.execute("SELECT * FROM users WHERE discord_id=%s",
(self.discord_id, ))
result = cur.fetchone()
db.put_conn(conn, cursor=cur)
return not not result # Convert to bool
def run_sql(cls, statement):
conn = get_conn()
cursor = conn.cursor()
cursor.execute(statement)
conn.commit()
cursor.close()
conn.close()
def get_login_key(self):
conn, cur = db.get_conn()
cur.execute("SELECT key FROM login_keys WHERE discord_id=%s",
(self.discord_id, ))
result = cur.fetchone()
db.put_conn(conn, cursor=cur)
if result:
return result[0]
def longest_chain(from_hash = '0'*64):
conn = database.get_conn()
c = conn.cursor()
c.execute("SELECT * FROM chain WHERE prev_hash = ?", (from_hash,))
roots = c.fetchall()
chains = []
prev_hashs = []
for root in roots:
# chains.append([root.hash])
chains.append([root])
# print(root)
block_hash = root[1]
prev_hashs.append(block_hash)
t0 = time.time()
n = 0
while True:
if prev_hashs:
prev_hash = prev_hashs.pop(0)
else:
break
c.execute("SELECT * FROM chain WHERE prev_hash = ?", (prev_hash,))
leaves = c.fetchall()
n += 1
if len(leaves) > 0:
block_height = leaves[0][3]
if block_height % 1000 == 0:
print('longest height', block_height)
for leaf in leaves:
for chain in chains:
prev_block = chain[-1]
prev_block_hash = prev_block[1]
# print(prev_block_hash)
if prev_block_hash == prev_hash:
forking_chain = copy.copy(chain)
# chain.append(leaf.hash)
chain.append(leaf)
chains.append(forking_chain)
break
leaf_hash = leaf[1]
if leaf_hash not in prev_hashs and leaf_hash:
prev_hashs.append(leaf_hash)
t1 = time.time()
# print(tree.current_port, "query time", t1-t0, n)
longest = []
for i in chains:
# print(i)
if not longest:
longest = i
if len(longest) < len(i):
longest = i
return longest
def get(self):
block_hash = self.get_argument('hash')
conn = database.get_conn()
c = conn.cursor()
c.execute("SELECT * FROM chain WHERE hash = ?", (block_hash, ))
block = c.fetchone()
if setting.DEBUG_CHAIN:
print('GetBlockHandler', block)
self.finish({'block': list(block[1:])})
def get_membership(self):
conn, cur = db.get_conn()
cur.execute(
"SELECT started_at, duration FROM memberships WHERE discord_id=%s",
(self.discord_id, ))
result = cur.fetchone()
db.put_conn(conn, cursor=cur)
if result:
return Membership(self.discord_id, result[0], result[1])
else:
return Membership(self.discord_id, 0, 0)
def __init__(self):
#清空缓存
self.__sql = {
'filed': '*',
'where': '',
'group': '',
'order': '',
'having': '',
'limit': '',
}
self.__conn = get_conn()
self.__cursor = self.__conn.cursor()
def set_login_key(self, length=16):
key = "".join(
random.choice(tuple(string.digits + string.ascii_letters))
for _ in range(length))
conn, cur = db.get_conn()
if self.get_login_key():
cur.execute("UPDATE login_keys SET key=%s WHERE discord_id=%s",
(key, self.discord_id))
else:
cur.execute(
"INSERT INTO login_keys (discord_id, key) VALUES (%s, %s)",
(self.discord_id, key))
conn.commit()
db.put_conn(conn, cursor=cur)
return key
def post(self):
block_json = self.request.body
block = tornado.escape.json_decode(block_json)
assert isinstance(block, list)
block_hash = block[0]
prev_block_hash = block[1]
if block_hash in self.arrived_block_hash:
self.finish({})
return
conn = database.get_conn()
c = conn.cursor()
c.execute("SELECT * FROM chain WHERE hash = ?", (block_hash,))
blocks = c.fetchall()
# if c.rowcount == 0:
is_fetch_required = False
if not blocks:
c.execute("INSERT INTO chain(hash, prev_hash, height, timestamp, data) VALUES (?, ?, ?, ?, ?)", tuple(block))
conn.commit()
print(c.lastrowid)
self.arrived_block_hash.add(block_hash)
# c.execute("SELECT * FROM chain WHERE id = ?", (c.lastrowid, ))
# block = c.fetchone()
if prev_block_hash == chain_longest[-1][1]:
chain_longest.append([c.lastrowid]+block)
else:
is_fetch_required = True
names, pirmary = get_names()
host, port, pk = names[pirmary]
# get host and port from the new pirmary
block_data_json = block[4]
block_data = tornado.escape.json_decode(block_data_json)
if setting.DEBUG_CHAIN:
print('GossipHandler', block_hash, block_data)
if 'pirmary' in block_data:
names, pirmary = get_names()
if setting.DEBUG_CHAIN:
print('GossipHandler', block_hash, names[block_data['pirmary']])
host, port, pk = names[block_data['pirmary']]
is_fetch_required = True
if is_fetch_required:
fetch_chain(host, port, block_hash)
self.finish({})
def update_chain(new_block_data):
global chain_longest
conn = database.get_conn()
c = conn.cursor()
block_hash = latest_block_hash()
block_height = latest_block_height()
new_block_data_json = tornado.escape.json_encode(new_block_data)
digest = hashlib.sha256((block_hash+str(block_height)+new_block_data_json).encode('utf8'))
new_block_hash = digest.hexdigest()
c.execute("INSERT INTO chain(hash, prev_hash, height, timestamp, data) VALUES (?, ?, ?, CURRENT_TIMESTAMP, ?)", (new_block_hash, block_hash, block_height+1, new_block_data_json))
conn.commit()
print(c.lastrowid)
c.execute("SELECT * FROM chain WHERE id = ?", (c.lastrowid, ))
block = c.fetchone()
chain_longest.append(block)
return block[1:]
def create_membership(self, key):
conn, cur = db.get_conn()
cur.execute("SELECT duration FROM keys WHERE key=%s", (key, ))
result = cur.fetchone()
membership = False
if result:
cur.execute("DELETE FROM keys WHERE key=%s", (key, ))
if self.membership and self.membership.duration != 0:
cur.execute(
"UPDATE memberships SET started=%s, duration=%s WHERE discord_id=%s",
(int(time.time()), result[0], self.discord_id))
else:
cur.execute(
"INSERT INTO memberships (discord_id, started_at, duration) VALUES (%s, %s, %s)",
(self.discord_id, int(time.time()), result[0]))
conn.commit()
self.get_membership()
membership = True
db.put_conn(conn, cursor=cur)
return membership
def search():
conn = get_conn()
terms = get_unmined_terms(conn)
for term in terms:
print("doing term: ",term)
id_lijst = search_ids(term)
for i in range(0,len(id_lijst),1000): #batches van 1000 om regelmatig te committen.
small = id_lijst[i:i+1000]
insert_article(small,conn)
insert_term_articles(small,term,conn)
print("at: ",i) #script wordt via commandline aangeroepen, printen om voortgang te zien
conn.commit()
set_mined_variable(True,term,conn) #Variabele om aan te geven dat het klaar is, zodat als het tussentijds crasht (gebeurt wel eens) de data
#nog consistent is.
conn.close()
print("finished")
def app_auth():
key = request.args.get("key")
response = {"login": False}
if key:
conn, cur = db.get_conn()
cur.execute("SELECT discord_id FROM login_keys WHERE key=%s", (key, ))
result = cur.fetchone()
if result:
cur.execute(
"SELECT address, last_login FROM ip_address_logins WHERE discord_id=%s",
(result[0], ))
result1 = cur.fetchone()
current_time = time.time()
if result1:
if result1[0] != request.remote_addr and result1[
1] - current_time < 10800: # 10800 = 3hrs
response[
"reason"] = "Cannot use multiple IP addresses in quick succession."
else:
response["login"] = True
response["discord_id"] = result[0]
cur.execute(
"UPDATE ip_address_logins SET address=%s, last_login=%s, logins=logins+1 WHERE discord_id=%s",
(request.remote_addr, current_time, result[0]))
else:
response["login"] = True
response["discord_id"] = result[0]
cur.execute(
"INSERT INTO ip_address_logins VALUES (%s, %s, 0, %s)",
(result[0], request.remote_addr, current_time))
else:
response["reason"] = "Invalid key."
conn.commit()
db.put_conn(conn, cursor=cur)
return jsonify(response)
def fetch_chain(host, port, block_hash):
http_client = tornado.httpclient.AsyncHTTPClient()
conn = database.get_conn()
c = conn.cursor()
while True:
# try:
response = yield http_client.fetch("http://%s:%s/*get_block?hash=%s" % (host, port, block_hash), request_timeout=10)
rsp = tornado.escape.json_decode(response.body)
block = rsp['block']
block_height = block[2]
c.execute("SELECT * FROM chain WHERE hash = ?", (block_hash,))
blocks = c.fetchall()
if setting.DEBUG_CHAIN:
print('fetch_chain', block_hash, blocks)
# if c.rowcount == 0:
if not blocks:
c.execute("INSERT INTO chain(hash, prev_hash, height, timestamp, data) VALUES (?, ?, ?, ?, ?)", tuple(block))
if block_height == 1:
break
block_hash = block[1]
conn.commit()
get_chain(True)
def getPMIDinfo():
try:
req_dic = request.args.to_dict(
) #verschillende argumenten, de naam van de variabelen is arbitrair
values = []
waarde = ""
for key in req_dic.keys(): #pak alle termen.
waarde = req_dic[key]
values.append(waarde)
if len(values
) > 1: #er moeten wel 2 termen zijn om een overlap te hebben
cnx = database.get_conn()
pmid_title_list = database.get_overlap_pmid_title(
values[0], values[1], cnx
) #we gebruiken alleen de eerste 2 termen omdat dit simpeler is
cnx.close(
) #ZSM connectie sluiten zodat als het script gestopt wordt, die niet blijft hangen
question = " AND ".join((
values[0],
values[1],
))
basic = search_domain() + " AND " + question
terug = "<a href='https://www.ncbi.nlm.nih.gov/pubmed/?term={}' target='_blank'>{}</a>".format(
basic, question) #leuke link naar pubmed, want <3 pubmed
terug = terug.replace("[", "%5B").replace(
"]", "%5D") #haakjes enzo door HTML troep vervangen
table = "<table><tr><th>Pubmed link</th><th>Saveable link to table</th></tr>" #table headers
link = "<a href='{}' target='_blank'>Saveable overlap</a>".format(
str(request.url)
) #de link naar alleen de return zodat dit later opgevraagt kan worden of zelfs gebookmarkt kan worden
table += "<tr><td>{}</td><td>{}</td></tr>".format(
terug, link) #de row met de inhoudt voor de table
terug = table + "</table>"
terug += "<br /><br />"
terug += "<table>"
terug += "<tr><th>Pubmed ID</th><th>Title</th></tr>"
for pmid, title in pmid_title_list: #loopen over de pmids/titles en TR's van maken
terug += "<tr>"
terug += "<td>{}</td><td><a href='https://www.ncbi.nlm.nih.gov/pubmed/{}' target='_blank'>{}</a></td>".format(
str(pmid), str(pmid), title.encode('utf-8')
) #UTF-8 want unicode, pubmed linkjes bevatten gewoon het pubmedID, super chill.
terug += "</tr>"
terug += "</table>"
return terug
else:
return "ERROR" #Debug code.
except Exception as e:
return str(e)
sys.exit(255)
organization = options.org
verbosity = options.verbosity
token_file = options.token_file
no_migration = options.no_migration
manual_assocs = options.manual_assocs
db_connect_file = options.db_connect_file
line_comment = int(options.line_comment)
# Delay time (seconds) to get around Github rate limiting limiter
delay_time = 2.5
if verbosity > 0:
print("Getting database connection.")
conn = db.get_conn(db_connect_file, verbosity)
# Gather all of the repositories pull requests
names = contents.get_names(conn, verbosity)
repo_id = contents.get_repo_id(conn, repo_name, verbosity)
pull_requests = contents.get_prs(conn, repo_id, verbosity)
print("Number of pull requests:", len(pull_requests))
for pr_id in pull_requests:
comments = contents.get_comments(conn, names, pr_id, verbosity=verbosity)
pull_requests[pr_id]["comments"] = comments
if verbosity > 1:
print
print pull_requests
print
def create(self):
conn, cur = db.get_conn()
cur.execute("INSERT INTO users (discord_id) VALUES (%s)",
(self.discord_id, ))
conn.commit()
db.put_conn(conn, cursor=cur)
""" @Time : 2020/6/3 11:42 上午 @Author : sunjiawei @E-mail : [email protected] """ import sqlite3 from config import USE_RE, finish_url, sqlite_db from database import get_conn, ori_db_type, ori_db from gen_logger import get_logger import os import requests # Add this to display Chinese normally os.environ['NLS_LANG'] = 'SIMPLIFIED CHINESE_CHINA.UTF8' ori_conn, tar_conn = get_conn() coded_logger = get_logger('coded', 1) class FindCodingTable: """定义一个用于发现编码规则的类""" def __init__(self): self.db_type = ori_db_type self.db_name = ori_db self.logger = coded_logger def find_coding_table(self): """提供两种途径来抽取编码值的映射信息 1:基于正则表达式，从注释信息中提取 2:基于字典表与其他表的引用关系（未完成） """
def test_get_conn(self):
self.assertIsInstance(
database.get_conn(**settings.NET_ATENDE_DATABASE), MySQLDatabase)
parser = argparse.ArgumentParser(description="node description")
parser.add_argument('--name')
parser.add_argument('--host', default=None)
parser.add_argument('--port', default=None)
# parser.add_argument('--parent_host', default="127.0.0.1")
# parser.add_argument('--parent_port', default=2018)
# parser.add_argument('--control_host')
# parser.add_argument('--control_port', default=setting.DASHBOARD_PORT)
args = parser.parse_args()
current_name = args.name
current_host = args.host
current_port = args.port
print('parser', current_name, current_host, current_port)
conn = database.get_conn(current_name)
# c = conn.cursor()
# Insert a row of data
# c.execute("INSERT INTO chain(hash, prev_hash, height, timestamp, data) VALUES (?, ?, 0, CURRENT_TIMESTAMP, '{}')", (uuid.uuid4().hex, '0'*64))
# Save (commit) the changes
# conn.commit()
# c.execute("SELECT * FROM chain")
# for i in c.fetchall():
# print(i)
sk_filename = "%s.pem" % current_name
if os.path.exists(sk_filename):
current_sk = ecdsa.SigningKey.from_pem(open("./"+sk_filename).read())
else:
from datetime import datetime
from models import PatientRecord, MedicalVisit
from database import get_conn
PatientRecord.insert(first_name='Chance', last_name='Turner', age=22)
MedicalVisit.insert(visit_date=datetime.now(),
visit_reason="Sour Stomach",
patient_comments="It hurts when I do this!",
doctor_comments="Then dont do that!")
conn = get_conn()
cursor = conn.cursor()
cursor.execute('SELECT * FROM pat_record')
print(cursor.fetchall())
cursor.execute('SELECT * FROM med_visit')
print(cursor.fetchall())
cursor.close()
conn.close()
today = datetime.today
#visit_list = {today: MedicalVisit(today, "Check for flu", "Achy, fever, fatigue", "Did flu test, came back negative")}
#record = PatientRecord("Zak", "Kastl", 30, visit_list)
#print(record.full_name())
#print(record.visit_history[today].visit_reason)