def test_direct_answers_take_request_from_query(self, mock_request):
geocoding_result = Geocodes(
level_kind=LevelKind.city,
queries=[
RegionQuery(request='fooo'),
RegionQuery(request='barr'),
RegionQuery(request='bazz'),
],
answers=[
Answer([self.foo.set_query('').build_geocoded()]),
Answer([self.bar.set_query('').build_geocoded()]),
Answer([self.baz.set_query('').build_geocoded()]),
])
mock_request.return_value = make_success_response() \
.set_geocoded_features(
[
self.foo.set_query(self.bar_id).set_centroid(GeoPoint(0, 1)).build_geocoded(),
self.bar.set_query(self.foo_id).set_centroid(GeoPoint(0, 1)).build_geocoded(),
self.baz.set_query(self.baz_id).set_centroid(GeoPoint(0, 1)).build_geocoded(),
]
).build()
df = geocoding_result.centroids()
mock_request.assert_called_with(
RequestBuilder() \
.set_request_kind(RequestKind.explicit) \
.set_ids([self.foo.id, self.bar.id, self.baz.id]) \
.set_requested_payload([PayloadKind.centroids]) \
.build()
)
assert_row(df, names=['fooo', 'barr', 'bazz'])
def make_geocode_region(request: str,
name: str,
geo_object_id: str,
highlights: List[str],
level_kind: LevelKind = LevelKind.city) -> Geocodes:
return Geocodes(level_kind=level_kind,
queries=[RegionQuery(request=request)],
answers=[make_answer(name, geo_object_id, highlights)])
def test_to_dataframe(self):
df = Geocodes(
level_kind=LevelKind.city,
queries=[RegionQuery(request='FOO'),
RegionQuery(request='BAR')],
answers=features_to_answers(
[self.foo.build_geocoded(),
self.bar.build_geocoded()])).to_data_frame()
assert_row(df, names=['FOO', 'BAR'])
def test_exploding_answers_to_data_frame_take_request_from_feature_name(
self, mock_request):
foo_id = '123'
foo_name = 'foo'
bar_id = '456'
bar_name = 'bar'
geocoding_result = Geocodes(
level_kind=LevelKind.city,
queries=[RegionQuery(request=None)],
answers=[
Answer([
FeatureBuilder().set_id(foo_id).set_name(
foo_name).build_geocoded(),
FeatureBuilder().set_id(bar_id).set_name(
bar_name).build_geocoded()
])
])
mock_request.return_value = make_success_response() \
.set_geocoded_features(
[
FeatureBuilder().set_id(foo_id).set_query(foo_id).set_name(foo_name).set_centroid(
GeoPoint(0, 1)).build_geocoded(),
FeatureBuilder().set_id(bar_id).set_query(bar_id).set_name(bar_name).set_centroid(
GeoPoint(2, 3)).build_geocoded(),
]
).build()
df = geocoding_result.centroids()
mock_request.assert_called_with(
RequestBuilder() \
.set_request_kind(RequestKind.explicit)
.set_ids([foo_id, bar_id]) \
.set_requested_payload([PayloadKind.centroids]) \
.build()
)
assert_request_and_found_name_are_equal(df)
def test_df_rows_duplication_should_be_processed_correctly(
self, mock_request):
foo_id = '123'
foo_name = 'foo'
bar_id = '234'
bar_name = 'bar'
geocoding_result = Geocodes(level_kind=LevelKind.city,
queries=[
RegionQuery('foo'),
RegionQuery('bar'),
RegionQuery('foo')
],
answers=[
Answer([self.foo.build_geocoded()]),
Answer([self.bar.build_geocoded()]),
Answer([self.foo.build_geocoded()])
])
mock_request.return_value = make_success_response() \
.set_answers(
[
Answer([self.foo.set_query(foo_id).set_centroid(GeoPoint(0, 1)).build_geocoded()]),
Answer([self.bar.set_query(bar_id).set_centroid(GeoPoint(0, 1)).build_geocoded()])
]
).build()
df = geocoding_result.centroids()
mock_request.assert_called_with(
RequestBuilder() \
.set_request_kind(RequestKind.explicit) \
.set_ids([self.foo.id, self.bar.id]) \
.set_requested_payload([PayloadKind.centroids]) \
.build()
)
assert_row(df, names=['foo', 'bar', 'foo'])
def test_reorder_for_centroids_should_happen(mock_request):
new_york = FeatureBuilder().set_id('2').set_query('New York').set_name('New York').set_centroid(GeoPoint(0, 0)).build_geocoded()
las_vegas = FeatureBuilder().set_id('3').set_query('Las Vegas').set_name('Las Vegas').set_centroid(GeoPoint(0, 0)).build_geocoded()
los_angeles = FeatureBuilder().set_id('1').set_query('Los Angeles').set_name('Los Angeles').set_centroid(
GeoPoint(0, 0)).build_geocoded()
mock_request.return_value = make_success_response().set_geocoded_features([new_york, las_vegas, los_angeles]).build()
df = Geocodes(
level_kind=LevelKind.city,
queries=features_to_queries([los_angeles, new_york, las_vegas, los_angeles]),
answers=features_to_answers([los_angeles, new_york, las_vegas, los_angeles])
).centroids()
assert ['Los Angeles', 'New York', 'Las Vegas', 'Los Angeles'] == df[DF_COLUMN_FOUND_NAME].tolist()
def test_request_remove_duplicated_ids(mock_request):
try:
Geocodes(
level_kind=LEVEL_KIND,
queries=features_to_queries([FOO_FEATURE, FOO_FEATURE]),
answers=features_to_answers([FOO_FEATURE, FOO_FEATURE])
).centroids()
except ValueError:
pass # response doesn't contain proper feature with ids - ignore
mock_request.assert_called_with(
ExplicitRequest(
requested_payload=[PayloadKind.centroids],
ids=[FOO_FEATURE.id]
)
)
def make_simple_region(requests: Union[str, List[str]],
geo_object_ids: Union[str, List[str]] = None,
level_kind: LevelKind = LevelKind.county) -> Geocodes:
requests = requests if isinstance(requests, (list, tuple)) else [requests]
geo_object_ids = geo_object_ids if geo_object_ids is not None else [
request + '_id' for request in requests
]
geo_object_ids = geo_object_ids if isinstance(
geo_object_ids, (list, tuple)) else [geo_object_ids]
queries = []
answers = []
for request, id in zip(requests, geo_object_ids):
queries.append(RegionQuery(request=request))
answers.append(make_answer(request, id, []))
return Geocodes(level_kind, answers, queries)
def test_as_list(self):
regions = Geocodes(level_kind=LevelKind.city,
queries=features_to_queries([
self.foo.build_geocoded(),
self.bar.build_geocoded()
]),
answers=features_to_answers([
self.foo.build_geocoded(),
self.bar.build_geocoded()
])).as_list()
assert 2 == len(regions)
assert_row(regions[0].to_data_frame(),
names=self.foo.name,
id=self.foo.id,
found_name=self.foo.name)
assert_row(regions[1].to_data_frame(),
names=self.bar.name,
id=self.bar.id,
found_name=self.bar.name)
def make_geocoder(self) -> Geocoder:
usa = FeatureBuilder() \
.set_name(USA_NAME) \
.set_id(USA_ID) \
.set_highlights(USA_HIGHLIGHTS) \
.build_geocoded()
russia = FeatureBuilder() \
.set_name(RUSSIA_NAME) \
.set_id(RUSSIA_ID) \
.set_highlights(RUSSIA_HIGHLIGHTS) \
.build_geocoded()
geocodes = Geocodes(level_kind=LevelKind.country,
queries=features_to_queries([usa, russia]),
answers=features_to_answers([usa, russia]))
class StubGeocoder(Geocoder):
def _geocode(self) -> Geocodes:
return geocodes
return StubGeocoder()
@pytest.mark.parametrize('location,expected', [
# none
(None,
None
),
# single string
('name',
MapRegion.with_name('name')
),
# single region
(Geocodes(
level_kind=LEVEL_KIND,
queries=features_to_queries([FOO_FEATURE, BAR_FEATURE]),
answers=features_to_answers([FOO_FEATURE, BAR_FEATURE])
),
MapRegion.scope([feature_id(FOO), feature_id(BAR)])
),
# list of strings
([
'foo', 'bar'
],
[
MapRegion.with_name('foo'),
MapRegion.with_name('bar')
]
),