Python pywws.DataStore类代码示例

def get_pywws_data(dir_data):
    ydat = {'temp_out_max_hi':float('-inf'),'temp_out_min_lo':float('inf'),
        'hum_out_max':float('-inf'),'hum_out_min':float('inf'),'rel_pressure_max':float('-inf'),
        'rel_pressure_min':float('inf'),'wind_gust':float('-inf'),'rain':0.0,
        'temp_in_max_hi':float('-inf'),'temp_in_min_lo':float('inf'),'hum_in_max':float('-inf'),
        'hum_in_min':float('inf')}

    ahora = datetime.utcnow()
    try:
        dat = DataStore.calib_store(dir_data)
        adat = dat[dat.nearest(ahora)]
        gdat = dat[dat.nearest(ahora)-timedelta(hours=24):]
        dat = DataStore.hourly_store(dir_data)
        hdat = dat[dat.nearest(ahora)-timedelta(hours=24):]
        dat = DataStore.daily_store(dir_data)
        ddat = dat[dat.nearest(ahora)]
        dat = DataStore.monthly_store(dir_data)
        mdat = dat[dat.nearest(ahora)]
        f1=datetime(ahora.year,1,1,0,0,0)#primer momento del año
        for d in dat[dat.after(f1):]:
            for k in ydat.keys():
                if 'min' in k:
                    ydat[k] = min(ydat[k],d[k])
                elif 'rain' in k:
                    ydat[k] = ydat[k]+d[k]
                else:
                    ydat[k] = max(ydat[k],d[k])
    except:
        return None
    return {'a':adat,'g':gdat,'h':hdat,'d':ddat,'m':mdat,'y':ydat}

def CheckFixedBlock(ws, params, status, logger):
    fixed_block = ws.get_fixed_block(unbuffered=True)
    # check clocks
    try:
        s_time = DataStore.safestrptime(
            fixed_block['date_time'], '%Y-%m-%d %H:%M')
    except Exception:
        s_time = None
    if s_time:
        c_time = datetime.now().replace(second=0, microsecond=0)
        diff = abs(s_time - c_time)
        if diff > timedelta(minutes=2):
            logger.warning(
                "Computer and weather station clocks disagree by %s (H:M:S).", str(diff))
    # store weather station type
    params.set('config', 'ws type', ws.ws_type)
    # store info from fixed block
    pressure_offset = fixed_block['rel_pressure'] - fixed_block['abs_pressure']
    old_offset = eval(status.get('fixed', 'pressure offset', 'None'))
    if old_offset and abs(old_offset - pressure_offset) > 0.01:
        # re-read fixed block, as can get incorrect values
        logger.warning('Re-read fixed block')
        fixed_block = ws.get_fixed_block(unbuffered=True)
        if not fixed_block:
            return None
        pressure_offset = fixed_block['rel_pressure'] - fixed_block['abs_pressure']
    if old_offset and abs(old_offset - pressure_offset) > 0.01:
        logger.warning(
            'Pressure offset change: %g -> %g', old_offset, pressure_offset)
    params.unset('fixed', 'pressure offset')
    params.unset('fixed', 'fixed block')
    status.set('fixed', 'pressure offset', '%g' % (pressure_offset))
    status.set('fixed', 'fixed block', str(fixed_block))
    return fixed_block

def LiveLog(data_dir):
    logger = logging.getLogger('pywws.LiveLog')
    params = DataStore.params(data_dir)
    status = DataStore.status(data_dir)
    # localise application
    Localisation.SetApplicationLanguage(params)
    # open data file stores
    raw_data = DataStore.data_store(data_dir)
    calib_data = DataStore.calib_store(data_dir)
    hourly_data = DataStore.hourly_store(data_dir)
    daily_data = DataStore.daily_store(data_dir)
    monthly_data = DataStore.monthly_store(data_dir)
    # create a DataLogger object
    datalogger = DataLogger(params, status, raw_data)
    # create a RegularTasks object
    asynch = eval(params.get('config', 'asynchronous', 'False'))
    tasks = Tasks.RegularTasks(params, status, raw_data, calib_data,
                               hourly_data, daily_data, monthly_data,
                               asynch=asynch)
    # get live data
    try:
        for data, logged in datalogger.live_data(
                                    logged_only=(not tasks.has_live_tasks())):
            if logged:
                # process new data
                Process.Process(params, raw_data, calib_data,
                                hourly_data, daily_data, monthly_data)
                # do tasks
                tasks.do_tasks()
            else:
                tasks.do_live(data)
    except Exception, ex:
        logger.exception(ex)

 def get_readings(self):
     for data in DataStore.data_store(self.data_store)[self.last_ts:]:
         if data['idx'] <= self.last_ts:
             continue
         self.last_ts = data['idx']
         for key in self.keys:
             if not data[key]:
                 continue
             yield Reading(READING_TYPE, data[key], data['idx'], key)

