def test_retrive(self):
dao = CityDAO()
# Success Retriving
city = dao.retrive(City(1))
self.assertEqual(city.name, 'Kabul')
# Failed Retriving
# No info
city = dao.retrive(City(10000))
self.assertEqual(city, None)
# Bad Input
with self.assertRaises(ValueError):
dao.retrive(1)
def test_retrive_previous(self):
dao = CityDAO()
# Success Retriving
city = dao.retrive_previous(City(2))
self.assertEqual(city.name, 'Kabul')
# Last
city = dao.retrive_previous(City(5000))
self.assertEqual(city.name, 'Rafah')
# Failed Retriving
# No info
city = dao.retrive_previous(City(1))
self.assertEqual(city, None)
# Bad Input
with self.assertRaises(ValueError):
dao.retrive_previous(1)
def test_retrive_by_data(self):
dao = CityDAO()
# Success Retriving
# All Equal
city = City(1, 'Kabul', 'AFG', 'Kabol', 1780000)
retrived_city = dao.retrive_by_data(city)[-1]
self.assertEqual(city, retrived_city)
# Wrong ID but the rest Equal
city = City(10000, 'Kabul', 'AFG', 'Kabol', 1780000)
retrived_city = dao.retrive_by_data(city)[-1]
self.assertEqual(city.name, retrived_city.name)
# Failed Retriving
# No info (Wrong Data)
city = City(1, 'Kabul', 'AFG', 'Kabol', 178)
retrived_city = dao.retrive_by_data(city)
self.assertEqual(retrived_city, [])
# Bad Input
with self.assertRaises(ValueError):
dao.retrive_by_data([1, 'Kabul', 'AFG', 'Kabol', 1780000])
def comune():
global comune
comuni_data = csv.reader(open('csv/COMUNI_COORDINATE_1.csv', 'r'))
poll_dict = {}
modules.write_csv()
date = modules.get_date()
o3_data = csv.reader(open('csv/pollution_data/o3.csv', 'r'))
no2_data = csv.reader(open('csv/pollution_data/no2.csv', 'r'))
pm10_data = csv.reader(open('csv/pollution_data/pm10.csv', 'r'))
c = request.args.get('city_name')
for com in comuni_data:
if com[0] == c:
comune = City(com[0], [float(com[1]), float(com[2])])
nearest_loc = modules.get_nearest_loc(comune, loc_list)
nearest_loc_dist = round(nearest_loc[0], 1)
pm10 = modules.get_value(pm10_data, nearest_loc[1])
try:
o3 = modules.get_value(o3_data, nearest_loc[1])
no2 = modules.get_value(no2_data, nearest_loc[1])
poll_dict.update({'PM10': pm10, 'o3': o3, 'no2': no2})
except:
poll_dict.update({'pm10': pm10})
pm10_pct = (pm10 / 50) * 100
return render_template("comune.html",
c=c,
n=nearest_loc[1].decode('utf-8'),
d=nearest_loc_dist,
pm10=pm10,
pm10_pct=pm10_pct,
poll_dict=poll_dict,
date=date,
int=int)
def test_country_code(self):
# Creation
city = City(1, 'Santiago', 'CHI')
self.assertEqual(city.country_code, 'CHI')
# Modification
city.country_code = 'CHL'
self.assertEqual(city.country_code, 'CHL')
# None Value
with self.assertRaises(ValueError):
city.country_code = ''
# Invalid Value
with self.assertRaises(ValueError):
city.country_code = 'CH'
with self.assertRaises(ValueError):
city.country_code = 'CHILE'
with self.assertRaises(ValueError):
city.country_code = 1
def test_district(self):
# Creation
city = City(1, 'Santiago', 'CHI', 'Santiago')
self.assertEqual(city.district, 'Santiago')
# Modification
city.district = 'Santiago Centro'
self.assertEqual(city.district, 'Santiago Centro')
# None Value
with self.assertRaises(ValueError):
city.district = ''
# Invalid Value
with self.assertRaises(ValueError):
city.district = 'SC'
with self.assertRaises(ValueError):
city.district = 1
def test_name(self):
# Creation
city = City(1, 'Santiago')
self.assertEqual(city.name, 'Santiago')
# Modification
city.name = 'SANTIAGO'
self.assertEqual(city.name, 'SANTIAGO')
# None Value
with self.assertRaises(ValueError):
city.name = ''
# Invalid Value
with self.assertRaises(ValueError):
city.name = 'SG'
with self.assertRaises(ValueError):
city.name = 1
def test_city_id(self):
# Creation
city = City(10)
self.assertEqual(city.city_id, 10)
# Modification
city.city_id = 20
self.assertEqual(city.city_id, 20)
# None Value
with self.assertRaises(ValueError):
city.city_id = 0
# Invalid Value
with self.assertRaises(ValueError):
city.city_id = -10
with self.assertRaises(ValueError):
city.city_id = '10'
from cities import City
from users import User
from travels import Travels, Travel
from votes import Vote
from login import Login
cors = CORS(allow_origins_list=['http://localhost:9000'])
api = falcon.API(middleware=[cors.middleware])
api.add_route('/countries', Countries())
api.add_route('/country/{country}', Country())
api.add_route('/country/{country}/city/{city}', City())
api.add_route('/users/{query}', User())
api.add_route('/travel', Travel())
api.add_route('/travels', Travels())
api.add_route('/travel/vote', Vote())
api.add_route('/login', Login())
def main(args, session):
if session.query(City).count() and not args.reselect_cities:
logging.info('Selected cities exist and reselection not requested')
return
logging.info('Deleting existing cities')
session.query(City).delete()
cities = []
cities_by_id = {}
points = {}
with zipfile.ZipFile(args.cities_file, 'r') as zip_file:
file_name = zip_file.namelist()[0]
logging.info(f'Loading {file_name} from {args.cities_file}')
with zip_file.open(file_name, 'r') as tsv_file:
for line in io.TextIOWrapper(tsv_file):
row = line.rstrip('\n').split('\t')
city = City(city_id=int(row[0]),
name=row[1],
lat=float(row[4]),
lon=float(row[5]),
population=int(row[14]))
if city.population <= 0:
continue
cities.append(city)
cities_by_id[city.city_id] = city
points[city.city_id] = _lat_lon_to_point(city.lat, city.lon)
#if len(cities) >= 10000:
# break
max_population = max(city.population for city in cities)
logging.info(
f'Loaded {len(cities)} cities; maximum population is {max_population}')
logging.info('Indexing cities')
prop = rtree.index.Property()
prop.dimension = 3
index = rtree.index.Index(properties=prop)
for city in progress.percent(cities):
city_point = points[city.city_id]
index.insert(city.city_id, (*city_point, *city_point))
logging.info('Computing city weights')
sigma = args.cities_select_population_sigma_km
max_distance = _great_circle_to_cartesian_distance(3.0 * sigma)
weights = {}
for city in progress.percent(cities):
city_point = points[city.city_id]
region_population = 0
for nearby_id in index.intersection(
_box_around(city_point, max_distance)):
nearby_distance = _cartesian_distance(points[nearby_id],
city_point)
if nearby_distance <= max_distance:
d = nearby_distance / sigma
population = cities_by_id[nearby_id].population * math.exp(
-0.5 * d * d)
region_population += population
weights[city.city_id] = city.population / region_population
logging.info(f'Selecting {args.cities_to_select} cities')
cities.sort(key=lambda city: weights[city.city_id], reverse=True)
selected_cities = cities[:args.cities_to_select]
logging.info(f'Storing {len(selected_cities)} selected cities')
session.bulk_save_objects(selected_cities)