Project

General

Profile

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