desc
stringlengths 3
26.7k
| decl
stringlengths 11
7.89k
| bodies
stringlengths 8
553k
|
|---|---|---|
''
| def show_data(self, str_pcontract):
| (pcon, data) = self._gate.get_pcontract(str_pcontract)
self.candle_widget.plot_with_plotter('candles', data)
self._frame.load_data(data)
self.frame.draw_widgets()
return
|
'docstring for on_motion'
| def on_pick(self, event):
| six.print_('888888')
six.print_(str(event.mouseevent.xdata))
|
'docstring for on_motion'
| def on_move(self, event):
| if isinstance(event.xdata, np.float64):
i = (int(event.xdata) / 1)
if (self.pre_x != i):
six.print_(self.data.index[i])
six.print_(self.data[i])
c = ((pd.to_datetime(self.data.index[i]).strftime('%Y-%m-%d %H:%M:%S') + '\n') + 'hh')
self.fig.axes[2].set_xlabel(c)
self.pre_x = i
|
''
| @classmethod
def arg_to_type(cls, arg):
| tdict = {'BUY': 1, 'SHORT': 2, 'COVER': 3, 'SELL': 4, 'COVER_TODAY': 5, 'SELL_TODAY': 6, 'KAI': 7, 'PING': 8, 'CANCEL': 9}
if isinstance(arg, str):
return tdict[arg.upper()]
else:
return arg
|
''
| @classmethod
def arg_to_type(cls, arg):
| tdict = {'LMT': cls.LMT, 'MKT': cls.MKT}
if isinstance(arg, str):
return tdict[arg.upper()]
else:
return arg
|
''
| @classmethod
def arg_to_type(cls, arg):
| tdict = {'SPEC': cls.SPEC, 'HEDG': cls.HEDG}
if isinstance(arg, str):
return tdict[arg.upper()]
else:
return arg
|
''
| @classmethod
def arg_to_type(cls, arg):
| arg2type = {'LONG': cls.LONG, 'SHORT': cls.SHORT}
if isinstance(arg, str):
return arg2type[arg.upper()]
else:
return arg
|
'äžäžªææçå§æIDçŒå·ã'
| @classmethod
def next_order_id(cls):
| cls.order_id += 1
return OrderID(cls.order_id)
|
'Args:
new_price (float): ææ°ä»·æ Œã
Returns:
float. ä¿è¯éå çš'
| def order_margin(self, new_price):
| price = (self.price if self.contract.is_stock else new_price)
return (((price * self.quantity) * self._margin_ratio) * self.volume_multiple)
|
''
| def __str__(self):
| return ('%s.%s' % (self.code, self.exchange))
|
''
| @classmethod
def trading_interval(cls, contract):
| pass
|
'Args:
new_price (float): ææ°ä»·æ Œã
Returns:
float. çäºæ°é¢'
| def profit(self, new_price):
| profit = 0
if (self.direction == Direction.LONG):
profit += (((new_price - self.cost) * self.quantity) * self._volume_multiple)
else:
profit -= (((new_price - self.cost) * self.quantity) * self._volume_multiple)
return profit
|
''
| @property
def pre_margin(self):
| pass
|
'Args:
new_price (float): ææ°ä»·æ Œã
Returns:
float. è¯éå çš/åžåŒ'
| def position_margin(self, new_price):
| return (((new_price * self.quantity) * self._margin_ratio) * self._volume_multiple)
|
''
| def profit(self):
| direction = self.open.direction
if (direction == Direction.LONG):
return (((self.close.price - self.open.price) * self.open.quantity) * self.open.order.volume_multiple)
else:
return (((self.open.price - self.close.price) * self.open.quantity) * self.open.order.volume_multiple)
|
':arg bool color: Enables color support.
:arg string fmt: Log message format.
It will be applied to the attributes dict of log records. The
text between ``%(color)s`` and ``%(end_color)s`` will be colored
depending on the level if color support is on.
:arg dict colors: color mappings from logging level to terminal color
code
:arg string datefmt: Datetime format.
Used for formatting ``(asctime)`` placeholder in ``prefix_fmt``.
.. versionchanged:: 3.2
Added ``fmt`` and ``datefmt`` arguments.'
| def __init__(self, color=True, fmt=DEFAULT_FORMAT, datefmt=DEFAULT_DATE_FORMAT, colors=DEFAULT_COLORS):
| logging.Formatter.__init__(self, datefmt=datefmt)
self._fmt = fmt
self._colors = {}
if (color and _stderr_supports_color()):
fg_color = (curses.tigetstr('setaf') or curses.tigetstr('setf') or '')
if ((3, 0) < sys.version_info < (3, 2, 3)):
fg_color = unicode_type(fg_color, 'ascii')
for (levelno, code) in six.iteritems(colors):
self._colors[levelno] = unicode_type(curses.tparm(fg_color, code), 'ascii')
self._normal = unicode_type(curses.tigetstr('sgr0'), 'ascii')
else:
self._normal = ''
|
''
| def start(self):
| self._active = True
|
''
| def stop(self):
| self._active = False
|
'Args:
route (str): äºä»¶å
handler (function): åè°åœæ°
Returns:
Bool. æ¯åŠæ³šåæåã'
| def register(self, route, handler):
| if (route not in self._routes):
self._routes[route] = [handler]
return True
handlers = self._routes[route]
if (handler not in handlers):
handlers.append(handler)
return True
return False
|
''
| def unregister(self, route, handler):
| try:
handlerList = self._routes[route]
if (handler in handlerList):
handlerList.remove(handler)
if (not handlerList):
del self._routes[route]
except KeyError:
return
|
''
| @abc.abstractmethod
def emit(self, event):
| raise NotImplementedError
|
''
| @abc.abstractmethod
def _run(self):
| raise NotImplementedError
|
''
| def _process(self, event):
| if (event.route not in self._routes):
log.warning(('\xe4\xba\x8b\xe4\xbb\xb6%s \xe6\xb2\xa1\xe6\x9c\x89\xe8\xa2\xab\xe5\xa4\x84\xe7\x90\x86' % event.route))
return
for handler in self._routes[event.route]:
try:
log.debug(('\xe5\xa4\x84\xe7\x90\x86\xe4\xba\x8b\xe4\xbb\xb6%s' % event.route))
_thread.start_new_thread(handler, (event,))
except Exception as e:
log.error(e)
|
''
| def start(self):
| EventEngine.start(self)
self._thrd.start()
|
''
| def stop(self):
| EventEngine.stop(self)
|
''
| def _run(self):
| while (self._active == True):
try:
event = self._queue.get(block=True, timeout=1)
self._process(event)
except queue.Empty:
pass
|
'client or event'
| def emit(self, event):
| msg = Event.event_to_message(event)
self._emit_event_socket.send_string(msg)
return
|
''
| def start(self):
| EventEngine.start(self)
self._queue_engine.start()
self._thrd.start()
|
''
| def stop(self):
| EventEngine.stop(self)
self._queue_engine.stop()
self._context.destroy()
|
''
| def register(self, route, handler):
| if self._queue_engine.register(route, handler):
self._client_recv_event_socket.setsockopt(zmq.SUBSCRIBE, Event.message_header(route))
|
''
| def _run(self):
| poller = zmq.Poller()
poller.register(self._client_recv_event_socket, zmq.POLLIN)
if self._is_server:
poller.register(self._server_recv_event_socket, zmq.POLLIN)
while self._active:
socks = dict(poller.poll(1))
if ((self._client_recv_event_socket in socks) and (socks[self._client_recv_event_socket] == zmq.POLLIN)):
self._run_client()
if (self._is_server and (self._server_recv_event_socket in socks) and (socks[self._server_recv_event_socket] == zmq.POLLIN)):
self._run_server()
return
|
'containerå³å®æ¯åŠæ¯çº¿çšå®å
šçã
Args:
container (list or Queue): äºä»¶å®¹åš'
| def __init__(self, container=None):
| if container:
self._pool = container
|
''
| @property
def args(self):
| return self.data['data']
|
'ç»å®åæ°argsïŒåŒæ¥è°çšRPCServerçapinameæå¡,
è¿åç»æå䞺åè°åœæ°handlerçåæ°ã
Args:
apiname (str): æå¡APIå称ã
args (dict): ç»æå¡APIçåæ°ã
handler (function): åè°åœæ°ã'
| def call(self, apiname, args, handler):
| if (not isinstance(args, dict)):
raise InvalidRPCClientArguments(argtype=type(args))
assert (handler is not None)
log.debug(('RPCClient [%s] sync_call: %s' % (self._name, apiname)))
self.rid += 1
args['apiname'] = apiname
args['rid'] = self.rid
self._event_engine.emit(Event(self.EVENT_FROM_CLIENT, args))
with self._handlers_lock:
self._handlers[self.rid] = handler
|
'ç»å®åæ°argsïŒåæ¥è°çšRPCServerçapinameæå¡,
è¿å该æå¡çå€çç»æãåŠæè¶
æ¶ïŒè¿åNoneã
Args:
apiname (str): æå¡APIå称ã
args (dict): ç»æå¡APIçåæ°ã
handler (function): åè°åœæ°ã'
| def sync_call(self, apiname, args={}, timeout=5):
| log.debug(('RPCClient [%s] sync_call: %s' % (self._name, apiname)))
if (not isinstance(args, dict)):
self._timeout = 0
self._sync_ret = None
raise InvalidRPCClientArguments(argtype=type(args))
self.rid += 1
args['apiname'] = apiname
args['rid'] = self.rid
with self._sync_call_time_lock:
self._sync_call_time = datetime.now()
self._timeout = timeout
with self._handlers_lock:
self._handlers[self.rid] = None
self._event_engine.emit(Event(self.EVENT_FROM_CLIENT, args))
self._waiting_server_data()
ret = self._sync_ret
return ret
|
'Args:
route (str): æå¡å
handler (function): åè°åœæ°
Returns:
Bool. æ¯åŠæ³šåæåã'
| def register(self, route, handler):
| if (route in self._routes):
return False
with self._routes_lock:
self._routes[route] = handler
return True
|
''
| def unregister(self, route):
| with self._routes_lock:
if (route in self._routes):
del self._routes[route]
|
''
| def on_init(self, ctx):
| return
|
'éå纊éæ ¹k线è¿è¡'
| def on_symbol(self, ctx):
| return
|
'éæ ¹k线è¿è¡'
| def on_bar(self, ctx):
| return
|
''
| def on_exit(self, ctx):
| return
|
'Args:
scontexts (list): çç¥äžäžæéå
dcontexts (list): æ°æ®äžäžæéå
strpcon (str): äž»å纊
i (int): åœåprofileæ对åºçç»å玢åŒ'
| def __init__(self, scontexts, dcontexts, strpcon, i):
| self._marks = [ctx.marks for ctx in scontexts]
self._blts = [ctx.blotter for ctx in scontexts]
self._dcontexts = {}
self._ith_comb = i
self._main_pcontract = strpcon
for (key, value) in six.iteritems(dcontexts):
self._dcontexts[key] = value
|
'第j䞪çç¥çæææ亀æç», é»è®€è¿åç»åçæ亀æç»ã
Args:
j (int): 第j䞪çç¥
Returns:
list. [Transaction, ..]'
| def transactions(self, j=None):
| if (j is not None):
return self._blts[j].transactions
trans = []
for blt in self._blts:
trans.append(blt.transactions)
return trans
|
'第j䞪çç¥çæ¯ç¬äº€æ(äžåŒäžå¹³), é»è®€è¿åç»åçæ¯ç¬äº€æã
Args:
j (int): 第j䞪çç¥
Returns:
list. [OneDeal, ..]'
| def deals(self, j=None):
| ' \xe4\xba\xa4\xe6\x98\x93\xe4\xbf\xa1\xe5\x8f\xb7\xe5\xaf\xb9 '
positions = {}
deals = []
if (j is not None):
for trans in self.transactions(j):
self._update_positions(positions, deals, trans)
else:
for i in range(0, len(self._blts)):
deals += self.deals(i)
return deals
|
'第j䞪çç¥ç莊å·åå², é»è®€è¿åç»åç莊å·åå²ã
Args:
j (int): 第j䞪çç¥
Returns:
list. [{\'cash\', \'commission\', \'equity\', \'datetime\'}, ..]'
| def all_holdings(self, j=None):
| if (j is not None):
return self._blts[j].all_holdings
if (len(self._blts) == 1):
return self._blts[0].all_holdings
holdings = copy.deepcopy(self._blts[0].all_holdings)
for (i, hd) in enumerate(holdings):
for blt in self._blts[1:]:
rhd = blt.all_holdings[i]
hd['cash'] += rhd['cash']
hd['commission'] += rhd['commission']
hd['equity'] += rhd['equity']
return holdings
|
'Args:
j (int): 第j䞪çç¥
Returns:
dict. {\'cash\', \'commission\', \'history_profit\', \'equity\' }'
| def holding(self, j=None):
| if (j is not None):
return self._blts[j].holding
if (len(self._blts) == 1):
return self._blts[0].holding
holdings = copy.deepcopy(self._blts[0].holding)
for blt in self._blts[1:]:
rhd = blt.holding
holdings['cash'] += rhd['cash']
holdings['commission'] += rhd['commission']
holdings['equity'] += rhd['equity']
holdings['history_profit'] += rhd['history_profit']
return holdings
|
'è¿å第j䞪çç¥çç»åŸæ å¿éå'
| def marks(self, j=None):
| if (j is not None):
return self._marks[j]
return self._marks[0]
|
'è¿å第j䞪çç¥çææ , é»è®€è¿åç»åçææææ ã
Args:
j (int): 第j䞪çç¥
strpcon (str): åšæå纊
Returns:
dict. {ææ å:ææ }'
| def technicals(self, j=None, strpcon=None):
| pcon = (strpcon if strpcon else self._main_pcontract)
if (j is not None):
return {v.name: v for v in self._dcontexts[pcon].technicals[self._ith_comb][j].values()}
rst = {}
for j in range(0, len(self._blts)):
t = {v.name: v for v in self._dcontexts[pcon].technicals[self._ith_comb][j].values()}
rst.update(t)
return rst
|
'Args:
strpcon (str): åšæå纊ïŒåŠ\'BB.SHFE-1.Minute\'
Returns:
pd.DataFrame. æ°æ®'
| def data(self, strpcon=None):
| if (not strpcon):
strpcon = self._main_pcontract
strpcon = strpcon.upper()
return self._dcontexts[strpcon].raw_data
|
''
| def _update_positions(self, current_positions, deal_positions, trans):
| class PositionsDetail(object, ):
' \xe5\xbd\x93\xe5\x89\x8d\xe7\x9b\xb8\xe5\x90\x8c\xe5\x90\x88\xe7\xba\xa6\xe6\x8c\x81\xe4\xbb\x93\xe9\x9b\x86\xe5\x90\x88(\xe5\x8f\xaf\xe8\x83\xbd\xe4\xb8\x8d\xe5\x90\x8c\xe6\x97\xb6\xe9\x97\xb4\xe6\xae\xb5\xe4\xb8\x8b\xe5\x8d\x95)\xe3\x80\x82\n\n :ivar cost: \xe6\x8c\x81\xe4\xbb\x93\xe6\x88\x90\xe6\x9c\xac\xe3\x80\x82\n :ivar total: \xe6\x8c\x81\xe4\xbb\x93\xe6\x80\xbb\xe6\x95\xb0\xe3\x80\x82\n :ivar positions: \xe6\x8c\x81\xe4\xbb\x93\xe9\x9b\x86\xe5\x90\x88\xe3\x80\x82\n :vartype positions: list\n '
def __init__(self):
self.total = 0
self.positions = []
self.cost = 0
assert (trans.quantity > 0)
poskey = PositionKey(trans.contract, trans.direction)
p = current_positions.setdefault(poskey, PositionsDetail())
if (trans.side == TradeSide.KAI):
p.positions.append(trans)
p.total += trans.quantity
elif (trans.side == TradeSide.PING):
assert ((len(p.positions) > 0) and '\xe6\x89\x80\xe5\xb9\xb3\xe5\x90\x88\xe7\xba\xa6\xe6\xb2\xa1\xe6\x9c\x89\xe6\x8c\x81\xe4\xbb\x93')
left_vol = trans.quantity
last_index = 0
search_index = 0
p.total -= trans.quantity
if trans.contract.is_stock:
for position in reversed(p.positions):
if (position.datetime.date() < trans.datetime.date()):
break
search_index -= 1
if (search_index != 0):
positions = p.positions[:search_index]
left_positions = p.positions[search_index:]
else:
positions = p.positions
for position in reversed(positions):
if (position.quantity < left_vol):
left_vol -= position.quantity
last_index -= 1
deal_positions.append(OneDeal(position, trans, position.quantity))
elif (position.quantity == left_vol):
left_vol -= position.quantity
last_index -= 1
deal_positions.append(OneDeal(position, trans, position.quantity))
break
else:
position.quantity -= left_vol
left_vol = 0
deal_positions.append(OneDeal(position, trans, left_vol))
break
if ((last_index != 0) and (search_index != 0)):
p.positions = (positions[0:last_index] + left_positions)
elif (last_index != 0):
p.positions = positions[0:last_index]
assert ((left_vol == 0) or (last_index == 0))
|
''
| @abstractmethod
def update_signal(self, event):
| raise NotImplementedError('Should implement update_signal()')
|
''
| @abstractmethod
def update_fill(self, event):
| raise NotImplementedError('Should implement update_fill()')
|
'莊å·åå²æ
åµïŒæåäžæ ¹k线å€å¹³ææä»äœã'
| @property
def all_holdings(self):
| if self.positions:
self._force_close()
return self._all_holdings
|
'æ亀æç»ïŒæåäžæ ¹k线å€å¹³ææä»äœã'
| @property
def transactions(self):
| if self.positions:
self._force_close()
return self._all_transactions
|
''
| def update_data(self, ticks, bars):
| self._bars = bars
|
''
| def update_datetime(self, dt):
| if (self._datetime is None):
self._datetime = dt
self._start_date = dt
self._init_state()
elif (self._datetime.date() != dt.date()):
for order in self.open_orders:
if (order.side == TradeSide.PING):
pos = self.positions[PositionKey(order.contract, order.direction)]
pos.closable += order.quantity
self.open_orders.clear()
for (key, pos) in six.iteritems(self.positions):
pos.closable += pos.today
pos.today = 0
self._datetime = dt
|
''
| def update_status(self, dt, at_baropen):
| dh = {}
dh['datetime'] = dt
dh['commission'] = self.holding['commission']
pos_profit = 0.0
margin = 0.0
order_margin = 0.0
for (key, pos) in six.iteritems(self.positions):
bar = self._bars[key.contract]
new_price = (bar.open if at_baropen else bar.close)
pos_profit += pos.profit(new_price)
margin += pos.position_margin(new_price)
for order in self.open_orders:
assert (order.price_type == PriceType.LMT)
bar = self._bars[order.contract]
new_price = (bar.open if at_baropen else bar.close)
if (order.side == TradeSide.KAI):
order_margin += order.order_margin(new_price)
dh['equity'] = (((self._capital + self.holding['history_profit']) + pos_profit) - self.holding['commission'])
dh['cash'] = ((dh['equity'] - margin) - order_margin)
if (dh['cash'] < 0):
for key in six.iterkeys(self.positions):
if (not key.contract.is_stock):
raise Exception('\xe9\x9c\x80\xe8\xa6\x81\xe8\xbf\xbd\xe5\x8a\xa0\xe4\xbf\x9d\xe8\xaf\x81\xe9\x87\x91!')
self.holding['cash'] = dh['cash']
self.holding['equity'] = dh['equity']
self.holding['position_profit'] = pos_profit
if at_baropen:
self._all_holdings.append(dh)
else:
self._all_holdings[(-1)] = dh
|
'å¯èœäº§çäžç³»åorderäºä»¶ïŒåšbarçåŒçæ¶éŽäº€æã'
| def update_signal(self, event):
| assert (event.route == Event.SIGNAL)
new_orders = []
for order in event.orders:
errmsg = self._valid_order(order)
if (errmsg == ''):
order.datetime = self._datetime
new_orders.append(order)
if (order.side == TradeSide.KAI):
self.holding['cash'] -= order.order_margin(self._bars[order.contract].open)
else:
logger.warn(errmsg)
continue
self.open_orders.update(new_orders)
self._all_orders.extend(new_orders)
for order in new_orders:
self.api.order(copy.deepcopy(order))
for order in new_orders:
if (order.side == TradeSide.PING):
pos = self.positions[PositionKey(order.contract, order.direction)]
pos.closable -= order.quantity
|
''
| def update_fill(self, event):
| assert (event.route == Event.FILL)
trans = event.transaction
try:
self.open_orders.remove(trans.order)
except KeyError:
if (trans.order.side == TradeSide.CANCEL):
raise TradingError(err='\xe9\x87\x8d\xe5\xa4\x8d\xe6\x92\xa4\xe5\x8d\x95')
else:
assert (False and '\xe9\x87\x8d\xe5\xa4\x8d\xe6\x88\x90\xe4\xba\xa4')
self._update_holding(trans)
self._update_positions(trans)
|
''
| def _update_positions(self, trans):
| poskey = PositionKey(trans.contract, trans.direction)
if (trans.side == TradeSide.CANCEL):
pos = self.positions.get(poskey, None)
if pos:
pos.closable += trans.quantity
return
pos = self.positions.setdefault(poskey, Position(trans))
if (trans.side == TradeSide.KAI):
pos.cost = (((pos.cost * pos.quantity) + (trans.price * trans.quantity)) / (pos.quantity + trans.quantity))
pos.quantity += trans.quantity
if trans.contract.is_stock:
pos.today += trans.quantity
else:
pos.closable += trans.quantity
assert (pos.quantity == (pos.today + pos.closable))
elif (trans.side == TradeSide.PING):
pos.quantity -= trans.quantity
if (pos.quantity == 0):
del self.positions[poskey]
|
''
| def _update_holding(self, trans):
| if (trans.side == TradeSide.CANCEL):
return
self.holding['commission'] += trans.commission
if (trans.side == TradeSide.PING):
poskey = PositionKey(trans.contract, trans.direction)
flag = (1 if (trans.direction == Direction.LONG) else (-1))
profit = ((((trans.price - self.positions[poskey].cost) * trans.quantity) * flag) * trans.volume_multiple)
self.holding['history_profit'] += profit
self._all_transactions.append(trans)
|
''
| def _valid_order(self, order):
| if (order.quantity <= 0):
return '\xe4\xba\xa4\xe6\x98\x93\xe6\x95\xb0\xe9\x87\x8f\xe8\xa6\x81\xe5\xa4\xa7\xe4\xba\x8e0'
if (order.side == TradeSide.CANCEL):
if (order not in self.open_orders):
return '\xe6\x92\xa4\xe9\x94\x80\xe5\xa4\xb1\xe8\xb4\xa5\xef\xbc\x9a \xe4\xb8\x8d\xe5\xad\x98\xe5\x9c\xa8\xe8\xaf\xa5\xe8\xae\xa2\xe5\x8d\x95\xef\xbc\x81'
if (order.side == TradeSide.PING):
try:
poskey = PositionKey(order.contract, order.direction)
pos = self.positions[poskey]
if (pos.closable < order.quantity):
return '\xe5\x8f\xaf\xe5\xb9\xb3\xe4\xbb\x93\xe4\xbd\x8d\xe4\xb8\x8d\xe8\xb6\xb3'
except KeyError:
return ('\xe4\xb8\x8d\xe5\xad\x98\xe5\x9c\xa8\xe5\x90\x88\xe7\xba\xa6[%s]' % order.contract)
elif (order.side == TradeSide.KAI):
new_price = self._bars[order.contract].open
if (self.holding['cash'] < order.order_margin(new_price)):
return '\xe6\xb2\xa1\xe6\x9c\x89\xe8\xb6\xb3\xe5\xa4\x9f\xe7\x9a\x84\xe8\xb5\x84\xe9\x87\x91\xe5\xbc\x80\xe4\xbb\x93'
return ''
|
'åšåæµçæåäžæ ¹k线以closeä»·æ ŒåŒºå¹³æä»äœã'
| def _force_close(self):
| force_trans = []
if self._all_transactions:
price_type = self._all_transactions[(-1)].price_type
else:
price_type = PriceType.LMT
for pos in six.itervalues(self.positions):
order = Order(self._datetime, pos.contract, price_type, TradeSide.PING, pos.direction, self._bars[pos.contract].close, pos.quantity)
force_trans.append(Transaction(order))
for trans in force_trans:
self._update_holding(trans)
self._update_positions(trans)
if force_trans:
self.update_status(trans.datetime, False)
self.positions = {}
return
|
''
| def update_environment(self, dt, ticks, bars):
| self.blotter.update_datetime(dt)
self.exchange.update_datetime(dt)
self.blotter.update_data(ticks, bars)
self._datetime = dt
return
|
''
| def process_trading_events(self, at_baropen):
| if self._orders:
self.events_pool.put(SignalEvent(self._orders))
if (not self._orders):
self.events_pool.put(OnceEvent())
self._process_trading_events(at_baropen)
self._orders = []
|
''
| def _process_trading_events(self, at_baropen):
| while True:
try:
event = self.events_pool.get()
except queue.Empty:
assert False
except IndexError:
break
else:
if (event.route == Event.SIGNAL):
assert (not at_baropen)
self.blotter.update_signal(event)
elif (event.route == Event.ORDER):
assert (not at_baropen)
self.exchange.insert_order(event)
elif (event.route == Event.FILL):
self.blotter.api.on_transaction(event)
if ((event.route == Event.ONCE) or (event.route == Event.ORDER)):
self.exchange.make_market(self.blotter._bars, at_baropen)
self.blotter.update_status(self._datetime, at_baropen)
|
'Args:
name (str): æ å¿å称
ith_window (int): åšç¬¬å 䞪çªå£æŸç€ºïŒä»1åŒå§ã
x (datetime): æ¶éŽåæ
y (float): yåæ
styles (str): æ§å¶é¢è²ïŒçº¿çé£æ ŒïŒç¹çé£æ Œ
lw (int): 线宜
ms (int): ç¹ç倧å°'
| def plot_line(self, name, ith_window, x, y, styles, lw=1, ms=10, twinx=False):
| mark = self.marks[0].setdefault(name, [])
mark.append((ith_window, twinx, x, y, styles, lw, ms))
|
'Args:
name (str): æ å¿å称
ith_window (int): åšç¬¬å 䞪çªå£æŸç€ºïŒä»1åŒå§ã
x (float): xåæ
y (float): yåæ
text (str): ææ¬å
容
color (str): é¢è²
size (int): åäœå€§å°
rotation (float): æ蜬è§åºŠ'
| def plot_text(self, name, ith_window, x, y, text, color='black', size=15, rotation=0):
| mark = self.marks[1].setdefault(name, [])
mark.append((ith_window, x, y, text, color, size, rotation))
|
'Args:
orders (list/Order): æ€åïŒåæ°äžºlist衚瀺æ€å€äžªåã'
| def cancel(self, orders):
| orders = (orders if isinstance(orders, list) else [orders])
if (not self._cancel_now):
for order in orders:
norder = copy.deepcopy(order)
norder.side = TradeSide.CANCEL
self._orders.append(norder)
return
|
''
| @property
def open_orders(self):
| return self.blotter.open_orders
|
''
| def day_profit(self, contract):
| pass
|
''
| def rolling_forward(self):
| (self.new_row, self.last_curbar) = self._Helper.rolling_forward()
if (not self.new_row):
self.last_curbar -= 1
return (False, None)
self.next_datetime = self._Helper.data.index[self.last_curbar]
if ((self.datetime[0] >= self.next_datetime) and (self.curbar != 0)):
logger.error(('\xe5\x90\x88\xe7\xba\xa6[%s] \xe6\x95\xb0\xe6\x8d\xae\xe6\x97\xb6\xe9\x97\xb4\xe9\x80\x86\xe5\xba\x8f\xe6\x88\x96\xe5\x86\x97\xe4\xbd\x99' % self.pcontract))
raise
return (True, self.new_row)
|
'è·åçšæ·åšçç¥on_initåœæ°äžåå§åçåé'
| def get_item(self, name):
| return self._all_variables[self.ith_comb][self.ith_strategy][name]
|
''
| def add_item(self, name, value):
| if (self.ith_comb < len(self._all_variables)):
if (self.ith_strategy < len(self._all_variables[self.ith_comb])):
self._all_variables[self.ith_comb][self.ith_strategy][name] = value
else:
self._all_variables[self.ith_comb].append({name: value})
else:
self._all_variables.append([{name: value}])
if isinstance(value, SeriesBase):
self.add_series(name, value)
elif isinstance(value, TechnicalBase):
self.add_indicator(name, value)
else:
self.add_variable(name, value)
|
'æ·»å on_initäžåå§åçåºååé
Args:
attr (str): å±æ§å
s (Series): åºååé'
| def add_series(self, attr, s):
| s.reset_data([], self._size)
if (self.ith_comb < len(self._series)):
if (self.ith_strategy < len(self._series[self.ith_comb])):
self._series[self.ith_comb][self.ith_strategy][attr] = s
else:
self._series[self.ith_comb].append({attr: s})
else:
self._series.append([{attr: s}])
|
'æŽæ°ææ°tickä»·æ ŒïŒææ°barä»·æ Œ, ç¯å¢æ¶éŽã'
| def rolling_forward(self):
| if self._cur_data_context.new_row:
self.ctx_dt_series.curbar = self.ctx_curbar
self.ctx_datetime = min(self._cur_data_context.next_datetime, self.ctx_datetime)
try:
self.ctx_dt_series.data[self.ctx_curbar] = min(self._cur_data_context.next_datetime, self.ctx_datetime)
except IndexError:
self.ctx_dt_series.data.append(min(self._cur_data_context.next_datetime, self.ctx_datetime))
return True
(hasnext, data) = self._cur_data_context.rolling_forward()
if (not hasnext):
return False
self.ctx_dt_series.curbar = self.ctx_curbar
try:
self.ctx_dt_series.data[self.ctx_curbar] = min(self._cur_data_context.next_datetime, self.ctx_datetime)
except IndexError:
self.ctx_dt_series.data.append(min(self._cur_data_context.next_datetime, self.ctx_datetime))
self.ctx_datetime = min(self._cur_data_context.next_datetime, self.ctx_datetime)
return True
|
''
| def update_user_vars(self):
| self._cur_data_context.update_user_vars()
|
''
| def update_system_vars(self):
| self._cur_data_context.update_system_vars()
self._ticks[self._cur_data_context.contract] = self._cur_data_context.close[0]
self._bars[self._cur_data_context.contract] = self._cur_data_context.bar
oldbar = self._bars.setdefault(self._cur_data_context.contract, self._cur_data_context.bar)
if (self._cur_data_context.bar.datetime > oldbar.datetime):
self._bars[self._cur_data_context.contract] = self._cur_data_context.bar
|
''
| def __getitem__(self, strpcon):
| return DataContextAttributeHelper(self._data_contexts[strpcon.upper()])
|
''
| @property
def strategy(self):
| return self._cur_strategy_context.name
|
''
| @property
def pcontract(self):
| return self._cur_data_context.pcontract
|
''
| @property
def symbol(self):
| return str(self._cur_data_context.pcontract.contract)
|
'åœåæ¯ç¬¬å æ ¹k线, ä»1åŒå§'
| @property
def curbar(self):
| if self.on_bar:
return (self.ctx_curbar + 1)
else:
return self._cur_data_context.curbar
|
'k线åŒçä»·åºå'
| @property
def open(self):
| return self._cur_data_context.open
|
'k线æ¶çä»·åºå'
| @property
def close(self):
| return self._cur_data_context.close
|
'k线æé«ä»·åºå'
| @property
def high(self):
| return self._cur_data_context.high
|
'k线æäœä»·åºå'
| @property
def low(self):
| return self._cur_data_context.low
|
'k线æ亀éåºå'
| @property
def volume(self):
| return self._cur_data_context.volume
|
'k线æ¶éŽåºå'
| @property
def datetime(self):
| if self.on_bar:
return self.ctx_dt_series
else:
return self._cur_data_context.datetime
|
''
| @property
def open_orders(self):
| return list(self._cur_strategy_context.open_orders)
|
'Args:
price (float): ä»·æ Œ, 0è¡šåžä»·ã
quantity (int): æ°éã
symbol (str): å纊'
| def buy(self, price, quantity, symbol=None):
| if (not self.on_bar):
raise Exception('\xe5\x8f\xaa\xe6\x9c\x89on_bar\xe5\x87\xbd\xe6\x95\xb0\xe5\x86\x85\xe8\x83\xbd\xe4\xb8\x8b\xe5\x8d\x95\xef\xbc\x81')
if symbol:
contract = (Contract(symbol) if isinstance(symbol, str) else symbol)
else:
contract = self._cur_data_context.contract
price_type = (PriceType.MKT if (price == 0) else PriceType.LMT)
self._cur_strategy_context.buy(price, quantity, price_type, contract)
|
'Args:
price (float): ä»·æ Œ, 0è¡šåžä»·ã
quantity (int): æ°éã
symbol (str): å纊'
| def sell(self, price, quantity, symbol=None):
| if (not self.on_bar):
raise Exception('\xe5\x8f\xaa\xe6\x9c\x89on_bar\xe5\x87\xbd\xe6\x95\xb0\xe5\x86\x85\xe8\x83\xbd\xe4\xb8\x8b\xe5\x8d\x95\xef\xbc\x81')
if symbol:
contract = (Contract(symbol) if isinstance(symbol, str) else symbol)
else:
contract = self._cur_data_context.contract
price_type = (PriceType.MKT if (price == 0) else PriceType.LMT)
self._cur_strategy_context.sell(price, quantity, price_type, contract)
|
'Args:
price (float): ä»·æ Œ, 0è¡šåžä»·ã
quantity (int): æ°éã
symbol (str): å纊'
| def short(self, price, quantity, symbol=None):
| if (not self.on_bar):
raise Exception('\xe5\x8f\xaa\xe6\x9c\x89on_bar\xe5\x87\xbd\xe6\x95\xb0\xe5\x86\x85\xe8\x83\xbd\xe4\xb8\x8b\xe5\x8d\x95\xef\xbc\x81')
if symbol:
contract = (Contract(symbol) if isinstance(symbol, str) else symbol)
else:
contract = self._cur_data_context.contract
price_type = (PriceType.MKT if (price == 0) else PriceType.LMT)
self._cur_strategy_context.short(price, quantity, price_type, contract)
|
'Args:
price (float): ä»·æ Œ, 0è¡šåžä»·ã
quantity (int): æ°éã
symbol (str): å纊'
| def cover(self, price, quantity, symbol=None):
| if (not self.on_bar):
raise Exception('\xe5\x8f\xaa\xe6\x9c\x89on_bar\xe5\x87\xbd\xe6\x95\xb0\xe5\x86\x85\xe8\x83\xbd\xe4\xb8\x8b\xe5\x8d\x95\xef\xbc\x81')
if symbol:
contract = (Contract(symbol) if isinstance(symbol, str) else symbol)
else:
contract = self._cur_data_context.contract
price_type = (PriceType.MKT if (price == 0) else PriceType.LMT)
self._cur_strategy_context.cover(price, quantity, price_type, contract)
|
'Args:
direction (str/int): æä»æ¹åãå€å€Ž - \'long\' / 1 ïŒç©ºå€Ž - \'short\' / 2
symbol (str): å笊䞲å纊ïŒé»è®€äžºNone衚瀺䞻å纊ã
Returns:
Position. 该å纊çæä»'
| def position(self, direction='long', symbol=None):
| if (not self.on_bar):
raise Exception('\xe5\x8f\xaa\xe6\x9c\x89on_bar\xe5\x87\xbd\xe6\x95\xb0\xe5\x86\x85\xe8\x83\xbd\xe6\x9f\xa5\xe8\xaf\xa2\xe5\xbd\x93\xe5\x89\x8d\xe6\x8c\x81\xe4\xbb\x93\xef\xbc\x81')
direction = Direction.arg_to_type(direction)
contract = (Contract(symbol) if symbol else self._cur_data_context.contract)
return self._cur_strategy_context.position(contract, direction)
|
'è¿åæææä»åè¡š [Position]'
| def all_positions(self):
| return self._cur_strategy_context.all_positions()
|
'Args:
direction (str/int): æä»æ¹åãå€å€Ž - \'long\' / 1 ïŒç©ºå€Ž - \'short\' / 2
symbol (str): å笊䞲å纊ïŒé»è®€äžºNone衚瀺䞻å纊ã
Returns:
int. 该å纊çæä»æ°ç®ã'
| def pos(self, direction='long', symbol=None):
| if (not self.on_bar):
raise Exception('\xe5\x8f\xaa\xe6\x9c\x89on_bar\xe5\x87\xbd\xe6\x95\xb0\xe5\x86\x85\xe8\x83\xbd\xe6\x9f\xa5\xe8\xaf\xa2\xe5\xbd\x93\xe5\x89\x8d\xe6\x8c\x81\xe4\xbb\x93\xef\xbc\x81')
direction = Direction.arg_to_type(direction)
contract = (Contract(symbol) if symbol else self._cur_data_context.contract)
return self._cur_strategy_context.pos(contract, direction)
|
''
| def cancel(self, orders):
| self._cur_strategy_context.cancel(orders)
|
''
| def cash(self):
| if (not self.on_bar):
raise Exception('\xe5\x8f\xaa\xe6\x9c\x89on_bar\xe5\x87\xbd\xe6\x95\xb0\xe5\x86\x85\xe8\x83\xbd\xe6\x9f\xa5\xe8\xaf\xa2\xe5\x8f\xaf\xe7\x94\xa8\xe8\xb5\x84\xe9\x87\x91\xef\xbc\x81')
return self._cur_strategy_context.cash()
|
''
| def equity(self):
| if (not self.on_bar):
raise Exception('\xe5\x8f\xaa\xe6\x9c\x89on_bar\xe5\x87\xbd\xe6\x95\xb0\xe5\x86\x85\xe8\x83\xbd\xe6\x9f\xa5\xe8\xaf\xa2\xe5\xbd\x93\xe5\x89\x8d\xe6\x9d\x83\xe7\x9b\x8a\xef\xbc\x81')
return self._cur_strategy_context.equity()
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.