def test_df_rows_order(self, mock_request):
geocoding_result = Regions([
self.foo.set_query('').build_geocoded(),
self.bar.set_query('').build_geocoded(),
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 [self.foo.name, self.bar.name,
self.baz.name] == df[DF_REQUEST].tolist()
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 = Regions([
self.foo.set_query('').build_geocoded(),
self.bar.set_query('').build_geocoded(),
self.foo.set_query('').build_geocoded()
])
mock_request.return_value = make_success_response() \
.set_geocoded_features(
[
self.foo.set_query(foo_id).set_centroid(GeoPoint(0, 1)).build_geocoded(),
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 [self.foo.name, self.bar.name,
self.foo.name] == df[DF_REQUEST].tolist()
def test_geocoding_request():
foo = _query(request='foo')
bar = _query(request='bar',
scope=MapRegion.with_name('baz'),
ambiguity_resolver=AmbiguityResolver(
ignoring_strategy=IgnoringStrategyKind.skip_all))
request: GeocodingRequest = RequestBuilder() \
.set_request_kind(RequestKind.geocoding) \
.set_requested_payload([PayloadKind.boundaries, PayloadKind.centroids]) \
.set_resolution(123) \
.set_level(LevelKind.city) \
.set_namesake_limit(10) \
.set_queries([foo, bar]) \
.build()
json = RequestFormatter().format(request).to_dict()
parsed_request = RequestParser().parse(json)
assert isinstance(parsed_request, GeocodingRequest)
assert request.requested_payload == parsed_request.requested_payload
assert request.resolution == parsed_request.resolution
assert request.level == parsed_request.level
assert request.namesake_example_limit == parsed_request.namesake_example_limit
assert 2 == len(parsed_request.region_queries)
assert_region_query(foo, parsed_request.region_queries[0])
assert_region_query(bar, parsed_request.region_queries[1])
def test_df_request_when_query_is_empty_should_be_taken_from_found_name_column(
self, mock_request):
foo_id = '123'
foo_name = 'foo'
geocoding_result = Regions([
FeatureBuilder().set_id(foo_id).set_query('').set_name(
foo_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()
]
).build()
df = geocoding_result.centroids()
mock_request.assert_called_with(
RequestBuilder() \
.set_request_kind(RequestKind.explicit)
.set_ids([foo_id]) \
.set_requested_payload([PayloadKind.centroids]) \
.build()
)
assert foo_name == df[DF_REQUEST][0]
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 test_explicit_request():
request: ExplicitRequest = RequestBuilder() \
.set_request_kind(RequestKind.explicit) \
.set_ids(['1', '2', '3']) \
.build()
json = RequestFormatter().format(request).to_dict()
parsed_request = RequestParser().parse(json)
assert isinstance(parsed_request, ExplicitRequest)
assert request.requested_payload == parsed_request.requested_payload
assert request.resolution == parsed_request.resolution
assert request.geo_object_list == parsed_request.geo_object_list
def test_ambiguity_resolver():
foo = _query(request='foo', ambiguity_resolver=AmbiguityResolver(closest_coord=GeoPoint(1, 2)))
request: GeocodingRequest = RequestBuilder() \
.set_request_kind(RequestKind.geocoding) \
.set_namesake_limit(10) \
.set_queries([foo]) \
.build()
json = RequestFormatter().format(request).to_dict()
parsed_request = RequestParser().parse(json)
assert isinstance(parsed_request, GeocodingRequest)
assert 1 == len(parsed_request.region_queries)
assert_region_query(foo, parsed_request.region_queries[0])
def test_ambiguity_resolver_with_box():
foo = _query(request='foo', ambiguity_resolver=AmbiguityResolver(box=GeoRect(0, 1, 2, 3)))
request: GeocodingRequest = RequestBuilder() \
.set_request_kind(RequestKind.geocoding) \
.set_namesake_limit(10) \
.set_queries([foo]) \
.set_allow_ambiguous(True) \
.build()
json = RequestFormatter().format(request).to_dict()
parsed_request = RequestParser().parse(json)
assert isinstance(parsed_request, GeocodingRequest)
assert 1 == len(parsed_request.region_queries)
assert parsed_request.allow_ambiguous
assert_region_query(foo, parsed_request.region_queries[0])
def test_reverse_request():
request: ReverseGeocodingRequest = RequestBuilder() \
.set_request_kind(RequestKind.reverse) \
.set_reverse_coordinates([GeoPoint(1.0, 2.0)]) \
.set_level(LevelKind.city) \
.set_reverse_scope(MapRegion.with_name('foo_region')) \
.set_resolution(123) \
.set_requested_payload([PayloadKind.boundaries, PayloadKind.centroids]) \
.build()
json = RequestFormatter().format(request).to_dict()
parsed_request: ReverseGeocodingRequest = RequestParser().parse(json)
assert isinstance(parsed_request, ReverseGeocodingRequest)
assert request.requested_payload == parsed_request.requested_payload
assert request.resolution == parsed_request.resolution
assert request.coordinates == parsed_request.coordinates
assert request.level == parsed_request.level
assert request.scope == parsed_request.scope
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'])
