def generateYearsArray(start_year, end_year, **kwargs): first_year = asDatetime(start_year) last_year = asDatetime(end_year) interval = relativedelta(years=int(kwargs.get('interval', 1))) date_format = kwargs.get('date_format', None) as_numpy = kwargs.get('as_numpy', True) years = [] date = first_year if date_format in (datetime, object, 'object'): while date <= last_year: years.append(date) date += interval dtype = 'object' as_numpy = False elif date_format in (int, 'int'): while date <= last_year: years.append(date.year) date += interval dtype = 'i2' else: if date_format is None: date_format = '%Y' while date <= last_year: years.append(date.strftime(date_format)) date += interval dtype = '|S%d' % len(years[0]) if as_numpy: return N.array(years, dtype=dtype) else: return tuple(years)
def listDates(self, interval_start, interval_end, interval=None): if interval is None: _interval = self.interval else: _interval = interval dates = [] date = asDatetime(interval_start) while date <= asDatetime(interval_end): dates.append(date) date = monthsInterval(date, _interval) return tuple(dates)
def listDates(self, interval_start, interval_end, interval=None): if interval is None: num_days = relativedelta(days=self.interval) else: num_days = relativedelta(days=interval) dates = [] date = asDatetime(interval_start) while date <= asDatetime(interval_end): dates.append(date) date += num_days return tuple(dates)
def setTimeSpan(self, iter_start, iter_end): if isinstance(iter_start, (list, tuple)) and len(iter_start) == 2: iter_start = (iter_start[0], iter_start[1], lastDayOfMonth(*iter_start)) self.iter_start = asDatetime(iter_start) if isinstance(iter_end, (list, tuple)) and len(iter_end) == 2: iter_end = (iter_end[0], iter_end[1], lastDayOfMonth(*iter_end)) self.iter_end = asDatetime(iter_end)
def generateHoursArray(first_hour, last_hour): hour = asDatetime(first_hour) last_hour = asDatetime(last_hour) interval = relativedelta(hours=1) hours = [] while hour <= last_hour: int_date = (hour.year * 1000000) + (hour.month * 10000) int_date += (hour.day * 100) + hour.hour hours.append(int_date) hour += interval return N.array(hours, dtype='i4')
def _validTimes(self, start_time, end_time): """ returns tuple containing index of start_time and index of end_time """ if start_time is None or start_time == ':': if end_time is None: return self.base_time, self.base_time elif end_time == ':': return self.base_time, self.last_time return self.base_time, asDatetime(end_time) else: _start_time = asDatetime(start_time) if end_time is None: return _start_time, _start_time elif end_time == ':': return _start_time, self.last_time return _start_time, asDatetime(end_time)
def _indexForTime(_time): date_time = asDatetime(_time) years = date_time.year - self.base_time.year months = years * 12 if date_time.month != 12: months -= (12 - date_time.month) if self.base_time.month != 1: months -= self.base_time.month - 1 return months
def __call__(self, date, stats_matrix, data): num_hours = len(data) front_cushion = self.cushions[0] end_index = num_hours - self.cushions[1] self.detected = [] if self.isvalid is None: self.isvalid = [True for item in data] has_valid_data = True else: has_valid_data = self.hasValidData() if not has_valid_data: return # detect all sequences ... don't use filters for now detected = self.detector(data, 0, end_index) if len(detected) == 0: return # validate against Period of Record stats = stats_matrix[asDatetime(date).month] mean = stats[3] stddev = stats[5] for severity in self.severities: num_stddevs = self.stddevs[severity] limit = mean + (num_stddevs * stddev) for value, length, end_index in detected: if end_index < front_cushion: continue if length > limit and self.isvalid[end_index]: end_hour = self.hourFromIndex(end_index) detail = (severity, 'seq', end_hour, value, length, limit, num_stddevs) self._capture(end_index, detail)
def _indexForTime(_time): delta = asDatetime(_time) - self.base_time hours = (delta.days * 24) + (delta.seconds / 3600) indx = hours / interval over = hours % interval if over > 0: return indx + 1 else: return indx
def __call__(self, date, stats_matrix, data, isvalid=None): num_hours = len(data) start_index = self.cushions[0] - 1 end_index = (num_hours - self.cushions[1]) + 1 self.detected = [] if self.isvalid is None: self.isvalid = [True for item in data] has_valid_data = True else: has_valid_data = self.hasValidData() if not has_valid_data: return # detect any spikes ... don't use filters for now detected = self.detector(data, start_index, end_index) if len(detected) == 0: return # validate against Period of Record for the month stats = stats_matrix[asDatetime(date).month] mean = stats[3] stddev = stats[5] for severity in self.severities: num_stddevs = self.stddevs[severity] limit = mean + (num_stddevs * stddev) for spike, indx, value in detected: magnitude = min(abs(spike[0]), abs(spike[1])) if magnitude > limit and self.isvalid[indx]: hour = self.hourFromIndex(indx) detail = (severity, 'spk', hour, value, spike, limit, num_stddevs) self._capture(indx, detail)
def index(self, date_time): _date_time = asDatetime(date_time) if _date_time == self.base_time: return 0 delta = _date_time - self.base_time hours = (delta.days * 24) + (delta.seconds / 3600) if (hours % self.interval) == 0: return hours / self.interval else: return (hours + self.interval) / self.interval
def __init__(self, time_series, start_time=None, end_time=None, interval=None, duration=None): """ handles instances of the TimeSeriesData class or it's subclassses """ if start_time is None: iter_start = time_series.common_start_time else: iter_start = asDatetime(start_time) if end_time is None: iter_end = time_series.common_end_time else: iter_end = asDatetime(end_time) if interval is None: interval = time_series.interval if duration is None: duration = time_series.interval self.iterator = timeIterator(time_series.frequency, iter_start, iter_end, interval, duration)
def generateHoursArray(start_hour, end_hour, **kwargs): first_hour = asDatetime(start_hour) last_hour = asDatetime(end_hour) interval = relativedelta(hours=int(kwargs.get('interval', 1))) date_format = kwargs.get('date_format', None) as_numpy = kwargs.get('as_numpy', True) hours = [] hour = first_hour if date_format in (datetime, object, 'object'): while hour <= last_hour: hours.append(hour) hour += interval dtype = 'object' as_numpy = False elif date_format in (int, 'int'): while hour <= last_hour: hours.append((hour.year * 1000000) + (hour.month * 10000) + (hour.day * 100) + hour.hour) hour += interval dtype = N.dtype(int) elif date_format == 'tuple': while hour <= last_hour: hours.append((hour.year, hour.month, hour.day, hour.hour)) hour += interval dtype = N.dtype({ 'names': ['year', 'month', 'day', 'hour'], 'formats': ['i2', 'i2', 'i2', 'i2'] }) else: if date_format is None: date_format = '%Y-%m-%d-%H' while hour <= last_hour: hours.append(hour.strftime(date_format)) hour += interval dtype = '|S%d' % len(hours[0]) if as_numpy: return N.array(hours, dtype=dtype) else: return tuple(hours)
def __init__(self, time_series, start_time=None, end_time=None, interval=None, duration=None): """ handles instances of the MultiTimeSeries class or it's subclassses """ #TODO : handle 2D arrays if start_time is None: iter_start = time_series.common_start_time else: iter_start = asDatetime(start_time) if end_time is None: iter_end = time_series.common_end_time else: iter_end = asDatetime(end_time) if interval is None: interval = time_series.interval if duration is None: duration = time_series.interval self.dataset_names = time_series.dataset_names self.indexers = time_series.indexers self.iterator = timeIterator(time_series.frequency, iter_start, iter_end, interval, duration)
def generateDaysArray(start_date, end_date, **kwargs): first_date = asDatetime(start_date) last_date = asDatetime(end_date) interval = relativedelta(days=int(kwargs.get('interval', 1))) date_format = kwargs.get('date_format', None) as_numpy = kwargs.get('as_numpy', True) days = [] date = first_date if date_format in (datetime, object, 'object'): while date <= last_date: days.append(date) date += interval dtype = 'object' as_numpy = False elif date_format in (int, 'int'): while date <= date_hour: days.append((date.year * 10000) + (date.month * 100) + date.day) date += interval dtype = int elif date_format == 'tuple': while date <= last_date: days.append((date.year, date.month, date.day)) date += interval dtype = N.dtype({ 'names': ['year', 'month', 'day'], 'formats': ['i2', 'i2', 'i2'] }) else: if date_format is None: date_format = '%Y-%m-%d' while date <= last_date: days.append(date.strftime(date_format)) date += interval dtype = '|S%d' % len(days[0]) if as_numpy: return N.array(days, dtype=dtype) else: return tuple(days)
def index(self, date_time): _date_time = asDatetime(date_time) _base_time = self.base_time if _date_time.year == _base_time.year\ and _date_time.month == _base_time.month: return 0 _interval = self.interval # index may be negative if date_time is earlier than base_time years = _date_time.year - _base_time.year if years == 0: # both in same year months = _date_time.month - _base_time.month else: # different years months = (years * 12) + (_date_time.month - _base_time.month) if (months % _interval) == 0: return months / _interval else: return (months + _interval) / _interval
def getStationData(factory, station, _date_, dataset_name, cushion=0): _datetime_ = asDatetime(_date_) start_time = (_datetime_ - relativedelta(days=1)) + relativedelta(hours=8) end_time = _datetime_ + relativedelta(hours=7) if cushion != 0: start_time -= relativedelta(hours=cushion) end_time += relativedelta(hours=cushion) start_time = dateAsTuple(start_time, True) end_time = dateAsTuple(end_time, True) ucan = HourlyDataConnection(days_per_request=1) _start_date_, _end_date_, data =\ ucan.getData(station, dataset_name, start_time, end_time) data = N.array(data) data[N.where(N.isinf(data))] = N.nan return datetime(*_start_date_), datetime(*_end_date_), data
def getStationPrecip(factory, station, _date_, cushion=0, test_run=False): _datetime_ = asDatetime(_date_) start_time = _datetime_ - ONE_DAY + relativedelta(hours=7) end_time = _datetime_ + relativedelta(hours=7) if cushion != 0: start_time -= relativedelta(hours=cushion) end_time += relativedelta(hours=cushion) if test_run: if station['sid'] == STATION_CACHE['sid']: data = STATION_CACHE['data'] dates = STATION_CACHE['dates'] else: # hourly data file must already exist filepath = factory.getFilepathForUcanid(station['ucanid'], 'hours') if not os.path.exists(filepath): print SKIP_MSG % station print 'Hourly data file does not exist : %s' % filepath return None manager = HDF5DataFileManager(filepath, 'r') data = manager.getData('pcpn.value') STATION_CACHE['data'] = data dates = manager.getData('pcpn.date') STATION_CACHE['dates'] = dates STATION_CACHE['sid'] = station['sid'] _start_time = dateAsInt(start_time, True) _end_time = dateAsInt(end_time, True) indexes = N.where((dates > (_start_time - 1)) & (dates < _end_time)) if len(indexes[0]) > 0: return data[indexes] return None else: start_time = dateAsTuple(start_time, True) end_time = dateAsTuple(end_time, True) ucan = HourlyDataConnection(days_per_request=1) _start_date_, _end_date_, precip =\ ucan.getData(station, 'pcpn', start_time, end_time) precip = N.array(precip) precip[N.where(N.isinf(precip))] = N.nan return precip
def __call__(self, date, stats_matrix, data): start_index = self.cushions[0] num_hours = len(data) end_index = num_hours - self.cushions[1] self.detected = [] if self.isvalid is None: self.isvalid = [True for item in data] # validate against physical extremes missing_ = self._validate_(date, data, start_index, end_index) if not self.hasValidData(): return missing_ # needed for validatation against Period of Record for the month stats = stats_matrix[asDatetime(date).month] mean = stats[3] stddev = stats[5] for severity in self.severities: num_stddevs = self.stddevs[severity] upper_limit = mean + (num_stddevs * stddev) lower_limit = mean - (num_stddevs * stddev) indx = start_index while indx < end_index: if self.isvalid[indx]: value = data[indx] if value > upper_limit: hour = self.hourFromIndex(indx) detail = (severity, 'exts', hour, value, upper_limit, num_stddevs) self._capture(indx, detail) elif value < lower_limit: detail = (severity, 'exts', hour, value, lower_limit, -num_stddevs) self._capture(indx, detail) indx += 1 return missing_
def __init__(self, *data_info): """ Multiple dataset time series. All datasets must be the same frequency and interval. Arguments --------- data_info : information tuples, one for each dataset (name, data, base_time, data_attrs) name : name of dataset data : numpy array containing data base_time : date of first item in array data_attrs : data attributes dictionary as a minimum it should have the following: value_type : The type of data in the time series data set. 'linear' indicates linear data (i.e. data linearly increases or decrease from one value to another to the decimal precision of the software). 'discrete' is similar to 'linear' except thot values may only be whole numbers. 'direction' indicates data consisting spherical compass directions (i.e. values from 0 to 360 valid). The defualt is 'linear'. If a tuple/list is passed, the first item must be the type, followed by the lower value limit, then the upper value limit) missing : value that indicates missing data frequency : frequency of the data (i.e. 'hour','day',etc.) Default is 'hour'. interval : number of time units between entries in the data array. Default is 1. """ #TODO : handle 2D arrays frequency = str(data_info[0][-1].get('frequency', 'hour')) self.frequency = frequency interval = int(data_info[0][-1].get('interval', 1)) self.interval = interval if frequency == 'hour': def _relativeDelta(interval): return relativedelta(hours=interval) elif frequency == 'day': def _relativeDelta(interval): return relativedelta(days=interval) elif frequency == 'month': def _relativeDelta(interval): return relativedelta(months=interval) elif frequency == 'year': def _relativeDelta(interval): return relativedelta(years=interval) else: raise KeyError, 'Unsupported data frequency : %s' % frequency self.relativeDelta = _relativeDelta self.base_times = {} self.value_types = {} self.datasets = {} self.dataset_names = [] self.indexers = {} self.lower_limits = {} self.upper_limits = {} self.missing_values = {} common_start_time = datetime.now() common_end_time = datetime(1000, 1, 1) for name, data, base_time, data_attrs in data_info: self.dataset_names.append(name) self.datasets[name] = data self.base_times[name] = _base_time = asDatetime(base_time) common_start_time = max(common_start_time, _base_time) elapsed_time = (len(data) - 1) * self.interval last_time = _base_time + self.relativeDelta(elapsed_time) common_end_time = min(common_end_time, last_time) value_type = data_attrs.get('value_type', None) if isinstance(value_type, (tuple, list)): self.value_types[name] = value_type[0] self.lower_limits[name] = value_type[1] self.upper_limits[name] = value_type[2] else: self.value_types[name] = value_type self.lower_limits[name] = N.NINF self.upper_limits[name] = N.inf missing = data_attrs.get('missing', None) if missing is None: if data.dtype.kind == 'i': missing = -32768 elif data.dtype.kind == 'f': if len(N.where(N.isinf(data))) > 0: missing = N.inf else: missing = N.nan self.missing_values[name] = missing self.indexers[name] = timeIndexer(frequency, _base_time, interval) self.common_start_time = common_start_time self.common_end_time = common_end_time if self.frequency == 'hour': def _asDatetime(_time): if isinstance(_time, datetime): return _time elif isinstance(_time, (tuple, list)): return datetime(*_time) else: return datetime(_time / 1000000, (_time / 10000) % 100, (_time / 100) % 100, _time % 100) def _indexForTime(_time): delta = asDatetime(_time) - self.base_time hours = (delta.days * 24) + (delta.seconds / 3600) indx = hours / interval over = hours % interval if over > 0: return indx + 1 else: return indx def _relativeDelta(hours): return relativedelta(hours=hours) def _timeAsString(_time): return _time.strftime('%Y-%m-%d:%H') def _timeAtIndex(indx): return self.base_time + relativedelta(hours=indx * interval) elif self.frequency == 'day': def _asDatetime(_time): if isinstance(_time, datetime): return _time if isinstance(_time, (tuple, list)): return datetime(*_time) else: return datetime(_time / 10000, (_time / 100) % 100, _time % 100) def _indexForTime(_time): indx = (asDatetime(_time) - self.base_time).days / interval over = (asDatetime(_time) - self.base_time).days % interval if over > 0: return indx + 1 else: return indx def _relativeDelta(days): return relativedelta(days=days) def _timeAsString(_time): return _time.strftime('%Y-%m-%d') def _timeAtIndex(indx): return self.base_time + relativedelta(days=indx * interval) elif self.frequency == 'month': def _asDatetime(_time): if isinstance(_time, datetime): return _time if isinstance(_time, (tuple, list)): return datetime(*_time) else: return datetime(_time / 100, _time % 100, 1) def _indexForTime(_time): date_time = asDatetime(_time) years = date_time.year - self.base_time.year months = years * 12 if date_time.month != 12: months -= (12 - date_time.month) if self.base_time.month != 1: months -= self.base_time.month - 1 return months def _relativeDelta(months): return relativedelta(months=months) def _timeAsString(_time): return _time.strftime('%Y-%m') def _timeAtIndex(indx): return self.base_time + relativedelta(months=indx * interval) elif self.frequency == 'year': def _asDatetime(_time): if isinstance(_time, datetime): return _time if isinstance(_time, (tuple, list)): return datetime(*_time) else: return datetime(_time / 100, _time % 100, 1) def _indexForTime(_time): return asDatetime(_time).year - self.base_time.year def _relativeDelta(years): return relativedelta(years=years) def _timeAsString(_time): return _time.strftime('%Y') def _timeAtIndex(indx): return self.base_time + relativedelta(years=indx * interval) else: raise KeyError, 'Unsupported data frequency : %s' % self.frequency self.asDatetime = _asDatetime self.indexForTime = _indexForTime self.relativeDelta = _relativeDelta self.timeAsString = _timeAsString self.timeAtIndex = _timeAtIndex self.generator = dateArrayGenerator(self.frequency)
def index(self, date_time): _date_time = asDatetime(date_time) if _date_time == self.base_time: return 0 delta = _date_time - self.base_time if (delta.days % self.interval) == 0: return delta.days / self.interval else: return (delta.days + self.interval) / self.interval
# check to see if dewpt already exists and deal with it gen_dewpt = True if 'dewpt' in manager.listGroups(): if replace_existing: manager.deleteGroup('dewpt') else: gen_dewpt = False if gen_dewpt: (rhum_data,rhum_attrs),(temp_data,temp_attrs) = \ manager.getData(('rhum.value','temp.value'),True) rhum_data = factory.transformData('rhum', rhum_data, False) print rhum_data temp_data = factory.transformData('temp', temp_data, False) print ' ' print temp_data temp_start_hour = asDatetime(temp_attrs['first_hour']) dewpt_start_hour, dewpt_end_hour, dewpt_data = \ generateDewpointArray(rhum_data, asDatetime(rhum_attrs['first_hour']), temp_data, temp_start_hour, 'F') print ' ' print dewpt_data factory.createHourlyDataGroup(manager, 'dewpt', dewpt_data, dewpt_start_hour, dewpt_end_hour, units=temp_attrs['units'], min=N.nanmin(dewpt_data), max=N.nanmax(dewpt_data), missing=-32768) else: dewpt_data, dewpt_attrs = manager.getData('dewpt.value',True)
def __init__(self, base_time, interval): self.base_time = asDatetime(base_time) self.interval = interval
def _formatDate(self, date, include_hour): date_time = asDatetime(date, True) if include_hour: return date_time.strftime('%I %p on %b %d, %Y') return date_time.strftime('%b %d, %Y')
def _indexForTime(_time): indx = (asDatetime(_time) - self.base_time).days / interval over = (asDatetime(_time) - self.base_time).days % interval if over > 0: return indx + 1 else: return indx
def _indexForTime(_time): return asDatetime(_time).year - self.base_time.year
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - metadata = ['sid', 'name', 'active', 'network', 'last_report'] if options.bbox is not None: metadata.append('lat') metadata.append('lon') if options.county is not None: metadata.append('county') if options.state is not None: metadata.append('state') factory = ObsnetDataFactory(options) stations = factory.argsToStationData((), options, tuple(metadata)) stations = sorted(stations, key=lambda station: station['name']) # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - verified_stations = [] print '\n Active Stations\n%s' % separator for station in stations: last_hour = asDatetime(station['last_report'], True) station['last_hour'] = last_hour.strftime('%b %d, %Y at %I %p') delta = base_time - last_hour station['num_days'] = delta.days verified_stations.append(station) stations = sorted(verified_stations, key=lambda station: station['num_days']) for station in stations: print message % station
def __init__(self, name, base_time, data_array, **kwargs): """ Single dataset time series Arguments : name = name for data in time series base_time = datetime object : Date/time corresponding to the first item in `data_array`. data_array = Numpy array of values. If multidemensional, the first dimension must be time. kwargs can be used to voverride the default value for the follwing : value_type = The type of data values in the time series data set. 'linear' indicates linear data (i.e. data linearly increases or decrease from one value to another to the decimal precision of the software). 'discrete' is similar to 'linear' except thot values may only be whole numbers. 'direction' indicates data consisting spherical compass directions (i.e. values from 0 to 360 are valid). The defualt is 'linear' If a tuple/list is passed, the first item must be the type, followed by the lower value limit, then the upper value limit) frequency = Frequency of (time units between) items in `data_array`. Valid values are "hour", "day", "month", "year". Default is 'hour'. interval = Number of time units per array node. Default is 1 (e.g. increment=2 and frequency='hour' means there are 2 hours between each array index) missing_value = Value used for missing items in `data_array`. Defualt is -32768 for integer arrays and N.nan for float arrays. """ #TODO : handle 2D arrays self.base_time = asDatetime(base_time) self.data_name = name self.data = data_array self.data_interval = interval = int(kwargs.get('interval', 1)) self.data_type = pythonDataType(data_array.dtype) self.description = kwargs.get('description', '?') self.frequency = str(kwargs.get('frequency', 'hour')) self.units = kwargs.get('units', 'unknown') value_type = kwargs.get('value_type', None) if value_type is not None: self.value_type = value_type[0] self.lower_limit = float(value_type[1]) self.upper_limit = float(value_type[2]) else: self.value_type = 'linear' self.lower_limit = N.NINF self.upper_limit = N.inf self.missing_value = kwargs.get('missing_value', kwargs.get('missing', defaultMissingValue(data_array.dtype))) if self.missing_value is None: errmsg = 'No default missing value for dtype :' return ValueError, errmsg % dtype.__class__.__name__ if self.frequency == 'hour': def _asDatetime(_time): if isinstance(_time, datetime): return _time elif isinstance(_time, (tuple,list)): return datetime(*_time) else: return datetime( _time/1000000, (_time/10000) % 100, (_time/100) % 100, _time % 100 ) def _indexForTime(_time): delta = asDatetime(_time) - self.base_time hours = (delta.days * 24) + (delta.seconds / 3600) indx = hours / interval over = hours % interval if over > 0: return indx + 1 else: return indx def _relativeDelta(hours): return relativedelta(hours=hours) def _timeAsString(_time): return _time.strftime('%Y-%m-%d:%H') def _timeAtIndex(indx): return self.base_time + relativedelta(hours=indx*interval) elif self.frequency == 'day': def _asDatetime(_time): if isinstance(_time, datetime): return _time if isinstance(_time, (tuple,list)): return datetime(*_time) else: return datetime( _time/10000, (_time/100) % 100, _time % 100 ) def _indexForTime(_time): indx = (asDatetime(_time) - self.base_time).days / interval over = (asDatetime(_time) - self.base_time).days % interval if over > 0: return indx + 1 else: return indx def _relativeDelta(days): return relativedelta(days=days) def _timeAsString(_time): return _time.strftime('%Y-%m-%d') def _timeAtIndex(indx): return self.base_time + relativedelta(days=indx*interval) elif self.frequency == 'month': def _asDatetime(_time): if isinstance(_time, datetime): return _time if isinstance(_time, (tuple,list)): return datetime(*_time) else: return datetime( _time/100, _time % 100, 1 ) def _indexForTime(_time): date_time = asDatetime(_time) years = date_time.year - self.base_time.year months = years * 12 if date_time.month != 12: months -= (12 - date_time.month) if self.base_time.month != 1: months -= self.base_time.month - 1 return months def _relativeDelta(months): return relativedelta(months=months) def _timeAsString(_time): return _time.strftime('%Y-%m') def _timeAtIndex(indx): return self.base_time + relativedelta(months=indx*interval) elif self.frequency == 'year': def _asDatetime(_time): if isinstance(_time, datetime): return _time if isinstance(_time, (tuple,list)): return datetime(*_time) else: return datetime( _time/100, _time % 100, 1 ) def _indexForTime(_time): return asDatetime(_time).year - self.base_time.year def _relativeDelta(years): return relativedelta(years=years) def _timeAsString(_time): return _time.strftime('%Y') def _timeAtIndex(indx): return self.base_time + relativedelta(years=indx*interval) else: raise KeyError, 'Unsupported data frequency : %s' % self.frequency self.asDatetime = _asDatetime self.indexForTime = _indexForTime self.relativeDelta = _relativeDelta self.timeAsString = _timeAsString self.timeAtIndex = _timeAtIndex elapsed_time = (len(data_array) - 1) * self.data_interval self.last_time = self.base_time + self.relativeDelta(elapsed_time) self.indexer = timeIndexer(self.frequency, self.base_time, self.data_interval) self.generator = dateArrayGenerator(self.frequency)
def getTimeSpan(self, date): _time = list(dateAsTuple(date)[:3]) _time.append(self.first_hour_in_day) start_time = asDatetime(_time) end_time = start_time + ONE_DAY return start_time, end_time
def setTimeSpan(self, iter_start, iter_end): self.iter_start = asDatetime(iter_start) self.iter_end = asDatetime(iter_end)