def _getitem_iloc(self, key):
if not isinstance(key, tuple):
key = (key, None)
if isinstance(key[0], int) and isinstance(key[1], int):
return self._dataframe.getValue(key[0], key[1])
k = key[0]
if isinstance(k, int):
if k < 0:
k = self.shape[0] + k
rowkey = k
elif isinstance(k, slice):
sidx = 0 if k.start is None else k.start
if sidx < 0:
sidx = self.shape[0] + sidx
eidx = self.shape[0] - 1 if k.stop is None else k.stop - 1
if eidx < 0:
eidx = self.shape[0] + eidx
step = 1 if k.step is None else k.step
rowkey = Range(sidx, eidx, step)
elif isinstance(k, list):
rowkey = k
else:
return None
k = key[1]
if k is None:
colkey = Range(0, self.shape[1] - 1, 1)
else:
if isinstance(k, int):
sidx = k
if sidx < 0:
sidx = self.shape[1] + sidx
eidx = sidx
step = 1
colkey = Range(sidx, eidx, step)
elif isinstance(k, slice):
sidx = 0 if k.start is None else k.start
if sidx < 0:
sidx = self.shape[1] + sidx
eidx = self.shape[1] - 1 if k.stop is None else k.stop - 1
if eidx < 0:
eidx = self.shape[1] + eidx
step = 1 if k.step is None else k.step
colkey = Range(sidx, eidx, step)
elif isinstance(k, list):
colkey = k
else:
return None
r = self._dataframe.select(rowkey, colkey)
if r is None:
return None
if isinstance(r, MISeries):
r = series.Series(series=r)
else:
r = DataFrame(dataframe=r)
return r
def _getitem_iloc(self, key):
if isinstance(key, Index):
key = key.data
if isinstance(key, int):
if key < 0 or key >= self.__len__():
raise KeyError(key)
return self._series.getValue(key)
elif isinstance(key, (list, tuple, np.NDArray)):
if isinstance(key, np.NDArray):
key = key.aslist()
r = self._series.getValues(key)
return Series(series=r)
elif isinstance(key, slice):
if isinstance(key.start, basestring):
sidx = self._index.index(key.start)
if sidx < 0:
sidx = 0
else:
sidx = 0 if key.start is None else key.start
if sidx < 0:
sidx = self.__len__() + sidx
if isinstance(key.stop, basestring):
eidx = self._index.index(key.stop)
if eidx < 0:
eidx = self.__len__()
else:
eidx = self.__len__() - 1 if key.stop is None else key.stop - 1
if eidx < 0:
eidx = self.__len__() + eidx
step = 1 if key.step is None else key.step
rowkey = Range(sidx, eidx, step)
r = self._series.getValues(rowkey)
return Series(series=r)
else:
r = self._series.getValues(key)
if isinstance(r, MISeries):
return Series(series=r)
else:
return r
def _getitem_loc(self, key):
if isinstance(key, Index):
key = key.data
elif isinstance(key, datetime.datetime):
key = miutil.jdatetime(key)
if isinstance(key, (list, tuple, np.NDArray)):
if isinstance(key, np.NDArray):
key = key.aslist()
if isinstance(key[0], datetime.datetime):
key = miutil.jdatetime(key)
r = self._series.getValueByIndex(key)
return Series(series=r)
elif isinstance(key, slice):
if isinstance(key.start, basestring):
sidx = self._index.index(key.start)
if sidx < 0:
sidx = 0
else:
sidx = 0 if key.start is None else key.start
if sidx < 0:
sidx = self.__len__() + sidx
if isinstance(key.stop, basestring):
eidx = self._index.index(key.stop)
if eidx < 0:
eidx = self.__len__()
else:
eidx = self.__len__() - 1 if key.stop is None else key.stop - 1
if eidx < 0:
eidx = self.__len__() + eidx
step = 1 if key.step is None else key.step
rowkey = Range(sidx, eidx, step)
r = self._series.getValues(rowkey)
return Series(series=r)
else:
r = self._series.getValueByIndex(key)
if isinstance(r, MISeries):
return Series(series=r)
else:
return r
def __getitem__(self, indices):
if self.variable.getDataType() in [DataType.STRUCTURE, DataType.SEQUENCE]:
if isinstance(indices, str): #metadata
return self.member_array(indices)
else:
a = self.dataset.read(self.name)
return StructureArray(a.getArrayObject())
if indices is None:
inds = []
for i in range(self.ndim):
inds.append(slice(None))
indices = tuple(inds)
if not isinstance(indices, tuple):
inds = []
inds.append(indices)
indices = inds
if len(indices) < self.ndim:
indices = list(indices)
for i in range(self.ndim - len(indices)):
indices.append(slice(None))
indices = tuple(indices)
if len(indices) != self.ndim:
print 'indices must be ' + str(self.ndim) + ' dimensions!'
return None
if not self.proj is None and not self.proj.isLonLat():
xlim = None
ylim = None
xidx = -1
yidx = -1
for i in range(0, self.ndim):
dim = self.dims[i]
if dim.getDimType() == DimensionType.X:
k = indices[i]
if isinstance(k, basestring):
xlims = k.split(':')
if len(xlims) == 1:
xlim = [float(xlims[0])]
else:
xlim = [float(xlims[0]), float(xlims[1])]
xidx = i
elif dim.getDimType() == DimensionType.Y:
k = indices[i]
if isinstance(k, basestring):
ylims = k.split(':')
if len(ylims) == 1:
ylim = [float(ylims[0])]
else:
ylim = [float(ylims[0]), float(ylims[1])]
yidx = i
if not xlim is None and not ylim is None:
fromproj=KnownCoordinateSystems.geographic.world.WGS1984
inpt = PointD(xlim[0], ylim[0])
outpt1 = Reproject.reprojectPoint(inpt, fromproj, self.proj)
if len(xlim) == 1:
xlim = [outpt1.X]
ylim = [outpt1.Y]
else:
inpt = PointD(xlim[1], ylim[1])
outpt2 = Reproject.reprojectPoint(inpt, fromproj, self.proj)
xlim = [outpt1.X, outpt2.X]
ylim = [outpt1.Y, outpt2.Y]
indices1 = []
for i in range(0, self.ndim):
if i == xidx:
if len(xlim) == 1:
indices1.append(str(xlim[0]))
else:
indices1.append(str(xlim[0]) + ':' + str(xlim[1]))
elif i == yidx:
if len(ylim) == 1:
indices1.append(str(ylim[0]))
else:
indices1.append(str(ylim[0]) + ':' + str(ylim[1]))
else:
indices1.append(indices[i])
indices = indices1
origin = []
size = []
stride = []
ranges = []
dims = []
flips = []
onlyrange = True
for i in range(0, self.ndim):
isrange = True
dimlen = self.dimlen(i)
k = indices[i]
if isinstance(k, int):
if k < 0:
k = self.dims[i].getLength() + k
sidx = k
eidx = k
step = 1
elif isinstance(k, slice):
if isinstance(k.start, basestring):
sv = float(k.start)
sidx = self.dims[i].getValueIndex(sv)
elif isinstance(k.start, datetime.datetime):
sv = miutil.date2num(k.start)
sidx = self.dims[i].getValueIndex(sv)
else:
sidx = 0 if k.start is None else k.start
if sidx < 0:
sidx = self.dimlen(i) + sidx
if isinstance(k.stop, basestring):
ev = float(k.stop)
eidx = self.dims[i].getValueIndex(ev)
elif isinstance(k.stop, datetime.datetime):
ev = miutil.date2num(k.stop)
eidx = self.dims[i].getValueIndex(ev)
else:
eidx = self.dimlen(i) if k.stop is None else k.stop
if eidx < 0:
eidx = self.dimlen(i) + eidx
eidx -= 1
if isinstance(k.step, basestring):
nv = float(k.step) + self.dims[i].getDimValue()[0]
nidx = self.dims[i].getValueIndex(nv)
step = nidx - sidx
elif isinstance(k.step, datetime.timedelta):
nv = miutil.date2num(k.start + k.step)
nidx = self.dims[i].getValueIndex(nv)
step = nidx - sidx
else:
step = 1 if k.step is None else k.step
if sidx > eidx:
iidx = eidx
eidx = sidx
sidx = iidx
elif isinstance(k, list):
onlyrange = False
isrange = False
if not isinstance(k[0], datetime.datetime):
ranges.append(k)
else:
tlist = []
for tt in k:
sv = miutil.date2num(tt)
idx = self.dims[i].getValueIndex(sv)
tlist.append(idx)
ranges.append(tlist)
k = tlist
elif isinstance(k, basestring):
dim = self.variable.getDimension(i)
kvalues = k.split(':')
sv = float(kvalues[0])
sidx = dim.getValueIndex(sv)
if len(kvalues) == 1:
eidx = sidx
step = 1
else:
ev = float(kvalues[1])
eidx = dim.getValueIndex(ev)
if len(kvalues) == 2:
step = 1
else:
step = int(float(kvalues[2]) / dim.getDeltaValue())
if sidx > eidx:
iidx = eidx
eidx = sidx
sidx = iidx
else:
print k
return None
if isrange:
if eidx >= dimlen:
print 'Index out of range!'
return None
origin.append(sidx)
n = eidx - sidx + 1
size.append(n)
if n > 1:
dim = self.variable.getDimension(i)
if dim.isReverse():
step = -step
dim = dim.extract(sidx, eidx, step)
dim.setReverse(False)
dims.append(dim)
stride.append(step)
if step < 0:
step = abs(step)
flips.append(i)
rr = Range(sidx, eidx, step)
ranges.append(rr)
else:
if len(k) > 1:
dim = self.variable.getDimension(i)
dim = dim.extract(k)
dim.setReverse(False)
dims.append(dim)
#rr = self.dataset.read(self.name, origin, size, stride).reduce()
if onlyrange:
rr = self.dataset.dataset.read(self.name, ranges)
else:
rr = self.dataset.dataset.take(self.name, ranges)
if rr.getSize() == 1:
iter = rr.getIndexIterator()
return iter.getObjectNext()
else:
for i in flips:
rr = rr.flip(i)
rr = rr.reduce()
ArrayMath.missingToNaN(rr, self.fill_value)
if len(flips) > 0:
rrr = Array.factory(rr.getDataType(), rr.getShape())
MAMath.copy(rrr, rr)
array = np.array(rrr)
else:
array = np.array(rr)
data = np.DimArray(array, dims, self.fill_value, self.dataset.proj)
return data
def __getitem__(self, indices):
if not isinstance(indices, tuple):
inds = []
inds.append(indices)
indices = inds
if len(indices) < self.ndim:
if isinstance(indices, tuple):
indices = list(indices)
for i in range(self.ndim - len(indices)):
indices.append(slice(None))
allint = True
aindex = self._array.getIndex()
i = 0
for ii in indices:
if isinstance(ii, int):
if ii < 0:
ii = self.shape[i] + ii
aindex.setDim(i, ii)
else:
allint = False
break
i += 1
if allint:
return self._array.getObject(aindex)
if self.ndim == 0:
return self
newaxisn = 0
newaxis = False
if len(indices) > self.ndim:
newaxisn = len(indices) - self.ndim
newaxis = True
for i in range(newaxisn):
if not indices[-i - 1] is None:
newaxis = False
if newaxis:
indices = list(indices)
indices = indices[:-newaxisn]
if len(indices) != self.ndim:
print 'indices must be ' + str(self.ndim) + ' dimensions!'
raise IndexError()
ranges = []
flips = []
onlyrange = True
alllist = True
isempty = False
nshape = []
for i in range(0, self.ndim):
k = indices[i]
if isinstance(k, int):
if k < 0:
k = self._shape[i] + k
sidx = k
eidx = k
step = 1
alllist = False
elif isinstance(k, slice):
sidx = 0 if k.start is None else k.start
if sidx < 0:
sidx = self._shape[i] + sidx
eidx = self._shape[i] if k.stop is None else k.stop
if eidx < 0:
eidx = self._shape[i] + eidx
eidx -= 1
step = 1 if k.step is None else k.step
alllist = False
elif isinstance(k, (list, tuple, NDArray)):
if isinstance(k, NDArray):
k = k.aslist()
if isinstance(k[0], bool):
kk = []
for i in range(len(k)):
if k[i]:
kk.append(i)
k = kk
onlyrange = False
ranges.append(k)
continue
else:
print k
return None
if step < 0:
step = abs(step)
flips.append(i)
if eidx < sidx:
tempidx = sidx
sidx = eidx + 2
eidx = tempidx
if sidx >= self.shape[i]:
isempty = True
if eidx < sidx:
isempty = True
else:
rr = Range(sidx, eidx, step)
ranges.append(rr)
nshape.append(eidx - sidx + 1 if eidx - sidx >= 0 else 0)
if isempty:
r = ArrayUtil.empty([0], self.dtype._dtype)
return NDArray(r)
if onlyrange:
r = ArrayMath.section(self._array, ranges)
else:
if alllist:
r = ArrayMath.takeValues(self._array, ranges)
else:
r = ArrayMath.take(self._array, ranges)
if newaxis:
for i in flips:
r = r.flip(i)
rr = Array.factory(r.getDataType(), r.getShape())
MAMath.copy(rr, r)
rr = NDArray(rr)
newshape = list(rr.shape)
for i in range(newaxisn):
newshape.append(1)
return rr.reshape(newshape)
if r.getSize() == 1:
iter = r.getIndexIterator()
r = iter.getObjectNext()
if isinstance(r, Complex):
return complex(r.getReal(), r.getImaginary())
else:
return r
else:
for i in flips:
r = r.flip(i)
r = NDArray(r)
if onlyrange:
r.base = self.get_base()
return r
def __setitem__(self, indices, value):
#print type(indices)
if isinstance(indices, NDArray):
if isinstance(value, NDArray):
value = value.asarray()
ArrayMath.setValue(self._array, indices._array, value)
return None
if not isinstance(indices, tuple):
inds = []
inds.append(indices)
indices = inds
if len(indices) < self.ndim:
for i in range(self.ndim - len(indices)):
indices.append(slice(None))
if self.ndim == 0:
self._array.setObject(0, value)
return None
if len(indices) != self.ndim:
print 'indices must be ' + str(self.ndim) + ' dimensions!'
raise IndexError()
ranges = []
flips = []
onlyrange = True
alllist = True
for i in range(0, self.ndim):
k = indices[i]
if isinstance(k, int):
sidx = k
if sidx < 0:
sidx = self._shape[i] + sidx
eidx = sidx
step = 1
alllist = False
elif isinstance(k, (list, tuple, NDArray)):
if isinstance(k, NDArray):
k = k.aslist()
onlyrange = False
ranges.append(k)
continue
else:
sidx = 0 if k.start is None else k.start
if sidx < 0:
sidx = self._shape[i] + sidx
eidx = self._shape[i] if k.stop is None else k.stop
if eidx < 0:
eidx = self._shape[i] + eidx
eidx -= 1
step = 1 if k.step is None else k.step
alllist = False
if step < 0:
step = abs(step)
flips.append(i)
if eidx < sidx:
return
rr = Range(sidx, eidx, step)
ranges.append(rr)
if isinstance(value, (list, tuple)):
value = ArrayUtil.array(value)
if isinstance(value, NDArray):
value = value.asarray()
if onlyrange:
r = ArrayMath.setSection(self._array, ranges, value)
else:
if alllist:
r = ArrayMath.setSection_List(self._array, ranges, value)
else:
r = ArrayMath.setSection_Mix(self._array, ranges, value)
self._array = r
def _getitem_loc(self, key):
if not isinstance(key, tuple):
key = (key, None)
k = key[0]
rkeys = key[0]
if isinstance(k, slice):
sidx = 0 if k.start is None else self._index.index(k.start)
if sidx < 0:
raise KeyError(key)
eidx = self.shape[0] - 1 if k.stop is None else self._index.index(
k.stop)
if eidx < 0:
raise KeyError(key)
step = 1 if k.step is None else k.step
rowkey = Range(sidx, eidx, step)
else:
rloc = self._index.get_loc(k, outkeys=True)
if isinstance(rloc, tuple):
rowkey = rloc[0]
rkeys = rloc[1]
else:
rowkey = rloc
rkeys = None
if len(rowkey) == 0:
raise KeyError(key)
k = key[1]
if k is None:
colkey = Range(0, self.shape[1] - 1, 1)
else:
if isinstance(k, slice):
sidx = 0 if k.start is None else self.columns.indexOfName(
k.start)
if sidx < 0:
raise KeyError(key)
eidx = self.shape[
1] - 1 if k.stop is None else self.columns.indexOfName(
k.stop)
if eidx < 0:
raise KeyError(key)
step = 1 if k.step is None else k.step
colkey = Range(sidx, eidx, step)
elif isinstance(k, list):
colkey = self.columns.indexOfName(k)
elif isinstance(k, basestring):
col = self.columns.indexOfName(k)
if col < 0:
raise KeyError(key)
colkey = [col]
else:
return None
if isinstance(rowkey, (int, Range)):
r = self._dataframe.select(rowkey, colkey)
else:
if isinstance(colkey, Range):
ncol = colkey.length()
else:
ncol = len(colkey)
if len(rowkey) == 1 and ncol == 1:
if isinstance(colkey, Range):
return self._dataframe.getValue(rowkey[0], colkey.first())
else:
return self._dataframe.getValue(rowkey[0], colkey[0])
if rkeys is None:
r = self._dataframe.select(rowkey, colkey)
else:
if not isinstance(rkeys, list):
rkeys = [rkeys]
r = self._dataframe.select(rkeys, rowkey, colkey)
if r is None:
return None
if isinstance(r, MISeries):
r = series.Series(series=r)
else:
r = DataFrame(dataframe=r)
return r
def __setitem__(self, key, value):
if isinstance(value, datetime.datetime):
value = miutil.jdatetime(value)
if isinstance(value, (list, tuple)):
if isinstance(value[0], datetime.datetime):
value = miutil.jdatetime(value)
value = np.array(value)
if isinstance(value, np.NDArray):
value = value._array
if isinstance(key, basestring):
if isinstance(value, series.Series):
value = value.values._array
self._dataframe.setColumn(key, value)
return
hascolkey = True
if isinstance(key, tuple):
ridx = key[0]
cidx = key[1]
if isinstance(ridx, int) and isinstance(cidx, int):
if ridx < 0:
ridx = self.shape[0] + ridx
if cidx < 0:
cidx = self.shape[1] + cidx
self._dataframe.setValue(ridx, cidx, value)
return
elif isinstance(ridx, int) and isinstance(cidx, basestring):
if ridx < 0:
ridx = self.shape[0] + ridx
self._dataframe.setValue(ridx, cidx, value)
return
else:
key = (key, slice(None))
hascolkey = False
k = key[0]
if isinstance(k, int):
if k < 0:
k = self.shape[0] + k
rowkey = k
elif isinstance(k, basestring):
sidx = self._index.index(k)
if sidx < 0:
return None
eidx = sidx
step = 1
rowkey = Range(sidx, eidx, step)
elif isinstance(k, slice):
if isinstance(k.start, basestring):
sidx = self._index.index(k.start)
if sidx < 0:
sidx = 0
else:
sidx = 0 if k.start is None else k.start
if sidx < 0:
sidx = self.shape[0] + sidx
if isinstance(k.stop, basestring):
eidx = self._index.index(k.stop)
if eidx < 0:
eidx = self.shape[0] + eidx
else:
eidx = self.shape[0] - 1 if k.stop is None else k.stop - 1
if eidx < 0:
eidx = self.shape[0] + eidx
step = 1 if k.step is None else k.step
rowkey = Range(sidx, eidx, step)
elif isinstance(k, list):
if isinstance(k[0], int):
rowkey = k
else:
tlist = []
for tstr in k:
idx = self._index.index(tstr)
if idx >= 0:
tlist.append(idx)
rowkey = tlist
else:
return
if not hascolkey:
colkey = Range(0, self.shape[1] - 1, 1)
else:
k = key[1]
if isinstance(k, int):
sidx = k
if sidx < 0:
sidx = self.shape[1] + sidx
eidx = sidx
step = 1
colkey = Range(sidx, eidx, step)
elif isinstance(k, slice):
sidx = 0 if k.start is None else k.start
if sidx < 0:
sidx = self.shape[1] + sidx
eidx = self.shape[1] - 1 if k.stop is None else k.stop - 1
if eidx < 0:
eidx = self.shape[1] + eidx
step = 1 if k.step is None else k.step
colkey = Range(sidx, eidx, step)
elif isinstance(k, list):
if isinstance(k[0], int):
colkey = k
else:
colkey = self.columns.indexOfName(k)
elif isinstance(k, basestring):
col = self.columns.indexOf(k)
colkey = Range(col, col + 1, 1)
else:
return
self._dataframe.setValues(rowkey, colkey, value)
def __getitem__(self, key):
if isinstance(key, basestring):
data = self._dataframe.getColumnData(key)
if data is None:
return data
idx = self._index[:]
r = series.Series(np.array(data), idx, key)
return r
hascolkey = True
if isinstance(key, tuple):
ridx = key[0]
cidx = key[1]
if isinstance(ridx, int) and isinstance(cidx, int):
if ridx < 0:
ridx = self.shape[0] + ridx
if cidx < 0:
cidx = self.shape[1] + cidx
return self._dataframe.getValue(ridx, cidx)
elif isinstance(ridx, int) and isinstance(cidx, basestring):
if ridx < 0:
ridx = self.shape[0] + ridx
return self._dataframe.getValue(ridx, cidx)
else:
key = (key, slice(None))
hascolkey = False
k = key[0]
if isinstance(k, Index):
k = k.data
if isinstance(k, int):
if k < 0:
k = self.shape[0] + k
rowkey = k
elif isinstance(k, basestring):
sidx = self._index.index(k)
if sidx < 0:
return None
eidx = sidx
step = 1
rowkey = Range(sidx, eidx, step)
elif isinstance(k, slice):
if isinstance(k.start, basestring):
sidx = self._index.index(k.start)
if sidx < 0:
sidx = 0
else:
sidx = 0 if k.start is None else k.start
if sidx < 0:
sidx = self.shape[0] + sidx
if isinstance(k.stop, basestring):
eidx = self._index.index(k.stop)
if eidx < 0:
eidx = self.shape[0] + eidx
else:
eidx = self.shape[0] - 1 if k.stop is None else k.stop - 1
if eidx < 0:
eidx = self.shape[0] + eidx
step = 1 if k.step is None else k.step
rowkey = Range(sidx, eidx, step)
elif isinstance(k, (list, tuple, np.NDArray, series.Series)):
if isinstance(k[0], (int, bool)):
if isinstance(k, (list, tuple)):
rowkey = k
else:
rowkey = k.asarray()
else:
tlist = []
for tstr in k:
idx = self._index.index(tstr)
if idx >= 0:
tlist.append(idx)
rowkey = tlist
else:
rowkey = self._index.get_loc(k)
if not hascolkey:
colkey = Range(0, self.shape[1] - 1, 1)
else:
k = key[1]
if isinstance(k, int):
sidx = k
if sidx < 0:
sidx = self.shape[1] + sidx
eidx = sidx
step = 1
colkey = Range(sidx, eidx, step)
elif isinstance(k, slice):
sidx = 0 if k.start is None else k.start
if sidx < 0:
sidx = self.shape[1] + sidx
eidx = self.shape[1] - 1 if k.stop is None else k.stop - 1
if eidx < 0:
eidx = self.shape[1] + eidx
step = 1 if k.step is None else k.step
colkey = Range(sidx, eidx, step)
elif isinstance(k, list):
if isinstance(k[0], int):
colkey = k
else:
colkey = self.columns.indexOfName(k)
elif isinstance(k, basestring):
col = self.columns.indexOf(k)
colkey = Range(col, col + 1, 1)
else:
return None
r = self._dataframe.select(rowkey, colkey)
if r is None:
return None
if isinstance(r, MISeries):
r = series.Series(series=r)
else:
r = DataFrame(dataframe=r)
return r
def __getitem__(self, key):
if isinstance(key, basestring):
coldata = self.data.getColumnData(key)
if coldata.getDataType().isNumeric():
return NDArray(ArrayUtil.array(coldata.getDataValues()))
elif coldata.getDataType() == DataType.DATE:
vv = coldata.getData()
r = []
cal = Calendar.getInstance()
for v in vv:
cal.setTime(v)
year = cal.get(Calendar.YEAR)
month = cal.get(Calendar.MONTH) + 1
day = cal.get(Calendar.DAY_OF_MONTH)
hour = cal.get(Calendar.HOUR_OF_DAY)
minute = cal.get(Calendar.MINUTE)
second = cal.get(Calendar.SECOND)
dt = datetime.datetime(year, month, day, hour, minute,
second)
r.append(dt)
return r
else:
return NDArray(ArrayUtil.array(coldata.getData()))
hascolkey = True
if isinstance(key, tuple):
ridx = key[0]
cidx = key[1]
if isinstance(ridx, int) and isinstance(cidx, int):
if ridx < 0:
ridx = self.shape[0] + ridx
if cidx < 0:
cidx = self.shape[1] + cidx
return self.data.getValue(ridx, cidx)
elif isinstance(ridx, int) and isinstance(cidx, basestring):
if ridx < 0:
ridx = self.shape[0] + ridx
return self.data.getValue(ridx, cidx)
else:
key = (key, slice(None))
hascolkey = False
k = key[0]
if isinstance(k, int):
sidx = k
if sidx < 0:
sidx = self.shape[0] + sidx
eidx = sidx + 1
step = 1
rowkey = Range(sidx, eidx, step)
elif isinstance(k, slice):
if isinstance(k.start, basestring):
t = miutil.str2date(k.start)
t = miutil.jdate(t)
sidx = self.data.getTimeIndex(t)
if sidx < 0:
sidx = 0
else:
sidx = 0 if k.start is None else k.start
if sidx < 0:
sidx = self.shape[0] + sidx
if isinstance(k.stop, basestring):
t = miutil.str2date(k.stop)
t = miutil.jdate(t)
eidx = self.data.getTimeIndex(t) + 1
if eidx < 0:
eidx = self.shape[0]
else:
eidx = self.shape[0] if k.stop is None else k.stop
if eidx < 0:
eidx = self.shape[0] + eidx
step = 1 if k.step is None else k.step
rowkey = Range(sidx, eidx, step)
elif isinstance(k, list):
if isinstance(k[0], basestring):
tlist = []
for tstr in k:
t = miutil.jdate(miutil.str2date(tstr))
idx = self.data.getTimeIndex_Ex(t)
if idx >= 0:
tlist.append(idx)
rowkey = tlist
else:
rowkey = k
else:
return None
tcolname = self.data.getTimeColName()
if not hascolkey:
r = self.data.select(rowkey)
if r.findColumn(tcolname) is None:
r = TableData(r)
else:
r = TimeTableData(r, tcolname)
return PyTableData(r)
k = key[1]
if isinstance(k, int):
sidx = k
if sidx < 0:
sidx = self.shape[1] + sidx
eidx = sidx + 1
step = 1
colkey = Range(sidx, eidx, step)
elif isinstance(k, slice):
sidx = 0 if k.start is None else k.start
if sidx < 0:
sidx = self.shape[1] + sidx
eidx = self.shape[1] if k.stop is None else k.stop
if eidx < 0:
eidx = self.shape[1] + eidx
step = 1 if k.step is None else k.step
colkey = Range(sidx, eidx, step)
elif isinstance(k, list):
if isinstance(k[0], basestring):
cols = self.data.findColumns(k)
else:
cols = self.data.findColumns_Index(k)
colkey = cols
elif isinstance(k, basestring):
rows = self.data.getRows(rowkey)
coldata = self.data.getColumnData(rows, k)
if coldata.getDataType().isNumeric():
return NDArray(ArrayUtil.array(coldata.getDataValues()))
else:
return NDArray(ArrayUtil.array(coldata.getData()))
else:
return None
r = self.data.select(rowkey, colkey)
if r.findColumn(tcolname) is None:
r = TableData(r)
else:
r = TimeTableData(r, tcolname)
return PyTableData(r)
