def get_APIs(self) -> Globals:
class Capital:
def __init__(self, manager):
self.__manager = proxy(manager)
@property
def base(self):
return self.__manager.capital_base
@property
def net(self):
return self.__manager.capital_net
@property
def cash(self):
return self.__manager.capital_cash
@property
def available(self):
return self.__manager.capital_available
@property
def margin(self):
return self.__manager.capital_margin
return Globals({"Cap": Capital(self)}, {})
def __init__(self, code: StrategyCode, strategy: Strategy):
self.__strategy = strategy
self.__code = code
self.__signals_setting = {}
self.__signals_ast = {}
self.__ast_root = ast.parse(self.__code.code,
filename="[Strategy:%s]" %
self.__code.name,
mode="exec")
self.__globals = Globals({}, {})
self._parse()
def _init(self, loc):
init_transformer = InitTransformer()
init_transformer.visit(self.ast_root)
# XXX 必须要一个module node作为根节点。
exec(
compile(wrap_with_module(init_transformer.init_node),
"[Strategy:%s]" % self.__code.name,
mode="exec"),
dict(open=self.__strategy.open,
print=self.__strategy.printer.print,
**loc), loc)
self.__globals.update(Globals(loc["init"](), {}))
def get_APIs(self, strategy=None, signal=None, symbol=None) -> Globals:
const = dict(
Buy=partial(self.place_order, strategy=strategy, signal=signal, direction=OrderDirection.long_entry),
Sell=partial(self.place_order, strategy=strategy, signal=signal, direction=OrderDirection.long_exit),
SellShort=partial(self.place_order, strategy=strategy, signal=signal,
direction=OrderDirection.short_entry),
BuyToCover=partial(self.place_order, strategy=strategy, signal=signal,
direction=OrderDirection.short_exit),
Positions=self.current_positions)
var = dict(
Pos=lambda: self.current_positions[symbol],
MarketPosition=lambda: self.current_positions[symbol].type,
CurrentContracts=lambda: self.current_positions[symbol].volume,
)
return Globals(const, var)
def get_APIs(self, symbols=None, time_frame=None) -> Globals:
def capitalize(s: str) -> str:
return s[0].upper() + s[1:]
APIs = Globals({}, {})
if symbols and time_frame:
for field in ["open", "high", "low", "close", "volume", "timestamp", "datetime"]:
APIs.const[capitalize(field) + 's'] = {}
for symbol in symbols:
APIs.const[capitalize(field) + 's'][symbol] = getattr(self._data_view.find(symbol, time_frame),
field)
APIs.const[capitalize(field)] = getattr(self._data_view.find(symbols[0], time_frame), field)
APIs.const[field[0].upper()] = getattr(self._data_view.find(symbols[0], time_frame), field)
APIs.const["Points"] = {symbol: self._symbol_pool[symbol].point for symbol in symbols}
APIs.const["Point"] = self._symbol_pool[symbols[0]].point
return APIs
def get_APIs(self, symbols=None, time_frame=None) -> Globals:
temp = {
"Symbols": symbols,
"TimeFrame": time_frame,
"Symbol": symbols[0],
"StartTime": self.start_time,
"EndTime": self.end_time,
"Context": self.__context,
"Export": partial(export, strategy=self),
"Put": self.put_context,
"Get": self.get_context,
"print": self.printer.print,
"open": self.open,
"signals": self.signals,
"system_functions": self.system_functions
}
return Globals(temp, {})
def _parse(self):
glb = {}
loc = {}
exec(
compile(self.__code.code,
"[Strategy:%s]" % self.__code.name,
mode="exec"), glb, loc)
for key, value in loc.items():
if inspect.isfunction(value):
if key == "init":
self._init(loc)
else:
self._extract_signal_setting(key, value)
self.__signals_ast = find_func_in_module(self.signals, self.__ast_root)
self.__globals.update(
Globals(
{
key: value
for key, value in loc.items() if key not in self.signals
}, {}))
def get_APIs(self, **kwargs) -> Globals:
var = {"BarNum": self.get_bar_num}
return Globals({}, var)
def get_APIs(self, strategy=None, signal=None, symbols=None, time_frame=None) -> Globals:
APIs = Globals({}, {})
APIs.update(self.__account_manager.get_APIs())
APIs.update(self.__quotation_manager.get_APIs(symbols=symbols, time_frame=time_frame))
APIs.update(self.__trading_manager.get_APIs(strategy=strategy, signal=signal, symbol=symbols[0]))
return APIs
