def __init__(self): self._efficiency = Efficiency(self.trader) event.subscribe( OnEveryDt(self._efficiency, 1), _(self)._update, self) self._score = 1 self._last = 0
def __init__(self): self._balance = 0 self._position = 0 from marketsim.gen._out.event._event import Event self.on_traded = Event() self.orderBook = OfTrader() event.subscribe(self.inner.on_order_created, _(self).onOrderCreated, self)
def __init__(self): self.attributes = {"smooth":True} self._timer = event.Every(self.intervalDistr) event.subscribe(self._timer, _(self)._wakeUp, self) self.reset()
def __init__(self, lhs, rhs): self.lhs = lhs self.rhs = rhs if types.IEvent in inspect.getmro(type(lhs)): event.subscribe(lhs, _(self).fire, self) if types.IEvent in inspect.getmro(type(rhs)): event.subscribe(rhs, _(self).fire, self)
def __init__(self): event.subscribe(self.inner.on_order_created, _(self).onOrderCreated, self) event.subscribe(observable.OnOrderMatched(), _(self)._onOrderMatched, self) self.on_traded = event.Event() self.orderBook = orderbook.OfTrader() self._balance = 0 self._position = 0
def __init__(self, trader = None): from marketsim.gen._out.observable.trader._SingleProxy import SingleProxy from marketsim import event from marketsim import types self.trader = trader if trader is not None else SingleProxy() PendingVolume_Impl.__init__(self) if isinstance(trader, types.IEvent): event.subscribe(self.trader, self.fire, self)
def __init__(self, queue = None): from marketsim.gen._out.observable.orderbook._Asks import Asks from marketsim import event from marketsim import types self.queue = queue if queue is not None else Asks() _LastTradePrice_Impl.__init__(self) if isinstance(queue, types.IEvent): event.subscribe(self.queue, self.fire, self)
def bind_impl(self, ctx): if not hasattr(self, '_subscriptions'): self.trader.bind_ex(ctx) event.subscribe(self.trader.on_order_matched, _(self).onOrderMatched, self) event.subscribe(self.trader.on_order_disposed, _(self).onOrderDisposed, self) for x in self._subscriptions: x.bind_ex(ctx) self._bound_ex = True
def __init__(self, x = None): from marketsim.gen._out._constant import constant from marketsim import event from marketsim import types Observable[float].__init__(self) self.x = x if x is not None else constant(1.0) if isinstance(x, types.IEvent): event.subscribe(self.x, self.fire, self)
def __init__(self, trader): self.trader = trader self._efficiency = observable.Efficiency(trader) event.subscribe( observable.OnEveryDt(1, self._efficiency), _(self)._update, self) self._score = 1 self._last = 0
def __init__(self, ticker = "^GSPC", start = "2001-1-1", end = "2010-1-1"): ops.Observable[float].__init__(self) self.ticker = ticker self.start = start self.end = end self._quotes = None self._current = None event.subscribe(event.Every(ops.constant(1)), _(self)._wakeUp, self)
def __init__(self): Strategy.__init__(self) self._eventGen = event.Every(ops.constant(0.9)) event.subscribe(self._eventGen, _(self)._wakeUp, self) self.book = orderbook.OfTrader() self.midprice = observable.MidPrice(self.book) self.log = TraderHistory(SingleProxy()) self.prev_mid = None
def __init__(self): Strategy.__init__(self) self._eventGen = event.Every(ops.constant(1)) event.subscribe(self._eventGen, _(self)._wakeUp, self) self.quotes = data.load(self.ticker, self.start, self.end)['Adj Close'] self.log = TraderHistory(SingleProxy()) self.waitingForCancel = False
def __init__(self): Strategy.__init__(self) from marketsim._pub import strategy, side self._seller = strategy.price.Ladder(self.orderFactory, self.initialSize, side.Sell()) self._buyer = strategy.price.Ladder(self.orderFactory, self.initialSize, side.Buy()) event.subscribe(self._seller.on_order_created, _(self)._send, self) event.subscribe(self._buyer.on_order_created, _(self)._send, self)
def __init__(self): Strategy.__init__(self) props = dict([(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) event.subscribe(self._sell.on_order_created, _(self)._send, self) event.subscribe(self._buy.on_order_created, _(self)._send, self)
def regSide(side): for book in self._books: queue = book.queue(side) event.subscribe(queue.bestPrice, _(self, side)._schedule, self, {}) if not queue.empty: self._bests[side.id][queue.best.signedPrice] = queue self._oldBests[queue] = queue.best.signedPrice
def __init__(self): ops.Observable[float].__init__(self) self.price = LastTradePrice(self.book) self.reset() event.subscribe(self.price, _(self)._update, self) event.subscribe(self.depth, _(self)._update, self)
def __init__(self, source, timeframe = 1.): ops.Observable[types.ICandleStick].__init__(self) self._source = source self._event = event.subscribe(source, _(self)._update, self) event.subscribe(event.Every(ops.constant(timeframe)), _(self)._flush, self) self.timeframe = timeframe self.reset() self._mean = CMA(source) self._stddev = StdDev(source)
def regSide(side): for book in self._books: queue = book.queue(side) event.subscribe(queue.on_best_changed, bind.Method(self, '_schedule', side), self).bind(None) if not queue.empty: self._bests[side.id][queue.best.signedPrice] = queue self._oldBests[queue] = queue.best.signedPrice
def __init__(self): from marketsim.gen._out._observable import Observableint from marketsim import rtti from marketsim import _ from marketsim import event Observableint.__init__(self) rtti.check_fields(self) self.impl = self.getImpl() event.subscribe(self.impl, _(self).fire, self)
def __init__(self): Strategy.__init__(self) self._current = None self._estimators = [] for s in self.strategies: event.subscribe(s.on_order_created, _(self).send, self) e = self.performance(self.account(s)) e._origin = s self._estimators.append(e) event.subscribe(event.Every(ops.constant(1.)), _(self)._wakeUp, self)
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, book = None): from marketsim import float from marketsim.ops._all import Observable from marketsim.gen._out.observable.orderbook._OfTrader import OfTrader from marketsim import _ from marketsim import event Observable[float].__init__(self) self.book = book if book is not None else OfTrader() self.impl = self.getImpl() event.subscribe(self.impl, _(self).fire, self)
def __init__(self, source = None): from marketsim.gen._out._observable import Observablefloat from marketsim.gen._out._const import const_Float as _const_Float from marketsim import event from marketsim import rtti Observablefloat.__init__(self) self.source = source if source is not None else _const_Float(1.0) event.subscribe(self.source, self.fire, self) rtti.check_fields(self) _BreaksAtChanges_Impl.__init__(self)
def __init__(self, book = None): from marketsim import _ from marketsim import event from marketsim.gen._out._observable._observablefloat import Observablefloat from marketsim import deref_opt from marketsim.gen._out.orderbook._oftrader import OfTrader_IAccount as _orderbook_OfTrader_IAccount Observablefloat.__init__(self) self.book = book if book is not None else deref_opt(_orderbook_OfTrader_IAccount()) self.impl = self.getImpl() event.subscribe(self.impl, _(self).fire, self)
def __init__(self, side_distribution = None): from marketsim import Side from marketsim.ops._all import Observable from marketsim.gen._out.mathutils.rnd._uniform import uniform from marketsim import _ from marketsim import event Observable[Side].__init__(self) self.side_distribution = side_distribution if side_distribution is not None else uniform(0.0,1.0) self.impl = self.getImpl() event.subscribe(self.impl, _(self).fire, self)
def __init__(self, x = None): from marketsim.gen._out.math._moving import Moving_IObservableFloatFloat as _math_Moving_IObservableFloatFloat from marketsim import _ from marketsim import event from marketsim.gen._out._observable._observablefloat import Observablefloat from marketsim import deref_opt Observablefloat.__init__(self) self.x = x if x is not None else deref_opt(_math_Moving_IObservableFloatFloat()) self.impl = self.getImpl() event.subscribe(self.impl, _(self).fire, self)
def __init__(self, lossFactor = None): from marketsim.gen._out._const import const_Float as _const_Float from marketsim import _ from marketsim.gen._out._observable._observablebool import Observablebool from marketsim import event from marketsim import deref_opt Observablebool.__init__(self) self.lossFactor = lossFactor if lossFactor is not None else deref_opt(_const_Float(0.2)) self.impl = self.getImpl() event.subscribe(self.impl, _(self).fire, self)
def __init__(self, trader = None): from marketsim import _ from marketsim import event from marketsim.gen._out._observable._observablefloat import Observablefloat from marketsim.gen._out.trader._singleproxy import SingleProxy_ as _trader_SingleProxy_ from marketsim import deref_opt Observablefloat.__init__(self) self.trader = trader if trader is not None else deref_opt(_trader_SingleProxy_()) self.impl = self.getImpl() event.subscribe(self.impl, _(self).fire, self)
def __init__(self, x = None): from marketsim.gen._out.strategy.side._pairtrading import PairTrading_IOrderBookFloat as _strategy_side_PairTrading_IOrderBookFloat from marketsim import _ from marketsim import event from marketsim.gen._out._observable._observablefloat import Observablefloat from marketsim import deref_opt Observablefloat.__init__(self) self.x = x if x is not None else deref_opt(_strategy_side_PairTrading_IOrderBookFloat()) self.impl = self.getImpl() event.subscribe(self.impl, _(self).fire, self)
def __init__(self): from marketsim.gen._out.orderbook.ask._lasttradeprice import LastTradePrice as Ask from marketsim.gen._out.orderbook.bid._lasttradeprice import LastTradePrice as Bid self.ask = Ask(self.book) self.bid = Bid(self.book) self.reset() event.subscribe(self.ask, _(self)._update, self) event.subscribe(self.bid, _(self)._update, self) event.subscribe(self.depth, _(self)._update, self)
def onOrderMatched(self, order, price, volume): from marketsim.gen._out._side import Side from marketsim.gen._out.event._greaterthan import GreaterThan from marketsim.gen._out.event._lessthan import LessThan if order is not self._stopLossOrder: if volume > 0: handler = GreaterThan((1+self._maxloss) * price, _(self)._onPriceChanged)\ if self.side == Side.Sell else\ LessThan((1-self._maxloss) * price, _(self)._onPriceChanged) self._stopSubscription = event.subscribe( self._obsPrice, handler, self) self._stopSubscription.bind_ex(self._ctx_ex) self.onMatchedWith(price, +volume) else: self.onMatchedWith(price, -volume)
def __init__(self, cond=None, ifpart=None, elsepart=None): from marketsim import rtti from marketsim.gen._out._observabletrue import observableTrue_ as _observableTrue_ from marketsim.gen._out._const import const_Float as _const_Float from marketsim import event from marketsim.gen._out._observable import Observablefloat Observablefloat.__init__(self) self.cond = cond if cond is not None else _observableTrue_() event.subscribe(self.cond, self.fire, self) self.ifpart = ifpart if ifpart is not None else _const_Float(1.0) event.subscribe(self.ifpart, self.fire, self) self.elsepart = elsepart if elsepart is not None else _const_Float(1.0) event.subscribe(self.elsepart, self.fire, self) rtti.check_fields(self) _Condition_Impl.__init__(self)
def __init__(self, cond=None, ifpart=None, elsepart=None): from marketsim import rtti from marketsim.gen._out.side._observablesell import observableSell_ as _side_observableSell_ from marketsim.gen._out._observabletrue import observableTrue_ as _observableTrue_ from marketsim.gen._out._side import Side from marketsim import event from marketsim.gen._out.side._observablebuy import observableBuy_ as _side_observableBuy_ from marketsim.gen._out._observable import ObservableSide ObservableSide.__init__(self) self.cond = cond if cond is not None else _observableTrue_() event.subscribe(self.cond, self.fire, self) self.ifpart = ifpart if ifpart is not None else _side_observableSell_() event.subscribe(self.ifpart, self.fire, self) self.elsepart = elsepart if elsepart is not None else _side_observableBuy_( ) event.subscribe(self.elsepart, self.fire, self) rtti.check_fields(self) _Condition_Impl.__init__(self)
def __init__(self): Strategy.__init__(self) event.subscribe(self.inner.on_order_created, _(self).onOrderCreated, self)
def bind(self, ctx): event.subscribe(self._myTrader.on_order_sent, _(self).process, self, ctx) event.subscribe(self._eventGen, _(self)._wakeUp, self, ctx)
def __init__(self): Strategy.__init__(self) from marketsim import event, _ event.subscribe(self.eventGen, _(self)._wakeUp, self)
def __init__(self): _Base_Impl.__init__(self) self._subscription = event.subscribe(self.strategy.on_order_created, _(self).send, self) self._alias = [self.label]
def __init__(self): Strategy.__init__(self) event.subscribe(self.predicate, _(self)._wakeUp, self) event.subscribe(self.inner.on_order_created, _(self)._send, self) self._suspended = False
def bind_impl(self, ctx): from marketsim import event, _, context if not hasattr(self, '_subscriptions'): event.subscribe(self.queue.lastTrade, _(self).fire, self)
def bind_impl(self, context): if not hasattr(self, '_subscriptions'): Strategy.bind_impl(self, context) event.subscribe(context.trader.on_order_matched, _(self)._onOrderMatched, self)
def __init__(self): self._mean = Avg(self.source, self.alpha) # TODO: handle source and alpha change self.reset() self._event = event.subscribe(self.source, _(self)._update, self)
def __init__(self, proto, price): _meta.OwnsSingleOrder.__init__(self, proto) self._priceFunc = price event.subscribe(price, _(self)._update, self)
def __init__(self): self._dataSource = self.x self._subscription = event.subscribe(self.x, self.fire, self)
def __init__(self): from marketsim.gen._out.trader._ontraded import OnTraded event.subscribe(OnTraded(self.trader), self.fire, self)
def bind(self, ctx): from marketsim import event, _, context event.subscribe(self.queue.bestPrice, _(self).fire, self) context.bind(self._subscriptions, ctx)
def __init__(self): self._balance = 0 self._position = 0 self.on_traded = event.Event() self.orderBook = OfTrader() event.subscribe(self.inner.on_order_created, _(self).onOrderCreated, self)
def __init__(self): self.attributes = {'smooth': True} self._dataSource = self.x IndicatorBase.__init__(self) self._subscription = event.subscribe(event.Every(constant(self.dt)), self.fire, self)
def __init__(self): event.subscribe(event.Every(constant(1)), self.fire, self)
def on_strategy_set(self, value): if hasattr(self, '_subscription'): self._subscription.switchTo(value.on_order_created) else: self._subscription = event.subscribe(self.strategy.on_order_created, _(self).send, self)
def __init__(self): self.attributes = getattr(self.source, 'attributes', {}) self._smooth = 1 if 'smooth' in self.attributes and self.attributes['smooth'] else 0 self._lastPoint = None self._event = event.subscribe(self.source, _(self)._wakeUp, self) self.reset()
def bind_impl(self, ctx): if not hasattr(self, '_subscriptions'): event.subscribe(self.trader.on_order_matched, self.fire, self)
def __init__(self): event.subscribe(self.source, _(self)._update, self) self.reset()
def __init__(self): Strategy.__init__(self) for s in self.strategies: event.subscribe(s.on_order_created, _(self)._send, self)
def __init__(self): Strategy.__init__(self) for s in [self.A, self.B]: event.subscribe(s.on_order_created, _(self)._send, self)
def __init__(self): self._quotes = None self._current = None event.subscribe(event.Every(constant(1)), _(self)._wakeUp, self)
def bind_impl(self, ctx): if not hasattr(self, '_subscriptions'): event.subscribe(self._myTrader.on_order_sent, _(self).process, self) event.subscribe(self._eventGen, _(self)._wakeUp, self) self._bound_ex = True
def __init__(self): self.reset() self._alias = ['_details', 'Lagged'] self._event = event.subscribe(self.source, _(self)._update, self)
def __init__(self): self._price = BestPrice(self.queue) event.subscribe(self._price, _(self)._update, self) self._lastPrice = None
def __init__(self): self._value = None event.subscribe(self.source, _(self)._clean, self)