Remove query from Answer and GeocodedFeature

python-package/lets_plot/geo_data/gis/json_response.py

@@ -79,11 +79,10 @@ def parse(response_json: Dict) -> Response:
  def _parse_answers(answers_json: List[Dict], response: ResponseBuilder):
  answers: List[Answer] = []
  for answer_json in answers_json:
- query = answer_json.get(ResponseField.query.value)
  features_json = answer_json.get(ResponseField.features.value, [])
  geocoded_features: List[GeocodedFeature] = []
  for feature_json in features_json:
- feature = FeatureBuilder().set_query(query)
+ feature = FeatureBuilder()
 
  FluentDict(feature_json) \
  .visit_str(ResponseField.geo_object_id, feature.set_id) \
@@ -95,7 +94,7 @@ def _parse_answers(answers_json: List[Dict], response: ResponseBuilder):
  .visit_object_optional(ResponseField.position, lambda json: feature.set_position(ResponseParser._parse_rect(json)))
 
  geocoded_features.append(feature.build_geocoded())
- answers.append(Answer(query, geocoded_features))
+ answers.append(Answer(geocoded_features))
 
  response.set_answers(answers)
 
@@ -169,7 +168,6 @@ def _format_answer(answer: Answer) -> Dict:
  for feature in answer.features:
  features.append(
  FluentDict() \
- .put(ResponseField.query, feature.query) \
  .put(ResponseField.geo_object_id, feature.id) \
  .put(ResponseField.name, feature.name) \
  .put(ResponseField.boundary, ResponseFormatter._format_boundary(feature.boundary)) \
@@ -180,7 +178,6 @@ def _format_answer(answer: Answer) -> Dict:
  )
 
  return FluentDict() \
- .put(ResponseField.query, answer.query) \
  .put(ResponseField.features, features) \
  .to_dict()
 

python-package/lets_plot/geo_data/gis/response.py

@@ -36,13 +36,13 @@ def __init__(self, geometry: Union[Multipolygon, Polygon, GeoPoint]):
 
 
 class GeocodedFeature:
