/usr/share/pyshared/dipy/io/utils.py is in python-dipy 0.5.0-3.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 | ''' Utility functions for file formats '''
import sys
import numpy as np
sys_is_le = sys.byteorder == 'little'
native_code = sys_is_le and '<' or '>'
swapped_code = sys_is_le and '>' or '<'
default_compresslevel = 1
endian_codes = (# numpy code, aliases
('<', 'little', 'l', 'le', 'L', 'LE'),
('>', 'big', 'BIG', 'b', 'be', 'B', 'BE'),
(native_code, 'native', 'n', 'N', '=', '|', 'i', 'I'),
(swapped_code, 'swapped', 's', 'S', '!'))
# We'll put these into the Recoder class after we define it
class Recoder(object):
''' class to return canonical code(s) from code or aliases
The concept is a lot easier to read in the implementation and
tests than it is to explain, so...
>>> # If you have some codes, and several aliases, like this:
>>> code1 = 1; aliases1=['one', 'first']
>>> code2 = 2; aliases2=['two', 'second']
>>> # You might want to do this:
>>> codes = [[code1]+aliases1,[code2]+aliases2]
>>> recodes = Recoder(codes)
>>> recodes.code['one']
1
>>> recodes.code['second']
2
>>> recodes.code[2]
2
>>> # Or maybe you have a code, a label and some aliases
>>> codes=((1,'label1','one', 'first'),(2,'label2','two'))
>>> # you might want to get back the code or the label
>>> recodes = Recoder(codes, fields=('code','label'))
>>> recodes.code['first']
1
>>> recodes.code['label1']
1
>>> recodes.label[2]
'label2'
>>> # For convenience, you can get the first entered name by
>>> # indexing the object directly
>>> recodes[2]
2
'''
def __init__(self, codes, fields=('code',)):
''' Create recoder object
``codes`` give a sequence of code, alias sequences
``fields`` are names by which the entries in these sequences can be
accessed.
By default ``fields`` gives the first column the name
"code". The first column is the vector of first entries
in each of the sequences found in ``codes``. Thence you can
get the equivalent first column value with ob.code[value],
where value can be a first column value, or a value in any of
the other columns in that sequence.
You can give other columns names too, and access them in the
same way - see the examples in the class docstring.
Parameters
------------
codes : seqence of sequences
Each sequence defines values (codes) that are equivalent
fields : {('code',) string sequence}, optional
names by which elements in sequences can be accesssed
'''
self.fields = fields
self.field1 = {} # a placeholder for the check below
for name in fields:
if name in self.__dict__:
raise KeyError('Input name %s already in object dict'
% name)
self.__dict__[name] = {}
self.field1 = self.__dict__[fields[0]]
self.add_codes(codes)
def add_codes(self, codes):
''' Add codes to object
>>> codes = ((1, 'one'), (2, 'two'))
>>> rc = Recoder(codes)
>>> rc.value_set() == set((1,2))
True
>>> rc.add_codes(((3, 'three'), (1, 'first')))
>>> rc.value_set() == set((1,2,3))
True
'''
for vals in codes:
for val in vals:
for ind, name in enumerate(self.fields):
self.__dict__[name][val] = vals[ind]
def __getitem__(self, key):
''' Return value from field1 dictionary (first column of values)
Returns same value as ``obj.field1[key]`` and, with the
default initializing ``fields`` argument of fields=('code',),
this will return the same as ``obj.code[key]``
>>> codes = ((1, 'one'), (2, 'two'))
>>> Recoder(codes)['two']
2
'''
return self.field1[key]
def keys(self):
''' Return all available code and alias values
Returns same value as ``obj.field1.keys()`` and, with the
default initializing ``fields`` argument of fields=('code',),
this will return the same as ``obj.code.keys()``
>>> codes = ((1, 'one'), (2, 'two'), (1, 'repeat value'))
>>> k = Recoder(codes).keys()
>>> k.sort() # Just to guarantee order for doctest output
>>> k
[1, 2, 'one', 'repeat value', 'two']
'''
return self.field1.keys()
def value_set(self, name=None):
''' Return set of possible returned values for column
By default, the column is the first column.
Returns same values as ``set(obj.field1.values())`` and,
with the default initializing ``fields`` argument of
fields=('code',), this will return the same as
``set(obj.code.values())``
Parameters
------------
name : {None, string}
Where default of None gives result for first column
Returns
---------
val_set : set
set of all values for `name`
Examples
-----------
>>> codes = ((1, 'one'), (2, 'two'), (1, 'repeat value'))
>>> vs = Recoder(codes).value_set()
>>> vs == set([1, 2]) # Sets are not ordered, hence this test
True
>>> rc = Recoder(codes, fields=('code', 'label'))
>>> rc.value_set('label') == set(('one', 'two', 'repeat value'))
True
'''
if name is None:
d = self.field1
else:
d = self.__dict__[name]
return set(d.values())
# Endian code aliases
endian_codes = Recoder(endian_codes)
def allopen(fname, *args, **kwargs):
''' Generic file-like object open
If input ``fname`` already looks like a file, pass through.
If ``fname`` ends with recognizable compressed types, use python
libraries to open as file-like objects (read or write)
Otherwise, use standard ``open``.
'''
if hasattr(fname, 'write'):
return fname
if args:
mode = args[0]
elif 'mode' in kwargs:
mode = kwargs['mode']
else:
mode = 'rb'
if fname.endswith('.gz'):
if ('w' in mode and
len(args) < 2 and
not 'compresslevel' in kwargs):
kwargs['compresslevel'] = default_compresslevel
import gzip
opener = gzip.open
elif fname.endswith('.bz2'):
if ('w' in mode and
len(args) < 3 and
not 'compresslevel' in kwargs):
kwargs['compresslevel'] = default_compresslevel
import bz2
opener = bz2.BZ2File
else:
opener = open
return opener(fname, *args, **kwargs)
|