def validateForecastDates(dates, last_obs, end_date): if 'fcast_start' in dates: fcast_start = asDatetimeDate(dates['fcast_start']) if fcast_start > last_obs: fcast_end = asDatetimeDate(dates['fcast_end']) if fcast_start < end_date: if fcast_end > end_date: dates['fcast_end'] = dates['season_end'] elif fcast_start == end_date: dates['fcast_end'] = dates['fcast_start'] else: del dates['fcast_start'] del dates['fcast_end'] else: del dates['fcast_start'] del dates['fcast_end'] elif 'fcast_start_date' in dates: fcast_start = asDatetimeDate(dates['fcast_start_date']) if fcast_start > last_obs: fcast_dates['fcast_start'] = dates['fcast_start_date'] if fcast_start < end_date: fcast_end = asDatetimeDate(dates['fcast_end_date']) if fcast_end > end_date: dates['fcast_end'] = dates['season_end'] elif fcast_start == end_date: dates['fcast_end'] = dates['fcast_start_date'] else: dates['fcast_end'] = dates['fcast_end_date'] del dates['fcast_start_date'] del dates['fcast_end_date'] return dates
def _loadDataGridAttributes_(self): if hasattr(self, 'start_date') \ and isinstance(self.start_date, basestring): self.start_date = asDatetimeDate(self.start_date) if hasattr(self, 'end_date') \ and isinstance(self.end_date, basestring): self.end_date = asDatetimeDate(self.end_date)
def accumulateGdd(self, model_name, lo_gdd_th, hi_gdd_th, start_date, accumulated_chill, daily_gdd): # need GDD accumulation and chill mask from previous day prev_day = start_date - ONE_DAY # start with chill mask from the previous day ... a mask is necessary # so that GDD accumulation will continue even after chill hours begin # to decline in later months of the season prev_mask =\ self.getChillMask(model_name, lo_gdd_th, hi_gdd_th, prev_day) # allow accumulation wherever chill is above # minimum chill hour threshold for variety above_min_chill = N.where(accumulated_chill >= self.min_chill_units) # chill accumulation is below min chill hour threshold at all nodes if len(above_min_chill[0]) == 0: return N.zeros_like(daily_gdd), N.zeros(daily_gdd.shape, dtype=bool) # chill accumulation is cumulative, so we need accumulated GDD for # the previous date if asDatetimeDate(start_date) > asDatetimeDate(self.start_date): prev_gdd = self.getGdd(model_name, lo_gdd_th, hi_gdd_th, prev_day) prev_gdd = prev_gdd.astype(daily_gdd.dtype) else: prev_gdd = N.zeros_like(prev_mask.shape, dtype=daily_gdd.dtype) # accumulate GDD for this variety/model combination accumulated_gdd = N.zeros_like(daily_gdd) if daily_gdd.ndim == 2: # adjust previous day's mask to include any additional nodes where # minimum chill units have been reached on the current date prev_mask[above_min_chill] = True indexes = N.where(prev_mask == True) # update accumulated GDD array with valid node from daily_gdd accumulated_gdd[indexes] = daily_gdd[indexes] # add previous accumulation accumulated_gdd += prev_gdd return accumulated_gdd, prev_mask elif daily_gdd.ndim == 3: # create a 3D mask from the previous day's mask chill_mask = N.array( [prev_mask for i in range(daily_gdd.shape[0])], dtype=int) # adjust mask to include any additional dates/nodes where # minimum chill units have been reached chill_mask[above_min_chill] = True indexes = N.where(chill_mask == True) # insert input daily GDD only where new mask applies accumulated_gdd[indexes] = daily_gdd[indexes] # add the previous day's GDD accumlation to the first # day in the new accumulation accumulated_gdd[0] = prev_gdd + daily_gdd[0] # calculated the cumulative total GDD accumulated accumulated_gdd = N.cumsum(accumulated_gdd, axis=0) return accumulated_gdd, chill_mask
def validateSeasonDates(dates): season_end = dates['season_end'] end_date = asDatetimeDate(season_end) last_obs = asDatetimeDate(dates['last_obs']) if last_obs > end_date: dates['last_obs'] = season_end last_obs = end_date dates = validateForecastDates(dates, last_obs, end_date) last_valid = asDatetimeDate(dates['last_valid']) if last_valid > end_date: dates['last_valid'] = season_end return dates
def __call__(self, request): start_response = datetime.datetime.now() # decode request variables into a dictionary request_dict = self.requestAsDict(request) print '\n\nGrapeHardinessTempextHandler.__call__' # extract location coordinates location = self.extractLocationParameters(request_dict) lat, lon = location['coords'] print ' location :\n', location target_year = request_dict.get('season', None) print '\n target_year :', target_year # get the configured season limits dates = self.extractSeasonDates(request_dict) print ' dates :\n', dates season_start = asDatetimeDate(dates['season_start']) season_end = asDatetimeDate(dates['season_end']) target_year = dates['season'] del dates['season'] # initialize response string with season dates response = \ '{"tempexts":{%s,"data":{' % self.tightJsonString(dates)[1:-1] reader = \ self.tempextFileReader(target_year, self.source, self.region) if self.mode in ('dev', 'test'): print 'tempexts file :', reader.filepath # add recent averages data = \ reader.getSliceAtNode('mint', season_start, season_end, lon, lat) response = \ '%s"mint":%s' % (response, self.serializeData(data, '%.1f')) # add climate normal averages data = \ reader.getSliceAtNode('maxt', season_start, season_end, lon, lat) response = \ '%s,"maxt":%s' % (response, self.serializeData(data, '%.1f')) reader.close() del data if self.mode in ('dev', 'test'): print 'tempexts data retrieved in', elapsedTime( start_response, True) print '\n\nTEMPEXTS RESPONSE\n', response, '\n\n' self.respondWithJSON(request, '%s}}}' % response)
def compareDates(self, date1, op, date2): if isinstance(date1, datetime.datetime): if isinstance(date2, datetime.datetime): return self._compareDates(date1, op, date2) else: return self._compareDates(date1, op, asDatetime(date2)) elif isinstance(date1, datetime.date): if isinstance(date2, datetime.date): return self._compareDates(date1, op, date2) else: return self._compareDates(date1, op, asDatetimeDate(date2)) elif isinstance(date1, (tuple, basestring)): return self._compareDates(asDatetimeDate(date1), op, date2) else: errmsg = 'Invalid type for argument "date1" : %s' raise TypeError, errmsg % str(type(date1))
def __call__(self, request): # decode request variables into a dictionary request_dict = self.requestAsDict(request) # get the configured season limits dates = self.extractSeasonDates(request_dict) season_start = asDatetimeDate(dates['season_start']) season_end = asDatetimeDate(dates['season_end']) # create an array of days for X axis of data plots response_json = \ '{"days":%s}' % self.serializeDates(season_start, season_end) # send the respnse self.respond(request, response_json)
def __call__(self, request): print '\n\nGrapeHardinessSeasonDaysHandler.__call__' # decode request variables into a dictionary request_dict = self.requestAsDict(request) # extract season date limits from request dates = self.extractSeasonDates(request_dict) print ' dates :\n', dates season_start = asDatetimeDate(dates['season_start']) season_end = asDatetimeDate(dates['season_end']) # create an array of days for X axis of data plots response_json = \ '{"days":%s}' % self.serializeDates(season_start, season_end) # send the respnse self.respondWithJSON(request, response_json)
def estimateChill(self, model_name, **kwargs): """ estimate daily chill units and cumulative chill accumulation """ debug = kwargs.get('debug', False) # look through possible date conbinations date_arg = kwargs.get('date', kwargs.get('dates', None)) # not a single date or list of dates, look for start/end date if date_arg is None: start_date = kwargs.get('start_date', None) if start_date is None: raise KeyError, CHILL_DATE_ERR end_date = kwargs.get('end_date', None) if end_date is None: raise KeyError, CHILL_DATE_ERR # convert start/ end date into the list of dates that Linvill needs num_days = (end_date - start_date).days + 1 date_arg = [ start_date + relativedelta(days=days) for days in range(num_days) ] # may pass hourly temps when they are known hourly_temps = kwargs.get('hourly',None) if hourly_temps is None: # hourly temps were not passed ... need to iterpolate from mint/maxt mint = kwargs.get('mint', None) if mint is None: raise KeyError, CHILL_DATA_ERR maxt = kwargs.get('maxt', None) if maxt is None: raise KeyError, CHILL_DATA_ERR # get temperature units, default to Fahrenheit units = kwargs.get('units','F') # interpolate hourly temps from mint/maxt wit Linvill algorithm hourly_temps = self.linvill(date_arg, mint, maxt, units, debug) # set previous acummulation to zero - need 3D array even for 1 day previous = N.zeros((1,) + self.lats.shape, dtype=float) # attempt to override with actual previous day's accumulation if isinstance(date_arg, datetime): date = date_arg else: date = date_arg[0] if self.start_date is not None \ and asDatetimeDate(date) > self.start_date: previous[0] = self.getChill(model_name, 'accumulated', start_date=date-ONE_DAY) # create an instance of the chill accumulator class chill = self.chillCalculator(model_name, previous, None) # calculate daily chill units daily = chill.calcDailyChillUnits( chill.calcHourlyChillUnits(hourly_temps, debug) , debug) # calculate daily accumulations accumulated = chill.accumulate(daily) if daily.shape[0] == 1: return daily[0], accumulated[0] else: return daily, accumulated
def __call__(self, request): reader, location, dates, response = \ self.initializeResponse(request, 'risk') lat = location['lat'] lon = location['lon'] start_date = asDatetimeDate(dates['season_start']) last_valid = asDatetimeDate(dates['last_valid']) # get the min temp data slice at the requested location data_slice = \ reader.dataAtNode('mint', lon, lat, start_date, last_valid) reader.close() # temporarily free up the file if self.verbose: print '\nmint array size =', len(data_slice) print data_slice # initialize response data with min temp slice data = [ '"mint":%s' % self.serializeData(data_slice, '%d'), ] # get the data slice at the location for each kill temp dataset for dataset in ("T10", "T50", "T90"): reader.open() data_slice = \ reader.dataAtNode(dataset, lon, lat, start_date, last_valid) reader.close() if self.verbose: print '\n', dataset, 'array size =', len(data_slice) print data_slice # add the kill data template = '"%s":%%s' % dataset data.append(template % self.serializeData(data_slice, '%d')) reader.close() del reader # insert the actual data into the "data_arrays" placeholder response = response.replace('"data_arrays"', "{%s}" % ','.join(data)) if self.debug: print '\nAppleFrostRiskDataHandler response' print response # send the response self.respondWithJSON(request, response)
def _generateEmptyDateProvenance(self, provenance, attrs): records = [] record_tail = provenance.empty[1:] date = asDatetimeDate(attrs.get('start_date', self.start_date)) while date <= self.end_date: record = (asAcisQueryDate(date), ) + record_tail records.append(record) date += ONE_DAY return records
def dateAttributes(self, object_path, as_date_obj=False): attrs = self.objectAttributes(object_path) date_attrs = {} if as_date_obj: for key, value in attrs.items(): if key.endswith('date'): date_attrs[key] = asDatetimeDate(value) else: for key, value in attrs.items(): if key.endswith('date'): date_attrs[key] = value return date_attrs
def __call__(self, request): # decode request variables into a dictionary request_dict = self.requestAsDict(request) # get the configured season limits dates = self.extractSeasonDates(request_dict) if self.verbose: print 'season dates array size', len(dates) print dates response = '{"season":{"season_start":"%s","season_end":"%s"' response = response % (dates['season_start'], dates['season_end']) # create an array of days for X axis of data plots days = self.serializeDates(asDatetimeDate(dates['season_start']), asDatetimeDate(dates['season_end'])) response = '%s,"dates":%s}}' % (response, days) if self.debug: print '\nAppleFrostSeasonDatesHandler response' print response # send the respnse self.respondWithJSON(request, response)
def _datesToIndexes(self, dataset_path, start_time_obj, end_time_obj): attrs = self.getDatasetAttributes(dataset_path) start_date = attrs.get('start_date', None) if start_date is not None: if isinstance(start_date, basestring): start_date = asDatetimeDate(start_date) end_date = asDatetimeDate(attrs['end_date']) else: start_date = self._dateFromSequence(start_date) end_date = self._dateFromSequence(attrs['end_date']) else: start_day = attrs.get('start_day', None) if start_day is not None: start_date = self._dateFromSequence(start_day) end_date = self._dateFromSequence(attrs['end_day']) else: errmsg = '"%s" dataset is not indexable by date.' raise IndexError, errmsg % dataset_path if isinstance(start_time_obj, datetime.datetime): sdate = start_time_obj.date() edate = end_time_obj.date() elif isinstance(start_time_obj, datetime.date): sdate = start_time_obj edate = end_time_obj elif isinstance(start_time_obj, (tuple, list)): sdate = self._dateFromSequence(start_time_obj) edate = self._dateFromSequence(end_time_obj) elif isinstance(start_time_obj, basestring): sdate = asDatetimeDate(start_time_obj) edate = asDatetimeDate(end_time_obj) else: errmsg = 'Invalid data type for time object arguments : %s' raise TypeError, errmsg % str(type(start_time_obj)) if sdate >= start_date and edate <= end_date: return ((sdate - start_date).days, (edate - start_date).days + 1) else: errmsg = 'Invalid value in time object arguments : %s, %s' raise ValueError, errmsg % (str(start_time_obj), str(end_time_obj))
def _dateToIndex(self, dataset_path, time_obj): if isinstance(time_obj, datetime.datetime): date = datetime.date(*time_obj.timetuple()[:3]) elif isinstance(time_obj, datetime.date): date = time_obj elif isinstance(time_obj, (tuple, list)): date = self._dateFromSequence(time_obj) else: errmsg = 'Invalid data type for "time_obj" argument : %s' raise TypeError, errmsg % str(type(time_obj)) attrs = self.getDatasetAttributes(dataset_path) start_date = attrs.get('start_date', None) if start_date is not None: if isinstance(start_date, basestring): start_date = asDatetimeDate(start_date) end_date = asDatetimeDate(attrs['end_date']) else: start_date = self._dateFromSequence(start_date) end_date = self._dateFromSequence(attrs['end_date']) else: start_day = attrs.get('start_day', None) if start_day is not None: start_date = self._dateFromSequence(start_day) end_date = self._dateFromSequence(attrs['end_day']) else: errmsg = '"%s" dataset is not indexable by date.' raise IndexError, errmsg % dataset_path if date >= start_date and date <= end_date: return (date - start_date).days else: errmsg = '"time_obj" translates to date outside valid range' errmsg += ' (%s to %s) for dataset "%s"' errmsg = errmsg % (str(start_date), str(end_date), dataset_path) raise TypeError, errmsg
def getLastValidDate(self, dataset_path, start_date, data, **kwargs): # always honor a user-specified last valid date last_valid_date = kwargs.get('last_valid_date', None) # last valid date not specified by user, figure it out from the data if last_valid_date is None: if data.ndim == 2: # 2D rray is a single day # an array filled with N.nan is not valid missing, where = \ self._whereMissing(data, dataset=dataset_path) if len(where[0]) == data.size: num_valid_days = 0 else: num_valid_days = 1 else: # 3D array # for now, the code assumes a zyx or zxy data view num_nodes = data[0].size num_valid_days = num_days = data.shape[0] # starting from the last day in the array # find first day with at least one node with a valid value day = num_days - 1 missing, where = \ self._whereMissing(data[day], dataset=dataset_path) while day > 0 and len(where[0]) == num_nodes: # day has no valid values, decrement day counters day -= 1 num_valid_days -= 1 missing, where = \ self._whereMissing(data[day], missing=missing) if num_valid_days == 0: # last valid date will not be changed because there are # no valid values in the data prev_date_str = self.getDatasetAttribute( dataset_path, 'last_valid_date', None) if prev_date_str is not None: return asDatetimeDate(prev_date_str) else: return None # last valid date will be start_date plus number of valid days elif num_valid_days == 1: last_valid_date = start_date else: # num_valid_days > 1 last_valid_date = \ start_date + relativedelta(days=num_valid_days-1) return last_valid_date
arg_0 = args[0] if arg_0.isdigit(): target_year = int(args[0]) region = factory.regionConfig(options.region) source = factory.sourceConfig(options.source) filepath = factory.tempextsFilepath(target_year, source, region) else: filepath = os.path.abspath(arg_0) print 'testing in file :', filepath from_dates = input("Enter dates to copy : ") if debug: print 'from_dates =', from_dates if ',' in from_dates: start_date, end_date = from_dates.split(',') start_date = asDatetimeDate(start_date) end_date = asDatetimeDate(end_date) else: start_date = end_date = asDatetimeDate(from_dates) print 'Copying data from', start_date, 'to', end_date manager = TemperatureFileManager(filepath, factory.registry, mode='r') mint = manager.dateSlice('temps.mint', start_date, end_date) maxt = manager.dateSlice('temps.maxt', start_date, end_date) if forecast: source = 'NDFD' else: source = manager.fileAttribute('source') manager.close() to_date = asDatetimeDate(input("Enter date to copy data to : ")) if debug: print 'to_date :', to_date print 'Inserting data at', to_date
def _loadDateGridAttributes_(self): start_date = self.fileAttribute('start_date', None) if start_date is not None: self.start_date = asDatetimeDate(start_date) end_date = self.fileAttribute('end_date', None) if end_date is not None: self.end_date = asDatetimeDate(end_date)
def getAttributeAsDate(self, path, attribute_name): """ Access a date attribute and return it as a datetime.date """ date_str = self.getObjectAttribute(path, attribute_name, None) if date_str is not None: return asDatetimeDate(date_str) return None
last_obs_date = manager.datasetAttribute('temps.maxt', 'last_obs_date') last_valid_date = manager.datasetAttribute('temps.maxt', 'last_valid_date') if end_date is not None: # refresh start date cannot be earlier than first day in datasets # this is only relevant at the beginning of a new year data_limit = manager.dateAttribute('temps.maxt', 'start_date') start_date = max(start_date, data_limit) # refresh end date cannot be later the last day in the datasets # this is only relevant at the end of the year data_limit = manager.dateAttribute('temps.maxt', 'end_date') if end_date > data_limit: end_date = data_limit else: # refresh end date cannot be later than the last observation # otherwise, you risk stomping on the forecast end_date = min(end_date, asDatetimeDate(last_obs_date)) # recalculate actual number of days to be refreshed num_days = (end_date - start_date).days + 1 msg = ' refreshing data for %d days : %s thru %s' print msg % (num_days, str(start_date), str(end_date)) else: if start_date < datetime.date(target_date.year, 1, 1): errmsg = "%s is an invalid date for %d" raise ValueError, errmsg % (str(start_date), target_date.year) print ' refreshing data for', str(start_date) manager.close() # filter annoying numpy warnings
def preInitDates(self, start_date, end_date): self.start_date = asDatetimeDate(start_date) self.end_date = asDatetimeDate(end_date)
def dateAttribute(self, object_path, attribute_name, default=None): date = self.getObjectAttribute(object_path, attribute_name, default) if date != default: return asDatetimeDate(date) return default
def getDateAttribute(self, object_path, attribute_name, default=None): date = self.getObjectAttribute(object_path, attribute_name, default) if date is not None: return asDatetimeDate(date) return None
def __call__(self, request): start_response = datetime.datetime.now() # decode request variables into a dictionary request_dict = self.requestAsDict(request) # extract location coordinates location = request_dict['location'] coords = location.get('coords', None) if coords is not None: lat = float(coords[0]) lon = float(coords[1]) else: lat = float(location['lat']) lon = float(location['lon']) # GDD threshold and target_year gdd_threshold = str(request_dict['gdd_threshold']) target_year = request_dict.get('season', None) #if target_year is None: target_year = datetime.date.today().year if target_year is None: target_year = self.maxAvailableYear() # get the configured season limits dates = self.extractSeasonDates(request_dict, target_year) # initialize the response response_json = \ '{"season":{"gdd_threshold":"%s"' % gdd_threshold response_json = \ '%s,"location":%s' % (response_json,self.tightJsonString(location)) # create a POR file reader reader = \ self.getTargetYearFileReader(target_year, self.source, self.region) if self.mode in ('dev', 'test'): print 'season data file :', reader.filepath # create path to GDD dataset dataset_path = reader.gddDatasetPath(gdd_threshold) # capture the significant dates for the dataset if 'dates' in self.mode_config \ and target_year == self.mode_config.season: dates.update(self.mode_config.dates.attrs) else: dates.update(reader.getSignificantDates(dataset_path)) season_end = dates['season_end'] end_date = asDatetimeDate(season_end) start_date = asDatetimeDate(dates['season_start']) if 'fcast_start' in dates: fcast_start = asDatetimeDate(dates['fcast_start']) if fcast_start > end_date: del dates['fcast_start'] if 'fcast_end' in dates: fcast_end = asDatetimeDate(dates['fcast_end']) if fcast_end > end_date: if 'fcast_start' in dates: dates['fcast_end'] = season_end else: del dates['fcast_end'] last_obs = asDatetimeDate(dates['last_obs']) if last_obs > end_date: dates['last_obs'] = season_end last_valid = asDatetimeDate(dates['last_valid']) if last_valid > end_date: dates['last_valid'] = season_end last_valid = asDatetimeDate(season_end) # temporarily free up the POR file reader.close() # add season dates to response response_json = \ '%s,"dates":%s' % (response_json, self.tightJsonString(dates)) del dates # get the accumulated GDD for Y axis of data plots reader.open() response_json = '%s,"data":{"season":%s}}}' % ( response_json, self.serializeData( reader.getDataAtNode(dataset_path, lon, lat, start_date, last_valid))) reader.close() if self.mode in ('dev', 'test'): print 'season data retrieved in ', elapsedTime( start_response, True) # send the response self.respond(request, response_json)
def __call__(self, request): print '\n\GrapeHardinessTempDataHandler.__call__' start_response = datetime.datetime.now() # decode request variables into a dictionary request_dict = self.requestAsDict(request) varieties = self.extractVarietyParameters(request_dict) variety = varieties['variety'] # extract location coordinates location = self.extractLocationParameters(request_dict) if 'coords' in location: lat, lon = location['coords'] else: lat = location['lat'] lon = location['lon'] # extract season date limits from request dates = self.extractSeasonDates(request_dict) target_year = dates['season'] print ' target_year :', target_year print ' dates :\n', dates # create a variety file reader reader = self.varietyFileReader(variety, target_year, self.source, self.region, 'season') if self.mode in ('dev', 'test'): print 'hardtemp data file :', reader.filepath # path to the hardiness temp dataset dataset_path = 'hardtemp' # capture the significant dates for the dataset if 'dates' in self.mode_config \ and target_year == self.mode_config.season: dates.update(self.mode_config.dates.attrs) else: dates.update(reader.significantDates(dataset_path)) # temporarily free up the file reader.close() season_end = dates['season_end'] end_date = asDatetimeDate(season_end) start_date = asDatetimeDate(dates['season_start']) if 'fcast_start' in dates: fcast_start = asDatetimeDate(dates['fcast_start']) if fcast_start > end_date: del dates['fcast_start'] if 'fcast_end' in dates: fcast_end = asDatetimeDate(dates['fcast_end']) if fcast_end > end_date: if 'fcast_start' in dates: dates['fcast_end'] = season_end else: del dates['fcast_end'] last_obs = asDatetimeDate(dates['last_obs']) if last_obs > end_date: dates['last_obs'] = season_end last_valid = asDatetimeDate(dates['last_valid']) if last_valid > end_date: dates['last_valid'] = season_end last_valid = asDatetimeDate(season_end) #dates = self.tightJsonString(dates) # get the accumulated GDD for Y axis of data plots reader.open() data = \ reader.dataAtNode(dataset_path, lon, lat, start_date, last_valid) reader.close() if self.mode in ('dev', 'test'): print 'hardtemp data retrieved in ', elapsedTime( start_response, True) # initialize the response response_dict = { "hardtemp": { "variety": variety, "location": location, "dates": dates, "data": "data_array" } } response = self.tightJsonString(response_dict).replace('\\"', '"') response = \ response.replace('"data_array"', self.serializeData(data, '%.1f')) # send the response self.respondWithJSON(request, response)
del date_attrs['start_date'] del date_attrs['end_date'] fcast_start = temps.dateAttribute(maxt_path, 'fcast_start_date', None) fcast_end = temps.dateAttribute(maxt_path, 'fcast_end_date', None) temps.close() if fcast_start is None: print 'No forecast available.' exit() if fcast_end < datetime.date.today(): print 'No forecast available beyond', datetime.date.today() exit() if fcast_end > season_end_date: fcast_end = season_end_date last_valid = asDatetimeDate(fcast_end) date_attrs['last_valid_date'] = last_valid.strftime('%Y-%m-%d') print '\n\n', fcast_start, fcast_end, last_valid temps_last_obs = asDatetimeDate(date_attrs['last_obs_date']) if debug: print 'temps last obs, last valid', temps_last_obs, last_valid print 'facast_start, fcast_end', fcast_start, fcast_end print 'num days to retrieve', (fcast_end - fcast_start).days + 1 #last_valid = max(last_valid, fcast_end) #if debug: print 'usable last valid', last_valid build_dirpath = os.path.join(dirpaths.build, region_dirpath, source_dirpath) variety_template = CONFIG.filenames.build
# build the groups and their datasets for group_name in groups_in_file: if verbose: print ' building group : %s' % group_name builder.buildGroup(group_name, True) # create a source file reader reader = factory.getSourceFileReader(source, target_year, region, 'temps') # create lat,lon grids in POR file if verbose: print ' creating lat/lon datasets' builder.initLonLatData(reader.lons, reader.lats) # don't get data past last valid date in current year if target_year == current_year: lvd = reader.getDatasetAttribute('temps.mint', 'last_valid_date') end_date = asDatetimeDate(lvd) # get minimum and maximum temperatures mint = reader.getTimeSlice('temps.mint', start_date, end_date) maxt = reader.getTimeSlice('temps.maxt', start_date, end_date) reader.close() del reader # build the GDD datasets for the first sequence of dates for threshold, th_string in gdd_thresholds: manager.open('a') manager.updateThresholdGroup(threshold, start_date, mint, maxt, source.tag, **kwargs) manager.close() #report performance
def __call__(self, request): start_response = datetime.datetime.now() # decode request variables into a dictionary request_dict = self.requestAsDict(request) # extract location coordinates location = request_dict['location'] coords = location.get('coords', None) if coords is not None: lat = float(coords[0]) lon = float(coords[1]) else: lat = float(location['lat']) lon = float(location['lon']) # GDD threshold and target_year gdd_threshold = request_dict['gdd_threshold'] target_year = request_dict.get('season', None) # get the configured season limits dates = self.extractSeasonDates(request_dict, target_year) season_start = asDatetimeDate(dates['season_start']) season_end = asDatetimeDate(dates['season_end']) target_year = dates['season'] del dates['season'] # initialize response string with season dates response = \ '{"history":{%s,"data":{' % self.tightJsonString(dates)[1:-1] reader = self.getHistoryFileReader(target_year, self.source, self.region, gdd_threshold) if self.mode in ('dev', 'test'): print 'history file :', reader.filepath # add recent averages data = \ reader.getSliceAtNode('recent', season_start, season_end, lon, lat) response = '%s"recent":%s' % (response, self.serializeData(data)) # add climate normal averages data = \ reader.getSliceAtNode('normal', season_start, season_end, lon, lat) response = '%s,"normal":%s' % (response, self.serializeData(data)) # add period of record averages data = \ reader.getSliceAtNode('por.avg', season_start, season_end, lon, lat) response = '%s,"poravg":%s' % (response, self.serializeData(data, 4)) # add period of record - percent diffrence max GDD to average GDD data = \ reader.getSliceAtNode('por.max', season_start, season_end, lon, lat) response = '%s,"pormax":%s' % (response, self.serializeData(data, 4)) # add period of record - percent diffrence min GDD to average GDD data = \ reader.getSliceAtNode('por.min', season_start, season_end, lon, lat) response = '%s,"pormin":%s' % (response, self.serializeData(data, 4)) reader.close() del data if self.mode in ('dev', 'test'): print 'history data retrieved in', elapsedTime( start_response, True) self.respond(request, '%s}}}' % response)
num_args = len(args) # determine target year from number of arguments if num_args in (0, 2, 4): target_year = UPDATE_START_TIME.year elif num_args in (1, 3, 5): target_year = int(args[0]) else: raise SyntaxError, INPUT_ERROR # get a file manager for the target year reader = factory.getSourceFileManager(source_key, target_year, region, 'temps') print 'source filepath', reader.filepath # need last valid date for last_valid_date = \ asDatetimeDate(reader.getDatasetAttribute('temps.mint','last_valid_date')) # reprocess all days in the current year if num_args == 0: start_date = datetime.date(target_year, 1, 1) end_date = datetime.date(target_year, 12, 31) # reprocess a single day in the current year elif num_args == 2: end_date = start_date = \ datetime.date(target_year, int(args[0]), int(args[1])) # reprocess single day in a specifc year elif num_args == 3: end_date = start_date = \ datetime.date(target_year, int(args[1]), int(args[2])) # reprocess range of dates in the current year elif num_args == 4:
def acisDateString(self, date): return asDatetimeDate(date).strftime('%Y-%m-%d')