def Flash(self, aCount=1, aDelay=100):
Log("TPinOut.Flash", aCount, aDelay)
for i in range(0, aCount):
self.Set(True)
time.sleep_ms(aDelay)
self.Set(False)
time.sleep_ms(aDelay)
def SetNo(self, aIdx, aOn):
Log('TLeds.SetNo', aIdx, aOn)
if (aIdx < len(self.Leds)):
self.Leds[aIdx].Set(aOn)
else:
print('index out of range', aIdx)
def Set(self, aOn):
Log('TLeds.Set-2', aOn)
# here is error: MemoryError
for Led in self.Leds:
#for i in range(len(self.Leds)):
#Led = self.Leds[i]
Led.Set(aOn)
def Toggle(self):
Log("TLeds.Toggle")
Led = self.Leds[self.Idx]
Led.Flash(1)
self.Idx += 1
if (self.Idx >= self.GetCount()):
self.Idx = 0
def __init__(self):
Log('TLeds.init')
self.Idx = 0
self.Leds = []
self.Leds.append(TPinOut(2, "sys"))
self.Leds.append(TPinOut(15, "red"))
self.Leds.append(TPinOut(12, "green"))
self.Leds.append(TPinOut(13, "blue"))
def connSQL(dbname):
cnx = None
if usesqlite:
from sqlite3 import dbapi2
DBfile = getDBlocation(dbname)
if not xbmcvfs.exists(DBfile):
cnx = dbapi2.connect(DBfile)
cnx.text_factory = str
createDatabase(cnx, dbname)
else:
cnx = dbapi2.connect(DBfile)
cnx.text_factory = str
else:
import mysql.connector
from mysql.connector import errorcode
dbname = 'amazon_' + dbname
mysql_config = {
'host': addon.getSetting('dbhost'),
'port': addon.getSetting('dbport'),
'user': addon.getSetting('dbuser'),
'password': addon.getSetting('dbpass'),
'database': dbname,
'use_unicode': False,
'get_warnings': True,
'buffered': True
}
try:
cnx = mysql.connector.connect(**mysql_config)
except mysql.connector.Error as err:
if err.errno == errorcode.CR_CONN_HOST_ERROR:
Dialog.notification('MySQL/MariaDB', getString(30224),
xbmcgui.NOTIFICATION_ERROR)
elif err.errno == errorcode.ER_ACCESS_DENIED_ERROR:
Dialog.notification('MySQL/MariaDB', getString(30225),
xbmcgui.NOTIFICATION_ERROR)
elif err.errno == errorcode.ER_BAD_DB_ERROR:
mysql_config['database'] = None
cnx = mysql.connector.connect(**mysql_config)
c = cnx.cursor()
cur_exec(
c,
'CREATE DATABASE %s CHARACTER SET utf8 COLLATE utf8_general_ci;'
% dbname)
cnx.database = dbname
createDatabase(cnx, dbname)
else:
Log(err)
if not cnx:
exit()
return cnx
def _dump(buf, t, baseOffset=0, arraySize=0):
if arraySize > 0 and t.dataType != "char":
for i in range(0, arraySize - 1):
_dump(buf, t, baseOffset + i * t.dataSize, 0)
else:
if t.dataType == "Struct":
for f in t.fields:
_dump(buf, f, baseOffset + f.offset, f.arraySize)
else:
v = extractData(buf, t, baseOffset)
Log(t.name + "=" + str(v))
def getDBlocation(retvar):
custdb = addon.getSetting('customdbfolder') == 'true'
old_dbpath = xbmc.translatePath(getConfig('old_dbfolder')).decode('utf-8')
cur_dbpath = dbpath
if not old_dbpath:
old_dbpath = cur_dbpath
if custdb:
cur_dbpath = xbmc.translatePath(
addon.getSetting('dbfolder')).decode('utf-8')
else:
addon.setSetting('dbfolder', dbpath)
orgDBfile = {
'tv': os.path.join(dbpath, 'tv.db'),
'movie': os.path.join(dbpath, 'movies.db')
}
oldDBfile = {
'tv': os.path.join(old_dbpath, 'tv.db'),
'movie': os.path.join(old_dbpath, 'movies.db')
}
DBfile = {
'tv': os.path.join(cur_dbpath, 'tv.db'),
'movie': os.path.join(cur_dbpath, 'movies.db')
}
if old_dbpath != cur_dbpath:
Log('DBPath changed')
if xbmcvfs.exists(oldDBfile['tv']) and xbmcvfs.exists(
oldDBfile['movie']):
if not xbmcvfs.exists(cur_dbpath):
xbmcvfs.mkdir(cur_dbpath)
if not xbmcvfs.exists(DBfile['tv']) or not xbmcvfs.exists(
DBfile['movie']):
copyDB(oldDBfile, DBfile)
writeConfig('old_dbfolder', cur_dbpath)
if custdb:
org_fileacc = int(
xbmcvfs.Stat(orgDBfile['tv']).st_mtime() +
xbmcvfs.Stat(orgDBfile['movie']).st_mtime())
cur_fileacc = int(
xbmcvfs.Stat(DBfile['tv']).st_mtime() +
xbmcvfs.Stat(DBfile['movie']).st_mtime())
if org_fileacc > cur_fileacc:
copyDB(orgDBfile, DBfile, True)
return DBfile[retvar]
def waitforDB(cnx):
if not usesqlite:
return
c = cnx.cursor()
error = True
while error:
error = False
try:
c.execute('SELECT name FROM sqlite_master WHERE type="table"'
).fetchone()
except:
error = True
xbmc.sleep(1000)
Log('Database locked')
c.close()
"""
Functions for extracting and translating metadata from utorrent resume data to deluge
compatable values
"""
import deluge.component as component
from common import Log
log = Log()
log.transmitting = True
# infinite in utorrent is 0, and -1 in deluge
_translate_inf = lambda x: -1 if x == 0 else x
def max_download_speed(info):
downspeed = float(info['downspeed']) / 1024
return _translate_inf(downspeed)
def max_upload_speed(info):
upspeed = float(info['upspeed']) / 1024
return _translate_inf(upspeed)
def max_connections(info):
return info['max_connections']
def max_upload_slots(info):
return _translate_inf(info['ulslots'])
#======= Import Modules =======
#----- General -----
import os
#----- SDL -----
from common import Log
from classify_image import ClassifyImage
#======= Global Variable =======
log = Log(os.environ['SDL_LOG_LEVEL'])
#======= Main Function =======
if __name__ == '__main__':
#======= Start Message =======
log.output_msg(1, 1, "main() started")
log.output_msg(1, 1, "log.log_level = {0}".format(log.log_level))
#======= Start Process =======
app = ClassifyImage()
app.load_data()
def __init__(self):
"""
Constructor
"""
#======= Setup Log =======
self.log = Log(os.environ['SDL_LOG_LEVEL'])
#======= Start Message =======
self.log.output_msg(1, 1, "ClassifyImage.__init__() started")
#======= Setup Log Directory =======
if 'SDL_LOG_DIR' in os.environ:
self.log_dir = os.environ['SDL_LOG_DIR']
else:
self.log_dir = './log'
self.log.output_msg(1, 1, "self.log_dir = {0}".format(self.log_dir))
#======= Setup Model Path =======
if 'SDL_MODEL_PATH' in os.environ:
self.model_path = os.environ['SDL_MODEL_PATH']
else:
self.model_path = "model.sample_cnn"
self.log.output_msg(1, 1,
"self.model_path = {0}".format(self.model_path))
#======= Setup Class Num =======
if 'SDL_CLASS_NUM' in os.environ:
self.class_num = int(os.environ['SDL_CLASS_NUM'])
else:
self.class_num = 10
self.log.output_msg(1, 1,
"self.class_num = {0}".format(self.class_num))
#======= Setup Row Num =======
if 'SDL_ROW_NUM' in os.environ:
self.row_num = int(os.environ['SDL_ROW_NUM'])
else:
self.row_num = 32
self.log.output_msg(1, 1, "self.row_num = {0}".format(self.row_num))
#======= Setup Col Num =======
if 'SDL_COL_NUM' in os.environ:
self.col_num = int(os.environ['SDL_COL_NUM'])
else:
self.col_num = 32
self.log.output_msg(1, 1, "self.col_num = {0}".format(self.col_num))
#======= Set Channel Num =======
if 'SDL_CHANNEL_NUM' in os.environ:
self.channel_num = int(os.environ['SDL_CHANNEL_NUM'])
else:
self.channel_num = 3
self.log.output_msg(1, 1,
"self.channel_num = {0}".format(self.channel_num))
#======= Setup Batch Size =======
if 'SDL_BATCH_SIZE' in os.environ:
self.batch_size = int(os.environ['SDL_BATCH_SIZE'])
else:
self.batch_size = 32
self.log.output_msg(1, 1,
"self.batch_siize = {0}".format(self.batch_size))
#======= Setup Epoch Number =======
if 'SDL_EPOCH_NUM' in os.environ:
self.epoch_num = int(os.environ['SDL_EPOCH_NUM'])
else:
self.epoch_num = 32
self.log.output_msg(1, 1,
"self.epoch_num = {0}".format(self.epoch_num))
#======= Setup SGD Learning Rate =======
if 'SDL_SGD_LR' in os.environ:
self.sgd_lr = float(os.environ['SDL_SGD_LR'])
else:
self.sgd_lr = 0.01
self.log.output_msg(1, 1, "self.sgd_lr = {0}".format(self.sgd_lr))
#======= Setup SGD Decay =======
if 'SDL_SGD_Decay' in os.environ:
self.sgd_decay = float(os.environ['SDL_SGD_DECAY'])
else:
self.sgd_decay = 1e-4
self.log.output_msg(1, 1,
"self.sgd_decay = {0}".format(self.sgd_decay))
#======= Setup SGD Momentum =======
if 'SDL_SGD_MOMENTUM' in os.environ:
self.sgd_momentum = float(os.environ['SDL_SGD_MOMENTUM'])
else:
self.sgd_momentum = 0.9
self.log.output_msg(
1, 1, "self.sgd_momentum = {0}".format(self.sgd_momentum))
#======= Setup Data Augmentation =======
if 'SDL_DATA_AUG' in os.environ:
self.data_aug = bool(os.environ['SDL_DATA_AUG'])
else:
self.data_aug = True
self.log.output_msg(1, 1, "self.data_aug = {0}".format(self.data_aug))
#======= Setup Featurewise Center =======
if 'SDL_DATA_AUG_FCENTER' in os.environ:
self.data_aug_fcenter = bool(os.environ['SDL_DATA_AUG_FCENTER'])
else:
self.data_aug_fcenter = False
self.log.output_msg(
1, 1, "self.data_aug_fcenter = {0}".format(self.data_aug_fcenter))
#======= Setup Samplewise Center =======
if 'SDL_DATA_AUG_SCENTER' in os.environ:
self.data_aug_scenter = bool(os.environ['SDL_DATA_AUG_SCENTER'])
else:
self.data_aug_scenter = False
self.log.output_msg(
1, 1, "self.data_aug_scenter = {0}".format(self.data_aug_scenter))
#======= Setup Featurewise STD Normalization =======
if 'SDL_DATA_AUG_FSTDNORM' in os.environ:
self.data_aug_fstdnorm = bool(os.environ['SDL_DATA_AUG_FSTDNORM'])
else:
self.data_aug_fstdnorm = False
self.log.output_msg(
1, 1,
"self.data_aug_fstdnorm = {0}".format(self.data_aug_fstdnorm))
#======= Setup Samplewise STD Normalization =======
if 'SDL_DATA_AUG_SSTDNORM' in os.environ:
self.data_aug_sstdnorm = bool(os.environ['SDL_DATA_AUG_SSTDNORM'])
else:
self.data_aug_sstdnorm = False
self.log.output_msg(
1, 1,
"self.data_aug_sstdnorm = {0}".format(self.data_aug_sstdnorm))
#======= Setup ZCA Whitening =======
if 'SDL_DATA_AUG_ZCA' in os.environ:
self.data_aug_zca = bool(os.environ['SDL_DATA_AUG_ZCA'])
else:
self.data_aug_zca = False
self.log.output_msg(
1, 1, "self.data_aug_zca = {0}".format(self.data_aug_zca))
#======= Setup Rot Range =======
if 'SDL_DATA_AUG_ROT_RANGE' in os.environ:
self.data_aug_rot_range = int(os.environ['SDL_DATA_AUG_ROT_RANGE'])
else:
self.data_aug_rot_range = 0
self.log.output_msg(
1, 1,
"self.data_aug_rot_range = {0}".format(self.data_aug_rot_range))
#======= Setup Width Shift Range =======
if 'SDL_DATA_AUG_WSHIFT_RANGE' in os.environ:
self.data_aug_wshift_range = int(
os.environ['SDL_DATA_AUG_WSHIFT_RANGE'])
else:
self.data_aug_wshift_range = 0
self.log.output_msg(
1, 1, "self.data_aug_wshift_range = {0}".format(
self.data_aug_wshift_range))
#======= Setup Height Shift Range =======
if 'SDL_DATA_AUG_HSHIFT_RANGE' in os.environ:
self.data_aug_hshift_range = int(
os.environ['SDL_DATA_AUG_HSHIFT_RANGE'])
else:
self.data_aug_hshift_range = 0
self.log.output_msg(
1, 1, "self.data_aug_hshift_range = {0}".format(
self.data_aug_hshift_range))
#======= Setup Horizontal Flip =======
if 'SDL_DATA_AUG_HFLIP' in os.environ:
self.data_aug_hflip = bool(os.environ['SDL_DATA_AUG_HFLIP'])
else:
self.data_aug_hflip = False
self.log.output_msg(
1, 1, "self.data_aug_hflip = {0}".format(self.data_aug_hflip))
#======= Setup Vertical Flip =======
if 'SDL_DATA_AUG_VFLIP' in os.environ:
self.data_aug_vflip = bool(os.environ['SDL_DATA_AUG_VFLIP'])
else:
self.data_aug_vflip = False
self.log.output_msg(
1, 1, "self.data_aug_vflip = {0}".format(self.data_aug_vflip))
#======= End Message =======
self.log.output_msg(1, 1, "ClassifyImage.__init__() ended")
import redis
from common import configHttp
from common import rsa_aes
import readConfig
from common import Log
config = readConfig.ReadConfig()
content = configHttp.ConfigHttp()
log=Log.Log()
a=rsa_aes.Rsa()
# 获取图形验证码
def getcapture():
pool = redis.ConnectionPool(host=config.get_redis('yc_host'), password=config.get_redis('yc_password'))
r = redis.Redis(connection_pool=pool)
content.set_url("/property/api/v1/user/getCaptcha")
req=content.get()
# 获取sessionid
ssion=req.headers['Set-Cookie'].split(';')[0].split('=')[1]
tuxing = r.get("YC:PROPERTY:USER:CAPTCHA:%s"%ssion)
tx=str(tuxing, encoding='utf-8')
return [tx,req.cookies]
[tx,session]=getcapture()
# 忘记登录密码，不加密
def forgotpwd(mobile, newPwd, confirmpwd,smscode='000000',utype=1,code=tx):
"""
:param mobile:手机号
:param newPwd:新密码
:param confirmpwd:确认密码
:param code:图形验证码
#sql = Sql("Select index, mi, why.* from MY_STRUCT where index in (1,3,5)")
#sql = Sql("Select index, mi, why.*, str from MY_STRUCT where str in ('a', 'test')")
#sql = Sql("Select index, mi, why.*, str from MY_STRUCT where index between 2 and 3")
#sqlQuery = "Select *, index, mi, why2[*].*, str from MY_STRUCT where str like 't.*'"
sqlQuery = "Select * from MY_STRUCT"
index = 1
while index < len(sys.argv):
if sys.argv[index] == "--debug":
common.doLog = True
else:
sqlQuery = ' '.join(sys.argv[index:])
break
index += 1
Log(sqlQuery)
if len(sqlQuery) > 0:
sql = Sql(sqlQuery)
node = sql.findNode("[TABLE]")
if node == None:
raise QueryException("table not specified in query")
# Find and verify table name
tableNode = node.getchildren()[0]
tableName = tableNode.getdata()
if not tableName in tables:
raise QueryException("Structure '{0}' unknown".format(tableName))
tableData = tables[tableName]
# Copyright(c) 2020
# Environment: python 3.5
# Author By: zhanfei
# Create Date: 2020-06-02
# Scenario:通过登录接口获取Token
#################################################
import requests
import json
import sys
sys.path.append("..")
from common.ReadConfig import *
from common.Log import *
from common.ReqApi import *
log = Log().get_logger()
# 调用获取token接口
def get_token():
rmt = ReqApi('/test_data/GetToken.yml', 'testcase1', 2)
result = rmt.run_request()
data2 = result[2]
print(data2)
token = data2['data']['token']
return token
if __name__ == "__main__":
print(get_token())
def Toggle(self):
Log("TPinOut.Toggle")
self.Set(not self.Get())
def Set(self, aOn):
Log('TPinOut.Set', aOn, self.Alias, self.Pin)
self.Obj.value(aOn)
def setUpClass(cls):
cls.log = Log()
cls.r = YzApi()
cls.r.login()
def createDatabase(cnx, dbname):
c = cnx.cursor()
cur_exec(c, 'drop table if exists categories')
Log('Creating %s database' % dbname.upper())
if 'movie' in dbname:
cur_exec(c, 'drop table if exists movies')
cur_exec(
c, '''create table movies(
asin VARCHAR(144) UNIQUE,
movietitle TEXT,
trailer BOOLEAN,
poster TEXT,
plot TEXT,
director TEXT,
writer TEXT,
runtime INTEGER,
year INTEGER,
premiered TEXT,
studio TEXT,
mpaa TEXT,
actors TEXT,
genres TEXT,
stars FLOAT,
votes INTEGER,
fanart TEXT,
isprime BOOLEAN,
isHD BOOLEAN,
isAdult BOOLEAN,
popularity INTEGER,
recent INTEGER,
audio INTEGER,
PRIMARY KEY(asin))''')
else:
cur_exec(c, 'drop table if exists shows')
cur_exec(c, 'drop table if exists seasons')
cur_exec(c, 'drop table if exists episodes')
cur_exec(
c, '''CREATE TABLE shows(
asin VARCHAR(144) UNIQUE,
seriestitle TEXT,
plot TEXT,
network TEXT,
mpaa TEXT,
genres TEXT,
actors TEXT,
airdate TEXT,
year INTEGER,
stars float,
votes INTEGER,
seasontotal INTEGER,
episodetotal INTEGER,
audio INTEGER,
isHD BOOLEAN,
isprime BOOLEAN,
popularity INTEGER,
recent INTEGER,
imdb TEXT,
poster TEXT,
banner TEXT,
fanart TEXT,
PRIMARY KEY(asin));''')
cur_exec(
c, '''CREATE TABLE seasons(
asin VARCHAR(144) UNIQUE,
seriesasin TEXT,
season INTEGER,
seriestitle TEXT,
plot TEXT,
actors TEXT,
network TEXT,
mpaa TEXT,
genres TEXT,
airdate TEXT,
year INTEGER,
stars float,
votes INTEGER,
episodetotal INTEGER,
audio INTEGER,
popularity INTEGER,
recent INTEGER,
isHD BOOLEAN,
isprime BOOLEAN,
imdburl TEXT,
poster TEXT,
banner TEXT,
fanart TEXT,
forceupdate BOOLEAN,
PRIMARY KEY(asin));''')
cur_exec(
c, '''create table episodes(
asin VARCHAR(144) UNIQUE,
seasonasin TEXT,
seriesasin TEXT,
seriestitle TEXT,
season INTEGER,
episode INTEGER,
poster TEXT,
mpaa TEXT,
actors TEXT,
genres TEXT,
episodetitle TEXT,
studio TEXT,
stars float,
votes INTEGER,
fanart TEXT,
plot TEXT,
airdate TEXT,
year INTEGER,
runtime INTEGER,
isHD BOOLEAN,
isprime BOOLEAN,
isAdult BOOLEAN,
audio INTEGER,
PRIMARY KEY(asin));''')
cnx.commit()
c.close()
def __init__(self):
self.log = Log()
self.Yaml = DataSource()
def __init__(self, aPin, aAlias):
Log('TPinBase.init', aPin, aAlias)
self.Pin = aPin
self.Alias = aAlias
