Project

General

Profile

1 11 aaronmk
# Useful functions and classes
2
3 1068 aaronmk
import collections
4
5 931 aaronmk
#### Function wrappers for statements
6
7
def noop(*args, **kw_args): pass
8
9
def and_(a, b): return a and b
10
11 791 aaronmk
#### Object metadata
12
13 341 aaronmk
def type_name(value): return type(value).__name__
14
15 135 aaronmk
def module(value): return type(value).__module__.split('.')
16
17
def root_module(value): return module(value)[0]
18
19 1233 aaronmk
#### Type checking and conversion
20 791 aaronmk
21
class ConstraintError(ValueError):
22
    def __init__(self, check_func, value):
23 795 aaronmk
        ValueError.__init__(self, str(value)+' must satisfy constraint '
24
            +check_func.__name__)
25 791 aaronmk
26 836 aaronmk
def cast(type_, val):
27 1046 aaronmk
    '''Passes None through. Does not cast a subclass to a superclass (which
28
    doesn't make sense in a dynamically-typed language).'''
29
    if val != None and not isinstance(val, type_): val = type_(val)
30 836 aaronmk
    return val
31
32 1233 aaronmk
def all_not_none(vals): return reduce(and_, map(lambda v: v != None, vals))
33
34 791 aaronmk
def is_str(val): return isinstance(val, basestring)
35
36 1007 aaronmk
def is_list(val): return isinstance(val, list)
37
38 1233 aaronmk
def bool2str(val):
39
    if val: return '1'
40
    else: return ''
41
42 1046 aaronmk
#### Basic types
43
44 1359 aaronmk
def do_ignore_none(do, val):
45
    if val == None: return val
46
    else: return do(val)
47
48 1483 aaronmk
def coalesce(*vals):
49
    for val in vals:
50
        if val != None: return val
51
    return None
52
53 1373 aaronmk
def none_if(val, *none_vals):
54
    for none_val in none_vals:
55
        if cast(type(none_val), val) == none_val: return None
56
    return val
57 1046 aaronmk
58 1445 aaronmk
#### Classes
59
60
def classes_eq(val0, val1): return val0() == val1() # compare instances
61
62 791 aaronmk
#### Iterables
63
64 135 aaronmk
def first(iter_): return iter_.next()
65
66 133 aaronmk
def skip(iter_, func):
67
    # Advance iter while func is True
68
    try:
69
        while func(iter_.curr()): iter_.next()
70
    except StopIteration: pass # nothing after the matching elements
71
72 1147 aaronmk
class WrapIter:
73
    def __init__(self, wrap_func, iterable):
74
        self.wrap_func = wrap_func
75
        self.iter_ = iterable.__iter__()
76
77
    def __iter__(self): return self
78
79
    def next(self): return self.wrap_func(self.iter_.next())
80 934 aaronmk
81 791 aaronmk
class CheckedIter:
82
    def __init__(self, check_func, iterable):
83
        self.check_func = check_func
84
        self.iter_ = iterable.__iter__()
85
86
    def __iter__(self): return self
87
88
    def next(self):
89
        entry = self.iter_.next()
90
        if self.check_func(entry): return entry
91
        else: raise ConstraintError(self.check_func, entry)
92
93 1008 aaronmk
#### Lists
94
95
def list_get(list_, idx, default=None):
96
    try: return list_[idx]
97
    except IndexError: return default
98
99 1414 aaronmk
def list_set_length(list_, len_, fill=None, expand_only=False):
100 1415 aaronmk
    '''@param list_ Must be a list, not a tuple'''
101 1414 aaronmk
    extra_needed = len_ - len(list_)
102
    if extra_needed > 0: list_ += extra_needed*[fill]
103
    elif not expand_only: del list_[len_:]
104
105 1415 aaronmk
def list_as_length(list_, len_, fill=None):
106
    list_ = list(list_) # will also convert a tuple to a list
107
    list_set_length(list_, len_, fill)
108
    return list_
109
110 1281 aaronmk
def list_set(list_, idx, value, default=None):
111 1414 aaronmk
    list_set_length(list_, idx+1, default, expand_only=True)
112 1281 aaronmk
    list_[idx] = value
113
114
def list_setdefault(list_, idx, default=None):
115
    try: return list_[idx]
