Project

General

Profile

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)
(35-35/40)