1
|
# Useful functions and classes
|
2
|
|
3
|
import collections
|
4
|
|
5
|
import dicts
|
6
|
import objects
|
7
|
|
8
|
#### Function wrappers for statements
|
9
|
|
10
|
def noop(*args, **kw_args): pass
|
11
|
|
12
|
def and_(a, b): return a and b
|
13
|
|
14
|
#### Object metadata
|
15
|
|
16
|
def type_name(value): return type(value).__name__
|
17
|
|
18
|
def class_name(value): return value.__class__.__name__
|
19
|
|
20
|
def module(value): return type(value).__module__.split('.')
|
21
|
|
22
|
def root_module(value): return module(value)[0]
|
23
|
|
24
|
#### Type checking and conversion
|
25
|
|
26
|
class ConstraintError(ValueError):
|
27
|
def __init__(self, check_func, value):
|
28
|
ValueError.__init__(self, str(value)+' must satisfy constraint '
|
29
|
+check_func.__name__)
|
30
|
|
31
|
def cast(type_, val):
|
32
|
'''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
|
return val
|
36
|
|
37
|
def all_not_none(vals): return reduce(and_, map(lambda v: v != None, vals))
|
38
|
|
39
|
def is_str(val): return isinstance(val, basestring)
|
40
|
|
41
|
def is_list(val): return isinstance(val, list)
|
42
|
|
43
|
def bool2str(val):
|
44
|
if val: return '1'
|
45
|
else: return ''
|
46
|
|
47
|
#### Basic types
|
48
|
|
49
|
def do_ignore_none(do, val):
|
50
|
if val == None: return val
|
51
|
else: return do(val)
|
52
|
|
53
|
def coalesce(*vals):
|
54
|
for val in vals:
|
55
|
if val != None: return val
|
56
|
return None
|
57
|
|
58
|
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
|
|
63
|
#### Classes
|
64
|
|
65
|
def classes_eq(val0, val1): return val0() == val1() # compare instances
|
66
|
|
67
|
#### Iterables
|
68
|
|
69
|
def first(iter_): return iter_.next()
|
70
|
|
71
|
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
|
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
|
|
86
|
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
|
#### Lists
|
99
|
|
100
|
def list_get(list_, idx, default=None):
|
101
|
try: return list_[idx]
|
102
|
except IndexError: return default
|
103
|
|
104
|
def list_set_length(list_, len_, fill=None, expand_only=False):
|
105
|
'''@param list_ Must be a list, not a tuple'''
|
106
|
extra_needed = len_ - len(list_)
|
107
|
if extra_needed > 0: list_ += extra_needed*[fill]
|
108
|
elif not expand_only: del list_[len_:]
|
109
|
|
110
|
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
|
def list_set(list_, idx, value, default=None):
|
116
|
list_set_length(list_, idx+1, default, expand_only=True)
|
117
|
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
|
subset_skip = object() # tells list_subset() to leave out invalid indexes
|
126
|
|
127
|
def list_subset(list_, idxs, default=subset_skip):
|
128
|
'''
|
129
|
@param idxs list|None If None, returns entire list. An index of '+' appends
|
130
|
the rest of the list.
|
131
|
@param default The value to use for invalid indexes, or subset_skip to leave
|
132
|
them out of the returned list
|
133
|
'''
|
134
|
if idxs == None: return list_
|
135
|
subset = []
|
136
|
for i, idx in enumerate(idxs):
|
137
|
if idx == '+':
|
138
|
prev_idxs = idxs[:i] # excluding the current value, which is '+'
|
139
|
if prev_idxs: subset_start = max(prev_idxs)+1
|
140
|
else: subset_start = 0
|
141
|
subset += list_[subset_start:]
|
142
|
else:
|
143
|
value = list_get(list_, idx, default)
|
144
|
if value is not subset_skip: subset.append(value)
|
145
|
return subset
|
146
|
|
147
|
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
|
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
|
def list_flip(list_): return dict((v, i) for i, v in enumerate(list_))
|
163
|
|
164
|
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
|
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
|
#### Dicts
|
185
|
|
186
|
def rename_key(dict_, orig, new): dict_[new] = dict_.pop(orig)
|
187
|
|
188
|
def dict_subset(dict_, keys):
|
189
|
try: from ordereddict import OrderedDict
|
190
|
except ImportError: subset = dict()
|
191
|
else: subset = OrderedDict()
|
192
|
for key in keys:
|
193
|
try: subset[key] = dict_[key]
|
194
|
except KeyError: pass
|
195
|
return subset
|
196
|
|
197
|
def have_same_value(dict_, *keys):
|
198
|
return all_equal_ignore_none([dict_.get(k, None) for k in keys])
|
199
|
|
200
|
class DefaultDict(dicts.DictProxy):
|
201
|
'''Unlike collections.defaultdict, provides a view of the given dict instead
|
202
|
of copying it.'''
|
203
|
def __init__(self, dict_, default=None):
|
204
|
dicts.DictProxy.__init__(self, dict_)
|
205
|
|
206
|
self.default = default
|
207
|
|
208
|
def __getitem__(self, key): return self.inner.get(key, self.default)
|
209
|
|
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
|
|
214
|
class ListDict:
|
215
|
'''Views a list as a dict, given a key->index mapping
|
216
|
@pre len(list_) == len(keys)'''
|
217
|
def __init__(self, list_, keys, key_idxs=None):
|
218
|
assert len(list_) == len(keys)
|
219
|
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
|
def __str__(self): return '{\n'+(''.join(str(k)+': '+str(v)+'\n'
|
227
|
for k, v in zip(self.keys, self.list)))+'}\n'
|
228
|
|
229
|
#### Named tuples
|
230
|
|
231
|
class NamedTuple(objects.BasicObject):
|
232
|
def __init__(self, **attrs): self.__dict__ = attrs
|
233
|
|
234
|
def __iter__(self): return iter(self.__dict__)
|
235
|
|
236
|
def __getitem__(self, key): return getattr(self, key)
|