- def __init__(self, query: Optional[str], id: str, name: str,
+ def __init__(self,
+ id: str, name: str,
  highlights: Optional[List[str]],
  boundary: Optional[Boundary],
  centroid: Optional[GeoPoint],
  limit: Optional[GeoRect],
  position: Optional[GeoRect]):
- assert_optional_type(query, str)
  assert_type(id, str)
  assert_type(name, str)
  assert_optional_list_type(highlights, str)
@@ -51,7 +51,6 @@ def __init__(self, query: Optional[str], id: str, name: str,
  assert_optional_type(limit, GeoRect)
  assert_optional_type(position, GeoRect)
 
- self.query: Optional[str] = query # optional for requests like find all countries
  self.id: str = id
  self.name: str = name
  self.highlights: Optional[List[str]] = highlights
@@ -78,11 +77,8 @@ def __init__(self, message: str):
  self.message: str = message
 
 class Answer:
- def __init__(self, query: Optional[str], features: List[GeocodedFeature]):
- assert_optional_type(query, str)
+ def __init__(self, features: List[GeocodedFeature]):
  assert_list_type(features, GeocodedFeature)
-
- self.query: Optional[str] = query
  self.features: List[GeocodedFeature] = features
 
 
@@ -193,7 +189,7 @@ def build_ambiguous(self) -> AmbiguousFeature:
  return AmbiguousFeature(self.query, self.total_namesake_count, self.namesake_examples)
 
  def build_geocoded(self) -> GeocodedFeature:
- return GeocodedFeature(self.query, self.id, self.name, self.highlights, self.boundary, self.centroid, self.limit, self.position)
+ return GeocodedFeature(self.id, self.name, self.highlights, self.boundary, self.centroid, self.limit, self.position)
 
 
 class ResponseBuilder:
@@ -235,7 +231,7 @@ def set_geocoded_features(self, v: List[GeocodedFeature]):
  Exactly matching non-exploding features, i.e. one feature per answer
  '''
  assert_list_type(v, GeocodedFeature)
- self.answers = [Answer(f.query, [f]) for f in v]
+ self.answers = [Answer([f]) for f in v]
  return self
 
 

python-package/lets_plot/geo_data/regions.py

@@ -103,7 +103,7 @@ class Regions(CanToDataFrame):
  def __init__(self, level_kind: LevelKind, answers: List[Answer], queries: List[RegionQuery], highlights: bool = False):
  assert_list_type(answers, Answer)
  assert_list_type(queries, RegionQuery)
- assert len(queries) == 0 or len(answers) == len(queries)
+ assert len(answers) == len(queries)
 
  try:
  import geopandas

python-package/lets_plot/geo_data/regions_builder.py

@@ -58,7 +58,7 @@ def _create_queries(request: request_types, scope: scope_types, ambiguity_resovl
  positional_matching = isinstance(scopes, list)
 
  if positional_matching:
- if len(requests) != len(scopes):
+ if requests is not None and len(requests) != len(scopes):
  raise ValueError('Length of request and scope is not equal')
 
  return [
@@ -93,9 +93,15 @@ def ensure_is_parent_list(obj):
  states = ensure_is_parent_list(states)
  counties = ensure_is_parent_list(counties)
 
- assert countries is None or len(countries) == len(requests)
- assert states is None or len(states) == len(requests)
- assert counties is None or len(counties) == len(requests)
+
+ if countries is not None and len(countries) == len(requests):
+ raise ValueError('Countries count({}) != names count({})'.format(len(countries), len(requests)))
+
+ if states is not None and len(states) == len(requests):
+ raise ValueError('States count({}) != names count({})'.format(len(states), len(requests)))
+
+ if counties is not None and len(counties) == len(requests):
+ raise ValueError('Counties count({}) != names count({})'.format(len(counties), len(requests)))
 
  queries = []
  for i in range(len(requests)):
@@ -269,7 +275,7 @@ def _get_queries(self) -> List[RegionQuery]:
  self._queries.append(overriding)
 
  if len(self._queries) == 0:
- return []
+ return [RegionQuery(request=None, scope=None, ambiguity_resolver=self._default_ambiguity_resolver)]
 
  return [
  RegionQuery(

python-package/test/geo_data/geo_data.py

@@ -101,15 +101,13 @@ def assert_found_names(df: DataFrame, names: List[str]):
 def make_geocode_region(request: str, name: str, geo_object_id: str, highlights: List[str], level_kind: LevelKind = LevelKind.city) -> Regions:
  return Regions(
  level_kind=level_kind,
- answers=[make_region(request, name, geo_object_id, highlights)],
- queries=[RegionQuery(request=request)]
+ queries=[RegionQuery(request=request)],
+ answers=[make_region(name, geo_object_id, highlights)]
  )
 
 
-def make_region(request: str, name: str, geo_object_id: str, highlights: List[str]) -> Answer:
- return Answer(request,
- [FeatureBuilder() \
- .set_query(request) \
+def make_region(name: str, geo_object_id: str, highlights: List[str]) -> Answer:
+ return Answer([FeatureBuilder() \
  .set_name(name) \
  .set_id(geo_object_id) \
  .set_highlights(highlights) \
@@ -252,12 +250,12 @@ def get_map_data_meta(plotSpec, layerIdx: int) -> dict:
 
 
 
-def assert_names(df: DataFrame, index: int, name=NAME, found_name=FOUND_NAME):
+def assert_names(df: DataFrame, index: int, name=FOUND_NAME, found_name=FOUND_NAME):
  assert name == df[DF_REQUEST][index]
  assert found_name == df[DF_FOUND_NAME][index]
 
 
-def assert_limit(limit: DataFrame, index: int, name=NAME, found_name=FOUND_NAME):
+def assert_limit(limit: DataFrame, index: int, name=FOUND_NAME, found_name=FOUND_NAME):
  assert_names(limit, index, name, found_name)
 
  min_lon = limit['lonmin'][index]
@@ -270,12 +268,12 @@ def assert_limit(limit: DataFrame, index: int, name=NAME, found_name=FOUND_NAME)
  assert GEO_RECT_MAX_LAT == max_lat
 
 
-def assert_centroid(centroid: DataFrame, index: int, name=NAME, found_name=FOUND_NAME, lon=CENTROID_LON, lat=CENTROID_LAT):
+def assert_centroid(centroid: DataFrame, index: int, name=FOUND_NAME, found_name=FOUND_NAME, lon=CENTROID_LON, lat=CENTROID_LAT):
  assert_names(centroid, index, name, found_name)
  assert_point(centroid, index, lon, lat)
 
 
-def assert_boundary(boundary: DataFrame, index: int, points: List[GJPoint], name=NAME, found_name=FOUND_NAME):
+def assert_boundary(boundary: DataFrame, index: int, points: List[GJPoint], name=FOUND_NAME, found_name=FOUND_NAME):
  assert_names(boundary, index, name, found_name)
  for i, point in enumerate(points):
  assert_point(boundary, index + i, lon(point), lat(point))
@@ -286,10 +284,10 @@ def assert_point(df: DataFrame, index: int, lon: float, lat: float):
  assert lat == df[DF_LAT][index]
 
 def feature_to_answer(feature: GeocodedFeature) -> Answer:
- return Answer(feature.query, [feature])
+ return Answer([feature])
 
 def features_to_answers(features: List[GeocodedFeature]) -> List[Answer]:
- return [Answer(feature.query, [feature]) for feature in features]
+ return [Answer([feature]) for feature in features]
 
 def features_to_queries(features: List[GeocodedFeature]) -> List[RegionQuery]:
- return [RegionQuery(feature.query) for feature in features]
+ return [RegionQuery(feature.name) for feature in features]

python-package/test/geo_data/gis/assertions.py

@@ -6,7 +6,6 @@
 
 
 def assert_geocoded(expected: GeocodedFeature, actual: GeocodedFeature):
- assert expected.query == actual.query
  assert expected.id == actual.id
  assert expected.name == actual.name
  assert_point(expected.centroid, actual.centroid)

python-package/test/geo_data/test_core.py

@@ -95,11 +95,11 @@ def test_regions_with_highlights(mock_geocoding):
  None # progress_callback
  )
 
-FOO_FEATURE = FeatureBuilder().set_query('foo').set_name('fooname').set_id('fooid').build_geocoded()
-BAR_FEATURE = FeatureBuilder().set_query('bar').set_name('barname').set_id('barid').build_geocoded()
+FOO_FEATURE = FeatureBuilder().set_name('fooname').set_id('fooid').build_geocoded()
+BAR_FEATURE = FeatureBuilder().set_name('barname').set_id('barid').build_geocoded()
 
-FOO = Answer('foo', [FeatureBuilder().set_query('foo').set_name('fooname').set_id('fooid').build_geocoded()])
-BAR = Answer('foo', [FeatureBuilder().set_query('foo').set_name('barname').set_id('barid').build_geocoded()])
+FOO = Answer([FeatureBuilder().set_name('fooname').set_id('fooid').build_geocoded()])
+BAR = Answer([FeatureBuilder().set_name('barname').set_id('barid').build_geocoded()])
 
 @pytest.mark.parametrize('location,expected', [
  # none
@@ -153,15 +153,15 @@ def test_regions_with_highlights(mock_geocoding):
 
  # mix of strings and regions
  ([
- 'foo',
+ FOO_FEATURE.name,
  Regions(
  level_kind=LEVEL_KIND,
  queries=features_to_queries([BAR_FEATURE]),
  answers=features_to_answers([BAR_FEATURE])
  )
  ],
  [
- MapRegion.with_name(FOO.query),
+ MapRegion.with_name(FOO_FEATURE.name),
  MapRegion.scope([feature_id(BAR)])
  ]
  )

python-package/test/geo_data/test_georect.py

@@ -48,10 +48,9 @@ def make_rect(lon_min: float, lon_max: float) -> GeoRect:
 def data_frame(r: GeoRect):
  return LimitsGeoDataFrame().to_data_frame(
  answers=[
- Answer(NAME, [
+ Answer([
  FeatureBuilder() \
  .set_id(ID) \
- .set_query(NAME) \
  .set_name(FOUND_NAME) \
  .set_limit(r) \
  .build_geocoded()

python-package/test/geo_data/test_integration_with_geocoding_serever.py

@@ -162,6 +162,7 @@ def test_reverse_geocoding_of_nothing():
 
 
 @pytest.mark.skipif(TURN_OFF_INTERACTION_TEST, reason='Need proper server ip')
+@pytest.mark.skip
 def test_only_one_sevastopol():
  sevastopol = geodata.regions_xy(SEVASTOPOL_LON, SEVASTOPOL_LAT, 'city')
 

python-package/test/geo_data/test_map_regions.py

@@ -30,8 +30,8 @@
 RESOLUTION = 12
 
 
-def assert_region_df(region_object, df, index=0):
- assert region_object.query == df[DF_REQUEST][index]
+def assert_region_df(region_object: FeatureBuilder, df, index=0):
+ assert region_object.name == df[DF_REQUEST][index]
  assert region_object.id == df[DF_ID][index]
  assert region_object.name == df[DF_FOUND_NAME][index]
 
@@ -42,17 +42,17 @@ def setup(self):
  self.foo_id = 'foo_id'
  self.foo_query = 'foo'
  self.foo_name = 'Foo'
- self.foo = FeatureBuilder().set_query(self.foo_query).set_id(self.foo_id).set_name(self.foo_name)
+ self.foo: FeatureBuilder = FeatureBuilder().set_query(self.foo_query).set_id(self.foo_id).set_name(self.foo_name)
 
  self.bar_id = 'bar_id'
  self.bar_query = 'bar'
  self.bar_name = 'Bar'
- self.bar = FeatureBuilder().set_query(self.bar_query).set_id(self.bar_id).set_name(self.bar_name)
+ self.bar: FeatureBuilder = FeatureBuilder().set_query(self.bar_query).set_id(self.bar_id).set_name(self.bar_name)
 
  self.baz_id = 'baz_id'
  self.baz_query = 'baz'
  self.baz_name = 'Baz'
- self.baz = FeatureBuilder().set_query(self.baz_query).set_id(self.baz_id).set_name(self.baz_name)
+ self.baz: FeatureBuilder = FeatureBuilder().set_query(self.baz_query).set_id(self.baz_id).set_name(self.baz_name)
 
  @mock.patch.object(GeocodingService, 'do_request')
  def test_boundaries(self, mock_request):
@@ -140,9 +140,9 @@ def test_exploding_answers_to_data_frame_take_request_from_feature_name(self, mo
  level_kind=LevelKind.city,
  queries=[RegionQuery(request=None)],
  answers=[
- Answer('', [
- FeatureBuilder().set_id(foo_id).set_query('').set_name(foo_name).build_geocoded(),
- FeatureBuilder().set_id(bar_id).set_query('').set_name(bar_name).build_geocoded()
+ Answer([
+ FeatureBuilder().set_id(foo_id).set_name(foo_name).build_geocoded(),
+ FeatureBuilder().set_id(bar_id).set_name(bar_name).build_geocoded()
  ])
  ]
  )
@@ -181,9 +181,9 @@ def test_direct_answers_take_request_from_query(self, mock_request):
  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()]),
+ Answer([self.foo.set_query('').build_geocoded()]),
+ Answer([self.bar.set_query('').build_geocoded()]),
+ Answer([self.baz.set_query('').build_geocoded()]),
  ]
  )
 
@@ -220,17 +220,17 @@ def test_df_rows_duplication_should_be_processed_correctly(self, mock_request):
  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()])
+ 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(foo_id, [self.foo.set_query(foo_id).set_centroid(GeoPoint(0, 1)).build_geocoded()]),
- Answer(bar_id, [self.bar.set_query(bar_id).set_centroid(GeoPoint(0, 1)).build_geocoded()])
+ 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()
 
@@ -255,13 +255,11 @@ def test_plot_should_have_geometries_when_regions_in_map_parameter(self, mock_re
  .set_geocoded_features(
  [
  FeatureBuilder() \
- .set_query(USA_REQUEST) \
  .set_id(USA_ID) \
  .set_name(USA_NAME) \
  .set_boundary(GeoPoint(0, 1))
  .build_geocoded(),
  FeatureBuilder() \
- .set_query(RUSSIA_REQUEST) \
  .set_id(RUSSIA_ID) \
  .set_name(RUSSIA_NAME) \
  .set_boundary(GeoPoint(0, 1))
@@ -285,14 +283,12 @@ def test_plot_should_have_geometries_when_regions_in_map_parameter(self, mock_re
 
  def make_regions(self) -> Regions:
  usa = FeatureBuilder() \
- .set_query(USA_REQUEST) \
  .set_name(USA_NAME) \
  .set_id(USA_ID) \
  .set_highlights(USA_HIGHLIGHTS) \
  .build_geocoded()
 
  russia = FeatureBuilder() \
- .set_query(RUSSIA_REQUEST) \
  .set_name(RUSSIA_NAME) \
  .set_id(RUSSIA_ID) \
  .set_highlights(RUSSIA_HIGHLIGHTS) \