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
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
|
import numeric as sb
import numerictypes as nt
import sys
import types
import re
# formats regular expression
# allows multidimension spec with a tuple syntax in front
# of the letter code '(2,3)f4' and ' ( 2 , 3 ) f4 '
# are equally allowed
format_re = re.compile(r'(?P<repeat> *[(]?[ ,0-9]*[)]? *)(?P<dtype>[A-Za-z0-9.]*)')
numfmt = nt.typeDict
def find_duplicate(list):
"""Find duplication in a list, return a list of dupicated elements"""
dup = []
for i in range(len(list)):
if (list[i] in list[i+1:]):
if (list[i] not in dup):
dup.append(list[i])
return dup
def _split(input):
"""Split the input formats string into field formats without splitting
the tuple used to specify multi-dimensional arrays."""
newlist = []
hold = ''
for element in input.split(','):
if hold != '':
item = hold + ',' + element
else:
item = element
left = item.count('(')
right = item.count(')')
# if the parenthesis is not balanced, hold the string
if left > right :
hold = item
# when balanced, append to the output list and reset the hold
elif left == right:
newlist.append(item)
hold = ''
# too many close parenthesis is unacceptable
else:
raise SyntaxError, item
# if there is string left over in hold
if hold != '':
raise SyntaxError, hold
return newlist
class format_parser:
def __init__(self, formats, aligned=False):
self._parseFormats(formats, aligned)
def _parseFormats(self, formats, aligned=0):
""" Parse the field formats """
_alignment = nt._alignment
_bytes = nt.nbytes
_typestr = nt._typestr
if (type(formats) in [types.ListType, types.TupleType]):
_fmt = formats[:]
elif (type(formats) == types.StringType):
_fmt = _split(formats)
else:
raise NameError, "illegal input formats %s" % `formats`
self._nfields = len(_fmt)
self._repeats = [1] * self._nfields
self._itemsizes = [0] * self._nfields
self._sizes = [0] * self._nfields
stops = [0] * self._nfields
self._offsets = [0] * self._nfields
self._rec_aligned = aligned
# preserve the input for future reference
self._formats = [''] * self._nfields
sum = 0
maxalign = 1
unisize = nt._unicodesize
for i in range(self._nfields):
# parse the formats into repeats and formats
try:
(_repeat, _dtype) = format_re.match(_fmt[i].strip()).groups()
except TypeError, AttributeError:
raise ValueError('format %s is not recognized' % _fmt[i])
# Flexible types need special treatment
_dtype = _dtype.strip()
if _dtype[0] in ['V','S','U']:
self._itemsizes[i] = int(_dtype[1:])
if _dtype[0] == 'U':
self._itemsizes[i] *= unisize
_dtype = _dtype[0]
if _repeat == '':
_repeat = 1
else:
_repeat = eval(_repeat)
_fmt[i] = numfmt[_dtype]
if not issubclass(_fmt[i], nt.flexible):
self._itemsizes[i] = _bytes[_fmt[i]]
self._repeats[i] = _repeat
if (type(_repeat) in [types.ListType, types.TupleType]):
self._sizes[i] = self._itemsizes[i] * reduce(lambda x,y: x*y, _repeat)
else:
self._sizes[i] = self._itemsizes[i] * _repeat
sum += self._sizes[i]
if self._rec_aligned:
# round sum up to multiple of alignment factor
align = _alignment[_fmt[i]]
sum = ((sum + align - 1)/align) * align
maxalign = max(maxalign, align)
stops[i] = sum - 1
self._offsets = stops[i] - self._sizes[i] + 1
# Unify the appearance of _format, independent of input formats
revfmt = _typestr[_fmt[i]]
self._formats[i] = `_repeat`+revfmt
if issubclass(_fmt[i], nt.flexible):
if issubclass(_fmt[i], nt.unicode_):
self._formats[i] += `self._itemsizes[i] / unisize`
else:
self._formats[i] += `self._itemsizes[i]`
self._fmt = _fmt
# This pads record so next record is aligned if self._rec_align is
# true. Otherwise next the record starts right after the end
# of the last one.
self._total_itemsize = (stops[-1]/maxalign + 1) * maxalign
class record(nt.void):
def _finalize(self, arr):
self.parsed = arr.parsed
self._nfields = arr._nfields
self._names = arr._names
self._fields = {}
def __repr__(self):
return "A record with %d fields named %s" % (self._nfields,
self._names)
def __str__(self):
return self.data[:]
def __getitem__(self, obj):
self.field(obj)
def __setitem__(self, obj, val):
self.setfield(obj, val)
# This allows array scalars to be returned that are of record type.
sb.register_dtype(record)
class ndrecarray(sb.ndarray):
def __new__(subtype, *args, **kwds):
shape = args[0]
formats = args[1]
buf = kwds.get('buf',None)
aligned = kwds.get('aligned',0)
parsed = format_parser(formats, aligned)
itemsize = parsed._total_itemsize
if buf is None:
self = sb.ndarray.__new__(subtype, shape, (record, itemsize))
else:
byteorder = kwds.get('byteorder', sys.byteorder)
swapped = 0
if (byteorder != sys.byteorder):
swapped = 1
self = sb.ndarray.__new__(subtype, shape, (record, itemsize),
buffer=buf, swapped=swapped)
self.parsed = parsed
return self
def __init__(self, shape, formats, names=None, buf=None, offset=0,
strides=None, byteorder=sys.byteorder, aligned=0):
self._updateattr()
self._setfieldnames(names)
# now create a dictionary of field-names that returns type object
# offset
# This should grab the names out of self.parsed that are important
# to have later and should set self._attributes
# to the list of meta information that needs to be carried around
def _updateattr(self):
self._nfields = self.parsed._nfields
self._attributes = ['parsed','_nfields','_fields','_names']
def __array_finalize__(self, obj):
self._attributes = obj._attributes
for key in self._attributes:
setattr(self, key, getattr(obj, key))
self._fields = {}
def _setfieldnames(self, names=None):
"""convert input field names into a list and assign to the _names
attribute """
if (names):
if (type(names) in [types.ListType, types.TupleType]):
pass
elif (type(names) == types.StringType):
names = names.split(',')
else:
raise NameError, "illegal input names %s" % `names`
self._names = map(lambda n:n.strip(), names)[:self._nfields]
else:
self._names = []
# if the names are not specified, they will be assigned as "c1, c2,..."
# if not enough names are specified, they will be assigned as "c[n+1],
# c[n+2],..." etc. where n is the number of specified names..."
self._names += map(lambda i:
'c'+`i`, range(len(self._names)+1,self._nfields+1))
# check for redundant names
_dup = find_duplicate(self._names)
if _dup:
raise ValueError, "Duplicate field names: %s" % _dup
def _get_fields(self):
self._fields = {}
parsed = self.parsed
basearr = self.__array__()
for indx in range(self._nfields):
# We need the offset and the data type of the field
_offset = parsed._offsets[indx]
_type = parsed._fmt[indx]
if issubclass(_type, nt.flexible):
_type = nt.dtype2char(_type)+`parsed._itemsizes[indx]`
arr = basearr.getfield(_type, _offset)
# Put this array as a value in dictionary
# Do both name and index
self._fields[indx] = arr
self._fields[self._names[indx]] = arr
def field(self, field_name):
if self._fields == {}:
self._get_fields()
return self._fields[field_name]
def setfield(self, field_name, val):
|
