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

import math
import os
import sys
import time
import types
import urllib

from trac.core import *
from trac.db import Table, Column, Index
from trac.env import IEnvironmentSetupParticipant

from tracmarket.api import *
from tracmarket.db import *
from tracmarket.ledger import ILedger, MissingAccount
from tracmarket.mq import *
from tracmarket.util import *
from tracmarket.response import *

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

class CommandInterpreter(Component):
    implements(IMessageBusSubscriber)

    default_verb = 'show'

    ledgers = ExtensionPoint(ILedger)
    interpreters = ExtensionPoint(ICommandInterpreter)

    namespace = None

    def __init__(self):
        # XXX deprecate
        self.ledger = iter(self.ledgers).next()
        self.exchange_authname = self.config.get(
            'market', 'exchange_authname', 'tracmarket')
        self.currency = self.config.get('market', 'currency', 'TMP')
        self.basket_marketmaker_size = Size(self.config.get(
            'market', 'basket_marketmaker_size', 500))
        self.basket_price = Price(self.config.get(
            'market', 'basket_price', 100))
        agent = self.exchange_authname
        db = self.env.get_db_cnx()
        # these exit silently if the accounts already exist in the db
        self.ledger.mkaccount(db, entity=agent, 
                account='minted', type='liability',
                description='baskets, contracts, and currency created by %s' 
                    % agent)
        self.ledger.mkaccount(db, entity=agent, 
                account='issued', type='asset',
                description='issued baskets (components held by traders)')
        self.ledger.mkaccount(db, entity=agent, 
                account='available', type='asset',
                description='available assets')
        self.ledger.mkaccount(db, entity=agent, 
                account='reserve', type='asset',
                description='reserved assets (order margin etc.)')
        # XXX do we need this, or does db commit on cnx close?
        db.commit()

    # IMessageBusSubscriber methods

    def solicit(self, bus):
        # XXX deprecate in favor of ctl._route_cmd
        # bus.subscribe('market.cmd', reader=self._run_cmd)
        gre = re.compile('^market\.cmd\.%s\.*' % self.namespace)
        bus.subscribe(gre, reader=self._run_cmd)

    def _run_cmd(self, bus, group, msg):
        # receive a command, parse and execute it; responses go to bus
        ctx = bus.ctx
        cmd = msg.data
        cmx = self.parse_cmd(ctx, cmd)
        if cmx:
            cmx()

    # ICommandInterpreter methods

    def parse_cmd(self, ctx, cmd):
        """Returns a Context object that, when called, will execute
        cmd.  Returns None if this specialist can't handle this
        command; if throw=True, then throws an exception explaining
        why.  Calling the Context object returns a clearsilver
        template name and optional mime-type (default text/html).
        Optional context (such as currency) can be requested in req.
        Any session variables must be carried in req.  Authenticated
        user, if needed by command, must be available as req.authname.
        Results are returned as a Response object, suitable for stuffing 
        into hdf if the *_ui module chooses to."""
        cmx = Cmd(ctx=ctx, cmd=cmd, interpreter=self)
        return cmx

    # XXX deprecate
    def res(self, ctx):
        # return ctx.res.market[self.namespace]
        return ctx.res.market

    # backend methods (don't touch res below here)

    def by_symbol(self, a, b):
        if type(a) is dict:
            a = a['symbol']
            b = b['symbol']
        aparts = a.split('.')
        bparts = b.split('.')
        for i in range(len(aparts)):
            apart = aparts[i]
            if i > len(bparts) - 1:
                return 1
            bpart = bparts[i]
            try:
                apart = float(apart)
            except:
                pass
            try:
                bpart = float(bpart)
            except:
                pass
            c = cmp(apart, bpart)
            if c:
                return c
        return cmp(a,b)

    def ck_accounts(self, ctx):
        # XXX use perms -- for now go ahead and let anonymous play
        # if authname == 'anonymous':
        #     return
        env = self.env
        db = ctx.db
        authname = ctx.req.authname
        ledger = self.ledger
        currency = self.currency
        agent = self.exchange_authname
        # trader account setup
        try:
            ledger.normal(db, entity=authname, account='available')
            ledger.normal(db, entity=authname, account='reserve')
            ledger.normal(db, entity=authname, account='granted')
        except MissingAccount:
            ledger.mkaccount(db, entity=authname, 
                    account='available', type='asset',
                    description='available assets')
            ledger.mkaccount(db, entity=authname, 
                    account='reserve', type='asset',
                    description='reserved assets (order margin etc.)')
            # currency granted to this trader as seed funding
            ledger.mkaccount(db, entity=authname, 
                    account='granted', type='liability',
                    description='grants to %s from %s' % (authname,agent))
            self.grant(ctx, initial=True)

    def content_url(self):
        return None

    def basket_symbol(self):
        return None

    def grant(self, ctx, initial=False):
        '''(de)allocate seed funds such that each trader has enough to
        trade one of each existing basket'''
        env = self.env
        db = ctx.db
        authname = ctx.req.authname
        ledger = self.ledger
        currency = self.currency
        agent = self.exchange_authname
        if authname == agent:
            # don't grant points to exchange agent
            return
        basket_count = 0
        for interpreter in self.interpreters:
            if hasattr(interpreter, 'basket_count'):
                basket_count += interpreter.basket_count()
        granted = ledger.balance(db, authname, 'granted', currency)
        grant = (basket_count * self.basket_price) - granted
        # provide ability to hardcode minimum available balance
        # (e.g. training mode)
        minbal = Price(self.config.get( 'market', 'grant_minimum_balance', '0'))
        available = ledger.balance(db, authname, 'available', currency)
        if minbal > 0:
            mingrant = minbal - available
        else:
            mingrant = Price("infinity") * -1
        grant = max(grant, mingrant)
        if grant == 0:
            return
        reserve = ledger.balance(db, authname, 'reserve', currency)
        if grant > 0:
            # increase grant (slowly; discourage manipulation of page count)
            # don't grant more than 10% of the total page count
            page_factor = float(
                    self.config.get('market', 'grant_page_factor', .1))
            maxgrant = self.basket_price * basket_count * page_factor
            # don't grant more than 100% of trader's reserve funds
            reserve_factor = float(
                    self.config.get('market', 'grant_reserve_factor', 1))
            maxgrant = min(maxgrant, reserve * reserve_factor)
            # don't grant newbies more than enough to trade 5 baskets
            initial_limit = float(
                    self.config.get('market', 'grant_initial_limit', 5))
            if initial:
                maxgrant = self.basket_price * initial_limit
            grant = int(min(grant, maxgrant))
            if initial:
                # provide ability to hardcode initial grant 
                grant = float(
                    self.config.get('market', 'grant_initial', grant))
            grant = max(grant, mingrant)
            if not grant:
                return
            a = ledger.mkleg(db, entity=authname, 
                    account='available', debit=grant, symbol=currency)
            b = ledger.mkleg(db, entity=authname, 
                    account='granted', credit=grant, symbol=currency)
            ledger.post(db, agent, (a, b), 
                    '%s grants %f %s seed funding to %s' %
                    (agent, grant, currency, authname))
        else:
            # decrease grant (rapidly; recover quickly from manipulation)
            no_decrease = int(
                    self.config.get('market', 'grant_no_decrease', 1))
            if no_decrease:
                return
            grant = abs(grant)
            a = ledger.mkleg(db, entity=authname, 
                    account='available', credit=grant, symbol=currency)
            b = ledger.mkleg(db, entity=authname, 
                    account='granted', debit=grant, symbol=currency)
            try:
                ledger.post(db, agent, (a, b),
                    '%s reduces %s seed funding liability ' +
                    '(%d fewer baskets on site)' % (agent, authname, grant))
            except InsufficientFunds:
                # either the trader's out of available funds, or we
                # tried to decrease below total granted 
                pass

    def query_timer(self, ctx, start, end):
        elapsed = end - start
        if elapsed > .1:
            self.env.log.info(
                "cmd took %f seconds: %s" % (elapsed, ctx.cmd))

    def pre_cmd(self, ctx):
        '''housekeeping to run before every command'''
        db = ctx.db
        # only run granting once every 24 hours for each trader
        timer_name = "grant_period_" + ctx.req.authname
        timer = Timer.control(env=self.env, db=db, name=timer_name)
        grant_period = self.config.get('market', 'grant_period', 24 * 3600)
        if timer.expired(grant_period):
            # granting runs for this trader only
            self.grant(ctx)
            timer.reset()
        # show balance *after* granting 
        ctx.res.market.current_balance = ctx.ledger.balance(
                db, ctx.req.authname, 'available', ctx.currency)
        ctx.res.market.currency = ctx.currency

    def cmd_ping(self, ctx):
        ctx.res.market.ping = 'ping response ' + str(time.time())