def Hourly(data_dir):
    # get file locations
    params = DataStore.params(data_dir)
    status = DataStore.status(data_dir)
    # localise application
    Localisation.SetApplicationLanguage(params)
    # open data file stores
    raw_data = DataStore.data_store(data_dir)
    calib_data = DataStore.calib_store(data_dir)
    hourly_data = DataStore.hourly_store(data_dir)
    daily_data = DataStore.daily_store(data_dir)
    monthly_data = DataStore.monthly_store(data_dir)
    # get weather station data
    DataLogger(params, status, raw_data).log_data()
    # do the processing
    Process.Process(params,
                    raw_data, calib_data, hourly_data, daily_data, monthly_data)
    # do tasks
    if not Tasks.RegularTasks(params, status, raw_data, calib_data,
                              hourly_data, daily_data, monthly_data).do_tasks():
        return 1
    return 0

 def check_fixed_block(self):
     fixed_block = self.ws.get_fixed_block(unbuffered=True)
     # check clocks
     try:
         s_time = DataStore.safestrptime(
             fixed_block['date_time'], '%Y-%m-%d %H:%M')
     except Exception:
         s_time = None
     if s_time:
         c_time = datetime.now().replace(second=0, microsecond=0)
         diff = abs(s_time - c_time)
         if diff > timedelta(minutes=2):
             self.logger.warning(
                 "Computer and weather station clocks disagree by %s (H:M:S).", str(diff))
     # store weather station type
     self.params.set('config', 'ws type', self.ws.ws_type)
     # store info from fixed block
     self.status.unset('fixed', 'pressure offset')
     if not self.params.get('config', 'pressure offset'):
         self.params.set('config', 'pressure offset', '%g' % (
             fixed_block['rel_pressure'] - fixed_block['abs_pressure']))
     self.params.unset('fixed', 'fixed block')
     self.status.set('fixed', 'fixed block', str(fixed_block))
     return fixed_block

def Reprocess(data_dir, update):
    logger = logging.getLogger('pywws-reprocess')
    raw_data = DataStore.data_store(data_dir)
    if update:
        # update old data to copy high nibble of wind_dir to status
        logger.warning("Updating status to include extra bits from wind_dir")
        count = 0
        for data in raw_data[:]:
            count += 1
            idx = data['idx']
            if count % 10000 == 0:
                logger.info("update: %s", idx.isoformat(' '))
            elif count % 500 == 0:
                logger.debug("update: %s", idx.isoformat(' '))
            if data['wind_dir'] is not None:
                if data['wind_dir'] >= 16:
                    data['status'] |= (data['wind_dir'] & 0xF0) << 4
                    data['wind_dir'] &= 0x0F
                    raw_data[idx] = data
                if data['status'] & 0x800:
                    data['wind_dir'] = None
                    raw_data[idx] = data
        raw_data.flush()
    # delete old format summary files
    logger.warning('Deleting old summaries')
    for summary in ['calib', 'hourly', 'daily', 'monthly']:
        for root, dirs, files in os.walk(
                os.path.join(data_dir, summary), topdown=False):
            logger.info(root)
            for file in files:
                os.unlink(os.path.join(root, file))
            os.rmdir(root)
    # create data summaries
    logger.warning('Generating hourly and daily summaries')
    params = DataStore.params(data_dir)
    calib_data = DataStore.calib_store(data_dir)
    hourly_data = DataStore.hourly_store(data_dir)
    daily_data = DataStore.daily_store(data_dir)
    monthly_data = DataStore.monthly_store(data_dir)
    Process.Process(
        params,
        raw_data, calib_data, hourly_data, daily_data, monthly_data)
    return 0

