root/trac/hacks/marketplugin/0.9/tracmarket/specialist.py

import os
import re
import time
import types
import urllib

from trac.core import *
from trac.env import IEnvironmentSetupParticipant
from trac.util import format_datetime

from tracmarket.command import *
from tracmarket.order import *

SequenceType = (types.ListType, types.TupleType, types.GeneratorType)

class Specialist(CommandInterpreter):

    def pre_cmd(self, ctx):
        '''housekeeping to run before every command'''
        super(Specialist, self).pre_cmd(ctx)
        db = ctx.db
        ctx.res.market.content_url = self.content_url(ctx.symbol)
        ctx.res.market.book_url = self.book_url(ctx, ctx.symbol)
        ctx.res.market.basket_url = self.basket_url(ctx.symbol)
        ctx.res.market.basket_symbol = self.basket_symbol(ctx.symbol)
        ctx.res.market.basket_price = self.basket_price

    def post_cmd(self, ctx):
        '''housekeeping to run after every command'''
        db = ctx.db
        # symbol = Symbol(ctx, ctx.symbol)
        symbol = ctx.symbol
        currency = ctx.currency
        # only run order matching every 60 seconds
        timer = Timer.control(env=self.env, db=db, name='match_period')
        match_period = self.config.get('market', 'match_period', 60)
        if timer.expired(match_period):
            timer.reset()
            # run basket marketmaker
            self.cmd_make(ctx)
            # run order matching
            self.cmd_match(ctx)

    def cmd_book(self, ctx):
        # XXX use res_book()
        quote = Quote(self.env, ctx.db, ctx.symbol, ctx.currency)
        last = quote.last
        book = quote.book
        bids = OrderQ(self.exchange_authname, 'bid', book.bids)
        asks = OrderQ(self.exchange_authname, 'ask', book.asks)
        if last:
            ctx.res['market.last_trade'] = dict(last)
            ctx.res['market.last_trade.ftime'] = format_datetime(
                    last.time)
        ctx.res.market.book.bids = bids
        ctx.res.market.book.asks = asks

    def cmd_buy(self, ctx, qty, price=None):
        authname = ctx.req.authname
        db = ctx.db
        price = price and Price(price)
        order = self.order(ctx, owner=authname, size=Size(qty), 
                limit_price=price)
        ctx.res['market.order'] = dict(order)
        ctx.res.info("Entered order id %d: %s" % (order.id, ctx.cmd))
        # XXX need to queue orders first, check and process later --
        # XXX remove next 4 lines after this is done
        # run basket marketmaker
        self.cmd_make(ctx)
        # run order matching
        self.cmd_match(ctx)
    cmd_b = cmd_buy
    cmd_bid = cmd_buy

    def cmd_cancel(self, ctx, id):
        """Cancel an order.  Returns order object -- check contents
        for status."""
        order = Order.selectone(ctx.env, ctx.db, id=id)
        # XXX auth ck 
        order.cancel(ctx.db, ctx.ledger, ctx.req.authname)
        ctx.res['market.cancelled_order'] = dict(order)
        ctx.res.info("Cancelled order id %d" % (order.id))

    def cmd_last(self, ctx):
        '''return last trade'''
        db = ctx.db
        symbol = ctx.symbol
        currency = ctx.currency
        trade = self.quote(db, symbol, currency).last
        ctx.res['market.last_trade'] = dict(trade)

    def cmd_make(self, ctx):
        """maintain the basket market for this symbol"""
        symbol = ctx.symbol
        if self.res_underlying(ctx, symbol, ck_only=True):  
            self.basket_marketmaker(ctx, symbol)

    def cmd_match(self, ctx):
        """match all open orders for this specialist"""
        (fills, cancels, stops) = self.match(ctx)
        ctx.res['market.match.fills'] = fills
        ctx.res['market.match.cancels'] = cancels
        ctx.res['market.match.stops'] = stops
        ctx.res['market.match.activity'] = fills + cancels + stops

    def cmd_orders(self, ctx):
        authname = ctx.req.authname
        orders = Order.open_orders(ctx.env, ctx.db, owner=authname)
        i = 0
        for order in orders:
            ctx.res['market.orders.%d' % order.id] = dict(order)
            i += 1
        ctx.res['market.order_count'] = i

    def cmd_estimate(self, ctx):
        self.res_estimate(ctx)

    def cmd_sell(self, ctx, qty, price=None):
        authname = ctx.req.authname
        db = ctx.db
        price = price and Price(price)
        order = self.order(ctx, owner=authname, size=(-1 * Size(qty)), 
                limit_price=price)
        ctx.res['market.order'] = dict(order)
        ctx.res.info("Entered order id %d: %s" % (order.id, ctx.cmd))
        # XXX need to queue orders first, check and process later --
        # XXX remove next 4 lines after this is done
        # run basket marketmaker
        self.cmd_make(ctx)
        # run order matching
        self.cmd_match(ctx)
    cmd_s = cmd_sell
    cmd_a = cmd_sell
    cmd_ask = cmd_sell

    def cmd_show(self, ctx):
        req = ctx.req
        entity = req.authname
        component_symbols = self.component_symbols(ctx, ctx.symbol)
        basket = list(component_symbols)
        if not basket:
            # looking for a particular contract; just show the order book
            return self.cmd_book(ctx)
        ctx.res['title'] = ctx.symbol + " basket"
        ctx.res['market.show_basket'] = 1
        ctx.res['market.basket_sequence'] = basket
        # add the basket
        self.res_basket(ctx, ctx.symbol)
        # add the basket book
        self.cmd_book(ctx)

        '''
        # XXX probably want to replace this entire for loop with the
        # XXX results of estimate() instead
        for contract in basket:
            # add the prices to res
            quote = Quote(self.env, ctx.db, contract, ctx.currency)
            bids = OrderQ(self.exchange_authname, 'bid', quote.book.bids)
            asks = OrderQ(self.exchange_authname, 'ask', quote.book.asks)
            bid = (len(bids) and bids[0]) or None
            ask = (len(asks) and asks[0]) or None
            last = quote.last
            path = 'market.basket.%s' % contract
            ctx.res[path].bid = bid and dict(bid)
            ctx.res[path].ask = ask and dict(ask)
            ctx.res[path].last = last and dict(last)

            # add the book as well
            # XXX why don't we just call cmd_book(symbol=contract)?
            m = re.match(".*\.(\w+)$", contract)
            if not m:
                raise RuntimeError, "unknown contract: %s" % contract
            version = m.group(1);
            ctx.res[path].bids = bids
            ctx.res[path].asks = asks
            # and trader's positions
            # XXX near dup of report.cmd_positions
            positions = self.positions(ctx, entity, contract)
            for acct,symbol,position in positions:
                # ordered by entity,account,symbol
                a = dict(acct)
                a['symbol'] = symbol
                a['position'] = position
                ctx.res[path].positions[entity][acct.account] = a
            '''

    def cmd_update(self, ctx, id, size):
        authname = ctx.req.authname
        size = Size(size)
        order = Order.selectone(ctx.env, ctx.db, id=id)
        if order.side == 'bid':
            order = order.update(ctx.db, ctx.ledger, authname, bid=size)
        else:
            order = order.update(ctx.db, ctx.ledger, authname, ask=size)
        ctx.res['market.order'] = dict(order)
        ctx.res.info("Updated order id %d" % (order.id))
    cmd_up = cmd_update

    def res_basket(self, ctx, basket_symbol):
        '''merge underlying and quotes'''
        res = self.res(ctx).basket
        if res:
            return res
        res_underlying = self.res_underlying(ctx, basket_symbol)
        res_quotes = self.res_quotes(ctx, basket_symbol)
        component_symbols = self.component_symbols(ctx, basket_symbol)
        for symbol in component_symbols:
            d = dict(res_underlying[symbol])
            d.update(dict(res_quotes[symbol]))
            res[symbol] = d
        return res

    def res_book(self, ctx, symbol):
        res = self.res(ctx).book[symbol]
        if res:
            return res
        quote = Quote(self.env, ctx.db, symbol, ctx.currency)
        last = quote.last
        book = quote.book
        bids = OrderQ(self.exchange_authname, 'bid', book.bids)
        asks = OrderQ(self.exchange_authname, 'ask', book.asks)
        if last:
            res.last_trade = dict(last)
            res.last_trade.ftime = format_datetime(last.time)
        res.bids = bids
        res.asks = asks
        return res

    def component_symbols(self, ctx, basket_symbol):
        res_underlying = self.res_underlying(ctx, basket_symbol)
        if not res_underlying:
            return ()
        return res_underlying.symbols

    def res_quotes(self, ctx, basket_symbol):
        res = self.res(ctx).quotes
        if res:
            return res
        component_symbols = self.component_symbols(ctx, basket_symbol)
        total = 0
        # XXX finish this -- see quotes.py
        # bus = ctx.bus
        # for symbol in component_symbols:
        #     id = subscribe('market.value.%s' % symbol)
        #     bus.send('market.symbol', Msg(symbol))
        #     msg = bus.recv(id)
        #     value = msg.data
        #     res[symbol].value = Price(value) 
        # XXX deprecate this call to values()
        quotes = []
        for symbol in component_symbols:
            quote = self.quote(ctx.db, symbol=symbol, currency=ctx.currency)
            last = quote.last or Object(price=None)
            bid = quote.bidpop() or Object(limit_price=None)
            ask = quote.askpop() or Object(limit_price=None)
            res[symbol].bid = bid
            res[symbol].ask = ask
            res[symbol].last = last
            quotes.append(quote)
        values = self.values(quotes)
        for symbol,value in values.items():
            total += value
            res[symbol].value = Price(value) 
        total = 0
        high = 0
        high_symbol = None
        high_version = None
        # summarize
        for symbol in component_symbols:
            total += res[symbol].value
            if res[symbol].value > high:
                high = res[symbol].value
                high_symbol = symbol
                high_version = self.parse_symbol(symbol)[1]
        res.total = Price(total)
        res.high = Price(high)
        res.high_symbol = high_symbol
        res.high_version = high_version
        return res

    def values(self, quotes):
        total = 0
        undef_count = 0
        values = {}
        for quote in quotes:
            symbol = quote.symbol
            last = quote.last or Object(price=None)
            bid = quote.bidpop() or Object(limit_price=None)
            ask = quote.askpop() or Object(limit_price=None)
            value = last.price or bid.limit_price or ask.limit_price
            if value is None:
                undef_count += 1
            else:
                total += value
            values[symbol] = value
        # set default values
        for quote in quotes:
            symbol = quote.symbol
            value = values[symbol]
            if value is None:
                value = (self.basket_price - total) / undef_count
                if value <= 0:
                    value = 0
                values[symbol] = value
            assert values[symbol] is not None
        return values


    def res_estimate(self, ctx):
        '''Provide estimated cost, for this trader, of raising each
        contract's bid price to highest in basket, while maintaining
        total basket value ~= basket_price.  (For example, if
        ctx.symbol == 'wiki.FooPage.3', then this function will
        estimate the cost of making each FooPage version the default
        viewable version of the page.) 
        
        Math derived from basket.js.
        '''
        res = self.res(ctx).estimate
        if res:
            return res
        entity = ctx.req.authname
        res_positions = self.res_positions(ctx, entity)
        basket_symbol = self.basket_symbol(ctx.symbol)
        res_quotes = self.res_quotes(ctx, basket_symbol)
        component_symbols = self.component_symbols(ctx, basket_symbol)
        res_book = {}
        for symbol in component_symbols:
            res_book[symbol] = self.res_book(ctx, symbol)

        def estimate_bid(symbol, size, price, cost, net, commands, new_pos):
            price = Price(max(min_price, price))
            reserve = price * size
            cost += reserve
            net += self.basket_price * size - reserve
            commands.append("%s bid %f %f" % (symbol, size, price))
            return dict(symbol=symbol, size=size, price=price, cost=cost, 
                    net=net, commands=commands, new_pos=new_pos)
        def estimate_ask(symbol, size, price, cost, net, commands, new_pos):
            price = Price(min(max_price, price))
            reserve = 0
            baskets_needed = size - new_pos[symbol]
            commands
            if baskets_needed > 0: 
                # buy baskets 
                for s in new_pos:
                    new_pos[s] += baskets_needed
                commands.append("%s bid %f %f" % 
                        (basket_symbol, baskets_needed, self.basket_price))
                reserve += self.basket_price * size
            cost += reserve
            # post ask for individual contract
            new_pos[symbol] -= size
            # allow for profit from selling off contract
            net += price * size - reserve
            commands.append("%s ask %f %f" % (symbol, size, price))
            return dict(symbol=symbol, size=size, price=price, cost=cost, 
                    net=net, commands=commands, new_pos=new_pos)

        min_price = self.basket_price/100
        max_price = self.basket_price - min_price
        new_high = res_quotes.high + (min_price * 1.4)

        for high_symbol in component_symbols:
            new_total = res_quotes.total - \
                    res_quotes[high_symbol].value + new_high
            # init dict to hold new estimated positions 
            new_pos = {}
            for symbol in component_symbols:
                new_pos[symbol] = res_positions.available[symbol] or 0
            # init simulation env 
            sim = dict(symbol=None, size=None, price=None,
                    cost=0, net=0, commands=[], new_pos=new_pos)
            ck_total = 0
            for symbol in component_symbols:
                # calculate new contract value
                value = res_quotes[symbol].value
                if symbol == high_symbol:
                    # set new high price
                    value = new_high
                else:
                    # normalize
                    value = (value * self.basket_price) / new_total
                res[high_symbol].value[symbol] = Price(value)
                # simulate orders needed to reach new contract value
                sim.update(dict(symbol=symbol))
                ck_total += value
                if value > res_quotes[symbol].value:
                    # need to move price up; create bid
                    for o in res_book[symbol].asks:
                        # fill existing asks
                        sim['price'] = o.limit_price
                        sim['size'] = o.ask_pending
                        if sim['price'] > value:
                            # passed best price
                            break
                        sim = estimate_bid(**sim)
                    # set the new inside bid 
                    sim['price'] = value
                    sim['size'] = 1
                    sim = estimate_bid(**sim)
                elif value < res_quotes[symbol].value:
                    # need to move price down; create ask
                    for o in res_book[symbol].bids:
                        # fill existing bids
                        sim['price'] = o.limit_price
                        sim['size'] = o.bid_pending
                        if sim['price'] < value:
                            # passed best price
                            break
                        sim = estimate_ask(**sim)
                    # set new inside ask 
                    sim['price'] = value
                    sim['size'] = 1
                    sim = estimate_ask(**sim)
            res[high_symbol].ck_total = ck_total
            res[high_symbol].cost = sim['cost']
            res[high_symbol].net = sim['net']
            res[high_symbol].commands = sim['commands']
            res[high_symbol].commands_quoted = urllib.quote(
                    '\n'.join(sim['commands']))
            res[high_symbol].new_positions = sim['new_pos']
            res[high_symbol].ratio = round(sim['net']/sim['cost'], 2)

    def res_positions(self, ctx, entity):
        res = self.res(ctx).positions[entity]
        if res:
            return res
        positions = self.positions(ctx, entity)
        for acct,symbol,balance in positions:
            # ordered by entity,account,symbol
            res[acct.account][symbol] = balance
        return res

    # backend methods (don't touch res below here)
        
    def basket_marketmaker(self, ctx, symbol):
        env = self.env
        db = ctx.db
        currency = ctx.currency
        ledger = ctx.ledger
        agent = self.exchange_authname
        target = self.basket_marketmaker_size
        price = self.basket_price

        # find out what we have on order right now
        bids = Order.open_orders(self.env, db, limit_price=price,
            owner=agent, side='bid', symbol=symbol, currency=currency)
        asks = Order.open_orders(self.env, db, limit_price=price,
            owner=agent, side='ask', symbol=symbol, currency=currency)
        bid = None
        ask = None
        bid_pending = 0
        ask_pending = 0
        for o in bids:
            # if o.limit_price != price:
            #     # cancel mispriced order
            #     o.cancel(db, ledger, agent)
            #     continue
            bid = o
            bid_pending += bid.bid_pending
        for o in asks:
            # if o.limit_price != price:
            #     # cancel mispriced order
            #     o.cancel(db, ledger, agent)
            #     continue
            ask = o
            ask_pending += ask.ask_pending

        # handle the bid side
        # only place enough bids to buy back what we've sold
        issued = ledger.balance(db, agent, 'issued', symbol)
        needed = issued - bid_pending
        size = min(target, needed)
        # don't exceed available funds
        available = ledger.balance(db, agent, 'available', currency)
        size = min(size, available/price)
        if size > 0:
            if bid:
                # update an existing order (we don't care which one)
                size += bid.bid_pending
                bid = bid.update(db, ledger, agent,
                        bid=size)
                assert bid
            else:
                # place a new order
                self.order(ctx, owner=agent, size=size, 
                        limit_price=Price(price), symbol=symbol)

        # handle the ask side
        size = target - ask_pending
        if size > 0:
            # create baskets
            a = ledger.mkleg(db, entity=agent, account='available',
                    debit=size, symbol=symbol)
            b = ledger.mkleg(db, entity=agent, account='minted',
                    credit=size, symbol=symbol)
            ledger.post(db,agent,(a,b), 'mint %s baskets' % symbol)
            if ask:
                # update an existing order (we don't care which one)
                size += ask.ask_pending
                # print "updating", size
                ask = ask.update(db, ledger, agent,
                        ask=size)
                assert ask
            else:
                # create new
                size *= -1
                self.order(ctx, owner=agent, size=size, 
                        limit_price=Price(price), symbol=symbol)

    def basket_url(self, symbol):
        return None

    def expire(self, db, ledger, agent, symbol, currency,
            **kwargs):
        # cancel expired orders
        for side in ('bid', 'ask'):
            expired = Order.open_orders(self.env, db,
                side=side,
                symbol=symbol, currency=currency,
                append='expires < %f' % time.time())
            for o in expired:
                o.cancel(db, ledger, agent)

    def match(self, ctx):
        env = self.env
        db = ctx.db
        ledger = ctx.ledger
        # these are set by child class
        currency = self.currency
        prefix = self.namespace + '.'
        agent = self.exchange_authname
        total_fills = 0
        total_cancels = 0
        total_stops = 0
        symbols = Order.open_symbols(env, db, prefix=prefix, currency=currency)
        for symbol in symbols:
            # if symbol == 'wiki.FooPage.3':
            #     import pdb; pdb.set_trace()
            basket = self.component_symbols(ctx, symbol)
            kw = dict(db=db, ledger=ledger, agent=agent, basket=basket,
                    symbol=symbol, currency=currency)
            redo = False
            self.expire(**kw)
            while True:
                (market_fills, market_cancels) = self.match_market(**kw) 
                stops = self.trigger_stops(**kw) 
                (limit_fills, limit_cancels) = self.match_limit(**kw)
                # print "MATCHED LIMIT"
                total_fills += market_fills + limit_fills
                total_cancels += market_cancels + limit_cancels
                total_stops += stops
                if market_fills or limit_fills or market_cancels or \
                        limit_cancels or stops:
                    continue
                break
        return (total_fills, total_cancels, total_stops)
    
    def match_limit(self, db, ledger, agent, symbol, currency, basket):
        '''fill limit orders'''
        fills = 0
        cancels = 0
        bids = Order.limit_orders(self.env, db,
            side='bid', symbol=symbol, currency=currency)
        asks = Order.limit_orders(self.env, db,
            side='ask', symbol=symbol, currency=currency)
        # XXX possible memory hog
        bids = OrderQ(self.exchange_authname, 'bid', bids)
        asks = OrderQ(self.exchange_authname, 'ask', asks)
        while True:
            fill = self.find_fill(db, bids, asks)
            if not (fill):
                break
            assert fill.bid.limit_price >= fill.price >= fill.ask.limit_price
            (bid, ask) = Order.match(db, ledger, agent, fill.bid, fill.ask,
                    price=fill.price, basket=basket)
            # dequeue if completely filled
            if not bid.bid_pending:
                bids.dq(bid)
            if not ask.ask_pending:
                asks.dq(ask)
            fills += bid.filled and 1
            cancels += bid.cancelled and 1
            fills += ask.filled and 1
            cancels += ask.cancelled and 1
        return (fills, cancels)

    def find_fill(self, db, bids, asks):
        '''returns a Fill object, or None'''
        # import pdb; pdb.set_trace()
        if not (len(bids) and len(asks)):
            return None
        bid = bids[0]
        ask = asks[0]

        if bid.limit_price < ask.limit_price:
            # spread exists
            return None

        if bid.owner == ask.owner:
            return self.handle_crossed_orders(db, bids, asks)

        fill = Fill(bid, ask)

        return fill

    def handle_crossed_orders(self, db, bids, asks):
        '''Called if trader tried to cross their own order -- we can't
        allow a trade to take place.  We leave both orders on the
        books, but we ignore one of the two orders by popping it off
        the queue, and recurse, searching for fills.  If we
        finally find a good fill, we return a Fill object, just like
        find_fill().
        '''
        # XXX rewrite this whole damn thing -- probably by moving most
        # XXX of the functionality into OrderQ and Fill
        ledger = self.ledger
        agent = self.exchange_authname
        def pop_discount(bids, asks):
            def discount(orders):
                '''how much price improvement we would lose if
                we matched against next order instead of
                current'''
                if len(orders) < 2:
                    return Price("infinity")
                current = orders[0]
                next = orders[1]
                price = current.limit_price
                next_price = next.limit_price
                discount = abs(next_price - price)
                return discount
            bid_discount = discount(bids)
            ask_discount = discount(asks)
            if bid_discount <= ask_discount:
                bids.pop(0)
            else:
                asks.pop(0)
        def try_fill(b, a):
            fill = self.find_fill(db, b, a)
            if fill:
                bids[:] = OrderQ(self.exchange_authname, 'bid', b)
                asks[:] = OrderQ(self.exchange_authname, 'ask', a)
                return fill
            return None
        # make a copy of bids and asks 'cause we're going to modify,
        # recurse, and retry, sorta like an NFA
        b = OrderQ(self.exchange_authname, 'bid', bids)
        a = OrderQ(self.exchange_authname, 'ask', asks)
        b.reload()
        a.reload()
        if not (len(b) and len(a)):
            bids[:] = b
            asks[:] = a
            return None
        # if bid price is higher than ask...
        if b[0].limit_price > a[0].limit_price:
            # we assume trader wants the newer order to prevail --
            # cancel the older one
            fill = Fill(b[0], a[0])
            self.env.log.debug('cancel crossed order: ' +
                    str(fill.oldest))
            ledger.post(db,agent,(), 'cancel crossed order %s' % fill.oldest)
            fill.oldest.cancel(db, ledger, agent)
            if fill.oldest is b[0]:
                b.pop(0)
            elif fill.oldest is a[0]:
                a.pop(0)
            else:
                assert False
            return try_fill(b, a)
        # this pops either b or a, not both
        pop_discount(b, a)
        # try to fill -- this updates the contents of bids and asks
        # queues (from b and a) if we find a good fill
        fill = try_fill(b, a)
        if fill: 
            return fill
        # resulted in no match; try popping the newest
        b = OrderQ(self.exchange_authname, 'bid', bids)
        a = OrderQ(self.exchange_authname, 'ask', asks)
        if b[0].ctime > a[0].ctime:
            b.pop(0)
        else:
            a.pop(0)
        fill = try_fill(b, a)
        if fill: 
            return fill
        # ok, try popping the oldest
        b = OrderQ(self.exchange_authname, 'bid', bids)
        a = OrderQ(self.exchange_authname, 'ask', asks)
        if b[0].ctime < a[0].ctime:
            b.pop(0)
        else:
            a.pop(0)
        fill = try_fill(b, a)
        if fill: 
            return fill
        # no joy; give up
        return None

            
    def match_market(self, db, ledger, agent, symbol, currency, basket):
        '''fill market orders'''
        fills = 0
        cancels = 0
        market_bids = Order.market_orders(self.env, db,
            side='bid', symbol=symbol, currency=currency)
        market_asks = Order.market_orders(self.env, db,
            side='ask', symbol=symbol, currency=currency)
        # XXX possible memory hog
        market_bids = list(market_bids)
        market_asks = list(market_asks)
        if market_bids:
            asks = Order.limit_orders(self.env, db,
                side='ask', symbol=symbol, currency=currency)
            for ask in asks:
                if not market_bids:
                    break
                fill_price = ask.limit_price
                assert fill_price
                while True:
                    bid = market_bids.pop(0)
                    if bid.owner == ask.owner:
                        # trader tried to hit their own limit order --
                        # skip their market order
                        continue
                (bid, ask) = Order.match(db, ledger, agent, bid, ask,
                        price=fill_price, basket=basket)
                fills += bid.filled and 1
                cancels += bid.cancelled and 1
                fills += ask.filled and 1
                cancels += ask.cancelled and 1
        if market_asks:
            bids = Order.limit_orders(self.env, db,
                side='bid', symbol=symbol, currency=currency)
            for bid in bids:
                if not market_asks:
                    break
                fill_price = bid.limit_price
                assert fill_price
                while True:
                    ask = market_asks.pop(0)
                    if bid.owner == ask.owner:
                        # trader tried to hit their own limit order --
                        # skip their market order
                        continue
                (bid, ask) = Order.match(db, ledger, agent, bid, ask, 
                        price=fill_price, basket=basket)
                fills += bid.filled and 1
                cancels += bid.cancelled and 1
                fills += ask.filled and 1
                cancels += ask.cancelled and 1
        return (fills, cancels)

    def order(self, ctx, owner, size, **kwargs):
        """Create an order to buy or sell 'size' items.  Orders with
        different denominations go into different books; we don't
        perform automatic currency conversion.  Negative size means
        sell, positive size means buy.  Kwargs are specific to the
        instrument being traded.  Returns order object."""
        env = ctx.env
        db = ctx.db
        ledger = ctx.ledger
        # allow callers to override ctx.symbol by using kwargs
        kwsymbol = kwargs.pop('symbol',None)
        if kwsymbol:
            symbol = kwsymbol
        else:
            symbol = ctx.symbol
        currency = ctx.currency
        basket = self.component_symbols(ctx, symbol)
        if not size:
            raise ValueError("order size can't be zero") 
        if size > 0:
            order = Order.create(env, db, ledger, owner=owner,
                    symbol=symbol, currency=currency,
                    bid = size, basket=basket,
                    **kwargs)
        else:
            order = Order.create(env, db, ledger, owner=owner,
                    symbol=symbol, currency=currency,
                    ask = abs(size), basket=basket,
                    **kwargs)
        return order

    def parse_symbol(self, symbol):
        return None, None

    def positions(self, ctx, entity=None, symbol=None):
        # XXX replace all this with a single sql query 
        ledger = self.ledger
        db = ctx.db
        if symbol:
            symbols = (symbol,)
        else:
            symbols = list(ledger.symbols(db))
            symbols.sort(self.by_symbol)
        for acct in ledger.accounts(db, entity=entity):
            for symbol in symbols:
                if symbol == ctx.currency:
                    continue
                balance = acct.balance(symbol)
                if not balance:
                    continue
                yield acct, symbol, balance

    def quote(self, db, symbol, currency, last_count=1):
        """Return a consolidated quote containing order book and
        'last_count' number of trades."""
        self.env.log.debug("quote() called for " + symbol)
        quote = Quote(self.env, db, symbol=symbol, currency=currency,
                last_count=last_count)
        return quote

    def trigger_stops(self, db, ledger, agent, symbol, currency, **kwargs):
        '''convert any triggered stop orders to limit orders'''
        stops = 0
        last = None
        quote = self.quote(db, symbol=symbol, currency=currency)
        if quote.last:
            last = quote.last.price
        if not last:
            return False
        bids = Order.stop_orders(self.env, db,
            side='bid', symbol=symbol, currency=currency)
        asks = Order.stop_orders(self.env, db,
            side='ask', symbol=symbol, currency=currency)
        for bid in bids:
            if last > bid.stop_price:
                # stop has been triggered; remove stop
                bid.update(db, ledger, agent,
                        stop_price=None)
                stops += 1
        for ask in asks:
            if last < ask.stop_price:
                # stop has been triggered; remove stop
                ask.update(db, ledger, agent,
                        stop_price=None)
                stops += 1
        return stops

