/lib/util.py - Annotate - BIEN 3 - NCEAS Projects

root/lib/util.py @ 2844

-            aaronmk
+# Useful functions and classes
-            aaronmk
+import collections
 import dicts
-            aaronmk
+import objects
-            aaronmk
+#### Function wrappers for statements
 def noop(*args, **kw_args): pass
 def and_(a, b): return a and b
-            aaronmk
+#### Object metadata
-            aaronmk
+def type_name(value): return type(value).__name__
-            aaronmk
+def class_name(value): return value.__class__.__name__
-            aaronmk
+def module(value): return type(value).__module__.split('.')
 def root_module(value): return module(value)[0]
-            aaronmk
+#### Type checking and conversion
             aaronmk
 class ConstraintError(ValueError):
     def __init__(self, check_func, value):
-            aaronmk
+        ValueError.__init__(self, str(value)+' must satisfy constraint '
             +check_func.__name__)
             aaronmk
-            aaronmk
+def cast(type_, val):
-            aaronmk
+    '''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)
-            aaronmk
+    return val
-            aaronmk
+def all_not_none(vals): return reduce(and_, map(lambda v: v != None, vals))
-            aaronmk
+def is_str(val): return isinstance(val, basestring)
-            aaronmk
+def is_list(val): return isinstance(val, list)
-            aaronmk
+def bool2str(val):
     if val: return '1'
     else: return ''
-            aaronmk
+#### Basic types
-            aaronmk
+def do_ignore_none(do, val):
     if val == None: return val
     else: return do(val)
-            aaronmk
+def coalesce(*vals):
     for val in vals:
         if val != None: return val
     return None
-            aaronmk
+def none_if(val, *none_vals):
     for none_val in none_vals:
         if cast(type(none_val), val) == none_val: return None
     return val
             aaronmk
-            aaronmk
+#### Classes
 def classes_eq(val0, val1): return val0() == val1() # compare instances
-            aaronmk
+#### Iterables
-            aaronmk
+def first(iter_): return iter_.next()
-            aaronmk
+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
-            aaronmk
+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())
             aaronmk
-            aaronmk
+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)
-            aaronmk
+#### Lists
 def list_get(list_, idx, default=None):
     try: return list_[idx]
     except IndexError: return default
-            aaronmk
+def list_set_length(list_, len_, fill=None, expand_only=False):
-            aaronmk
+    '''@param list_ Must be a list, not a tuple'''
-            aaronmk
+    extra_needed = len_ - len(list_)
     if extra_needed > 0: list_ += extra_needed*[fill]
     elif not expand_only: del list_[len_:]
-            aaronmk
+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_
-            aaronmk
+def list_set(list_, idx, value, default=None):
-            aaronmk
+    list_set_length(list_, idx+1, default, expand_only=True)
-            aaronmk
+    list_[idx] = value
 def list_setdefault(list_, idx, default=None):
     try: return list_[idx]
     except IndexError:
         list_set(list_, idx, default, default)
         return default
-            aaronmk
+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
     @param default The value to use for invalid indexes, or subset_skip to leave
         them out of the returned list
     '''
-            aaronmk
+    if idxs == None: return list_
-            aaronmk
+    subset = []
     for idx in idxs:
-            aaronmk
+        value = list_get(list_, idx, default)
-            aaronmk
+        if value is not subset_skip: subset.append(value)
-            aaronmk
+    return subset
-            aaronmk
+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
-            aaronmk
+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_
-            aaronmk
+def list_flip(list_): return dict((v, i) for i, v in enumerate(list_))
-            aaronmk
+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]
-            aaronmk
+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)
-            aaronmk
+#### Dicts
-            aaronmk
+def rename_key(dict_, orig, new): dict_[new] = dict_.pop(orig)
             aaronmk
-            aaronmk
+def dict_subset(dict_, keys):
     subset = dict()
     for key in keys:
         try: subset[key] = dict_[key]
         except KeyError: pass
     return subset
             aaronmk
-            aaronmk
+def have_same_value(dict_, *keys):
     return all_equal_ignore_none([dict_.get(k, None) for k in keys])
-            aaronmk
+class DefaultDict(dicts.DictProxy):
     '''Unlike collections.defaultdict, provides a view of the given dict instead
     of copying it.'''
-            aaronmk
+    def __init__(self, dict_, default=None):
-            aaronmk
+        dicts.DictProxy.__init__(self, dict_)
         self.default = default
     def __getitem__(self, key): return self.inner.get(key, self.default)
             aaronmk
 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)
             aaronmk
 class ListDict:
-            aaronmk
+    '''Views a list as a dict, given a key->index mapping
     @pre len(list_) == len(keys)'''
-            aaronmk
+    def __init__(self, list_, keys, key_idxs=None):
-            aaronmk
+        assert len(list_) == len(keys)
-            aaronmk
+        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]]
-            aaronmk
+    def __str__(self): return '{\n'+(''.join(str(k)+': '+str(v)+'\n'
         for k, v in zip(self.keys, self.list)))+'}\n'
             aaronmk
 #### Named tuples
-            aaronmk
+class NamedTuple(objects.BasicObject):
-            aaronmk
+    def __init__(self, **attrs): self.__dict__ = attrs
             aaronmk
-            aaronmk
+    def __iter__(self): return iter(self.__dict__)
             aaronmk
     def __getitem__(self, key): return getattr(self, key)

Project

General

Profile