def Reprocess(data_dir):
    # delete old format summary files
    print "Deleting old summaries"
    for summary in ["calib", "hourly", "daily", "monthly"]:
        for root, dirs, files in os.walk(os.path.join(data_dir, summary), topdown=False):
            print root
            for file in files:
                os.unlink(os.path.join(root, file))
            os.rmdir(root)
    # create data summaries
    print "Generating hourly and daily summaries"
    params = DataStore.params(data_dir)
    raw_data = DataStore.data_store(data_dir)
    calib_data = DataStore.calib_store(data_dir)
    hourly_data = DataStore.hourly_store(data_dir)
    daily_data = DataStore.daily_store(data_dir)
    monthly_data = DataStore.monthly_store(data_dir)
    Process.Process(params, raw_data, calib_data, hourly_data, daily_data, monthly_data)
    return 0

     if o == '-h' or o == '--help':
         print __usage__.strip()
         return 0
     elif o == '-n' or o == '--noaction':
         noaction = True
 # check arguments
 if len(args) != 1:
     print >>sys.stderr, 'Error: 1 argument required\n'
     print >>sys.stderr, __usage__.strip()
     return 2
 data_dir = args[0]
 # date & time range of data to be changed, in UTC!
 start = datetime(2013, 10, 27, 11, 21)
 stop  = datetime(2013, 10, 29, 18, 32)
 # open data store
 raw_data = DataStore.data_store(data_dir)
 # process the data
 aperture = timedelta(minutes=14, seconds=30)
 # make list of changes to apply after examining the data
 changes = []
 for data in raw_data[start:stop]:
     if data['temp_out'] is None:
         continue
     # get temperatures at nearby times
     idx = data['idx']
     temp_list = []
     for local_data in raw_data[idx-aperture:idx+aperture]:
         temp = local_data['temp_out']
         if temp is not None:
             temp_list.append(temp)
     if len(temp_list) < 3:

def LiveLog(data_dir):
    logger = logging.getLogger('pywws.LiveLog')
    params = DataStore.params(data_dir)
    status = DataStore.status(data_dir)
    # localise application
    Localisation.SetApplicationLanguage(params)
    # connect to weather station
    ws_type = params.get('fixed', 'ws type')
    if ws_type:
        params.unset('fixed', 'ws type')
        params.set('config', 'ws type', ws_type)
    ws_type = params.get('config', 'ws type', '1080')
    ws = WeatherStation.weather_station(
        ws_type=ws_type, params=params, status=status)
    fixed_block = CheckFixedBlock(ws, params, status, logger)
    if not fixed_block:
        logger.error("Invalid data from weather station")
        return 3
    # open data file stores
    raw_data = DataStore.data_store(data_dir)
    calib_data = DataStore.calib_store(data_dir)
    hourly_data = DataStore.hourly_store(data_dir)
    daily_data = DataStore.daily_store(data_dir)
    monthly_data = DataStore.monthly_store(data_dir)
    # create a RegularTasks object
    tasks = Tasks.RegularTasks(
        params, status, calib_data, hourly_data, daily_data, monthly_data)
    # get time of last logged data
    two_minutes = timedelta(minutes=2)
    last_stored = raw_data.before(datetime.max)
    if last_stored == None:
        last_stored = datetime.min
    if datetime.utcnow() < last_stored:
        raise ValueError('Computer time is earlier than last stored data')
    last_stored += two_minutes
    # get live data
    hour = timedelta(hours=1)
    next_hour = datetime.utcnow().replace(
                                    minute=0, second=0, microsecond=0) + hour
    next_ptr = None
    for data, ptr, logged in ws.live_data(
                                    logged_only=(not tasks.has_live_tasks())):
        now = data['idx']
        if logged:
            if ptr == next_ptr:
                # data is contiguous with last logged value
                raw_data[now] = data
            else:
                # catch up missing data
                Catchup(ws, logger, raw_data, now, ptr)
            next_ptr = ws.inc_ptr(ptr)
            # process new data
            Process.Process(params, status, raw_data, calib_data,
                            hourly_data, daily_data, monthly_data)
            # do tasks
            tasks.do_tasks()
            if now >= next_hour:
                next_hour += hour
                fixed_block = CheckFixedBlock(ws, params, status, logger)
                if not fixed_block:
                    logger.error("Invalid data from weather station")
                    return 3
                # save any unsaved data
                raw_data.flush()
        else:
            tasks.do_live(data)
    return 0

    try:
        opts, args = getopt.getopt(
            argv[1:], "hcv", ['help', 'catchup', 'verbose'])
    except getopt.error, msg:
        print >>sys.stderr, 'Error: %s\n' % msg
        print >>sys.stderr, __usage__.strip()
        return 1
    # process options
    catchup = False
    verbose = 0
    for o, a in opts:
        if o == '-h' or o == '--help':
            print __usage__.strip()
            return 0
        elif o == '-c' or o == '--catchup':
            catchup = True
        elif o == '-v' or o == '--verbose':
            verbose += 1
    # check arguments
    if len(args) != 2:
        print >>sys.stderr, "Error: 2 arguments required"
        print >>sys.stderr, __usage__.strip()
        return 2
    logger = ApplicationLogger(verbose)
    return ToService(
        DataStore.params(args[0]), DataStore.status(args[0]),
        DataStore.calib_store(args[0]), args[1]).Upload(catchup=catchup)

