# Useful functions and classes

import collections

from ordereddict import OrderedDict

import dicts

import objects

#### 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 class_name(value): return value.__class__.__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

subset_skip = object() # tells list_subset() to leave out invalid indexes

def list_subset(list_, idxs, default=subset_skip):

    '''

    @param idxs list|None If None, returns entire list. An index of '+' appends

        the rest of the list.

    @param default The value to use for invalid indexes, or subset_skip to leave

        them out of the returned list

    '''

    if idxs == None: return list_

    subset = []

    for i, idx in enumerate(idxs):

        if idx == '+':

            prev_idxs = idxs[:i] # excluding the current value, which is '+'

            if prev_idxs: subset_start = max(prev_idxs)+1

            else: subset_start = 0

            subset += list_[subset_start:]

        else:

            value = list_get(list_, idx, default)

            if value is not subset_skip: subset.append(value)

    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 = OrderedDict()

    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(dicts.DictProxy):

    '''Unlike collections.defaultdict, provides a view of the given dict instead

    of copying it.'''

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

        dicts.DictProxy.__init__(self, dict_)

        self.default = default

    def __getitem__(self, key): return self.inner.get(key, self.default)

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(objects.BasicObject):

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

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

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