def test_where_scope_us_48_with_level():
name = 'oslo'
oslo_in_norway = geodata.geocode_cities(
names=name).scope('norway').get_geocodes()
oslo_in_usa = geodata.geocode_cities(
names=name).scope('us-48').get_geocodes()
assert oslo_in_norway.id[0] != oslo_in_usa.id[0]
def test_scope_us_48_with_level():
# Oslo is a city in Marshall County, Minnesota, United States
# Also Oslo is a capital of Norway
name = 'oslo'
oslo_in_norway = geodata.geocode_cities(name).where(
name, scope='norway').get_geocodes()
oslo_in_usa = geodata.geocode_cities(name).where(
name, scope='us-48').get_geocodes()
assert oslo_in_norway.id[0] != oslo_in_usa.id[0]
def test_none_parents_at_diff_levels():
warwick = geodata.geocode_cities('warwick').states('georgia').get_geocodes()
worcester = geodata.geocode_cities('worcester').countries('uk').get_geocodes()
cities = geodata.geocode_cities(['warwick', 'worcester'])\
.states(['Georgia', None])\
.countries([None, 'United Kingdom'])\
.get_geocodes()
assert_row(
cities,
names=['warwick', 'worcester'],
id=[warwick.id[0], worcester.id[0]]
)
def test_ambiguity_allow_ambiguous():
r = geodata.geocode_cities(['gotham', 'new york', 'manchester']) \
.allow_ambiguous() \
.get_geocodes()
actual = r[DF_COLUMN_FOUND_NAME].tolist()
assert 29 == len(actual) # 1 New York + 27 Manchester
def test_ambiguity_drop_not_matched():
r = geodata.geocode_cities(['gotham', 'new york', 'manchester']) \
.ignore_all_errors() \
.get_geocodes()
actual = r[DF_COLUMN_FOUND_NAME].tolist()
assert actual == ['New York']
def test_regions_parents_in_regions_object_and_geo_data_frame():
# parent request from regions object should be propagated to resulting GeoDataFrame
massachusetts = geodata.geocode_states('massachusetts')
boston = geodata.geocode_cities('boston').states(massachusetts)
assert_row(boston.get_geocodes(), names='boston', state='massachusetts', county=NO_COLUMN, country=NO_COLUMN)
assert_row(boston.get_centroids(), names='boston', state='massachusetts', county=NO_COLUMN, country=NO_COLUMN)
def test_name_columns(geometry_getter):
request = 'boston'
found_name = 'Boston'
boston = geodata.geocode_cities(request)
assert_row(boston.get_geocodes(), names=request, found_name=found_name)
assert_row(geometry_getter(boston), names=request, found_name=found_name)
def test_select_all_query_with_empty_result_should_return_empty_dataframe():
geocoder = geocode_cities().scope('foo')
geocodes = geocoder.get_geocodes()
assert 0 == len(geocodes)
centroids = geocoder.get_centroids()
assert 0 == len(centroids)
def test_request_scope_and_parent_county():
assert_that(geocode_cities('foo_city').counties('foo_county').scope('foo_country'))\
.has_level(eq(LevelKind.city))\
.has_scope(ScopeMatcher().with_names(['foo_country'])) \
.has_query(QueryMatcher()
.with_name('foo_city')
.county(eq_map_region_with_name('foo_county'))
)
def test_do_not_add_unsued_parents_columns():
moscow = geodata.geocode_cities('moscow').countries('russia')
assert moscow.get_geocodes().columns.tolist() == [DF_COLUMN_ID, COLUMN_NAME_CITY, DF_COLUMN_FOUND_NAME, DF_COLUMN_COUNTRY]
gdf_columns = [COLUMN_NAME_CITY, DF_COLUMN_FOUND_NAME, DF_COLUMN_COUNTRY, 'geometry']
assert moscow.get_limits().columns.tolist() == gdf_columns
assert moscow.get_centroids().columns.tolist() == gdf_columns
assert moscow.get_boundaries().columns.tolist() == gdf_columns
def test_all_columns_order():
boston = geodata.geocode_cities('boston').counties('suffolk').states('massachusetts').countries('usa')
assert boston.get_geocodes().columns.tolist() == [DF_COLUMN_ID, COLUMN_NAME_CITY, DF_COLUMN_FOUND_NAME, DF_COLUMN_COUNTY,
DF_COLUMN_STATE, DF_COLUMN_COUNTRY]
gdf_columns = [COLUMN_NAME_CITY, DF_COLUMN_FOUND_NAME, DF_COLUMN_COUNTY, DF_COLUMN_STATE, DF_COLUMN_COUNTRY, 'geometry']
assert boston.get_limits().columns.tolist() == gdf_columns
assert boston.get_centroids().columns.tolist() == gdf_columns
assert boston.get_boundaries().columns.tolist() == gdf_columns
def test_ambiguity_closest_to_boston_by_name():
r = geodata.geocode(
level='city',
names='Warwick'
) \
.where('Warwick', closest_to=geodata.geocode_cities('boston'))
assert_row(r.get_geocodes(), id=WARWICK_ID, found_name='Warwick')
assert_row(r.get_centroids(), lon=WARWICK_LON, lat=WARWICK_LAT)
def test_case():
usa = geodata.geocode_countries(names=['usa'])
states_48 = geodata.geocode_states(['us-48'])
states_list = ['NY', 'TX', 'louisiana']
states = geodata.geocode_states(names=states_list).scope(usa)
cities_list = ['New york', 'boston', 'la']
t_cities = geodata.geocode_cities(names=cities_list).scope(usa)
def test_ambiguity_drop_not_found():
try:
r = geodata.geocode_cities(['gotham', 'new york', 'manchester']) \
.ignore_not_found() \
.get_geocodes()
except ValueError as ex:
str(ex).startswith('Multiple objects (27) were found for manchester')
return
assert False, 'Should throw exception'
def test_where_scope_with_existing_country_in_df():
df = {
'city': ['moscow', 'tashkent', 'washington'],
'country': ['russia', 'uzbekistan', 'usa']
}
washington_county=geodata.geocode_counties('Washington county').states('iowa').countries('usa')
cities = geodata.geocode_cities(df['city']).countries(df['country'])\
.where('washington', country='usa', scope=washington_county)
assert_row(cities.get_geocodes(), index=2, names='washington', country='usa', found_name='Washington')
def test_rows_order():
city_names = [
'Boston', 'Phoenix', 'Tucson', 'Salt Lake City', 'Los Angeles',
'San Francisco'
]
city_regions = geodata.geocode_cities(city_names).scope('US')
# create path preserving the order
df = city_regions.get_centroids()
df = df.set_index(get_request_column_name(df))
df = df.reindex(city_names)
def test_parents_in_regions_object_and_geo_data_frame():
boston = geodata.geocode_cities('boston').counties('suffolk').states('massachusetts').countries('usa')
assert_row(boston.get_geocodes(), names='boston', county='suffolk', state='massachusetts', country='usa')
assert_row(boston.get_limits(), names='boston', county='suffolk', state='massachusetts', country='usa')
assert_row(boston.get_centroids(), names='boston', county='suffolk', state='massachusetts', country='usa')
assert_row(boston.get_boundaries(), names='boston', county='suffolk', state='massachusetts', country='usa')
# antimeridian
ru = geodata.geocode(level='country', names='russia')
assert_row(ru.get_geocodes(), country='russia', city=NO_COLUMN, county=NO_COLUMN, state=NO_COLUMN)
assert_row(ru.get_limits(), country=['russia', 'russia'], city=NO_COLUMN, county=NO_COLUMN, state=NO_COLUMN)
def test_list_of_regions_parents_in_regions_object_and_geo_data_frame():
# parent request from regions object should be propagated to resulting GeoDataFrame
states = geodata.geocode_states(['massachusetts', 'texas'])
cities = geodata.geocode_cities(['boston', 'austin']).states(states)
assert_row(cities.get_geocodes(),
names=['boston', 'austin'],
state=['massachusetts', 'texas'],
county=NO_COLUMN,
country=NO_COLUMN
)
assert_row(cities.get_geocodes(),
names=['boston', 'austin'],
state=['massachusetts', 'texas'],
county=NO_COLUMN,
country=NO_COLUMN
)
def test_ambiguity_scope_boston_by_box():
boston = geodata.geocode_cities('boston').get_centroids().iloc[[0]]
buffer = 0.6
boston_centroid = ShapelyPoint(boston.geometry.x, boston.geometry.y)
r = geodata.geocode(
level='city',
names='Warwick'
) \
.where('Warwick',
scope=shapely.geometry.box(
boston_centroid.x - buffer,
boston_centroid.y - buffer,
boston_centroid.x + buffer,
boston_centroid.y + buffer
))
assert_row(r.get_geocodes(), id=WARWICK_ID, found_name='Warwick')
assert_row(r.get_centroids(), lon=WARWICK_LON, lat=WARWICK_LAT)
def test_allow_ambiguous_result_should_keep_request():
cities = geocode_cities('foo')
assert_row(cities.get_geocodes(),
names=['foo', 'foo', 'foo'],
found_name=['Foo', 'Foo', 'Fooo'])
def test_where_west_warwick():
warwick = geodata.geocode_cities('west warwick').states('rhode island')
assert_row(warwick.get_geocodes(), names='west warwick', state='rhode island', found_name='West Warwick', id='382429')
assert_row(warwick.get_centroids(), lon=-71.5257788638961, lat=41.6969098895788)
def test_parent_states_us48():
boston = geodata.geocode_cities('boston').states('us-48').get_geocodes()
assert_row(boston, names='boston', found_name='Boston')
def test_query_scope_with_different_level_should_work():
geodata.geocode_cities(['moscow', 'worcester'])\
.where('moscow', scope='russia')\
.where('worcester', scope='massachusetts')\
.get_geocodes()
def test_city_with_ambiguous_county_and_scope():
assert_error(
"Region is not found: worcester county",
lambda: geodata.geocode_cities('worcester').counties('worcester county').scope('usa').get_geocodes()
)
def test_where_scope_with_existing_country():
washington_county=geodata.geocode_counties('Washington county').states('iowa').countries('usa')
washington = geodata.geocode_cities('washington').countries('United States of America')\
.where('washington', country='United States of America', scope=washington_county)
assert_row(washington.get_geocodes(), names='washington', country='United States of America', found_name='Washington')
def test_empty_request_centroid():
orange_county = geodata.geocode_counties('orange county').scope(
'north carolina')
r = geodata.geocode_cities().scope(orange_county)
df = r.get_centroids()
assert_request_and_found_name_are_equal(df)
def test_request_in_ambiguous_df():
warwick = geodata.geocode_cities('warwick').allow_ambiguous().get_geocodes()
assert_row(warwick, names='warwick', found_name='Warwick')
def test_positional_regions():
df = geodata.geocode_cities(['york',
'york']).states(['New York',
'Illinois']).get_geocodes()
assert ['New York', 'Little York'] == df['found name'].tolist()
def test_where_scope():
worcester = geodata.geocode_cities('worcester').where('worcester', scope=box(-71.00, 42.00, -72.00, 43.00))
assert_row(worcester.get_geocodes(), names='worcester', found_name='Worcester', id='3688419')
assert_row(worcester.get_centroids(), lon=-71.8154652712922, lat=42.2678737342358)
def test_where_with_parent():
washington_county=geodata.geocode_counties('Washington county').states('Vermont').countries('usa')
geodata.geocode_cities(['worcester', 'worcester']) \
.countries(['usa', 'Great Britain']) \
.where('worcester', country='usa', scope=washington_county) \
.get_geocodes()
