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].... |
''
| @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 colo... | 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, 'a... |
''
| 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... |
''
| 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... |
'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(... |
'ç»å®åæ°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 se... |
'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.deal... |
'第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]
... |
'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['com... |
'è¿å第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].valu... |
'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 ... |
''
| @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, orde... |
''
| 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 +=... |
'å¯èœäº§çäžç³»å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['ca... |
''
| 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 (Fals... |
''
| 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):
... |
''
| 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.posi... |
''
| 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\x... |
'åšåæµçæåäžæ ¹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.contr... |
''
| 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)
... |
'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(('... |
'è·åçšæ·åšçç¥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_vari... |
'æ·»å 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.appe... |
'æŽæ°ææ°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)
exc... |
''
| 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._cu... |
''
| 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... |
'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... |
'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... |
'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... |
'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._c... |
'è¿åæææä»åè¡š [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._c... |
''
| 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.