if __name__ == "__main__":
    sys.exit(main())

 for o, a in opts:
     if o == '--help':
         usage()
         return 0
 # check arguments
 if len(args) != 2:
     print >>sys.stderr, 'Error: 2 arguments required\n'
     print >>sys.stderr, __usage__.strip()
     return 2
 # process arguments
 in_name = args[0]
 out_name = args[1]
 # open input
 in_file = open(in_name, 'r')
 # open data file store
 ds = DataStore.data_store(out_name)
 # get time to go forward to
 first_stored = ds.after(datetime.min)
 if first_stored == None:
     first_stored = datetime.max
 # copy any missing data
 last_date = None
 count = 0
 for line in in_file:
     items = line.split(',')
     local_date = DataStore.safestrptime(items[2].strip(), '%Y-%m-%d %H:%M:%S')
     local_date = local_date.replace(tzinfo=TimeZone.Local)
     date = local_date.astimezone(TimeZone.utc)
     if last_date and date < last_date:
         date = date + timedelta(hours=1)
         print "Corrected DST ambiguity %s %s -> %s" % (

        return self.Upload(tweet)

def main(argv=None):
    if argv is None:
        argv = sys.argv
    try:
        opts, args = getopt.getopt(argv[1:], "h", ['help'])
    except getopt.error, msg:
        print >>sys.stderr, 'Error: %s\n' % msg
        print >>sys.stderr, __usage__.strip()
        return 1
    # process options
    for o, a in opts:
        if o in ('-h', '--help'):
            print __usage__.strip()
            return 0
    # check arguments
    if len(args) != 2:
        print >>sys.stderr, "Error: 2 arguments required"
        print >>sys.stderr, __usage__.strip()
        return 2
    logger = ApplicationLogger(1)
    params = DataStore.params(args[0])
    Localisation.SetApplicationLanguage(params)
    if ToTwitter(params).UploadFile(args[1]):
        return 0
    return 3

if __name__ == "__main__":
    sys.exit(main())

        return 1
    access_token = dict(urlparse.parse_qsl(content))
    params.set('twitter', 'key', access_token['oauth_token'])
    params.set('twitter', 'secret', access_token['oauth_token_secret'])
    print 'Success! Authorisation data has been stored in %s' % params._path
    return 0

def main(argv=None):
    if argv is None:
        argv = sys.argv
    try:
        opts, args = getopt.getopt(argv[1:], "h", ['help'])
    except getopt.error, msg:
        print >>sys.stderr, 'Error: %s\n' % msg
        print >>sys.stderr, __usage__.strip()
        return 1
    # process options
    for o, a in opts:
        if o in ('-h', '--help'):
            print __usage__.strip()
            return 0
    # check arguments
    if len(args) != 1:
        print >>sys.stderr, "Error: 1 argument required"
        print >>sys.stderr, __usage__.strip()
        return 2
    return TwitterAuth(DataStore.params(args[0]))

if __name__ == "__main__":
    sys.exit(main())

########
# Main
########
# Global Variables
AdaScreenNumber = 0
data = {}
forecast_bom_today = ""
forecast_bom_tomorrow = ""
forecast_file_today = ""
forecast_toggle = 0
global_init=True
readings = {}
# pywws data
if config.getboolean('Output','PYWWS_PUBLISH'):
	ds = DataStore.data_store(config.get('PYWWS','STORAGE'))
	dstatus = DataStore.status(config.get('PYWWS','STORAGE'))
if config.getboolean('Output','ADA_LCD'):
	AdaLcd.clear()
if config.getboolean('Output','SENSEHAT_DISPLAY'):
	# Set up display
	PiSenseHat.clear()
	PiSenseHat.set_rotation(config.get('SenseHat','ROTATION'))
if config.getboolean('Sensors','ENOCEAN'):
	eoCommunicator = eoSerialCommunicator(port=config.get('EnOcean','PORT'))
	eoCommunicator.start()
# Warm up sensors
print "Waiting for sensors to settle"
for i in range(1,6):
	Sample()
	time.sleep(1)