class IntegrationTestsSoilData(unittest.TestCase):
__owm = owm.OWM(os.getenv('OWM_API_KEY', None))
def test_call_soil_data(self):
mgr = self.__owm.agro_manager()
# check if any previous polygon exists on this account
n_old_polygons = len(mgr.get_polygons())
# create pol1
geopol1 = GeoPolygon([[[-121.1958, 37.6683], [-121.1779, 37.6687],
[-121.1773, 37.6792], [-121.1958, 37.6792],
[-121.1958, 37.6683]]])
test_pol = mgr.create_polygon(geopol1, 'soil_data_test_pol')
soil = mgr.soil_data(test_pol)
self.assertTrue(isinstance(soil, Soil))
self.assertEqual(test_pol.id, soil.polygon_id)
# Delete test polygon
mgr.delete_polygon(test_pol)
polygons = mgr.get_polygons()
self.assertEqual(n_old_polygons, len(polygons))
class TesIntegrationTileManager(unittest.TestCase):
__owm = owm.OWM(os.getenv('OWM_API_KEY', None))
def test_tiles_fetch(self):
mgr = self.__owm.tile_manager(MapLayerEnum.PRECIPITATION)
tile = mgr.get_tile(3, 6, 7)
self.assertIsInstance(tile, Tile)
class IntegrationTestsPollutionAPI30(unittest.TestCase):
__owm = owm.OWM(os.getenv('OWM_API_KEY', None)).airpollution_manager()
def test_coindex_around_coords(self):
"""
Test feature: get CO index around geo-coordinates.
"""
u = self.__owm.coindex_around_coords(45, 9)
self.assertIsNotNone(u)
self.assertIsNotNone(u.co_samples)
self.assertIsNotNone(u.reception_time())
self.assertIsNotNone(u.reference_time())
self.assertIsNone(u.interval)
self.assertIsNotNone(u.location)
def test_ozone_around_coords(self):
"""
Test feature: get ozone around geo-coordinates.
"""
u = self.__owm.ozone_around_coords(0.0,
10.0,
start='2016-12-31 12:55:55+00:00')
self.assertIsNotNone(u)
self.assertIsNotNone(u.du_value)
self.assertIsNotNone(u.reception_time())
self.assertIsNotNone(u.reference_time())
self.assertIsNone(u.interval)
self.assertIsNotNone(u.location)
def test_no2index_around_coords(self):
"""
Test feature: get NO2 index around geo-coordinates.
"""
u = self.__owm.no2index_around_coords(
0.0, 10.0, start='2016-12-31 12:55:55+00:00')
self.assertIsNotNone(u)
self.assertIsNotNone(u.no2_samples)
self.assertIsNotNone(u.reception_time())
self.assertIsNotNone(u.reference_time())
self.assertIsNone(u.interval)
self.assertIsNotNone(u.location)
def test_so2index_around_coords(self):
"""
Test feature: get SO2 index around geo-coordinates.
"""
u = self.__owm.so2index_around_coords(
0.0, 10.0, start='2016-12-31 12:55:55+00:00')
self.assertIsNotNone(u)
self.assertIsNotNone(u.so2_samples)
self.assertIsNotNone(u.reception_time())
self.assertIsNotNone(u.reference_time())
self.assertIsNone(u.interval)
self.assertIsNotNone(u.location)
class IntegrationTestsPollutionAPI30(unittest.TestCase):
__owm = owm.OWM(os.getenv('OWM_API_KEY', None)).airpollution_manager()
def test_air_quality_at_coords(self):
"""
Test feature: get all air quality data around geo-coordinates.
"""
airstatus = self.__owm.air_quality_at_coords(45, 9)
self.assertIsNotNone(airstatus)
self.assertIsNotNone(airstatus.air_quality_data)
self.assertIsNotNone(airstatus.reception_time())
self.assertIsNotNone(airstatus.reference_time())
self.assertIsNotNone(airstatus.location)
def test_air_quality_forecast_at_coords(self):
"""
Test feature: get all forecasted air quality data around geo-coordinates.
"""
list_of_airstatuses = self.__owm.air_quality_forecast_at_coords(45, 9)
self.assertTrue(list_of_airstatuses)
for airstatus in list_of_airstatuses:
self.assertIsNotNone(airstatus.air_quality_data)
self.assertIsNotNone(airstatus.reception_time())
self.assertIsNotNone(airstatus.reference_time())
self.assertIsNotNone(airstatus.location)
def test_air_quality_history_at_coords(self):
"""
Test feature: get historical air quality data around geo-coordinates.
"""
start = 1606223802 # Tuesday, November 24, 2020
list_of_airstatuses = self.__owm.air_quality_history_at_coords(
45, 9, start)
self.assertIsInstance(list_of_airstatuses, list)
for airstatus in list_of_airstatuses:
self.assertIsNotNone(airstatus.air_quality_data)
self.assertIsNotNone(airstatus.reception_time())
self.assertIsNotNone(airstatus.reference_time())
self.assertIsNotNone(airstatus.location)
class IntegrationTestsGeocodingAPI(unittest.TestCase):
__owm = owm.OWM(os.getenv('OWM_API_KEY', None))
def test_geocode(self):
mgr = self.__owm.geocoding_manager()
# Geocode all Paris in the United States
locations = mgr.geocode('Paris', 'US')
self.assertTrue(isinstance(locations, list))
self.assertTrue(all([isinstance(l, Location) for l in locations]))
self.assertTrue(all([l.name == 'Paris' and l.country == 'US' for l in locations]))
def test_reverse_geocode(self):
mgr = self.__owm.geocoding_manager()
# Reverse geocode the geocoords for Florence (Italy)
locations = mgr.reverse_geocode(43.783731, 11.246603)
self.assertTrue(isinstance(locations, list))
self.assertTrue(all([isinstance(l, Location) for l in locations]))
self.assertTrue(all([l.name == 'Firenze' and l.country == 'IT' for l in locations]))
class IntegrationTestsUVIndexAPI30(unittest.TestCase):
__owm = owm.OWM(os.getenv('OWM_API_KEY', None)).uvindex_manager()
def test_uvindex_around_coords(self):
"""
Test feature: get UV index around geo-coordinates.
"""
u = self.__owm.uvindex_around_coords(45, 9)
self.assertIsNotNone(u)
self.assertIsNotNone(u.value)
self.assertIsNotNone(u.reception_time())
self.assertIsNotNone(u.location)
def test_uvindex_forecast_around_coords(self):
"""
Test feature: get UV index forecast around geo-coordinates.
"""
uv_list = self.__owm.uvindex_forecast_around_coords(45, 9)
self.assertIsInstance(uv_list, list)
for item in uv_list:
self.assertIsNotNone(item.value)
self.assertIsNotNone(item.reception_time())
self.assertIsNotNone(item.location)
def test_uvindex_history_around_coords(self):
"""
Test feature: get UV index history around geo-coordinates.
"""
start = datetime(2017, 6, 21)
end = datetime(2017, 6, 27)
uv_list = self.__owm.uvindex_history_around_coords(37.7,
-122.37,
start,
end=end)
self.assertIsInstance(uv_list, list)
for item in uv_list:
self.assertIsNotNone(item.value)
self.assertIsNotNone(item.reception_time())
self.assertIsNotNone(item.location)
class IntegrationTestsWebAPI25(unittest.TestCase):
__owm = owm.OWM(os.getenv('OWM_API_KEY', None)).weather_manager()
def test_weather_at_place(self):
"""
Test feature: get currently observed weather at specific location
"""
o1 = self.__owm.weather_at_place('London,GB')
o2 = self.__owm.weather_at_place('Kiev')
self.assertTrue(o1 is not None)
self.assertTrue(o1.reception_time() is not None)
loc = o1.location
self.assertTrue(loc is not None)
self.assertTrue(all(v is not None for v in loc.__dict__.values()))
weat = o1.weather
self.assertTrue(weat is not None)
self.assertTrue(o2 is not None)
self.assertTrue(o2.reception_time() is not None)
loc = o2.location
self.assertTrue(loc is not None)
self.assertTrue(all(v is not None for v in loc.__dict__.values()))
weat = o2.weather
self.assertTrue(weat is not None)
def test_weather_at_coords(self):
"""
Test feature: get currently observed weather at specific coordinates
"""
o1 = self.__owm.weather_at_coords(41.896144, 12.484589) # Rome
o2 = self.__owm.weather_at_coords(-33.936524, 18.503723) # Cape Town
self.assertTrue(o1)
self.assertTrue(o1.reception_time())
loc = o1.location
self.assertTrue(loc)
self.assertTrue(all(v is not None for v in loc.__dict__.values()))
weat = o1.weather
self.assertTrue(weat)
self.assertTrue(o2)
self.assertTrue(o2.reception_time())
loc = o2.location
self.assertTrue(loc)
self.assertTrue(all(v is not None for v in loc.__dict__.values()))
weat = o2.weather
self.assertTrue(weat)
def test_weather_at_zipcode(self):
"""
Test feature: get currently observed weather at specific postcode
"""
o1 = self.__owm.weather_at_zip_code("94040", "US")
self.assertTrue(o1)
self.assertTrue(o1.reception_time())
loc = o1.location
self.assertTrue(loc)
self.assertTrue(all(v is not None for v in loc.__dict__.values()))
weat = o1.weather
self.assertTrue(weat)
def test_weather_at_id(self):
o1 = self.__owm.weather_at_id(5128581) # New York
o2 = self.__owm.weather_at_id(703448) # Kiev'
self.assertTrue(o1 is not None)
self.assertTrue(o1.reception_time() is not None)
loc = o1.location
self.assertTrue(loc is not None)
self.assertTrue(all(v is not None for v in loc.__dict__.values()))
weat = o1.weather
self.assertTrue(weat is not None)
self.assertTrue(o2 is not None)
self.assertTrue(o2.reception_time() is not None)
loc = o2.location
self.assertTrue(loc is not None)
self.assertTrue(all(v is not None for v in loc.__dict__.values()))
weat = o2.weather
self.assertTrue(weat is not None)
def test_weather_at_ids(self):
# New York, Kiev
observations = self.__owm.weather_at_ids([5128581, 703448])
o1 = observations[0]
o2 = observations[1]
self.assertTrue(o1 is not None)
self.assertTrue(o1.reception_time() is not None)
loc = o1.location
self.assertTrue(loc is not None)
self.assertTrue(all(v is not None for v in loc.__dict__.values()))
weat = o1.weather
self.assertTrue(weat is not None)
self.assertTrue(o2 is not None)
self.assertTrue(o2.reception_time() is not None)
loc = o2.location
self.assertTrue(loc is not None)
self.assertTrue(all(v is not None for v in loc.__dict__.values()))
weat = o2.weather
self.assertTrue(weat is not None)
def test_weather_at_places(self):
"""
Test feature: find currently observed weather for locations matching
the specified text search pattern
"""
# Test using searchtype=accurate
o1 = self.__owm.weather_at_places("London", "accurate")
o2 = self.__owm.weather_at_places("Paris", "accurate", 2)
self.assertTrue(isinstance(o1, list))
for item in o1:
self.assertTrue(item)
self.assertTrue(item.reception_time())
loc = item.location
self.assertTrue(loc is not None)
self.assertTrue(all(v is not None for v in loc.__dict__.values()))
weat = item.weather
self.assertTrue(weat is not None)
self.assertTrue(isinstance(o2, list))
self.assertFalse(len(o2) > 2)
for item in o2:
self.assertTrue(item)
self.assertTrue(item.reception_time())
loc = item.location
self.assertTrue(loc is not None)
self.assertTrue(all(v is not None for v in loc.__dict__.values()))
weat = item.weather
self.assertTrue(weat is not None)
# Test using searchtype=like
o3 = self.__owm.weather_at_places("London", "like")
o4 = self.__owm.weather_at_places("Paris", "like", 2)
self.assertTrue(isinstance(o3, list))
for item in o3:
self.assertTrue(item)
self.assertTrue(item.reception_time())
loc = item.location
self.assertTrue(loc is not None)
self.assertTrue(all(v is not None for v in loc.__dict__.values()))
weat = item.weather
self.assertTrue(weat is not None)
self.assertTrue(isinstance(o4, list))
self.assertFalse(len(o4) > 2)
for item in o4:
self.assertTrue(item)
self.assertTrue(item.reception_time())
loc = item.location
self.assertTrue(loc is not None)
self.assertTrue(all(v is not None for v in loc.__dict__.values()))
weat = item.weather
self.assertTrue(weat is not None)
def test_weather_around_coords(self):
"""
Test feature: find currently observed weather for locations that are
nearby the specified coordinates
"""
o2 = self.__owm.weather_around_coords(57.0, -2.15) # Scotland
self.assertTrue(isinstance(o2, list))
for item in o2:
self.assertTrue(item is not None)
self.assertTrue(item.reception_time() is not None)
loc = item.location
self.assertTrue(loc is not None)
self.assertTrue(all(v is not None for v in loc.__dict__.values()))
weat = item.weather
self.assertTrue(weat is not None)
o1 = self.__owm.weather_around_coords(57.0, -2.15, 2) # Scotland
self.assertTrue(isinstance(o1, list))
for item in o1:
self.assertTrue(item is not None)
self.assertTrue(item.reception_time() is not None)
loc = item.location
self.assertTrue(loc is not None)
self.assertTrue(all(v is not None for v in loc.__dict__.values()))
weat = item.weather
self.assertTrue(weat is not None)
def test_forecast_at_place_on_3h(self):
"""
Test feature: get 3 hours forecast for a specific location
"""
fc1 = self.__owm.forecast_at_place("London,GB", "3h")
fc2 = self.__owm.forecast_at_place('Kiev', "3h")
self.assertTrue(fc1)
f1 = fc1.forecast
self.assertTrue(f1 is not None)
self.assertTrue(f1.reception_time() is not None)
loc = f1.location
self.assertTrue(loc is not None)
self.assertTrue(all(v is not None for v in loc.__dict__.values()))
for weather in f1:
self.assertTrue(weather is not None)
self.assertTrue(fc2 is not None)
f2 = fc2.forecast
self.assertTrue(f2 is not None)
self.assertTrue(f2.reception_time() is not None)
loc = f2.location
self.assertTrue(loc is not None)
self.assertTrue(all(v is not None for v in loc.__dict__.values()))
for weather in f2:
self.assertTrue(weather is not None)
def test_forecast_at_coords_on_3h(self):
"""
Test feature: get 3 hours forecast at a specific geographic coordinate
"""
# London,uk
fc1 = self.__owm.forecast_at_coords(51.5073509, -0.1277583, "3h")
# Kiev
fc2 = self.__owm.forecast_at_coords(50.4501, 30.5234, "3h")
self.assertTrue(fc1)
f1 = fc1.forecast
self.assertTrue(f1 is not None)
self.assertTrue(f1.reception_time() is not None)
loc = f1.location
self.assertTrue(loc is not None)
self.assertTrue(all(v is not None for v in loc.__dict__.values()))
for weather in f1:
self.assertTrue(weather is not None)
self.assertTrue(fc2 is not None)
f2 = fc2.forecast
self.assertTrue(f2 is not None)
self.assertTrue(f2.reception_time() is not None)
loc = f2.location
self.assertTrue(loc is not None)
self.assertTrue(all(v is not None for v in loc.__dict__.values()))
for weather in f2:
self.assertTrue(weather is not None)
with self.assertRaises(ValueError):
self.__owm.forecast_at_coords(199, 199, '3h')
def test_forecast_at_id_on_3h(self):
"""
Test feature: get 3 hours forecast for city ID
"""
# London,uk
fc1 = self.__owm.forecast_at_id(2643743, '3h')
# Kiev
fc2 = self.__owm.forecast_at_id(703448, '3h')
self.assertTrue(fc1)
f1 = fc1.forecast
self.assertTrue(f1 is not None)
self.assertTrue(f1.reception_time() is not None)
loc = f1.location
self.assertTrue(loc is not None)
self.assertTrue(all(v is not None for v in loc.__dict__.values()))
for weather in f1:
self.assertTrue(weather is not None)
self.assertTrue(fc2 is not None)
f2 = fc2.forecast
self.assertTrue(f2 is not None)
self.assertTrue(f2.reception_time() is not None)
loc = f2.location
self.assertTrue(loc is not None)
self.assertTrue(all(v is not None for v in loc.__dict__.values()))
for weather in f2:
self.assertTrue(weather is not None)
# Unexistent
try:
fc3 = self.__owm.forecast_at_id(99999999999999, '3h')
self.fail()
except pyowm.commons.exceptions.NotFoundError:
pass # ok
def forecast_at_place_daily(self):
"""
Test feature: get daily forecast for a specific location
"""
fc1 = self.__owm.forecast_at_place("London,GB", "daily")
fc2 = self.__owm.forecast_at_place('Kiev', "daily")
self.assertTrue(fc1)
f1 = fc1.forecast
f1 = fc1.forecast
self.assertTrue(f1 is not None)
self.assertTrue(f1.reception_time() is not None)
loc = f1.location
self.assertTrue(loc is not None)
self.assertTrue(all(v is not None for v in loc.__dict__.values()))
for weather in f1:
self.assertTrue(weather is not None)
self.assertTrue(fc2 is not None)
f2 = fc2.forecast
self.assertTrue(f2 is not None)
self.assertTrue(f2.reception_time() is not None)
loc = f2.location
self.assertTrue(loc is not None)
self.assertTrue(all(v is not None for v in loc.__dict__.values()))
for weather in f2:
self.assertTrue(weather is not None)
def test_forecast_at_coords_daily(self):
"""
Test feature: get daily forecast at a specific geographic coordinate
"""
fc1 = self.__owm.forecast_at_coords(51.5073509, -0.1277583,
'daily') # London,uk
self.assertTrue(fc1)
f1 = fc1.forecast
self.assertTrue(f1 is not None)
self.assertTrue(f1.reception_time() is not None)
loc = f1.location
self.assertTrue(loc is not None)
self.assertTrue(all(v is not None for v in loc.__dict__.values()))
for weather in f1:
self.assertTrue(weather is not None)
with self.assertRaises(ValueError):
self.__owm.forecast_at_coords(199, 199, 'daily')
def test_forecast_at_id_daily(self):
"""
Test feature: get daily forecast for a specific city ID
"""
# London,uk
fc1 = self.__owm.forecast_at_id(2643743, 'daily')
# Kiev
fc2 = self.__owm.forecast_at_id(703448, 'daily')
try:
fc3 = self.__owm.forecast_at_id(99999999, 'daily')
raise AssertionError("APIRequestError was expected here")
except pyowm.commons.exceptions.NotFoundError:
pass # Ok!
self.assertTrue(fc1)
f1 = fc1.forecast
self.assertTrue(f1 is not None)
self.assertTrue(f1.reception_time() is not None)
loc = f1.location
self.assertTrue(loc is not None)
self.assertTrue(all(v is not None for v in loc.__dict__.values()))
for weather in f1:
self.assertTrue(weather is not None)
self.assertTrue(fc2 is not None)
f2 = fc2.forecast
self.assertTrue(f2 is not None)
self.assertTrue(f2.reception_time() is not None)
loc = f2.location
self.assertTrue(loc is not None)
self.assertTrue(all(v is not None for v in loc.__dict__.values()))
for weather in f2:
self.assertTrue(weather is not None)
def test_station_tick_history(self):
"""
Test feature: get station tick weather history for a specific
meteostation
"""
try:
h1 = self.__owm.station_tick_history(39276)
if h1 is not None:
sh1 = h1.station_history
self.assertTrue(sh1 is not None)
data1 = sh1.measurements
self.assertTrue(data1 is not None)
self.assertFalse(0, len(data1))
h2 = self.__owm.station_tick_history(39276, limit=2)
self.assertTrue(h2 is not None)
sh2 = h2.station_history
self.assertTrue(sh2 is not None)
data2 = sh2.measurements
self.assertTrue(data2 is not None)
self.assertFalse(len(data2) > 2)
h3 = self.__owm.station_tick_history(987654) # Shall be None
self.assertFalse(h3 is not None)
except pyowm.commons.exceptions.UnauthorizedError:
pass # it's a paid-level API feature
def test_station_hour_history(self):
"""
Test feature: get station hour weather history for a specific
meteostation
"""
try:
h1 = self.__owm.station_hour_history(123)
if h1 is not None:
sh1 = h1.station_history
self.assertTrue(sh1 is not None)
data1 = sh1.measurements
self.assertTrue(data1 is not None)
self.assertFalse(0, len(data1))
h2 = self.__owm.station_hour_history(987654) # Shall be None
self.assertFalse(h2 is not None)
except pyowm.commons.exceptions.UnauthorizedError:
pass # it's a paid-level API feature
def test_station_day_history(self):
"""
Test feature: get station hour weather history for a specific
meteostation
"""
try:
h1 = self.__owm.station_day_history(123)
if h1 is not None:
sh1 = h1.station_history
self.assertTrue(sh1 is not None)
data1 = sh1.measurements
self.assertTrue(data1 is not None)
self.assertFalse(0, len(data1))
h2 = self.__owm.station_day_history(123, limit=3)
self.assertTrue(h2 is not None)
sh2 = h2.station_history
self.assertTrue(sh2 is not None)
data2 = sh2.measurements
self.assertTrue(data2 is not None)
h3 = self.__owm.station_day_history(987654) # Shall be None
self.assertFalse(h3 is not None)
except pyowm.commons.exceptions.UnauthorizedError:
pass # it's a paid-level API feature
def test_weather_at_places_in_bbox(self):
o = self.__owm.weather_at_places_in_bbox(0.734720, 38.422663, 1.964651,
39.397204, 10, False) # Ibiza
self.assertTrue(isinstance(o, list))
for item in o:
self.assertTrue(item is not None)
self.assertTrue(item.reception_time() is not None)
loc = item.location
self.assertTrue(loc is not None)
weat = item.weather
self.assertTrue(weat is not None)
def test_one_call(self):
result = self.__owm.one_call(lat=46.49, lon=11.33)
self.assertTrue(isinstance(result, OneCall))
self.assertEqual(46.49, result.lat)
self.assertEqual(11.33, result.lon)
self.assertEqual("Europe/Rome", result.timezone)
self.assertTrue(isinstance(result.current, Weather))
self.assertEqual(48, len(result.forecast_hourly))
for i, weather in enumerate(result.forecast_hourly):
self.assertTrue(isinstance(weather, Weather),
f"entry {i} of forecast_hourly is invalid")
self.assertEqual(8, len(result.forecast_daily))
for i, weather in enumerate(result.forecast_daily):
self.assertTrue(isinstance(weather, Weather),
f"entry {i} of forecast_hourly is invalid")
def test_one_call_historical(self):
result = self.__owm.one_call_history(lat=46.49, lon=11.33)
self.assertTrue(isinstance(result, OneCall))
self.assertEqual(46.49, result.lat)
self.assertEqual(11.33, result.lon)
self.assertEqual("Europe/Rome", result.timezone)
self.assertTrue(isinstance(result.current, Weather))
for i, weather in enumerate(result.forecast_hourly):
self.assertTrue(isinstance(weather, Weather),
f"entry {i} of forecast_hourly is invalid")
self.assertEqual(8, len(result.forecast_daily))
for i, weather in enumerate(result.forecast_daily):
self.assertTrue(isinstance(weather, Weather),
f"entry {i} of forecast_hourly is invalid")
class IntegrationTestsPolygonsAPISubset(unittest.TestCase):
__owm = owm.OWM(os.getenv('OWM_API_KEY', None))
def test_polygons_CRUD(self):
mgr = self.__owm.agro_manager()
# check if any previous polygon exists on this account
n_old_polygons = len(mgr.get_polygons())
# create pol1
geopol1 = GeoPolygon([[[-121.1958, 37.6683], [-121.1779, 37.6687],
[-121.1773, 37.6792], [-121.1958, 37.6792],
[-121.1958, 37.6683]]])
pol1 = mgr.create_polygon(geopol1, 'polygon_1')
# create pol2
geopol2 = GeoPolygon([[[-141.1958, 27.6683], [-141.1779, 27.6687],
[-141.1773, 27.6792], [-141.1958, 27.6792],
[-141.1958, 27.6683]]])
pol2 = mgr.create_polygon(geopol2, 'polygon_2')
# Read all
polygons = mgr.get_polygons()
self.assertEqual(n_old_polygons + 2, len(polygons))
self.assertTrue(all([isinstance(p, Polygon) for p in polygons]))
# Read one by one
result = mgr.get_polygon(pol1.id)
self.assertEqual(pol1.id, result.id)
self.assertEqual(pol1.name, pol1.name)
self.assertEqual(pol1.area, result.area)
self.assertEqual(pol1.user_id, result.user_id)
self.assertEqual(pol1.center.lon, result.center.lon)
self.assertEqual(pol1.center.lat, result.center.lat)
self.assertEqual(pol1.geopolygon.geojson(),
result.geopolygon.geojson())
result = mgr.get_polygon(pol2.id)
self.assertEqual(pol2.id, result.id)
self.assertEqual(pol2.name, result.name)
self.assertEqual(pol2.area, result.area)
self.assertEqual(pol2.user_id, result.user_id)
self.assertEqual(pol2.center.lon, result.center.lon)
self.assertEqual(pol2.center.lat, result.center.lat)
self.assertEqual(pol2.geopolygon.geojson(),
result.geopolygon.geojson())
# Update a polygon
pol2.name = 'a better name'
mgr.update_polygon(pol2)
result = mgr.get_polygon(pol2.id)
self.assertEqual(pol2.id, result.id)
self.assertEqual(pol2.area, result.area)
self.assertEqual(pol2.user_id, result.user_id)
self.assertEqual(pol2.center.lon, result.center.lon)
self.assertEqual(pol2.center.lat, result.center.lat)
self.assertEqual(pol2.geopolygon.geojson(),
result.geopolygon.geojson())
self.assertNotEqual(pol2.name,
pol1.name) # of course, the name has changed
# Delete polygons one by one
mgr.delete_polygon(pol1)
polygons = mgr.get_polygons()
self.assertEqual(n_old_polygons + 1, len(polygons))
mgr.delete_polygon(pol2)
polygons = mgr.get_polygons()
self.assertEqual(n_old_polygons, len(polygons))
class IntegrationTestsSatelliteImageryStats(unittest.TestCase):
__owm = owm.OWM(os.getenv('OWM_API_KEY', None))
__polygon = None
__acquired_from = 1500336000 # 18 July 2017
__acquired_to = 1508976000 # 26 October 2017
@classmethod
def setUpClass(cls):
# create a polygon
mgr = cls.__owm.agro_manager()
geopol = GeoPolygon([[[-121.1958, 37.6683], [-121.1779, 37.6687],
[-121.1773, 37.6792], [-121.1958, 37.6792],
[-121.1958, 37.6683]]])
cls.__polygon = mgr.create_polygon(geopol, 'stats_test_polygon')
@classmethod
def tearDownClass(cls):
# delete the polygon
mgr = cls.__owm.agro_manager()
mgr.delete_polygon(cls.__polygon)
def test_stats_for_satellite_image(self):
mgr = self.__owm.agro_manager()
# search all Landsat 8 images in the specified time frame and with high valid data percentage
result_set = mgr.search_satellite_imagery(
self.__polygon.id, self.__acquired_from, self.__acquired_to, None,
None, None, None, SatelliteEnum.LANDSAT_8.symbol, None, 0.5, 99.5,
None)
self.assertIsInstance(result_set, list)
self.assertTrue(
all([
isinstance(i, MetaImage)
and i.satellite_name == SatelliteEnum.LANDSAT_8.name
for i in result_set
]))
# only keep EVI and NDVI ones
ndvi_only = [
mimg for mimg in result_set if mimg.preset == PresetEnum.NDVI
]
evi_only = [
mimg for mimg in result_set if mimg.preset == PresetEnum.EVI
]
self.assertTrue(len(ndvi_only) > 1)
self.assertTrue(len(evi_only) > 1)
# now search for stats for both types
stats_ndvi = mgr.stats_for_satellite_image(ndvi_only[0])
stats_evi = mgr.stats_for_satellite_image(evi_only[0])
self.assertIsInstance(stats_ndvi, dict)
self.assertIsInstance(stats_evi, dict)
# try to search for stats of a non NDVI or EVI image
falsecolor_only = [
mimg for mimg in result_set
if mimg.preset == PresetEnum.FALSE_COLOR
]
with self.assertRaises(ValueError):
mgr.stats_for_satellite_image(falsecolor_only[0])
class IntegrationTestsSatelliteImagerySearch(unittest.TestCase):
__owm = owm.OWM(os.getenv('OWM_API_KEY', None))
__polygon = None
__acquired_from = 1500336000 # 18 July 2017
__acquired_to = 1508976000 # 26 October 2017
@classmethod
def setUpClass(cls):
# create a polygon
mgr = cls.__owm.agro_manager()
geopol = GeoPolygon([[[-121.1958, 37.6683], [-121.1779, 37.6687],
[-121.1773, 37.6792], [-121.1958, 37.6792],
[-121.1958, 37.6683]]])
cls.__polygon = mgr.create_polygon(geopol, 'search_test_polygon')
@classmethod
def tearDownClass(cls):
# delete the polygon
mgr = cls.__owm.agro_manager()
mgr.delete_polygon(cls.__polygon)
# Test methods
def test_search_all(self):
mgr = self.__owm.agro_manager()
# search all images in the specified time frame
result_set = mgr.search_satellite_imagery(self.__polygon.id,
self.__acquired_from,
self.__acquired_to)
self.assertIsInstance(result_set, list)
self.assertEqual(len(result_set), 360)
self.assertTrue(all([isinstance(i, MetaImage) for i in result_set]))
def test_search_for_one_satellite(self):
mgr = self.__owm.agro_manager()
# search all Landsat 8 images in the specified time frame
result_set = mgr.search_satellite_imagery(
self.__polygon.id, self.__acquired_from, self.__acquired_to, None,
None, None, None, SatelliteEnum.LANDSAT_8.symbol, None, None, None,
None)
self.assertIsInstance(result_set, list)
self.assertEqual(len(result_set), 132)
self.assertTrue(
all([
isinstance(i, MetaImage)
and i.satellite_name == SatelliteEnum.LANDSAT_8.name
for i in result_set
]))
def test_search_for_geotiff_type_only(self):
mgr = self.__owm.agro_manager()
# search all geotiff images in the specified time frame
result_set = mgr.search_satellite_imagery(self.__polygon.id,
self.__acquired_from,
self.__acquired_to,
ImageTypeEnum.GEOTIFF, None,
None, None, None, None, None,
None, None)
self.assertIsInstance(result_set, list)
self.assertEqual(len(result_set), 120)
self.assertTrue(
all([
isinstance(i, MetaImage)
and i.image_type == ImageTypeEnum.GEOTIFF for i in result_set
]))
def test_search_for_ndvi_preset_only(self):
mgr = self.__owm.agro_manager()
# search all NDVI images in the specified time frame
result_set = mgr.search_satellite_imagery(self.__polygon.id,
self.__acquired_from,
self.__acquired_to, None,
PresetEnum.NDVI, None, None,
None, None, None, None, None)
self.assertIsInstance(result_set, list)
self.assertEqual(len(result_set), 90)
self.assertTrue(
all([
isinstance(i, MetaImage) and i.preset == PresetEnum.NDVI
for i in result_set
]))
def test_search_for_falsecolor_png_only(self):
mgr = self.__owm.agro_manager()
# search all PNG images in falsecolor in the specified time frame
result_set = mgr.search_satellite_imagery(
self.__polygon.id, self.__acquired_from, self.__acquired_to,
ImageTypeEnum.PNG, PresetEnum.FALSE_COLOR, None, None, None, None,
None, None, None)
self.assertIsInstance(result_set, list)
self.assertEqual(len(result_set), 60)
self.assertTrue(
all([
isinstance(i, MetaImage) and i.preset == PresetEnum.FALSE_COLOR
and i.image_type == ImageTypeEnum.PNG for i in result_set
]))
def test_detailed_search(self):
mgr = self.__owm.agro_manager()
# in the specified time frame, search all PNG images in truecolor acquired by Sentinel 2
# and with a max cloud coverage of 5% and at least 90% of valid data coverage
result_set = mgr.search_satellite_imagery(
self.__polygon.id, self.__acquired_from, self.__acquired_to,
ImageTypeEnum.PNG, PresetEnum.TRUE_COLOR, None, None,
SatelliteEnum.SENTINEL_2.symbol, None, 5, 90, None)
self.assertIsInstance(result_set, list)
self.assertEqual(len(result_set), 30)
self.assertTrue(
all([
isinstance(i, MetaImage) and i.preset == PresetEnum.TRUE_COLOR
and i.image_type == ImageTypeEnum.PNG
and i.satellite_name == SatelliteEnum.SENTINEL_2.name
and i.cloud_coverage_percentage <= 5
and i.valid_data_percentage >= 90 for i in result_set
]))
class IntegrationTestsAlertAPI30(unittest.TestCase):
__owm = owm.OWM(os.getenv('OWM_API_KEY', None))
cond1 = Condition(WeatherParametersEnum.HUMIDITY, OperatorsEnum.LESS_THAN, 10)
cond2 = Condition(WeatherParametersEnum.CLOUDS, OperatorsEnum.LESS_THAN, 90)
start = '2019-07-01 14:17:00+00'
end = '2019-07-02 14:17:00+00'
# a rectangle around the city of Moscow
area1 = geo.Polygon.from_dict({
"type": "Polygon",
"coordinates": [
[
[
36.826171875,
55.17259379606185
],
[
39.012451171875,
55.17259379606185
],
[
39.012451171875,
56.15778819063682
],
[
36.826171875,
56.15778819063682
],
[
36.826171875,
55.17259379606185
]
]
]})
# somewhere in Dubai
area2 = geo.Point.from_dict({
"type": "Point",
"coordinates": [
55.29693603515625,
25.186301620540558
]})
def test_triggers_CRUD(self):
mgr = self.__owm.alert_manager()
# check if any previous triggers exist on this account
n_old_triggers = len(mgr.get_triggers())
# create trigger1
trigger1 = mgr.create_trigger(self.start, self.end, conditions=[self.cond1], area=[self.area1])
# create trigger2
trigger2 = mgr.create_trigger(self.start, self.end, conditions=[self.cond2], area=[self.area2])
# Read all created triggers
triggers = mgr.get_triggers()
self.assertEqual(n_old_triggers + 2, len(triggers))
# Read one by one
result = mgr.get_trigger(trigger1.id)
self.assertEqual(trigger1.id, result.id)
self.assertEqual(trigger1.start_after_millis, result.start_after_millis)
self.assertEqual(trigger1.end_after_millis, result.end_after_millis)
self.assertEqual(len(trigger1.conditions), len(result.conditions))
self.assertEqual(len(trigger1.area), len(result.area))
result = mgr.get_trigger(trigger2.id)
self.assertEqual(trigger2.id, result.id)
self.assertEqual(trigger2.start_after_millis, result.start_after_millis)
self.assertEqual(trigger2.end_after_millis, result.end_after_millis)
self.assertEqual(len(trigger2.conditions), len(result.conditions))
self.assertEqual(len(trigger2.area), len(result.area))
# Update a trigger
modified_trigger2 = copy.deepcopy(trigger2)
modified_trigger2.conditions = [self.cond1, self.cond2]
mgr.update_trigger(modified_trigger2)
result = mgr.get_trigger(modified_trigger2.id)
self.assertEqual(modified_trigger2.id, result.id)
self.assertEqual(modified_trigger2.start_after_millis, result.start_after_millis)
self.assertEqual(modified_trigger2.end_after_millis, result.end_after_millis)
self.assertEqual(len(modified_trigger2.area), len(result.area))
# of course, conditions have been modified with respect to former trigger 2
self.assertNotEqual(len(trigger2.conditions), len(result.conditions))
self.assertEqual(len(modified_trigger2.conditions), len(result.conditions))
# Delete triggers one by one
mgr.delete_trigger(trigger1)
triggers = mgr.get_triggers()
self.assertEqual(n_old_triggers + 1, len(triggers))
mgr.delete_trigger(modified_trigger2)
triggers = mgr.get_triggers()
self.assertEqual(n_old_triggers, len(triggers))
class IntegrationTestsStationsAPI30(unittest.TestCase):
__owm = owm.OWM(os.getenv('OWM_API_KEY', None))
def test_stations_CRUD(self):
mgr = self.__owm.stations_manager()
# check if any previous station exists on this account
n_old_stations = len(mgr.get_stations())
# create stat1
stat1 = mgr.create_station('PYOWM1', 'pyowm_test_station_1',
45.0, 9.0, 189.0)
# create stat2
stat2 = mgr.create_station('PYOWM2', 'pyowm_test_station_2',
46.0, 18.0, 50.0)
# Read all
stations = mgr.get_stations()
self.assertEqual(n_old_stations + 2, len(stations))
# Read one by one
result = mgr.get_station(stat1.id)
self.assertEqual(stat1.id, result.id)
self.assertEqual(stat1.external_id, result.external_id)
self.assertEqual(stat1.name, result.name)
self.assertEqual(stat1.lat, result.lat)
self.assertEqual(stat1.lon, result.lon)
self.assertEqual(stat1.alt, result.alt)
result = mgr.get_station(stat2.id)
self.assertEqual(stat2.id, result.id)
self.assertEqual(stat2.external_id, result.external_id)
self.assertEqual(stat2.name, result.name)
self.assertEqual(stat2.lat, result.lat)
self.assertEqual(stat2.lon, result.lon)
self.assertEqual(stat2.alt, result.alt)
# Update a station
modified_stat2 = copy.deepcopy(stat2)
modified_stat2.eternal = 'modified_pyowm_test_station_2'
modified_stat2.lat = 30.6
mgr.update_station(modified_stat2)
result = mgr.get_station(modified_stat2.id)
self.assertEqual(modified_stat2.id, result.id)
self.assertEqual(modified_stat2.external_id, result.external_id)
self.assertEqual(modified_stat2.name, result.name)
# of course, lat had been modified
self.assertEqual(modified_stat2.lon, result.lon)
self.assertEqual(modified_stat2.alt, result.alt)
# Delete stations one by one
mgr.delete_station(stat1)
stations = mgr.get_stations()
self.assertEqual(n_old_stations + 1, len(stations))
mgr.delete_station(modified_stat2)
stations = mgr.get_stations()
self.assertEqual(n_old_stations, len(stations))
def test_measurements_and_buffers(self):
mgr = self.__owm.stations_manager()
# check if any previous station exists on this account
n_old_stations = len(mgr.get_stations())
# create station
test_station = mgr.create_station('PYOWM_TEST_BUFFERS', 'pyowm_test_buffers', 45.0, 9.0, 189.0)
# create and bufferize some measurements for the test station
buf = Buffer(test_station.id)
buf.append_from_dict(dict(station_id=test_station.id, timestamp=1505231630,
temperature=100, wind_speed=2.1,
wind_gust=67, humidex=77))
buf.append_from_dict(dict(station_id=test_station.id, timestamp=1505429694,
temperature=100, wind_speed=2.1,
wind_gust=67, humidex=77))
mgr.send_buffer(buf)
# now directly send measurements
measurement = Measurement.from_dict(dict(station_id=test_station.id, timestamp=1505415230,
temperature=100, wind_speed=2.1,
wind_gust=67, humidex=77))
measurements_list = [
Measurement.from_dict(dict(station_id=test_station.id, timestamp=1505315230,
temperature=100, wind_speed=2.1,
wind_gust=67, humidex=77))
]
mgr.send_measurement(measurement)
mgr.send_measurements(measurements_list)
# read the measurements for station
msmts = mgr.get_measurements(test_station.id, 'd', 1505200000, 1505430000)
for m in msmts:
self.assertEqual(test_station.id, m.station_id)
self.assertEqual('d', m.aggregated_on)
# Delete stations one by one
mgr.delete_station(test_station)
stations = mgr.get_stations()
self.assertEqual(n_old_stations, len(stations))
class IntegrationTestsSatelliteImageryDownload(unittest.TestCase):
__owm = owm.OWM(os.getenv('OWM_API_KEY', None))
__polygon = None
__acquired_from = 1500336000 # 18 July 2017
__acquired_to = 1508976000 # 26 October 2017
@classmethod
def setUpClass(cls):
# create a polygon
mgr = cls.__owm.agro_manager()
geopol = GeoPolygon([[[-121.1958, 37.6683], [-121.1779, 37.6687],
[-121.1773, 37.6792], [-121.1958, 37.6792],
[-121.1958, 37.6683]]])
cls.__polygon = mgr.create_polygon(geopol, 'search_test_polygon')
@classmethod
def tearDownClass(cls):
# delete the polygon
mgr = cls.__owm.agro_manager()
mgr.delete_polygon(cls.__polygon)
# Test methods
def test_download_png(self):
mgr = self.__owm.agro_manager()
# search PNG, truecolor, non-tile images acquired by Landsat 8
result_set = mgr.search_satellite_imagery(
self.__polygon.id, self.__acquired_from, self.__acquired_to,
ImageTypeEnum.PNG, PresetEnum.TRUE_COLOR, None, None,
SatelliteEnum.LANDSAT_8.symbol, None, None, None, None)
self.assertIsInstance(result_set, list)
self.assertEqual(len(result_set), 22)
# just keep the non-tile images
non_tile_pngs = [
mimg for mimg in result_set if isinstance(mimg, MetaPNGImage)
]
self.assertEqual(len(non_tile_pngs), 11)
# download one
result = mgr.download_satellite_image(non_tile_pngs[0])
self.assertIsInstance(result, SatelliteImage)
self.assertIsInstance(result.metadata, MetaPNGImage)
img = result.data
self.assertIsInstance(img, Image)
self.assertEqual(img.image_type, ImageTypeEnum.PNG)
self.assertNotEqual(len(img.data), 0)
def test_download_geotiff(self):
mgr = self.__owm.agro_manager()
# search GeoTiff, EVIimages acquired by Landsat 8
result_set = mgr.search_satellite_imagery(
self.__polygon.id, self.__acquired_from, self.__acquired_to,
ImageTypeEnum.GEOTIFF, PresetEnum.EVI, None, None,
SatelliteEnum.LANDSAT_8.symbol, None, None, None, None)
self.assertIsInstance(result_set, list)
self.assertEqual(len(result_set), 11)
# download one
result = mgr.download_satellite_image(
result_set[0], palette=PaletteEnum.CONTRAST_SHIFTED)
self.assertIsInstance(result, SatelliteImage)
self.assertIsInstance(result.metadata, MetaGeoTiffImage)
img = result.data
self.assertIsInstance(img, Image)
self.assertEqual(img.image_type, ImageTypeEnum.GEOTIFF)
self.assertNotEqual(len(img.data), 0)
def test_download_tile(self):
mgr = self.__owm.agro_manager()
# search PNG, truecolor, tile images acquired by Landsat 8
result_set = mgr.search_satellite_imagery(
self.__polygon.id, self.__acquired_from, self.__acquired_to,
ImageTypeEnum.PNG, PresetEnum.TRUE_COLOR, None, None,
SatelliteEnum.LANDSAT_8.symbol, None, None, None, None)
self.assertIsInstance(result_set, list)
self.assertEqual(len(result_set), 22)
# just keep the tiles
tile_pngs = [mimg for mimg in result_set if isinstance(mimg, MetaTile)]
self.assertEqual(len(tile_pngs), 11)
# try to download one without specifying x, y and zoom
with self.assertRaises(AssertionError):
mgr.download_satellite_image(tile_pngs[0])
with self.assertRaises(AssertionError):
mgr.download_satellite_image(tile_pngs[0], x=1)
with self.assertRaises(AssertionError):
mgr.download_satellite_image(tile_pngs[0], x=1, y=2)
# download one
result = mgr.download_satellite_image(tile_pngs[1], x=1, y=2, zoom=5)
self.assertIsInstance(result, SatelliteImage)
self.assertIsInstance(result.metadata, MetaTile)
img = result.data
self.assertIsInstance(img, Image)
self.assertEqual(img.image_type, ImageTypeEnum.PNG)
self.assertNotEqual(len(img.data), 0)
def test_persisting_to_disk(self):
path = '%s.tif' % uuid.uuid4()
mgr = self.__owm.agro_manager()
# search GeoTiff, EVIimages acquired by Landsat 8
result_set = mgr.search_satellite_imagery(
self.__polygon.id, self.__acquired_from, self.__acquired_to,
ImageTypeEnum.GEOTIFF, PresetEnum.EVI, None, None,
SatelliteEnum.LANDSAT_8.symbol, None, None, None, None)
self.assertTrue(len(result_set) > 1)
metaimg = result_set[0]
sat_img = mgr.download_satellite_image(metaimg)
try:
self.assertFalse(os.path.isfile(path))
sat_img.persist(path)
self.assertTrue(os.path.isfile(path))
except:
self.fail()
finally:
os.remove(path)
