# Useful functions and classes

import collections

import dicts
import objects
import strings

#### 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, strings.ustr(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):
    try: from ordereddict import OrderedDict
    except ImportError: subset = dict()
    else: 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(strings.ustr(k)+': '
        +strings.ustr(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)