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)
|