def handle(self, *args, **options):
req = http.request('GET', url)
json_dat = json.loads(req.data.decode())
new_weather = Weather(date=datetime.fromtimestamp(json_dat['dt']),
wind_speed=json_dat['wind']['speed'],
temp=json_dat['main']['temp'],
humidity=json_dat['main']['humidity'],
pressure=json_dat['main']['pressure'])
new_weather.save()
print(new_weather)
def get_weather_forecast_5d_3h(self):
"""Retrieves the 5 days 3 hour weather forecast"""
weather_data = _client.get_weather_forecast_5d_3h()
try:
Weather.create(created_date=to_utc_datetime(),
data=weather_data,
data_source=1,
weather_forecast_type=Forecast.FIVE_DAYS_THREE_HOUR)
return HTTPStatus.CREATED
except BaseException:
raise
def get_current_weather(self):
"""Retrieves the current weather data"""
weather_data = _client.get_current_weather()
try:
Weather.create(created_date=to_utc_datetime(),
data=weather_data,
data_source=1,
weather_forecast_type=Forecast.HOURLY)
return HTTPStatus.CREATED
except BaseException:
raise
def test_get_or_create_existing_id(self):
activity = Weather.get_or_create(id=5,
title="Titl 499",
description="Full Desc")
self.assertEqual(activity.id, 5)
self.assertEqual(activity.title, "Titl")
self.assertEqual(activity.description, "Desc")
def test_get_or_create_create(self):
activity = Weather.get_or_create(id=499,
title="Titl 499",
description="Full Desc")
self.assertEqual(activity.id, 499)
self.assertEqual(activity.title, "Titl 499")
self.assertEqual(activity.description, "Full Desc")
def test_get_or_create_get(self):
activity = Weather.get_or_create(id=5,
title="Titl",
description="Desc")
self.assertEqual(activity.id, 5)
self.assertEqual(activity.title, "Titl")
self.assertEqual(activity.description, "Desc")
def _retrieve_data(data_source_id: int = 2):
from api.models import DataSourceData, Weather, Forecast
from playhouse.shortcuts import model_to_dict
from api.helpers.data_frame_helper import (flatten_json_data_in_column,
filter_column_json_data)
data_source_data_df = DataFrame(
list(DataSourceData.select().where(
DataSourceData.data_source_id == data_source_id).dicts()))
# floors the seconds to 0, move it to the server function so that the user can
# interact with it.
data_source_data_df['created_date'] = data_source_data_df['created_date'].map(
lambda x: x.replace(second=0))
hourly_weather_query = Weather.select().where(
Weather.weather_forecast_type == Forecast.HOURLY)
hourly_filter = "{dt: dt, weather: {main: weather[0].main,"\
"description: weather[0].description}, main: main, wind: wind"\
", rain: rain, clouds: clouds}"
hourly_weather_array = []
for weather in hourly_weather_query:
hourly_weather_array.append(model_to_dict(weather, recurse=False))
hourly_weater_df = DataFrame(hourly_weather_array)
hourly_weater_df = filter_column_json_data(hourly_weater_df, 'data',
hourly_filter)
hourly_weater_df = flatten_json_data_in_column(hourly_weater_df, 'data')
return {
"data_source_data_df": data_source_data_df,
"hourly_weather_data_df": hourly_weater_df
}
def update_forecast():
json = get_weather_json()
if json is not None:
try:
city = None
city = City.objects.get(city_id=json['id'])
new_weather = Weather()
new_weather.temp = json['main']['temp']
new_weather.wind_speed = json['wind']['speed']
new_weather.humidity = json['main']['humidity']
new_weather.pressure = json['main']['pressure']
new_weather.city = city
new_weather.save()
print("saving...", new_weather)
return new_weather
except Exception as e:
print("Error: ", e)
return None
def test_get_or_create_empty_id(self):
none_activity = Weather.get_or_create()
self.assertIsNone(none_activity)
none_activity = Weather.get_or_create(id=5)
self.assertIsNone(none_activity)
none_activity = Weather.get_or_create(id=5, title="Titl")
self.assertIsNone(none_activity)
none_activity = Weather.get_or_create(id=15, title="Titl")
self.assertIsNone(none_activity)
none_activity = Weather.get_or_create(title="Titl")
self.assertIsNone(none_activity)
none_activity = Weather.get_or_create(description="Desc")
self.assertIsNone(none_activity)
none_activity = Weather.get_or_create(title="Titl", description="Desc")
self.assertIsNone(none_activity)
def retrieve_all_weather_data(self, limit: int, start_date: str,
end_date: str, order_by: str, sort: str,
forecast_type: str):
"""Retrieves all weather data
Arguments:
limit {int} -- limits the number of results
start_date {str} -- start date
end_date {str} -- end date
order_by {str} -- order result by given key
sort {str} -- sorts the data in ascending or descending order
forecast_type {str} -- forecast type
Returns:
WeatherData -- An array of all weather data
"""
all_data_array = []
obj_attributes = filter_items_from_list(dir(Weather), '^__')
order_by_field = Weather
query = Weather.select()
# Set defaults
if not limit:
limit = 20
if not order_by:
order_by = 'id'
if not sort:
sort = 'desc'
if start_date:
try:
validate_dateformat('start_date', start_date)
query = query.where(Weather.created_date >= start_date)
except ValueError as err:
raise ValueError(HTTPStatus.BAD_REQUEST,
str(err))
if end_date:
try:
validate_dateformat('end_date', end_date)
query = query.where(Weather.created_date <= end_date)
except ValueError as err:
raise ValueError(HTTPStatus.BAD_REQUEST,
str(err))
if order_by.strip().lower() in obj_attributes:
order_by_field = getattr(Weather, order_by.strip().lower())
else:
raise ValueError(HTTPStatus.BAD_REQUEST,
f'Field {order_by.strip().lower()} does not exist')
if sort.lower() in _ALLOWED_SORT_VALUES:
if sort.lower() == _ALLOWED_SORT_VALUES[0]:
query = query.order_by(order_by_field.asc())
else:
query = query.order_by(order_by_field.desc())
else:
raise ValueError(
HTTPStatus.BAD_REQUEST,
'Invalid sort value, only "asc" or "desc" are allowed')
try:
casted_limit = int(limit)
except ValueError:
raise ValueError(
HTTPStatus.BAD_REQUEST,
'Invalid limit value, only values of type <int> are allowed')
query = query.limit(casted_limit)
if forecast_type == 'hourly':
query = query.where(Weather.weather_forecast_type == 'HOURLY')
elif forecast_type == 'weekly':
query = query.where(
Weather.weather_forecast_type == 'FIVE_DAYS_THREE_HOUR')
try:
for result in query:
result.data = json.loads(result.data) # escapes json data
all_data_array.append(model_to_dict(result, recurse=False))
return all_data_array
except BaseException:
raise