class MockHttpClientMeasurements(HttpClient):
msmt1 = Measurement('test_station', 1378459200,
temperature=dict(min=0, max=100), wind_speed=2.1, wind_gust=67,
humidex=77, weather_other=dict(key='val1'))
msmt2 = Measurement('test_station', 1878459999,
temperature=dict(min=20, max=180), wind_speed=0.7, wind_gust=-7,
humidex=12, weather_other=dict(key='val2'))
aggr_msmt1 = AggregatedMeasurement('id1', 1200, 'd', temp=dict(max=9,min=1),
precipitation=dict(min=8.2, max=44.8))
aggr_msmt2 = AggregatedMeasurement('id1', 1500, 'd', temp=dict(max=8,min=-2))
aggr_msmt3 = AggregatedMeasurement('id1', 3000, 'd', temp=dict(max=9,min=0))
def get_json(self, uri, params=None, headers=None):
items = [self.aggr_msmt1.to_dict(),
self.aggr_msmt2.to_dict(),
self.aggr_msmt3.to_dict()]
for i in items:
i['date'] = i['timestamp']
i['type'] = i['aggregated_on']
del i['timestamp']
del i['aggregated_on']
# filter on time-windos
new_items = []
for i in items:
if params['from'] <= i['date'] <= params['to']:
new_items.append(i)
# check optional limit
if 'limit' in params:
return 200, new_items[:params['limit']]
return 200, new_items
def post(self, uri, params=None, data=None, headers=None):
return 200, ''
def test_assertions_on_instantation(self):
with self.assertRaises(AssertionError):
AggregatedMeasurement(None, self.ts, 'h', temp=None, humidity=None,
wind=None, pressure=None, precipitation=None)
with self.assertRaises(AssertionError):
AggregatedMeasurement('test', None, 'h', temp=None, humidity=None,
wind=None, pressure=None, precipitation=None)
with self.assertRaises(AssertionError):
AggregatedMeasurement('test', '1234', 'h', temp=None, humidity=None,
wind=None, pressure=None, precipitation=None)
with self.assertRaises(AssertionError):
AggregatedMeasurement('test', -123, 'h', temp=None, humidity=None,
wind=None, pressure=None, precipitation=None)
with self.assertRaises(AssertionError):
AggregatedMeasurement('test', self.ts, None, temp=None, humidity=None,
wind=None, pressure=None, precipitation=None)
def parse_JSON(self, JSON_string):
"""
Parses a *pyowm.stationsapi30.measurement.AggregatedMeasurement*
instance out of raw JSON data.
:param JSON_string: a raw JSON string
:type JSON_string: str
:return: a *pyowm.stationsapi30.measurement.AggregatedMeasurement*
instance or ``None`` if no data is available
:raises: *ParseResponseError* if it is impossible to find or parse the
data needed to build the result
"""
if JSON_string is None:
raise parse_response_error.ParseResponseError('JSON data is None')
d = json.loads(JSON_string)
station_id = d.get('station_id', None)
ts = d.get('date', None)
if ts is not None:
ts = int(ts)
aggregated_on = d.get('type', None)
temp = d.get('temp', dict())
humidity = d.get('humidity', dict())
wind = d.get('wind', dict())
pressure = d.get('pressure', dict())
precipitation = d.get('precipitation', dict())
return AggregatedMeasurement(station_id,
ts,
aggregated_on,
temp=temp,
humidity=humidity,
wind=wind,
pressure=pressure,
precipitation=precipitation)
def test_aggregated_on_with_wrong_values(self):
with self.assertRaises(ValueError):
wrong = 'xyz'
AggregatedMeasurement('mytest', self.ts, wrong,
temp=dict(min=0, max=100),
humidity=dict(min=10, max=110),
wind=dict(speed=2.1, gust=67),
pressure=None,
precipitation=None)
class TestAggregatedMeasurementParser(unittest.TestCase):
test_msmt_json = '''{"station_id": "mytest","date": 123456789,
"type": "m",
"temp": {"min": 0, "max": 100},
"humidity": {"min": 10, "max": 110},
"wind": {"speed": 2.1, "gust": 67},
"pressure": {},
"precipitation": {}}
'''
test_msmt = AggregatedMeasurement('mytest',
123456789,
'm',
temp=dict(min=0, max=100),
humidity=dict(min=10, max=110),
wind=dict(speed=2.1, gust=67),
pressure=None,
precipitation=None)
def test_parse_JSON(self):
instance = AggregatedMeasurementParser()
result = instance.parse_JSON(self.test_msmt_json)
self.assertTrue(isinstance(result, AggregatedMeasurement))
self.assertEqual(self.test_msmt.station_id, result.station_id)
self.assertEqual(self.test_msmt.timestamp, result.timestamp)
self.assertEqual(self.test_msmt.aggregated_on, result.aggregated_on)
self.assertEqual(self.test_msmt.temp, result.temp)
self.assertEqual(self.test_msmt.humidity, result.humidity)
self.assertEqual(self.test_msmt.wind, result.wind)
self.assertEqual(self.test_msmt.pressure, result.pressure)
self.assertEqual(self.test_msmt.precipitation, result.precipitation)
def test_parse_JSON_fails_with_none_input(self):
instance = AggregatedMeasurementParser()
with self.assertRaises(parse_response_error.ParseResponseError):
instance.parse_JSON(None)
def test_parse_dict(self):
data_dict = json.loads(self.test_msmt_json)
instance = AggregatedMeasurementParser()
result = instance.parse_dict(data_dict)
self.assertTrue(isinstance(result, AggregatedMeasurement))
self.assertEqual(self.test_msmt.station_id, result.station_id)
self.assertEqual(self.test_msmt.timestamp, result.timestamp)
self.assertEqual(self.test_msmt.aggregated_on, result.aggregated_on)
self.assertEqual(self.test_msmt.temp, result.temp)
self.assertEqual(self.test_msmt.humidity, result.humidity)
self.assertEqual(self.test_msmt.wind, result.wind)
self.assertEqual(self.test_msmt.pressure, result.pressure)
self.assertEqual(self.test_msmt.precipitation, result.precipitation)
def test_parse_dict_fails_with_wrong_input(self):
instance = AggregatedMeasurementParser()
with self.assertRaises(AssertionError):
instance.parse_dict(1234)
def get_measurements(self,
station_id,
aggregated_on,
from_timestamp,
to_timestamp,
limit=100):
"""
Reads measurements of a specified station recorded in the specified time
window and aggregated on minute, hour or day. Optionally, the number of
resulting measurements can be limited.
:param station_id: unique station identifier
:type station_id: str
:param aggregated_on: aggregation time-frame for this measurement
:type aggregated_on: string between 'm','h' and 'd'
:param from_timestamp: Unix timestamp corresponding to the beginning of
the time window
:type from_timestamp: int
:param to_timestamp: Unix timestamp corresponding to the end of the
time window
:type to_timestamp: int
:param limit: max number of items to be returned. Defaults to 100
:type limit: int
:returns: list of *pyowm.stationsapi30.measurement.AggregatedMeasurement*
objects
"""
assert station_id is not None
assert aggregated_on is not None
assert from_timestamp is not None
assert from_timestamp > 0
assert to_timestamp is not None
assert to_timestamp > 0
if to_timestamp < from_timestamp:
raise ValueError(
"End timestamp can't be earlier than begin timestamp")
assert isinstance(limit, int)
assert limit >= 0
query = {
'appid': self.API_key,
'station_id': station_id,
'type': aggregated_on,
'from': from_timestamp,
'to': to_timestamp,
'limit': limit
}
status, data = self.http_client.get_json(
MEASUREMENTS_URI,
params=query,
headers={'Content-Type': 'application/json'})
return [AggregatedMeasurement.from_dict(item) for item in data]
def test_from_dict(self):
the_dict = {
"station_id": "mytest",
"date": 123456789,
"type": "m",
"temp": {
"min": 0,
"max": 100
},
"humidity": {
"min": 10,
"max": 110
},
"wind": {
"speed": 2.1,
"gust": 67
},
"pressure": {},
"precipitation": {}
}
expected = AggregatedMeasurement('mytest',
123456789,
'm',
temp=dict(min=0, max=100),
humidity=dict(min=10, max=110),
wind=dict(speed=2.1, gust=67),
pressure=None,
precipitation=None)
result = AggregatedMeasurement.from_dict(the_dict)
self.assertTrue(isinstance(result, AggregatedMeasurement))
self.assertEqual(expected.station_id, result.station_id)
self.assertEqual(expected.timestamp, result.timestamp)
self.assertEqual(expected.aggregated_on, result.aggregated_on)
self.assertEqual(expected.temp, result.temp)
self.assertEqual(expected.humidity, result.humidity)
self.assertEqual(expected.wind, result.wind)
self.assertEqual(expected.pressure, result.pressure)
self.assertEqual(expected.precipitation, result.precipitation)
with self.assertRaises(pyowm.commons.exceptions.ParseAPIResponseError):
AggregatedMeasurement.from_dict(None)
with self.assertRaises(AssertionError):
none_timestamp = copy.deepcopy(the_dict)
none_timestamp['date'] = None
AggregatedMeasurement.from_dict(none_timestamp)
class TestAggregatedMeasurement(unittest.TestCase):
ts = 1378459200
iso_ts = "2013-09-06 09:20:00+00"
date_ts = dt.strptime(iso_ts, '%Y-%m-%d %H:%M:%S+00').replace(tzinfo=UTC())
_test_instance = AggregatedMeasurement('mytest', ts, 'm',
temp=dict(min=0, max=100),
humidity=dict(min=10, max=110),
wind=dict(speed=2.1, gust=67),
pressure=None,
precipitation=None)
def test_assertions_on_instantation(self):
with self.assertRaises(AssertionError):
AggregatedMeasurement(None, self.ts, 'h', temp=None, humidity=None,
wind=None, pressure=None, precipitation=None)
with self.assertRaises(AssertionError):
AggregatedMeasurement('test', None, 'h', temp=None, humidity=None,
wind=None, pressure=None, precipitation=None)
with self.assertRaises(AssertionError):
AggregatedMeasurement('test', '1234', 'h', temp=None, humidity=None,
wind=None, pressure=None, precipitation=None)
with self.assertRaises(AssertionError):
AggregatedMeasurement('test', -123, 'h', temp=None, humidity=None,
wind=None, pressure=None, precipitation=None)
with self.assertRaises(AssertionError):
AggregatedMeasurement('test', self.ts, None, temp=None, humidity=None,
wind=None, pressure=None, precipitation=None)
def test_aggregated_on_with_wrong_values(self):
with self.assertRaises(ValueError):
wrong = 'xyz'
AggregatedMeasurement('mytest', self.ts, wrong,
temp=dict(min=0, max=100),
humidity=dict(min=10, max=110),
wind=dict(speed=2.1, gust=67),
pressure=None,
precipitation=None)
def test_creation_time(self):
result = self._test_instance.creation_time()
self.assertEqual(self.ts, result)
result = self._test_instance.creation_time(timeformat='iso')
self.assertEqual(self.iso_ts, result)
result = self._test_instance.creation_time(timeformat='date')
self.assertEqual(self.date_ts, result)
with self.assertRaises(ValueError):
self._test_instance.creation_time(timeformat='unknown')
def test_to_dict(self):
expected_dict = {
"station_id": "mytest",
"timestamp": 1378459200,
"aggregated_on": "m",
"temp":{"min": 0, "max": 100},
"humidity": {"min": 10, "max": 110},
"wind": {"speed": 2.1,"gust": 67},
"pressure": {},
"precipitation": {}}
result_dict = self._test_instance.to_dict()
self.assertTrue(all(item in result_dict.items()
for item in expected_dict.items()))
def test_to_JSON(self):
expected = '''
{"station_id": "mytest",
"timestamp": 1378459200,
"aggregated_on": "m",
"temp":{"min":0, "max": 100},
"humidity":{"min":10, "max": 110},
"wind":{"speed":2.1,"gust":67},
"pressure":{}, "precipitation":{}}
'''
result = self._test_instance.to_JSON()
self.assertEquals(json.loads(expected), json.loads(result))
class TestAggregatedMeasurement(unittest.TestCase):
ts = 1378459200
iso_ts = "2013-09-06 09:20:00+00"
date_ts = dt.strptime(iso_ts, '%Y-%m-%d %H:%M:%S+00').replace(tzinfo=UTC())
_test_instance = AggregatedMeasurement('mytest', ts, 'm',
temp=dict(min=0, max=100),
humidity=dict(min=10, max=110),
wind=dict(speed=2.1, gust=67),
pressure=None,
precipitation=None)
def test_assertions_on_instantation(self):
with self.assertRaises(AssertionError):
AggregatedMeasurement(None, self.ts, 'h', temp=None, humidity=None,
wind=None, pressure=None, precipitation=None)
with self.assertRaises(AssertionError):
AggregatedMeasurement('test', None, 'h', temp=None, humidity=None,
wind=None, pressure=None, precipitation=None)
with self.assertRaises(AssertionError):
AggregatedMeasurement('test', '1234', 'h', temp=None, humidity=None,
wind=None, pressure=None, precipitation=None)
with self.assertRaises(AssertionError):
AggregatedMeasurement('test', -123, 'h', temp=None, humidity=None,
wind=None, pressure=None, precipitation=None)
with self.assertRaises(AssertionError):
AggregatedMeasurement('test', self.ts, None, temp=None, humidity=None,
wind=None, pressure=None, precipitation=None)
def test_aggregated_on_with_wrong_values(self):
with self.assertRaises(ValueError):
wrong = 'xyz'
AggregatedMeasurement('mytest', self.ts, wrong,
temp=dict(min=0, max=100),
humidity=dict(min=10, max=110),
wind=dict(speed=2.1, gust=67),
pressure=None,
precipitation=None)
def test_creation_time(self):
result = self._test_instance.creation_time()
self.assertEqual(self.ts, result)
result = self._test_instance.creation_time(timeformat='iso')
self.assertEqual(self.iso_ts, result)
result = self._test_instance.creation_time(timeformat='date')
self.assertEqual(self.date_ts, result)
with self.assertRaises(ValueError):
self._test_instance.creation_time(timeformat='unknown')
test_instance_none_timestamp = copy.deepcopy(self._test_instance)
test_instance_none_timestamp.timestamp = None
self.assertIsNone(test_instance_none_timestamp.creation_time())
def test_from_dict(self):
the_dict = {
"station_id": "mytest",
"date": 123456789,
"type": "m",
"temp":{"min": 0, "max": 100},
"humidity": {"min": 10, "max": 110},
"wind": {"speed": 2.1,"gust": 67},
"pressure": {},
"precipitation": {}}
expected = AggregatedMeasurement('mytest', 123456789, 'm',
temp=dict(min=0, max=100),
humidity=dict(min=10, max=110),
wind=dict(speed=2.1, gust=67),
pressure=None,
precipitation=None)
result = AggregatedMeasurement.from_dict(the_dict)
self.assertTrue(isinstance(result, AggregatedMeasurement))
self.assertEqual(expected.station_id, result.station_id)
self.assertEqual(expected.timestamp, result.timestamp)
self.assertEqual(expected.aggregated_on, result.aggregated_on)
self.assertEqual(expected.temp, result.temp)
self.assertEqual(expected.humidity, result.humidity)
self.assertEqual(expected.wind, result.wind)
self.assertEqual(expected.pressure, result.pressure)
self.assertEqual(expected.precipitation, result.precipitation)
with self.assertRaises(pyowm.commons.exceptions.ParseAPIResponseError):
AggregatedMeasurement.from_dict(None)
with self.assertRaises(AssertionError):
none_timestamp = copy.deepcopy(the_dict)
none_timestamp['date'] = None
AggregatedMeasurement.from_dict(none_timestamp)
def test_to_dict(self):
expected_dict = {
"station_id": "mytest",
"timestamp": 1378459200,
"aggregated_on": "m",
"temp":{"min": 0, "max": 100},
"humidity": {"min": 10, "max": 110},
"wind": {"speed": 2.1,"gust": 67},
"pressure": {},
"precipitation": {}}
result_dict = self._test_instance.to_dict()
self.assertTrue(all(item in result_dict.items()
for item in expected_dict.items()))