116
    except IndexError:
117
        list_set(list_, idx, default, default)
118
        return default
119
120 2020 aaronmk
subset_skip = object() # tells list_subset() to leave out invalid indexes
121
122
def list_subset(list_, idxs, default=subset_skip):
123
    '''
124
    @param idxs list|None If None, returns entire list
125
    @param default The value to use for invalid indexes, or subset_skip to leave
126
        them out of the returned list
127
    '''
128 1494 aaronmk
    if idxs == None: return list_
129 1147 aaronmk
    subset = []
130
    for idx in idxs:
131 2020 aaronmk
        value = list_get(list_, idx, default)
132
        if value != subset_skip: subset.append(value)
133 1147 aaronmk
    return subset
134
135 1012 aaronmk
def list_eq_is(list0, list1):
136
    '''Compares two lists using is'''
137
    if len(list0) != len(list1): return False
138
    for i in xrange(len(list0)):
139
        if list0[i] is not list1[i]: return False
140
    return True
141
142 1344 aaronmk
def list_replace(list_, repl_elem, with_slice):
143
    list_ = list_[:] # don't modify input!
144
    while True:
145
        try: idx = list_.index(repl_elem)
146
        except ValueError: break
147
        list_[idx:idx+1] = with_slice
148
    return list_
149
150 1145 aaronmk
def list_flip(list_): return dict((v, i) for i, v in enumerate(list_))
151
152 1767 aaronmk
def sort_by_len(list_of_lists): list_of_lists.sort(lambda *a: cmp(*map(len, a)))
153
154
def shortest(*lists):
155
    lists = list(lists)
156
    sort_by_len(lists)
157
    return lists[0]
158
159
def longest(*lists):
160
    lists = list(lists)
161
    sort_by_len(lists)
162
    return lists[-1]
163
164 1785 aaronmk
def all_equal(vals, default=False):
165
    '''@return default if len(vals) < 2'''
166
    if len(vals) < 2: return default
167
    return reduce(and_, map(lambda v: v == vals[0], vals), True)
168
169
def all_equal_ignore_none(vals):
170
    return all_equal(filter(lambda v: v != None, vals), default=False)
171
172 791 aaronmk
#### Dicts
173
174 330 aaronmk
def rename_key(dict_, orig, new): dict_[new] = dict_.pop(orig)
175 466 aaronmk
176 467 aaronmk
def dict_subset(dict_, keys):
177
    subset = dict()
178
    for key in keys:
179
        try: subset[key] = dict_[key]
180
        except KeyError: pass
181
    return subset
182 1068 aaronmk
183 1785 aaronmk
def have_same_value(dict_, *keys):
184
    return all_equal_ignore_none([dict_.get(k, None) for k in keys])
185
186 1068 aaronmk
class DefaultDict(collections.defaultdict):
187
    def __init__(self, dict_, default=None):
188
        collections.defaultdict.__init__(self, lambda: default, dict_)
189
190
def dict_subset_right_join(dict_, keys):
191
    '''Gets a subset of a dict, using None for subset keys that don't exist'''
192
    return dict_subset(DefaultDict(dict_), keys)
193 1147 aaronmk
194
class ListDict:
195 1415 aaronmk
    '''Views a list as a dict, given a key->index mapping
196
    @pre len(list_) == len(keys)'''
197 1147 aaronmk
    def __init__(self, list_, keys, key_idxs=None):
198 1415 aaronmk
        assert len(list_) == len(keys)
199 1147 aaronmk
        if key_idxs == None: key_idxs = list_flip(keys)
200
        self.list = list_
201
        self.keys = keys
202
        self.key_idxs = key_idxs
203
204
    def __getitem__(self, key): return self.list[self.key_idxs[key]]
205
206 1178 aaronmk
    def __str__(self): return '{\n'+(''.join(str(k)+': '+str(v)+'\n'
207
        for k, v in zip(self.keys, self.list)))+'}\n'
208 1443 aaronmk
209
#### Named tuples
210
211
class NamedTuple:
212
    def __init__(self, **attrs): self.__dict__ = attrs
213 1908 aaronmk
214 1910 aaronmk
    def __iter__(self): return iter(self.__dict__)
215 1908 aaronmk
216
    def __getitem__(self, key): return getattr(self, key)