def rapidWind(Msg,wfpiconsole):
""" Handles RapidWind Websocket messages received from either SKY or TEMPEST
module
INPUTS:
Msg Websocket messages received from SKY or TEMPEST
wfpiconsole wfpiconsole object
"""
# Replace missing observations from Rapid Wind Websocket JSON
# with NaN
Ob = [x if x != None else NaN for x in Msg['ob']]
# Discard duplicate Rapid Wind Websocket messages
if 'RapidMsg' in wfpiconsole.Obs:
if wfpiconsole.Obs['RapidMsg']['ob'][0] == Ob[0]:
print('Discarding duplicate Rapid Wind Websocket message')
return
# Extract observations from latest Rapid Wind Websocket JSON
Time = [Ob[0],'s']
WindSpd = [Ob[1],'mps']
WindDir = [Ob[2],'degrees']
# Extract wind direction from previous SKY Rapid-Wind Websocket JSON
if 'RapidMsg' in wfpiconsole.Obs:
Ob = [x if x != None else NaN for x in wfpiconsole.Obs['RapidMsg']['ob']]
WindDirOld = [Ob[2],'degrees']
else:
WindDirOld = [0,'degrees']
# If windspeed is zero, freeze direction at last direction of non-zero wind
# speed and edit latest Rapid Wind Websocket JSON. Calculate wind shift
if WindSpd[0] == 0:
WindDir = WindDirOld
Msg['ob'][2] = WindDirOld[0]
# Store latest Rapid Wind wfpiconsole.Observation JSON message
wfpiconsole.Obs['RapidMsg'] = Msg
# Calculate derived variables from Rapid Wind observations
WindDir = derive.CardinalWindDirection(WindDir,WindSpd)
# Convert observation units as required
WindSpd = observation.Units(WindSpd,wfpiconsole.config['Units']['Wind'])
WindDir = observation.Units(WindDir,'degrees')
# Update wfpiconsole display with derived Rapid Wind observations
wfpiconsole.Obs['rapidShift'] = WindDir[0] - WindDirOld[0]
wfpiconsole.Obs['rapidSpd'] = observation.Format(WindSpd,'Wind')
wfpiconsole.Obs['rapidDir'] = observation.Format(WindDir,'Direction')
# Animate wind rose arrow if WindSpeedPanel panel is active
if hasattr(wfpiconsole,'WindSpeedPanel'):
for panel in getattr(wfpiconsole,'WindSpeedPanel'):
panel.animateWindRose()
# Return wfpiconsole object
return wfpiconsole
def Units(Obs, Unit):
""" Sets the required observation units
INPUTS:
Obs Observations with current units
Unit Required output unit
OUTPUT:
cObs Observation converted into required unit
"""
# Convert temperature observations
cObs = Obs[:]
if Unit in ['f', 'c']:
for ii, T in enumerate(Obs):
if T == 'c':
if Unit == 'f':
cObs[ii - 1] = Obs[ii - 1] * 9 / 5 + 32
cObs[ii] = 'f'
else:
cObs[ii - 1] = Obs[ii - 1]
cObs[ii] = 'c'
# Convert pressure and pressure trend observations
elif Unit in ['inhg', 'mmhg', 'hpa', 'mb']:
for ii, P in enumerate(Obs):
if P in ['mb', 'mb/hr']:
if Unit == 'inhg':
cObs[ii - 1] = Obs[ii - 1] * 0.0295301
if P == 'mb':
cObs[ii] = ' inHg'
else:
cObs[ii] = ' inHg/hr'
elif Unit == 'mmhg':
cObs[ii - 1] = Obs[ii - 1] * 0.750063
if P == 'mb':
cObs[ii] = ' mmHg'
else:
cObs[ii] = ' mmHg/hr'
elif Unit == 'hpa':
cObs[ii - 1] = Obs[ii - 1]
if P == 'mb':
cObs[ii] = ' hPa'
else:
cObs[ii] = ' hPa/hr'
else:
cObs[ii - 1] = Obs[ii - 1]
if P == 'mb':
cObs[ii] = ' mb'
else:
cObs[ii] = ' mb/hr'
# Convert windspeed observations
elif Unit in ['mph', 'lfm', 'kts', 'kph', 'bft', 'mps']:
for ii, W in enumerate(Obs):
if W == 'mps':
if Unit == 'mph' or Unit == 'lfm':
cObs[ii - 1] = Obs[ii - 1] * 2.2369362920544
cObs[ii] = 'mph'
elif Unit == 'kts':
cObs[ii - 1] = Obs[ii - 1] * 1.9438
cObs[ii] = 'kts'
elif Unit == 'kph':
cObs[ii - 1] = Obs[ii - 1] * 3.6
cObs[ii] = 'km/h'
elif Unit == 'bft':
cObs[ii - 1] = derive.BeaufortScale(Obs[ii - 1:ii + 1])[2]
cObs[ii] = 'bft'
else:
cObs[ii - 1] = Obs[ii - 1]
cObs[ii] = 'm/s'
# Convert wind direction observations
elif Unit in ['degrees', 'cardinal']:
for ii, W in enumerate(Obs):
if W == 'degrees':
if cObs[ii - 1] is None:
cObs[ii - 1] = 'Calm'
cObs[ii] = ''
elif Unit == 'cardinal':
cObs[ii - 1] = derive.CardinalWindDirection(Obs[ii - 1:ii +
1])[2]
cObs[ii] = ''
else:
cObs[ii - 1] = Obs[ii - 1]
cObs[ii] = 'degrees'
# Convert rain accumulation and rain rate observations
elif Unit in ['in', 'cm', 'mm']:
for ii, Prcp in enumerate(Obs):
if Prcp in ['mm', 'mm/hr']:
if Unit == 'in':
cObs[ii - 1] = Obs[ii - 1] * 0.0393701
if Prcp == 'mm':
cObs[ii] = ' in'
else:
cObs[ii] = ' in/hr'
elif Unit == 'cm':
cObs[ii - 1] = Obs[ii - 1] * 0.1
if Prcp == 'mm':
cObs[ii] = ' cm'
else:
cObs[ii] = ' cm/hr'
else:
cObs[ii - 1] = Obs[ii - 1]
if Prcp == 'mm':
cObs[ii] = ' mm'
else:
cObs[ii] = ' mm/hr'
# Convert distance observations
elif Unit in ['km', 'mi']:
for ii, Dist in enumerate(Obs):
if Dist == 'km':
if Unit == 'mi':
cObs[ii - 1] = Obs[ii - 1] * 0.62137
cObs[ii] = 'miles'
# Return converted observations
return cObs
def Tempest(Msg, wfpiconsole):
""" Handles Websocket messages received from TEMPEST module
INPUTS:
Msg Websocket messages received from TEMPEST module
wfpiconsole wfpiconsole object
"""
# Replace missing observations from latest TEMPEST Websocket JSON with NaN
Ob = [x if x != None else NaN for x in Msg['obs'][0]]
# Discard duplicate TEMPEST Websocket messages
if 'TempestMsg' in wfpiconsole.Obs:
if wfpiconsole.Obs['TempestMsg']['obs'][0] == Ob[0]:
print('Discarding duplicate TEMPEST Websocket message')
return
# Extract TEMPEST device ID, API flag, and station configuration object
Device = wfpiconsole.config['Station']['TempestID']
flagAPI = wfpiconsole.flagAPI[0]
Config = wfpiconsole.config
# Extract required observations from latest TEMPEST Websocket JSON
Time = [Ob[0], 's']
WindSpd = [Ob[2], 'mps']
WindGust = [Ob[3], 'mps']
WindDir = [Ob[4], 'degrees']
Pres = [Ob[6], 'mb']
Temp = [Ob[7], 'c']
Humidity = [Ob[8], '%']
UV = [Ob[10], 'index']
Radiation = [Ob[11], 'Wm2']
Rain = [Ob[12], 'mm']
Strikes = [Ob[15], 'count']
# Extract lightning strike data from the latest AIR Websocket JSON "Summary"
# object
StrikeTime = [
Msg['summary']['strike_last_epoch']
if 'strike_last_epoch' in Msg['summary'] else NaN, 's'
]
StrikeDist = [
Msg['summary']['strike_last_dist']
if 'strike_last_dist' in Msg['summary'] else NaN, 'km'
]
Strikes3hr = [
Msg['summary']['strike_count_3h']
if 'strike_count_3h' in Msg['summary'] else NaN, 'count'
]
# Store latest TEMPEST Websocket message
wfpiconsole.Obs['TempestMsg'] = Msg
# Extract required derived observations
minPres = wfpiconsole.Obs['MinPres']
maxPres = wfpiconsole.Obs['MaxPres']
minTemp = wfpiconsole.Obs['outTempMin']
maxTemp = wfpiconsole.Obs['outTempMax']
StrikeCount = {
'Today': wfpiconsole.Obs['StrikesToday'],
'Month': wfpiconsole.Obs['StrikesMonth'],
'Year': wfpiconsole.Obs['StrikesYear']
}
rainAccum = {
'Today': wfpiconsole.Obs['TodayRain'],
'Yesterday': wfpiconsole.Obs['YesterdayRain'],
'Month': wfpiconsole.Obs['MonthRain'],
'Year': wfpiconsole.Obs['YearRain']
}
peakSun = wfpiconsole.Obs['peakSun']
avgWind = wfpiconsole.Obs['AvgWind']
maxGust = wfpiconsole.Obs['MaxGust']
# Request TEMPEST data from the previous three hours
Data3h = requestAPI.weatherflow.Last3h(Device, Time[0], Config)
# Calculate derived variables from TEMPEST observations
DewPoint = derive.DewPoint(Temp, Humidity)
SLP = derive.SLP(Pres, Config)
PresTrend = derive.SLPTrend(Pres, Time, Data3h, Config)
FeelsLike = derive.FeelsLike(Temp, Humidity, WindSpd, Config)
MaxTemp, MinTemp = derive.TempMaxMin(Time, Temp, maxTemp, minTemp, Device,
Config, flagAPI)
MaxPres, MinPres = derive.SLPMaxMin(Time, Pres, maxPres, minPres, Device,
Config, flagAPI)
StrikeCount = derive.StrikeCount(Strikes, StrikeCount, Device, Config,
flagAPI)
StrikeFreq = derive.StrikeFrequency(Time, Data3h, Config)
StrikeDeltaT = derive.StrikeDeltaT(StrikeTime)
FeelsLike = derive.FeelsLike(Temp, Humidity, WindSpd, Config)
RainRate = derive.RainRate(Rain)
rainAccum = derive.RainAccumulation(Rain, rainAccum, Device, Config,
flagAPI)
AvgWind = derive.MeanWindSpeed(WindSpd, avgWind, Device, Config, flagAPI)
MaxGust = derive.MaxWindGust(WindGust, maxGust, Device, Config, flagAPI)
WindSpd = derive.BeaufortScale(WindSpd)
WindDir = derive.CardinalWindDirection(WindDir, WindSpd)
peakSun = derive.peakSunHours(Radiation, peakSun, wfpiconsole.Astro,
Device, Config, flagAPI)
UVIndex = derive.UVIndex(UV)
# Convert observation units as required
Temp = observation.Units(Temp, Config['Units']['Temp'])
MaxTemp = observation.Units(MaxTemp, Config['Units']['Temp'])
MinTemp = observation.Units(MinTemp, Config['Units']['Temp'])
DewPoint = observation.Units(DewPoint, Config['Units']['Temp'])
FeelsLike = observation.Units(FeelsLike, Config['Units']['Temp'])
SLP = observation.Units(SLP, Config['Units']['Pressure'])
MaxPres = observation.Units(MaxPres, Config['Units']['Pressure'])
MinPres = observation.Units(MinPres, Config['Units']['Pressure'])
PresTrend = observation.Units(PresTrend, Config['Units']['Pressure'])
StrikeDist = observation.Units(StrikeDist, Config['Units']['Distance'])
RainRate = observation.Units(RainRate, Config['Units']['Precip'])
TodayRain = observation.Units(rainAccum['Today'],
Config['Units']['Precip'])
YesterdayRain = observation.Units(rainAccum['Yesterday'],
Config['Units']['Precip'])
MonthRain = observation.Units(rainAccum['Month'],
Config['Units']['Precip'])
YearRain = observation.Units(rainAccum['Year'], Config['Units']['Precip'])
WindSpd = observation.Units(WindSpd, Config['Units']['Wind'])
WindDir = observation.Units(WindDir, Config['Units']['Direction'])
WindGust = observation.Units(WindGust, Config['Units']['Wind'])
AvgWind = observation.Units(AvgWind, Config['Units']['Wind'])
MaxGust = observation.Units(MaxGust, Config['Units']['Wind'])
FeelsLike = observation.Units(FeelsLike, Config['Units']['Temp'])
# Store derived TEMPEST observations in dictionary
derivedObs = {}
derivedObs['outTemp'] = observation.Format(Temp, 'Temp')
derivedObs['outTempMax'] = observation.Format(MaxTemp, 'Temp')
derivedObs['outTempMin'] = observation.Format(MinTemp, 'Temp')
derivedObs['DewPoint'] = observation.Format(DewPoint, 'Temp')
derivedObs['FeelsLike'] = observation.Format(FeelsLike, 'Temp')
derivedObs['Pres'] = observation.Format(SLP, 'Pressure')
derivedObs['MaxPres'] = observation.Format(MaxPres, 'Pressure')
derivedObs['MinPres'] = observation.Format(MinPres, 'Pressure')
derivedObs['PresTrend'] = observation.Format(PresTrend, 'Pressure')
derivedObs['StrikeDeltaT'] = observation.Format(StrikeDeltaT, 'TimeDelta')
derivedObs['StrikeDist'] = observation.Format(StrikeDist, 'StrikeDistance')
derivedObs['StrikeFreq'] = observation.Format(StrikeFreq,
'StrikeFrequency')
derivedObs['Strikes3hr'] = observation.Format(Strikes3hr, 'StrikeCount')
derivedObs['StrikesToday'] = observation.Format(StrikeCount['Today'],
'StrikeCount')
derivedObs['StrikesMonth'] = observation.Format(StrikeCount['Month'],
'StrikeCount')
derivedObs['StrikesYear'] = observation.Format(StrikeCount['Year'],
'StrikeCount')
derivedObs['Humidity'] = observation.Format(Humidity, 'Humidity')
derivedObs['FeelsLike'] = observation.Format(FeelsLike, 'Temp')
derivedObs['RainRate'] = observation.Format(RainRate, 'Precip')
derivedObs['TodayRain'] = observation.Format(TodayRain, 'Precip')
derivedObs['YesterdayRain'] = observation.Format(YesterdayRain, 'Precip')
derivedObs['MonthRain'] = observation.Format(MonthRain, 'Precip')
derivedObs['YearRain'] = observation.Format(YearRain, 'Precip')
derivedObs['WindSpd'] = observation.Format(WindSpd, 'Wind')
derivedObs['WindGust'] = observation.Format(WindGust, 'Wind')
derivedObs['AvgWind'] = observation.Format(AvgWind, 'Wind')
derivedObs['MaxGust'] = observation.Format(MaxGust, 'Wind')
derivedObs['WindDir'] = observation.Format(WindDir, 'Direction')
derivedObs['Radiation'] = observation.Format(Radiation, 'Radiation')
derivedObs['peakSun'] = observation.Format(peakSun, 'peakSun')
derivedObs['UVIndex'] = observation.Format(UVIndex, 'UV')
# Update wfpiconsole display with derived TEMPEST observations
updateDisplay(derivedObs, wfpiconsole, 'Tempest')
# Set flags for required API calls
wfpiconsole.flagAPI[0] = 0
# Return wfpiconsole object
return wfpiconsole
def Sky(Msg, wfpiconsole):
""" Handles Websocket messages received from SKY module
INPUTS:
Msg Websocket messages received from SKY module
wfpiconsole wfpiconsole object
"""
# Replace missing observations from latest SKY Websocket JSON with NaN
Ob = [x if x != None else NaN for x in Msg['obs'][0]]
# Discard duplicate SKY Websocket messages
if 'SkyMsg' in wfpiconsole.Obs:
if wfpiconsole.Obs['SkyMsg']['obs'][0] == Ob[0]:
print('Discarding duplicate SKY Websocket message')
return
# Extract SKY device ID and API flag, and station configuration object
Device = wfpiconsole.config['Station']['SkyID']
flagAPI = wfpiconsole.flagAPI[1]
Config = wfpiconsole.config
# Extract required observations from latest SKY Websocket JSON
Time = [Ob[0], 's']
UV = [Ob[2], 'index']
Rain = [Ob[3], 'mm']
WindSpd = [Ob[5], 'mps']
WindGust = [Ob[6], 'mps']
WindDir = [Ob[7], 'degrees']
Radiation = [Ob[10], 'Wm2']
# Store latest SKY Websocket message
wfpiconsole.Obs['SkyMsg'] = Msg
# Extract required observations from latest AIR Websocket observations
while not 'outAirMsg' in wfpiconsole.Obs:
time.sleep(0.01)
Ob = [
x if x != None else NaN for x in wfpiconsole.Obs['outAirMsg']['obs'][0]
]
Temp = [Ob[2], 'c']
Humidity = [Ob[3], '%']
# Set wind direction to None if wind speed is zero
if WindSpd[0] == 0:
WindDir = [None, 'degrees']
# Extract required derived observations
rainAccum = {
'Today': wfpiconsole.Obs['TodayRain'],
'Yesterday': wfpiconsole.Obs['YesterdayRain'],
'Month': wfpiconsole.Obs['MonthRain'],
'Year': wfpiconsole.Obs['YearRain']
}
peakSun = wfpiconsole.Obs['peakSun']
avgWind = wfpiconsole.Obs['AvgWind']
maxGust = wfpiconsole.Obs['MaxGust']
# Calculate derived variables from SKY observations
FeelsLike = derive.FeelsLike(Temp, Humidity, WindSpd, Config)
RainRate = derive.RainRate(Rain)
rainAccum = derive.RainAccumulation(Rain, rainAccum, Device, Config,
flagAPI)
AvgWind = derive.MeanWindSpeed(WindSpd, avgWind, Device, Config, flagAPI)
MaxGust = derive.MaxWindGust(WindGust, maxGust, Device, Config, flagAPI)
WindSpd = derive.BeaufortScale(WindSpd)
WindDir = derive.CardinalWindDirection(WindDir, WindSpd)
peakSun = derive.peakSunHours(Radiation, peakSun, wfpiconsole.Astro,
Device, Config, flagAPI)
UVIndex = derive.UVIndex(UV)
# Convert observation units as required
RainRate = observation.Units(RainRate, Config['Units']['Precip'])
TodayRain = observation.Units(rainAccum['Today'],
Config['Units']['Precip'])
YesterdayRain = observation.Units(rainAccum['Yesterday'],
Config['Units']['Precip'])
MonthRain = observation.Units(rainAccum['Month'],
Config['Units']['Precip'])
YearRain = observation.Units(rainAccum['Year'], Config['Units']['Precip'])
WindSpd = observation.Units(WindSpd, Config['Units']['Wind'])
WindDir = observation.Units(WindDir, Config['Units']['Direction'])
WindGust = observation.Units(WindGust, Config['Units']['Wind'])
AvgWind = observation.Units(AvgWind, Config['Units']['Wind'])
MaxGust = observation.Units(MaxGust, Config['Units']['Wind'])
FeelsLike = observation.Units(FeelsLike, Config['Units']['Temp'])
# Store derived SKY observations in dictionary
derivedObs = {}
derivedObs['FeelsLike'] = observation.Format(FeelsLike, 'Temp')
derivedObs['RainRate'] = observation.Format(RainRate, 'Precip')
derivedObs['TodayRain'] = observation.Format(TodayRain, 'Precip')
derivedObs['YesterdayRain'] = observation.Format(YesterdayRain, 'Precip')
derivedObs['MonthRain'] = observation.Format(MonthRain, 'Precip')
derivedObs['YearRain'] = observation.Format(YearRain, 'Precip')
derivedObs['WindSpd'] = observation.Format(WindSpd, 'Wind')
derivedObs['WindGust'] = observation.Format(WindGust, 'Wind')
derivedObs['AvgWind'] = observation.Format(AvgWind, 'Wind')
derivedObs['MaxGust'] = observation.Format(MaxGust, 'Wind')
derivedObs['WindDir'] = observation.Format(WindDir, 'Direction')
derivedObs['Radiation'] = observation.Format(Radiation, 'Radiation')
derivedObs['peakSun'] = observation.Format(peakSun, 'peakSun')
derivedObs['UVIndex'] = observation.Format(UVIndex, 'UV')
# Update wfpiconsole display with derived SKY observations
updateDisplay(derivedObs, wfpiconsole, 'Sky')
# Set flags for required API calls
wfpiconsole.flagAPI[1] = 0
# Return wfpiconsole object
return wfpiconsole
def Download(metData, Config, dt):
""" Download the latest daily and hourly weather forecast data using the
WeatherFlow BetterForecast API
INPUTS:
metData Dictionary holding weather forecast data
Config Station configuration
dt Time in seconds since function last called
OUTPUT:
metData Dictionary holding weather forecast data
"""
# Get current time in station time zone
Tz = pytz.timezone(Config['Station']['Timezone'])
funcCalled = datetime.now(pytz.utc).astimezone(Tz)
Midnight = int(
Tz.localize(datetime(funcCalled.year, funcCalled.month,
funcCalled.day)).timestamp())
funcError = 0
# Set time format based on user configuration
if Config['Display']['TimeFormat'] == '12 hr':
if Config['System']['Hardware'] != 'Other':
TimeFormat = '%-I %P'
else:
TimeFormat = '%I %p'
else:
TimeFormat = '%H:%M'
# Download latest forecast data
Data = requestAPI.weatherflow.Forecast(Config)
# Verify API response and extract forecast
if requestAPI.weatherflow.verifyResponse(Data, 'forecast'):
metData['Dict'] = Data.json()
else:
funcError = 1
if not 'Dict' in metData:
metData['Dict'] = {}
# Extract all forecast data from WeatherFlow JSON object
try:
# Extract all hourly and daily forecasts
hourlyForecasts = (metData['Dict']['forecast']['hourly'])
dailyForecasts = (metData['Dict']['forecast']['daily'])
# Extract 'valid from' time of all available hourly forecasts and
# retrieve forecast for the current hour
Hours = list(forecast['time'] for forecast in hourlyForecasts)
hoursInd = bisect.bisect(Hours, int(UNIX.time()))
hourlyCurrent = hourlyForecasts[hoursInd]
hourlyLocalDay = hourlyCurrent['local_day']
# Extract 'Valid' until time of forecast for current hour
Valid = Hours[bisect.bisect(Hours, int(UNIX.time()))]
Valid = datetime.fromtimestamp(Valid, pytz.utc).astimezone(Tz)
# Extract 'day_start_local' time of all available daily forecasts and
# retrieve forecast for the current day
dailyDayNum = list(forecast['day_num'] for forecast in dailyForecasts)
dailyCurrent = dailyForecasts[dailyDayNum.index(hourlyLocalDay)]
# Extract weather variables from current hourly forecast
Temp = [hourlyCurrent['air_temperature'], 'c']
WindSpd = [hourlyCurrent['wind_avg'], 'mps']
WindGust = [hourlyCurrent['wind_gust'], 'mps']
WindDir = [hourlyCurrent['wind_direction'], 'degrees']
Icon = hourlyCurrent['icon'].replace('cc-', '')
# Extract Precipitation Type, Percent, and Amount from current hourly
# forecast
if 'precip_type' in hourlyCurrent:
PrecipType = hourlyCurrent['precip_type']
if PrecipType not in ['rain', 'snow']:
PrecipType = 'rain'
else:
PrecipType = 'rain'
if 'precip_probability' in hourlyCurrent:
PrecipPercnt = [hourlyCurrent['precip_probability'], '%']
else:
PrecipPercnt = [0, '%']
if 'precip' in hourlyCurrent:
PrecipAmount = [hourlyCurrent['precip'], 'mm']
else:
PrecipAmount = [0, 'mm']
# Extract weather variables from current daily forecast
highTemp = [dailyCurrent['air_temp_high'], 'c']
lowTemp = [dailyCurrent['air_temp_low'], 'c']
precipDay = [dailyCurrent['precip_probability'], '%']
# Extract list of expected conditions and find time when expected conditions
# will change
conditionList = list(forecast['conditions']
for forecast in hourlyForecasts[hoursInd:])
try:
Ind = next(i for i, C in enumerate(conditionList)
if C != hourlyCurrent['conditions'])
except StopIteration:
Ind = len(conditionList) - 1
Time = datetime.fromtimestamp(Hours[Ind], pytz.utc).astimezone(Tz)
if Time.date() == funcCalled.date():
Conditions = hourlyCurrent['conditions'].capitalize(
) + ' until ' + datetime.strftime(Time, TimeFormat) + ' today'
elif Time.date() == funcCalled.date() + timedelta(days=1):
Conditions = hourlyCurrent['conditions'].capitalize(
) + ' until ' + datetime.strftime(Time, TimeFormat) + ' tomorrow'
else:
Conditions = hourlyCurrent['conditions'].capitalize(
) + ' until ' + datetime.strftime(
Time, TimeFormat) + ' on ' + Time.strftime('%A')
# Calculate derived variables from forecast
WindDir = derive.CardinalWindDirection(WindDir, WindSpd)
# Convert forecast units as required
Temp = observation.Units(Temp, Config['Units']['Temp'])
highTemp = observation.Units(highTemp, Config['Units']['Temp'])
lowTemp = observation.Units(lowTemp, Config['Units']['Temp'])
WindSpd = observation.Units(WindSpd, Config['Units']['Wind'])
WindGust = observation.Units(WindGust, Config['Units']['Wind'])
WindDir = observation.Units(WindDir, Config['Units']['Direction'])
PrecipAmount = observation.Units(PrecipAmount,
Config['Units']['Precip'])
# Define and format labels
metData['Time'] = funcCalled
metData['Valid'] = datetime.strftime(Valid, TimeFormat)
metData['Temp'] = observation.Format(Temp, 'forecastTemp')
metData['highTemp'] = observation.Format(highTemp, 'forecastTemp')
metData['lowTemp'] = observation.Format(lowTemp, 'forecastTemp')
metData['WindSpd'] = observation.Format(WindSpd, 'forecastWind')
metData['WindGust'] = observation.Format(WindGust, 'forecastWind')
metData['WindDir'] = observation.Format(WindDir, 'Direction')
metData['PrecipPercnt'] = observation.Format(PrecipPercnt, 'Humidity')
metData['PrecipDay'] = observation.Format(precipDay, 'Humidity')
metData['PrecipAmount'] = observation.Format(PrecipAmount, 'Precip')
metData['PrecipType'] = PrecipType
metData['Conditions'] = Conditions
metData['Icon'] = Icon
metData['Status'] = ''
# Check expected conditions icon is recognised
if Icon in [
'clear-day', 'clear-night', 'rainy', 'possibly-rainy-day',
'possibly-rainy-night', 'snow', 'possibly-snow-day',
'possibly-snow-night', 'sleet', 'possibly-sleet-day',
'possibly-sleet-night', 'thunderstorm',
'possibly-thunderstorm-day'
'possibly-thunderstorm-night', 'windy', 'foggy', 'cloudy',
'partly-cloudy-day', 'partly-cloudy-night'
]:
metData['Icon'] = Icon
else:
metData['Icon'] = '--'
# Unable to extract forecast data from JSON object. Set set forecast
# variables to blank and indicate to user that forecast is unavailable
except (IndexError, KeyError, ValueError):
metData['Time'] = funcCalled
metData['Valid'] = '--'
metData['Temp'] = '--'
metData['highTemp'] = '--'
metData['lowTemp'] = '--'
metData['WindSpd'] = '--'
metData['WindGust'] = '--'
metData['WindDir'] = '--'
metData['PrecipPercnt'] = '--'
metData['PrecipDay'] = '--'
metData['PrecipAmount'] = '--'
metData['PrecipType'] = '--'
metData['Conditions'] = ''
metData['Icon'] = '--'
metData['Status'] = 'Forecast currently\nunavailable...'
funcError = 1
# Schedule new forecast to be downloaded at the top of the next hour, or in
# 5 minutes if error was detected. Note secondsSched refers to number of
# seconds since the function was last called.
Now = datetime.now(pytz.utc).astimezone(Tz)
downloadTime = Tz.localize(
datetime.combine(Now.date(), time(Now.hour, 0, 0)) +
timedelta(hours=1))
if not funcError:
secondsSched = math.ceil((downloadTime - funcCalled).total_seconds())
else:
secondsSched = 300 + math.ceil((funcCalled - Now).total_seconds())
Clock.schedule_once(partial(Download, metData, Config), secondsSched)
# Return metData dictionary
return metData
def ExtractDarkSky(metData, Config):
""" Parse the weather forecast from DarkSky
INPUTS:
metData Dictionary holding weather forecast data
Config Station configuration
OUTPUT:
metData Dictionary holding weather forecast data
"""
# Get current time in station time zone
Tz = pytz.timezone(Config['Station']['Timezone'])
Now = datetime.now(pytz.utc).astimezone(Tz)
# Extract all forecast data from DarkSky JSON file. If forecast is
# unavailable, set forecast variables to blank and indicate to user that
# forecast is unavailable
Tz = pytz.timezone(Config['Station']['Timezone'])
try:
metDict = (metData['Dict']['hourly']['data'])
except KeyError:
metData['Time'] = Now
metData['Temp'] = '--'
metData['WindDir'] = '--'
metData['WindSpd'] = '--'
metData['Weather'] = 'ForecastUnavailable'
metData['Precip'] = '--'
metData['Valid'] = '--'
# Attempt to download forecast again in 10 minutes and return
# metData dictionary
Clock.schedule_once(lambda dt: Download(metData, Config), 600)
return metData
# Extract 'valid from' time of all available hourly forecasts, and
# retrieve forecast for the current hourly period
Times = list(item['time'] for item in metDict)
metDict = metDict[bisect.bisect(Times, int(time.time())) - 1]
# Extract 'Issued' and 'Valid' times
Issued = Times[0]
Valid = Times[bisect.bisect(Times, int(time.time()))]
Issued = datetime.fromtimestamp(Issued, pytz.utc).astimezone(Tz)
Valid = datetime.fromtimestamp(Valid, pytz.utc).astimezone(Tz)
# Extract weather variables from DarkSky forecast
Temp = [metDict['temperature'], 'c']
WindSpd = [metDict['windSpeed'] / 2.2369362920544, 'mps']
WindDir = [metDict['windBearing'], 'degrees']
Precip = [metDict['precipProbability'] * 100, '%']
Weather = metDict['icon']
# Convert forecast units as required
Temp = observation.Units(Temp, Config['Units']['Temp'])
WindSpd = observation.Units(WindSpd, Config['Units']['Wind'])
# Define and format labels
metData['Time'] = Now
metData['Issued'] = datetime.strftime(Issued, '%H:%M')
metData['Valid'] = datetime.strftime(Valid, '%H:%M')
metData['Temp'] = ['{:.1f}'.format(Temp[0]), Temp[1]]
metData['WindDir'] = derive.CardinalWindDirection(WindDir)[2]
metData['WindSpd'] = ['{:.0f}'.format(WindSpd[0]), WindSpd[1]]
metData['Precip'] = '{:.0f}'.format(Precip[0])
# Define weather icon
if Weather == 'clear-day':
metData['Weather'] = '1'
elif Weather == 'clear-night':
metData['Weather'] = '0'
elif Weather == 'rain':
metData['Weather'] = '12'
elif Weather == 'snow':
metData['Weather'] = '27'
elif Weather == 'sleet':
metData['Weather'] = '18'
elif Weather == 'wind':
metData['Weather'] = 'wind'
elif Weather == 'fog':
metData['Weather'] = '6'
elif Weather == 'cloudy':
metData['Weather'] = '7'
elif Weather == 'partly-cloudy-day':
metData['Weather'] = '3'
elif Weather == 'partly-cloudy-night':
metData['Weather'] = '2'
else:
metData['Weather'] = 'ForecastUnavailable'
# Return metData dictionary
return metData
