# Useful functions and classes

import collections

#### Function wrappers for statements

def noop(*args, **kw_args): pass

def and_(a, b): return a and b

#### Object metadata

def type_name(value): return type(value).__name__

def module(value): return type(value).__module__.split('.')

def root_module(value): return module(value)[0]

#### Type checking and conversion

class ConstraintError(ValueError):

    def __init__(self, check_func, value):

        ValueError.__init__(self, str(value)+' must satisfy constraint '

            +check_func.__name__)

def cast(type_, val):

    '''Passes None through. Does not cast a subclass to a superclass (which

    doesn't make sense in a dynamically-typed language).'''

    if val != None and not isinstance(val, type_): val = type_(val)

    return val

def all_not_none(vals): return reduce(and_, map(lambda v: v != None, vals))

def is_str(val): return isinstance(val, basestring)

def is_list(val): return isinstance(val, list)

def bool2str(val):

    if val: return '1'

    else: return ''

#### Basic types

def do_ignore_none(do, val):

    if val == None: return val

    else: return do(val)

def coalesce(*vals):

    for val in vals:

        if val != None: return val

    return None

def none_if(val, *none_vals):

    for none_val in none_vals:

        if cast(type(none_val), val) == none_val: return None

    return val

#### Classes

def classes_eq(val0, val1): return val0() == val1() # compare instances

#### Iterables

def first(iter_): return iter_.next()

def skip(iter_, func):

    # Advance iter while func is True

    try:

        while func(iter_.curr()): iter_.next()

    except StopIteration: pass # nothing after the matching elements

class WrapIter:

    def __init__(self, wrap_func, iterable):

        self.wrap_func = wrap_func

        self.iter_ = iterable.__iter__()

    def __iter__(self): return self

    def next(self): return self.wrap_func(self.iter_.next())

class CheckedIter:

    def __init__(self, check_func, iterable):

        self.check_func = check_func

        self.iter_ = iterable.__iter__()

    def __iter__(self): return self

    def next(self):

        entry = self.iter_.next()

        if self.check_func(entry): return entry

        else: raise ConstraintError(self.check_func, entry)

#### Lists

def list_get(list_, idx, default=None):

    try: return list_[idx]

    except IndexError: return default

def list_set_length(list_, len_, fill=None, expand_only=False):

    '''@param list_ Must be a list, not a tuple'''

    extra_needed = len_ - len(list_)

    if extra_needed > 0: list_ += extra_needed*[fill]

    elif not expand_only: del list_[len_:]

def list_as_length(list_, len_, fill=None):

    list_ = list(list_) # will also convert a tuple to a list

    list_set_length(list_, len_, fill)

    return list_

def list_set(list_, idx, value, default=None):

    list_set_length(list_, idx+1, default, expand_only=True)

    list_[idx] = value

def list_setdefault(list_, idx, default=None):

    try: return list_[idx]

    except IndexError:

        list_set(list_, idx, default, default)

        return default

def list_subset(list_, idxs):

    '''@param idxs list|None If None, returns entire list'''

    if idxs == None: return list_

    subset = []

    for idx in idxs:

        try: subset.append(list_[idx])

        except IndexError: pass

    return subset

def list_eq_is(list0, list1):

    '''Compares two lists using is'''

    if len(list0) != len(list1): return False

    for i in xrange(len(list0)):

        if list0[i] is not list1[i]: return False

    return True

def list_replace(list_, repl_elem, with_slice):

    list_ = list_[:] # don't modify input!

    while True:

        try: idx = list_.index(repl_elem)

        except ValueError: break

        list_[idx:idx+1] = with_slice

    return list_

def list_flip(list_): return dict((v, i) for i, v in enumerate(list_))

def sort_by_len(list_of_lists): list_of_lists.sort(lambda *a: cmp(*map(len, a)))

def shortest(*lists):

    lists = list(lists)

    sort_by_len(lists)

    return lists[0]

def longest(*lists):

    lists = list(lists)

    sort_by_len(lists)

    return lists[-1]

def all_equal(vals, default=False):

    '''@return default if len(vals) < 2'''

    if len(vals) < 2: return default

    return reduce(and_, map(lambda v: v == vals[0], vals), True)

def all_equal_ignore_none(vals):

    return all_equal(filter(lambda v: v != None, vals), default=False)

#### Dicts

def rename_key(dict_, orig, new): dict_[new] = dict_.pop(orig)

def dict_subset(dict_, keys):

    subset = dict()

    for key in keys:

        try: subset[key] = dict_[key]

        except KeyError: pass

    return subset

def have_same_value(dict_, *keys):

    return all_equal_ignore_none([dict_.get(k, None) for k in keys])

class DefaultDict(collections.defaultdict):

    def __init__(self, dict_, default=None):

        collections.defaultdict.__init__(self, lambda: default, dict_)

def dict_subset_right_join(dict_, keys):

    '''Gets a subset of a dict, using None for subset keys that don't exist'''

    return dict_subset(DefaultDict(dict_), keys)

class ListDict:

    '''Views a list as a dict, given a key->index mapping

    @pre len(list_) == len(keys)'''

    def __init__(self, list_, keys, key_idxs=None):

        assert len(list_) == len(keys)

        if key_idxs == None: key_idxs = list_flip(keys)

        self.list = list_

        self.keys = keys

        self.key_idxs = key_idxs

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

    def __str__(self): return '{\n'+(''.join(str(k)+': '+str(v)+'\n'

        for k, v in zip(self.keys, self.list)))+'}\n'

#### Named tuples

class NamedTuple:

    def __init__(self, **attrs): self.__dict__ = attrs

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

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