class OWMApi(Api):
def __init__(self):
super(OWMApi, self).__init__("owm")
self.lang = "en"
self.observation = ObservationParser()
self.forecast = ForecastParser()
def build_query(self, params):
params.get("query").update({"lang": self.lang})
return params.get("query")
def get_data(self, response):
return response.text
def weather_at_place(self, name):
data = self.request({
"path": "/weather",
"query": {"q": name}
})
return self.observation.parse_JSON(data)
def three_hours_forecast(self, name):
data = self.request({
"path": "/forecast",
"query": {"q": name}
})
return self.to_forecast(data, "3h")
def daily_forecast(self, name, limit=None):
query = {"q": name}
if limit is not None:
query["cnt"] = limit
data = self.request({
"path": "/forecast/daily",
"query": query
})
return self.to_forecast(data, "daily")
def to_forecast(self, data, interval):
forecast = self.forecast.parse_JSON(data)
if forecast is not None:
forecast.set_interval(interval)
return Forecaster(forecast)
else:
return None
def parse_JSON(self, JSON_string):
"""
Parses a list of *Observation* instances out of raw JSON data. Only
certain properties of the data are used: if these properties are not
found or cannot be parsed, an error is issued.
:param JSON_string: a raw JSON string
:type JSON_string: str
:returns: a list of *Observation* instances or ``None`` if no data is
available
:raises: *ParseResponseError* if it is impossible to find or parse the
data needed to build the result, *APIResponseError* if the OWM API
returns a HTTP status error (this is an OWM web API 2.5 bug)
"""
d = json.loads(JSON_string)
observation_parser = ObservationParser()
if 'cod' not in d:
raise ParseResponseError(''.join([__name__,
': impossible to read JSON data']))
# Check if server returned errors: this check overcomes the lack of use
# of HTTP error status codes by the OWM API 2.5. This mechanism is
# supposed to be deprecated as soon as the API fully adopts HTTP for
# conveying errors to the clients
if d['cod'] == "404":
print("OWM API: data not found - response payload: " + \
json.dumps(d))
return None
if d['cod'] == "200":
# Handle the case when no results are found
if 'count' in d and d['count'] == "0":
return []
else:
if 'list' in d:
return [observation_parser.parse_JSON(json.dumps(item)) \
for item in d['list']]
else:
raise ParseResponseError(''.join([__name__,
': impossible to read ' \
'observation list from JSON data'])
)
raise APIResponseError("OWM API: error - response payload: " + \
json.dumps(d))
class OWMApi(Api):
def __init__(self):
super(OWMApi, self).__init__("owm")
self.lang = "en"
self.observation = ObservationParser()
self.forecast = ForecastParser()
def build_query(self, params):
params.get("query").update({"lang": self.lang})
return params.get("query")
def get_data(self, response):
return response.text
def weather_at_place(self, name):
data = self.request({"path": "/weather", "query": {"q": name}})
return self.observation.parse_JSON(data)
def three_hours_forecast(self, name):
data = self.request({"path": "/forecast", "query": {"q": name}})
return self.to_forecast(data, "3h")
def daily_forecast(self, name, limit=None):
query = {"q": name}
if limit is not None:
query["cnt"] = limit
data = self.request({"path": "/forecast/daily", "query": query})
return self.to_forecast(data, "daily")
def to_forecast(self, data, interval):
forecast = self.forecast.parse_JSON(data)
if forecast is not None:
forecast.set_interval(interval)
return Forecaster(forecast)
else:
return None
class OWMApi(Api):
''' Wrapper that defaults to the Mycroft cloud proxy so user's don't need
to get their own OWM API keys '''
def __init__(self):
super(OWMApi, self).__init__("owm")
self.owmlang = "en"
self.encoding = "utf8"
self.observation = ObservationParser()
self.forecast = ForecastParser()
def build_query(self, params):
params.get("query").update({"lang": self.owmlang})
return params.get("query")
def get_data(self, response):
return response.text
def weather_at_place(self, name, lat, lon):
if lat and lon:
q = {"lat": lat, "lon": lon}
else:
q = {"q": name}
data = self.request({
"path": "/weather",
"query": q
})
return self.observation.parse_JSON(data)
def three_hours_forecast(self, name, lat, lon):
if lat and lon:
q = {"lat": lat, "lon": lon}
else:
q = {"q": name}
data = self.request({
"path": "/forecast",
"query": q
})
return self.to_forecast(data, "3h")
def daily_forecast(self, name, lat, lon, limit=None):
if lat and lon:
q = {"lat": lat, "lon": lon}
else:
q = {"q": name}
if limit is not None:
q["cnt"] = limit
data = self.request({
"path": "/forecast/daily",
"query": q
})
return self.to_forecast(data, "daily")
def to_forecast(self, data, interval):
forecast = self.forecast.parse_JSON(data)
if forecast is not None:
forecast.set_interval(interval)
return Forecaster(forecast)
else:
return None
def set_OWM_language(self, lang):
self.owmlang = lang
# Certain OWM condition information is encoded using non-utf8
# encodings. If another language needs similar solution add them to the
# encodings dictionary
encodings = {
'se': 'latin1'
}
self.encoding = encodings.get(lang, 'utf8')
class OWMApi(Api):
''' Wrapper that defaults to the Mycroft cloud proxy so user's don't need
to get their own OWM API keys '''
def __init__(self):
super(OWMApi, self).__init__("owm")
self.lang = "en"
self.observation = ObservationParser()
self.forecast = ForecastParser()
def build_query(self, params):
params.get("query").update({"lang": self.lang})
return params.get("query")
def get_data(self, response):
return response.text
def weather_at_place(self, name, lat, lon):
if lat and lon:
q = {"lat": lat, "lon": lon}
else:
q = {"q": name}
data = self.request({
"path": "/weather",
"query": q
})
return self.observation.parse_JSON(data)
def three_hours_forecast(self, name, lat, lon):
if lat and lon:
q = {"lat": lat, "lon": lon}
else:
q = {"q": name}
data = self.request({
"path": "/forecast",
"query": q
})
return self.to_forecast(data, "3h")
def daily_forecast(self, name, lat, lon, limit=None):
if lat and lon:
q = {"lat": lat, "lon": lon}
else:
q = {"q": name}
if limit is not None:
q["cnt"] = limit
data = self.request({
"path": "/forecast/daily",
"query": q
})
return self.to_forecast(data, "daily")
def to_forecast(self, data, interval):
forecast = self.forecast.parse_JSON(data)
if forecast is not None:
forecast.set_interval(interval)
return Forecaster(forecast)
else:
return None