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, 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):
     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, 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 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, 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, 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, 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 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):
     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 __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)
        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, 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):
        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):

        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):
     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)