def getRoutingFileForDate(routing_date, files_path, DEBUG):
db_handler = DBHandler('')
available_routing_files = db_handler.getPathsToRoutingFilesForDate(
routing_date)
db_handler.close()
routing_file = ''
if 'bgprib.mrt' in available_routing_files:
routing_file = available_routing_files['bgprib.mrt']
elif 'dmp.gz' in available_routing_files and 'v6.dmp.gz' in available_routing_files:
# If there is not bgprib.mrt file available, but the two dmp files
# (for v4 and v6) are available, I use them
dmp_file = available_routing_files['dmp.gz']
readable_dmp = BGPDataHandler.getReadableFile(
dmp_file, False, files_path, DEBUG)
v6dmp_file = available_routing_files['v6.dmp.gz']
readable_v6dmp = BGPDataHandler.getReadableFile(
v6dmp_file, False, files_path, DEBUG)
routing_file = BGPDataHandler.concatenateFiles('{}/{}_v4andv6.dmp.readable'\
.format(files_path, routing_date),
readable_dmp, readable_v6dmp)
elif 'dmp.gz' in available_routing_files:
# If there is only one of the dmp files available, I will work with it
routing_file = available_routing_files['dmp.gz']
elif 'v6.dmp.gz' in available_routing_files:
# If there is only one of the dmp files available, I will work with it
routing_file = available_routing_files['v6.dmp.gz']
return routing_file
def store(geo):
cur = DBHandler.getConn().cursor()
if GeoDAO.isStored(cur, geo) is True:
print 'Geo({0},{1}) is already stored.'.\
format(geo.longitude, geo.latitude)
return
sql = '''insert into geo(longitude,latitude,city,province,city_name,
province_name,address,address_pinyin,more)
values(%s, %s, %s, %s, %s, %s, %s, %s, %s)'''
value = []
value.append('longitude' in geo and geo.longitude or None)
value.append('latitude' in geo and geo.latitude or None)
value.append('city' in geo and geo.city or None)
value.append('province' in geo and geo.province or None)
value.append('city_name' in geo and geo.city_name or None)
value.append('province_name' in geo and geo.province_name or None)
value.append('address' in geo and geo.address or None)
value.append('address_pinyin' in geo and geo.address or None)
value.append('more' in geo and geo.more or None)
cur.execute(sql, value)
cur.close()
return DBHandler.getConn().insert_id()
def udfbc():
userid = request.form['userid']
candidate = request.form['candidate'].capitalize()
relation = request.form['relation']
childName = request.form['childName'].capitalize()
fname = request.form['fname'].capitalize()
mname = request.form['mname'].capitalize()
gender = request.form['gender']
religion = request.form['religion']
districtOfDOB = request.form['districtOfDOB']
grandFatherName = request.form['grandFatherName'].capitalize()
grandFatherCNIC = request.form['grandFatherCNIC'].capitalize()
dob = request.form['dob']
address = request.form['address'].capitalize()
district = request.form['district']
tehsil = request.form['tehsil']
doi = request.form['doi']
db = DBHandler(app.config["DATABASEIP"], app.config["DB_USER"],
app.config["DB_PASSWORD"], app.config["DATABASE"])
result = db.updateDataForBC(userid, candidate, relation, childName, fname,
mname, gender, religion, districtOfDOB,
grandFatherName, grandFatherCNIC, dob, address,
district, tehsil, doi)
return redirect(url_for('ufubc'))
def insert_tweet(tweet: Tweet, db_handler: DBHandler):
query = (
f"INSERT INTO {TweetDBHandler.DATABASE_NAME}.tweets (id, createdAt, text, userId, isRetweet, latitude, longitude, place_country, place_name, place_type) "
"VALUES (%s,%s,%s,%s,%s,%s,%s,%s,%s,%s)")
# values = TweetDBHandler.gen_tweet_query_values(tweet)
values = tweet.tweet_tuple()
db_handler.execute_query_with_data(query, values)
def add_paciente():
if not session.get('logged_in'):
return "you need to log in first"
if request.method == 'POST':
if 'file' not in request.files:
print("no file")
render_template('paciente_add.html')
f = request.files['file']
filename = f.filename
open('files/' + filename, 'x') # Cuidado: va a tirar excepcion si el archivo ya existe
file_path = 'files/' + filename # Para guardar en DB
f.save(file_path)
paciente_name = getPacienteNameFromFile(file_path) # Para guardar en DB
fecha = str(datetime.date.today())
dni = request.form['dni']
if dni == "":
dni = "0"
paciente = Paciente(id=None, nombre=paciente_name, dni=dni, fecha=fecha, file_path=file_path)
db = DBHandler()
db.add_paciente(paciente)
list_paciente = db.get_pacientes()
return render_template('pacientes.html', lista=list_paciente)
else:
return render_template('paciente_add.html')
def hosts_liked():
dbh = DBHandler()
results = dbh.query("SELECT user_id, liked_id FROM user_action")
liked = pd.DataFrame(results, columns=['user_id', 'host_id'])
liked['flag'] = 'l'
return liked
def signin():
error = None
try:
db = pymysql.connect(app.config["DATABASEIP"], app.config["DB_USER"], app.config["DB_PASSWORD"],
app.config["DATABASE"])
cur = db.cursor()
if request.method == 'POST':
email_form = request.form['email']
print(email_form)
sql = 'SELECT COUNT(1) FROM USERS WHERE email = %s ;'
args = (email_form)
cur.execute(sql, args)
if not cur.fetchone()[0]:
print("why")
raise ServerError('Invalid Email')
password_form = request.form['password']
# cur.execute("SELECT password FROM USERS WHERE email = {};"
# .format(email_form))
sql2 = 'SELECT password FROM USERS WHERE email = %s ;'
args2 = (email_form)
cur.execute(sql2, args2)
projectList = []
error = None
DBHandler_ = DBHandler(app.config["DATABASEIP"], app.config["DB_USER"], app.config["DB_PASSWORD"],
app.config["DATABASE"])
try:
projectList = DBHandler_.getProjectList(email_form)
session['projectList'] = projectList
print(session['projectList'])
except DBError as e:
error = str(e)
print(str(e))
for row in cur.fetchall():
#print(type(password_form))
# print(row[0].strip("'"))
print(password_form)
print(row[0])
if password_form == row[0]:
session['user'] = request.form['email']
return render_template('addfiles.html',projectList=session['projectList'], error=error ,email=session['user'])
else:
raise ServerError('Invalid password')
except ServerError as e :
error = str(e)
except Exception as e:
error = str(e)
return render_template('login.html', error=error)
def __init__(self, videoinfo, logfile=None, isShow=False, savepic=False):
"""初始化
Arguments:
videoinfo {视频信息} -- {'name','datetime','descrption'}
Keyword Arguments:
logfile {string} -- 可选，log文件名 (default: {None})
isShow {bool} -- 是否显示处理过程 (default: {False})
"""
BasicPart.__init__(self, logfile, isShow)
self.videoinfo = videoinfo
self.__mkdirs()
self.dbhandler = DBHandler()
self.item_list = []
# 人物识别
self.pf = PersonFace(True)
fi = FeatureIndex(True)
fi.load_person_index(["Person"])
self.pf.setFeatureIndex(fi)
self.savepic = savepic
# solr
self.solrhandler = MainSolr(logfile, isShow)
self.save_video()
pass
def get_host_ids():
dbh = DBHandler()
results = dbh.query(
'SELECT user_id, CONCAT(fname, \" \", lname) AS name FROM user')
host_id = pd.DataFrame(results, columns=['host_id', 'name'])
return host_id
def saveDB(col, data, db="Pstatus.db", table=jh):
Pdb = DBHandler(db)
# 创建表
# table_cmd =
# status
# table_cmd = col[0] + " INT,"
# 日期
table_cmd = col[0] + " text,"
for i in range(1, len(col)):
table_cmd += col[i] + " REAL DEFAULT 0,"
table_cmd = table_cmd.rstrip(',')
print("table_cmd:", table_cmd)
Pdb.createTable(table, table_cmd)
# 插入数据
Pdb.insertMany(table, data)
# 提交
Pdb.dbCommit()
# 查询
# des,res = Pdb.queryAll("Pstatus",1000)
# print(res)
# 关闭
Pdb.dbClose()
def handle_next_request(self):
db = DBHandler(DB_PATH)
itemsList = db.getItemsList()
listSize = len(itemsList)
self.index = (self.index + 1) % listSize
returnItem = itemsList[0]['data'][self.index]
return returnItem
def handle_crawl_request(self):
db = DBHandler(DB_PATH)
data = request.form.to_dict()
newItem = {'username': data['username'], 'data': self.getContent(data)}
db.addItem(newItem)
returnItem = newItem['data'][0]
return returnItem
def hosts_seen():
dbh = DBHandler()
results = dbh.query("SELECT user_id, seen_id FROM user_seen")
seen = pd.DataFrame(results, columns=['user_id', 'host_id'])
seen['flag'] = 's'
return seen
def get_user_ids():
dbh = DBHandler()
results = dbh.query('SELECT user_id FROM user')
user_id = [item[0] for item in results]
user_id = pd.DataFrame(user_id, columns=['user_id'])
return user_id
def userSignIn():
error = None
db = None
try:
userId = request.form['userid']
password = request.form['password']
db = DBHandler(app.config["DATABASEIP"], app.config["DB_USER"],
app.config["DB_PASSWORD"], app.config["DATABASE"])
result = db.signin(userId, password, "user")
if (result == None):
error = 'Invalid Credentials. Please try again.'
else:
session['logged_in'] = True
session['id'] = result[0]
session['username'] = result[1].capitalize()
session['userid'] = result[3]
session['type'] = 'user'
return redirect(url_for('userWelcome'))
return render_template('login.html', error=error)
except Exception as e:
print(e)
error = str(e)
return render_template('login.html', error=error)
def onSub(user_open_ID):
user_dict = WeChatHandler().getUserInfo(user_open_ID)
user_priority = UserHandler.verify_user(user_open_ID)
if user_priority == -1:
user_insert_sql = "INSERT into UserInfo VALUES ('%s', 'N', '%s', null, '%s', null, null, null, '%s', null, " \
"null, null, null)" % (
user_open_ID, user_dict['nickname'], TypeDef.sex_dict[user_dict['sex']],
(user_dict['city'] + ',' + user_dict['province'] + ',' + user_dict[
'country']).replace("\'", "\\\'"))
DBHandler().insert(user_insert_sql)
else:
update_sql = "UPDATE UserInfo SET WechatName = '%s',Sex='%s',Address='%s' WHERE Open_ID = '%s'"\
% (user_dict['nickname'], TypeDef.sex_dict[user_dict['sex']],
(user_dict['city'] + ',' + user_dict['province'] + ',' + user_dict['country']).replace("\'", "\\\'"),
user_open_ID)
DBHandler().update(update_sql)
return_msg = Resource.getMsg("WlcMsg", user_dict['language'])
'''
if user_dict['language'] == "zh_CN":
sql_query = "Select IDX,Media_ID,Title from HistoryArticle"
else:
sql_query = "Select IDX,Media_ID,Title from HistoryArticle WHERE Language = 'en'"
results = DBHandler().select(sql_query)
for line in results[1]:
return_msg = return_msg + str(line[0]) + "..." + line[2] + "\n"
threading.Timer(3, WeChatHandler().sendMsgViaCust,
(Resource.getMsg("Menu", user_dict['language']), "touser", user_open_ID)
).start()
'''
return return_msg
def createproject():
print("In Project Creation")
if request.method == 'POST':
pname = request.form['pname']
pDesc = request.form['pDesc']
error = None
projectList = []
projectlistJSON = []
DBHandler_ = DBHandler(app.config["DATABASEIP"], app.config["DB_USER"],
app.config["DB_PASSWORD"], app.config["DATABASE"])
error = None
try:
create = DBHandler_.createProject(pname, pDesc, session['user'])
projectList = DBHandler_.getProjectList(session['user'])
projectlistJSON = DBHandler_.getProjectJSON(session['user'])
if (projectList != []):
session['projectList'] = projectList
except DBError as e:
error = e
return render_template('createProject.html',
projectList=projectlistJSON,
email=session['user'])
def valid(self, username, password):
query = f"SELECT COUNT(*) FROM User WHERE username = '******' AND password = PASSWORD('{password}')"
DB = DBHandler()
count = DB.exec(query)
if count[0][0]:
return True
return (False)
def udfdc():
userid = request.form['userid']
natureOfDeath = request.form['natureOfDeath']
unc = request.form['unc']
no = request.form['no']
place = request.form['place']
district = request.form['district']
applicantName = request.form['applicantName'].capitalize()
applicantCNIC = request.form['applicantCNIC']
relation = request.form['relation']
decessedName = request.form['decessedName'].capitalize()
decessedCNIC = request.form['decessedCNIC']
gender = request.form['gender']
religion = request.form['religion']
fname = request.form['fname'].capitalize()
fatherCNIC = request.form['fatherCNIC']
graveyardName = request.form['graveyardName'].capitalize()
dob = request.form['dob']
dod = request.form['dod']
reason = request.form['reason'].capitalize()
address = request.form['address'].capitalize()
occupation = request.form['occupation'].capitalize()
markOfIndication = request.form['markOfIndication'].capitalize()
db = DBHandler(app.config["DATABASEIP"], app.config["DB_USER"],
app.config["DB_PASSWORD"], app.config["DATABASE"])
result = db.updateDataForDC(userid, unc, no, place, district,
applicantName, applicantCNIC, relation,
decessedName, decessedCNIC, gender, religion,
fname, fatherCNIC, graveyardName, dob, dod,
reason, address, occupation, markOfIndication,
natureOfDeath)
return redirect(url_for('ufudc'))
def feedback():
db=None
error = None
result1=None
result2=None
try:
name = request.form.get('name')
email = request.form.get('email')
subject = request.form.get('subject')
message = request.form.get('message')
db = DBHandler('localhost', app.config["DB_USER"], app.config["DB_PASSWORD"],
app.config["DATABASE"])
result1 = db.getPatientID2(name, email)
print("Aik lgani hai chal ja")
if (result1 != False):
print("Aik lgani hai chal ja 2")
result2 = db.insertFeedback(result1,subject,message)
if (result2 != True):
flash("Feedback Not Sent!")
else:
flash("Your feedback have been Sent!")
except Exception as e:
print(e)
error = str(e)
return redirect(url_for('index', _anchor='feedBack'))
finally:
return redirect(url_for('index'))
def unSub_Weahter(user, city, lang):
UserHandler.logger.info(
"User <%s> is un-subscribing the city <%s> weather" % (user, city))
# QUERY
user_sub_result = DBHandler().select(
"SELECT Cities from WeatherSub WHERE Open_ID = '%s'" % user)
content = ""
if int(user_sub_result[0]) > 0:
old_cities = user_sub_result[1][0][0].split()
if city not in old_cities:
content = "未订阅<%s>天气" % city
else:
old_cities.remove(city)
if len(old_cities) > 0:
content = Resource.getMsg(
"UnSubWea", lang) % (city, " ".join(old_cities))
update_sql = "UPDATE WeatherSub SET Cities = '%s' WHERE Open_ID = '%s'" % (
" ".join(old_cities), user)
DBHandler().update(update_sql)
else:
content = Resource.getMsg("UnSubAllWea", lang) % city
delete_sql = "DELETE from WeatherSub WHERE Open_ID = '%s'" % (
user)
DBHandler().delete(delete_sql)
else:
content = Resource.getMsg("NoSub", lang)
return content
def check_wait(self, user, msg):
content = ""
counts = 0
if user in self.user_wait_list and user == self.user_list[
0] and msg == "是":
DBHandler().insert(
"INSERT into HealthyRecord VALUES (null, '%s', 'Y', null)" %
user)
counts = DBHandler().select(
"SELECT CreateData from HealthyRecord WHERE IsRecord = 'Y' and CreateData > '2017-09' \
and CreateData < '2017-10' AND Open_ID = '%s'" % user)[0]
content = Resource.getMsg("RecordFmt") % (
Resource.getMsg("GodSub"), str(counts))
self.user_wait_list.remove(user)
if Utill.is_last_day():
content = content + Resource.getMsg("BillHealty") % (counts,
counts)
elif user in self.user_wait_list and user == self.user_list[
1] and msg == "是":
DBHandler().insert(
"INSERT into HealthyRecord VALUES (null, '%s', 'Y', null)" %
user)
counts = DBHandler().select(
"SELECT CreateData from HealthyRecord WHERE IsRecord = 'Y' and CreateData > '2017-09' \
and CreateData < '2017-10' AND Open_ID = '%s'" % user)[0]
content = Resource.getMsg("RecordFmt") % (
Resource.getMsg("LingSub"), str(counts))
self.user_wait_list.remove(user)
if Utill.is_last_day():
content = content + Resource.getMsg("BillHealty") % (counts,
counts)
return content
def process(threadName):
while True:
with open('configurations.json') as f:
data = json.load(f)
DATABASEIP = data["DATABASEIP"]
DB_USER = data["DB_USER"]
DB_PASSWORD = data["DB_PASSWORD"]
DATABASE = data["DATABASE"]
THREAD_SLEEP_TIME = data["THREAD_SLEEP_TIME"]
DBHandler_ = DBHandler(DATABASEIP, DB_USER, DB_PASSWORD, DATABASE)
fileList = []
try:
fileList = DBHandler_.getFilesToProcess()
print("Going to process" + str(len(fileList)) + "files")
try:
for file_ in fileList:
FileProcessor_ = FileProcessor()
FileProcessor_.process(file_)
except Exception as e:
print("Error in File Processing Thread" + str(e))
print(traceback.format_exc())
DBHandler_.updateFileStatus(file_.FileName, "F")
except Exception as e:
print("Error in File Processing Thread" + str(e))
print(traceback.format_exc())
print(threadName + "going to sleep for " + str(THREAD_SLEEP_TIME))
time.sleep(THREAD_SLEEP_TIME)
def hosts_messaged():
dbh = DBHandler()
results = dbh.query(
"SELECT DISTINCT sending_user, receiving_user FROM user_message")
messaged = pd.DataFrame(results, columns=['user_id', 'host_id'])
messaged['flag'] = 'm'
return messaged
def showUsers():
print("In show Files")
DBHandler_ = DBHandler(app.config["DATABASEIP"], app.config["DB_USER"], app.config["DB_PASSWORD"],
app.config["DATABASE"])
pname = request.args.get("pname")
print("Project:",pname)
projectUsersList = DBHandler_.getProjectUsers(pname)
return jsonify(projectUsersList)
def paciente_dni():
if request.method == 'POST':
db = DBHandler()
dni = request.form['dni']
if int(dni) > 1:
paciente = db.get_one_paciente_dni(dni)
return render_template('paciente_details.html', paciente=paciente, fromAdmin=False)
return render_template('paciente_dni.html')
def handleLogin(self, username, password):
if DBHandler.login(username, password) is True:
self.soc.send(Protocols.GOOD.encode())
DBHandler.log(username, Protocols.ACTION_LOGIN,
username + Protocols.CONTENT_LOGIN)
self.soc.close()
else:
self.soc.send(Protocols.LOGIN_FAILED.encode())
self.soc.close()
def search_paciente(name_or_dni):
if not session.get('logged_in'):
return "you need to log in first"
if request.method == 'POST':
val = request.form['search_text']
name_or_dni = str(name_or_dni)
db = DBHandler()
list = db.search_paciente(name_or_dni=name_or_dni)
return render_template('pacientes.html', list=list)
def delete_paciente(post_id):
if not session.get('logged_in'):
return "you need to log in first"
db = DBHandler()
paciente = db.get_one_paciente(post_id)
try:
os.remove(paciente.file_path)
except:
print("Error al eliminar archivo")
db.delete_paciente(post_id)
return render_template('delete.html', paciente=paciente)
def query_db(jh):
dbquery = DBHandler(db)
dbquery.row_factory()
col_name,rv = dbquery.queryAll(jh,100000)
dbquery.dbCommit()
dbquery.dbClose()
# return (rv[0] if rv else None) if one else rv
return col_name,rv
def saveSents(corpuspath,diacratic):
l = []
tool = MyToolKit()
hdb = DBHandler("model.db")
for path, dirs, files in os.walk(corpuspath):
for f in files:
if f.startswith('_') != diacratic :
print("Traiter le fichier : "+path+'/'+f)
f = codecs.open(path+'/'+f,'r', encoding='utf-8').read()
#f = f.replace('||', ' ')
l += tool.sents(f,["\n","\r",".",":",",",';'],subsent=['"',"'",'-'])
l2 = []
for a in l:
#Eliminé les phrases qui ont un seul mot (problème de nettoyage)
if len(tool.words(a))>1 : l2.append("# "+a+" $")
print("Création de la distribution de fréquences ...")
fdist = nltk.FreqDist(l2)
print("OK !")
print("Convertir la liste en cours ...")
data = []
for fd in fdist: data.append([fd,fdist[fd]])
print("Stocker les phrases base de données !")
hdb.connect()
if diacratic == True : hdb.insertIntoTable('sents_all',data)
else : hdb.insertIntoTable('sents',data)
print("OK !")
def saveNormalizedWord():
tool = MyToolKit()
hdb = DBHandler("model.db")
print("Récuperation des phrases (with diacratic) ...")
hdb.connect()
sents = hdb.getFromTable('sents_train')
print("Done !")
print("Récuperations des mots, et Création des distributions de fréquences ...")
words = []
fdist = nltk.FreqDist()
#words = []
for sent in sents:
for word in tool.words(sent[1]):
#word_without_diac = tool.DeleteDiacritic(word)
#if len(word) > 1 or word == 'و':
if have_diac(word)==True or word == '#' or word == '$' : fdist[normalizeArabicAlif(word)] = fdist[normalizeArabicAlif(word)]+sent[2]
print("Done !")
print("Convertion des listes en cours ...")
data = []
#data = []
#for fd in fdist: data.append([fd,fdist[fd]])
for fd in fdist: data.append([fd,fdist[fd]])
print("OK !")
print("Stocker les mots dans la base de données :")
print("With diac ...")
hdb.insertIntoTable('words_normalized',data)
print("Done !")
def saveNgramsDiac(n):
tool = MyToolKit()
hdb = DBHandler("model.db")
print(":::: Statistique Ngrams("+str(n)+") ::::")
print("Récuperation des phrases (with diacratic) ...")
hdb.connect()
sents = hdb.getFromTable('sents_train',attribute='sent')
print("Done !")
print("Création des Ngrams ...")
grams = []
for sent in sents: grams += nltk.ngrams(tool.words(sent[0]),n)
print("Done !")
print("Création de la distribution de fréquences ...")
fdist = nltk.FreqDist(grams)
print("Done !")
print("Convertion des listes en cours ...")
data = []
for fd in fdist: data.append([' '.join(fd),fdist[fd]])
print("OK !")
print("Stocker les mots dans la base de données :")
hdb.insertIntoTable('grams'+str(n),data)
print("Done !")
def __init__(self, parent=None ):
QtGui.QMainWindow.__init__(self, parent)
self.setupUi(self)
#self.connection_string="sqlite:///%s/../../davstorage/db/devel.db" % (os.getcwd())
self.connection_string="postgres://*****:*****@localhost/davstorage"
self.dbhandler = DBHandler(self.connection_string)
widget = AuthWindow(self.dbhandler,self)
widget.setModal(True)
widget.exec_()
if self.dbhandler.getCurrentUser() == None:
self.close()
self.update_data()
def creatDict():
tool = MyToolKit()
hdb = DBHandler("model.db")
print("Récuperation des mots (with diacratic) ...")
hdb.connect()
words = hdb.getFromTable('words')
print("Done !")
print("Création du dictionnaire ...")
dict = defaultdict(list)
for tuple in words:
dict[DeleteDiacritic(normalizeArabicAlif(tuple[1]))].append(tuple[1])
data = []
print("Done !")
print("Convertion de la liste en cours ...")
for type in dict:
data.append((type,' '.join(dict[type])))
print("Done !")
print("Stocker le dictionnaire dans la base de données :")
hdb.insertIntoTable('dictionary',data)
print("Done !")
def insert_district_his_statistics_data(conn, values): sql = 'insert into district_his_statistics_data(insert_date, district, district_avarage_price, deal_in_last_month, deal_compare_last_month, deal_compare_last_year, on_sale, deal_in_90_days, deal_in_yesterday, daikan_in_yesterday) values (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s)' dbHandler = DBHandler() dbHandler.insert_batch_record(conn, sql, values)
# "/mnt/data27/wisser/drmaize/image_data/e013SLB/microimages/reconstructed/HS/e013SLBp01wA1x20_1506111930rc001.ome.tif"
import sys, os
from DBHandler import DBHandler
from xlrd import open_workbook
db_name = "test_drmaizeIDB"
dbh = DBHandler(database=db_name)
path = "/mnt/data27/wisser/drmaize/image_data/e013SLB/microimages/reconstructed/HS/"
xls_file_path = "/mnt/data27/wisser/drmaize/Bioimage_Metadata.xlsm"
book = open_workbook(xls_file_path)
files = [file for file in os.listdir(path)
if os.path.isfile(os.path.join(path, file)) and not f.startswith('.')]
table = 'inventory'
sheet = book.sheet_by_index(0)
for row_index in xrange(1, sheet.nrows):
row_list = []
# If sampleID isn't exp 13
sampleID = str(sheet.cell(row_index, 1).value).encode('ascii')
if sampleID[:6] == '013SLB':
for col_index in xrange(1, sheet.ncols-1):
row_list.append(str(sheet.cell(row_index, col_index).value).encode('ascii'))
dbh.insert_into(table,row_list)
# Failed: INSERT into microImage VALUES
# ('013SLBp01wA1','e013SLBp01s1_1412161734_R1_GR1_B1_L201.lsm','e013SLBp01s1_1412161734_R1_GR1_B1_L300.lsm',
def insert_history_statistics_data(conn, values): sql = 'insert into history_statistics_data(insert_date, on_sale, deal_in_90_days, deal_in_yesterday, daikan_in_yesterday, new_added_house_yesterday, new_added_customer_yesterday) values (%s, %s, %s, %s, %s, %s, %s)' dbHandler = DBHandler() dbHandler.insert_single_record(conn, sql, values)
def insert_village_his_statistics_data(conn, values): sql = 'insert into village_his_statistics_data(insert_date, village_name, village_avarage_price, on_sale, deal_in_90_days, deal_in_30_days, daikan_in_30_days) values (%s, %s, %s, %s, %s, %s, %s)' dbHandler = DBHandler() dbHandler.insert_batch_record(conn, sql, values)
################################################################################
import os, sys, thread,\
traceback, time,\
xmlrpclib
try:
import irclib
except:
print "\n\nImport of irclib has failed! Please install python-irclib!\n\n"
sys.exit(1)
from DocXMLRPCServer import DocXMLRPCServer
from DBHandler import DBHandler
from PersonaliPy import Mood
db = DBHandler()
################################################################################
#########################
# Credits: #
#########################
# #
# Martin Brabham #
# #
# Chris Soyars #
# #
#########################
################
# DevBot Class #
def setUp(self): self.handler = DBHandler()
class DBHandlerTester(unittest.TestCase):
def setUp(self):
self.handler = DBHandler()
def tearDown(self):
self.handler.closeCursor()
def testCreateNewTableAndInsertRow(self):
self.handler.createNewTable(['c1', 'c2', 'c3', 'c4'])
row1 = ['r1c1', 'r1c2', 'r1c3', 'r1c4']
self.handler.insertRow(row1)
row2 = ['r2c1', 'r2c2', 'r2c3', 'r3c4']
self.handler.insertRow(row2)
results = self.handler.executeQuery('select * from xmldata')
# each returned row is a tuple, so has to be converted to list for comparison
assert list(results[0]) == row1 and list(results[1]) == row2, results
def testGetColumnNames(self):
columns = ['c1', 'c2', 'c3', 'c4']
self.handler.createNewTable(columns)
results = self.handler.getColumnNames()
assert results == columns, results
class MainWindow(QtGui.QMainWindow, Ui_MainWindow):
currentUser = None
currentGroup = None
def __init__(self, parent=None ):
QtGui.QMainWindow.__init__(self, parent)
self.setupUi(self)
#self.connection_string="sqlite:///%s/../../davstorage/db/devel.db" % (os.getcwd())
self.connection_string="postgres://*****:*****@localhost/davstorage"
self.dbhandler = DBHandler(self.connection_string)
widget = AuthWindow(self.dbhandler,self)
widget.setModal(True)
widget.exec_()
if self.dbhandler.getCurrentUser() == None:
self.close()
self.update_data()
def event(self, event):
if event == QtCore.QEvent.Close:
self.update_data()
return super(MainWindow, self).event(event)
def add_user(self):
widget = UserWindow(self.dbhandler,parent=self)
widget.show()
def delete_user(self):
user = self.dbhandler.session.query(User).filter_by(login=self.currentUser.__str__()).first()
user.is_deleted=True
self.dbhandler.session.add(user)
self.dbhandler.session.commit()
self.update_data()
def edit_user(self):
widget = UserWindow(self.dbhandler,self.currentUser,parent=self)
widget.show()
pass
def add_group(self):
widget = GroupWindow(self.dbhandler,None,pgroup =self.currentGroup,parent=self)
widget.show()
pass
def edit_group(self):
widget = GroupWindow(self.dbhandler,self.currentGroup,pgroup =self.currentGroup, parent=self)
widget.show()
pass
def delete_group(self):
user = self.dbhandler.session.query(Group).filter_by(name=self.currentGroup.__str__()).first()
user.is_deleted=True
self.dbhandler.session.add(user)
self.dbhandler.session.commit()
self.update_data()
def tab_changed(self, widget):
self.update_data()
pass
def restr_group(self):
widget = RestrictionsWindow(self.dbhandler,self.currentGroup,parent=self)
widget.show()
pass
def update_data(self):
users = self.dbhandler.getUsers()
self.lstUsers.clear()
for u in users:
self.lstUsers.addItem(QtGui.QListWidgetItem(u.login))
self.treeGroups.clear()
usr = self.dbhandler.getCurrentUser();
for group in self.dbhandler.getGroups():
rs = self.dbhandler.session.query(ActionRestrict).filter_by(actor_id=usr.id, actor_type=1, object_type=2, object_id = group.id).first()
if rs != None and rs.action & actions["ADMIN"] != 0 :
item=QtGui.QTreeWidgetItem([group.name])
item.addChildren(self.get_groupWidgetTree(group, usr))
#item = self.get_groupWidgetTree(group)
self.treeGroups.addTopLevelItem(item)
else:
subs = self.get_groupWidgetTree(group, usr)
for i in subs:
self.treeGroups.addTopLevelItem(i)
def get_groupWidgetTree(self, group, usr):
lst = []
for g in group.subgroups:
rs = self.dbhandler.session.query(ActionRestrict).filter_by(actor_id=usr.id, actor_type=1, object_type=2, object_id = g.id).first()
subs = self.get_groupWidgetTree(g, usr)
if rs != None and rs.action & actions["ADMIN"] != 0 :
gi = QtGui.QTreeWidgetItem([g.name])
gi.addChildren(subs)
gi.setData(0,32, rs.action)
lst.append(gi)
else:
for i in subs:
d = i.data(0,32)
if d.toUInt()[0] & actions["ADMIN"] != 0:
lst.append(i)
return lst
# def get_groupWidgetTree(self, group):
# lst = []
# for g in group.subgroups:
# gi = QtGui.QTreeWidgetItem([g.name])
# gi.addChildren(self.get_groupWidgetTree(g))
# lst.append(gi)
#
# return lst
def groupItemChanged(self, item):
if item == None:
self.currentGroup = None
else:
self.currentGroup = item.text(0)
pass
def userItemChanged(self, item):
self.currentUser = item.text()
pass
__author__ = 'fernando'
import matplotlib.pyplot as plt
from datetime import date, timedelta, datetime
from numpy import array
from DBHandler import DBHandler
class ChartGenerator:
def __init__(self, data):
self.data = array(data)
def generate(self):
print self.data[:,0]
x = array([datetime.strptime(d, "%Y-%m-%d %H:%M:%S") for d,s, t in self.data])
plt.plot(x, self.data[:,2])
plt.show()
if __name__ == "__main__":
db = DBHandler('/home/fernando/SONDAS_NAI/','/home/fernando/SONDAS_NAI/tempDatabase.db')
#db.loadData()
lines = db.findTempBySonda('SOND04', datetime(year=2013, month=10, day=1), datetime(year=2013, month=10, day=30))
chart = ChartGenerator(lines)
chart.generate()