# XXX deprecate in favor of e.g. traders.py technique
class Cmd(dict):
    '''A command object.

    This parser implements an "object [verb [args]]" grammar.  An
    object's behavior in the absence of verb or args is
    class-dependent.  
    
    Example commands:

    show FooPage order book: 
    
        wiki.FooPage 
    
    buy 50 FooPage version 3 @ .23 TMP:

        wiki.FooPage.3 b 50 .23 TMP

    cancel order 1234:

        order.1234 cancel

    show portfolio:

        portfolio 
    
    '''

    def __init__(self, ctx, cmd, interpreter):
        self.cmd = cmd
        tokens = self.tokenize(cmd)
        symbol = tokens.pop(0)
        parts = symbol.split('.', 2)
        namespace = parts[0]
        if not interpreter.namespace:
            return None
        if not namespace == interpreter.namespace:
            return None
        if tokens:
            args = tokens[:]
            verb = args.pop(0)
        else:
            args = None
            verb = None
        if not verb:
            verb = interpreter.default_verb
        func = self.parse_verb(interpreter, verb)
        # create Context object
        currency = interpreter.currency
        # XXX deprecate
        ctx.res.market.cmd = cmd
        ctx.res.market.currency = currency
        ctx.res.market.symbol = symbol
        ctx.res.market.namespace = namespace
        ctx.res.market.verb = verb
        ctx.res.market.args = args
        # import pdb; pdb.set_trace()
        kw = dict(ctx=ctx, interpreter=interpreter, 
            namespace=namespace, func=func,
            symbol=symbol, verb=verb, args=args, currency=currency)
        self.update(kw)

    def __getattr__(self, name):
        if self.has_key(name):
            return self[name]
        return getattr(self.ctx, name)

    def parse_verb(self, interpreter, verb):
        method = "cmd_%s" % verb
        if not hasattr(interpreter, method):
            raise SyntaxError, "unknown verb: %s: %s: %s" % (
                verb, self.cmd, interpreter)
        return getattr(interpreter, method)

    def tokenize(self, cmd):
        # XXX handle quoted arguments
        tokens = cmd.split()
        return tokens

    def __call__(self):
        '''Execute command.'''
        ctx = self.ctx
        interpreter = self.interpreter
        func = self.func
        args = self.args
        start = time.time()
        interpreter.ck_accounts(ctx)
        # call any pre-execution method
        if hasattr(interpreter, "pre_cmd"):
            getattr(interpreter, "pre_cmd")(self)
        # call the cmd_* method
        if args:
            res = func(self, *args)
        else:
            res = func(self)
        # call any post-execution method
        if hasattr(interpreter, "post_cmd"):
            getattr(interpreter, "post_cmd")(self)
        end = time.time()
        interpreter.query_timer(self, start, end)
        # XXX deprecate
        return res

class Timer(DbObject):
    '''a set of simple, named, persistent timers'''

    VERSION = 1
    TABLE = Table('timer', key=('name'))[
                Column('name'),
                Column('tick', type='numeric'),
            ]
    NAME = TABLE.name
    COLUMNS = [ c.name for c in TABLE.columns ]

    def _set_defaults(self):
        self.chattr(tick=0)

    def control(cls, env, db, name):
        timer = cls.selectone(env, db, name=name)
        if not timer:
            timer = cls(env, db, name=name, tick=0)
            timer = timer.insert()
        return timer
    control = classmethod(control)

    def expired(self, period):
        if time.time() > self.tick + float(period):
            return True
        return False

    def reset(self):
        self.update(tick=time.time())


class InitCommand(InitDB):
    implements(IEnvironmentSetupParticipant)
    dbobjects = (Timer,)