def report_customer_products_sold_total(invoices, products, customers,
dateStart, dateEnd):
# Will return 2 dictionaries:
# 1) a dictionary as list customers and the total number and value of products sold to them in the given date range in this format: Customer Code, Customer Name, Product Code, Product Name, Total Quantity Sold, Total Value Sold. Here (customer code, product code) will be unique.
# And 2) a second footer dictionary showing: t the end also show the sum of Total Quantity Sold, sum of Total Value Sold.
db = DBHelper()
data, columns = db.fetch(
'SELECT i.customer_code, c.customer_code as "Customer Code", c.name as "Customer Name" '
' , ili.product_code as "Product Code", p.name as "Product Name" '
' , SUM(ili.quantity) as "Total Quantity Sold", SUM(ili.extended_price) as "Total Value Sold" '
' FROM invoice i JOIN invoice_line_item ili ON i.invoice_no = ili.invoice_no '
' JOIN customer c ON i.customer_code = c.customer_code '
' JOIN product p ON ili.product_code = p.code '
' WHERE i.date between \'' + dateStart + '\' and \'' + dateEnd + '\' '
' GROUP BY i.customer_code, c.customer_code, c.name, i.invoice_no, ili.product_code, p.name '
)
result = row_as_dict(data, columns)
data, columns = db.fetch(
'SELECT 0 as "Footer", SUM(ili.quantity) as "Total Quantity Sold", SUM(ili.extended_price) as "Total Value Sold" '
' FROM invoice i JOIN invoice_line_item ili ON i.invoice_no = ili.invoice_no '
' JOIN customer c ON i.customer_code = c.customer_code '
' JOIN product p ON ili.product_code = p.code '
' WHERE i.date between \'' + dateStart + '\' and \'' + dateEnd + '\' '
' ')
result2 = row_as_dict(data, columns)
printDictInCSVFormat(
result, (None),
('Customer Code', 'Customer Name', 'Product Code', 'Product Name',
'Total Quantity Sold', 'Total Value Sold'))
printDictInCSVFormat(result2, (None),
('Total Quantity Sold', 'Total Value Sold'))
return result.values(), result2
def report_products_sold(invoices, products, dateStart, dateEnd):
# Will return 2 dictionaries:
# 1) a dictionary as list of in products sold in the given date range in tabular format of: Product Code, Product Name, Total Quantity Sold, Total Value Sold. Here, (product code) will be unique.
# And 2) a second dictionary of the footer will also be returned containing: t the end also show the sum of Total Value Sold.
db = DBHelper()
data, columns = db.fetch(
'SELECT p.code as "Code", ili.product_code as "Product Code", p.name as "Product Name" '
' , SUM(ili.quantity) as "Total Quantity Sold", SUM(ili.extended_price) as "Total Value Sold" '
' FROM invoice i JOIN invoice_line_item ili ON i.invoice_no = ili.invoice_no '
' JOIN product p ON ili.product_code = p.code '
' WHERE i.date between \'' + dateStart + '\' and \'' + dateEnd + '\' '
' GROUP BY p.code, ili.product_code, p.name ')
result = row_as_dict(data, columns)
data, columns = db.fetch(
'SELECT 0 as "Footer", SUM(ili.extended_price) as "Total Value Sold" '
' FROM invoice i JOIN invoice_line_item ili ON i.invoice_no = ili.invoice_no '
' JOIN product p ON ili.product_code = p.code '
' WHERE i.date between \'' + dateStart + '\' and \'' + dateEnd + '\' '
' ')
result2 = row_as_dict(data, columns)
printDictInCSVFormat(result, (None),
('Product Code', 'Product Name',
'Total Quantity Sold', 'Total Value Sold'))
printDictInCSVFormat(result2, (None), ('Total Value Sold', ))
return result, result2
def __init__(self, code, startDateTime, endDateTime):
self.code = code
self.startDateTime = startDateTime
self.endDateTime = endDateTime
self.dbHelper = DBHelper()
self.dataDim = config.getDataDim()
self.debugTrainData = config.debugForPrepareData
self.backWindow = config.backWindowLength
def get_province(req):
db = DBHelper('region')
data = db.where(pid='0').select()
print(db.sql)
print(data)
req.start_response("200 ok", [("ContentType", "application/json")])
return [json.dumps(data).encode('utf8')]
def report_list_all_paymentMedthod():
db = DBHelper()
data, columns = db.fetch('SELECT pm.code as "Code", pm.name as "Name" '
' FROM paymentmethod as pm')
result = row_as_dict(data, columns)
#print (result)
printDictInCSVFormat(result, ('Code', ), ('Name', ))
return result #send result for caller program to use
def get_max_id(game_name):
if not check_game_name(game_name):
abort(404)
dbHelper = DBHelper()
table_name = "tb_{}".format(game_name.lower())
id = dbHelper.select_max_id(table_name)
return jsonify({"code": 200, "maxid": str(id)})
def deleteuser(self):
delrol = ""
delrol = self.deleteinput.text()
try:
_deleteuser = DBHelper()
row = _deleteuser.deleteUserQuery(delrol)
except Exception:
print('')
def __init__(self, code, startDateTime, endDateTime):
self.code = code
self.startDateTime = startDateTime
self.endDateTime = endDateTime
self.dbHelper = DBHelper()
self.utils = Utils()
self.debug = config.debugForPrepareData
def check_if_court_occupied(court_no):
dbh = DBHelper()
court_usage1 = dbh.get_court_usage(court_no)
if court_usage1:
# print court_usage1
return court_usage1
else:
print("No Court ")
return
def purchaseTicket(self):
_cNumber = self._cNumber.text()
_cDate = self._cDate.text()
_cFullName = self._cFullName.text()
_cSecNumber = self._cSecNumber.text()
_p = DBHelper()
_p.InsertPurchaseCCQuery(self._uid, self._paymentType, self.totalCost,
self.totalTickets, _cNumber, _cDate,
_cFullName, _cSecNumber)
def parse_mails(min_mails=100):
db = DBHelper()
print("\n### RETRIEVING DATA FROM DATABASE ###")
db.execute("SET group_concat_max_len = 18446744073709547520")
results = db.execute("""
select x.from, x.to, m.txt
from
(select z.mailId id, GROUP_CONCAT(y.paragraph separator ' ') txt
from mail_paragraphs z
join sha_paragraphs y
on z.pid = y.id
where z.deleted = 0
group by z.mailId) m
join
(select a.mailId as id, a.from, a.to
from from_to_mail a
join (select aut.from f, aut.to t
from from_to_mail aut
where aut.from rlike "^[A-Za-z0-9.-][email protected]$"
and aut.to rlike "^[A-Za-z0-9.-][email protected]$"
and mailId in
(select mailId from mail_paragraphs where deleted = 0)
group by f, t
having count(*) > {0}) b
on a.from = b.f
and a.to = b.t) x
on m.id = x.id;
""".format(min_mails))
authors, recipients, emails, cnt, progress = [], [], [], 0, 0
print("\n### PARSING EMAILS ###")
filecount = db.rowcount
for row in results:
cnt += 1
emails.append(stem(row))
authors.append(row[0])
recipients.append(row[1])
tmp_progress = int(cnt * 100 / filecount)
if tmp_progress % 10 == 0 and progress != tmp_progress:
progress = tmp_progress
print("-- {} / {} emails parsed ({} %)".format(
cnt, filecount, progress))
le = preprocessing.LabelEncoder()
le.fit(authors + recipients)
enc_authors = le.transform(authors)
enc_recipients = le.transform(recipients)
print("-- {} emails from/to {} addresses parsed".format(
cnt, len(le.classes_)))
pickle.dump(emails, open("./data/word_data.pkl", "wb"))
pickle.dump(np.array(enc_authors), open("./data/authors.pkl", "wb"))
pickle.dump(np.array(enc_recipients), open("./data/recipients.pkl", "wb"))
pickle.dump(np.array(le.classes_), open("./data/classes.pkl", "wb"))
return emails, enc_authors, enc_recipients, le.classes_
def get_count():
dic = {}
dbHelper = DBHelper()
for t in games:
table_name = "tb_{}".format(t.lower())
count = dbHelper.select_count(table_name)
dic[t] = count
return jsonify({"code": 200, "count": dic})
def publish(announcement):
bot = telepot.Bot(TOKEN)
db1 = DBHelper()
keyboard = ReplyKeyboardMarkup(keyboard=[['Share my Thought'],
['Listen to a Thought']],
one_time_keyboard=True,
resize_keyboard=True)
alluser = db1.get_all_user()
for user in alluser:
bot.sendMessage(user[0], announcement, reply_markup=keyboard)
def is_admin(id):
db = DBHelper()
cnx = db.getConn()
if cnx is None:
print 'connection is null'
else:
if db.checkIfAdmin(id, cnx) == 1:
return True
else:
return False
def Login(self):
_login = DBHelper()
res = _login.LoginQuery(self.username_LE.text(), self.password_LE.text())
if(len(res) > 0):
if (self.username_LE.text() == str(res[0][1]) and
self.password_LE.text() == str(res[0][2])):
QMessageBox.information(QMessageBox(),'Successful','Login Successful')
self.accept()
else:
QMessageBox.warning(QMessageBox(), 'Error', 'Bad user or password')
def parse_mails(min_mails = 100):
db = DBHelper()
print("\n### RETRIEVING DATA FROM DATABASE ###")
db.execute("SET group_concat_max_len = 18446744073709547520")
results = db.execute("""
select x.from, x.to, m.txt
from
(select z.mailId id, GROUP_CONCAT(y.paragraph separator ' ') txt
from mail_paragraphs z
join sha_paragraphs y
on z.pid = y.id
where z.deleted = 0
group by z.mailId) m
join
(select a.mailId as id, a.from, a.to
from from_to_mail a
join (select aut.from f, aut.to t
from from_to_mail aut
where aut.from rlike "^[A-Za-z0-9.-][email protected]$"
and aut.to rlike "^[A-Za-z0-9.-][email protected]$"
and mailId in
(select mailId from mail_paragraphs where deleted = 0)
group by f, t
having count(*) > {0}) b
on a.from = b.f
and a.to = b.t) x
on m.id = x.id;
""".format(min_mails))
authors, recipients, emails, cnt, progress = [], [], [], 0, 0
print("\n### PARSING EMAILS ###")
filecount = db.rowcount
for row in results:
cnt += 1
emails.append(stem(row))
authors.append(row[0])
recipients.append(row[1])
tmp_progress = int(cnt*100 / filecount)
if tmp_progress % 10 == 0 and progress != tmp_progress:
progress = tmp_progress
print("-- {} / {} emails parsed ({} %)".format(cnt, filecount, progress))
le = preprocessing.LabelEncoder()
le.fit(authors+recipients)
enc_authors = le.transform(authors)
enc_recipients = le.transform(recipients)
print("-- {} emails from/to {} addresses parsed".format(cnt, len(le.classes_)))
pickle.dump(emails, open("./data/word_data.pkl", "wb"))
pickle.dump(np.array(enc_authors), open("./data/authors.pkl", "wb"))
pickle.dump(np.array(enc_recipients), open("./data/recipients.pkl", "wb"))
pickle.dump(np.array(le.classes_), open("./data/classes.pkl", "wb"))
return emails, enc_authors, enc_recipients, le.classes_
def get_user_data(id):
db = DBHelper()
cnx = db.getConn()
condExpr = ' UserID = ' + str(id)
cursor = db.fetchFromWhere('UserInfo', condExpr, cnx)
if cursor.rowcount > 0:
userInfo = cursor.fetchone()
print 'userInfo-->', userInfo
return userInfo
else:
return None
def addUser(self):
first_name = ""
last_name = ""
Joined = ""
first_name = self.first_name.text()
last_name = self.last_name.text()
Joined = self.Joined.text()
try:
_userSearch = DBHelper()
row = _userSearch.addUserQuery(first_name, last_name, Joined)
except Exception:
print('')
def student_detail(req, sno):
# sno = req.GET.get('sno')
print(sno)
db = DBHelper('student')
student = db.where(sno=sno).select()
if student:
student = student[0]
return render(req, 'studentdetail.html', {
'title': student['sname'],
'data': student
})
else:
return render(req, '404.html')
def handleEditRow(self):
button = QtWidgets.qApp.focusWidget()
index = self.tableWidget.indexAt(button.pos())
if index.isValid():
item = self.tableWidget.item(index.row(), 0)
item1 = self.tableWidget.item(index.row(), 4)
item2 = self.tableWidget.item(index.row(), 5)
self.item_text = item.text()
self.item_text1 = item1.text()
self.item_text2 = item2.text()
print(self.item_text, self.item_text1, self.item_text2)
updateRecord = DBHelper()
updateRecord.updatePaymentQuery(self.item_text, self.item_text1,
self.item_text2)
def fopt(idchat):
dbh = DBHelper()
result = dbh.select_idchat('data', idchat)
ini = len(result)
i = 1
while i < len(result):
if result[i - 1][3] == result[i][2]:
result[i - 1][3] == result[i][3]
dbh.delete_id('data', result[i][0])
result.pop(i)
else:
i = i + 1
out = len(result)
return 'Ottimizzato: ' + str(ini) + ' -> ' + str(out)
def do_login(environ, start_response):
# 获取请求方法类型
method = environ.get('REQUEST_METHOD', 'GET')
if method == 'GET':
paremeters = environ.get('QUERY_STRING')
paremeters = parse_qs(paremeters)
print(paremeters)
paremeters = {
key: value[0] if len(value) == 1 else value
for key, value in paremeters.items()
}
print(paremeters)
username = paremeters.get('username')
password = paremeters.get('password')
sex = paremeters.get('sex')
print(username, password)
# 业务逻辑处理
password = hashlib.sha1(password.encode('utf8')).hexdigest()
print(password)
db = DBHelper('user')
res = db.where(username=username, password=password).select()
print(db.sql)
print(res)
start_response("200 ok", [('ContentType', 'text/html')])
# if res:
# # 通过验证
# return [b"<html><head><meta http-equiv='refresh' content='0;url=/'></head><body></body></html>"]
# else:
#跳转登录页面
# return [b"<html><head><meta http-equiv='refresh' content='0;url=/login'></head><body></body></html>"]
# return [b"<meta http-equiv='refresh' content='0;url=/login'>"]
return [b'dologin']
else: #post
# 参数长度
contentLength = int(environ.get('CONTENT_LENGTH', 0))
fp = environ.get('wsgi.input')
paremeters = fp.read(contentLength).decode('utf8')
paremeters = parse_qs(paremeters)
paremeters = {
key: value[0] if len(value) == 1 else value
for key, value in paremeters.items()
}
username = paremeters.get('username')
password = paremeters.get('password')
sex = paremeters.get('sex')
print(paremeters)
print(username, password, sex)
# 业务逻辑处理
start_response("200 ok", [('ContentType', 'text/html')])
return [b'world']
def loaddata(self):
_userpaymentGrid = DBHelper()
result = _userpaymentGrid.userPaymentQuery()
self.tableWidget.setRowCount(0)
for row_number, row_data in enumerate(result):
self.tableWidget.insertRow(row_number)
for column_number, data in enumerate(row_data):
self.tableWidget.setItem(row_number, column_number,
QTableWidgetItem(str(data)))
self.btn_edit = QPushButton('Edit')
self.btn_edit.clicked.connect(self.handleEditRow)
self.tableWidget.setCellWidget(row_number, 10, self.btn_edit)
self.tableWidget.item(row_number,
0).setFlags(QtCore.Qt.ItemIsEnabled)
def normalize_artists(path, db_name, table_name):
DBHelper.make_table(db_name,table_name)
artists = SourceParser.retrieve_artists(path)
norm_artists = {}
for artist in artists:
lyrics = DBHelper.get_lyrics(db_name, table_name, artist)
if lyrics:
norm_artists[artist] = lyrics
else:
norm_artists[artist] = SourceParser.normalize_data(path + artist + ".txt")
DBHelper.update_lyrics(db_name,table_name, artist, norm_artists[artist])
return norm_artists
def check_username(req):
if req.method == 'GET':
username = req.GET.get('username')
else:
username = req.POST.get('username')
# 查询数据库
db = DBHelper('user')
res = db.where(username=username).select()
if res:
data = {'code': 1, 'msg': '用户名不可用'}
else:
data = {'code': 0, 'msg': '用户名可用'}
req.start_response("200 ok", [("ContentType", "application/json")])
print(res)
return [json.dumps(data).encode('utf8')]
def authorize_user_id(id):
db = DBHelper()
cnx = db.getConn()
if cnx is None:
return None
else:
cnx.set_converter_class(NumpyMySQLConverter)
condExpr = 'UserID = ' + str(id)
cursor = db.fetchFromWhere("UserInfo", condExpr, cnx)
print 'row count->', cursor.rowcount
if cursor.rowcount > 0:
return True
else:
return False
def generate_reverse_index():
"""
生成反向索引(前提是已经生成好了正向索引),索引内容:
key_word_id content
关键词ID [[内容包含关键词的答案1的ID,关键词权重],........]
:return:
"""
db_helper = DBHelper.get_instance()
# db_helper.clear_reverse_indexes()
i = 1494000
r = db_helper.get_forward_indexes(1494000)
for f_index in r:
a_id = f_index['answer_id']
content_info = f_index['content_info']
i += 1
if i % 1000 == 0:
print(i)
print(time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time())))
if content_info:
for content in content_info:
db_helper.add_reverse_index_content(content[0], a_id, content[1])
r.close()
def generateKey(self):
"""Génère le bi-clé dans la ressource P11. (Voir setKeyOptions)"""
self.cryptoID = DBHelper.getInstance().newCryptoID()
sensitiveKeys = self.x509Req.isCA()
p11Helper = None
if self.generateKeyOnSmartCard:
p11Helper = anssipki.P11Helper.connect(
Conf.getValue("PKCS11_SMARTCARD_MODULE"),
Conf.getValue("PKCS11_SMARTCARD_PIN"),
Conf.getValue("PKCS11_SMARTCARD_LABEL"),
Conf.getValue("PKCS11_SMARTCARD_SLOT") != None,
Conf.getValue("PKCS11_SMARTCARD_SLOT"))
self.smartCardP11Helper = p11Helper
if not p11Helper:
raise Exception('Error loading PKCS#11 ressource.')
# Flag specific à SWIG. Une fois mis à true, l'objet C++ réferencé
# est détruit lorsque ce dernier est récupéré par le GC.
self.smartCardP11Helper.thisown = True
else:
p11Helper = anssipki.P11Helper.getInstance()
if self.keyType == anssipki.KPA_RSA:
usage = anssipki.USAGE_SIGNATURE
self.hPublicKey, self.hPrivateKey = p11Helper.generateRSAKeyPair(
self.keyLength, self.cryptoID, sensitiveKeys, self.label,
usage)
else:
raise Exception('KeyType not implemented')
self.x509Req.setPublicKey(p11Helper.extractPublicKey(self.hPublicKey))
def generate_forward_index():
"""
生成问题正向索引,并存入数据库
索引内容:
question_id content_info
问题ID 内容关键词ID.....
:return:
"""
db_helper = DBHelper.get_instance()
# # 清空正向索引
# db_helper.clear_forward_indexes()
# db_helper.clear_key_word()
r = db_helper.get_all_answers(db_helper.get_forward_index_count())
# 重新生成索引
i = db_helper.get_forward_index_count()
for answer in r:
res = handler_each_answer(answer)
db_helper.add_forward_indexes(res[0], res[1])
i += 1
if i % 1000 == 0:
print(i)
print(time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time())))
r.close()
def index(req):
articles = DBHelper('article').select()
for article in articles:
article['publishtime'] = datetime.strftime(article['publishtime'],
'%Y-%m-%d')
print(articles)
return render(req, 'blog.html', {'articles': articles})
class OriginalDataSaver:
def __init__(self, csvFileName):
self.csvFileName = csvFileName
self.dbHelper = DBHelper()
self.code = self.csvFileName.replace('.CSV', '')
def taobaoShop(self, array):
# for taobao数据商家
createTime = array[0].strip() + ' ' + array[1].strip()
createTime_object = datetime.strptime(createTime, '%Y/%m/%d %H:%M')
k = KLine(None, ktype5F, self.code, createTime_object,
float(array[2].strip()), float(array[5].strip()),
float(array[3].strip()), float(array[4].strip()),
int(array[6].strip()), int(array[7].strip()))
return k
def tongxinda(self, array):
# for 通信达
createTime = array[0].strip() + ' ' + array[1].strip()
createTime_object = datetime.strptime(createTime, '%Y/%m/%d %H%M')
k = KLine(None, ktype5F, '600846', createTime_object,
float(array[2].strip()), float(array[5].strip()),
float(array[3].strip()), float(array[4].strip()),
int(array[6].strip()), int(array[7].strip()))
return k
def buildKLine(self, array):
if len(array) > 7:
return self.taobaoShop(array)
def processFile(self):
print('OriginalDataSaver start...')
with open(os.path.join(dir, self.csvFileName), 'r') as f:
i = 0
for line in f:
array = line.split(',')
k = self.buildKLine(array)
self.dbHelper.saveKLine(k)
i += 1
if i % 1000 == 0:
print('OriginalDataSaver.processFile ' + self.code +
' progress line num ' + str(i))
print('OriginalDataSaver end')
def searchuser(self):
searchrol = ""
searchrol = self.searchinput.text()
try:
_userSearch = DBHelper()
row = _userSearch.userSearchQuery(searchrol)
if (len(row) > 0):
serachresult = "User ID : " + str(
row[0]) + '\n' + "User Name : " + str(
row[1]) + '\n' + "Joined Date : " + str(row[2])
QMessageBox.information(QMessageBox(), 'Successful',
serachresult)
else:
QMessageBox.warning(QMessageBox(), 'Error',
'Could not Find Record in Table.')
except Exception:
QMessageBox.warning(QMessageBox(), 'Error',
'Could not Find Record in Table.')
def _postInit(self, command):
OLD_PLUGIN_PATH = path.abspath(translatePath(path.join(path.dirname(self.__profile__), "..", "plugin.games.xbmame")))
ADDON_PATH = translatePath(self.__profile__)
if path.exists(OLD_PLUGIN_PATH):
try :
print self.__profile__
if path.exists(ADDON_PATH):rmtree(ADDON_PATH)
move(OLD_PLUGIN_PATH, ADDON_PATH)
except Exception:
pass
self.MEDIA_PATH = path.join(self.__settings__.getAddonInfo("path"), "resources", "skins", "Default", "media")
self._MAME_CONFIG_PATH = translatePath(path.join(self.__profile__, "cfg"))
self._MAME_NVRAM_PATH = translatePath(path.join(self.__profile__, "nvram"))
if not path.exists(self._MAME_CONFIG_PATH): makedirs(self._MAME_CONFIG_PATH)
self._MAME_CACHE_PATH = translatePath(path.join(self.__profile__, "titles"))
if not path.exists(self._MAME_CACHE_PATH): makedirs(self._MAME_CACHE_PATH)
SETTINGS_PLUGIN_ID = "%s.settings" % self.__settings__.getAddonInfo("id")
SETTINGS_PLUGIN_PATH = path.join(path.dirname(self.__settings__.getAddonInfo("path")), SETTINGS_PLUGIN_ID)
try:
Addon(SETTINGS_PLUGIN_ID)
self.SETTINGS_PLUGIN_ID=SETTINGS_PLUGIN_ID
except Exception:
if not path.exists(path.join(SETTINGS_PLUGIN_PATH, "resources")): makedirs(path.join(SETTINGS_PLUGIN_PATH, "resources"))
plugin = open(path.join(SETTINGS_PLUGIN_PATH, "addon.xml"), "w")
plugin.write("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?><addon id=\"%s\" name=\"DIP Switches\"><extension point=\"xbmc.python.library\" library=\"default.py\" /> <extension point=\"xbmc.addon.metadata\"><platform>all</platform><summary></summary><description></description></extension></addon>" % SETTINGS_PLUGIN_ID)
plugin.close()
dialog.ok(self.__language__(30000), self.__language__(30704), self.__language__(30705))
executebuiltin("RestartApp")
self._FILTERS = ""
if not path.exists(self.__profile__): makedirs(self.__profile__)
self._MAME_DATABASE_PATH = translatePath(path.join(self.__settings__.getAddonInfo("profile"), "XBMame.db"))
self._db = DBHelper(self._MAME_DATABASE_PATH)
self.getSettings()
while self._MAME_EXE_PATH=="":
self.__settings__.openSettings()
self.getSettings()
if command[0]=="exec": self.execute(command[1:])
else:
if self._db.isEmpty():MameImport(self)
dbver = self._db.getSetting("database-version")
if dbver=="":dbver="1.0"
if dbver!=DB_VERSION:
dialog.ok(self.__language__(30600), self.__language__(30620), self.__language__(30621) % (dbver, DB_VERSION), self.__language__(30622))
MameImport(self)
class WeiboDB:
def __init__(self):
self.db = DBHelper(GV.server, GV.user, GV.pwd, GV.database);
# 将微博与词条进行关联操作.执行失败返回 False, 否则返回 True
def combine_klg(self, uid, weibomsg):
if(weibomsg['run'] != ''):
text = weibomsg['mc'] + "//@" + weibomsg['run'] + weibomsg['rmc'];
else:
text = weibomsg['mc'];
klg_list = utility.match_klg(text);
if( len(klg_list) > 0 ): # 存在某个词条
try:
insert_batch = [];
update_mt = '';
for klg in klg_list:
insert_batch.append( [weibomsg['mid'], klg] );
update_mt += str(klg) + ',';
update_mt = update_mt.rstrip(',');
self.db.insert("INSERT IGNORE INTO weibomsg (mid,uid,un,sn,iu,mc,murl,srn,iurl,rc,cc,pt,nc) VALUES (%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s)",
[weibomsg['mid'], uid, weibomsg['un'], weibomsg['un'], weibomsg['iu'], text, weibomsg['page'],
weibomsg['srn'], weibomsg['pu'], weibomsg['rc'], weibomsg['cc'], weibomsg['pt'], weibomsg['nc']]);
self.db.insert_many("INSERT IGNORE INTO abbre_weibomsg (mid,abrid) VALUES(%s, %s)", insert_batch);
self.db.update("UPDATE `abbreviation` SET mt=%s WHERE abrid IN (" + update_mt + ")", [utility.now()]);
except Exception,e:
logging.exception("%s 绑定数据库失败: " + str(e), weibomsg['mid']);
def main():
arg_helper = CmdArgumentsHelper();
arg_helper.add_argument('query', 'q', 'query', 1);
arg_helper.add_argument('root_dir', 'r', 'root', 1);
arg_helper.add_argument('top_tag_num', 't', 'top_tag_num', 1);
args = arg_helper.read_arguments();
print (args);
root = args['root_dir'];
top_tag_num = int(args['top_tag_num']);
query = args['query'];
from PhotoDao import PhotoDao;
from DBHelper import DBHelper;
db_helper = DBHelper();
db_helper.init(root);
photo_dao = PhotoDao(db_helper);
print('get photo ids.');
tic();
photo_ids = photo_dao.getClassPhotoIds(query, ''.join([query]));
toc();
print('get photos ...');
tic();
photos = photo_dao.getPhotos(query, photo_ids);
toc();
print('gen top tags via user...');
from task_gen_top_tags import task_gen_top_tag_via_user;
tic();
top_word = task_gen_top_tag_via_user(photos, query, top_tag_num, root);
toc();
print('build tag features...');
from task_gen_top_tags import task_build_tag_features;
tic();
task_build_tag_features(top_word, query, photos, 0, root);
toc();
def getPhotosMultiThread(root, query, photo_ids):
from PhotoDao import PhotoDao;
from DBHelper import DBHelper;
db_helper = DBHelper();
db_helper.init(root);
photo_dao = PhotoDao(db_helper);
infos = [];
for photo_id in photo_ids:
info = {};
info['photo_dao'] = photo_dao;
info['photo_id'] = photo_id;
info['query'] = query;
infos.append(info);
print('done generaing infos for photo');
import time;
start=time.time()
from multiprocessing import Pool
pool = Pool(processes=30) # start 4 worker processes
photos = pool.map(getPhoto, infos) # prints "[0, 1, 4,..., 81]"
print "process_files_parallel()", time.time()-start
return photos;
def __init__(self): self.db = DBHelper(GV.server, GV.user, GV.pwd, GV.database);
import time;
start=time.time()
from multiprocessing import Pool
pool = Pool(processes=30) # start worker processes
photos_keep = pool.map(filter_photo_with_top_tags, photos)
print("process_files_parallel()", time.time()-start);
photos = [];
for photo_info in photos_keep:
if(photo_info['keep']):
photos.append(photo_info['photo']);
return photos;
if __name__ == '__main__':
from PhotoDao import PhotoDao;
from DBHelper import DBHelper;
db_helper = DBHelper();
root = '/nas02/home/h/o/hongtao/Iconic';
db_helper.init(root);
query = 'love';
photo_dao = PhotoDao(db_helper);
photo_ids = photo_dao.getClassPhotoIds(query, ''.join([query]));
# photo_ids = photo_ids[0:100];
# photos = photo_dao.getPhotos(query, photo_ids);
photos = getPhotosMultiThread(root, query, photo_ids);
print('obtain ' + str(len(photos)) + ' photos.');
top_tagfile = '/nas02/home/h/o/hongtao/magiconic/FlickrDownloader/tmp_dir/data/tags/%s.txt' % query;
fin = open(top_tagfile, 'r');
for tag in fin:
env_lang = config.get_language()
print ' current language setting = ' + env_lang
set_proto_lang(env_lang)
set_msg_lang(env_lang)
# Get network IP addr
if CCTV_URL == '':
CCTV_URL = 'http://'
tempstr = subprocess.check_output('dig +short myip.opendns.com @resolver1.opendns.com', shell=True)
tempstr.replace('\r', '')
tempstr.replace('\n', '')
CCTV_URL += tempstr.strip()
CCTV_URL += ':' + CCTV_PORT
print 'Found external IP = ' + CCTV_URL
# Initialize DB
dbhelper = DBHelper(MYSQL_USER, MYSQL_PASS, MYSQL_DB)
dbhelper.connect()
dbhelper.checktables()
# Connect serial
t_ser = SerialThread(recv_queue, send_queue, incoming_cmd_callback)
t_ser.connect()
# Make worker thread
t_dev = DeviceManagerThread(dbhelper, recv_queue, send_queue, device_thread_callback)
# Start main loop
if __name__ == '__main__':
try:
# Start worker thread
t_dev.load_devices()
t_dev.load_noti()
t_dev.load_macro()
#!/usr/bin/env python3
from DBHelper import DBHelper
import numpy as np
import time
from datetime import timedelta, datetime
db = DBHelper()
print("Fetching codes")
results = db.execute("""
SELECT mailId, pid
from mail_paragraphs
where deleted = 0
order by mailid, sortorder
""")
ms = {} #all paragraphs per mail
ps = {} #all mails per paragraph
mailParas = {} #the string representation of all paragrpahs per mail
for res in results:
if res[0] not in ms:
ms[res[0]] = []
if res[0] not in mailParas:
mailParas[res[0]] = ""
if res[1] not in ps:
ps[res[1]] = set()
ms[res[0]].append(res[1])
ps[res[1]].add(res[0])
#!/usr/bin/env python3
from string import punctuation
from hashlib import sha256
from mail_functions import *
from DBHelper import DBHelper
def mapToSQL(map, tablename):
imp = map.copy()
imp.pop('', None)
imp.pop('body', None)
imp.pop('SHABody', None)
vals = [str(v).replace("'", "") for v in imp.values()]
return "insert into " + tablename + '(`' + '`, `'.join(imp.keys()) + "`) values ('" + "', '".join(vals) + "'); "
db = DBHelper()
columnNames = [cols[0] for cols in db.execute("select lower(column_name) from information_schema.columns where table_name = 'mails'")]
print("Following columns are already present: \n {}".format(columnNames))
sha_vals = {line[0]: line[1] for line in db.execute("select sha, id from sha_paragraphs")}
print(str(len(sha_vals)) + ' sha values already in database')
parsedFiles = {c[0].strip(): 1 for c in db.execute("select filepath from mails")}
count = 0
sumparagraphs = 0
sumdistinctparagraphs = len(sha_vals)
print(str(len(parsedFiles)) + " already parsed files")
for file in getListOfFiles('../../maildir'):
`x-bcc` longtext, `filepath` longtext, `to` longtext, `x-origin` longtext, `x-filename` longtext, `x-from` longtext, `date` longtext, `x-to` longtext, `message-id` longtext, `content-type` longtext, `mime-version` longtext, `cc` longtext, `bcc` longtext, `attendees` longtext, `re` longtext, `time` longtext, `conference room` longtext, PRIMARY KEY (`id`) ) ENGINE=InnoDB DEFAULT CHARSET=latin1; DROP TABLE IF EXISTS `sha_paragraphs`; CREATE TABLE `sha_paragraphs` ( `sha` varchar(200) NOT NULL, `paragraph` longtext, id int, PRIMARY KEY (`sha`) ) ENGINE=InnoDB DEFAULT CHARSET=latin1; """ db = DBHelper() db.execute(sql, True)
def __init__(self, databaseName, sizesFilename, peopleFilename, sizeCatalogFile): self.dbHelper = DBHelper(databaseName, sizesFilename, peopleFilename, sizeCatalogFile) #self.doClotheCategoryTest() self.doMatchClotheTest()
class Tester():
#constructor
def __init__(self, databaseName, sizesFilename, peopleFilename, sizeCatalogFile):
self.dbHelper = DBHelper(databaseName, sizesFilename, peopleFilename, sizeCatalogFile)
#self.doClotheCategoryTest()
self.doMatchClotheTest()
# (!!!) (fix this)
# does the "clothe category" test
def doClotheCategoryTest(self):
peoples = self.dbHelper.people.peopleDataLines
clotheCategories = self.dbHelper.sizes.getClotheCategories()
catSizeTypes = self.dbHelper.sizes.getSizeTypes()
# create the people size map
peopleSizeMap = {}
sizeTypesList = self.dbHelper.sizes.getSizeTypesList()
for i in range(len(sizeTypesList)):
peopleSizeMap[sizeTypesList[i]] = i+1
# test start time
start_time = time.time()
for people in peoples:
parts = people.split('\t')
for clotheCategory in clotheCategories:
personSizes = {}
sizesList = []
sizes = catSizeTypes[clotheCategory]
for size in sizes:
personSizes[size.upper()] = parts[peopleSizeMap[size]]
sizesList.append(size.upper())
query = self.dbHelper.getClotheCategoryQuery(clotheCategory, sizesList, personSizes)
self.dbHelper.queryDB(query)
# elapsed time
elapsed_time = time.time() - start_time
print 'clothe category test lasted: ' + str(elapsed_time)
# does the "match clothe" test
def doMatchClotheTest(self):
peoples = self.dbHelper.people.peopleDataLines
# create the people size map
peopleSizeMap = {}
sizeTypesList = self.dbHelper.sizes.getSizeTypesList()
for i in range(len(sizeTypesList)):
peopleSizeMap[sizeTypesList[i]] = i+1
# test start time
start_time = time.time()
for people in peoples:
parts = people.split('\t')
personSizes = {}
for sizeType in sizeTypesList:
personSizes[sizeType.upper()] = parts[peopleSizeMap[sizeType]]
query = self.dbHelper.getMatchClotheQuery(sizeTypesList, personSizes)
self.dbHelper.queryDB(query)
# elapsed time
elapsed_time = time.time() - start_time
print 'match clothe test lasted: ' + str(elapsed_time)
class XBMame:
def __init__(self, ADDON_ID, arg):
self.__settings__ = Addon(ADDON_ID)
self.__language__ = Addon(ADDON_ID).getLocalizedString
self.__profile__ = translatePath(Addon(ADDON_ID).getAddonInfo("profile"))
command = arg.split(":")
if len(command)==1:Path="/"
else: Path = "/%s" % command[1]
XBMameGUI("XBMame.xml", self.__settings__.getAddonInfo("path"), "default", "720p", Plugin=self, Path=Path, command=command)
def _postInit(self, command):
OLD_PLUGIN_PATH = path.abspath(translatePath(path.join(path.dirname(self.__profile__), "..", "plugin.games.xbmame")))
ADDON_PATH = translatePath(self.__profile__)
if path.exists(OLD_PLUGIN_PATH):
try :
print self.__profile__
if path.exists(ADDON_PATH):rmtree(ADDON_PATH)
move(OLD_PLUGIN_PATH, ADDON_PATH)
except Exception:
pass
self.MEDIA_PATH = path.join(self.__settings__.getAddonInfo("path"), "resources", "skins", "Default", "media")
self._MAME_CONFIG_PATH = translatePath(path.join(self.__profile__, "cfg"))
self._MAME_NVRAM_PATH = translatePath(path.join(self.__profile__, "nvram"))
if not path.exists(self._MAME_CONFIG_PATH): makedirs(self._MAME_CONFIG_PATH)
self._MAME_CACHE_PATH = translatePath(path.join(self.__profile__, "titles"))
if not path.exists(self._MAME_CACHE_PATH): makedirs(self._MAME_CACHE_PATH)
SETTINGS_PLUGIN_ID = "%s.settings" % self.__settings__.getAddonInfo("id")
SETTINGS_PLUGIN_PATH = path.join(path.dirname(self.__settings__.getAddonInfo("path")), SETTINGS_PLUGIN_ID)
try:
Addon(SETTINGS_PLUGIN_ID)
self.SETTINGS_PLUGIN_ID=SETTINGS_PLUGIN_ID
except Exception:
if not path.exists(path.join(SETTINGS_PLUGIN_PATH, "resources")): makedirs(path.join(SETTINGS_PLUGIN_PATH, "resources"))
plugin = open(path.join(SETTINGS_PLUGIN_PATH, "addon.xml"), "w")
plugin.write("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?><addon id=\"%s\" name=\"DIP Switches\"><extension point=\"xbmc.python.library\" library=\"default.py\" /> <extension point=\"xbmc.addon.metadata\"><platform>all</platform><summary></summary><description></description></extension></addon>" % SETTINGS_PLUGIN_ID)
plugin.close()
dialog.ok(self.__language__(30000), self.__language__(30704), self.__language__(30705))
executebuiltin("RestartApp")
self._FILTERS = ""
if not path.exists(self.__profile__): makedirs(self.__profile__)
self._MAME_DATABASE_PATH = translatePath(path.join(self.__settings__.getAddonInfo("profile"), "XBMame.db"))
self._db = DBHelper(self._MAME_DATABASE_PATH)
self.getSettings()
while self._MAME_EXE_PATH=="":
self.__settings__.openSettings()
self.getSettings()
if command[0]=="exec": self.execute(command[1:])
else:
if self._db.isEmpty():MameImport(self)
dbver = self._db.getSetting("database-version")
if dbver=="":dbver="1.0"
if dbver!=DB_VERSION:
dialog.ok(self.__language__(30600), self.__language__(30620), self.__language__(30621) % (dbver, DB_VERSION), self.__language__(30622))
MameImport(self)
def getSettings(self):
self._MAME_PARAMS = {}
self._FILTERS = ""
# Fetching settings
# General settings
self._MAME_EXE_PATH = self.__settings__.getSetting("mame_exe_path").replace("\\", "/")
self._MAME_ROM_PATH = self.__settings__.getSetting("mame_rom_path").replace("\\", "/")
self._MAME_SAMPLES_PATH = self.__settings__.getSetting("mame_samples_path").replace("\\", "/")
self._USE_MAMEINFO = self.__settings__.getSetting("mame_mameinfo")=="true"
self._USE_HISTORY = self.__settings__.getSetting("mame_history")=="true"
# Thumbnails settings
self._MAME_TITLES_PATH = self.__settings__.getSetting("mame_titles_path").replace("\\", "/")
self._CACHE_TITLES = self.__settings__.getSetting("cache_titles")=="true"
self._ONLINE_TITLES = self.__settings__.getSetting("online_titles")=="true"
self._HIRES_TITLES = self.__settings__.getSetting("hires_titles")=="true"
self._ROMSET_TITLES = self.__settings__.getSetting("romset_titles")=="true"
# ROM filters
if self.__settings__.getSetting("hide_clones")=="true":self._FILTERS +=" AND cloneof=''"
if self.__settings__.getSetting("hide_nothave")=="true":self._FILTERS += " AND have"
if self.__settings__.getSetting("hide_notworking")=="true":self._FILTERS += " AND isworking"
if self.__settings__.getSetting("hide_impemul")=="true":self._FILTERS += " AND emul"
if self.__settings__.getSetting("hide_impcolor")=="true":self._FILTERS += " AND color"
if self.__settings__.getSetting("hide_graphics")=="true":self._FILTERS += " AND graphic"
if self.__settings__.getSetting("hide_impsound")=="true":self._FILTERS += " AND sound"
# Emulator settings
# Video related
if self.__settings__.getSetting("mame_video")=="Direct3D":
self._MAME_PARAMS["-video"] = "d3d"
self._MAME_PARAMS["-d3dversion"] = self.__settings__.getSetting("mame_d3dversion")
if self.__settings__.getSetting("mame_video")=="DirectDraw":self._MAME_PARAMS["-video"] = "ddraw"
if self.__settings__.getSetting("mame_video")=="GDI":self._MAME_PARAMS["-video"] = "gdi"
if self.__settings__.getSetting("mame_switchres")=="true": self._MAME_PARAMS["-switchres"] = ""
if self.__settings__.getSetting("mame_filter")=="true": self._MAME_PARAMS["-filter"] = ""
if self.__settings__.getSetting("mame_scanlines")=="true": self._MAME_PARAMS["-effect"] = "scanlines.png"
# Other settings
if self.__settings__.getSetting("mame_multithread")=="true": self._MAME_PARAMS["-multithreading"] = ""
if self.__settings__.getSetting("mame_cheat")=="true": self._MAME_PARAMS["-waitvsync"] = ""
if self.__settings__.getSetting("mame_gameinfo")=="false": self._MAME_PARAMS["-skip_gameinfo"] = ""
if self._USE_MAMEINFO:
self._mameinfo_dat = InfoFile(self._db, path.dirname(self._MAME_EXE_PATH))
else:
self._mameinfo_dat = InfoFile(self._db)
if self._USE_HISTORY:
self._history_dat = HistoryFile(self._db, path.dirname(self._MAME_EXE_PATH))
else:
self._history_dat = HistoryFile(self._db)
self.TITLES_PATH = ""
if self._MAME_TITLES_PATH:
if self._MAME_CACHE_PATH:
self.TITLES_PATH = self._MAME_CACHE_PATH
else:
self.TITLES_PATH = self._MAME_TITLES_PATH
elif self._MAME_CACHE_PATH:
self.TITLES_PATH = self._MAME_CACHE_PATH
try:
self.GUI.populateList(self.browse(self.GUI.path))
except AttributeError:
pass
def execute(self, args):
print args
if args[0]=="builddb":MameImport(self)
elif args[0]=="config":
if len(args)==1:
self.__settings__.openSettings()
else:
self._gameSettings(args[1])
self.getSettings()
elif args[0]=="buildthumb":
self._thumbNails()
try:
self.GUI.populateList(self.browse(self.GUI.path))
except AttributeError:
pass
elif args[0]=="havemiss":
self._haveList()
try:
self.GUI.populateList(self.browse(self.GUI.path))
except AttributeError:
pass
elif args[0]=="addfav":
self._db.execute("INSERT INTO Favorites VALUES (null,?);", (args[1],))
self._db.commit()
elif args[0]=="delfav":
self._db.execute("DELETE FROM Favorites WHERE gamename=?;", (args[1],))
self._db.commit()
self.GUI.populateList(self.browse(self.GUI.path))
elif args[0]=="game":
self._runGame(args[1])
elif args[0]=="info":
game = GameItem(self._db, id=args[1])
InfoDialog("InfoDialog.xml", self.__settings__.getAddonInfo("path"), "Default", "720p", game=game, Plugin=self)
elif args[0]=="search":
if len(args)>1:
lock()
self.GUI.populateList(self._gameCollection("", search=args[1]))
unlock()
else:
kbd = Keyboard(heading=self.__language__(30106))
kbd.doModal()
if kbd.isConfirmed():
if len(kbd.getText()): self.execute(["search", kbd.getText()])
elif args[0]=="related":
lock()
self.GUI.populateList(self._gameCollection("", related=args[1]))
unlock()
def browse(self, Path):
Path = Path[1:].split("/")
lock()
items = []
if Path[0]=="":
items.append(self._item(self.__language__(30100), ICON_YEAR, "browse:/year"))
items.append(self._item(self.__language__(30101), ICON_BIOS, "browse:/bios"))
items.append(self._item(self.__language__(30102), ICON_MANUFACTURER, "browse:/manu"))
items.append(self._item(self.__language__(30103), ICON_NAME, "browse:/name"))
items.append(self._item(self.__language__(30104), ICON_HDD, "browse:/hdd"))
items.append(self._item(self.__language__(30105), ICON_ALL, "browse:/all"))
items.append(self._item(self.__language__(30108), ICON_FAVORITES, "browse:/favorites"))
items.append(self._item(self.__language__(30106), ICON_SEARCH, "exec:search"))
elif Path[0]=="year":
if len(Path)>1:
items.append(self._item(self.__language__(30500), "parent.png", "browse:/year"))
items = self._gameCollection("year", year=Path[1])
else:
items.append(self._item(self.__language__(30500), "parent.png", "browse:/"))
sql = "SELECT year FROM Games WHERE id>0 %s GROUP BY year ORDER BY year" % self._FILTERS
years = self._db.Query(sql, ())
for year in years:
items.append(self._item(year[0], ICON_YEAR, "browse:/year/%s" % year[0]))
elif Path[0]=="bios":
if len(Path)>1:
items.append(self._item(self.__language__(30500), "parent.png", "browse:/bios"))
items = self._gameCollection("bios", bios=Path[1])
else:
items.append(self._item(self.__language__(30500), "parent.png", "browse:/"))
sql = "SELECT gamename, romset FROM Games WHERE isbios AND romset IN (SELECT romof FROM Games WHERE romof<>'' %s GROUP BY romof) ORDER BY gamename" % self._FILTERS
bioses = self._db.Query(sql, ())
for bios in bioses:
items.append(self._item(bios[0], ICON_BIOS, "browse:/bios/%s" % bios[1]))
elif Path[0]=="manu":
if len(Path)>1:
items.append(self._item(self.__language__(30500), "parent.png", "browse:/manu"))
items = self._gameCollection("manu", manufacturer=Path[1])
else:
items.append(self._item(self.__language__(30500), "parent.png", "browse:/"))
sql = "SELECT manufacturer FROM Games WHERE id>0 %s GROUP BY manufacturer ORDER BY manufacturer" % self._FILTERS
manufacturers = self._db.Query(sql, ())
for manufacturer in manufacturers:
items.append(self._item(manufacturer[0], ICON_BIOS, "browse:/manu/%s" % manufacturer[0]))
elif Path[0]=="name":
if len(Path)>1:
items.append(self._item(self.__language__(30500), "parent.png", "browse:/name"))
if Path[1]=="#":
criteria = "("
for i in range(10):
criteria += "gamename LIKE '" + str(i) + "%'"
if i < 9:
criteria += " OR "
criteria += ")"
else:
criteria = "gamename LIKE '" + Path[1] + "%'"
items = self._gameCollection("name", letter=criteria)
else:
items.append(self._item(self.__language__(30500), "parent.png", "browse:/"))
folders = ['#', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']
for folder in folders:
items.append(self._item(self.__language__( 30107 ) % folder.upper(), ICON_NAME, "browse:/name/%s" % folder))
elif Path[0]=="hdd":
items = self._gameCollection("", hasdisk=1)
elif Path[0]=="all":
items = self._gameCollection("")
elif Path[0]=="favorites":
items = self._gameCollection("", favorites=1)
unlock()
return items
def _item(self, caption, image, action="", menu = ""):
menu = "%s,exec:config," % self.__language__(30803) + menu
if menu[-1]==",": menu=menu[:-1]
if image=="":
item = ListItem(label = caption)
item.setProperty("action", action)
item.setProperty("menu", menu)
else:
item = ListItem(label = caption, thumbnailImage = image)
item.setProperty("action", action)
item.setProperty("menu", menu)
return item
def _gameCollection(self, parentpath, year="", bios="", manufacturer="", letter="", search="", hasdisk=0, list="", related="", favorites=0, cache=False):
# xbmcgui.lock()
sql = "SELECT id, gamename, gamecomment, thumb, romset, hasdips FROM Games WHERE NOT isbios %s %s ORDER BY gamename"
criteria=""
values=""
if year:
criteria="AND year=?"
values = (year,)
if bios:
criteria="AND romof=?"
values = (bios,)
if hasdisk:
criteria="AND hasdisk"
values = ""
if manufacturer:
criteria="AND manufacturer=?"
values = (manufacturer,)
if letter:
criteria="AND %s" % letter
values = ()
if list:
criteria="AND id IN (%s)" % list
values = ()
if related:
criteria="AND gamename IN (%s)" % related
values = ()
if favorites:
criteria="AND romset IN (SELECT gamename FROM Favorites)"
values = ()
if search:
criteria="AND gamename LIKE '%" + search + "%'"
values = ()
sql = "SELECT id, gamename, gamecomment, thumb, romset, hasdips, info, history FROM Games WHERE NOT isbios %s %s ORDER BY gamename" % (criteria, self._FILTERS)
games = self._db.Query(sql, values)
item = self._item(self.__language__(30500), "parent.png", "browse:/%s" % parentpath)
item.setProperty("menu", "%s,%s" %(self.__language__( 30900 ), "exec:config"))
items = [item]
for game in games:
thumb = path.join(self.TITLES_PATH, "%s.png" % str(game[4]))
if not path.exists(thumb): thumb = "default.png"
if str(game[2])!="": label = "%s (%s)" % (str(game[1]), str(game[2]))
else: label = str(game[1])
item = xbmcgui.ListItem(label=label, thumbnailImage=thumb)
item.setProperty("action", "exec:game:%s" % game[0])
menu = "%s,exec:config,%s,exec:config:%s,%s,exec:info:%s" %(self.__language__( 30803 ), self.__language__( 30800 ), game[0], self.__language__( 30802 ), game[0])
if not favorites: menu+=",%s,exec:addfav:%s" % (self.__language__(30804), game[4])
else:menu+=",%s,exec:delfav:%s" % (self.__language__(30805), game[4])
item.setProperty("menu", menu)
items.append(item)
# xbmcgui.unlock()
return items
del games
def _runGame(self, romset):
game = GameItem(self._db, id=romset)
if game.have:
self._MAME_PARAMS["-cfg_directory"] = "\"%s\"" % self._MAME_CONFIG_PATH.replace("\\", "/")
self._MAME_PARAMS["-nvram_directory"] = "\"%s\"" % self._MAME_NVRAM_PATH.replace("\\", "/")
self._MAME_PARAMS["-rompath"] = "\"%s\"" % self._MAME_ROM_PATH.replace("\\", "/")
self._MAME_PARAMS["-artpath"] = "\"%s\"" % self.MEDIA_PATH.replace("\\", "/")
if self._MAME_SAMPLES_PATH:
self._MAME_PARAMS["-samplepath"] = "\"%s\"" % self._MAME_SAMPLES_PATH.replace("\\", "/")
if game.biosset:
self._MAME_PARAMS["-bios"] = game.biosset
cfgxml = "<?xml version=\"1.0\"?><mameconfig version=\"10\"><system name=\"%s\"><input>" % game.romset
for switch in game.dipswitches:
switch = DIPSwitch(self._db, switch[0])
cfgxml+= "<port tag=\"%s\" type=\"DIPSWITCH\" mask=\"%s\" defvalue=\"%s\" value=\"%s\" />" % (switch.tag,switch.mask,switch.defvalue,switch.value)
cfgxml+="</input><video>"
cfgxml+="<target index=\"0\" view=\"%s\" rotate=\"%s\" backdrops=\"%s\" overlays=\"%s\" bezels=\"%s\" zoom=\"%s\" />" % (game.view, game.rotate, game.backdrops, game.overlays, game.bezels, game.zoom)
cfgxml+="</video></system></mameconfig>"
cfg = open(path.join(self._MAME_CONFIG_PATH, "%s.cfg" % game.romset), "w")
cfg.write(cfgxml)
cfg.close()
command = self._MAME_EXE_PATH
for key in self._MAME_PARAMS.keys():
command += " %s %s " % (key, self._MAME_PARAMS[key])
command+=game.romset
command = "System.Exec(\"%s\")" % command.replace("\"", "\\\"")
executebuiltin(command)
else:
if dialog.yesno(self.__language__(30701), self.__language__(30702), self.__language__(30703)):MameImport(self)
def _gameSettings(self, romset_id):
__fakesettings__ = Addon(self.SETTINGS_PLUGIN_ID)
SETTINGS_PLUGIN_XML_TEMPLATE = path.join(__fakesettings__.getAddonInfo("path"), "resources", "settings.xml")
SETTINGS_PLUGIN_XML_DOCUMENT = translatePath(path.join(__fakesettings__.getAddonInfo("profile"), "settings.xml"))
game = GameItem(self._db, id=romset_id)
rotate_by_name = {self.__language__(30916):0,self.__language__(30917):90,self.__language__(30918):180,self.__language__(30919):270}
rotate_by_value = {0:self.__language__(30916),90:self.__language__(30917),180:self.__language__(30918),720:self.__language__(30919)}
view_by_name = {self.__language__(30921):0,self.__language__(30922):1,self.__language__(30923):2,self.__language__(30924):3}
view_by_value = {0:self.__language__(30921),1:self.__language__(30922),2:self.__language__(30923),2:self.__language__(30924)}
bool_by_name = {"false":0, "true":1}
bool_by_value = {0:"false", 1:"true"}
settings_xml ="<settings>"
settings_xml +="<category label=\"%s\">" % self.__language__(30914)
settings_xml +="<setting label=\"%s\" type=\"labelenum\" id=\"display_rotate\" values=\"%s|%s|%s|%s\" default=\"%s\"/>" % \
(self.__language__(30915), self.__language__(30916), self.__language__(30917), self.__language__(30918), self.__language__(30919), view_by_value[game.view])
settings_xml +="<setting label=\"%s\" type=\"labelenum\" id=\"display_view\" values=\"%s|%s|%s|%s\" default=\"%s\"/>" % \
(self.__language__(30920), self.__language__(30921), self.__language__(30922), self.__language__(30923), self.__language__(30924), rotate_by_value[game.rotate])
settings_xml +="<setting label=\"%s\" type=\"bool\" id=\"display_backdrops\" default=\"%s\"/>" % (self.__language__(30925), bool_by_value[game.backdrops])
settings_xml +="<setting label=\"%s\" type=\"bool\" id=\"display_overlays\" default=\"%s\"/>" % (self.__language__(30926), bool_by_value[game.overlays])
settings_xml +="<setting label=\"%s\" type=\"bool\" id=\"display_bezels\" default=\"%s\"/>" % (self.__language__(30927), bool_by_value[game.bezels])
settings_xml +="<setting label=\"%s\" type=\"bool\" id=\"display_zoom\" default=\"%s\"/>" % (self.__language__(30928), bool_by_value[game.zoom])
settings_xml +="</category>"
switches = self._db.getList("Dipswitches", ["id"], {"romset_id=":romset_id})
if len(game.biossets):
values = ""
for biosset in game.biossets:
if game.biosset==biosset.name:default = biosset.description
values+="|%s" % biosset.description
settings_xml +="<category label=\"%s\">" % self.__language__(30937)
settings_xml +="<setting label=\"%s\" type=\"labelenum\" id=\"biosset\" values=\"%s\" default=\"%s\"/>" % \
(self.__language__(30938), values[1:], default)
settings_xml +="</category>"
settings_xml +="<category label=\"%s\">" % self.__language__(30801)
for switch in switches:
switch = DIPSwitch(self._db, id=switch["id"])
values = ""
for value in switch.values_by_value:
values+="|%s" % value
if values=="|On|Off" or values=="|Yes|No":
if switch.values_by_name[str(switch.value)]=="On" or switch.values_by_name[str(switch.value)]=="Yes":
default="true"
else:
default="false"
settings_xml += "<setting label=\"%s\" type=\"bool\" id=\"S%s\" default=\"%s\"/>" % (switch.name, switch.id, default)
else:
settings_xml += "<setting label=\"%s\" type=\"labelenum\" id=\"S%s\" default=\"%s\" values=\"%s\"/>" % (switch.name, switch.id, switch.values_by_name[str(switch.value)], values[1:])
settings_xml+="</category>"
settings_xml+="</settings>"
settings_xml_file = open(SETTINGS_PLUGIN_XML_TEMPLATE, "w")
settings_xml_file.write(settings_xml.encode('utf8'))
settings_xml_file.close()
__fakesettings__.openSettings()
if path.exists(SETTINGS_PLUGIN_XML_DOCUMENT):
src = open(SETTINGS_PLUGIN_XML_DOCUMENT, "r")
xml = src.read()
src.close()
xml = re.sub("\r|\t|\n", "", xml)
settings = XMLHelper().getNodes(xml, "setting")
for setting in settings:
if XMLHelper().getAttribute(setting, "setting", "id")=="display_view":
game.view = view_by_name[XMLHelper().getAttribute(setting, "setting", "value")]
elif XMLHelper().getAttribute(setting, "setting", "id")=="display_rotate":
game.rotate = rotate_by_name[XMLHelper().getAttribute(setting, "setting", "value")]
elif XMLHelper().getAttribute(setting, "setting", "id")=="display_backdrops":
game.backdrops = bool_by_name[XMLHelper().getAttribute(setting, "setting", "value")]
elif XMLHelper().getAttribute(setting, "setting", "id")=="display_overlays":
game.overlays = bool_by_name[XMLHelper().getAttribute(setting, "setting", "value")]
elif XMLHelper().getAttribute(setting, "setting", "id")=="display_bezels":
game.bezels = bool_by_name[XMLHelper().getAttribute(setting, "setting", "value")]
elif XMLHelper().getAttribute(setting, "setting", "id")=="display_zoom":
game.zoom = bool_by_name[XMLHelper().getAttribute(setting, "setting", "value")]
elif XMLHelper().getAttribute(setting, "setting", "id")=="biosset":
game.biosset = BiosSet(self._db).getByDescription(XMLHelper().getAttribute(setting, "setting", "value")).name
else:
switch = DIPSwitch(self._db, id=XMLHelper().getAttribute(setting, "setting", "id")[1:])
value = XMLHelper().getAttribute(setting, "setting", "value")
if value=="true":
try:
switch.value = switch.values_by_value["On"]
except KeyError:
switch.value = switch.values_by_value["Yes"]
elif value=="false":
try:
switch.value = switch.values_by_value["Off"]
except KeyError:
switch.value = switch.values_by_value["No"]
else:
switch.value=switch.values_by_value[XMLHelper().getAttribute(setting, "setting", "value")]
switch.writeDB()
game.writeDB()
self._db.commit()
remove(SETTINGS_PLUGIN_XML_DOCUMENT)
remove(SETTINGS_PLUGIN_XML_TEMPLATE)
def _thumbNails(self):
if self._MAME_TITLES_PATH or self._ONLINE_TITLES:
progress = DialogProgress()
progress.create(self.__language__(30615))
if self._ROMSET_TITLES:
files = self._db.runQuery("SELECT romset FROM Games WHERE have")
else:
files = self._db.runQuery("SELECT romset FROM Games")
count = len(files)
step = count/20
index = 0
for file in files:
romset = file["romset"]
if progress.iscanceled():
break
index += 1
if self._MAME_TITLES_PATH:
filename = path.join(self._MAME_TITLES_PATH, "%s.png" % romset)
if self._CACHE_TITLES:
cachefile = path.join(self._MAME_CACHE_PATH, "%s.png" % romset)
if not path.exists(cachefile):
if path.exists(filename):
copyfile(filename, cachefile)
filename = cachefile
if self._ONLINE_TITLES:
filename = path.join(self._MAME_CACHE_PATH, "%s.png" % romset)
if self._HIRES_TITLES:res="hi"
else:res="lo"
if not path.exists(filename):
urlcleanup()
urlretrieve("https://www.otaku-realm.net/xbmame/%s/%s.png" % (res, romset), filename)
progress.update(int((float(index)/float(count)) * 100), self.__language__(30616), self.__language__(30617) % romset, self.__language__(30618) % (index, count))
if index % step == 0:
progress.update(int((float(index)/float(count)) * 100), self.__language__(30616), self.__language__(30617) % romset, self.__language__(30618) % (index, count))
progress.close()
def _haveList(self):
progress = DialogProgress()
progress.create(self.__language__(30611))
files = listdir(self._MAME_ROM_PATH)
count = len(files)
step = count/20
index = 0
for file in files:
if progress.iscanceled(): break
index += 1
romset = file.replace(".zip", "").replace(".rar", "").replace(".7z","")
if index % step == 0:
progress.update(int((float(index)/float(count)) * 100), self.__language__(30612), self.__language__(30613) % romset, self.__language__(30614) % (index, count))
self._db.execute("UPDATE Games SET have=1 WHERE romset=?", (romset,))
self._db.commit()
progress.close()