class Fill(object):
    def __init__(self, bid, ask):
        self.bid = bid
        self.ask = ask

    def oldest(self):
        orders = [self.bid, self.ask]
        def by_ctime(a,b): return cmp(a.ctime, b.ctime)
        orders.sort(by_ctime)
        return orders[0]
    oldest = property(oldest)

    def price(self):
        # use the oldest limit price; newer orders will be improved
        return self.oldest.limit_price
    price = property(price)

class OrderQ(list):
    # XXX this should be expanded; move a lot of the matching into here

    def __init__(self, exchange_authname, side, data):
        assert side in ('bid', 'ask')
        self.exchange_authname = exchange_authname
        self.side = side
        self[:] = list(data)
        self.refresh()
    
    def refresh(self):
        # remove canceled orders
        for o in self:
            if o.status > 0:
                self.remove(o)
        # re-sort
        self.sort(self.by_priority)

    def reload(self):
        # reload all orders from db
        # XXX this should really redo the original SQL query, maybe
        # after we move this to order.py
        for o in self:
            self.remove(o)
            self.append(o.reload())
        self.refresh()
    
    def dq(self,order):
        for o in self:
            if o.id == order.id:
                self.remove(o)
                break

    def by_priority(self, x, y):
        # sort by price
        if x.limit_price != y.limit_price:
            if self.side == 'bid':
                return cmp(y.limit_price, x.limit_price)
            if self.side == 'ask':
                return cmp(x.limit_price, y.limit_price)
        # put customer orders first
        if x.owner != y.owner:
            if x.owner == self.exchange_authname:
                return 1
            if y.owner == self.exchange_authname:
                return -1
        # give up and sort by time
        return cmp(x.ctime, y.ctime)

class Object(dict):

    def __init__(self, **kwargs):
        self.update(kwargs)

    def __getattr__(self, name):
        # XXX won't pickle without this -- why?
        if name.startswith('__'):
            super(Object, self).__getattr__(name)
        return self[name]