# Dictionaries

import itertools

import UserDict

def is_dict(value): return hasattr(value, 'keys')

class DictProxy(UserDict.DictMixin):

    '''A proxy that forwards all accesses to an inner dict.'''

    def __init__(self, inner=None):

        if inner == None: inner = {}

        self.inner = inner

    def keys(self): return self.inner.keys()

    def __getitem__(self, key): return self.inner[key]

    def __setitem__(self, key, value): self.inner[key] = value

    def __delitem__(self, key): del self.inner[key]

class KeyExistsError(KeyError):

    def __init__(self, key):

        KeyError.__init__(self, key)

        self.key = key

class OnceOnlyDict(DictProxy):

    '''A dict that only allows each key to be assigned once (no overwriting).'''

    def __setitem__(self, key, value):

        if key in self.inner: raise KeyExistsError(key)

        DictProxy.__setitem__(self, key, value)

class IdCompared:

    '''A value that's compared using `is` instead of ==.

    Do not use this for strings as they are interned, causing `is` to have the

    same meaning as ==.

    '''

    def __init__(self, value): self.value = value

    def __eq__(self, other):

        return (other != None and other.__class__ == self.__class__

            and other.value is self.value)

    def __hash__(self): return id(self.value)

class IdDict(dict):

    '''A dict that stores objects by id()'''

    def add(self, *values):

        for value in values: self[id(value)] = value

        return self

    def add_vars(self, vars_): return self.add(*vars_.values())

class MergeDict:

    '''A dict that checks each of several dicts'''

    def __init__(self, *dicts): self.dicts = dicts

    def __getitem__(self, key):

        for dict_ in self.dicts:

            try: return dict_[key]

            except KeyError: pass

        raise # reraise last KeyError

class AttrsDictView:

    '''A dict view of an object's attributes

    @pre If you want __iter__() to work, value must have a __dict__

    '''

    def __init__(self, value): self.value = value

    def __iter__(self): return iter(self.value.__dict__)

    def __getitem__(self, key): return getattr(self.value, key)

import util

def make_hashable(value):

    if isinstance(value, list): value = tuple(value)

    elif isinstance(value, dict): value = util.NamedTuple(**value)

    return value

def join(dict0, dict1):

    '''Joins dict0 (A->B mapping) to dict1 (B->C mapping) SQL-style.

    If a value in dict0 has no key in dict1, uses the value itself.

    '''

    new_dict = {}

    for out, in_ in dict0.iteritems():

        try: out_value = dict1.get(in_, in_) # use in_ if no match found

        except TypeError: out_value = in_ # unhashable type

        new_dict[out] = out_value

    return new_dict