def __init__(self):
self.log = Logger('main').logger()
config = Config(main_cfg_path)
config.cfg_load()
port = config.cfg.get('Arduino', 'port_name')
baudrate = config.cfg.get('Arduino', 'baudrate')
self.project = config.cfg.get('Project', 'name')
self.tmp_data = config.cfg.get('Data', 'tmp')
self.led1 = config.cfg.get('Data', 'led1')
self.led2 = config.cfg.get('Data', 'led2')
self.sound = config.cfg.get('Data', 'sound')
self.data_backup = config.cfg.get('Log', 'data_backup')
self.ser = SerialHelper()
port_name = config.cfg.get('Arduino', 'port_name')
port = self.ser.serial_port(port_name)
if port != '':
self.ser.port = port
self.ser.baudrate = baudrate
self.ser.start()
if not self.ser.alive:
self.log.error('Cannot open port {}!'.format(port))
sys.exit()
else:
self.log.error('Cannot find port {}!'.format(port_name))
sys.exit()
# here must add sleep >= 2, will be cannot receive if not
time.sleep(2)
def __init__(self):
self.log = Logger("main").logger()
config = Config(main_cfg_path)
config.cfg_load()
self.port_name = config.cfg.get('Relay', 'port_name')
self.port = None
self.ser = None
def update(self, config: Config, create=False) -> bool:
""" 更新指定配置
- config Config: 要更新的配置
- create bool[False]: 如果不存在相同ID配置是否新增该配置
- return bool: 返回更新是否成功
"""
# 判断输入是否合法
err = config.check()
if err:
self._warning("配置修改失败: 输入不合法, {}".format(err))
return False
# 判断配置是否存在
if self.exists(config.id) is False:
if create:
return self.add(Config)
else:
self._warning("更新配置失败: 配置不存在(ID:{})".format(config.id))
return False
# 保存配置
old_cfg = self.getConfig(config.id)
if config.save(self.getConfigPath(config.id)) is False:
self._warning("更新配置失败: 配置文件保存失败(ID:{})".format(config.id))
return False
self._info("更新配置成功, 旧配置Config={}".format(old_cfg.toJSON()))
return True
def index(self):
config = Config.get()
app = config['app']
appStr = json.dumps(app, indent=4)
if request.method == 'POST':
content = request.form.get('config')
newApp = json.loads(content)
config['app'] = newApp
Config.write(config)
return redirect('admin/config')
return self.render('admin/config.html', appStr = appStr)
def getData(self):
if not os.path.exists(self.dataPath):
config = Config.get()
self.dataPath = config[
'appRoot'] + '/src/py/web/static/test_data/test.csv'
data = csv.reader(open(self.dataPath, 'r'))
isTitle = True
title = []
tickData = []
for line in data:
if isTitle:
for t in line:
title.append(t)
isTitle = False
continue
tick = {}
for i, t in enumerate(line):
tick[title[i]] = t
tickData.append(tick)
self.over = True
return tickData
def test(self):
if request.method == 'POST':
id = request.args.get('id')
model = Model.query.get(id)
modelName = model.nick_name
f = request.files['file']
uploadPath = ''
config = Config.get()
if f.filename:
uploadPath = config[
'appRoot'] + '/src/py/web/static/test_data/' + modelName + '.csv'
f.save(uploadPath)
@flask.stream_with_context
def generate():
id = request.args.get('id')
model = Model.query.get(id)
cmd = 'CTP_CONFIG_PATH=%s python %s/src/py/test.py %s %s' % (
os.environ.get('CTP_CONFIG_PATH'), config['appRoot'],
modelName, uploadPath)
p = subprocess.Popen(cmd,
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
while p.poll() is None:
line = p.stdout.read()
if not line: continue
yield line + '\n'
return self.render('admin/runner_test.html', logs=generate())
else:
return self.render('admin/runner_test.html', logs=[])
def __init__(self, name, isToFile=False):
self.logger = logging.getLogger(name)
self.isToFile = isToFile
if self.isToFile:
config = Config.get()
today = datetime.datetime.now().strftime("%Y%m%d")
path = "%s/src/py/web/static/logs/online/%s_%s.log" % (
config['appRoot'], name, today)
print path, name
self.logger.addHandler(logging.FileHandler(path))
def lbtest(self):
config = Config.get()
if request.method == 'GET':
id = request.args.get('id')
model = Model.query.get(id)
modelName = model.nick_name
else:
id = request.form.get('id')
testVersion = request.form.get('testVersion')
iids = request.form.get('iids')
startDate = request.form.get('startDate')
endDate = request.form.get('endDate')
isRandom = request.form.get('isRandom')
maxSlippage = request.form.get('maxSlippage')
optional = ''
if isRandom:
optional += ' -r '
if isRandom and maxSlippage:
optional += ' -s ' + maxSlippage + ' '
model = Model.query.get(id)
modelName = model.nick_name
cmd = 'CTP_CONFIG_PATH=%s python %s/src/py/lbtest.py %s %s %s %s %s %s' \
% (os.environ.get('CTP_CONFIG_PATH'), config['appRoot'], optional, modelName, testVersion, iids,
startDate, endDate)
now = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
fd = open(
'%s/src/py/web/static/logs/lbtest/%s_%s_%s.log' %
(config['appRoot'], modelName, testVersion, now), 'w')
subprocess.Popen(cmd, shell=True, stdout=fd)
locking = Locker.getLocking('TEST_SERVICE_RUNNING_' + modelName)
files = []
for file in os.listdir('%s/src/py/web/static/logs/lbtest/' %
(config['appRoot'])):
if file.find(modelName) >= 0:
files.append(file)
return self.render('admin/runner_lbtest.html',
locking=locking,
id=id,
logs=files)
def __getConn(type=WEB_CONN):
config = Config()
"""
@summary: 静态方法，从连接池中取出连接
@return MySQLdb.connection
"""
if Mysql.__ht_pool is None and type == Mysql.HT_CONN:
__ht_pool = PooledDB(creator=pymysql, mincached=1, maxcached=20,
host=config.get_db_ht_value(Config.OPT_DB_HOST), port=config.get_db_ht_value_int(Config.OPT_DB_PORT),
user=config.get_db_ht_value(Config.OPT_DB_USER), passwd=config.get_db_ht_value(Config.OPT_DB_PWD),
db=config.get_db_ht_value(Config.OPT_DB_NAME), use_unicode=False,
charset=config.get_db_ht_value(Config.OPT_DB_CHAR), cursorclass=DictCursor)
return __ht_pool.connection()
else:
__pool = PooledDB(creator=pymysql, mincached=1, maxcached=20,
host=config.get_db_web_value(Config.OPT_DB_HOST), port=config.get_db_web_value_int(Config.OPT_DB_PORT),
user=config.get_db_web_value(Config.OPT_DB_USER), passwd=config.get_db_web_value(Config.OPT_DB_PWD),
db=config.get_db_web_value(Config.OPT_DB_NAME), use_unicode=False,
charset=config.get_db_web_value(Config.OPT_DB_CHAR), cursorclass=DictCursor)
return __pool.connection()
def add(self, config: Config) -> bool:
""" 添加并保存配置
- config Config: 要添加的配置
- return bool: 返回添加是否成功
"""
# 判断输入是否合法
err = config.check()
if err:
self._warning("配置添加失败: 输入不合法, {}".format(err))
return False
# 判断是否已存在
if self.exists(config.id):
self._warning("配置添加失败: 已存在相同ID({})配置".format(config.id))
return False
# 尝试保存
if config.save(self.getConfigPath(config.id)) is False:
self._warning("配置添加失败: 配置文件保存失败, Config={}".format(
config.toJSON()))
return False
self._info("配置添加成功(ID:{})".format(config.id))
return True
def __init__(self):
self.log = Logger("main").logger()
self.ard = Arduino()
self.process = DataProcess()
self.r = Relay()
self.keyword = ParseCSV('../testfile/testcase/{}_keyword.csv'.format(
self.ard.project))
config = Config('../config/{}.ini'.format(self.ard.project))
config.cfg_load()
self.led_num = config.cfg.getint('config', 'led')
self.power_button = config.cfg.get('config', 'power_button')
m_cfg = Config(main_cfg_path)
m_cfg.cfg_load()
self.led1_data = m_cfg.cfg.get('Data', 'led1')
self.sound_data = m_cfg.cfg.get('Data', 'sound')
if not self.r.init_relay():
self.log.error('Something is wrong with your relay!')
sys.exit()
def assembly_mapping_data(self, datas: list, lordId=None, viceId=None):
"""
处理需要映射的数据
:param datas: 查询结果数据
:param lordId: 主表id
:param viceId: 副表id
:return:
"""
mapping_list = self.query_mapping_conf(lordId, viceId)
for mapping in mapping_list:
mapping_file = mapping.mapping_file
mapping_key = eval(mapping.mapping_key)
enumerate_dict = Config().get_config(name=mapping_file,
current_path=ENUMERATE_PATH)
datas = conversion.replace_dict_value(
replace_key=mapping_key,
keep_dict=datas,
enumerate_dict=enumerate_dict)
return datas
def __init__(self, modelName, iids, version):
self.server = Redis.get()
self.sender = Redis.get()
self.cache = Redis.get()
self.config = Config.get()
self.modelName = modelName
self.srvChannel = version
self.appConfig = self.config['app'][modelName]
self.iids = iids
# 获取模型
m = Model.query.filter(Model.nick_name==modelName).first()
if not m:
print 'Error: model not exist'
exit()
className = m.class_name
moduleName = 'model.' + className
moduleMeta = __import__(moduleName, globals(), locals(), [className])
classMeta = getattr(moduleMeta, className)
self.model = classMeta(modelName, self)
from common.MySQL import MySQL
from common.Config import Config
from common.Redis import Redis
import time as timeer
import hashlib
import demjson as JSON
import datetime
def format_price(num):
num = float('{:.2f}'.format(num))
return 0 if num > 10000000.0 else num
db = MySQL()
rds = Redis.get()
config = Config.get()
iids = config['iids']
runningKey = 'CTP.QUEUE.RUNNING.CNT'
rds.incr(runningKey)
for i in xrange(1,10000):
runningCnt = int(rds.get(runningKey))
if runningCnt > 5:
break
data = rds.rpop(config['queueKey'])
if not data:
timeer.sleep(1)
continue
def getConfig(self, cfg_id: str) -> Config:
""" 获取指定配置 """
if self.exists(cfg_id) is False:
return None
return Config.load(self.getConfigPath(cfg_id))
import os
import datetime
from common.Config import Config
from runner.testrunner import TestRunner
main_cfg_path = '../config/main.ini'
def make_dir(path):
if not os.path.exists(path):
os.makedirs(path)
config = Config(main_cfg_path)
config.cfg_load()
prj_name = config.cfg.get('Project', 'name')
report_path = config.cfg.get('Result', 'path')
testlist = config.cfg.get('TestCase', 'list')
make_dir(report_path)
reprot_name = '{}/{}_test_report_{}.html'.format(
report_path, prj_name,
datetime.datetime.now().strftime('%m%d%H%M%S'))
title = '{} Automation Test Report'.format(prj_name)
description = 'Test Execution Details:'
TR = TestRunner(reprot_name, title, description, testlist)
TR.run()
'''
TC = TestCase()
case_path = r'..\testfile\testcase\{}_test_case.csv'.format(prj_name)
def index(self):
if request.method == 'POST':
iid = request.form.get('iid')
if not iid:
return jsonify(code=10002, msg="IID Name cannot be empty")
config = Config.get()
tick = filter(lambda x: x not in '0123456789', iid)
# add tick table
if tick not in config['iids']:
config['iids'].append(tick)
Config.write(config)
mysql = MySQL()
sql = '''
CREATE TABLE IF NOT EXISTS `tick_%s` (
`id` bigint(20) NOT NULL AUTO_INCREMENT,
`token` char(32) NOT NULL DEFAULT '',
`iid` varchar(50) NOT NULL DEFAULT '',
`time` char(17) NOT NULL DEFAULT '',
`msec` int(11) NOT NULL DEFAULT '0',
`price` decimal(10,2) NOT NULL DEFAULT '0.00',
`volume` int(11) NOT NULL DEFAULT '0',
`bid_price1` decimal(10,2) NOT NULL DEFAULT '0.00',
`bid_volume1` int(11) NOT NULL DEFAULT '0',
`ask_price1` decimal(10,2) NOT NULL DEFAULT '0.00',
`ask_volume1` int(11) NOT NULL DEFAULT '0',
`mtime` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
PRIMARY KEY (`id`),
UNIQUE KEY idx_token(`token`),
KEY idx_time(`time`)
) ENGINE=InnoDB CHARSET=utf8;''' % (tick)
mysql.insert(sql)
tickModel = createTickModel(tick)
tmp_val = app._got_first_request
app._got_first_request = False
admin.add_view(TickView(tickModel, db.session,
category='Tick'))
app._got_first_request = tmp_val
f = request.files['csv']
if not f:
return jsonify(code=0, msg="create iid success")
tmpPath = '/tmp/%s' % (f.filename)
f.save(tmpPath)
csv_reader = csv.reader(open(tmpPath))
isTitle = True
total = succ = 0
mysql = MySQL()
for row in csv_reader:
if isTitle:
if not self.checkTitle(row):
return jsonify(
code=10001,
msg=
"Error, title should be ['time', 'msec', 'price', 'volume', 'bid_price1', 'bid_volume1', 'ask_price1', 'ask_volume1']"
)
isTitle = False
continue
total += 1
if self.insertTickData(mysql, iid, row):
succ += 1
return jsonify(code=0,
msg='ok',
data={
'total': total,
'succ': succ
})
return self.render('admin/tick_upload.html')
def __init__(self, modelName, tradeSrv):
self.modelName = modelName
self.tradeSrv = tradeSrv
self.appConfig = Config.get()['app'][modelName]
# @Desc : 主服务程序，处理IP
# # @Date : 2018-11-14绑定、监听和消息获取等
import socket
import select
import time, json
from multiprocessing import Queue
from threading import Thread
from common.DataStruct import MessHead, ClientInfo
from handler.HandlerCommon import HandlerCommon
from kafka.KafkaProducer import KafkaProducer
from kafka.KafkaConsumer import KafkaConsumer
from common.Config import Config
config = Config()
class MainServer(object):
def __init__(self,
address,
logger,
timeout=10,
socketnum=32,
max_message=1024,
heart_timeout=25):
'''
类初始化
:param address: 服务器地址，tuple(ip,port)
:param logger: 日志类
:param timeout: epoll超时时间，int
from trainer import Trainer
from common.Config import Config
from unityagents import UnityEnvironment
import matplotlib.pyplot as plt
env = UnityEnvironment(file_name="...") # file_name should be the path to tennis env (see Tennis.ipynd)
cfg = Config(n_agents=2,
lr_actor=1e-4,
lr_critic=1e-3,
epsilon=0.1,
noise_rate=0.1,
gamma=0.99,
tau=0.01,
buffer_size=int(5e5),
batch_size=256,
save_dir="./model",
save_rate=2000,
high_action=1,
low_action=-1,
obs_shape=2*[24],
action_shape=2*[2],
rerrot_every=100)
if __name__ == '__main__':
trainer = Trainer(cfg, env)
returns = trainer.run(4000)
plt.plot(returns)
plt.ylabel('Score')
plt.xlabel('Episode')
def __init__(self):
self.db = MySQL()
self.rds = Redis.get()
self.config = Config.get()
class Timeline:
def __init__(self):
Log.init(LOG_FILE_PATH)
Log.getLogger().info('START')
self.touchPos = (0, 0)
def start(self):
self.buttons = []
self.blitCursor = True
self.config = Config(CONFIG_FILENAME)
pygame.mixer.pre_init(44100, -16, 1, 512)
pygame.init()
pygame.mouse.set_visible(False)
self.loadFonts()
self.screen = pygame.display.set_mode((1920, 1080), pygame.FULLSCREEN)
self.cursor = pygame.image.load(
'assets/images/cursor.png').convert_alpha()
self.touchScreen = None
if self.config.isTouch():
print("Loading touch screen...")
self.touchScreen = TouchScreen(
self.config.getTouchDevicePartialName(),
(self.config.getTouchScreenMaxX(),
self.config.getTouchScreenMaxY()))
if not self.touchScreen.setup():
self.config.setTouch(False)
self.background = pygame.image.load(
'assets/images/background.png').convert()
self.dotImage = pygame.image.load(
'assets/images/dot-normal.png').convert_alpha()
self.dotTappedImage = pygame.image.load(
'assets/images/dot-tapped.png').convert_alpha()
self.dotSelectedImage = pygame.image.load(
'assets/images/dot-selected.png').convert_alpha()
languageButtonImage = pygame.image.load(
'assets/images/language-button-normal.png').convert()
languageButtonTappedImage = pygame.image.load(
'assets/images/language-button-tapped.png').convert()
languageButtonSelectedImage = pygame.image.load(
'assets/images/language-button-selected.png').convert()
self.languageButtons = []
for i in range(len(self.config.getLanguages())):
language = self.config.getLanguages()[i]
languageFont = pygame.font.Font(
language['fonts']['textFont']['filename'],
language['fonts']['textFont']['size'])
languageButton = LanguageButton(
self.screen,
Rect(i * 63 + 15, 1010, languageButtonImage.get_width(),
languageButtonImage.get_height()), languageButtonImage,
languageButtonTappedImage, languageButtonSelectedImage,
language['buttonText'], DOT_TEXT_COLOR,
DOT_SELECTED_TEXT_COLOR, DOT_SELECTED_TEXT_COLOR, languageFont,
partial(self.languageClicked, i))
if language['prefix'] == self.config.languagePrefix:
languageButton.visible = False
self.languageButtons.append(languageButton)
self.buttons.append(languageButton)
self.dots = self.config.getDots()
self.dotButtons = []
for i in range(len(self.dots)):
dot = self.dots[i]
x = dot['x']
y = dot['y']
dotButton = Button(
self.screen,
Rect(x - self.dotImage.get_width() // 2,
y - self.dotImage.get_height() // 2,
self.dotImage.get_width(), self.dotImage.get_height()),
self.dotImage, self.dotTappedImage, str(i + 1), DOT_TEXT_COLOR,
DOT_SELECTED_TEXT_COLOR, self.numbersFont,
partial(self.dotClicked, i), 1.5)
self.dotButtons.append(dotButton)
self.buttons.append(dotButton)
self.selectedDotIndex = 0
self.loadDot()
Log.getLogger().info('INIT')
self.loop()
def loadFonts(self):
languageData = self.config.getLanguage()
self.numbersFont = pygame.font.Font(
languageData['fonts']['numbersFont']['filename'],
languageData['fonts']['numbersFont']['size'])
self.headerFont = pygame.font.Font(
languageData['fonts']['headerFont']['filename'],
languageData['fonts']['headerFont']['size'])
self.textFont = pygame.font.Font(
languageData['fonts']['textFont']['filename'],
languageData['fonts']['textFont']['size'])
self.smallTextFont = pygame.font.Font(
languageData['fonts']['smallTextFont']['filename'],
languageData['fonts']['smallTextFont']['size'])
def dotClicked(self, index):
Log.getLogger().info('DOT_CLICKED,' + str(index + 1))
self.selectedDotIndex = index
self.loadDot()
def languageClicked(self, index):
self.config.changeLanguage(index)
Log.getLogger().info('LANGUAGE_CHANGED,' + self.config.languagePrefix)
self.loadFonts()
self.onLanguageChanged()
self.loadDot()
def onLanguageChanged(self):
languages = self.config.getLanguages()
for i in range(len(languages)):
if i == self.config.languageIndex:
self.languageButtons[i].visible = False
else:
self.languageButtons[i].visible = True
def loadDot(self):
dot = self.dots[self.selectedDotIndex]
textFont = self.smallTextFont if dot.get('smallText',
False) else self.textFont
self.currTexts = Utilities.renderTextList(self.config, textFont,
dot['textKey'], TEXT_COLOR)
self.currHeader = self.headerFont.render(
self.config.getText(dot['headerKey']), True, TEXT_COLOR)
for i in range(len(self.dotButtons)):
if i == self.selectedDotIndex:
self.dotButtons[i].image = self.dotSelectedImage
self.dotButtons[i].color = DOT_SELECTED_TEXT_COLOR
self.dotButtons[i].createText(self.dotButtons[i].text,
self.dotButtons[i].font)
else:
self.dotButtons[i].image = self.dotImage
self.dotButtons[i].color = DOT_TEXT_COLOR
self.dotButtons[i].createText(self.dotButtons[i].text,
self.dotButtons[i].font)
def onMouseDown(self, pos):
for button in self.buttons:
button.onMouseDown(pos)
def onMouseUp(self, pos):
for button in self.buttons:
button.onMouseUp(pos)
def onMouseMove(self, pos):
pass
def draw(self, dt):
self.screen.blit(self.background, (0, 0))
if self.config.isRtl():
self.screen.blit(self.currHeader,
(1788 - self.currHeader.get_width(), 895))
Utilities.drawTextsOnRightX(self.screen, self.currTexts,
(1788, 951), 40)
dotX = 1857
else:
self.screen.blit(self.currHeader, (320, 895))
Utilities.drawTextsOnLeftX(self.screen, self.currTexts, (320, 951),
40)
dotX = 240
self.screen.blit(self.dotSelectedImage,
(dotX - self.dotSelectedImage.get_width() // 2,
911 - self.dotSelectedImage.get_height() // 2))
selectedNumberTextBox = self.numbersFont.render(
str(self.selectedDotIndex + 1), True, TEXT_COLOR)
self.screen.blit(selectedNumberTextBox,
(dotX - selectedNumberTextBox.get_width() // 2,
911 - selectedNumberTextBox.get_height() // 2))
for button in self.buttons:
button.draw()
def loop(self):
try:
isGameRunning = True
clock = pygame.time.Clock()
lastTime = pygame.time.get_ticks()
font = pygame.font.Font(None, 30)
while isGameRunning:
for event in pygame.event.get():
if event.type == MOUSEBUTTONDOWN:
if not self.config.isTouch():
self.onMouseDown(event.pos)
elif event.type == MOUSEBUTTONUP:
if not self.config.isTouch():
self.onMouseUp(event.pos)
elif event.type == KEYDOWN:
if event.key == K_ESCAPE:
isGameRunning = False
if self.config.isTouch():
event = self.touchScreen.readUpDownEvent()
while event is not None:
if event['type'] == TouchScreen.DOWN_EVENT:
self.onMouseDown(event['pos'])
elif event['type'] == TouchScreen.UP_EVENT:
self.onMouseUp(event['pos'])
event = self.touchScreen.readUpDownEvent()
if not self.config.isTouch():
self.onMouseMove(pygame.mouse.get_pos())
else:
pos = self.touchScreen.getPosition()
self.onMouseMove(pos)
self.screen.fill([0, 0, 0])
currTime = pygame.time.get_ticks()
dt = currTime - lastTime
lastTime = currTime
self.draw(dt / 1000)
if not self.config.isTouch() and self.blitCursor:
self.screen.blit(self.cursor, (pygame.mouse.get_pos()))
if self.config.showFPS():
fps = font.render(str(int(clock.get_fps())), True,
Color('white'))
self.screen.blit(fps, (50, 50))
pygame.display.flip()
clock.tick(60)
pygame.quit()
except Exception as e:
Log.getLogger().exception('ERROR,Error occured!')
def start(self):
self.buttons = []
self.blitCursor = True
self.config = Config(CONFIG_FILENAME)
pygame.mixer.pre_init(44100, -16, 1, 512)
pygame.init()
pygame.mouse.set_visible(False)
self.loadFonts()
self.screen = pygame.display.set_mode((1920, 1080), pygame.FULLSCREEN)
self.cursor = pygame.image.load(
'assets/images/cursor.png').convert_alpha()
self.touchScreen = None
if self.config.isTouch():
print("Loading touch screen...")
self.touchScreen = TouchScreen(
self.config.getTouchDevicePartialName(),
(self.config.getTouchScreenMaxX(),
self.config.getTouchScreenMaxY()))
if not self.touchScreen.setup():
self.config.setTouch(False)
self.background = pygame.image.load(
'assets/images/background.png').convert()
self.dotImage = pygame.image.load(
'assets/images/dot-normal.png').convert_alpha()
self.dotTappedImage = pygame.image.load(
'assets/images/dot-tapped.png').convert_alpha()
self.dotSelectedImage = pygame.image.load(
'assets/images/dot-selected.png').convert_alpha()
languageButtonImage = pygame.image.load(
'assets/images/language-button-normal.png').convert()
languageButtonTappedImage = pygame.image.load(
'assets/images/language-button-tapped.png').convert()
languageButtonSelectedImage = pygame.image.load(
'assets/images/language-button-selected.png').convert()
self.languageButtons = []
for i in range(len(self.config.getLanguages())):
language = self.config.getLanguages()[i]
languageFont = pygame.font.Font(
language['fonts']['textFont']['filename'],
language['fonts']['textFont']['size'])
languageButton = LanguageButton(
self.screen,
Rect(i * 63 + 15, 1010, languageButtonImage.get_width(),
languageButtonImage.get_height()), languageButtonImage,
languageButtonTappedImage, languageButtonSelectedImage,
language['buttonText'], DOT_TEXT_COLOR,
DOT_SELECTED_TEXT_COLOR, DOT_SELECTED_TEXT_COLOR, languageFont,
partial(self.languageClicked, i))
if language['prefix'] == self.config.languagePrefix:
languageButton.visible = False
self.languageButtons.append(languageButton)
self.buttons.append(languageButton)
self.dots = self.config.getDots()
self.dotButtons = []
for i in range(len(self.dots)):
dot = self.dots[i]
x = dot['x']
y = dot['y']
dotButton = Button(
self.screen,
Rect(x - self.dotImage.get_width() // 2,
y - self.dotImage.get_height() // 2,
self.dotImage.get_width(), self.dotImage.get_height()),
self.dotImage, self.dotTappedImage, str(i + 1), DOT_TEXT_COLOR,
DOT_SELECTED_TEXT_COLOR, self.numbersFont,
partial(self.dotClicked, i), 1.5)
self.dotButtons.append(dotButton)
self.buttons.append(dotButton)
self.selectedDotIndex = 0
self.loadDot()
Log.getLogger().info('INIT')
self.loop()
def edit_view(self):
id = request.args.get('id')
return_url = get_redirect_target() or self.get_url('.index_view')
model = self.get_one(id)
if model is None:
flash('Record does not exist.', 'error')
return redirect(return_url)
form = self.edit_form(obj=model)
if self.validate_form(form):
if self.update_model(form, model):
config = Config.get()
filename = '%s/src/py/model/%s.py' % (config['appRoot'],
form.class_name.data)
with open(filename, 'w') as f:
f.write(form.source.data)
flash('Record was successfully saved.', 'success')
return redirect(request.url)
if request.method == 'GET':
self.on_form_prefill(form, id)
if not form.source.data:
form.source.data = '''
#!/usr/bin/env python
# -*- encoding:utf-8 -*-
#
from .ModelBase import ModelBase
class %s(ModelBase):
"""
模型类：
编写算法时，需要重写onTick、tradeSuccess以及tradeCancel方法
onTick：当有Tick信号时触发
tradeSuccess：下单成功时触发
tradeCancel：订单撤销时触发
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
可用变量：
self.appConfig: 应用配置，在Config配置中，appKey所对应的配置项
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
可用方法：
self.tradeNormal(iid='', price=3690, volume=2, isOpen=True, isBuy=True, isToday=True)
该方法用于下普通单，直到成交，触发tradeSuccess方法，
可手动撤单，撤单成功后会触发tradeCancel方法
self.tradeFAK(iid='', price=3690, volume=2, isOpen=True, isBuy=True, isToday=True)
该方法用于下FAK单，触发tradeSuccess或tradeCancel方法
self.tradeFOK(iid='', price=3690, volume=2, isOpen=True, isBuy=True, isToday=True)
该方法用于下FOK单，触发tradeSuccess或tradeCancel方法
self.tradeIOC(iid='', price=3690, volume=2, isOpen=True, isBuy=True, isToday=True)
该方法用于下市价单，涨跌停情况外，触发tradeSuccess方法
以上全部方法均返回tradeId，tradeId为此次交易的唯一订单ID，
可用于追踪订单
self.cancel(iid, tradeId)
该方法用于撤单
"""
def __init__(self, appKey, tradeSrv):
super(%s, self).__init__(appKey, tradeSrv)
def onTick(self, tick):
"""
tick：Dict
{
'iid': 'hc1808', // 合约
'price': 3400, // 最新价
'volume': 340, // 数量
'bidPrice1': 3333,
'bidVolume1': 300,
'askPrice1': 3322,
'askVolume1': 33,
'time': '20180312 11:23:44', // 时间
'msec': 500, // 毫秒
}
"""
pass
def tradeSuccess(self, tradeId, dealPrice, dealVolume):
"""
tradeId: String 订单号
dealPrice: Float 成交价
dealVolume: Int 成交量
"""
pass
def tradeCancel(self, tradeId):
pass
''' % (form.class_name.data, form.class_name.data)
template = self.edit_template
return self.render(template,
id=id,
model=model,
form=form,
return_url=return_url)
def UrlDecoderHook(s):
sid = s.get("sessionId")
bs = s.get("brokerserver")
return Dest(sid, bs)
def UrlDecoder(s):
return json.loads(s, object_hook=UrlDecoderHook)
if __name__ == '__main__':
print "case0##############"
conf = Config('../../conf/client.conf')
qi = DestQueryInfo(Authentication("tt", "2"), "test1", "1", "20000")
print qi
dest = Destination(conf)
url = dest.getDest(qi)
print url
dest.destroy()
print "case1##############"
testUrl = "{\"sessionId\":\"8045f5cb0521c82598584f3151b1a1d5\",\"brokerserver\":[\"dwbasis130001.sqa.cm4:39903\", \"er2\"]}"
dest = UrlDecoder(testUrl)
print dest.sessionId
print dest.brokerserver
print dest.brokerserver[0]
print dest.brokerserver[1]
def build(self):
config = Config.get()
appRoot = config['appRoot']
ctpConfig = config['ctpConfig']
self.cmd = "%s/%s %s/%s" % (appRoot, self.cmd, appRoot, ctpConfig)
Created on 2010-10-22
@author: jiugao
'''
from client.Authentication import Authentication
from client.Tunnel import Tunnel
from common.Config import Config
from connection.TunnelConnection import TCPool
from destination.Destination import Destination
from message.MessageFactory import MessageFactory
import os.path
basepath = os.path.dirname(__file__)
auth = None
conf = Config(basepath + '/../../conf/client.conf')
destination = Destination(conf)
tcPool = TCPool(destination)
def set_router(urls):
conf.setRouters(urls)
def use(passport):
global auth
oldAuth = auth
auth = passport
return oldAuth
def passport(user, pwd):
return Authentication(user, pwd)
def build(self):
config = Config.get()
appRoot = config['appRoot']
self.cmd = "CTP_CONFIG_PATH=%s python %s/%s %s" % (os.environ.get('CTP_CONFIG_PATH'), appRoot, self.cmd, self.globalId)
