def main():
# Make a .montehelper dir in HOME
mhdir = os.path.join(os.path.expanduser('~'), '.montehelper')
if not os.path.exists(mhdir):
os.makedirs(mhdir)
# Initialize logging
logfile = os.path.join(mhdir, 'montehelper.log')
fh = logging.FileHandler(logfile)
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
fh.setFormatter(formatter)
logger.addHandler(fh)
logger.info('Logging initialized')
# Database backup
cfg = Preferences()
dbfile = cfg.GetProperty('sqlite', 'dbfile')
# Backup database file
sfile = SimpleRotater(dbfile)
sfile.backup()
# Check database version and do necessary updates
version = int(cfg.GetProperty('program', 'version'))
db = Database()
db.updatedb(version)
# Create instances of needed classes
li = Listeners() #@UnusedVariable
# Create GUI and show
mh = MonteHelper(0)
logger.info('Main window created, starting main loop')
mh.MainLoop()
class Cashier:
def __init__(self):
self.db = Database()
def checkout(self, items):
itemDetails = []
for item in items:
x = list(self.db.getItemDetails(item[0]))
x.append(item[1])
itemDetails.append(x)
print itemDetails
self.cost = []
print "\n\n Summary: \n\n"
for i in itemDetails:
print "id = "+str(i[0])
print "name = "+str(i[1])
print "category = "+str(i[2])
print "life time since date of manufacture(in days) = "+str(i[3])
print "price = "+str(i[4])
print "quantity = "+str(i[5])
print "cost for that quantity = " + str(i[5] * i[4])
self.cost.append(i[4]*i[5])
print "net cost = " + str(sum(self.cost))
answer = str(raw_input("proceed? yes/no"))
if answer == "yes":
print "purchase accepted."
for item in items:
self.db.updateInventory(item)
else:
print "no purchase"
print "Thank you for visiting."
def close(self):
self.db.close()
def LiveLog(self, username, projectname, packagename, branchname, distro, release, arch):
data = self.GetJob(username, projectname, packagename, branchname, distro, release, arch, "")
if data is None:
return ("No build is planned for this package at the moment...", -1)
elif data['status'] == 'BUILDING':
rowsToShow=40
con = Database(self.config)
stmt = "SELECT * FROM log WHERE buildid = ? ORDER BY id DESC LIMIT ?"
cursor = con.execute(stmt, (data['id'], rowsToShow))
data = cursor.fetchall()
con.close()
output = ""
for row in data:
output = row['line'] + output
timeout = 2
elif data['status'] == 'CANCELLED':
return ("This build has been removed from the build queue...", -1)
elif data['status'] == 'WAITING':
return ("We are waiting for a build machine to become available...", 10)
elif data['status'] == 'FINISHED':
output = Logger().getLog(username, projectname, packagename, branchname, distro, release, arch, data['buildnumber'])
# stop refreshing
timeout=-1
return (output, timeout)
def CheckForHangingBuild(self):
# check for hanging build (BuildingTimeout in config.yml)
con = Database(self.config)
stmt = "SELECT * FROM build "
stmt += "WHERE status = 'BUILDING' and hanging = 0 "
stmt += "AND datetime(started,'+" + str(self.config['lbs']['BuildingTimeout']) + " seconds') < '" + datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S") + "'"
stmt += " ORDER BY id DESC"
cursor = con.execute(stmt)
data = cursor.fetchall()
cursor.close()
for row in data:
stmt = "SELECT * FROM log WHERE buildid=? AND datetime(created,'+" + str(self.config['lbs']['BuildingTimeout']) + " seconds') > '" + datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S") + "'"
cursor = con.execute(stmt, (row['id'],))
if cursor.fetchone() is None:
# mark the build as hanging, so that we don't try to release the machine several times
stmt = "UPDATE build SET hanging = 1 WHERE id = ?"
cursor = con.execute(stmt, (row['id'],))
con.commit()
# check if the machine is still occupied with that build
#stmt = "SELECT * FROM machine WHERE username = ? and projectname = ? and packagename = ? AND name = ?"
#cursor = con.execute(stmt, (row['username'], row['projectname'], row['packagename'], row['buildmachine']))
#if cursor.fetchone() is None:
# # TODO mark build as stopped. do not release the machine, it might already build something else?
# con.close()
# return
print("stopping machine %s because of hanging build %d" % (row["buildmachine"], row["id"]))
print("current time: %s" % (datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")))
print("sql statement: %s" % (stmt))
con.close()
self.ReleaseMachine(row["buildmachine"], True)
# when the build job realizes that the buildmachine is gone:
# the log will be written, email sent, and logs cleared
# the build will be marked as failed as well
return
con.close()
class Main:
def __init__(self, mailer=None):
if mailer is None:
mailer = Mailer()
self.mailer = mailer
self.db = Database(mailer)
self.phone = Phone()
self.doRemove = self.remove
def processLoop(self, storage):
for sms in storage.getValids():
self.db.add(sms)
self.doRemove(sms)
def remove(self,sms):
self.phone.removeSms(sms)
def oneStep(self):
allsms = Phone().getAllSms()
store = SmsStorage(allsms)
self.processLoop(store)
def main(self):
while True:
try:
self.oneStep()
except Exception, e:
exctype, exc, tb = sys.exc_info()
syslog.syslog("%s:%s:%s"%(exctype,str(exc),traceback.format_tb(tb)))
time.sleep(1)
def show_experiments():
dbname = inform.getvalue("db")
print h2("Database: " + dbname)
print h2("Experiments")
db = Database(dbname)
exprs = db.get_experiments()
headings = ("ID","Name","Date","Experimenter")
link_f = lambda x: link("show_plates","[ {0} ]".format(str(x)),
db=dbname,experiment=str(x))
display = (link_f,None,None,None)
print table_from_tuples(exprs,headings,display=display)
print h2("Create New Experiment")
form = Form(action=SCRIPT_NAME,method="get")
form.add_hidden("action","create_experiment")
form.add_hidden("db",dbname)
form.add_text_field("name","Name")
form.add_return()
form.add_text_field("experimenter","Experimenter")
form.add_return()
for i in range(1,N_PLATES+1):
form.add_text_field("plateid","Plate ID ")
form.add_text_field("platename"," Plate Name ")
form.add_return()
form.add_submit("Create")
print form
def buy(self, symbol, quantity, buyPrice, profitableSellingPrice):
# Do you have an open order?
self.check_order()
try:
# Create order
orderId = Orders.buy_limit(symbol, quantity, buyPrice)
# Database log
Database.write([orderId, symbol, 0, buyPrice, 'BUY', quantity, self.option.profit])
#print('Buy order created id:%d, q:%.8f, p:%.8f' % (orderId, quantity, float(buyPrice)))
self.logger.info('%s : Buy order created id:%d, q:%.8f, p:%.8f, Take profit aprox :%.8f' % (symbol, orderId, quantity, float(buyPrice), profitableSellingPrice))
self.order_id = orderId
return orderId
except Exception as e:
#print('bl: %s' % (e))
self.logger.debug('Buy error: %s' % (e))
time.sleep(self.WAIT_TIME_BUY_SELL)
return None
def runWorkload(self, datadir, scaleFactor, pageSize, workloadMode): db = Database(pageSize=pageSize) self.createRelations(db) self.loadDataset(db, datadir, scaleFactor) self.runOperations(db, workloadMode) db.close() shutil.rmtree(db.fileManager().dataDir, ignore_errors=True) del db
def GetFinishedQueue(self):
con = Database(self.config)
cursor = con.execute("SELECT * FROM build WHERE status='FINISHED' ORDER BY finished DESC LIMIT ?", (self.config['lbs']['ShowNumberOfFinishedJobs'],))
data = cursor.fetchall()
con.close()
result = deque()
for row in data:
result.append(row)
return result
def GetBuildQueue(self):
con = Database(self.config)
cursor = con.execute("SELECT * FROM build WHERE status='WAITING' ORDER BY id ASC")
data = cursor.fetchall()
con.close()
result = deque()
for row in data:
result.append(row)
return result
def __init__(self, normalized, website, camperid, day, dest, page, year, refresh):
Database.__init__(self, website, camperid, day, dest, page, year, refresh)
self.normalized = normalized
csv_object_in = normalized.csv_object
self.folder_out = csv_object_in.foldername
self.csv_accumulated = self.obtainAccumulatedRecords(csv_object_in)
#self.csv_object = self.recordsSpecialFields(self.csv_accumulated)
self.csv_object = self.csv_accumulated
return None
def get_all(createdby=None):
urls = []
if createdby is None:
urlrows = db.query_db('select short from urls')
else:
urlrows = db.query_db('select short from urls where createdby = ?', [createdby])
for row in urlrows:
url = Url(row["short"])
urls.append(url)
return urls
def collect_data():
global reads
global current_data
starttime = time.clock()
for x in range(0,numReaders):
XBeeStatus[x]=0
for x in range(0,numReaders):
#xbee.send('tx',dest_addr_long=XBeeAddress[x],dest_addr=UNKNOWN,data=b't')
time.sleep(1)
current_data=''
xbee.send('tx',dest_addr_long=XBeeAddress[x],dest_addr=UNKNOWN,data=b'D')
start = time.clock()
time.sleep(2)
while XBeeStatus[x] != 12:
if (time.clock()-start)>30:
#xbee.send('tx',dest_addr_long=XBeeAddress[x],dest_addr=UNKNOWN,data=b'D')
#XBeeStatus[x]=0
#current_data=''
#start = time.clock()
#print ("Re-sent DATA_SEND to {0}".format(x))
#time.sleep(2)
print "Did not recieve data"
XBeeStatus[x] = 12
#xbee.send('tx',dest_addr_long=XBeeAddress[x],dest_addr=UNKNOWN,data=b't')
current_data=1594*'0'
if (time.clock()-starttime)>115:
print ("Exceeded time limit")
return
try:
if packets.qsize() > 0:
newPacket = packets.get_nowait()
handlePacket(newPacket)
except KeyboardInterrupt:
break
# Save to database
db = Database(dbname)
for res in range(0,4):
data = current_data[res*394:res*394+394]
well_data = ''
for well in range(0,96):
well_data = well_data+','+str(int(data[12+well*4:14+well*4]+data[10+well*4:12+well*4],16))
current_time = int(data[6:8]+data[4:6]+data[2:4]+data[0:2],16)
db.add_data(exp_id,XBeeID[x],current_time,data[8:10],well_data)
db.close()
# Save to text file
save_path = '/media/usbhdd'
filename = os.path.join(save_path,XBeeFilenames[x])
current_file = open(filename,'a')
current_file.write(current_data)
current_file.write('\n')
current_file.close()
reads = reads+1
print ("Recieved data: {0}".format(reads))
return
class DatabaseConnectionTest(unittest.TestCase):
def setUp(self):
self.db = Database()
self.db.setup()
def tearDown(self):
self.db.dropTables()
def test_countResponses(self):
count = self.db.countResponses()
self.assertEquals(count, 0)
def test_insertsResponseIntoTable(self):
oldCount = self.db.countResponses()
resp = Response()
resp.recog = "True"
resp.comp = "Composer"
resp.comp_conf = "5"
resp.piece = "Piece"
resp.piece_conf = "3"
resp.name = "Name"
resp.age = "23"
self.db.saveResponse(resp)
newCount = self.db.countResponses()
newResponses = newCount - oldCount
self.assertEquals(newResponses, 1)
def make_database_from_pairs(df, bizpairs):
"""
make the database from the pairs returned from mrjob.
df is the dataframe, smalldf or fulldf.
bizpairs are a list of elements, each of which is a list of two
lists. The first of these lists has the two business id's, while
the second has the similarity and the common support
Returns an instance of the Database class.
"""
dbase=Database(df)
cache={}
for bp,corrs in bizpairs:
b1,b2=bp
i1=dbase.uniquebizids[b1]
i2=dbase.uniquebizids[b2]
sim,nsup=corrs
dbase.database_sim[i1][i2]=sim
dbase.database_sim[i2][i1]=sim
dbase.database_sup[i1][i2]=nsup
dbase.database_sup[i2][i1]=nsup
if cache.has_key(b1):
nsup1=cache[b1]
else:
nsup1=dbase.df[dbase.df.business_id==b1].user_id.count()
cache[b1]=nsup1
if cache.has_key(b2):
nsup2=cache[b2]
else:
nsup2=dbase.df[dbase.df.business_id==b2].user_id.count()
cache[b2]=nsup2
dbase.database_sim[i1][i1]=1.0
dbase.database_sim[i2][i2]=1.0
dbase.database_sup[i1][i1]=nsup1
dbase.database_sup[i2][i2]=nsup2
return dbase
def main ():
my_database = Database()
my_database.add_user('cool_user_jim_bob')
new_users = [
User(name='wendy', fullname='Wendy Williams', password='******'),
User(name='otherperson', fullname='Cool Beans', password='******'),
User(name='yay', fullname='NEVAR potatoes', password='******')
]
my_database.add_all_users(new_users)
print my_database.session.query(User).filter_by(password='******').first().name
def GetMachines(self):
con = Database(self.config)
stmt = "SELECT name FROM machine"
cursor = con.execute(stmt)
data = cursor.fetchall()
cursor.close()
con.close()
result = []
for row in data:
result.append(row['name'])
return result
def ProcessBuildQueue(self):
# loop from left to right
# check if a project might be ready to build
con = Database(self.config)
cursor = con.execute("SELECT * FROM build WHERE status='WAITING' ORDER BY id ASC")
data = cursor.fetchall()
for row in data:
self.attemptToFindBuildMachine(con, row)
cursor.close()
con.close()
self.CheckForHangingBuild()
class Dispatcher(object):
""" Dispatcher class to control process of working. """
def __init__(self):
create_or_check_path("logs/")
fileConfig('config/logger.conf')
self.database = Database()
self.parser = Parser()
self.event_processor = EventProcessor()
self.downloader = Downloader()
self.new_events_file = None
self.new_data = None
self.new_event = None
def processor(self):
""" Process of downloading, parsing and saving information. """
download_status = True
while download_status:
getting_event_status = self.get_event()
if getting_event_status:
processing_event_status = self.process_event()
if processing_event_status:
self.process_data()
else:
download_status = self.download()
def get_event(self):
""" Asks Parser for a new event.
:return: False if getting event failed else True
"""
self.new_event = self.parser.get_event(self.new_events_file)
return False if self.new_event is None else True
def download(self):
""" Sends a request to Downloader.
:return: False if downloading failed else True
"""
self.new_events_file = self.downloader.download_archive()
return False if self.new_events_file is None else True
def process_event(self):
""" Asks EventProcessor to get data from event.
:return: False if processing event failed else True
"""
self.new_data = self.event_processor.process_event(self.new_event)
return False if self.new_data is None else True
def process_data(self):
""" Sends data to Database. """
self.database.process_data(self.new_data)
def CanFindMachineBuildingProject(self, username, projectname):
con = Database(self.config)
stmt = "SELECT * FROM machine WHERE status = ? AND username = ? AND projectname = ?"
cursor = con.execute(stmt, ('BUILDING', username, projectname))
data = cursor.fetchone()
cursor.close()
con.close()
if data is not None:
# there is a machine building a package of the specified project
return True
return False
class ChatBot:
def __init__(self):
self.intros = {"Hello.","Hi!","Hey.","What's up?",
"Nice to see you.","Greetings.","...",
"Get on with it.","I haven't got all day.",
"*Sigh*","What a life..."}
self.database = Database()
self.database.readDatabase()
self.exits = {"Bye.","Goodbye.","Good bye.","Have a nice day.",
"See you.","See you again soon.",
"Nice talking with you."}
## self.setExit(self.shutdown)
##
## def setExit(self,f):
## if os.name == "nt":
## try:
## import win32api
## except ImportError:
## pass
## else:
## win32api.SetConsoleCtrlHandler(f,True)
## else: #Assume unix-like
## import signal
## signal.signal(signal.SIGTERM,f)
def shutdown(self,frame=None):
res = random.sample(self.exits,1)
print(res[0])
self.database.writeDatabase()
input()
def run(self):
print("Running ChatBot...\n")
res = random.sample(self.intros,1)
res = res[0]
lines = []
lines.append(res)
try:
while True:
sleep(0.6)
userResponse = input("ChatBot: " + res + '\nYou: ')
lines.append(userResponse)
if len(lines) is 4: #Must be even
ss = Snapshot()
[ss.append(l) for l in lines]
self.database.addSnapshot(ss)
lines = lines[2:] #Chop off oldest exchange
res = self.database.getFinale(userResponse)
lines.append(res)
except (KeyboardInterrupt, EOFError):
try:
sleep(2) #Get remaining interrupts
except:
pass
res = random.sample(self.exits,1)
print(res[0])
self.database.writeDatabase()
def GetJob(self,username, projectname, packagename, branchname, distro, release, arch, where):
con = Database(self.config)
stmt = "SELECT * FROM build "
stmt += "WHERE username = ? AND projectname = ? AND packagename = ? AND branchname = ? AND distro = ? AND release = ? AND arch = ? "
stmt += "AND hanging = 0 "
stmt += where
stmt += " ORDER BY id DESC"
cursor = con.execute(stmt, (username, projectname, packagename, branchname, distro, release, arch))
data = cursor.fetchone()
cursor.close()
con.close()
return data
def create_experiment():
dbname = inform.getvalue("db")
db = Database(dbname)
exp_name = inform.getvalue("name","")
experimenter = inform.getvalue("experimenter","")
exp_id = db.add_experiment(name=exp_name,experimenter=experimenter)
ids = inform.getlist("plateid")
names = inform.getlist("platename")
for pid,name in zip(ids,names):
db.add_plate(exp_id,pid,name)
show_experiments()
def process_item(self, item, spider):
# log.msg("\n\nitem: " + item.__str__() + "scrape id: " + spider.spider_id.__str__(), level = log.ERROR)
soup = BeautifulSoup(item["text"])
item["text"] = "".join(soup.findAll(text=True))
stripped_content = item["text"].replace(" ", "")
myhash = hashlib.sha1(stripped_content.__str__()).digest()
base64encoding = base64.b64encode(myhash)
item["content_hash"] = base64encoding
if base64encoding not in self.text_hashes:
# log.msg("\n\nitem: " + item.__str__(), level = log.ERROR)
self.text_hashes.append(base64encoding)
database = Database()
database.add_item(item, spider.spider_id, spider.search_term)
def __init__(self, roomnaam):
self.room_name = roomnaam
db = Database()
cursor = db.get_cursor()
cursor.execute(("SELECT * FROM `rooms` WHERE `name` = '%s'" % self.room_name))
row = cursor.fetchone()
try:
self.room_id = row[0]
except TypeError:
raise ValueError("Room doesn't exist!")
def __init__(self):
Database.__init__(self)
# get a logger
self.__logger = logging.getLogger("chattest.server.MySQLDatabase")
self.__logger.debug("Created a new MySQLDatabase object...")
# get a configuration
self.__configuration = configuration()
# init member variables
self.__connection = None
self.__cursor = None
def hits_record(self, sourceip):
d = db.get_db()
ip = ipaddr.IPAddress(sourceip)
hittoday = db.query_db("select * from hits where short=? and hitdate=date('now')", [self.short])
hitfield = "hits%s" % (ip.version)
# update hit counters
if len(hittoday) == 0:
d.execute("insert into hits (short,hitdate,%s) values (?,date('now'),1)" % (hitfield), [self.short])
else:
d.execute("update hits set %s=%s+1 where short=? and hitdate=date('now')" % (hitfield, hitfield), [self.short])
d.commit()
return
def authenticate(username, password):
username = username.lower().strip()
if len(username) == 0 or len(password) == 0:
return None
userdb = db.query_db("select * from users where username = ?", [username])
if len(userdb) == 1:
# user exists, check the hash
hash = userdb[0]["password"]
if pbkdf2_sha256.verify(password, hash):
d = db.get_db()
d.execute("update users set logins = logins + 1, last_login = date('now') where username = ?", [username])
d.commit()
return User(username)
return None
def __init__(self):
Database.__init__(self)
self.total_downloads = 0
self.queue = Queue(0)
self.report = {'success':[], 'failure':[]}
self.threads = []
for i in range(c.cfg('download-threads')):
thread = self.Downloader(self.queue, self.report)
thread.start()
self.threads.append(thread)
if self.queue.qsize() > 0:
self.queue.join()
def getStatus(self):
db = Database()
cursor = db.get_cursor()
cursor.execute(("SELECT * FROM `light` WHERE `light_id` = %s ORDER BY `datetime` DESC" % self.light_id))
row = cursor.fetchone()
cursor.close()
db.closeConnection()
# item 2 of the tuple is in
if row[2] == 1:
return "true"
else:
return "false"
import Database.Database as Database
# MH
from Problem.util import read_instance as Instance
from Problem import SCP as Problem
from Metrics import Diversidad as dv
# RepairGPU
from Problem.util import SCPProblem
# Definicion Environments Vars
workdir = os.path.abspath(os.getcwd())
workdirInstance = workdir + env('DIR_INSTANCES')
connect = Database.Database()
def HHO_SCP(id, instance_file, instance_dir, population, maxIter,
discretizacionScheme, repair):
print(f'repair: {repair}')
instance_path = workdirInstance + instance_dir + instance_file
if not os.path.exists(instance_path):
print(f'No se encontró la instancia: {instance_path}')
return False
instance = Instance.Read(instance_path)
problemaGPU = SCPProblem.SCPProblem(instance_path)
def saveConfigSetting(self):
product_cfg_buf_dic = deepcopy(self.data_of_select_product_cfg_js_dic)
# 数据库
product_cfg_buf_dic['database']['host'] = self.led_db_ip.text()
product_cfg_buf_dic['database']['user'] = self.led_db_user.text()
product_cfg_buf_dic['database']['pw'] = self.led_db_pw.text()
product_cfg_buf_dic['database']['port'] = int(self.led_db_port.text())
product_cfg_buf_dic['database'][
'db_reslt'] = self.led_db_chk_name.text()
product_cfg_buf_dic['database'][
'tb_reslt'] = self.led_db_chk_table.text()
product_cfg_buf_dic['database'][
'db_param'] = self.led_db_rec_name.text()
product_cfg_buf_dic['database'][
'tb_param'] = self.led_db_rec_table.text()
# 附加标签
product_cfg_buf_dic['label_add']['height'] = float(
self.led_add_label_height.text())
product_cfg_buf_dic['label_add']['width'] = float(
self.led_add_label_width.text())
product_cfg_buf_dic['label_add']['x_offset'] = float(
self.led_add_label_x_offset.text())
product_cfg_buf_dic['label_add']['y_offset'] = float(
self.led_add_label_y_offset.text())
product_cfg_buf_dic['label_add']['left_margin'] = float(
self.led_add_label_left_margin.text())
product_cfg_buf_dic['label_add']['right_margin'] = float(
self.led_add_label_right_margin.text())
# 标签
product_cfg_buf_dic['label']['width'] = float(
self.led_label_width.text())
product_cfg_buf_dic['label']['height'] = float(
self.led_label_height.text())
product_cfg_buf_dic['label']['has_bar_code'] = int(
self.ckb_use_barcode.isChecked())
product_cfg_buf_dic['label']['bar_code_size'] = float(
self.led_label_barcode_size.text())
product_cfg_buf_dic['label']['bar_x_offset'] = float(
self.led_label_barcode_x_offset.text())
product_cfg_buf_dic['label']['bar_y_offset'] = float(
self.led_label_barcode_y_offset.text())
product_cfg_buf_dic['label']['has_qr_code'] = int(
self.ckb_use_qrcode.isChecked())
product_cfg_buf_dic['label']['qr_code_size'] = float(
self.led_label_qrcode_size.text())
product_cfg_buf_dic['label']['qr_x_offset'] = float(
self.led_label_qrcode_x_offset.text())
product_cfg_buf_dic['label']['qr_y_offset'] = float(
self.led_label_qrcode_y_offset.text())
product_cfg_buf_dic['label']['has_hr'] = int(
self.ckb_use_hr.isChecked())
product_cfg_buf_dic['label']['hr_size'] = float(
self.led_label_hr_size.text())
product_cfg_buf_dic['label']['hr_x_offset'] = float(
self.led_label_hr_x_offset.text())
product_cfg_buf_dic['label']['hr_y_offset'] = float(
self.led_label_hr_y_offset.text())
# 保存打印机名
if self.printer_name_cur_str == '':
product_cfg_buf_dic['printer_name'] = self.led_printer_name.text()
else:
product_cfg_buf_dic['printer_name'] = self.printer_name_cur_str
tempStr = ''
if self.beChangeDefaultCfg:
if float(product_cfg_buf_dic['label']['width']) == 12.0 and float(
product_cfg_buf_dic['label']['height']) == 5.5:
fp = open(self.first_cfg_path, 'w')
json.dump(product_cfg_buf_dic, fp, indent=4)
fp.close()
tempStr = "\n并保存默认配置为:" + format('%s' % self.first_cfg_path)
elif float(
product_cfg_buf_dic['label']['width']) == 37.8 and float(
product_cfg_buf_dic['label']['height']) == 16.8:
fp = open(self.third_cfg_path, 'w')
json.dump(product_cfg_buf_dic, fp, indent=4)
fp.close()
tempStr = "\n并保存默认配置为:" + format('%s' % self.third_cfg_path)
elif float(
product_cfg_buf_dic['label']['width']) == 18.0 and float(
product_cfg_buf_dic['label']['height']) == 40.0:
fp = open(self.second_cfg_path, 'w')
json.dump(product_cfg_buf_dic, fp, indent=4)
fp.close()
tempStr = "\n并保存默认配置为:" + format('%s' % self.second_cfg_path)
else:
pass
try:
DBproduct.SaveCfgToDB(self.strmacid, self.model_name,
self.strstationid, product_cfg_buf_dic)
QMessageBox.warning(
None, 'PASS',
'已存入当前配置到' + format('%s.' % self.db_db_param_str) +
format('%s中' % self.db_tb_param_str) + tempStr)
self.btn_quit_config.setEnabled(1)
except Exception:
QMessageBox.warning(None, 'Error', '未存入当前产品配置')
return
def get_user_item_score(self):
hm_db = Database(self.id)
hm_db.connect()
return hm_db.get_item_score()
def get_user_peace_status(self):
hm_db = Database(self.id)
hm_db.connect()
return hm_db.get_peace_status()
def update_user_records(self, battles_lost, battles_won, total_winnings):
hm_db = Database(self.id)
hm_db.connect()
return " Your new battle records: **" \
+ str(hm_db.update_battle_records(battles_lost, battles_won, total_winnings)) + "**"
def update_user_peace_cooldown(self):
hm_db = Database(self.id)
hm_db.connect()
return hm_db.update_peace_cooldown()
from tkinter import *
from windowManager import windowManager
from Order import Order
from History import History
from Database import Database
from startModule import *
root = Tk()
root.geometry('550x450')
root.title('')
data = Database()
manager = windowManager(root, data)
root.mainloop()
return pairings
def opponentMatchWins(p):
'''Returns player p's oppenents match wins count'''
match_qry = """SELECT winner, loser
FROM Matches
WHERE winner = (%s)
OR
loser = (%s)"""
# wins_qry = """SELECT wins FROM Players WHERE id = (%s)"""
wins_qry = """SELECT COUNT(*) FROM Matches WHERE winner = (%s)"""
OWM = 0
with Cursor(tournament_database) as cursor:
cursor.execute(match_qry, [p, p])
p_opps = [opp for tpl in cursor.fetchall() for opp in tpl if opp != p]
for opp in p_opps:
qry = wins_qry
cursor.execute(qry, [opp])
OWM += cursor.fetchone()[0]
return OWM
tournament_database = Database('tournament', 'tournament.sql')
from Human import Human
from Student import Student
from Dean import Dean
from Semester import Semester
from Database import Database
from Leader import Leader
from Course import Course
from Subject import Subject
from Friends import Friends
import random
prowadzacyList = []
database = Database()
people = database.get_leaders()
for person in people:
leader = Leader(person[3], person[4], person[5], person[1])
prowadzacyList.append(leader)
kursyList = []
przedmioty = database.get_courses()
for przedmiot in przedmioty:
course = Course(przedmiot[1])
kursyList.append(course)
przedmiotyList = []
kursy = database.get_subjects()
for kurs in kursy:
subject = Subject(kurs[1])
class Trader(object):
# Static variables
logger = logging.getLogger("Trader")
client = Client(API_KEY, API_SECRET)
exchange_data_lock = threading.Lock()
exchange_data = DictMap({})
db_lock = threading.Lock()
database = Database()
close_prices = deque(maxlen=50)
symbol_info = DictMap(client.get_symbol_info(symbol=TRADING_PAIR))
order_queue = Queue()
order_queue_lock = threading.Lock()
analyzed_data = DictMap({})
analyzed_data_lock = threading.Lock()
buy_prices = []
buy_prices_lock = threading.Lock()
buying_lock = threading.Lock()
selling_analyzed_data = DictMap({})
def __init__(self):
self.order_id = 0
self.last_buy_price = None
self.last_sell_price = None
self.buying_lock_acquired = False
self.partially_filled_wait_start_time = None
self.order_wait_start_time = None
self.stoploss_triggered = False
def timeout(self, t, order_type='partially_filled'):
"""
Check for timeout
"""
if order_type == 'partially_filled':
if int(time.time()) > (int(t) + PARTIALLY_FILLED_WAIT_TIME):
return True
else:
if int(time.time()) > (int(t) + ORDER_WAIT_TIME):
return True
return False
@staticmethod
def get_exchange_data():
"""
Get exchange data
"""
def get_order_book(symbol):
"""
{
"lastUpdateId": 1027024,
"bids": [
[
"4.00000000", # PRICE
"431.00000000", # QTY
[] # Can be ignored
]
],
"asks": [
[
"4.00000200",
"12.00000000",
[]
]
]
}
"""
order_book = Trader.client.get_order_book(symbol=symbol, limit=10)
return DictMap(order_book)
def get_balance(asset):
"""
{
"asset": "BTC",
"free": "4723846.89208129",
"locked": "0.00000000"
}
"""
balance = Trader.client.get_asset_balance(asset)
return DictMap(balance)
def get_order_book_ticker(symbol):
"""
{
"symbol": "LTCBTC",
"bidPrice": "4.00000000",
"bidQty": "431.00000000",
"askPrice": "4.00000200",
"askQty": "9.00000000"
}
"""
ticker = Trader.client.get_orderbook_ticker(symbol=symbol)
return DictMap(ticker)
def get_sell_prices(symbol):
open_orders = Trader.client.get_open_orders(symbol=symbol)
sell_prices = [
float(open_order['price']) for open_order in open_orders
if open_order['side'] == 'SELL'
and open_order['status'] in ['NEW', 'PARTIALLY_FILLED']
]
return list(set(sell_prices))
order_book = get_order_book(TRADING_PAIR)
order_book_ticker = get_order_book_ticker(TRADING_PAIR)
sell_prices = get_sell_prices(TRADING_PAIR)
return DictMap({
'order_book': order_book,
'ticker': order_book_ticker,
'sell_prices': sell_prices
})
@staticmethod
def print_exchange_info():
"""
Print exchange information
"""
ask = Trader.exchange_data.ticker.askPrice
bid = Trader.exchange_data.ticker.bidPrice
diff = '%.8lf' % (float(ask) - float(bid))
spread = '%.2lf' % ((float(ask) / float(bid) - 1) * 100)
Trader.logger.info("*** ask: %s - bid: %s - diff: %s - spread: %s" %
(ask, bid, diff, spread))
@staticmethod
def update_exchange_info():
"""
Update the exchange data periodically.
Start as a daemon thread in main program
"""
while True:
Trader.logger.debug("Updating exchange data...")
start_time = time.time()
Trader.exchange_data_lock.acquire()
try:
Trader.exchange_data = Trader.get_exchange_data()
except Exception as e:
Trader.logger.exception(e)
Trader.exchange_data_lock.release()
Trader.print_exchange_info()
end_time = time.time()
time_diff = end_time - start_time
if time_diff < UPDATE_EXCHANGE_WAIT_TIME:
Trader.logger.debug("Sleeping ...")
time.sleep(UPDATE_EXCHANGE_WAIT_TIME - time_diff)
@staticmethod
def get_order_status(order_id):
"""
{
"symbol": "LTCBTC",
"orderId": 1,
"clientOrderId": "myOrder1",
"price": "0.1",
"origQty": "1.0",
"executedQty": "0.0",
"status": "NEW",
"timeInForce": "GTC",
"type": "LIMIT",
"side": "BUY",
"stopPrice": "0.0",
"icebergQty": "0.0",
"time": 1499827319559
}
"""
try:
order = Trader.client.get_order(orderId=order_id,
symbol=TRADING_PAIR)
except:
order = {}
return DictMap(order)
def buy(self, quantity, price):
"""
Create buy order
"""
price = self.format_price(price)
fmtd_price = '{0:.8f}'.format(price).rstrip(
'0') # in case, str(price) is in exponential notation
quantity = self.format_quantity(quantity)
self.logger.info("Buying %s at %s..." % (str(quantity), str(price)))
try:
order = Trader.client.order_limit_buy(symbol=TRADING_PAIR,
quantity=quantity,
price=fmtd_price,
newOrderRespType='RESULT')
except Exception as e:
self.logger.exception(e)
raise
self.last_buy_price = price
self.logger.info("Buying order %s created." % order['orderId'])
return order['orderId']
def sell(self, quantity, price):
"""
Create sell order
"""
price = self.format_price(price)
fmtd_price = '{0:.8f}'.format(price).rstrip('0')
quantity = self.format_quantity(quantity)
self.logger.info("Selling %s at %s..." % (str(quantity), str(price)))
try:
order = Trader.client.order_limit_sell(symbol=TRADING_PAIR,
quantity=quantity,
price=fmtd_price,
newOrderRespType='RESULT')
except Exception as e:
self.logger.exception(e)
raise
self.last_sell_price = price
self.logger.info("Selling order %s created." % order['orderId'])
return order['orderId']
def cancel(self, order_id):
"""
Cancel open order
"""
try:
resp = Trader.client.cancel_order(symbol=TRADING_PAIR,
orderId=order_id)
except Exception as e:
self.logger.exception(e)
raise
self.logger.info("Order %s has been cancelled." % resp['orderId'])
return resp['orderId']
@staticmethod
def analyze(signal):
"""
Analyze data
"""
close_prices = list(signal)
rsi = relative_strength_index(close_prices, RSI_PERIOD)
Trader.logger.debug("RSI: %.2lf" % rsi[-1])
buy_now = False
sell_now = False
if rsi[-2] <= RSI_OVERSOLD_PERCENTAGE and rsi[-1] > rsi[-2]:
buy_now = True
if rsi[-1] >= RSI_OVERBOUGHT_PERCENTAGE:
sell_now = True
return DictMap({'buy_now': buy_now, 'sell_now': sell_now})
@staticmethod
def analyze_market_data():
"""
Analyze market data
Start as daemon thread
"""
server_time = Trader.client.get_server_time()
server_time_offset = int(time.time() * 1000) - int(
server_time['serverTime'])
Trader.logger.debug("Time offset: %d" % server_time_offset)
close_time = 0
while True:
Trader.logger.debug("RUNNING...")
st = time.time()
if len(Trader.close_prices) == 0: # first time fetch
data = Trader.client.get_klines(
symbol=TRADING_PAIR,
interval=KLINE_INTERVAL_1MINUTE,
limit=500)
for point in data:
Trader.close_prices.append(float(point[4]))
close_time = int(data[-1][6])
else:
current_time_with_offset = int(
time.time() * 1000) - server_time_offset
Trader.logger.debug("close time: " + str(close_time))
Trader.logger.debug("current time with offset: " +
str(current_time_with_offset))
if current_time_with_offset > close_time:
try:
data = Trader.client.get_klines(
symbol=TRADING_PAIR,
interval=KLINE_INTERVAL_1MINUTE,
limit=2)
except Exception as e:
Trader.logger.exception(e)
continue
close_time_new = int(data[-1][6])
if close_time != close_time_new: # to avoid duplicate
close_time = close_time_new
Trader.close_prices.append(float(data[0][4]))
Trader.analyzed_data_lock.acquire()
Trader.analyzed_data = Trader.analyze(
Trader.close_prices)
Trader.logger.debug(str(Trader.analyzed_data))
Trader.analyzed_data_lock.release()
et = time.time()
if (et - st) < ANALYZE_WAIT:
Trader.logger.debug("SLEEPING...")
time.sleep(ANALYZE_WAIT - (et - st))
@staticmethod
def check_order():
"""
Check status for orders in queue
Start as daemon thread
"""
while True:
Trader.order_queue_lock.acquire()
order_queue_empty = Trader.order_queue.empty()
Trader.order_queue_lock.release()
if not order_queue_empty:
Trader.order_queue_lock.acquire()
order_id = Trader.order_queue.get()
Trader.order_queue_lock.release()
Trader.logger.info("Checking for order #%d status..." %
order_id)
order_status = Trader.get_order_status(order_id)
if not order_status:
continue
Trader.logger.info("Order #%s status: %s" %
(order_id, order_status.status))
Trader.db_lock.acquire()
order_data = {
'order_id': str(order_id),
'price': order_status.price,
'orig_quantity': order_status.origQty,
'executed_quantity': order_status.executedQty,
'side': order_status.side,
'time': order_status.time,
'status': order_status.status
}
Trader.database.order_update(order_data)
Trader.db_lock.release()
Trader.logger.info("Checking done for order #%d" % order_id)
else:
Trader.logger.info(
"Order queue is empty. Waiting for new order...")
time.sleep(CHECK_ORDER_WAIT_TIME)
def update_balance(self,
name,
initial_amount=None,
initial_quantity=None,
executed_quantity=None,
price=None,
side=None,
first_time=False):
"""
Update balance to database
"""
Trader.logger.debug("Updating balance...")
data = {'thread_name': name, 'pairs': {}}
modifier = 1 - FEE / 100.0
Trader.db_lock.acquire()
if first_time:
if not initial_amount:
data['pairs']['initial_amount'] = '0.0'
data['pairs']['current_amount'] = '0.0'
else:
data['pairs']['initial_amount'] = str(initial_amount)
data['pairs']['current_amount'] = str(initial_amount)
if not initial_quantity:
data['pairs']['initial_quantity'] = '0.0'
data['pairs']['current_quantity'] = '0.0'
else:
data['pairs']['initial_quantity'] = str(initial_quantity)
data['pairs']['current_quantity'] = str(initial_quantity)
else:
executed_quantity = float(executed_quantity)
price = float(price)
current_amount = float(
Trader.database.trader_read(
name, key='current_amount')['pairs']['current_amount'])
current_quantity = float(
Trader.database.trader_read(
name, key='current_quantity')['pairs']['current_quantity'])
if executed_quantity > 0.0:
if side == 'SELL':
current_quantity = current_quantity - executed_quantity
current_amount = current_amount + executed_quantity * price * modifier
else: #BUY
current_quantity = current_quantity + executed_quantity * modifier
current_amount = current_amount - executed_quantity * price
else:
return
data['pairs']['current_amount'] = str(current_amount)
data['pairs']['current_quantity'] = str(current_quantity)
Trader.database.trader_update(data)
Trader.db_lock.release()
def validate(self, quantity, price):
"""
Check validity of an order before sending it to the exchange
"""
filters = Trader.symbol_info.filters
price_filter = filters[0]
lot_size_filter = filters[1]
notional_filter = filters[2]
min_price = float(price_filter['minPrice'])
max_price = float(price_filter['maxPrice'])
tick_size = float(price_filter['tickSize'])
min_quantity = float(lot_size_filter['minQty'])
max_quantity = float(lot_size_filter['maxQty'])
step_size = float(lot_size_filter['stepSize'])
min_notional = float(notional_filter['minNotional'])
if price < min_price or price > max_price:
raise Exception('PRICE_EXCEPTION')
if quantity < min_quantity or quantity > max_quantity:
raise Exception('QUANTITY_EXCEPTION')
if price * quantity < min_notional:
raise Exception('MIN_NOTIONAL')
return True
def amount_to_quantity(self, amount, price):
"""
Calculate quantity
"""
quantity = amount / price
return self.format_quantity(quantity)
def format_quantity(self, quantity):
"""
Format quantity
"""
step_size = float(Trader.symbol_info.filters[1]['stepSize'])
return round(
float(step_size * math.floor(float(quantity) / step_size)), 8)
def format_price(self, price):
"""
Format price
"""
tick_size = float(Trader.symbol_info.filters[0]['tickSize'])
return round(float(tick_size * math.floor(float(price) / tick_size)),
8)
def calc_profit(self, price):
"""
Calculate the profit
"""
profit = (price / self.last_buy_price - 1) * 100
return profit
def is_profitable(self, price):
"""
Check for profitability
"""
if self.calc_profit(price) >= PREFERRED_PROFIT:
return True
return False
def is_stoploss(self, price):
"""
Check for loss
"""
loss_perc = 100 * (1 - price / float(self.last_buy_price))
if loss_perc >= STOPLOSS_TRIGGER_PERCENTAGE:
return True
return False
def calc_profitable_price(self):
"""
Calculate the profitable price
"""
price = self.last_buy_price * (1 + PREFERRED_PROFIT / 100.0)
return self.format_price(price)
def calc_buy_price(self):
"""
Calculate buy price
"""
order_book = self.exchange_data.order_book
orders = order_book.bids
last_ask = float(order_book.asks[0][0])
quantities = [float(order[1]) for order in orders]
prices = [float(order[0]) for order in orders]
for i in range(1, len(quantities)):
if sum(quantities[:i]) >= (QUANTITY_COEFFICIENT * INITIAL_AMOUNT /
prices[0]):
break
optimal_prices = prices[:i]
tick_size = float(Trader.symbol_info.filters[0]['tickSize'])
buy_price = optimal_prices[-1]
while True:
buy_price = buy_price + tick_size
if buy_price not in optimal_prices:
break
buy_price = buy_price + (BUY_PRICE_TICK_OFFSET - 1) * tick_size
if buy_price > last_ask:
buy_price = last_ask
return self.format_price(buy_price)
def calc_sell_price(self):
"""
Calculate sell price
"""
order_book = self.exchange_data.order_book
sell_prices = self.exchange_data.sell_prices # our sell prices in order book
orders = order_book.asks
last_bid = float(order_book.bids[0][0])
quantities = [float(order[1]) for order in orders]
prices = [float(order[0]) for order in orders]
for i in range(1, len(quantities)):
if sum(quantities[:i]) >= (QUANTITY_COEFFICIENT * INITIAL_AMOUNT /
prices[0]):
break
optimal_prices = prices[:i]
cmn_prices = sorted(set(sell_prices) & set(optimal_prices))
if cmn_prices:
sell_price = cmn_prices[0]
else:
tick_size = float(Trader.symbol_info.filters[0]['tickSize'])
sell_price = optimal_prices[-1]
while True:
sell_price = sell_price - tick_size
if sell_price not in optimal_prices:
break
sell_price = sell_price - (SELL_PRICE_TICK_OFFSET - 1) * tick_size
if sell_price < last_bid:
sell_price = last_bid
return self.format_price(sell_price)
def calc_sell_quantity(self):
"""
Calculate sell quantity
"""
name = threading.currentThread().getName()
Trader.db_lock.acquire()
balance = float(
Trader.database.trader_read(
name, key='current_quantity')['pairs']['current_quantity'])
Trader.db_lock.release()
return self.format_quantity(balance)
def calc_buy_quantity(self, price):
"""
Calculate buy quantity
"""
name = threading.currentThread().getName()
Trader.db_lock.acquire()
balance = float(
Trader.database.trader_read(
name, key='current_amount')['pairs']['current_amount'])
Trader.db_lock.release()
return self.amount_to_quantity(balance, price)
def calc_price_range(self, price=None, side='buy'):
"""
Calculate price range.
If the price of an open order is out of this range, cancel that order and place it again with new price.
"""
order_book = self.exchange_data.order_book
tick_size = float(Trader.symbol_info.filters[0]['tickSize'])
if side == 'buy':
orders = order_book.bids
else: #sell
orders = order_book.asks
lower_price = float(orders[0][0])
quantities = [float(order[1]) for order in orders]
prices = [float(order[0]) for order in orders]
if price:
my_price = float(price)
try:
idx = prices.index(my_price)
except:
idx = None
Trader.logger.debug(
"my price is not on the book. Set lower_price to my_price")
lower_price = my_price
if idx and idx < len(prices) - 1:
if abs(my_price -
float(orders[idx + 1][0])) > DIFF_TICKS * tick_size:
lower_price = float(orders[idx + 1][0])
for i in range(1, len(quantities)):
if sum(quantities[:i]) >= (QUANTITY_COEFFICIENT * INITIAL_AMOUNT /
lower_price):
break
upper_price = float(orders[i - 1][0])
return [lower_price, upper_price]
def buy_action(self, status=None):
self.logger.info("*** BUY ACTION ***")
if status == 'filled' or status == 'cancelled_partially_filled':
if status == 'filled' and self.stoploss_triggered:
self.stoploss_triggered = False
self.partially_filled_wait_start_time = None
self.order_wait_start_time = None
Trader.buy_prices_lock.acquire()
Trader.logger.debug("Removing price %s from buy_prices" %
(str(self.last_buy_price)))
Trader.logger.debug("buy_prices: %s" % str(Trader.buy_prices))
Trader.buy_prices = list(set(Trader.buy_prices))
try:
Trader.buy_prices.remove(self.last_buy_price)
except Exception as e:
Trader.logger.info(
"Probably the buy order was partially filled but not enough to sell."
)
Trader.logger.exception(e)
Trader.logger.debug("buy_prices: %s" % str(Trader.buy_prices))
Trader.buy_prices_lock.release()
if not self.buying_lock_acquired:
# Acquire the lock until the buying action is complete
# It blocks other threads to avoid multiple buy orders at a time
Trader.logger.debug("Acquiring buying lock...")
Trader.buying_lock.acquire()
self.buying_lock_acquired = True
Trader.logger.debug("Buying lock acquired.")
if not status or status == 'filled' or status == 'cancelled_partially_filled':
self.order_id = 0
buy_price = self.calc_buy_price()
ask = self.calc_sell_price()
Trader.buy_prices_lock.acquire()
buy_prices = Trader.buy_prices
Trader.buy_prices_lock.release()
Trader.analyzed_data_lock.acquire()
buy_now = Trader.analyzed_data.buy_now
Trader.analyzed_data_lock.release()
if not buy_now:
return
if len(buy_prices) > 0:
Trader.logger.debug("buy_prices: %s" % str(buy_prices))
min_price = min(buy_prices)
min_price_perc = (min_price / buy_price - 1) * 100
if min_price_perc >= BUY_MORE_PRICE_PERCENTAGE:
pass
else:
Trader.logger.info(
"There are incomplete actions. Waiting...")
return
bid_ask_spread = 100. * (ask / buy_price - 1)
if bid_ask_spread < BID_ASK_SPREAD:
Trader.logger.info("BID: %s - ASK: %s - SPREAD: %.2lf" %
(str(buy_price), str(ask), bid_ask_spread))
return
quantity = self.calc_buy_quantity(buy_price)
try:
self.validate(quantity, buy_price)
self.order_id = self.buy(quantity, buy_price)
except Exception as e:
Trader.logger.exception(e)
Trader.logger.info("An error occurred during buying.")
Trader.logger.debug("Releasing the buying lock...")
self.buying_lock_acquired = False
Trader.buying_lock.release()
elif status == 'new' or status == 'partially_filled':
if status == 'new':
if not self.order_wait_start_time:
self.order_wait_start_time = time.time()
if not self.timeout(self.order_wait_start_time,
order_type='new'):
return
if status == 'partially_filled':
if not self.partially_filled_wait_start_time:
self.partially_filled_wait_start_time = time.time()
if not self.timeout(self.partially_filled_wait_start_time):
Trader.logger.info(
"Partially filled. Waiting for order to be filled...")
return
else:
Trader.logger.info("Waiting for order timed out.")
ask = self.calc_sell_price()
bid_ask_spread = 100. * (ask / self.last_buy_price - 1)
price_range = self.calc_price_range(side='buy',
price=self.last_buy_price)
self.logger.debug("BUY_ACTION: price_range: %s" % str(price_range))
# if the price is not in range, cancel and try to place an order again
if self.last_buy_price > price_range[
0] or self.last_buy_price < price_range[
1] or bid_ask_spread < BID_ASK_SPREAD:
try:
self.cancel(self.order_id)
except Exception as e:
Trader.logger.exception(e)
def sell_action(self, status=None):
self.logger.info("*** SELL ACTION ***")
sell_price = self.calc_sell_price()
quantity = self.calc_sell_quantity()
profitable_price = self.calc_profitable_price()
if not status or status == 'filled' or status == 'cancelled' or status == 'cancelled_partially_filled':
if status == 'filled' or status == 'cancelled_partially_filled':
self.partially_filled_wait_start_time = None
self.order_wait_start_time = None
Trader.buy_prices_lock.acquire()
Trader.logger.debug("Appending price %s to buy_prices" %
(str(self.last_buy_price)))
Trader.logger.debug("buy_prices: %s" % str(Trader.buy_prices))
Trader.buy_prices.append(self.last_buy_price)
Trader.logger.debug("buy_prices: %s" % str(Trader.buy_prices))
Trader.buy_prices_lock.release()
Trader.logger.debug("Releasing buying lock...")
try:
Trader.buying_lock.release()
except Exception as e:
Trader.logger.exception(e)
else:
self.buying_lock_acquired = False
self.order_id = -1
Trader.analyzed_data_lock.acquire()
sell_now = Trader.analyzed_data.sell_now
Trader.analyzed_data_lock.release()
if self.is_stoploss(sell_price):
Trader.logger.info("Stop loss.")
self.stoploss_triggered = True
if not sell_now and not self.stoploss_triggered:
Trader.logger.info("waiting for sell signal.")
return
if self.stoploss_triggered:
loss_perc = 100 * (1 - sell_price / float(self.last_buy_price))
if loss_perc <= STOPLOSS_PERCENTAGE and not sell_now:
Trader.logger.info("Stop loss: waiting for sell signal.")
return
if loss_perc <= STOPLOSS_PERCENTAGE or loss_perc >= IMMEDIATELY_STOPLOSS_PERCENTAGE:
Trader.logger.info("Selling at %.2lf percent loss." %
loss_perc)
quantity = self.calc_sell_quantity()
else:
return
elif self.is_profitable(sell_price):
Trader.logger.info(
"The profit is %.2lf. Try to sell it. Least profitable_price is %.8lf."
% (self.calc_profit(sell_price), profitable_price))
else:
Trader.logger.info("Least profitable_price is %.8lf." %
(profitable_price))
return
try:
self.validate(quantity, sell_price)
self.order_id = self.sell(quantity, sell_price)
except Exception as e:
Trader.logger.exception(e)
if status == 'cancelled_partially_filled':
raise
Trader.logger.error(
"Cannot sell. Please handle it manually. Exiting...")
sys.exit(1)
elif status == 'new' or status == 'partially_filled':
if status == 'new':
if not self.order_wait_start_time:
self.order_wait_start_time = time.time()
if not self.timeout(self.order_wait_start_time,
order_type='new'):
return
if status == 'partially_filled':
if not self.partially_filled_wait_start_time:
self.partially_filled_wait_start_time = time.time()
if not self.timeout(self.partially_filled_wait_start_time):
Trader.logger.info("Waiting for order to be filled...")
return
else:
Trader.logger.info("Waiting for filled order timed out.")
price_range = self.calc_price_range(price=self.last_sell_price,
side='sell')
self.logger.debug(
"SELL_ACTION: last_sell: %s - sell_price: %s - price_range: %s"
%
(str(self.last_sell_price), str(sell_price), str(price_range)))
# cancel order that's not profitable anymore
if self.last_sell_price < price_range[
0] or self.last_sell_price > price_range[1]:
try:
self.cancel(self.order_id)
except Exception as e:
Trader.logger.exception(e)
Trader.logger.info(
"Cannot cancel order #%s. Maybe it has already fully filled."
% str(self.order_id))
def trade(self):
"""
Trading logic
"""
name = threading.currentThread().getName()
self.logger.info("%s starting...", name)
self.update_balance(name,
initial_amount=INITIAL_AMOUNT,
first_time=True)
while True:
# make a copy of exchange data
Trader.exchange_data_lock.acquire()
self.exchange_data = Trader.exchange_data
Trader.exchange_data_lock.release()
if self.order_id == 0:
self.buy_action()
elif self.order_id == -1:
self.sell_action()
else:
Trader.db_lock.acquire()
order_data = Trader.database.order_read(self.order_id)
Trader.db_lock.release()
if not order_data:
Trader.logger.info(
"Waiting for order data to be available... Sleeping for a while..."
)
time.sleep(CHECK_ORDER_WAIT_TIME)
else:
order_data = DictMap(order_data)
if order_data.status == 'NEW' and order_data.side == 'BUY':
self.buy_action(status='new')
elif order_data.status == 'NEW' and order_data.side == 'SELL':
self.sell_action(status='new')
elif order_data.status == 'FILLED' and order_data.side == 'BUY':
self.update_balance(
name,
executed_quantity=order_data.executed_quantity,
price=order_data.price,
side='BUY')
self.sell_action(status='filled')
elif order_data.status == 'FILLED' and order_data.side == 'SELL':
self.update_balance(
name,
executed_quantity=order_data.executed_quantity,
price=order_data.price,
side='SELL')
self.buy_action(status='filled')
elif order_data.status == 'PARTIALLY_FILLED' and order_data.side == 'BUY':
self.buy_action(status='partially_filled')
elif order_data.status == 'PARTIALLY_FILLED' and order_data.side == 'SELL':
self.sell_action(status='partially_filled')
elif order_data.status == 'CANCELED':
#if the order was cancelled and executed_quantity is 0, handle it as a normal case
if float(order_data.executed_quantity) == 0.0:
if order_data.side == 'BUY':
self.buy_action()
else:
self.sell_action()
# buy all with the current amount
# if the amount is not enough, sell more
else:
self.update_balance(
name,
executed_quantity=order_data.executed_quantity,
price=order_data.price,
side=order_data.side)
Trader.db_lock.acquire()
current_amount = float(
Trader.database.trader_read(
name, key='current_amount')['pairs']
['current_amount'])
current_quantity = float(
Trader.database.trader_read(
name, key='current_quantity')['pairs']
['current_quantity'])
Trader.db_lock.release()
if current_quantity * float(
order_data.price) > float(
Trader.symbol_info.filters[2]
['minNotional']):
if order_data.side == 'BUY':
self.sell_action(
status='cancelled_partially_filled')
else: # sell more when the selling order was partially filled
self.sell_action()
else:
try:
self.buy_action(
status='cancelled_partially_filled')
except:
Trader.logger.info(
'Order was partially filled. Unable to buy or sell. Please handle it manually.'
)
Trader.logger.info('%s exits now...' %
name)
sys.exit(1)
# Only put an order to the queue if its orderId > 0
if int(self.order_id) > 0:
Trader.order_queue_lock.acquire()
Trader.order_queue.put(self.order_id)
Trader.order_queue_lock.release()
time.sleep(TRADER_WAIT_TIME)
class Interface():
def __init__(self, parent):
self.window = Frame(parent) # Main window frame initialized
self.window.grid()
self.container = Frame(
self.window
) # Container window frame initialized - used to clear window
self.container.grid()
self.startup()
self.database = Database("credentials.db")
def clearWindow(self):
self.container.grid_forget()
self.container = Frame(self.window)
self.container.grid()
self.errMessage = Message(self.container,
font=('MS', 10),
fg='red',
width="320")
self.errMessage.config(justify="center")
def startup(self):
# Initialized widgets
lblUsername = Label(self.container, text='Username:'******'MS', 10))
lblPassword = Label(self.container, text='Password:'******'MS', 10))
lblRepeat = Label(self.container,
text='Repeat Password:'******'MS', 10))
lblCourse = Label(self.container, text='Your Course:', font=('MS', 10))
lblOr = Label(self.container, text='or', font=('MS', 10))
lblID = Label(self.container, text='Student ID:', font=('MS', 10))
btnLogIn = Button(self.container, text='Log-In', font=('MS', 10))
btnRegister = Button(self.container, text='Register', font=('MS', 10))
btnOpenLogIn = Button(self.container,
text='Open log-in Form',
font=('MS', 10))
btnOpenReg = Button(self.container,
text='Open Registration Form',
font=('MS', 10))
self.errMessage = Message(self.container,
font=('MS', 10),
fg='red',
width="320")
self.entUsername = Entry(self.container)
self.entPassword = Entry(self.container, show="*")
self.entRepeat = Entry(self.container, show="*")
self.entID = Entry(self.container)
self.cmbCourse = ttk.Combobox(self.container,
width=17,
state="readonly")
# Widget configuration
lblUsername.grid(row=0, column=0, padx=10, pady=5, sticky=E)
self.entUsername.grid(row=0, column=1, padx=10)
lblPassword.grid(row=1, column=0, padx=10, pady=5, sticky=E)
self.entPassword.grid(row=1, column=1)
btnLogIn.grid(row=2, column=0, columnspan=2, pady=10)
lblOr.grid(row=3, column=0, columnspan=2, pady=5)
btnOpenReg.grid(row=4, column=0, columnspan=2, pady=10)
self.cmbCourse['values'] = ["Computer Science"]
self.errMessage.config(justify="center")
def openRegistration():
self.errMessage.grid_forget()
btnLogIn.grid_forget()
btnOpenReg.grid_forget()
lblRepeat.grid(row=2, column=0, padx=10, pady=5, sticky=E)
self.entRepeat.grid(row=2, column=1)
lblID.grid(row=3, column=0, padx=10, pady=5, sticky=E)
self.entID.grid(row=3, column=1)
lblCourse.grid(row=4, column=0, padx=10, pady=5, sticky=E)
self.cmbCourse.grid(row=4, column=1, padx=10)
btnRegister.grid(row=5, column=0, columnspan=2, pady=10)
lblOr.grid(row=6, column=0, columnspan=2, pady=5)
btnOpenLogIn.grid(row=7, column=0, columnspan=2, pady=10)
self.entUsername.delete(0, END)
self.entPassword.delete(0, END)
def openLogIn():
self.errMessage.grid_forget()
lblRepeat.grid_forget()
self.entRepeat.grid_forget()
btnRegister.grid_forget()
btnOpenLogIn.grid_forget()
lblCourse.grid_forget()
self.cmbCourse.grid_forget()
lblID.grid_forget()
self.entID.grid_forget()
btnLogIn.grid(row=2, column=0, columnspan=2, pady=10)
lblOr.grid(row=3, column=0, columnspan=2, pady=5)
btnOpenReg.grid(row=4, column=0, columnspan=2, pady=10)
self.entUsername.delete(0, END)
self.entPassword.delete(0, END)
self.entRepeat.delete(0, END)
self.entID.delete(0, END)
self.entPassword.option_clear()
def tryLogIn():
if self.logIn():
self.clearWindow()
self.createMenu(self.entUsername.get())
def tryRegister():
if self.register():
openLogIn() # Go back to log-in
# Widget actions
btnLogIn['command'] = tryLogIn
btnRegister['command'] = tryRegister
btnOpenReg['command'] = openRegistration
btnOpenLogIn['command'] = openLogIn
# Function to check user credentials and proceed with logging in when 'log-in' button is pressed.
# Performs checks on user input.
def logIn(self):
username = self.entUsername.get()
password = self.entPassword.get()
if len(username) == 0 or len(password) == 0:
self.errMessage.grid(row=5, columnspan=2)
self.errMessage.config(text="You must complete all login fields!")
return False
if len(password) < 8:
self.errMessage.grid(row=5, columnspan=2)
self.errMessage.config(text="Password is at least 8 characters!")
return False
if not self.database.getUser(username, password):
self.errMessage.grid(row=5, columnspan=2)
self.errMessage.config(text="Invalid username/password.")
return False
# User is now logged in
return True
# Function to register user when 'register' button is pressed. Performs checks on user input.
def register(self):
username = self.entUsername.get()
password = self.entPassword.get()
passwordRep = self.entRepeat.get()
course = self.cmbCourse.get()
id = self.entID.get()
# Checks regarding registration fields are made here
if len(username) == 0 or len(password) == 0 or len(
passwordRep) == 0 or len(course) == 0 or len(id) == 0:
self.errMessage.grid(row=8, columnspan=2)
self.errMessage.config(
text="You must complete all registration fields!")
return False
if self.database.getUsername(username):
self.errMessage.grid(row=8, columnspan=2)
self.errMessage.config(text="This username already exists!")
return False
if len(password) < 8:
self.errMessage.grid(row=8, columnspan=2)
self.errMessage.config(
text="Password must be 8 character or more!")
return False
if password != passwordRep:
self.errMessage.grid(row=8, columnspan=2)
self.errMessage.config(text="Passwords do not match!")
return False
if len(id) > 8 or not re.findall(r'[Cc][0-9]{7}', id):
self.errMessage.grid(row=8, columnspan=2)
self.errMessage.config(text="Invalid Student ID.")
return False
# User is registered into the database here
self.errMessage.grid_forget()
self.database.addEntry(username, password, course, id)
messagebox.showinfo(
"Registered",
"You have successfully registered! You can now log-in.")
return True
def createMenu(self, username):
for row in self.database.getUserData(username):
frmCourse = Frame(self.container)
lblID = Label(self.container,
text="Student ID: " + row[2],
font=('MS', 10))
lblCourse = Label(self.container,
text="Course: " + row[1],
font=('MS', 10))
lblLesson = Label(frmCourse,
text="Choose lesson: ",
font=('MS', 10))
lblOr = Label(frmCourse, text='or', font=('MS', 10))
cmbCourse = ttk.Combobox(frmCourse, width=17, state="readonly")
btnSelect = Button(frmCourse, text='Go to Lesson', font=('MS', 10))
btnHistory = Button(frmCourse,
text='View History',
font=('MS', 10))
cmbCourse['values'] = ["Lesson 1", "Lesson 2"]
# DELETE ME
def select():
if len(cmbCourse.get()) == 0:
print("You must choose a lesson!")
self.errMessage.grid(row=3, columnspan=2)
self.errMessage.config(text="You must choose a lesson!")
return
self.clearWindow()
print("Open Lesson Menu")
def history():
self.clearWindow()
print("Open History Menu")
btnSelect['command'] = select
btnHistory['command'] = history
lblID.grid(row=0, column=0, columnspan=2, sticky=W, padx=5, pady=5)
lblCourse.grid(row=1, column=0, columnspan=2, sticky=W, padx=5)
frmCourse.grid(row=2, columnspan=2, pady=20, padx=5)
lblLesson.grid(row=0, column=0, sticky=W, pady=5)
cmbCourse.grid(row=0, column=1, sticky=W, pady=5)
btnSelect.grid(row=1, columnspan=2, pady=5)
lblOr.grid(row=3, column=0, columnspan=2, pady=10)
btnHistory.grid(row=4, columnspan=2, pady=5)
for el in elems:
if el:
res.append(el.replace("(", "").replace(")", "").replace(",", ""))
if isPlayer == False:
return [Player(int(res[0]), res[1], int(res[2]))]
if isPlayer == True:
return [Command(int(res[0]), res[1], res[2])]
return None
def getCount(command: str):
return [int(re.findall(r"(\d+)", command)[0])]
if __name__ == "__main__":
db = Database()
db.load()
dict_create = {
r"create player (\(\d+, \w+, \d+\), )*\(\d+, \w+, \d+\)": {
"funk": db.add_player,
"args": getPlayers
},
r"create command (\(\d+, \w+, \w+\), )*\(\d+, \w+, \w+\)": {
"funk": db.add_command,
"args": getCommands
}
}
dict_delete = {
r"delete player (\d+, )*\d+": {
"funk": db.del_player,
"args": getIds
def update_user_level(self):
hm_db = Database(self.id)
hm_db.connect()
return "\n<:worrysign10:531221748964786188> New level: **" + str(hm_db.update_level()) +\
"** <:worrysign10:531221748964786188>"
def threadCode(values):
conf = \
{"nameOfTheExperiment": "../50_clients_1_threadTWICE",
"placement": "us-west-2c",
"databaseType": "m3.large",
"clientInstances": (1, "m3.large"),
"middlewareInstances": (1, "m3.large"),
"databaseUsername": "******",
"databasePassword": "******",
"databaseName": "mepas",
"databasePortNumber": 5432,
"middlewarePortNumber": 6789,
"runningTimeInSeconds": 600,
"threadPoolSize": 1,
"connectionPoolSize": 1,
"totalClients": 2,
"totalQueues": 2,
"messageSize": 20,
"mappings": [(0, 0)],
"clientsData": [(2, 1)],
"username": "******",
"variable": "totalClients",
"values": values}
for variable in conf["values"]:
conf[conf["variable"]] = variable
conf["clientsData"][0] = (variable, 1)
print conf["clientsData"]
# you always need one database instance for every experiment
database = instancesRetriever.createDatabase(conf["databaseType"])
numberOfClientInstances = conf["clientInstances"][0]
clientType = conf["clientInstances"][1]
clientIPs = []
clients = []
for i in range(0, numberOfClientInstances):
inst = instancesRetriever.createClient(clientType)
clients.append(inst)
clientIPs.append(
(inst.ip_address, inst.private_ip_address, inst.instance_type))
numberOfMiddlewareInstances = conf["middlewareInstances"][0]
middlewareType = conf["middlewareInstances"][1]
middlewareIPs = []
middlewares = []
for i in range(0, numberOfMiddlewareInstances):
inst = instancesRetriever.createMiddleware(middlewareType)
middlewares.append(inst)
middlewareIPs.append(
(inst.ip_address, inst.private_ip_address, inst.instance_type))
databaseIP = (database.ip_address, database.private_ip_address)
print "IPs of machines that are going to be used"
print "Database"
print databaseIP[0] + ": " + databaseIP[
1] + ":" + database.instance_type
print "Clients"
for client in clientIPs:
print client[0] + ": " + client[2]
print "Middlewares"
for middleware in middlewareIPs:
print middleware[0] + ": " + middleware[2]
# clean database
auxiliaryFunctionsFilePath = "../../src/main/resources/auxiliary_functions.sql"
basicFunctionsFilePath = "../../src/main/resources/read_committed_basic_functions.sql"
print ">>> Going to clean and initialize database"
db = Database(databaseIP[0], conf["databasePortNumber"],
conf["databaseName"], conf["databaseUsername"],
conf["databasePassword"])
db.recreateDatabase()
db.initializeDatabase(
conf["totalClients"], conf["totalQueues"],
[auxiliaryFunctionsFilePath, basicFunctionsFilePath])
print ">>> Database was cleaned and initialized!"
print ">>> Starting CPU, memory and network utilization logging in database"
db.startLogging(conf["username"]
) # start logging CPU, memory and network utilization
print ">>> Database logging started"
# transfer the JAR to the clients & middlewares
print ">>> transferring executable JAR to clients & middlewares"
for client in clientIPs:
scpTo(jarFile, "", conf["username"], client[0])
print "JAR moved to client with IP: " + client[0]
for middleware in middlewareIPs:
scpTo(jarFile, "", conf["username"], middleware[0])
print "JAR moved to middleware with IP: " + middleware[0]
print ">>> executable JAR was transferred to the clients & middlewares"
middlewareInstances = []
for middlewareIP in middlewareIPs:
middleware = Middleware(conf["username"], middlewareIP[0],
databaseIP[1], conf["databasePortNumber"],
conf["databaseUsername"],
conf["databasePassword"],
conf["databaseName"],
str(conf["threadPoolSize"]),
str(conf["connectionPoolSize"]),
str(conf["middlewarePortNumber"]))
print middleware
middlewareInstances.append(middleware)
clientInstances = []
i = 0
for mapping in conf["mappings"]:
privateIPOfCorrespondingMiddleware = middlewareIPs[mapping[1]][1]
client = Client(conf["username"], clientIPs[mapping[0]][0],
privateIPOfCorrespondingMiddleware,
str(conf["middlewarePortNumber"]),
str(conf["clientsData"][i][0]),
str(conf["totalClients"]),
str(conf["totalQueues"]), str(conf["messageSize"]),
str(conf["clientsData"][i][1]),
str(conf["runningTimeInSeconds"]))
clientInstances.append(client)
i += 1
# clean the clients & MW from old logs and get the ready for the current experiment
# assumes file exists "~/logs" in the corresponding machines
print ">>> going to clean clients ..."
for client in clientInstances:
client.clean()
client.getReady()
print ">>> clients were cleaned from previous experiments and are ready for the new ones"
print ">>> going to clean middlewares ..."
for middleware in middlewareInstances:
middleware.clean()
middleware.getReady()
print ">>> middlewares were cleaned from previous experiments and are ready for the new ones"
print ">>> middlewares are starting ..."
for middleware in middlewareInstances:
middleware.startLogging()
middleware.start()
print ">>> middlewares were started"
now = datetime.datetime.now()
print ">>> clients are starting ... (" + str(now) + ")"
for client in clientInstances:
client.startLogging()
client.start()
print ">>> clients were started"
print ">>> waiting until all clients have finished ..."
for client in clientInstances:
while not client.isFinished():
pass
client.stopLogging()
now = datetime.datetime.now()
print ">>> clients have finished (" + str(now) + ")"
print ">>> stopping middlewares ..."
for middleware in middlewareInstances:
middleware.stop()
middleware.stopLogging()
print ">>> middlewares were stopped"
db.stopLogging(conf["username"])
# create a directory for the point of the experiment
experimentPointPath = createPath([conf["nameOfTheExperiment"]],
str(variable))
os.mkdir(experimentPointPath)
# save given configuration in the experimentPointPath
confFile = open(createPath([experimentPointPath], "configuration.csv"),
"w")
w = csv.writer(confFile)
for key, val in conf.items():
w.writerow([key, val])
confFile.flush()
# gather results and put them back somewhere locally
print ">>> getting log files from middlewares ..."
instanceCounter = 1
for middleware in middlewareIPs:
localDirectoryResults = experimentPointPath + "/middlewareInstance" + str(
instanceCounter)
os.mkdir(localDirectoryResults)
scpFrom("logs/*", localDirectoryResults, conf["username"],
middleware[0])
instanceCounter += 1
print ">>> log files from middlewares received"
print ">>> getting log files from clients ..."
instanceCounter = 1
for client in clientIPs:
localDirectoryResults = experimentPointPath + "/clientInstance" + str(
instanceCounter)
os.mkdir(localDirectoryResults)
scpFrom("logs/*", localDirectoryResults, conf["username"],
client[0])
instanceCounter += 1
print ">>> log files from clients were received"
print ">>> getting log files from database ..."
localDirectoryResults = experimentPointPath + "/database"
os.mkdir(localDirectoryResults)
scpFrom("logs/*", localDirectoryResults, conf["username"],
databaseIP[0])
print ">>> log files from database received"
instancesRetriever.terminateInstance(database)
for client in clients:
instancesRetriever.terminateInstance(client)
for middleware in middlewares:
instancesRetriever.terminateInstance(middleware)
def toggle_user_peace_status(self):
hm_db = Database(self.id)
hm_db.connect()
return hm_db.toggle_peace_status()
YOUTUBE_API_VERSION,
developerKey=DEVELOPER_KEY)
try:
video.youtube_search(y,
query="Вашингтон",
ChnlId="UCWwCM3cvQjiAecvkph7EyCQ")
for vidId in video.id_list:
video_comment_threads = comments.get_threads(y, vidId)
for thread in video_comment_threads:
comments.get(y, thread["id"])
# break
i = 0 # type: int
#https://www.youtube.com/watch?v=8W7QkEokCz0
ODB = Database("Ovechkin")
ovi_names = [
u"Алекс", u"Ови", u"Овечкин", u"Овца",
u"Сан", u"Саш", u"великий", u"Великий",
u"Барашкин", u"Капитан", u"Овц"
]
while (i != len(comments.authors)):
ODB.savetodb(comments.authors[i], comments.text[i], ovi_names)
# print "qty="+i
i += 1
ODB.deinit()
except HttpError, e:
print "An HTTP error %d occurred:\n%s" % (e.resp.status, e.content)
def find_user(self):
hm_db = Database(self.id)
hm_db.connect()
return hm_db.find_acct()
message = ""
#Setting up Socket connection
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind(('0.0.0.0', self.port))
while True:
#Waiting for connection
s.listen(10)
print("Waiting for a connection...")
connection, client_address = s.accept()
#Accepting connection
print('Connection Accepted from: ' + str(client_address[0]))
message = connection.recv(1024).decode()
print("Recieved message: " + message)
#Send to Database
self.database.writeRecord(message)
#Write to file
with open(self.path, 'a') as f:
f.write(message + "\n")
print("Message saved")
message = ""
#Needs to be an Absolute Path to get proper saving functionality
d = Database("/Users/jd/Documents/Capstone/output.txt")
c = Consumer("/Users/jd/Documents/Capstone/output.txt", 6969, d)
c.consume()
def delete_user(self):
hm_db = Database(self.id)
hm_db.connect()
hm_db.delete_acct()
return " Deleted account! <a:pepehands:485869482602922021>"
def generate_content(self, df_rec):
self.df_rec = df_rec
pptcontent = {} # dictionary to store all ppt content for a gene
"""Info fields of a gene"""
Info_rec = self.df_rec[7]
#Info_rec=variants_dataframe['INFO'][0]
''' generating dictionary of info fields '''
self.Info_dict = self.generate_info_dict(Info_rec)
"""
###########################################################
##################### Generate PPT content ################
###########################################################
"""
""" Presentation Line 1 """
""" calling function het_homo for subject,mom and dad """
try:
sub_hh = str(self.het_homo(self.df_rec[9]))
except:
sub_hh = "NA"
try:
mom_hh = str(self.het_homo(self.df_rec[10]))
except:
mom_hh = "NA"
try:
dad_hh = str(self.het_homo(self.df_rec[11]))
except:
dad_hh = "NA"
''' generating key dictionary by parsing the drill file '''
key_dictionary = self.generate_key_dictionary()
''' getting all necessary values from info dictionary by using
parsed dictionary keys from drill file fields '''
try:
NCBI_GENE = self.get_dict_value(key_dictionary['NCBI_gene'])
CAVA_GENE = self.get_dict_value(key_dictionary['CAVA_GENE'])
CAVA_CSN = self.get_dict_value(key_dictionary['CAVA_CSN'])
CAVA_LOC = self.get_dict_value(key_dictionary['CAVA_LOC'])
CAVA_IMPACT = self.get_dict_value(key_dictionary['CAVA_IMPACT'])
Phenotype = self.get_dict_value(key_dictionary['OMIM_Phenotypes'])
ExAC_AC = self.get_dict_value(key_dictionary['ExAC_AC'])
ExAC_AN_Adj = self.get_dict_value(key_dictionary['ExAC_AN_Adj'])
ExAC_AC_Hom = self.get_dict_value(key_dictionary['ExAC_AC_Hom'])
ExAC_AF_popmax = self.get_dict_value(
key_dictionary['ExAC_AF_POPMAX'])
ExAc_popmax = self.get_dict_value(key_dictionary['ExAC_POPMAX'])
gnomAD_AC = self.get_dict_value(key_dictionary['gnomAD_AC'])
gnomAD_Ex_AN_raw = self.get_dict_value(
key_dictionary['gnomAD_EX_AN_raw'])
gnomAD_Ex_Hom = self.get_dict_value(
key_dictionary['gnomAD_EX_Hom'])
gnomAD_AF_popmax = self.get_dict_value(
key_dictionary['gnomAD_AF_POPMAX'])
gnomAD_EX_popmax = self.get_dict_value(
key_dictionary['gnomAD_EX_POPMAX'])
Clinvar_significance = self.get_dict_value(
key_dictionary['Clinvar_significance'])
Clinvar_measureset = self.get_dict_value(
key_dictionary['Clinvar_measureset'])
Clinvar_transcipt = self.get_dict_value(
key_dictionary['Clinvar_transcript'])
Clinvar_protein = self.get_dict_value(
key_dictionary['Clinvar_protein'])
HGMD_pub = self.get_dict_value(key_dictionary['HGMD_Pubmed'])
HGMD_dna = self.get_dict_value(key_dictionary['HGMD_DNA'])
#HGMD_gene=self.get_dict_value(key_dictionary['HGMD_GENE'])
#HGMD_PROT=self.get_dict_value(key_dictionary['HGMD_PROT'])
Sift = self.get_dict_value(key_dictionary['dbNSFP_Sift'])
Polyphen = self.get_dict_value(key_dictionary['dbNSFP_Polyphen'])
#Metalr=self.get_dict_value(key_dictionary['dbNSFP_Metalr'])
Mutationtaster = self.get_dict_value(
key_dictionary['dbNSFP_Mutationtaster'])
#Vest3=self.get_dict_value(key_dictionary['dbNSFP_Vest3Score'])
ensemble_id = self.get_dict_value(
key_dictionary['HGNC_ensemble_id'])
entrez_id = self.get_dict_value(key_dictionary['HGNC_entrez_id'])
omim_id = self.get_dict_value(key_dictionary['HGNC_omim_id'])
#ucsc_id=self.get_dict_value(key_dictionary['HGNC_ucsc_id'])
#HGNC_location=self.get_dict_value(key_dictionary['HGNC_location'])
uniprot_id = self.get_dict_value(
key_dictionary['HGNC_uniprot_ids'])
Phenotype_list = self.get_dict_value(key_dictionary['HPO_term'])
except:
raise Exception(
"In valid keys ,Check drill_file_fields.txt in /config")
if Clinvar_transcipt == Clinvar_protein == "NA":
#warnings.warn(" WARNING !!!! : using CAVA Protein,transcript not clinvar ")
tran = CAVA_CSN.split("_")[0]
try:
prot = CAVA_CSN.split("_")[1]
except:
prot = "NA"
else:
tran, prot = Clinvar_transcipt, Clinvar_protein
location = CAVA_LOC
if dad_hh == mom_hh == "NEG":
pptcontent['Gene'] = str(NCBI_GENE + " , " + sub_hh + " , " +
tran + " , " + prot + " , [DENOVO] " +
" Dad is : " + dad_hh + " , " +
"Mom is : " + mom_hh)
else:
pptcontent['Gene'] = str(NCBI_GENE + " , " + sub_hh + " , " +
tran + " , " + prot + " , " +
" Dad is : " + dad_hh + " , " +
"Mom is : " + mom_hh)
""" Presentation Line 2 """
pptcontent['Disease'] = str(" & ".join(self.clean_pheno(Phenotype)))
""" Presentation Line 3 """
if ExAC_AC == ExAC_AN_Adj == ExAC_AC_Hom == ExAC_AF_popmax == ExAc_popmax == "NA":
Exac_string = "ExAC => Not reported"
else:
Exac_string = str("ExAC => " + ExAC_AC + "/" + ExAC_AN_Adj +
" (" + ExAC_AC_Hom + " hom ;" +
self.clean_exac_val(ExAC_AF_popmax) + "% " +
ExAc_popmax + ")")
if gnomAD_AC == gnomAD_Ex_AN_raw == gnomAD_Ex_Hom == gnomAD_AF_popmax == gnomAD_EX_popmax == "NA":
gnomAD_string = "gnomAD => Not reported"
else:
gnomAD_string = str("gnomAD => " + gnomAD_AC + "/" +
gnomAD_Ex_AN_raw + " (" + gnomAD_Ex_Hom +
" hom;" +
self.clean_exac_val(gnomAD_AF_popmax) + "% " +
gnomAD_EX_popmax + ")")
pptcontent['Exac'] = Exac_string + " , " + gnomAD_string
""" Presentation Line 4 """
if Clinvar_significance == Clinvar_measureset == HGMD_pub == HGMD_dna == "NA":
pptcontent['Clinvar'] = str(
"ClinVar => Not reported , HGMD => Not reported")
elif Clinvar_significance == Clinvar_measureset == "NA":
pptcontent['Clinvar'] = str("ClinVar => Not reported" +
" , HGMD => PMID: " + HGMD_pub +
", DNA: " + HGMD_dna)
elif HGMD_pub == HGMD_dna == "NA":
pptcontent['Clinvar'] = str("ClinVar => " + Clinvar_significance +
" , ID: " + Clinvar_measureset +
" , HGMD => Not reported")
else:
pptcontent['Clinvar'] = str("ClinVar => " + Clinvar_significance +
" , ID: " + Clinvar_measureset +
" , HGMD => PMID: " + HGMD_pub +
", DNA: " + HGMD_dna)
""" Presentation Line 5 """
pptcontent['In_silico'] = str("In silico => SIFT : " + Sift +
" , Polyphen : " + Polyphen +
" , Mutation Taster Pred : " +
"".join(Mutationtaster) +
" , CAVA_IMPACT : " + CAVA_IMPACT)
""" Presentation Line 6 """
pptcontent['Loc'] = str("Location => " +
location) #+" , Region => NA")
""" URLS """
#Cid="ENSG00000144554"
#Entrez_id="2177"
#Uniport_id="Q9BXW9"
exac_url = str("http://exac.broadinstitute.org/gene/" + ensemble_id)
ncbi_url = str("https://www.ncbi.nlm.nih.gov/gene/" + entrez_id)
uniprot_url = str("http://www.uniprot.org/uniprot/" + uniprot_id)
marrvel_url = str("http://marrvel.org/search/gene/" + CAVA_GENE)
genecards_url = str(
"http://www.genecards.org/cgi-bin/carddisp.pl?gene=" + CAVA_GENE)
if Clinvar_measureset != "NA":
clinvar_url = str(
"https://www.ncbi.nlm.nih.gov/clinvar/variation/" +
Clinvar_measureset)
pptcontent['clinvar_url'] = clinvar_url
else:
pptcontent['clinvar_url'] = "NA"
if HGMD_pub != "NA":
hgmd_pub_url = str("http://www.ncbi.nlm.nih.gov/pubmed/?term=" +
HGMD_pub)
pptcontent['hgmd_pub_url'] = hgmd_pub_url
else:
pptcontent['hgmd_pub_url'] = "NA"
if omim_id != "NA":
omim_url = str("https://www.omim.org/entry/" + omim_id +
"?search=" + omim_id + "&highlight=" + omim_id)
pptcontent['omim_url'] = omim_url
else:
pptcontent['omim_url'] = "NA"
'''
##########################################################
############# Searching DB for gene ######################
##########################################################
'''
#dirs=os.getcwd().split("\\")
#home=str(dirs[0]+"\\"+dirs[1])
db_path = os.path.join(self.database_path, "GENE_DB.db")
db = Database(db_path)
#rec=(("ANKRD2","NA","NA"),("FANCD2","NA","NA"),("RUNX1","NA","NA"),("NEFL","NA","NA"),("AMNCD1","NA","NA"),("NEFL2","NA","NA"),("NEFL7","NA","NA"))
table_name = "Gene_table"
table_cols = [
"GENE_SYM:text:PRIMARY KEY", "Entrez_summary:text:",
"Uniprot_summary:text:", "Exac_table:text:"
]
db.create_table(table_name, table_cols)
#db.insert_records(rec)
gene_list = [str(i) for i in db.get_gene_list()]
Cgene = NCBI_GENE
if Cgene in gene_list:
print " ===> Gene found in Database \n"
summaries = db.get_records(Cgene)
entrez_summary = str(summaries[1])
uniprot_summary = str(summaries[2])
pptcontent['exac_table'] = str(summaries[3])
#pptcontent['exac_table']="NA"
db.close_db_connection()
else:
"""web search for summary exac and entrez summary """
print " ===> Fetching gene details from web \n"
wp = get_web_content(exac_url, ncbi_url, uniprot_url)
pptcontent['exac_table'] = wp.exac_tab_vals()
entrez_summary = wp.entrez_gene_summary()
uniprot_summary = wp.uniprot_gene_summary()
rec = (Cgene, entrez_summary, uniprot_summary,
pptcontent['exac_table'])
db.insert_records(rec)
db.db_commit()
db.close_db_connection()
print " ===> Gene details added to DB \n"
""" Presentation Line 7 """
pptcontent['entrez_summary'] = str(
"Entrez Gene Summary / (CAVA_GENE_ID : " + ensemble_id + ") => " +
entrez_summary)
""" Presentation Line 8 """
pptcontent['uniprot_summary'] = str("Uniprot Gene Summary => " +
uniprot_summary)
""" ADD neceassary URLs of sources """
pptcontent['exac_url'] = exac_url
pptcontent['ncbi_url'] = ncbi_url
pptcontent['uniprot_url'] = uniprot_url
pptcontent['marrvel_url'] = marrvel_url
pptcontent['genecards_url'] = genecards_url
""" adding phenotypes list to ppt content """
#pheno_list="Bruising_susceptibility,Autosomal_dominant_inheritance,Thrombocytopenia"
def clean_phenotypes(pheno_list):
#pheno_list="Motor_delay,Hyporeflexia,Autosomal_dominant_inheritance,Decreased_motor_nerve_conduction_velocity,Areflexia,Myelin_outfoldings,Autosomal_recessive_inheritance,Pes_cavus,Onion_bulb_formation,Juvenile_onset,Segmental_peripheral_demyelination/remyelination,Distal_sensory_impairment,Clusters_of_axonal_regeneration,Heterogeneous,Variable_expressivity,Decreased_number_of_peripheral_myelinated_nerve_fibers,Distal_amyotrophy,Distal_muscle_weakness,Hammertoe,Steppage_gait,Ptosis,Scoliosis,Increased_connective_tissue,Hypotrophy_of_the_small_hand_muscles,Nemaline_bodies,Foot_dorsiflexor_weakness,High_palate,Facial_palsy,Split_hand,Ulnar_claw,Flexion_contracture"
pheno_items = pheno_list.split(",")
pheno_items = [re.sub("_", " ", p) for p in pheno_items]
try:
dom_recess = [
p for p in pheno_items if p.__contains__("dominant")
or p.__contains__("recessive")
]
inheritance = [
dm for dm in dom_recess if dm.__contains__("Autosomal")
]
except:
inheritance = "NA"
try:
pheno_types = [p for p in pheno_items if p not in inheritance]
except:
pheno_types = "NA"
''' Inheritance Label '''
inheritance = "".join(inheritance)
recessive = inheritance.__contains__("recessive")
dominant = inheritance.__contains__("dominant")
if recessive and dominant:
pptcontent['Inheritance'] = "AD/AR"
elif dominant:
pptcontent['Inheritance'] = "AD"
elif recessive:
pptcontent['Inheritance'] = "AR"
else:
pptcontent['Inheritance'] = "NA"
pptcontent['phenotype_list'] = pheno_types
#else:
# pptcontent['phenotype_list']=pheno_types[0:14]
clean_phenotypes(Phenotype_list)
"""
Capturing Screenshots (disabled) / un-comment below code chunk to enable screen shot capturing
"""
#img_dir_comm=str("mkdir img")
#os.popen(img_dir_comm)
#Cgene="FANCD2"
#home="h:/rp"
#screen_shots(Cgene,home) ## triggering screenshot generation by calling screen_shots.py
return pptcontent
def get_user_peace_cooldown(self):
hm_db = Database(self.id)
hm_db.connect()
return hm_db.get_peace_cooldown()
import PySimpleGUI as sg
from User import User
from Database import Database
from Validator import Validator
DB = Database()
class App:
@staticmethod
def init():
message = sg.Text('', key='-TEXT-', size=(30, 2))
layout = [[sg.Text('Username'), sg.InputText()],
[sg.Text('Password'),
sg.InputText(password_char='*')],
[sg.ReadButton('Register'),
sg.Cancel(), message]]
window = sg.Window('Simple Registration App', layout)
window.set_icon('icon.ico')
while True:
event, values = window.read()
if event == 'Cancel' or event == None:
break
if values and values[0] and values[
1]: # values[0] holds username, values[1] password
if Validator.is_valid(values[1]):
new_user = User(values[0], values[1])
try:
new_user.add(DB)
def __init__(self, esNueva=True, rowData=None):
super(QtWidgets.QDialog, self).__init__()
self.esNueva = esNueva
self.rowData = rowData
self.db = Database.getInstance()
self.productores = self.db.getProductoresList()
self.personas = self.db.getPersonasList()
self.autos = self.db.getAutosList(
None if esNueva else rowData['Auto_id'])
self.gruposRiesgo = self.db.getGruposRiesgoList()
self.resize(400, 367)
self.verticalLayout = QtWidgets.QVBoxLayout(self)
self.formLayout = QtWidgets.QFormLayout()
self.productorLabel = QtWidgets.QLabel(self)
self.productorLabel.setText("Productor")
self.formLayout.setWidget(0, QtWidgets.QFormLayout.LabelRole,
self.productorLabel)
self.productorComboBox = QtWidgets.QComboBox(self)
for productor in self.productores:
self.productorComboBox.addItem(
f"{productor['apellido']}, {productor['nombre']}",
userData=productor['legajo'])
self.formLayout.setWidget(0, QtWidgets.QFormLayout.FieldRole,
self.productorComboBox)
self.conductorLabel = QtWidgets.QLabel(self)
self.conductorLabel.setText("Conductor")
self.formLayout.setWidget(1, QtWidgets.QFormLayout.LabelRole,
self.conductorLabel)
self.conductorComboBox = QtWidgets.QComboBox(self)
for persona in self.personas:
self.conductorComboBox.addItem(
f"{persona['apellido']}, {persona['nombre']}",
userData=persona['dni'])
self.formLayout.setWidget(1, QtWidgets.QFormLayout.FieldRole,
self.conductorComboBox)
self.autoLabel = QtWidgets.QLabel(self)
self.autoLabel.setText("Auto")
self.formLayout.setWidget(2, QtWidgets.QFormLayout.LabelRole,
self.autoLabel)
self.autoComboBox = QtWidgets.QComboBox(self)
for auto in self.autos:
self.autoComboBox.addItem(
f"id/patente: {auto['id']} - Modelo: {auto['marca']} {auto['nombre']}",
userData=auto['id'])
self.formLayout.setWidget(2, QtWidgets.QFormLayout.FieldRole,
self.autoComboBox)
self.addAuto = QtWidgets.QPushButton()
self.addAuto.setText("Agregar Auto")
self.formLayout.setWidget(3, 1, self.addAuto)
self.grupoDeRiesgoLabel = QtWidgets.QLabel(self)
self.grupoDeRiesgoLabel.setText("Grupo de Riesgo")
self.formLayout.setWidget(4, QtWidgets.QFormLayout.LabelRole,
self.grupoDeRiesgoLabel)
self.GrupoDeRiesgoCombo = QtWidgets.QComboBox(self)
for grupoRiesgo in self.gruposRiesgo:
self.GrupoDeRiesgoCombo.addItem(f"{grupoRiesgo['descripcion']}",
userData=grupoRiesgo['id'])
self.formLayout.setWidget(4, QtWidgets.QFormLayout.FieldRole,
self.GrupoDeRiesgoCombo)
self.franquiciaLabel = QtWidgets.QLabel(self)
self.franquiciaLabel.setText("Franquicia")
self.formLayout.setWidget(5, QtWidgets.QFormLayout.LabelRole,
self.franquiciaLabel)
self.franquiciaLineEdit = QtWidgets.QLineEdit(self)
self.formLayout.setWidget(5, QtWidgets.QFormLayout.FieldRole,
self.franquiciaLineEdit)
self.validoDesdeLabel = QtWidgets.QLabel(self)
self.validoDesdeLabel.setText("Válido desde")
self.formLayout.setWidget(6, QtWidgets.QFormLayout.LabelRole,
self.validoDesdeLabel)
self.validoDesdeDateEdit = QtWidgets.QDateEdit(self)
self.validoDesdeDateEdit.setDate(QtCore.QDate.currentDate())
self.validoDesdeDateEdit.setCalendarPopup(True)
self.validoDesdeDateEdit.setDisplayFormat("dd-MM-yyyy")
self.formLayout.setWidget(6, QtWidgets.QFormLayout.FieldRole,
self.validoDesdeDateEdit)
self.primaLabel = QtWidgets.QLabel(self)
self.primaLabel.setText("Prima")
self.formLayout.setWidget(7, QtWidgets.QFormLayout.LabelRole,
self.primaLabel)
self.primaValue = QtWidgets.QLabel(self)
self.formLayout.setWidget(7, QtWidgets.QFormLayout.FieldRole,
self.primaValue)
self.verticalLayout.addLayout(self.formLayout)
self.buttonBox = QtWidgets.QDialogButtonBox(self)
self.buttonBox.setOrientation(QtCore.Qt.Horizontal)
self.buttonBox.setStandardButtons(QtWidgets.QDialogButtonBox.Cancel
| QtWidgets.QDialogButtonBox.Ok)
self.verticalLayout.addWidget(self.buttonBox)
self.error = QtWidgets.QLabel(self)
self.verticalLayout.addWidget(self.error)
self.buttonBox.accepted.connect(self.handleOK)
self.buttonBox.rejected.connect(self.reject)
QtCore.QMetaObject.connectSlotsByName(self)
# signals
self.conductorComboBox.currentIndexChanged.connect(
self.actualizarPrima)
self.autoComboBox.currentIndexChanged.connect(self.actualizarPrima)
self.GrupoDeRiesgoCombo.currentIndexChanged.connect(
self.actualizarPrima)
self.franquiciaLineEdit.textChanged.connect(self.actualizarPrima)
self.actualizarPrima()
if (esNueva):
self.dialogNuevaPoliza()
else:
if not rowData:
self.reject()
else:
self.dialogEditarPoliza(rowData)
def add_user(self):
hm_db = Database(self.id)
hm_db.connect()
return " Made account!\nYour starting :moneybag: balance: **$" + str(
hm_db.insert_acct()) + "**"
class AdminWindow(QWidget):
def __init__(self):
super().__init__()
self.table = QTableWidget(self) # 添加表格对象
self.database = Database('./data.db')
self.check_list = [] # 保存所有的选择框
self.show_password_flag = False # 是否显示原密码
self.select_all_flag = False # 是否选择全部
self.main_window = None
self.set_ui()
def set_main_window(self, widget):
self.main_window = widget
def set_ui(self):
self.setWindowTitle("Management page")
self.setFixedSize(1200, 900) # 配合图片大小设定的值
self.font = QFont("Consolas")
self.setFont(self.font)
self.setWindowIcon(QIcon("./IMG/python-logo.png")) # 设置图标
self.add_table() # 添加数据表格
self.get_all_user() # add table 之后才有show
self.add_line_edit() # 添加输入框
self.add_label() # 添加标签
self.add_button() # 添加按钮并绑定事件
# 添加数据表格
def add_table(self):
self.table.setFixedWidth(1020) # 设置宽度
self.table.setFixedHeight(600) # 设置高度
self.table.move(10, 30) # 设置显示的位置
self.table.horizontalHeader().setSectionResizeMode(
QHeaderView.Stretch) # 自动填充
self.table.horizontalHeader().setFont(self.font) # 设置一下字体
# self.table.setSelectionMode(QAbstractItemView.SingleSelection) # 只能单选
self.table.setSelectionBehavior(QAbstractItemView.SelectRows) # 只能选择整行
self.table.setColumnCount(4) # 设置列数
self.table.setHorizontalHeaderLabels(
["Choice", "username", "password", 'created_time']) # 设置首行
self.table.setEditTriggers(
QAbstractItemView.NoEditTriggers) # 表格中的内容设置为无法修改
self.table.verticalHeader().hide() # 把序号隐藏
self.table.setSortingEnabled(False) # 自动排序
# 获取所有的用户信息
def get_all_user(self):
data = self.database.read_table(
) # 从数据库中获取用户信息，用户信息以 username, password, created_time 形式返回
for user in data:
self.add_row(user[0], user[1], user[2])
# 在表格上添加一行新的内容
def add_row(self, username, password, created_time):
row = self.table.rowCount() # 表格的行数
self.table.setRowCount(row + 1) # 添加一行表格
self.table.setItem(row, 1,
QTableWidgetItem(str(username))) # 将用户信息插入到表格中
self.table.setItem(row, 2, QTableWidgetItem(str(password)))
self.table.setItem(row, 3, QTableWidgetItem(str(created_time)))
# 设置复选框
widget = QWidget()
check = QCheckBox()
self.check_list.append(check) # 添加到复选框列表中
check_lay = QHBoxLayout()
check_lay.addWidget(check)
check_lay.setAlignment(Qt.AlignCenter)
widget.setLayout(check_lay)
self.table.setCellWidget(row, 0, widget)
def add_line_edit(self):
self.username_edit = QLineEdit(self)
self.username_edit.setFixedSize(240, 40)
self.username_edit.move(760, 700)
self.username_edit.setPlaceholderText('username')
self.password_edit = QLineEdit(self)
self.password_edit.setFixedSize(240, 40)
self.password_edit.move(760, 760)
self.password_edit.setPlaceholderText('password')
self.password_edit.setEchoMode(QLineEdit.Password)
# 更新密码的输入框
self.update_username_edit = QLineEdit(self)
self.update_username_edit.setFixedSize(240, 40)
self.update_username_edit.move(160, 700)
self.update_username_edit.setPlaceholderText('username')
self.update_password_edit = QLineEdit(self)
self.update_password_edit.setFixedSize(240, 40)
self.update_password_edit.move(160, 760)
self.update_password_edit.setPlaceholderText('new password')
def show_password(self):
if self.show_password_flag: # 如果是真，隐藏密码
self.password_edit.setEchoMode(QLineEdit.Password)
self.show_password_flag = False
self.show_password_button.setText('Show')
else: # 否则显示密码
self.password_edit.setEchoMode(QLineEdit.Normal)
self.show_password_flag = True
self.show_password_button.setText("Hide")
# 添加界面上的标签控件
def add_label(self):
self.username_label = QLabel(self)
self.username_label.setFixedSize(160, 40)
self.username_label.move(640, 700)
self.username_label.setText('username')
self.password_label = QLabel(self)
self.password_label.setFixedSize(160, 40)
self.password_label.move(640, 760)
self.password_label.setText('password')
# 更新密码的标签
self.update_username_label = QLabel(self)
self.update_username_label.setFixedSize(160, 40)
self.update_username_label.move(40, 700)
self.update_username_label.setText('username')
self.update_password_label = QLabel(self)
self.update_password_label.setFixedSize(160, 40)
self.update_password_label.move(40, 760)
self.update_password_label.setText('password')
# 添加界面上的按钮控件
def add_button(self):
# 创建按钮对象
self.delete_button = QPushButton(self)
self.update_button = QPushButton(self)
self.add_button_ = QPushButton(self)
self.show_password_button = QPushButton(self)
self.clear_button = QPushButton(self)
self.select_all_button = QPushButton(self)
self.refresh_button = QPushButton(self)
self.main_window_button = QPushButton(self)
# 设置按钮上的文本
self.delete_button.setText("Delete")
self.update_button.setText("Update")
self.add_button_.setText("Add")
self.show_password_button.setText("Show")
self.clear_button.setText("Clear")
self.select_all_button.setText("Select All")
self.refresh_button.setText("Refresh")
self.main_window_button.setText("Main window")
# 在按钮上设置提示信息
self.delete_button.setToolTip(
"Delete the selected user, you can choose multiple users")
self.clear_button.setToolTip(
"Clear all the users, including the super user, but the super user will be "
"created later by default")
self.select_all_button.setToolTip(
"Select all the users, including the super user")
self.show_password_button.setToolTip("Show or hide the password")
self.add_button_.setToolTip(
"Add a new user with the username and password in the input box")
self.update_button.setToolTip(
"Update the password with the chosen username")
self.refresh_button.setToolTip("Click here to refresh the table")
self.main_window_button.setToolTip(
"Click here and you will go to the user interface")
# 控制位置
self.delete_button.move(1040, 340)
self.select_all_button.move(1040, 280)
self.clear_button.move(1040, 400)
self.refresh_button.move(1040, 460)
self.update_button.move(430, 700)
self.add_button_.move(1020, 700)
self.show_password_button.move(1020, 750)
self.main_window_button.move(500, 820)
# 绑定事件
self.delete_button.clicked.connect(self.delete_user)
self.select_all_button.clicked.connect(self.select_all)
self.clear_button.clicked.connect(self.clear)
self.show_password_button.clicked.connect(self.show_password)
self.add_button_.clicked.connect(self.add_user)
self.update_button.clicked.connect(self.update_password)
self.refresh_button.clicked.connect(self.refresh)
self.main_window_button.clicked.connect(self.show_main_window)
self.main_window_button.setFixedSize(200, 40)
def show_main_window(self):
self.main_window.show()
def delete_user(self):
choose_list = []
for i in self.check_list:
if i.isChecked():
username = self.table.item(self.check_list.index(i), 1).text()
if username == 'admin':
answer = QMessageBox.critical(
self, 'Error',
'You are going to delete the super user, but it will be created later with the default password',
QMessageBox.Yes | QMessageBox.Cancel,
QMessageBox.Cancel)
if answer == QMessageBox.Yes:
choose_list.append(i)
if answer == QMessageBox.Cancel:
return
else:
choose_list.append(i)
for i in choose_list:
username = self.table.item(self.check_list.index(i), 1).text()
self.database.delete_table_by_username(username)
self.table.removeRow(self.check_list.index(i))
self.check_list.remove(i)
self.database.create_table()
# 选择是否选择全部
def select_all(self):
try:
if not self.select_all_flag:
for check in self.check_list:
check.setCheckState(2) # 设置为选择状态
self.select_all_button.setText("Unselect")
self.select_all_flag = True
else:
for check in self.check_list:
check.setCheckState(0) # 设置为未选状态
self.select_all_button.setText("Select All")
self.select_all_flag = False
except: # 该错误是由于没有复选框引起
pass
# 一行一行的添加数据
def add_user(self):
username = self.username_edit.text()
password = self.password_edit.text()
if all((username, password)):
flag = self.database.insert_table(username, password)
if flag:
QMessageBox.critical(
self, 'Error',
'Already exists the username {}, please use another username'
.format(username))
else:
self.add_row(username, password, self.database.get_time())
self.username_edit.setText('') # 清空输入的用户信息
self.password_edit.setText('')
else:
QMessageBox.critical(self, 'Error', "Please fill in the blanks")
# 清空所有的数据，包括数据库和表格中的数据
def clear(self):
self.table.clearContents() # 清空表格的内容
self.table.setRowCount(0) # 将表格的行数重置为0
self.database.clear() # 清空数据库数据
# 更新密码
def update_password(self):
username = self.update_username_edit.text()
password = self.update_password_edit.text()
if len(password) >= 6:
self.database.update_table(username, password)
self.change_table(username, password)
self.update_password_edit.setText('')
self.update_username_edit.setText('')
else:
QMessageBox.information(self, 'Error',
'Password is too short, at least 6 words',
QMessageBox.Yes, QMessageBox.Yes)
# 更新表格
def change_table(self, username, password):
find_flag = False
for row in range(self.table.rowCount()):
username_find = self.table.item(row, 1).text()
if username_find == username:
self.table.item(row, 2).setText(password)
find_flag = True
break
if not find_flag: # 如果没有找到对应的用户名
QMessageBox.information(
self, 'prompt',
'Can not find the username {}'.format(username))
# 重新加载数据库并显示
def refresh(self):
self.table.clearContents()
self.check_list.clear()
self.table.setRowCount(0)
self.database.create_table()
self.get_all_user()
def update_user_money(self, amount):
hm_db = Database(self.id)
hm_db.connect()
return "Your new account balance: **$" + str(
hm_db.update_money(amount)) + "**"
def createUser(self, username=None, getAnotherUserData=False, email=None):
db = Database()
if db.connect():
if email != None:
#forget password
sql = "SELECT * FROM `user` WHERE `email` = '" + str(
email) + "';"
db.execute(sql)
data = db.getCursor().fetchone()
if data != None:
self.__usr = User(data=data,
getAnotherUserData=getAnotherUserData)
else:
sql = "SELECT * FROM `user` WHERE `username` = '" + str(
username) + "';"
db.execute(sql)
data = db.getCursor().fetchone()
if data != None:
self.__usr = User(data=data,
getAnotherUserData=getAnotherUserData)
db.close()
from Database import Database from menu import Menu Database.initialize() menu = Menu() menu.run_menu()
import xbmcgui
import xbmcaddon
import json
import threading
from datetime import datetime
import urllib
from DownloadUtils import DownloadUtils
from Database import Database
_MODE_BASICPLAY = 12
_MODE_ITEM_DETAILS = 17
# define our global download utils
downloadUtils = DownloadUtils()
db = Database()
class RandomInfoUpdaterThread(threading.Thread):
logLevel = 0
event = None
exit = False
def __init__(self, *args):
addonSettings = xbmcaddon.Addon(id='plugin.video.xbmb3c')
level = addonSettings.getSetting('logLevel')
self.logLevel = 0
if (level != None):
self.logLevel = int(level)
# 用户数据相关
import pymysql
from Database import Database
database = Database()
_host = database.gethost()
_port = database.getport()
_sql_user = database.getuser()
_sql_password = database.getpassword()
_database = database.getdatabase()
# get username:string,password:string,useremail:string, return id
def register(login_name, username, password, useremail, bio):
connection = pymysql.connect(_host, _port, _sql_user, _sql_password,
_sql_password)
# End
try:
with connection.cursor() as cursor:
# Create a new record
# TODO add sql line in here
sql1 = "INSERT INTO `Auth` (`login_name`,`password`,`user_email`) VALUES (%s, %s, %s)"
cursor.execute(sql1, (login_name, password, useremail))
sql2 = "INSERT INTO `User` (`user_name`, `bio`) VALUES (%s, %s)"
cursor.execute(sql2, (username, bio))
# !connection is not autocommit by default. So you must commit to save
# your changes.
connection.commit()
except Exception as e:
