from rpython.rlib import jit from pypy.interpreter.baseobjspace import W_Root from pypy.interpreter.typedef import TypeDef, GetSetProperty from pypy.interpreter.gateway import interp2app, unwrap_spec, WrappedDefault from pypy.interpreter.error import OperationError, oefmt from pypy.module.micronumpy import support, concrete from pypy.module.micronumpy.base import W_NDimArray, convert_to_array, W_NumpyObject from pypy.module.micronumpy.descriptor import decode_w_dtype from pypy.module.micronumpy.iterators import ArrayIter from pypy.module.micronumpy.strides import (calculate_broadcast_strides, shape_agreement, shape_agreement_multiple) from pypy.module.micronumpy.casting import (find_binop_result_dtype, can_cast_array, can_cast_type) import pypy.module.micronumpy.constants as NPY from pypy.module.micronumpy.converters import order_converter def parse_op_arg(space, name, w_op_flags, n, parse_one_arg): if space.is_w(w_op_flags, space.w_None): w_op_flags = space.newtuple([space.newtext('readonly')]) if not space.isinstance_w(w_op_flags, space.w_tuple) and not \ space.isinstance_w(w_op_flags, space.w_list): raise oefmt(space.w_ValueError, '%s must be a tuple or array of per-op flag-tuples', name) ret = [] w_lst = space.listview(w_op_flags) if space.isinstance_w(w_lst[0], space.w_tuple) or \ space.isinstance_w(w_lst[0], space.w_list): if len(w_lst) != n: raise oefmt(space.w_ValueError, '%s must be a tuple or array of per-op flag-tuples', name) for item in w_lst: ret.append(parse_one_arg(space, space.listview(item))) else: op_flag = parse_one_arg(space, w_lst) for i in range(n): ret.append(op_flag) return ret class OpFlag(object): def __init__(self): self.rw = '' self.broadcast = True self.force_contig = False self.force_align = False self.native_byte_order = False self.tmp_copy = '' self.allocate = False def parse_op_flag(space, lst): op_flag = OpFlag() for w_item in lst: item = space.text_w(w_item) if item == 'readonly': op_flag.rw = 'r' elif item == 'readwrite': op_flag.rw = 'rw' elif item == 'writeonly': op_flag.rw = 'w' elif item == 'no_broadcast': op_flag.broadcast = False elif item == 'contig': op_flag.force_contig = True elif item == 'aligned': op_flag.force_align = True elif item == 'nbo': op_flag.native_byte_order = True elif item == 'copy': op_flag.tmp_copy = 'r' elif item == 'updateifcopy': op_flag.tmp_copy = 'rw' elif item == 'allocate': op_flag.allocate = True elif item == 'no_subtype': raise oefmt(space.w_NotImplementedError, '"no_subtype" op_flag not implemented yet') elif item == 'arraymask': raise oefmt(space.w_NotImplementedError, '"arraymask" op_flag not implemented yet') elif item == 'writemask': raise oefmt(space.w_NotImplementedError, '"writemask" op_flag not implemented yet') else: raise oefmt(space.w_ValueError, 'op_flags must be a tuple or array of per-op flag-tuples') if op_flag.rw == '': raise oefmt(space.w_ValueError, "None of the iterator flags READWRITE, READONLY, or " "WRITEONLY were specified for an operand") return op_flag def parse_func_flags(space, nditer, w_flags): if space.is_w(w_flags, space.w_None): return elif not space.isinstance_w(w_flags, space.w_tuple) and not \ space.isinstance_w(w_flags, space.w_list): raise oefmt(space.w_ValueError, 'Iter global flags must be a list or tuple of strings') lst = space.listview(w_flags) for w_item in lst: if not space.isinstance_w(w_item, space.w_bytes) and not \ space.isinstance_w(w_item, space.w_unicode): raise oefmt(space.w_TypeError, "expected string or Unicode object, %T found", w_item) item = space.text_w(w_item) if item == 'external_loop': nditer.external_loop = True elif item == 'buffered': # Each iterator should be 1d nditer.buffered = True elif item == 'c_index': nditer.tracked_index = 'C' elif item == 'f_index': nditer.tracked_index = 'F' elif item == 'multi_index': nditer.tracked_index = 'multi' elif item == 'common_dtype': nditer.common_dtype = True elif item == 'delay_bufalloc': nditer.delay_bufalloc = True elif item == 'grow_inner': nditer.grow_inner = True elif item == 'ranged': nditer.ranged = True elif item == 'refs_ok': nditer.refs_ok = True elif item == 'reduce_ok': raise oefmt(space.w_NotImplementedError, 'nditer reduce_ok not implemented yet') nditer.reduce_ok = True elif item == 'zerosize_ok': nditer.zerosize_ok = True else: raise oefmt(space.w_ValueError, 'Unexpected iterator global flag "%s"', item) if nditer.tracked_index and nditer.external_loop: raise oefmt(space.w_ValueError, 'Iterator flag EXTERNAL_LOOP cannot be used if an index or ' 'multi-index is being tracked') def is_backward(imp_order, order): if imp_order == order: return False if order == NPY.KEEPORDER: return False else: return True class OperandIter(ArrayIter): _immutable_fields_ = ['slice_shape', 'slice_stride', 'slice_backstride', 'operand_type', 'base'] def getitem(self, state): # cannot be called - must return a boxed value assert False def getitem_bool(self, state): # cannot be called - must return a boxed value assert False def setitem(self, state, elem): # cannot be called - must return a boxed value assert False class ConcreteIter(OperandIter): def __init__(self, array, size, shape, strides, backstrides, op_flags, base): OperandIter.__init__(self, array, size, shape, strides, backstrides) self.slice_shape =[] self.slice_stride = [] self.slice_backstride = [] if op_flags.rw == 'r': self.operand_type = concrete.ConcreteNonWritableArrayWithBase else: self.operand_type = concrete.ConcreteArrayWithBase self.base = base def getoperand(self, state): assert state.iterator is self impl = self.operand_type res = impl([], self.array.dtype, self.array.order, [], [], self.array.storage, self.base) res.start = state.offset return res class SliceIter(OperandIter): def __init__(self, array, size, shape, strides, backstrides, slice_shape, slice_stride, slice_backstride, op_flags, base): OperandIter.__init__(self, array, size, shape, strides, backstrides) self.slice_shape = slice_shape self.slice_stride = slice_stride self.slice_backstride = slice_backstride if op_flags.rw == 'r': self.operand_type = concrete.NonWritableSliceArray else: self.operand_type = concrete.SliceArray self.base = base def getoperand(self, state): assert state.iterator is self impl = self.operand_type arr = impl(state.offset, self.slice_stride, self.slice_backstride, self.slice_shape, self.array, self.base) return arr def calculate_ndim(op_in, oa_ndim): if oa_ndim >=0: return oa_ndim else: ndim = 0 for op in op_in: if op is None: continue assert isinstance(op, W_NDimArray) ndim = max(ndim, op.ndims()) return ndim def coalesce_axes(it, space): # Copy logic from npyiter_coalesce_axes, used in ufunc iterators # and in nditer's with 'external_loop' flag can_coalesce = True for idim in range(it.ndim - 1): for op_it, _ in it.iters: if op_it is None: continue assert isinstance(op_it, ArrayIter) indx = len(op_it.strides) if it.order == NPY.FORTRANORDER: indx = len(op_it.array.strides) - indx assert indx >=0 astrides = op_it.array.strides[indx:] else: astrides = op_it.array.strides[:indx] # does op_it iters over array "naturally" if astrides != op_it.strides: can_coalesce = False break if can_coalesce: for i in range(len(it.iters)): new_iter = coalesce_iter(it.iters[i][0], it.op_flags[i], it, it.order) it.iters[i] = (new_iter, new_iter.reset()) if len(it.shape) > 1: if it.order == NPY.FORTRANORDER: it.shape = it.shape[1:] else: it.shape = it.shape[:-1] else: it.shape = [1] else: break # Always coalesce at least one for i in range(len(it.iters)): new_iter = coalesce_iter(it.iters[i][0], it.op_flags[i], it, NPY.CORDER) it.iters[i] = (new_iter, new_iter.reset()) if len(it.shape) > 1: if it.order == NPY.FORTRANORDER: it.shape = it.shape[1:] else: it.shape = it.shape[:-1] else: it.shape = [1] def coalesce_iter(old_iter, op_flags, it, order, flat=True): ''' We usually iterate through an array one value at a time. But after coalesce(), getoperand() will return a slice by removing the fastest varying dimension(s) from the beginning or end of the shape. If flat is true, then the slice will be 1d, otherwise stack up the shape of the fastest varying dimension in the slice, so an iterator of a 'C' array of shape (2,4,3) after two calls to coalesce will iterate 2 times over a slice of shape (4,3) by setting the offset to the beginning of the data at each iteration ''' shape = [s+1 for s in old_iter.shape_m1] if len(shape) < 1: return old_iter strides = old_iter.strides backstrides = old_iter.backstrides if order == NPY.FORTRANORDER: new_shape = shape[1:] new_strides = strides[1:] new_backstrides = backstrides[1:] _stride = old_iter.slice_stride + [strides[0]] _shape = old_iter.slice_shape + [shape[0]] _backstride = old_iter.slice_backstride + [strides[0] * (shape[0] - 1)] fastest = shape[0] else: new_shape = shape[:-1] new_strides = strides[:-1] new_backstrides = backstrides[:-1] # use the operand's iterator's rightmost stride, # even if it is not the fastest (for 'F' or swapped axis) _stride = [strides[-1]] + old_iter.slice_stride _shape = [shape[-1]] + old_iter.slice_shape _backstride = [(shape[-1] - 1) * strides[-1]] + old_iter.slice_backstride fastest = shape[-1] if fastest == 0: return old_iter if flat: _shape = [support.product(_shape)] if len(_stride) > 1: _stride = [min(_stride[0], _stride[1])] _backstride = [(shape[0] - 1) * _stride[0]] return SliceIter(old_iter.array, old_iter.size / fastest, new_shape, new_strides, new_backstrides, _shape, _stride, _backstride, op_flags, it) class IndexIterator(object): def __init__(self, shape, backward=False): self.shape = shape self.index = [0] * len(shape) self.backward = backward @jit.unroll_safe def next(self): for i in range(len(self.shape) - 1, -1, -1): if self.index[i] < self.shape[i] - 1: self.index[i] += 1 break else: self.index[i] = 0 def getvalue(self): if not self.backward: ret = self.index[-1] for i in range(len(self.shape) - 2, -1, -1): ret += self.index[i] * self.shape[i - 1] else: ret = self.index[0] for i in range(1, len(self.shape)): ret += self.index[i] * self.shape[i - 1] return ret class W_NDIter(W_NumpyObject): _immutable_fields_ = ['ndim', ] def __init__(self, space, w_seq, w_flags, w_op_flags, w_op_dtypes, w_casting, w_op_axes, w_itershape, buffersize=0, order=NPY.KEEPORDER, allow_backward=True): self.external_loop = False self.buffered = False self.tracked_index = '' self.common_dtype = False self.delay_bufalloc = False self.grow_inner = False self.ranged = False self.refs_ok = False self.reduce_ok = False self.zerosize_ok = False self.index_iter = None self.done = False self.first_next = True self.op_axes = [] self.allow_backward = allow_backward if not space.is_w(w_casting, space.w_None): self.casting = space.text_w(w_casting) else: self.casting = 'safe' # convert w_seq operands to a list of W_NDimArray if space.isinstance_w(w_seq, space.w_tuple) or \ space.isinstance_w(w_seq, space.w_list): w_seq_as_list = space.listview(w_seq) self.seq = [convert_to_array(space, w_elem) if not space.is_none(w_elem) else None for w_elem in w_seq_as_list] else: self.seq = [convert_to_array(space, w_seq)] if order == NPY.ANYORDER: # 'A' means "'F' order if all the arrays are Fortran contiguous, # 'C' order otherwise" order = NPY.CORDER for s in self.seq: if s and not(s.get_flags() & NPY.ARRAY_F_CONTIGUOUS): break else: order = NPY.FORTRANORDER elif order == NPY.KEEPORDER: # 'K' means "as close to the order the array elements appear in # memory as possible", so match self.order to seq.order order = NPY.CORDER for s in self.seq: if s and not(s.get_order() == NPY.FORTRANORDER): break else: order = NPY.FORTRANORDER self.order = order parse_func_flags(space, self, w_flags) self.op_flags = parse_op_arg(space, 'op_flags', w_op_flags, len(self.seq), parse_op_flag) # handle w_op_axes oa_ndim = -1 if not space.is_none(w_op_axes): oa_ndim = self.set_op_axes(space, w_op_axes) self.ndim = calculate_ndim(self.seq, oa_ndim) # handle w_op_dtypes part 1: creating self.dtypes list from input if not space.is_none(w_op_dtypes): w_seq_as_list = space.listview(w_op_dtypes) self.dtypes = [decode_w_dtype(space, w_elem) for w_elem in w_seq_as_list] if len(self.dtypes) != len(self.seq): raise oefmt(space.w_ValueError, "op_dtypes must be a tuple/list matching the number of ops") else: self.dtypes = [] # handle None or writable operands, calculate my shape outargs = [i for i in range(len(self.seq)) if self.seq[i] is None or self.op_flags[i].rw == 'w'] if len(outargs) > 0: out_shape = shape_agreement_multiple(space, [self.seq[i] for i in outargs]) else: out_shape = None if space.isinstance_w(w_itershape, space.w_tuple) or \ space.isinstance_w(w_itershape, space.w_list): self.shape = [space.int_w(i) for i in space.listview(w_itershape)] else: self.shape = shape_agreement_multiple(space, self.seq, shape=out_shape) if len(outargs) > 0: # Make None operands writeonly and flagged for allocation if len(self.dtypes) > 0: out_dtype = self.dtypes[outargs[0]] else: out_dtype = None for i in range(len(self.seq)): if self.seq[i] is None: self.op_flags[i].allocate = True continue if self.op_flags[i].rw == 'w': continue out_dtype = find_binop_result_dtype( space, self.seq[i].get_dtype(), out_dtype) for i in outargs: if self.seq[i] is None: # XXX can we postpone allocation to later? self.seq[i] = W_NDimArray.from_shape(space, self.shape, out_dtype) else: if not self.op_flags[i].broadcast: # Raises if output cannot be broadcast try: shape_agreement(space, self.shape, self.seq[i], False) except OperationError as e: raise oefmt(space.w_ValueError, "non-broadcastable" " output operand with shape %s doesn't match " "the broadcast shape %s", str(self.seq[i].get_shape()), str(self.shape)) if self.tracked_index != "": order = self.order if order == NPY.KEEPORDER: order = self.seq[0].implementation.order if self.tracked_index == "multi": backward = False else: backward = (( order == NPY.CORDER and self.tracked_index != 'C') or ( order == NPY.FORTRANORDER and self.tracked_index != 'F')) self.index_iter = IndexIterator(self.shape, backward=backward) # handle w_op_dtypes part 2: copy where needed if possible if len(self.dtypes) > 0: for i in range(len(self.seq)): self_d = self.dtypes[i] seq_d = self.seq[i].get_dtype() if not self_d: self.dtypes[i] = seq_d elif self_d != seq_d: impl = self.seq[i].implementation if self.buffered or 'r' in self.op_flags[i].tmp_copy: if not can_cast_array( space, self.seq[i], self_d, self.casting): raise oefmt(space.w_TypeError, "Iterator operand %d" " dtype could not be cast from %R to %R" " according to the rule '%s'", i, seq_d, self_d, self.casting) order = support.get_order_as_CF(impl.order, self.order) new_impl = impl.astype(space, self_d, order).copy(space) self.seq[i] = W_NDimArray(new_impl) else: raise oefmt(space.w_TypeError, "Iterator " "operand required copying or buffering, " "but neither copying nor buffering was " "enabled") if 'w' in self.op_flags[i].rw: if not can_cast_type( space, self_d, seq_d, self.casting): raise oefmt(space.w_TypeError, "Iterator" " requested dtype could not be cast from " " %R to %R, the operand %d dtype, accord" "ing to the rule '%s'", self_d, seq_d, i, self.casting) elif self.buffered and not (self.external_loop and len(self.seq)<2): for i in range(len(self.seq)): if i not in outargs: self.seq[i] = self.seq[i].descr_copy(space, w_order=space.newint(self.order)) self.dtypes = [s.get_dtype() for s in self.seq] else: #copy them from seq self.dtypes = [s.get_dtype() for s in self.seq] # create an iterator for each operand self.iters = [] for i in range(len(self.seq)): it = self.get_iter(space, i) it.contiguous = False self.iters.append((it, it.reset())) if self.external_loop: coalesce_axes(self, space) def get_iter(self, space, i): arr = self.seq[i] imp = arr.implementation if arr.is_scalar(): return ConcreteIter(imp, 1, [], [], [], self.op_flags[i], self) shape = self.shape if (self.external_loop and len(self.seq)<2 and self.buffered): # Special case, always return a memory-ordered iterator stride = imp.dtype.elsize backstride = imp.size * stride - stride return ConcreteIter(imp, imp.get_size(), [support.product(shape)], [stride], [backstride], self.op_flags[i], self) backward = imp.order != self.order # XXX cleanup needed strides = imp.strides backstrides = imp.backstrides if self.allow_backward: if ((abs(imp.strides[0]) < abs(imp.strides[-1]) and not backward) or \ (abs(imp.strides[0]) > abs(imp.strides[-1]) and backward)): # flip the strides. Is this always true for multidimension? strides = imp.strides[:] backstrides = imp.backstrides[:] shape = imp.shape[:] strides.reverse() backstrides.reverse() shape.reverse() r = calculate_broadcast_strides(strides, backstrides, imp.shape, shape, backward) iter_shape = shape if len(shape) != len(r[0]): # shape can be shorter when using an external loop, just return a view iter_shape = imp.shape return ConcreteIter(imp, imp.get_size(), iter_shape, r[0], r[1], self.op_flags[i], self) def set_op_axes(self, space, w_op_axes): if space.len_w(w_op_axes) != len(self.seq): raise oefmt(space.w_ValueError, "op_axes must be a tuple/list matching the number of ops") op_axes = space.listview(w_op_axes) oa_ndim = -1 for w_axis in op_axes: if not space.is_none(w_axis): axis_len = space.len_w(w_axis) if oa_ndim == -1: oa_ndim = axis_len elif axis_len != oa_ndim: raise oefmt(space.w_ValueError, "Each entry of op_axes must have the same size") self.op_axes.append([space.int_w(x) if not space.is_none(x) else -1 for x in space.listview(w_axis)]) if oa_ndim == -1: raise oefmt(space.w_ValueError, "If op_axes is provided, at least one list of axes " "must be contained within it") raise oefmt(space.w_NotImplementedError, "op_axis not finished yet") # Check that values make sense: # - in bounds for each operand # ValueError: Iterator input op_axes[0][3] (==3) is not a valid axis of op[0], which has 2 dimensions # - no repeat axis # ValueError: The 'op_axes' provided to the iterator constructor for operand 1 contained duplicate value 0 return oa_ndim def descr_iter(self, space): return self def getitem(self, it, st): w_res = W_NDimArray(it.getoperand(st)) return w_res def descr_getitem(self, space, w_idx): idx = space.int_w(w_idx) try: it, st = self.iters[idx] except IndexError: raise oefmt(space.w_IndexError, "Iterator operand index %d is out of bounds", idx) return self.getitem(it, st) def descr_setitem(self, space, w_idx, w_value): raise oefmt(space.w_NotImplementedError, "not implemented yet") def descr_len(self, space): space.newint(len(self.iters)) @jit.unroll_safe def descr_next(self, space): for it, st in self.iters: if not it.done(st): break else: self.done = True raise OperationError(space.w_StopIteration, space.w_None) res = [] if self.index_iter: if not self.first_next: self.index_iter.next() else: self.first_next = False for i, (it, st) in enumerate(self.iters): res.append(self.getitem(it, st)) self.iters[i] = (it, it.next(st)) if len(res) < 2: return res[0] return space.newtuple(res) def iternext(self): if self.index_iter: self.index_iter.next() for i, (it, st) in enumerate(self.iters): self.iters[i] = (it, it.next(st)) for it, st in self.iters: if not it.done(st): break else: self.done = True return self.done return self.done def descr_iternext(self, space): return space.newbool(self.iternext()) def descr_copy(self, space): raise oefmt(space.w_NotImplementedError, "not implemented yet") def descr_debug_print(self, space): raise oefmt(space.w_NotImplementedError, "not implemented yet") def descr_enable_external_loop(self, space): raise oefmt(space.w_NotImplementedError, "not implemented yet") @unwrap_spec(axis=int) def descr_remove_axis(self, space, axis): raise oefmt(space.w_NotImplementedError, "not implemented yet") def descr_remove_multi_index(self, space, w_multi_index): raise oefmt(space.w_NotImplementedError, "not implemented yet") def descr_reset(self, space): raise oefmt(space.w_NotImplementedError, "not implemented yet") def descr_get_operands(self, space): l_w = [] for op in self.seq: l_w.append(op.descr_view(space)) return space.newlist(l_w) def descr_get_dtypes(self, space): res = [None] * len(self.seq) for i in range(len(self.seq)): res[i] = self.seq[i].descr_get_dtype(space) return space.newtuple(res) def descr_get_finished(self, space): return space.newbool(self.done) def descr_get_has_delayed_bufalloc(self, space): raise oefmt(space.w_NotImplementedError, "not implemented yet") def descr_get_has_index(self, space): return space.newbool(self.tracked_index in ["C", "F"]) def descr_get_index(self, space): if not self.tracked_index in ["C", "F"]: raise oefmt(space.w_ValueError, "Iterator does not have an index") if self.done: raise oefmt(space.w_ValueError, "Iterator is past the end") return space.newint(self.index_iter.getvalue()) def descr_get_has_multi_index(self, space): return space.newbool(self.tracked_index == "multi") def descr_get_multi_index(self, space): if not self.tracked_index == "multi": raise oefmt(space.w_ValueError, "Iterator is not tracking a multi-index") if self.done: raise oefmt(space.w_ValueError, "Iterator is past the end") return space.newtuple([space.newint(x) for x in self.index_iter.index]) def descr_get_iterationneedsapi(self, space): raise oefmt(space.w_NotImplementedError, "not implemented yet") def descr_get_iterindex(self, space): raise oefmt(space.w_NotImplementedError, "not implemented yet") def descr_get_itersize(self, space): return space.newint(support.product(self.shape)) def descr_get_itviews(self, space): raise oefmt(space.w_NotImplementedError, "not implemented yet") def descr_get_ndim(self, space): return space.newint(self.ndim) def descr_get_nop(self, space): raise oefmt(space.w_NotImplementedError, "not implemented yet") def descr_get_shape(self, space): raise oefmt(space.w_NotImplementedError, "not implemented yet") def descr_get_value(self, space): raise oefmt(space.w_NotImplementedError, "not implemented yet") @unwrap_spec(w_flags=WrappedDefault(None), w_op_flags=WrappedDefault(None), w_op_dtypes=WrappedDefault(None), w_order=WrappedDefault(None), w_casting=WrappedDefault(None), w_op_axes=WrappedDefault(None), w_itershape=WrappedDefault(None), w_buffersize=WrappedDefault(0)) def descr_new_nditer(space, w_subtype, w_seq, w_flags, w_op_flags, w_op_dtypes, w_casting, w_op_axes, w_itershape, w_buffersize, w_order): npy_order = order_converter(space, w_order, NPY.KEEPORDER) buffersize = space.int_w(w_buffersize) return W_NDIter(space, w_seq, w_flags, w_op_flags, w_op_dtypes, w_casting, w_op_axes, w_itershape, buffersize, npy_order) W_NDIter.typedef = TypeDef('numpy.nditer', __new__ = interp2app(descr_new_nditer), __iter__ = interp2app(W_NDIter.descr_iter), __getitem__ = interp2app(W_NDIter.descr_getitem), __setitem__ = interp2app(W_NDIter.descr_setitem), __len__ = interp2app(W_NDIter.descr_len), next = interp2app(W_NDIter.descr_next), iternext = interp2app(W_NDIter.descr_iternext), copy = interp2app(W_NDIter.descr_copy), debug_print = interp2app(W_NDIter.descr_debug_print), enable_external_loop = interp2app(W_NDIter.descr_enable_external_loop), remove_axis = interp2app(W_NDIter.descr_remove_axis), remove_multi_index = interp2app(W_NDIter.descr_remove_multi_index), reset = interp2app(W_NDIter.descr_reset), operands = GetSetProperty(W_NDIter.descr_get_operands), dtypes = GetSetProperty(W_NDIter.descr_get_dtypes), finished = GetSetProperty(W_NDIter.descr_get_finished), has_delayed_bufalloc = GetSetProperty(W_NDIter.descr_get_has_delayed_bufalloc), has_index = GetSetProperty(W_NDIter.descr_get_has_index), index = GetSetProperty(W_NDIter.descr_get_index), has_multi_index = GetSetProperty(W_NDIter.descr_get_has_multi_index), multi_index = GetSetProperty(W_NDIter.descr_get_multi_index), iterationneedsapi = GetSetProperty(W_NDIter.descr_get_iterationneedsapi), iterindex = GetSetProperty(W_NDIter.descr_get_iterindex), itersize = GetSetProperty(W_NDIter.descr_get_itersize), itviews = GetSetProperty(W_NDIter.descr_get_itviews), ndim = GetSetProperty(W_NDIter.descr_get_ndim), nop = GetSetProperty(W_NDIter.descr_get_nop), shape = GetSetProperty(W_NDIter.descr_get_shape), value = GetSetProperty(W_NDIter.descr_get_value), ) W_NDIter.typedef.acceptable_as_base_class = False