def event_connect(err_code):
if err_code == 0:
rlogger.info('Connected to KIWOOM Server')
ax_obj.OnReceiveTrData.connect(receive_trdata)
header = stream_readwriter.create_header(message.COLLECTOR, message.MARKET_STOCK, message.COLLECTOR_DATA, message.KIWOOM)
body = {'capability': message.CAPABILITY_REQUEST_RESPONSE}
stream_readwriter.write(sock, header, body)
def stream_write(sock, header, body, manager=None):
try:
stream_readwriter.write(sock, header, body)
except Exception as e:
logger.error('Stream write error ' + str(e))
if manager is not None:
manager.handle_disconnect(e.args[1])
def receive_trdata(screen_no, rqname, trcode, recordname, prev_next, data_len, err_code, msg1, msg2):
if prev_next == '2': #TODO
pass
if rqname in request_dict:
data = request_dict[rqname]
if data[2] == message.INVESTOR_ACCUMULATE_DATA:
result = investor_accumulate.get_data(ax_obj, rqname, trcode)
stream_readwriter.write(data[0], data[1], result)
request_dict.pop(rqname, None)
def run(client_name, client_type, client_index, client_count_info):
global _sock, _client_name
app = QCoreApplication([])
while True:
try:
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
server_address = (message.SERVER_IP, message.CLIENT_SOCKET_PORT)
sock.connect(server_address)
sock.settimeout(None)
print('Connected to apiserver')
break
except socket.error:
print('Retrying connect to apiserver')
time.sleep(1)
_sock = sock
socket_notifier = QtCore.QSocketNotifier(sock.fileno(),
QtCore.QSocketNotifier.Read)
socket_notifier.activated.connect(dispatch_message)
header = stream_readwriter.create_header(message.COLLECTOR,
message.MARKET_STOCK,
message.COLLECTOR_DATA)
body = {}
body['capability'] = message.CAPABILITY_COLLECT_SUBSCRIBE
body['name'] = client_name + '_COL' + str(client_index)
_client_name = body['name']
stream_readwriter.CLIENT_NAME = _client_name
stream_readwriter.write(sock, header, body)
app.exec_()
def callback_stock_subscribe(code, datas):
header = stream_readwriter.create_header(message.SUBSCRIBE_RESPONSE,
message.MARKET_STOCK,
message.STOCK_DATA)
header['code'] = code
stream_readwriter.write(_sock, header, datas)
def callback_trade_subscribe(result):
header = stream_readwriter.create_header(message.TRADE_SUBSCRIBE_RESPONSE,
message.MARKET_STOCK,
message.TRADE_DATA)
stream_readwriter.write(_sock, header, result)
def callback_alarm_subscribe(datas):
header = stream_readwriter.create_header(message.SUBSCRIBE_RESPONSE,
message.MARKET_STOCK,
message.ALARM_DATA)
header['code'] = message.STOCK_ALARM_CODE
stream_readwriter.write(_sock, header, datas)
def callback_index_subscribe(code, datas):
header = stream_readwriter.create_header(message.SUBSCRIBE_RESPONSE,
message.MARKET_STOCK,
message.INDEX_DATA)
header['code'] = code + message.INDEX_SUFFIX
stream_readwriter.write(_sock, header, datas)
def run(client_name, client_type, client_index, client_count_info):
global account, _sock, _client_name
app = QCoreApplication([])
conn = connection.Connection()
while True:
try:
if conn.is_connected():
break
else:
print('Retry connecting to CP Server')
time.sleep(5)
except:
print('Error while trying to server')
print('Connected to CP Server')
while True:
try:
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
server_address = (message.SERVER_IP, message.CLIENT_SOCKET_PORT)
sock.connect(server_address)
sock.settimeout(None)
print('Connected to apiserver')
break
except socket.error:
print('Retrying connect to apiserver')
time.sleep(1)
_sock = sock
socket_notifier = QtCore.QSocketNotifier(sock.fileno(),
QtCore.QSocketNotifier.Read)
socket_notifier.activated.connect(dispatch_message)
header = stream_readwriter.create_header(message.COLLECTOR,
message.MARKET_STOCK,
message.COLLECTOR_DATA)
body = {'client_count_info': client_count_info}
if client_type == message.CAPABILITY_TRADE:
body['capability'] = message.CAPABILITY_TRADE
body['name'] = client_name + '_TR' + str(client_index)
elif client_type == message.CAPABILITY_REQUEST_RESPONSE:
body['capability'] = message.CAPABILITY_REQUEST_RESPONSE
body['name'] = client_name + '_REQ' + str(client_index)
elif client_type == message.CAPABILITY_COLLECT_SUBSCRIBE:
body['capability'] = message.CAPABILITY_COLLECT_SUBSCRIBE
body['name'] = client_name + '_COL' + str(client_index)
elif client_type == message.CAPABILITY_TRADE_SUBSCRIBE:
body['capability'] = message.CAPABILITY_TRADE_SUBSCRIBE
body['name'] = client_name + '_TRCOL' + str(client_index)
if 'name' in body:
_client_name = body['name']
stream_readwriter.CLIENT_NAME = _client_name
stream_readwriter.write(sock, header, body)
if body['capability'] & message.CAPABILITY_TRADE or body[
'capability'] & message.CAPABILITY_TRADE_SUBSCRIBE:
account = trade_util.TradeUtil()
print('HAS TRADE CAPABILITY')
app.exec_()
def handle_request(sock, header, body):
print(_client_name, 'REQUEST ' + str(header))
header['type'] = message.RESPONSE
if header['method'] == message.SHUTDOWN:
shutdown.go_shutdown()
elif header['method'] == message.DAY_DATA:
_, data = stock_chart.get_day_period_data(header['code'],
header['from'],
header['until'])
stream_readwriter.write(sock, header, data)
elif header['method'] == message.MINUTE_DATA:
_, data = stock_chart.get_min_period_data(header['code'],
header['from'],
header['until'])
stream_readwriter.write(sock, header, data)
elif header['method'] == message.TODAY_MINUTE_DATA:
_, data = stock_today_data.get_today_min_data(header['code'])
stream_readwriter.write(sock, header, data)
elif header['method'] == message.TODAY_TICK_DATA:
_, data = stock_today_data.get_today_tick_data(header['code'])
stream_readwriter.write(sock, header, data)
elif header['method'] == message.ABROAD_DATA:
_, data = abroad_chart.get_period_data(header['code'],
header['period_type'],
header['count'])
stream_readwriter.write(sock, header, data)
elif header['method'] == message.CODE_DATA:
if header['market_type'] == message.KOSPI:
stream_readwriter.write(sock, header,
stock_code.get_kospi_company_code_list())
elif header['market_type'] == message.KOSDAQ:
stream_readwriter.write(sock, header,
stock_code.get_kosdaq_company_code_list())
elif header['method'] == message.CODE_TO_NAME_DATA:
stream_readwriter.write(sock, header,
stock_code.code_to_name(header['code']))
elif header['method'] == message.USCODE_DATA:
data = stock_code.get_us_code(header['us_type'])
stream_readwriter.write(sock, header, data)
elif header['method'] == message.INVESTOR_DATA:
data = investor_7254.check_investor_trend(header['code'],
header['from'],
header['until'])
stream_readwriter.write(sock, header, data)
elif header['method'] == message.UNI_CURRENT_DATA:
stream_readwriter.write(sock, header,
stock_uni_chart.get_uni_data(header['code']))
elif header['method'] == message.UNI_DATA:
stream_readwriter.write(
sock, header, stock_uni_chart.get_uni_week_data(header['code']))
def handle_trade_request(sock, header, body):
print(_client_name, 'TRADE REQUEST ' + str(header))
header['type'] = message.RESPONSE_TRADE
if header['method'] == message.GET_LONG_LIST:
lm = long_manifest_6033.LongManifest(account.get_account_number(),
account.get_account_type())
stream_readwriter.write(sock, header, lm.get_long_list())
elif header['method'] == message.BALANCE:
account_balance = balance.get_balance(account.get_account_number(),
account.get_account_type())
stream_readwriter.write(sock, header, {'balance': account_balance})
elif header['method'] == message.ORDER_STOCK:
code = header['code']
quantity = header['quantity']
price = header['price']
is_buy = header['trade_type'] == message.ORDER_BUY
status, msg = get_order_subscriber().process(
code, quantity, account.get_account_number(),
account.get_account_type(), price, is_buy)
result = {'status': status, 'msg': msg}
stream_readwriter.write(sock, header, result)
elif header['method'] == message.MODIFY_ORDER:
modify_order_obj = modify_order.ModifyOrder(
account.get_account_number(), account.get_account_type())
order_num = header['order_number']
code = header['code']
price = header['price']
new_order_num = modify_order_obj.modify_order(order_num, code, 0,
price)
result = {'order_number': new_order_num}
stream_readwriter.write(sock, header, result)
elif header['method'] == message.CANCEL_ORDER:
cancel_order_obj = cancel_order.CancelOrder(
account.get_account_number(), account.get_account_type())
order_num = header['order_number']
code = header['code']
amount = header['amount']
result = cancel_order_obj.cancel_order(order_num, code, amount)
result = {'result': result}
stream_readwriter.write(sock, header, result)
elif header['method'] == message.ORDER_IN_QUEUE:
order_queue = order_in_queue.OrderInQueue(account.get_account_number(),
account.get_account_type())
result = order_queue.request()
stream_readwriter.write(sock, header, result)
