def shift(self, periods, offset=None, timeRule=None): """ Analogous to DataFrame.shift """ if timeRule is not None and offset is None: offset = datetools.getOffset(timeRule) new_series = {} if offset is None: new_index = self.index for col, s in self.iteritems(): new_series[col] = s.shift(periods) else: new_index = self.index.shift(periods, offset) for col, s in self.iteritems(): new_series[col] = SparseSeries( s.sp_values, index=new_index, sparse_index=s.sp_index, fill_value=s.fill_value ) return SparseDataFrame( new_series, index=new_index, columns=self.columns, default_fill_value=self.default_fill_value, default_kind=self.default_kind, )
def __init__(self, start=None, end=None, nPeriods=None, offset=datetools.BDay(), timeRule=None): if timeRule is not None: offset = datetools.getOffset(timeRule) if timeRule is None: if offset in datetools._offsetNames: timeRule = datetools._offsetNames[offset] start = datetools.to_datetime(start) end = datetools.to_datetime(end) if start and not offset.onOffset(start): start = start + offset.__class__(n=1, **offset.kwds) if end and not offset.onOffset(end): end = end - offset.__class__(n=1, **offset.kwds) if nPeriods == None and end < start: end = None nPeriods = 0 if end is None: end = start + (nPeriods - 1) * offset if start is None: start = end - (nPeriods - 1) * offset self.offset = offset self.timeRule = timeRule self.start = start self.end = end self.nPeriods = nPeriods
def shift(self, periods, offset=None, timeRule=None): """ Analogous to DataFrame.shift """ if timeRule is not None and offset is None: offset = datetools.getOffset(timeRule) new_series = {} if offset is None: new_index = self.index for col, s in self.iteritems(): new_series[col] = s.shift(periods) else: new_index = self.index.shift(periods, offset) for col, s in self.iteritems(): new_series[col] = SparseSeries(s.sp_values, index=new_index, sparse_index=s.sp_index, fill_value=s.fill_value) return SparseDataFrame(new_series, index=new_index, columns=self.columns, default_fill_value=self.default_fill_value, default_kind=self.default_kind)
def __new__(cls, start=None, end=None, periods=None, offset=datetools.bday, timeRule=None, **kwds): # Allow us to circumvent hitting the cache index = kwds.get('index') if index is None: if timeRule is not None: offset = datetools.getOffset(timeRule) if timeRule is None: if offset in datetools._offsetNames: timeRule = datetools._offsetNames[offset] # Cachable if not start: start = kwds.get('begin') if not end: end = kwds.get('end') if not periods: periods = kwds.get('nPeriods') start = datetools.to_datetime(start) end = datetools.to_datetime(end) # inside cache range fromInside = start is not None and start > CACHE_START toInside = end is not None and end < CACHE_END useCache = fromInside and toInside if (useCache and offset.isAnchored() and not isinstance(offset, datetools.Tick)): index = cls.getCachedRange(start, end, periods=periods, offset=offset, timeRule=timeRule) else: xdr = XDateRange(start=start, end=end, nPeriods=periods, offset=offset, timeRule=timeRule) index = np.array(list(xdr), dtype=object, copy=False) index = index.view(cls) index.offset = offset else: index = index.view(cls) return index
def _cached_range(cls, start=None, end=None, periods=None, offset=None, time_rule=None, name=None): # HACK: fix this dependency later if time_rule is not None: offset = datetools.getOffset(time_rule) if offset is None: raise Exception('Must provide a DateOffset!') if offset not in _daterange_cache: xdr = generate_range(_CACHE_START, _CACHE_END, offset=offset) arr = np.array(list(xdr), dtype=object, copy=False) cachedRange = arr.view(DateRange) cachedRange.offset = offset cachedRange.tzinfo = None cachedRange.name = None _daterange_cache[offset] = cachedRange else: cachedRange = _daterange_cache[offset] if start is None: if end is None: raise Exception('Must provide start or end date!') if periods is None: raise Exception('Must provide number of periods!') assert (isinstance(end, datetime)) end = offset.rollback(end) endLoc = cachedRange.get_loc(end) + 1 startLoc = endLoc - periods elif end is None: assert (isinstance(start, datetime)) start = offset.rollforward(start) startLoc = cachedRange.get_loc(start) if periods is None: raise Exception('Must provide number of periods!') endLoc = startLoc + periods else: start = offset.rollforward(start) end = offset.rollback(end) startLoc = cachedRange.get_loc(start) endLoc = cachedRange.get_loc(end) + 1 indexSlice = cachedRange[startLoc:endLoc] indexSlice.name = name return indexSlice
def getCachedRange(cls, start=None, end=None, periods=None, offset=None, timeRule=None): # HACK: fix this dependency later if timeRule is not None: offset = datetools.getOffset(timeRule) if offset is None: raise Exception('Must provide a DateOffset!') if offset not in cls._cache: xdr = XDateRange(CACHE_START, CACHE_END, offset=offset) arr = np.array(list(xdr), dtype=object, copy=False) cachedRange = DateRange.fromIndex(arr) cachedRange.offset = offset cls._cache[offset] = cachedRange else: cachedRange = cls._cache[offset] if start is None: if end is None: raise Exception('Must provide start or end date!') if periods is None: raise Exception('Must provide number of periods!') assert (isinstance(end, datetime)) end = offset.rollback(end) endLoc = cachedRange.indexMap[end] + 1 startLoc = endLoc - periods elif end is None: assert (isinstance(start, datetime)) start = offset.rollforward(start) startLoc = cachedRange.indexMap[start] if periods is None: raise Exception('Must provide number of periods!') endLoc = startLoc + periods else: start = offset.rollforward(start) end = offset.rollback(end) startLoc = cachedRange.indexMap[start] endLoc = cachedRange.indexMap[end] + 1 indexSlice = cachedRange[startLoc:endLoc] indexSlice._parent = cachedRange return indexSlice
def shift(self, periods, offset=None, timeRule=None): """ Shift the underlying series of the DataMatrix and Series objects within by given number (positive or negative) of periods. Parameters ---------- periods : int (+ or -) Number of periods to move offset : DateOffset, optional Increment to use from datetools module timeRule : string Time rule to use by name Returns ------- DataMatrix """ if periods == 0: return self if timeRule is not None and offset is None: offset = datetools.getOffset(timeRule) N = len(self) if offset is None: newIndex = self.index indexer = np.zeros(N, dtype=int) if periods > 0: indexer[periods:] = np.arange(N - periods) newValues = self.values.take(indexer, axis=0) newValues[:periods] = NaN else: indexer[:periods] = np.arange(-periods, N) newValues = self.values.take(indexer, axis=0) newValues[periods:] = NaN else: newIndex = self.index.shift(periods, offset) newValues = self.values.copy() if self.objects is not None: shifted_objects = self.objects.shift(periods, offset=offset, timeRule=timeRule) shifted_objects.index = newIndex else: shifted_objects = None return DataMatrix(data=newValues, index=newIndex, columns=self.columns, objects=shifted_objects)
def test_getOffset(): assert_raises(Exception, getOffset, "gibberish") assert getOffset("WEEKDAY") == BDay() assert getOffset("EOM") == BMonthEnd() assert getOffset("W@MON") == Week(weekday=0) assert getOffset("W@TUE") == Week(weekday=1) assert getOffset("W@WED") == Week(weekday=2) assert getOffset("W@THU") == Week(weekday=3) assert getOffset("W@FRI") == Week(weekday=4)
def __new__(cls, start=None, end=None, periods=None, offset=datetools.bday, time_rule=None, tzinfo=None, name=None, **kwds): time_rule = kwds.get('timeRule', time_rule) if time_rule is not None: offset = datetools.getOffset(time_rule) if time_rule is None: if offset in datetools._offsetNames: time_rule = datetools._offsetNames[offset] # Cachable if not start: start = kwds.get('begin') if not periods: periods = kwds.get('nPeriods') start = datetools.to_datetime(start) end = datetools.to_datetime(end) if start is not None and not isinstance(start, datetime): raise ValueError('Failed to convert %s to datetime' % start) if end is not None and not isinstance(end, datetime): raise ValueError('Failed to convert %s to datetime' % end) # inside cache range. Handle UTC case useCache = _will_use_cache(offset) start, end, tzinfo = _figure_out_timezone(start, end, tzinfo) useCache = useCache and _naive_in_cache_range(start, end) if useCache: index = cls._cached_range(start, end, periods=periods, offset=offset, time_rule=time_rule, name=name) if tzinfo is None: return index else: xdr = generate_range(start=start, end=end, periods=periods, offset=offset, time_rule=time_rule) index = list(xdr) if tzinfo is not None: index = [d.replace(tzinfo=tzinfo) for d in index] index = np.array(index, dtype=object, copy=False) index = index.view(cls) index.name = name index.offset = offset index.tzinfo = tzinfo return index
def test_getOffset(): assert_raises(Exception, getOffset, 'gibberish') assert getOffset('WEEKDAY') == BDay() assert getOffset('EOM') == BMonthEnd() assert getOffset('W@MON') == Week(weekday=0) assert getOffset('W@TUE') == Week(weekday=1) assert getOffset('W@WED') == Week(weekday=2) assert getOffset('W@THU') == Week(weekday=3) assert getOffset('W@FRI') == Week(weekday=4)
def _cached_range(cls, start=None, end=None, periods=None, offset=None, time_rule=None, name=None): # HACK: fix this dependency later if time_rule is not None: offset = datetools.getOffset(time_rule) if offset is None: raise Exception('Must provide a DateOffset!') if offset not in _daterange_cache: xdr = generate_range(_CACHE_START, _CACHE_END, offset=offset) arr = np.array(list(xdr), dtype=object, copy=False) cachedRange = arr.view(DateRange) cachedRange.offset = offset cachedRange.tzinfo = None cachedRange.name = None _daterange_cache[offset] = cachedRange else: cachedRange = _daterange_cache[offset] if start is None: if end is None: raise Exception('Must provide start or end date!') if periods is None: raise Exception('Must provide number of periods!') assert(isinstance(end, datetime)) end = offset.rollback(end) endLoc = cachedRange.get_loc(end) + 1 startLoc = endLoc - periods elif end is None: assert(isinstance(start, datetime)) start = offset.rollforward(start) startLoc = cachedRange.get_loc(start) if periods is None: raise Exception('Must provide number of periods!') endLoc = startLoc + periods else: start = offset.rollforward(start) end = offset.rollback(end) startLoc = cachedRange.get_loc(start) endLoc = cachedRange.get_loc(end) + 1 indexSlice = cachedRange[startLoc:endLoc] indexSlice.name = name return indexSlice
def getCachedRange(cls, start=None, end=None, periods=None, offset=None, timeRule=None): # HACK: fix this dependency later if timeRule is not None: offset = datetools.getOffset(timeRule) if offset is None: raise Exception('Must provide a DateOffset!') if offset not in cls._cache: xdr = XDateRange(CACHE_START, CACHE_END, offset=offset) arr = np.array(list(xdr), dtype=object, copy=False) cachedRange = DateRange.fromIndex(arr) cachedRange.offset = offset cls._cache[offset] = cachedRange else: cachedRange = cls._cache[offset] if start is None: if end is None: raise Exception('Must provide start or end date!') if periods is None: raise Exception('Must provide number of periods!') assert(isinstance(end, datetime)) end = offset.rollback(end) endLoc = cachedRange.indexMap[end] + 1 startLoc = endLoc - periods elif end is None: assert(isinstance(start, datetime)) start = offset.rollforward(start) startLoc = cachedRange.indexMap[start] if periods is None: raise Exception('Must provide number of periods!') endLoc = startLoc + periods else: start = offset.rollforward(start) end = offset.rollback(end) startLoc = cachedRange.indexMap[start] endLoc = cachedRange.indexMap[end] + 1 indexSlice = cachedRange[startLoc:endLoc] indexSlice._parent = cachedRange return indexSlice
def mdf_timestep(self, parameter_s=""): """ Gets/sets the timestep used to advance the date when calling %mdf_advance or %mdf_evalto. %mdf_timestep [offset] eg: %mdf_timestep or: %mdf_timestep WEEKDAY """ if parameter_s: self.__timestep = datetools.getOffset(parameter_s) return self.__timestep
def __new__(cls, start=None, end=None, periods=None, offset=datetools.bday, timeRule=None, tzinfo=None, **kwds): if timeRule is not None: offset = datetools.getOffset(timeRule) if timeRule is None: if offset in datetools._offsetNames: timeRule = datetools._offsetNames[offset] # Cachable if not start: start = kwds.get('begin') if not periods: periods = kwds.get('nPeriods') start = datetools.to_datetime(start) end = datetools.to_datetime(end) # inside cache range. Handle UTC case useCache = (offset.isAnchored() and isinstance(offset, datetools.CacheableOffset)) start, end, tzinfo = _figure_out_timezone(start, end, tzinfo) useCache = useCache and _naive_in_cache_range(start, end) if useCache: index = cls._cached_range(start, end, periods=periods, offset=offset, timeRule=timeRule) if tzinfo is None: return index else: xdr = generate_range(start=start, end=end, periods=periods, offset=offset, timeRule=timeRule) index = list(xdr) if tzinfo is not None: index = [d.replace(tzinfo=tzinfo) for d in index] index = np.array(index, dtype=object, copy=False) index = index.view(cls) index.offset = offset index.tzinfo = tzinfo return index
def shift(self, periods, offset=None, timeRule=None): """ Analogous to Series.shift """ # no special handling of fill values yet if not isnull(self.fill_value): dense_shifted = self.to_dense().shift(periods, offset=offset, timeRule=timeRule) return dense_shifted.to_sparse(fill_value=self.fill_value, kind=self.kind) if periods == 0: return self.copy() if timeRule is not None and offset is None: offset = datetools.getOffset(timeRule) if offset is not None: return SparseSeries(self.sp_values, sparse_index=self.sp_index, index=self.index.shift(periods, offset), fill_value=self.fill_value) int_index = self.sp_index.to_int_index() new_indices = int_index.indices + periods start, end = new_indices.searchsorted([0, int_index.length]) new_indices = new_indices[start:end] new_sp_index = IntIndex(len(self), new_indices) if isinstance(self.sp_index, BlockIndex): new_sp_index = new_sp_index.to_block_index() return SparseSeries(self.sp_values[start:end].copy(), index=self.index, sparse_index=new_sp_index, fill_value=self.fill_value)
def shift(self, periods, offset=None, timeRule=None): """ Shift the underlying series of the DataMatrix and Series objects within by given number (positive or negative) of business/weekdays. Parameters ---------- periods : int (+ or -) Number of periods to move offset : DateOffset, optional Increment to use from datetools module timeRule : string time rule name to use by name (e.g. 'WEEKDAY') Returns ------- TimeSeries """ if periods == 0: return self.copy() if timeRule is not None and offset is None: offset = datetools.getOffset(timeRule) if offset is None: newValues = np.empty(len(self), dtype=self.dtype) if periods > 0: newValues[periods:] = self.values[:-periods] newValues[:periods] = np.NaN elif periods < 0: newValues[:periods] = self.values[-periods:] newValues[periods:] = np.NaN return Series(newValues, index=self.index) else: newIndex = self.index.shift(periods, offset) return Series(self, index=newIndex)
def generate_range(start=None, end=None, periods=None, offset=datetools.BDay(), time_rule=None): """ Generates a sequence of dates corresponding to the specified time offset. Similar to dateutil.rrule except uses pandas DateOffset objects to represent time increments Parameters ---------- start : datetime (default None) end : datetime (default None) periods : int, optional Note ---- * This method is faster for generating weekdays than dateutil.rrule * At least two of (start, end, periods) must be specified. * If both start and end are specified, the returned dates will satisfy start <= date <= end. Returns ------- dates : generator object See also -------- DateRange, dateutil.rrule """ if time_rule is not None: offset = datetools.getOffset(time_rule) if time_rule is None: if offset in datetools._offsetNames: time_rule = datetools._offsetNames[offset] start = datetools.to_datetime(start) end = datetools.to_datetime(end) if start and not offset.onOffset(start): start = offset.rollforward(start) if end and not offset.onOffset(end): end = offset.rollback(end) if periods is None and end < start: end = None periods = 0 if end is None: end = start + (periods - 1) * offset if start is None: start = end - (periods - 1) * offset cur = start if offset._normalizeFirst: cur = datetools.normalize_date(cur) while cur <= end: yield cur # faster than cur + offset cur = offset.apply(cur)