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):
     event.subscribe(self.inner.on_order_created, _(self).onOrderCreated, self)
     event.subscribe(OnOrderMatched(), _(self)._onOrderMatched, self)
     from marketsim.gen._out.event._event import Event
     self.on_traded = Event()
     self.orderBook = OfTrader()
     self._balance = 0
     self._position = 0

    def __init__(self):
        self.ask = self.book.Asks.BestPrice
        self.bid = self.book.Bids.BestPrice

        self.reset()
        event.subscribe(self.ask, _(self)._update, self)
        event.subscribe(self.bid, _(self)._update, self)
        event.subscribe(self.depth, _(self)._update, 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):
     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, 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 __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, queue, book, link):
     self._queue = queue
     self.book = book
     self._link = link
     queue.bestPrice += _(self)._onBestChanged
     self.bestPrice = BestPrice(self)
     self.lastTrade = LastTrade()
     queue.lastTrade += _(self)._onTraded
     self.reset()

    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):
     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 onOrderMatched(self, order, price, volume):
     if order is not self._stopLossOrder:
         if volume > 0:
             handler = event.GreaterThan((1+self._maxloss) * price, _(self)._onPriceChanged)\
                         if self.side == Side.Sell else\
                       event.LessThan((1-self._maxloss) * price, _(self)._onPriceChanged)
                         
             self._stopSubscription = event.subscribe(self._obsPrice, handler, self, self._ctx)
             self.onMatchedWith(price, +volume)
     else:
         self.onMatchedWith(price, -volume)

 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, source, folder):
     """ Initializes folder with source of values and accumulator object        
     """
     self._acc = folder
     self._source = source
     self._event = event.subscribe(self._source, _(self)._update, self)
     self._alias = ["_details", "fold", "old"]

    def __init__(self):
        self.attributes = {"smooth":True}

        self._timer = event.Every(self.intervalDistr)
        event.subscribe(self._timer, _(self)._wakeUp, self)
        
        self.reset()

 def process(self, order):
     if isinstance(order, types.IOrder):
         BookBase.process(self, order)
     else:
         # if 'callback' in dir(order):
         #    order.callback = _(self, order.callback)._sendToDownLink
         self._upLink.send(_(self._book, order).process)

 def __init__(self, source = ops.constant(1.)):
     ops.Observable[float].__init__(self)
     
     self._source = source
     self._event = event.subscribe(source, _(self)._wakeup, self)
     self._previous = None
     self._value = None

 def __init__(self):
     self._efficiency = Efficiency(self.trader)
     event.subscribe(
             OnEveryDt(self._efficiency, 1),
              _(self)._update, self)
     self._score = 1
     self._last = 0

 def _update(self, dummy = None):
     depth = self.depth()
     side = Side.Buy if depth < 0 else Side.Sell
     self.book.process(
                     request.EvalMarketOrder(side,
                                             abs(depth),
                                             _(self, -sign(depth))._callback))

 def onOrderCreated(self, order, source):
     self.orderBook.process(
                 request.EvalMarketOrder(
                             order.side,
                             order.volumeUnmatched,
                             _(self,
                               order.side,
                               order.volumeUnmatched)._update))