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

import re
import sys
import types

from tracmarket.mq import *

class Response(dict):
    '''An hdf-like response object, simpler and more pythonic than
    hdf, with more of the features we need, such as the ability to
    return entire subtrees.  Major reason for using this is to provide
    better isolation between UI modules and command interpreters -- I
    didn't want the interpreters to know anything about hdf, and the
    UI will often not be web or clearsilver anyway.  Side benefit is
    that it lessens dependence on any future decision trac core team
    might make in regards to use of clearsilver and hdf or HDFWrapper.
    Provides convenience methods _to_hdf() and _from_hdf() in the
    meantime.

    >>> res = Response()
    >>> res.foo.bar = 'baz'
    >>> res.foo.bar
    'baz'
    >>> res.foo
    {'bar': 'baz'}
    >>> assert res.foo
    >>> res.foo.baz.bing
    {}
    >>> assert not res.foo.baz.bing
    >>> res.foo
    {'bar': 'baz'}
    >>> assert not res.foo.baz.bing
    >>> res['foo']
    {'bar': 'baz'}
    >>> res['foo']['bar']
    'baz'
    >>> res['foo.bar']
    'baz'
    >>> res['foo.baz.bing'] = 3
    >>> res['foo.baz'] 
    {'bing': 3}
    >>> res['foo.baz.bing'] 
    3
    >>> res.foo.baz.bing
    3
    >>> assert res.foo.baz.bing
    >>> assert res.foo.baz.bing == 3
    >>> res['foo.num.4.blah'] = 'a'
    >>> res['foo.num.4.blah'] 
    'a'
    >>> res.foo.num[4].blah
    'a'
    >>> res.foo['num.4'].blah
    'a'
    >>> res['foo.num.5'] = 'b'
    >>> res.foo.num
    {'5': 'b', '4': {'blah': 'a'}}
    >>> res.foo.num[5]
    'b'
    >>> res.foo.num[6] = 'c'
    >>> res.foo.num
    {'5': 'b', '4': {'blah': 'a'}, '6': 'c'}
    >>> res.L.a = ('a','b',dict(foo=1,bar=2))
    >>> res.L.a._type
    'list'
    >>> res.L.a
    ['a', 'b', {'foo': 1, 'bar': 2}]
    >>> res.L.a[2]
    {'foo': 1, 'bar': 2}
    >>> res.L.a[2].foo
    1
    >>> res.L.a[1]
    'b'
    >>> list(res.L.a)
    ['a', 'b', {'foo': 1, 'bar': 2}]
    >>> res.L.a
    ['a', 'b', {'foo': 1, 'bar': 2}]
    >>> len(res.L.a)
    3
    >>> res.d.a = dict(a=1,b=2,c=3)
    >>> res.d.a.c
    3
    >>> res.foo
    {'baz': {'bing': 3}, 'num': {'5': 'b', '4': {'blah': 'a'}, '6': 'c'}, 'bar': 'baz'}

    '''

    def __init__(self, bus, path, name=None, val=None, typ='dict'):
        self._bus = bus
        self._path = path
        self._name = name
        self._type = typ
        if not val:
            return
        if type(val) in (list, tuple, types.GeneratorType):
            self._type = 'list'
            for v in val:
                self.append(v)
            return
        if type(val) in (dict,):
            for k,v in val.items():
                self[k] = v
            return
        assert ValueError, "unsupported Response type: %s" % val

    def __iter__(self):
        keys = []
        for k,v in super(Response, self).items():
            if str(k).startswith('_'):
                continue
            # only include Response objects if they're populated
            if isinstance(v, Response) and not len(v):
                continue
            try:
                # convert integer strings to integers
                k = int(k)
                assert k == float(k)
            except:
                pass
            keys.append(k)
        keys.sort()
        assert self._type in ('dict', 'list')
        if self._type == 'dict':
            for k in keys:
                yield str(k)
        if self._type == 'list':
            for k in keys:
                yield self[str(k)]

    def __getattr__(self, name):
        """allow self.foo.bar"""
        val = self[name]
        return val

    def __setattr__(self, name, val):
        # import pdb; pdb.set_trace()
        name = str(name)
        if name.startswith('_'):
            self.__dict__[name] = val
        elif name.startswith('__'):
            super(Response, self).__setattr__(name, val)
        else:
            self[name] = val

    def __getitem__(self, name):
        """allow self['foo.bar']"""
        name = str(name)
        item, child = self._parts(name)
        val = super(Response, self).get(item, None)
        if val is None:
            val = self[item] = Response(bus=self._bus, path=self._mkpath(), name=item)
        if child:
            return val[child]
        return val 

    def __setitem__(self, name, val):
        """allow self['foo.bar'] = 'baz'"""
        if self._type == 'list' and len(self) > 0 and type(name) is int:
            assert len(self) > int(name)
        self._set(name, val)

    def _set(self, name, val):
        name = str(name)
        # if name == 'order_count':
        #     import pdb; pdb.set_trace()
        assert not name.startswith('_'), "invalid res name = " + name
        item, child = self._parts(name)
        if type(val) in (list, tuple, dict):
            val = Response(bus=self._bus, path=self._mkpath(), 
                    name=item, val=val)
        if child:
            obj = self[item]
            obj[child] = val
        else:
            msg_data = None
            if type(val) is Response:
                if len(val):
                    msg_data = val.as_struct()
            else:
                msg_data = val
            if msg_data is not None:
                i=1
                sender=None
                while True:
                    try:
                        frame_name = sys._getframe(i).f_code.co_name
                        if not frame_name.startswith('_'):
                            sender = frame_name
                            break
                        i += 1
                    except:
                        break
                path = self._mkpath()
                if path:
                    group_parts = ['res', path, item]
                else:
                    group_parts = ['res', item]
                group = '.'.join(group_parts)
                # XXX turning off copy because some objects not yet pickleable
                msg = Msg(msg_data, sender=sender, cp=False)
                self._bus.send(group, msg)
            super(Response, self).__setitem__(item, val)

    def __len__(self):
        # only count objects that are populated
        try:
            return len(list(self.__iter__()))
        except:
            return 0

    def _mkpath(self):
        if not self._name:
            return ''
        if not self._path:
            return self._name
        return '.'.join((self._path, self._name))

    def __repr__(self):
        return repr(self.as_struct())

    def as_struct(self):
        '''return contents of self as python structure of nested lists
        and dicts'''
        assert self._type in ('dict', 'list')
        if self._type == 'dict':
            res = {}
            for k,v in self.items():
                if isinstance(v, Response):
                    if len(v):
                        res[k] = v.as_struct()
                else:
                    res[k] = v
        if self._type == 'list':
            res = []
            for v in list(self):
                if isinstance(v, Response):
                    if len(v):
                        res.append(v.as_struct())
                else:
                    res.append(v)
        return res

    def append(self, val):
        self._type = 'list'
        name = len(self)
        self._set(name, val)
    
    def items(self):
        assert self._type == 'dict'
        items = []
        for k in self.__iter__():
            items.append((k,self[k]))
        return items

    def info(self, text):
        self._message('info', text)

    def warning(self, text):
        self._message('warning', text)

    def error(self, text):
        self._message('error', text)

    def _message(self, type, text):
        if not self.market.messages:
            self.market.messages = []
        m = dict(text=text, type=type)
        self.market.messages.append(m)

    def keys(self):
        assert self._type == 'dict'
        keys = []
        for k in self.__iter__():
            keys.append(k)
        return keys

    def _parts(self, name):
        names = str(name).split('.')
        item = names[0]
        if len(names) > 1:
            child = '.'.join(names[1:])
        else:
            child = None
        return item, child

    def dump(self, prefix=None):
        '''return a string dump in "foo.bar.baz = 'bing'\n" format'''
        struct = self.as_struct()
        out = ''
        for name, val in self._walk_struct(struct):
            out += "%s = %s\n" % (name, val) 
        return out

    def _walk_struct(self, struct, prefix=None, recurse=True):
        index = None
        if issubclass(struct.__class__, (list, tuple)):
            index = range(len(struct))
        elif issubclass(struct.__class__, dict):
            index = struct.keys()
        if index:
            for i in index:
                try:
                    val = struct[i]
                except TypeError:
                    raise ValueError, \
                        "expected index, got %s, dir = %s" % (type(i), dir(i))
                if prefix:
                    name = prefix + "." + str(i)
                else:
                    name = str(i)
                if recurse:
                    for name, val in self._walk_struct(val, prefix=name):
                        yield name, val
                else:
                    yield name, val
        else:
            yield prefix, struct

    def to_hdf(self, hdf, prefix=None):
        '''populate hdf from self'''
        # XXX refactor to use _walk_struct(..., recurse=False)
        if not len(self):
            return
        struct = self.as_struct()
        # only iterate over self's immediate children; set_value()
        # will recurse for us
        if self._type == 'list':
            for i in range(len(self)): 
                val = struct[i]
                if prefix:
                    name = prefix + "." + i
                else:
                    name = i
                hdf.set_value(name, val)
        if self._type == 'dict':
            for k in self.keys(): 
                val = struct[k]
                if prefix:
                    name = prefix + "." + k
                else:
                    name = k
                hdf.set_value(name, val)

    def from_hdf(cls, hdf):
        def hdf_tree_walk(node, name=None):
            res = Response(bus=self._bus, path=self._mkpath(), name=name)
            while node:
                var = node.name() 
                val = node.value()
                # XXX can't handle nodes with both value and children
                if node.child():
                    child = hdf_tree_walk(node.child(), var)
                    res[var] = child
                else:
                    res[var] = val
                node = node.next()
            return res
        # import pdb; pdb.set_trace()
        res = hdf_tree_walk(hdf.child())
        return res
    from_hdf = classmethod(from_hdf)