def __init__(self):
Strategy.__init__(self)
props = { k : getattr(self, k) for k in self._properties.iterkeys() }
sp = merge_dict(props, side=Side.Sell)
bp = merge_dict(props, side=Side.Buy)
self._sell = LiquidityProviderSide(**sp)
self._buy = LiquidityProviderSide(**bp)
def __init__(self):
""" Runs generic two side strategy
trader - single asset single market trader
orderFactoryT - function to create orders: side -> *orderParams -> Order
eventGen - event generator to be listened - we'll use its advise method to subscribe to
orderFunc - function to calculate order parameters: Trader -> None | (side,*orderParams)
"""
Strategy.__init__(self)
self._wakeUp = bind.Method(self, '_wakeUp_impl')
event.subscribe(self._eventGen, self._wakeUp, self)
def __init__(self):
Strategy.__init__(self)
self._estimator_strategy = self.estimator(self.strategy) # TODO: dependency tracking
self._estimator = trader.SingleAsset(orderbook.OfTrader(trader.ParentProxy()),
self._estimator_strategy)
self._strategy = self.strategy
self._efficiency = self.efficiency(self._estimator) # TODO: dependency tracking
event.subscribe(self._efficiency, bind.Method(self, '_wakeUp_impl'), self)
def __init__(self):
""" Initializes generic one side trader and makes it working
orderBook - book to place orders in
side - side of orders to create
orderFactoryT - function to create orders: side -> *orderParams -> Order
eventGen - event generator to be listened - we'll use its advise method to subscribe to
orderFunc - function to calculate order parameters: Trader -> *orderParams
"""
Strategy.__init__(self)
self._wakeUp = bind.Method(self, '_wakeUp_impl')
event.subscribe(self._eventGen, self._wakeUp, self)
def __init__(self):
""" Runs generic two side strategy
trader - single asset single market trader
params.eventGen -- event that initiates strategy work
params.sideFunc -- function '() -> Side option' that calculates side of order to create
params.volumeFunc -- function '() -> Volume' calculating volume of order to create
params.orderFactory -- function 'Side -> Volume -> IOrder' instantiating orders
"""
Strategy.__init__(self)
self._wakeUp = bind.Method(self, '_wakeUp_impl')
event.subscribe(self.eventGen, self._wakeUp, self)
def __init__(self):
self._chooseTheBest = bind.Method(self, '_chooseTheBest_impl')
Strategy.__init__(self) # TODO: eventGen should be a parameter
self._eventGen = scheduler.Timer(mathutils.constant(1))
def _createInstance(sp):
estimator_strategy = self.estimator(sp)
estimator = trader.SingleAsset(orderbook.OfTrader(trader.ParentProxy()),estimator_strategy)
efficiency = self.efficiency(estimator)
return (sp, estimator, estimator_strategy, efficiency)
self._strategies = [_createInstance(sp) for sp in self.strategies]
self._chooseTheBest = bind.Method(self, '_chooseTheBest_impl')
self._current = None
event.subscribe(self._eventGen, self._chooseTheBest, self)
def __init__(self):
Strategy.__init__(self) # TODO: eventGen should be a parameter
self._eventGen = scheduler.Timer(mathutils.constant(1))
def _createInstance(sp):
estimator_strategy = self.estimator(sp)
estimator = trader.SingleAsset(orderbook.OfTrader(trader.ParentProxy()), estimator_strategy)
efficiency = self.efficiency(estimator)
return (sp, estimator, estimator_strategy, efficiency)
self._strategies = [_createInstance(sp) for sp in self.strategies]
self._choose = bind.Method(self, "_choose_impl")
self._strategyWeights = self.weight
self._current = None
# what is the data source for weight update?
event.subscribe(self._eventGen, self._choose, self)
# suspend all strategies
for (s, _, _, _) in self._strategies:
s.suspend(True)
def __init__(self):
Strategy.__init__(self)
for s in self.strategies:
event.subscribe(s.on_order_created, _(self)._send, self)
def suspend(self, s=True):
Strategy.suspend(self, s)
self._strategy.suspend(s)
self._estimator_strategy.suspend(s)
def suspended(self):
assert self._sell.suspended == self._suspended
assert self._buy.suspended == self._suspended
return Strategy.suspended(self)
def suspend(self, s):
Strategy.suspend(self, s)
self._sell.suspend(s)
self._buy.suspend(s)
def suspend(self, s=True):
Strategy.suspend(self, s)
if self._current:
self._current.suspend(s)
for (_, _, estimator_strategy, _) in self._strategies:
estimator_strategy.suspend(s)
def suspended(self):
for s in self.strategies:
assert s.suspended == self._suspended
return Strategy.suspended(self)
def suspend(self, flag):
Strategy.suspend(self, flag)
for s in self.strategies:
s.suspend(flag)
def __init__(self):
Strategy.__init__(self)
event.subscribe(self.eventGen, _(self)._wakeUp, self)
