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)
