def __init__(self, eventEngine, gatewayName='IB'):
"""Constructor"""
super(IbGateway, self).__init__(eventEngine, gatewayName)
self.host = EMPTY_STRING # 连接地址
self.port = EMPTY_INT # 连接端口
self.clientId = EMPTY_INT # 用户编号
self.tickerId = 0 # 订阅行情时的代码编号
self.tickDict = {} # tick快照字典，key为tickerId，value为VtTickData对象
self.tickProductDict = {} # tick对应的产品类型字典，key为tickerId，value为产品类型
self.orderId = 0 # 订单编号
self.orderDict = {} # 报单字典，key为orderId，value为VtOrderData对象
self.accountDict = {} # 账户字典
self.contractDict = {} # 合约字典
self.subscribeReqDict = {} # 用来保存订阅请求的字典
self.connected = False # 连接状态
self.wrapper = IbWrapper(self) # 回调接口
self.connection = EClientSocket(self.wrapper) # 主动接口
def __init__(self,
name=None,
call_msg=True,
host=None,
port=None,
client_id=None):
self.name = name
self.host = host
self.port = port
self.client_id = client_id
self.ref_nums = [0]
self.wrapper = SyncWrapper()
self.connection = EClientSocket(self.wrapper)
self.account = self.wrapper.account
self.contracts = self.wrapper.contracts
self.executions_ = self.wrapper.executions
self.order_messages = self.wrapper.order_messages
if self.host is None:
self.host = 'localhost'
if self.port is None:
self.port = 7496
if call_msg is False:
self.wrapper.suppress = True
if self.client_id is None:
self.client_id = 0
# listen to execution
#self.wrapper.register(self.method, events='execution')
self.__connect__ = self.connection.eConnect(self.host, self.port,
self.client_id)
self.__gen_order_id__(1)
sleep(.2)
def getMktData():
callback = IBWrapper()
callback.initiate_variables()
tws_conn = EClientSocket(callback)
tws_conn.eConnect("", 7497, 110)
# market data connection)
# tws_conn = Connection.create(port=7497, clientId=110) # now there is a problem: I have to change clientId every time to avoid usfarm issue
# tws_conn.connect()
# tws.connect()
# Assign the handling function defined above
# tws_conn.register(error_handler, 'Error')
# tws_conn.registerAll(reply_handler)
create = contract()
contract_info = create.create_contract('EUR', 'CASH', 'IDEALPRO', 'USD')
tickedId = 1002
sleep(10)
tws_conn.reqMktData(tickedId, contract_info, "", False)
sleep(10)
# tws_conn.disconnect()
tick_data = pd.DataFrame(
callback.tick_Price,
columns=['ticketId', 'field', 'price', 'canAutoExecute'])
# print(tick_data)
return tick_data
def __init__(self, host='localhost', port=7496, clientId=0):
self.host = host
self.port = port
self.clientId = clientId
self.parameters = settings.TradeParameters()
self.wrapper = ReferenceWrapper(self.parameters)
self.connection = EClientSocket(self.wrapper)
def __init__(self, host='127.0.0.1', port=7496, clientId=0):
self.host = host
self.port = port
self.clientId = clientId
self.wrapper = ReferenceWrapper()
self.connection = EClientSocket(self.wrapper)
self.logger = make_logger(self)
if not self.logger.handlers:
self.logger.addHandler(logging.StreamHandler())
def __init__(self, parameters):
# Variable initialization
#self.orders = orders.OrderBook()
#self.price_log = data.PriceLog()
#self.parameters = parameters
self.connection = EClientSocket(self)
self.connection.eConnect('localhost', 7496, 0) # host, port, clientId
tick_id = 1
symbol = "SLV"
contract = self.makeContract(symbol)
self.connection.reqMktData(tick_id, contract, [], False)
def __init__(self, account_name: str, host: str, port: int,
client_id: int):
self.account_name = account_name
# Instantiate IBWrapper callback.
self.callback = IBWrapper()
# Instantiate EClientSocket and return data to callback
self.tws = EClientSocket(self.callback)
# Connect to TWS.
self.tws.eConnect(host, port, client_id)
# Instantiate contract class.
self.create = contract()
self.callback.initiate_variables()
def __init__(self, host, port, client_id):
"""
TODO: 不应该维护一个巨大的类，可以考虑使用混合模式来管理这个类
:host:地址
:port:接口
:client_id:这个可以随便写一个,int
:req_id:请求id
"""
self.host = host
self.port = port
self.client_id = client_id
self.warpper = IbTestWrapper()
self.connection = EClientSocket(self.warpper)
self.req_id = 0
def __init__(self, host, port, clientId, kafka_host, kafka_port, config):
super(TWS_gateway, self).__init__()
self.config = config
self.host = host
self.port = port
self.clientId = clientId
self.ib_order_transmit = config.get("tws_gateway", "tws_gateway.order_transmit").strip('"').strip("'") if \
config.get("tws_gateway", "tws_gateway.order_transmit").strip('"').strip("'") <> None\
else False
logging.info('starting up TWS_gateway...')
logging.info('Order straight through (no-touch) flag = %s' %
('True' if self.ib_order_transmit == True else 'False'))
logging.info('connecting to Redis server...')
self.initialize_redis(config)
logging.info('starting up TWS_event_handler...')
self.tws_event_handler = TWS_event_handler(kafka_host, kafka_port)
logging.info('starting up IB EClientSocket...')
self.connection = EClientSocket(self.tws_event_handler)
logging.info('starting up client request handler - kafkaConsumer...')
self.cli_request_handler = KafkaConsumer( *[(v,0) for v in list(TWS_Protocol.topicMethods) + list(TWS_Protocol.gatewayMethods) ], \
metadata_broker_list=['%s:%s' % (kafka_host, kafka_port)],\
group_id = 'epc.tws_gateway',\
auto_commit_enable=True,\
auto_commit_interval_ms=30 * 1000,\
auto_offset_reset='largest') # discard old ones
self.reset_message_offset()
if not self.eConnect():
logging.error(
'TWS_gateway: unable to establish connection to IB %s:%d' %
(self.host, self.port))
sys.exit(-1)
else:
# start heart beat monitor
logging.info('starting up IB heart beat monitor...')
self.tlock = Lock()
self.ibh = IbHeartBeat(config)
self.ibh.register_listener([self.on_ib_conn_broken])
self.ibh.run()
logging.info('starting up subscription manager...')
self.initialize_subscription_mgr()
def __init__(self, host, port, client_id, req_dict, tick_dict, redis,
mongo_db):
"""
TODO: 不应该维护一个巨大的类，可以考虑使用混合模式来管理这个类
:host:地址
:port:接口
:client_id:这个可以随便写一个,int
:req_id:请求id
:redis:redis实例
"""
self.host = host
self.port = port
self.client_id = client_id
self.warpper = IbTestWrapper(req_dict, tick_dict, mongo_db)
self.connection = EClientSocket(self.warpper)
self.req_id = 0
self.req_dict = req_dict
self.tick_dict = tick_dict
self.redis = redis
def __init__(self, client_name='IB', host='localhost', port=7496, client_id=0):
"""Constructor"""
self.client_name = client_name
self.host = host # host IP address in a string; e.g. '127.0.0.1', 'localhost'
self.port = port # socket port; TWS default value: 7496; TWS demo account default value: 7497
self.client_id = client_id # socket client id
self.connected = False # status of the socket connection
self.tickerId = 0 # known as ticker ID or request ID
self.ipc_msg_dict = {} # key: ticker ID or request ID; value: request and response objects; response objects ususally carrys data, Events, and Status
self.order_id = 0 # current available order ID
self.order_dict = {} # key: ticker ID or request ID; value: request and response objects; response objects ususally carrys data, Events, and Status
self.context = None # key: ticker ID or request ID; value: request and response objects; response objects ususally carrys data, Events, and Status
self.data = None
self.wrapper = IBMsgWrapper(self) # the instance with IB message callback methods
self.connection = EClientSocket(self.wrapper) # low layer socket client
# TWS's data connection status
self.hmdf_status_dict = {}
for farm in IB_FARM_NAME_LS:
self.hmdf_status_dict[farm] = 'unknown'
# EVENTS
self.conn_down_event = Event() # sock connection event
self.mdf_conn_event = Event() # market data connection event
self.hdf_conn_event = Event() # hist data connection event
self.order_event = Event()
self.account_event = Event()
self.get_order_event = Event()
# LOCKER
self.req_id_locker = threading.Lock()
# CONSTANT VALUES
self.PRICE_DF_HEADER1 = ['time', 'open', 'high', 'low', 'close', 'volume']
self.PRICE_DF_HEADER2 = ['symbol', 'time', 'open', 'high', 'low', 'close', 'volume']
def __init__(self, host, port, strategies, instruments, logger):
self.msgs = queue.Queue()
self.book_builder = BookBuilder()
# strategies
self.instruments = instruments
self.contracts = dict()
self.strategies = []
for strategy in strategies:
strat = Recoil2(strategy['watch_threshold'],
strategy['watch_duration'],
strategy['slowdown_threshold'],
strategy['slowdown_duration'])
self.strategies.append(strat)
# operations
self.host = host
self.port = port
self.connection = EClientSocket(Connector(self.instruments, self.msgs))
self.next_id = None
self.log = logger
def __init__(self, datadecoder):
self.accountName = "asd781820"
self.callback = IBWrapper()
self.tws = EClientSocket(self.callback)
self.host = ""
self.port = 4002
self.clientId = 8
self.tws.eConnect(self.host, self.port, self.clientId)
self.dd = datadecoder
self.create = contract()
self.callback.initiate_variables()
self.callback.initiate_variables()
self.tws.reqAccountSummary(8, 'All', 'TotalCashValue')
self.filedf = datadecoder.usabledf
self.datadecoder = datadecoder
contract_Details = self.create.create_contract('EUR', 'CASH',
'IDEALPRO', 'USD')
tickerId = 10000
self.tws.reqRealTimeBars(tickerId, contract_Details, 5, "MIDPOINT", 0)
self.tickerId = 9010
self.df = pd.read_csv('df.csv')
self.RbinDict = bqe.makeRDf(self.df)
self.column_index_value_dict, self.binDict = bqe.makeDf(self.df)
def connect(self):
self._wrapper = ReferenceWrapper()
self._connection = EClientSocket(self._wrapper)
self._connection.eConnect(IB_HOST, IB_PORT, IB_CLIENT_ID)
###start of intializations
tf1 = 1
tf2 = 1
new_entry = 'T'
wdw = 25
ctime = 0
r_sflag = 0
r_qty = 0
cnt = 0
global o_type ,order_id
# end of intializations
callback = IBWrapper()
tws = EClientSocket(callback)
host = ""
port = 7497
clientId = 100
create = contract()
callback.initiate_variables()
tws.eConnect(host, port, clientId)
print("connected")
####dummy data request
contract_Details1 = create.create_contract("ES" ,"FUT" ,"GLOBEX" ,"USD" ,'' ,'' ,'20170616' ,'50')
tickerId = random.randint(1, 1000000)
# print(datetime.now())
tws.reqRealTimeBars(tickerId,
contract_Details1,
5,
"TRADES",
def __init__(self,
host='localhost',
port=7496,
client_id=0,
client_name='IB'):
"""
Args:
host: TWS 所在机器的 IP或域名
port: TWS配置的接收外部API的端口.TWS default value: 7496; TWS demo account default value: 7497
client_id: API<->TWS之间 sock连接的ID
client_name: 本次连接的名字。可选
"""
self.client_name = client_name
self.host = host # host IP address in a string; e.g. '127.0.0.1', 'localhost'
self.port = port # socket port;
self.client_id = client_id # socket client id
self.tickerId = 0 # known as ticker ID or request ID
self.ipc_msg_dict = {
} # key: ticker ID or request ID; value: request and response objects; response objects ususally carrys data, Events, and Status
self.order_id = 0 # current available order ID
self.order_history = {
} # key: ticker ID or request ID; value: request and response objects; response objects ususally carrys data, Events, and Status
# dict to store market depth data; key: (client_id, request_id)
self.market_depth_buffer = dict()
self.context = None # key: ticker ID or request ID; value: request and response objects; response objects ususally carrys data, Events, and Status
self.portfolio = None
self.account = None
self.wrapper = IBMsgWrapper(
self) # the instance with IB message callback methods
self.connection = EClientSocket(
self.wrapper) # low layer socket client
# TWS's data connection status
self.hmdf_status_dict = {}
for farm in IB_FARM_NAME_LS:
self.hmdf_status_dict[farm] = 'unknown'
# EVENTS
self.conn_down_event = Event() # sock connection event
self.mdf_conn_event = Event() # market data connection event
self.hdf_conn_event = Event() # hist data connection event
self.order_event = Event()
self.account_event = Event()
self.get_order_event = Event()
self.tick_snapshot_req_end = Event()
# LOCKER
self.req_id_locker = threading.Lock()
# Order ID cond
self.order_id_cond = threading.Condition()
# CONSTANT VALUES
self.PRICE_DF_HEADER1 = [
'time', 'open', 'high', 'low', 'close', 'volume'
]
self.PRICE_DF_HEADER2 = [
'symbol', 'time', 'open', 'high', 'low', 'close', 'volume'
]
numId = 0
if __name__ == '__main__':
cid = 10 # clientId: can be any number. It will show on IBGateway as folder/different user
orderId = 1 # orderId
accountId = 'DU594416'
symbolId = '???' # contract identifier id or asset id?
port = 4002
# =============================================================================
# ESTABLISH CONNECTION
# =============================================================================
# instantiate data in IBWrapper, still need to use this as EWrapper
# is an abstract object
data = IBWrapper()
tws = EClientSocket(data)
tws.eConnect('localhost' , port, cid)
# Initiate attributes to receive data (REQUIRED)
data.initiate_variables()
# =============================================================================
# =============================================================================
'''
# =============================================================================
# UPDATE YOUR PORTFOLIO WITH 2 ALTERNATIVES FUNCTION
# =============================================================================
# 1. update account: reqAccountUpdates(subscribe, accountId)
# subscribe: 0 - update Acc Time, 1 - update Acc Val, 2 - update Portfolio
tws.reqAccountUpdates(2, accountId)
# time (1 sec) is REQUIRED to get data, otherwise empty list
import time
from datetime import datetime
from IBWrapper import IBWrapper, contract
from ib.ext.EClientSocket import EClientSocket
from ib.ext.ScannerSubscription import ScannerSubscription
from __future__ import print_function
if __name__ == "__main__":
callback = IBWrapper() # Instantiate IBWrapper
tws = EClientSocket(callback) # Instantiate EClientSocket
host = ""
port = 7496
clientId = 5000
tws.eConnect(host, port, clientId) # Connect to TWS
tws.setServerLogLevel(5)
accountName = "DU123456" # Change to your own account
create = contract() # Instantiate contract class
# Initiate attributes to receive data. At some point we need a separate class for this
callback.initiate_variables()
# Account and Portfolio ##############################################################
# reqAccountUpdates ---> updateAccountTime self.update_AccountTime
# updateAccountValue self.update_AccountValue
# updatePortfolio self.update_Portfolio
# accountDownloadEnd self.accountDownloadEnd_flag
# reqAccountSummary ---> accountSummary self.account_Summary
# cancelAccountSummary
# accountSummaryEnd self.account_SummaryEnd_flag
# reqPositions ---> position self.update_Position
# cancelPositions
def __init__(self, host='localhost', port=7496, clientId=0):
self.host = host
self.port = port
self.clientId = clientId
self.wrapper = ReferenceWrapper()
self.connection = EClientSocket(self.wrapper)
print(df_order_status)
print(
"###############################################################\n"
)
else:
print(
"\n###################### No orders to show #######################\n"
)
return df_order_status
# Establish connection ----------------------------------------------------------------------
#accountName = "Your Account Name Here"
callback = IBWrapper() # Instantiate IBWrapper. callback
tws = EClientSocket(
callback) # Instantiate EClientSocket and return data to callback
host = ""
port = 4002
clientId = 8
tws.eConnect(host, port, clientId) # Connect to TWS
create = contract() # Instantiate contract class
callback.initiate_variables()
tws.reqAccountUpdates(1, accountName)
# Portfolio Query ------------------------------------------------------------
ib = IB()
df_portfolio = ib.portfolio()
count = len(df_portfolio)
# Disconnect ------------------------------------------------------------------
