def get_context_data(self, geo_id1, geo_id2):
page_context = {
'geo_id1': geo_id1,
'geo_id2': geo_id2,
}
release = self.request.GET.get('release')
version = self.request.GET.get('geo_version', self.default_geo_version)
try:
level, code = geo_id1.split('-', 1)
self.geo = geo_data.get_geography(code, level, version)
year = self.request.GET.get(
'release', get_primary_release_year_per_geography(self.geo))
page_context['geo1'] = geo_data.get_geography(code, level)
page_context['geo1_slug'] = '-' + slugify(page_context['geo1'])
page_context['geo1_release_year'] = str(year)
level, code = geo_id2.split('-', 1)
page_context['geo2'] = geo_data.get_geography(code, level)
page_context['geo2_slug'] = '-' + slugify(page_context['geo2'])
page_context['geo2_release_year'] = str(year)
# Get Release
page_context['geography'] = self.geo.as_dict_deep()
page_context[
'compare_primary_releases'] = get_page_releases_per_country(
settings.HURUMAP['primary_dataset_name'], self.geo, year)
except (ValueError, LocationNotFound):
raise Http404
return page_context
def get_context_data(self, geo_id1, geo_id2):
page_context = {
'geo_id1': geo_id1,
'geo_id2': geo_id2,
}
release = self.request.GET.get('release')
version = self.request.GET.get('geo_version', self.default_geo_version)
try:
level, code = geo_id1.split('-', 1)
self.geo = geo_data.get_geography(code, level, version)
year = self.request.GET.get(
'release', get_primary_release_year_per_geography(self.geo))
page_context['geo1'] = geo_data.get_geography(code, level)
page_context['geo1_slug'] = '-' + slugify(page_context['geo1'])
page_context['geo1_release_year'] = str(year)
level, code = geo_id2.split('-', 1)
page_context['geo2'] = geo_data.get_geography(code, level)
page_context['geo2_slug'] = '-' + slugify(page_context['geo2'])
page_context['geo2_release_year'] = str(year)
# Get Release
page_context['geography'] = self.geo.as_dict_deep()
page_context['compare_primary_releases'] = get_page_releases_per_country(
settings.HURUMAP['primary_dataset_name'], self.geo, year)
except (ValueError, LocationNotFound):
raise Http404
return page_context
def get_context_data(self, geo_id1, geo_id2):
page_context = {
'geo_id1': geo_id1,
'geo_id2': geo_id2,
}
release = self.request.GET.get('release')
try:
level, code = geo_id1.split('-', 1)
page_context['geo1'] = geo_data.get_geography(code, level)
page_context['geo1_release_year'] = str(
settings.WAZIMAP['primary_release_year'].get(
level, release)) if release == settings.WAZIMAP[
'latest_release_year'] else release
level, code = geo_id2.split('-', 1)
page_context['geo2'] = geo_data.get_geography(code, level)
page_context['geo2_release_year'] = str(
settings.WAZIMAP['primary_release_year'].get(
level, release)) if release == settings.WAZIMAP[
'latest_release_year'] else release
except (ValueError, LocationNotFound):
raise Http404
return page_context
def get_geos(self, geo_ids, geo_version):
"""
Return a tuple (data_geos, info_geos) of geo objects,
where data_geos or geos we should get data for, and info_geos
are geos that we only need to return geo info/metadata for.
"""
data_geos = []
info_geos = []
for geo_id in geo_ids:
# either country-KE or level|country-KE, which indicates
# we must break country-KE into +levels+
if '-' not in geo_id:
raise LocationNotFound('Invalid geo id: %s' % geo_id)
level, code = geo_id.split('-', 1)
if '|' in level:
# break geo down further
split_level, level = level.split('|', 1)
geo = geo_data.get_geography(code, level, geo_version)
info_geos.append(geo)
try:
data_geos.extend(geo.split_into(split_level))
except ValueError:
raise LocationNotFound('Invalid geo level: %s' %
split_level)
else:
# normal geo
data_geos.append(
geo_data.get_geography(code, level, geo_version))
return data_geos, info_geos
def get_geos(self, geo_ids, geo_version):
"""
Return a tuple (data_geos, info_geos) of geo objects,
where data_geos or geos we should get data for, and info_geos
are geos that we only need to return geo info/metadata for.
"""
data_geos = []
info_geos = []
for geo_id in geo_ids:
# either country-KE or level|country-KE, which indicates
# we must break country-KE into +levels+
if '-' not in geo_id:
raise LocationNotFound('Invalid geo id: %s' % geo_id)
level, code = geo_id.split('-', 1)
if '|' in level:
# break geo down further
split_level, level = level.split('|', 1)
geo = geo_data.get_geography(code, level, geo_version)
info_geos.append(geo)
try:
data_geos.extend(geo.split_into(split_level))
except ValueError:
raise LocationNotFound('Invalid geo level: %s' % split_level)
else:
# normal geo
data_geos.append(geo_data.get_geography(code, level, geo_version))
return data_geos, info_geos
def test_versioned_geos(self):
# create two geos at different versions
cpt11 = geo_data.geo_model.objects.create(geo_level='municipality', geo_code='cpt', long_name='City of Cape Town', version='2011')
cpt16 = geo_data.geo_model.objects.create(geo_level='municipality', geo_code='cpt', long_name='City of Cape Town', version='2016')
self.assertEquals(cpt16, geo_data.get_geography('cpt', 'municipality'))
self.assertEquals(cpt11, geo_data.get_geography('cpt', 'municipality', '2011'))
self.assertEquals(cpt16, geo_data.get_geography('cpt', 'municipality', '2016'))
def get_context_data(self, geo_id1, geo_id2):
page_context = {
'geo_id1': geo_id1,
'geo_id2': geo_id2,
}
try:
level, code = geo_id1.split('-', 1)
page_context['geo1'] = geo_data.get_geography(code, level)
level, code = geo_id2.split('-', 1)
page_context['geo2'] = geo_data.get_geography(code, level)
except (ValueError, LocationNotFound):
raise Http404
return page_context
def get_context_data(self, geo_id1, geo_id2):
page_context = {
'geo_id1': geo_id1,
'geo_id2': geo_id2,
}
try:
level, code = geo_id1.split('-', 1)
page_context['geo1'] = geo_data.get_geography(code, level)
level, code = geo_id2.split('-', 1)
page_context['geo2'] = geo_data.get_geography(code, level)
except (ValueError, Exception):
raise Http404
return page_context
def get_demographics_profile(geo_code, geo_level, session):
pop_dist_data, pop_total = get_stat_data(
['population group'], geo_level, geo_code, session)
youth_pop_dist_data, youth_pop_total = get_stat_data(['age in completed years'], geo_level, geo_code, session, table_name='youth_gender_age_in_completed_years')
youth_gender_data, _ = get_stat_data(['gender'], geo_level, geo_code, session, table_name='youth_gender_population_group')
youth_pop_group_data, _ = get_stat_data(['population group'], geo_level, geo_code, session, table_name='youth_gender_population_group')
final_data = {
'total_population': {
"name": "People",
"values": {"this": pop_total}
},
'youth_population_total': {
"name": "Youth aged 15-24",
"values": {"this": youth_pop_total}
},
'youth_population_perc': {
"name": "Of population are youth aged 15-24",
"values": {"this": percent(youth_pop_total, pop_total)},
},
'youth_population_by_year': youth_pop_dist_data,
'youth_population_by_gender': youth_gender_data,
'youth_population_by_pop_group': youth_pop_group_data
}
geo = geo_data.get_geography(geo_code, geo_level)
if geo.square_kms:
final_data['population_density'] = {
'name': "people per square kilometre",
'values': {"this": pop_total / geo.square_kms}
}
return final_data
def get_profile(geo_code, geo_level, profile_name=None):
# Census data
table = get_datatable('population_2011')
_, total_pop = table.get_stat_data(geo_level, geo_code, percent=False)
geo = geo_data.get_geography(geo_code, geo_level)
population_density = None
if geo.square_kms:
population_density = total_pop / geo.square_kms
indicator_calc = IndicatorCalculator(geo_code)
indicator_calc.calculate()
indicators = {}
indicators['cash_at_year_end'] = indicator_calc.cash_at_year_end()
indicators['cash_coverage'] = indicator_calc.cash_coverage()
indicators['op_budget_diff'] = indicator_calc.op_budget_diff()
indicators['cap_budget_diff'] = indicator_calc.cap_budget_diff()
indicators['rep_maint_perc_ppe'] = indicator_calc.rep_maint_perc_ppe()
indicators['wasteful_exp'] = indicator_calc.wasteful_exp_perc_exp()
indicators['expenditure_trends'] = indicator_calc.expenditure_trends()
indicators['revenue_breakdown'] = indicator_calc.revenue_breakdown()
indicators['expenditure_trends'] = indicator_calc.expenditure_trends()
indicators['expenditure_functional_breakdown'] = indicator_calc.expenditure_functional_breakdown()
return {
'total_population': total_pop,
'population_density': population_density,
'mayoral_staff': indicator_calc.mayoral_staff(),
'muni_contact': indicator_calc.muni_contact(),
'audit_opinions': indicator_calc.audit_opinions(),
'indicators': indicators,
}
def get(self, request, geo_id, *args, **kwargs):
try:
level, code = geo_id.split('-', 1)
geo = geo_data.get_geography(code, level)
except (ValueError, LocationNotFound):
raise Http404
parents = [g.as_dict() for g in geo.ancestors()]
return render_json_to_response(parents)
def get_context_data(self, *args, **kwargs):
session = get_session()
page_context = {}
code = self.kwargs.get('code', None)
#Fetch school perfromance over the year
school_results = session.query(Base.metadata.tables['secondary_school'])\
.filter(Base.metadata.tables['secondary_school'].c.geo_level == "region")\
.filter(Base.metadata.tables['secondary_school'].c.code == code)\
.all()
# Fetching schools
school = session.query(Base.metadata.tables['secondary_school'])\
.filter(Base.metadata.tables['secondary_school'].c.geo_level == "region")\
.filter(Base.metadata.tables['secondary_school'].c.year_of_result == self.year)\
.filter(Base.metadata.tables['secondary_school'].c.code == code)\
.one()
#get school coordinates
coordinates = session.query(Base.metadata.tables['secondary_school'].c.code, Base.metadata.tables['secondary_school'].c.name, Base.metadata.tables['secondary_school'].c.longitude, Base.metadata.tables['secondary_school'].c.latitude )\
.filter(Base.metadata.tables['secondary_school'].c.geo_level == "region")\
.filter(Base.metadata.tables['secondary_school'].c.code == code)\
.filter(Base.metadata.tables['secondary_school'].c.year_of_result == self.year)\
.filter(Base.metadata.tables['secondary_school'].c.longitude != 'UNKNOWN')\
.filter(Base.metadata.tables['secondary_school'].c.latitude != 'UNKNOWN')\
.all()
#Fetch the region where school is
try:
self.geo_level = 'region'
self.geo_code = school.geo_code
version = '2009'
self.geo = geo_data.get_geography(self.geo_code, self.geo_level,
version)
except (ValueError, Exception):
raise Http404
# load the profile
# profile_method = settings.WAZIMAP.get('profile_builder', None)
# self.profile_name = settings.WAZIMAP.get('default_profile', 'default')
#
# if not profile_method:
# raise ValueError("You must define WAZIMAP.profile_builder in settings.py")
# profile_method = import_string(profile_method)
# profile_data = profile_method(self.geo, self.profile_name, self.request)
profile_data = {}
profile_data['geography'] = self.geo.as_dict_deep()
profile_data['coordinates'] = json.dumps(coordinates,
cls=DjangoJSONEncoder)
profile_data['school'] = school
profile_data['year'] = self.year
profile_data['school_results'] = school_results
profile_data = enhance_api_data(profile_data)
page_context.update(profile_data)
profile_data_json = SafeString(
json.dumps(profile_data, cls=DjangoJSONEncoder))
page_context.update({'profile_data_json': profile_data_json})
session.close()
return page_context
def test_versioned_geos(self):
# create two geos at different versions
cpt11 = geo_data.geo_model.objects.create(
geo_level='municipality',
geo_code='cpt',
long_name='City of Cape Town',
version='2011')
cpt16 = geo_data.geo_model.objects.create(
geo_level='municipality',
geo_code='cpt',
long_name='City of Cape Town',
version='2016')
self.assertEquals(cpt16, geo_data.get_geography('cpt', 'municipality'))
self.assertEquals(
cpt11, geo_data.get_geography('cpt', 'municipality', '2011'))
self.assertEquals(
cpt16, geo_data.get_geography('cpt', 'municipality', '2016'))
def get(self, request, geo_id, *args, **kwargs):
try:
level, code = geo_id.split('-', 1)
geo = geo_data.get_geography(code, level)
except (ValueError, LocationNotFound):
raise Http404
parents = [g.as_dict() for g in geo.ancestors()]
return render_json_to_response(parents)
def get_context_data(self, *args, **kwargs):
session = get_session()
page_context = {}
code = self.kwargs.get('code', None)
#Fetch school perfromance over the year
school_results = session.query(Base.metadata.tables['secondary_school'])\
.filter(Base.metadata.tables['secondary_school'].c.geo_level == "region")\
.filter(Base.metadata.tables['secondary_school'].c.code == code)\
.all()
# Fetching schools
school = session.query(Base.metadata.tables['secondary_school'])\
.filter(Base.metadata.tables['secondary_school'].c.geo_level == "region")\
.filter(Base.metadata.tables['secondary_school'].c.year_of_result == self.year)\
.filter(Base.metadata.tables['secondary_school'].c.code == code)\
.one()
#get school coordinates
coordinates = session.query(Base.metadata.tables['secondary_school'].c.code, Base.metadata.tables['secondary_school'].c.name, Base.metadata.tables['secondary_school'].c.longitude, Base.metadata.tables['secondary_school'].c.latitude )\
.filter(Base.metadata.tables['secondary_school'].c.geo_level == "region")\
.filter(Base.metadata.tables['secondary_school'].c.code == code)\
.filter(Base.metadata.tables['secondary_school'].c.year_of_result == self.year)\
.filter(Base.metadata.tables['secondary_school'].c.longitude != 'UNKNOWN')\
.filter(Base.metadata.tables['secondary_school'].c.latitude != 'UNKNOWN')\
.all()
#Fetch the region where school is
try:
self.geo_level = 'region'
self.geo_code = school.geo_code
version = '2009'
self.geo = geo_data.get_geography(self.geo_code, self.geo_level, version)
except (ValueError, Exception):
raise Http404
# load the profile
# profile_method = settings.WAZIMAP.get('profile_builder', None)
# self.profile_name = settings.WAZIMAP.get('default_profile', 'default')
#
# if not profile_method:
# raise ValueError("You must define WAZIMAP.profile_builder in settings.py")
# profile_method = import_string(profile_method)
# profile_data = profile_method(self.geo, self.profile_name, self.request)
profile_data = {}
profile_data['geography'] = self.geo.as_dict_deep()
profile_data['coordinates'] = json.dumps(coordinates, cls=DjangoJSONEncoder)
profile_data['school'] = school
profile_data['year'] = self.year
profile_data['school_results'] = school_results
profile_data = enhance_api_data(profile_data)
page_context.update(profile_data)
profile_data_json = SafeString(json.dumps(profile_data, cls=DjangoJSONEncoder))
page_context.update({
'profile_data_json': profile_data_json
})
session.close()
return page_context
def get_context_data(self, **kwargs):
context = super(CountryPageView, self).get_context_data(**kwargs)
country_slug = self.kwargs['country']
country = COUNTRIES[country_slug]
country['slug'] = country_slug
geo = geo_data.get_geography(country['code'], 'country',
self.default_geo_version)
context['country'] = country
context['geography'] = geo.as_dict_deep()
return context
def get_context_data(self, **kwargs):
context = super(CountryPageView, self).get_context_data(**kwargs)
country_slug = self.kwargs['country']
country = COUNTRIES[country_slug]
country['slug'] = country_slug
geo = geo_data.get_geography(
country['code'], 'country', self.default_geo_version)
context['country'] = country
context['geography'] = geo.as_dict_deep()
return context
def dispatch(self, *args, **kwargs):
self.geo_id = self.kwargs.get('geography_id', None)
try:
self.geo_level, self.geo_code = self.geo_id.split('-', 1)
self.geo = geo_data.get_geography(self.geo_code, self.geo_level)
except (ValueError, LocationNotFound):
raise Http404
# check slug
if self.adjust_slugs and (kwargs.get('slug') or self.geo.slug):
if kwargs['slug'] != self.geo.slug:
kwargs['slug'] = self.geo.slug
url = '/profiles/%s-%s-%s' % (self.geo_level, self.geo_code, self.geo.slug)
return redirect(url, permanent=True)
# Skip the parent class's logic completely and go back to basics
return TemplateView.dispatch(self, *args, **kwargs)
def dispatch(self, *args, **kwargs):
self.geo_id = self.kwargs.get('geography_id', None)
try:
self.geo_level, self.geo_code = self.geo_id.split('-', 1)
self.geo = geo_data.get_geography(self.geo_code, self.geo_level)
except (ValueError, LocationNotFound):
raise Http404
# check slug
if self.adjust_slugs and (kwargs.get('slug') or self.geo.slug):
if kwargs['slug'] != self.geo.slug:
kwargs['slug'] = self.geo.slug
url = '/profiles/%s-%s-%s' % (self.geo_level, self.geo_code,
self.geo.slug)
return redirect(url, permanent=True)
# Skip the parent class's logic completely and go back to basics
return TemplateView.dispatch(self, *args, **kwargs)
def get_profile(geo_code, geo_level, profile_name=None):
# Census data
table = get_datatable('population_2011')
_, total_pop = table.get_stat_data(geo_level, geo_code, percent=False)
geo = geo_data.get_geography(geo_code, geo_level)
population_density = None
if geo.square_kms:
population_density = total_pop / geo.square_kms
indicator_calc = IndicatorCalculator(geo_code)
indicator_calc.calculate()
indicators = {}
indicators['cash_at_year_end'] = indicator_calc.cash_at_year_end()
indicators['cash_coverage'] = indicator_calc.cash_coverage()
indicators['op_budget_diff'] = indicator_calc.op_budget_diff()
indicators['cap_budget_diff'] = indicator_calc.cap_budget_diff()
indicators['rep_maint_perc_ppe'] = indicator_calc.rep_maint_perc_ppe()
indicators['wasteful_exp'] = indicator_calc.wasteful_exp_perc_exp()
indicators['expenditure_trends'] = indicator_calc.expenditure_trends()
indicators['revenue_breakdown'] = indicator_calc.revenue_breakdown()
indicators['expenditure_trends'] = indicator_calc.expenditure_trends()
indicators[
'expenditure_functional_breakdown'] = indicator_calc.expenditure_functional_breakdown(
)
return {
'total_population': total_pop,
'population_density': population_density,
'mayoral_staff': indicator_calc.mayoral_staff(),
'muni_contact': indicator_calc.muni_contact(),
'audit_opinions': indicator_calc.audit_opinions(),
'indicators': indicators,
}
def get_demographics_profile(geo_code, geo_level, session):
# population group
pop_dist_data, total_pop = get_stat_data(
['population group'], geo_level, geo_code, session)
# language
language_data, _ = get_stat_data(
['language'], geo_level, geo_code, session, order_by='-total')
language_most_spoken = language_data[language_data.keys()[0]]
# age groups
age_dist_data, total_age = get_stat_data(
['age groups in 5 years'], geo_level, geo_code, session,
table_name='agegroupsin5years',
recode=COLLAPSED_AGE_CATEGORIES,
key_order=('0-9', '10-19',
'20-29', '30-39',
'40-49', '50-59',
'60-69', '70-79',
'80+'))
# sex
db_model_sex = get_model_from_fields(['gender'], geo_level, table_name='gender')
query = session.query(func.sum(db_model_sex.total)) \
.filter(db_model_sex.gender == 'Male')
query = query.filter(db_model_sex.geo_code == geo_code)
total_male = query.one()[0]
sex_data = OrderedDict(( # census data refers to sex as gender
('Female', {
"name": "Female",
"values": {"this": round((total_pop - total_male) / total_pop * 100, 2)},
"numerators": {"this": total_pop - total_male},
}),
('Male', {
"name": "Male",
"values": {"this": round(total_male / total_pop * 100, 2)},
"numerators": {"this": total_male},
}),
))
add_metadata(sex_data, db_model_sex)
final_data = {
'language_distribution': language_data,
'language_most_spoken': language_most_spoken,
'population_group_distribution': pop_dist_data,
'age_group_distribution': age_dist_data,
'sex_ratio': sex_data,
'total_population': {
"name": "People",
"values": {"this": total_pop},
}
}
geo = geo_data.get_geography(geo_code, geo_level)
if geo.square_kms:
final_data['population_density'] = {
'name': "people per square kilometre",
'values': {"this": total_pop / geo.square_kms},
}
# median age/age category
db_model_age = get_model_from_fields(
['age in completed years'], geo_level,
table_name='ageincompletedyears'
)
objects = sorted(
get_objects_by_geo(db_model_age, geo_code, geo_level, session),
key=lambda x: int(getattr(x, 'age in completed years'))
)
# median age
median = calculate_median(objects, 'age in completed years')
final_data['median_age'] = {
"name": "Median age",
"values": {"this": median},
}
# age category
age_dist, _ = get_stat_data(
['age in completed years'], geo_level, geo_code, session,
table_name='ageincompletedyearssimplified',
key_order=['Under 18', '18 to 64', '65 and over'],
recode={'< 18': 'Under 18',
'>= 65': '65 and over'})
final_data['age_category_distribution'] = age_dist
# citizenship
citizenship_dist, _ = get_stat_data(
['citizenship'], geo_level, geo_code, session,
order_by='-total')
sa_citizen = citizenship_dist['Yes']['numerators']['this']
final_data['citizenship_distribution'] = citizenship_dist
final_data['citizenship_south_african'] = {
'name': 'South African citizens',
'values': {'this': percent(sa_citizen, total_pop)},
'numerators': {'this': sa_citizen},
}
# migration
province_of_birth_dist, _ = get_stat_data(
['province of birth'], geo_level, geo_code, session,
exclude_zero=True, order_by='-total')
final_data['province_of_birth_distribution'] = province_of_birth_dist
def region_recode(field, key):
if key == 'Born in South Africa':
return 'South Africa'
else:
return key
region_of_birth_dist, _ = get_stat_data(
['region of birth'], geo_level, geo_code, session,
exclude_zero=True, order_by='-total',
recode=region_recode)
if 'South Africa' in region_of_birth_dist:
born_in_sa = region_of_birth_dist['South Africa']['numerators']['this']
else:
born_in_sa = 0
final_data['region_of_birth_distribution'] = region_of_birth_dist
final_data['born_in_south_africa'] = {
'name': 'Born in South Africa',
'values': {'this': percent(born_in_sa, total_pop)},
'numerators': {'this': born_in_sa},
}
return final_data
def get_demographics_profile(geo_code, geo_level, session):
# population group
pop_dist_data, total_pop = get_stat_data(
['population group'], geo_level, geo_code, session)
ecd_age_groups, ecd_children = get_stat_data(
['age in completed years'], geo_level, geo_code, session,
table_name='ageincompletedyears',
only=['0', '1', '2', '3', '4', '5'],
recode=ECD_AGE_CATEGORIES)
ecd_gender, total_ecd_gender = get_stat_data(
['gender'], geo_level, geo_code, session,
table_name='genderunder9')
women_child_bearing_age, total_women_child_bearing_age = get_stat_data(
['age groups in 5 years'], geo_level, geo_code, session,
table_name='womenagegroupsin5years15to44',
order_by='age groups in 5 years'
)
final_data = {
'total_population': {
"name": "People",
"values": {"this": total_pop}
},
'ecd_age_groups': ecd_age_groups,
'ecd_children': {
"name": "Children 5 years and younger",
"values": {"this": ecd_children}
},
'ecd_gender': ecd_gender,
'women_child_bearing_age': women_child_bearing_age,
'total_women_child_bearing_age': {
"name": "Women between the age of 15-44 years",
"values": {"this": total_women_child_bearing_age}
}
}
geo = geo_data.get_geography(geo_code, geo_level)
if geo.square_kms:
final_data['population_density'] = {
'name': "people per square kilometre",
'values': {"this": total_pop / geo.square_kms}
}
final_data['child_population_density'] = {
'name': 'Children (0-5 years) per square kilometre',
'values': {"this": ecd_children / geo.square_kms}
}
ecd_pop_density = OrderedDict()
for k, age_group in ecd_age_groups.iteritems():
if k != 'metadata':
ecd_pop_density[age_group['name']] = {
"name": age_group['name'],
"values": {
"this": age_group['numerators']['this'] / geo.square_kms
},
"numerators": {
"this": age_group['numerators']['this']
}
}
ecd_pop_density['metadata'] = ecd_age_groups['metadata']
final_data['ecd_pop_density'] = ecd_pop_density
return final_data
