Use geocoding level instead of 'request' for a column name, remove da…

…ta_join_on/map_join_on, generate map_join for map automatically if map is a Geocoder object

livemap-demo/src/commonMain/kotlin/jetbrains/livemap/plotDemo/LiveMap.kt

@@ -89,8 +89,7 @@ class LiveMap : PlotConfigDemoBase() {
                   "geocoding": {
                     "url": "https://172.31.52.145:3025"
                   },
-                  "data_join_on": "States",
-                  "map_join_on": "request"
+                  "map_join": ["States", "state"]
                 }
               ]
             }
@@ -230,8 +229,7 @@ class LiveMap : PlotConfigDemoBase() {
                   "geocoding": {
                     "url": "https://172.31.52.145:3025"
                   },
-                  "data_join_on": "States",
-                  "map_join_on": "request"
+                  "map_join": ["States", "state"]
                 }
               ]
             }

plot-config-portable/src/commonMain/kotlin/jetbrains/datalore/plot/config/ConfigUtil.kt

@@ -9,6 +9,7 @@ import jetbrains.datalore.base.geometry.DoubleVector
 import jetbrains.datalore.plot.base.Aes
 import jetbrains.datalore.plot.base.DataFrame
 import jetbrains.datalore.plot.base.data.DataFrameUtil
+import jetbrains.datalore.plot.base.data.DataFrameUtil.findVariableOrFail
 import jetbrains.datalore.plot.base.data.DataFrameUtil.variables
 import jetbrains.datalore.plot.base.data.Dummies
 import jetbrains.datalore.plot.config.Option.Meta
@@ -45,7 +46,7 @@ object ConfigUtil {
         }
 
         fun computeMultiKeys(dataFrame: DataFrame, keyVarNames: List<*>): List<List<Any?>> {
-            val keyVars = keyVarNames.map { keyVarName -> variables(dataFrame)[keyVarName] ?: error("Key $keyVarName not found") }
+            val keyVars = keyVarNames.map { keyVarName -> findVariableOrFail(dataFrame, keyVarName as String)}
             return (0 until dataFrame.rowCount()).map { rowIndex -> keyVars.map { dataFrame.get(it)[rowIndex] } }
         }
 

plot-config-portable/src/commonMain/kotlin/jetbrains/datalore/plot/config/GeoConfig.kt

@@ -129,7 +129,7 @@ class GeoConfig(
         const val RECT_YMIN = "latmin"
         const val RECT_XMAX = "lonmax"
         const val RECT_YMAX = "latmax"
-        const val MAP_JOIN_REQUIRED_MESSAGE = "map_join or data_join_on/map_join_on is required when both data and map parameters used"
+        const val MAP_JOIN_REQUIRED_MESSAGE = "map_join is required when both data and map parameters used"
 
         fun isApplicable(layerOptions: Map<*, *>, combinedMappings: Map<*, *>): Boolean {
             if (combinedMappings.keys

plot-demo-common/src/commonMain/kotlin/jetbrains/datalore/plotDemo/model/plotConfig/Polygons.kt

@@ -239,8 +239,6 @@ open class Polygons : PlotConfigDemoBase() {
           "continent"
         ]
       ],
-      "data_join_on": null,
-      "map_join_on": null,
       "color": "white"
     }
   ]

python-package/lets_plot/geo_data/geocoder.py

@@ -5,8 +5,7 @@
 
 from pandas import Series
 
-from .geocodes import _to_level_kind, request_types, Geocodes, _raise_exception, \
-    _ensure_is_list
+from .geocodes import _to_level_kind, request_types, Geocodes, _raise_exception, _ensure_is_list
 from .gis.geocoding_service import GeocodingService
 from .gis.geometry import GeoRect, GeoPoint
 from .gis.request import RequestBuilder, GeocodingRequest, RequestKind, MapRegion, AmbiguityResolver, \
@@ -223,26 +222,18 @@ def __init__(self, lon, lat, level: Optional[Union[str, LevelKind]], scope=None)
 
     def _geocode(self) -> Geocodes:
         if self._geocodes is None:
-            self._geocodes = self._geocode()
+            response: Response = GeocodingService().do_request(self._request)
+            if not isinstance(response, SuccessResponse):
+                _raise_exception(response)
+            self._geocodes = Geocodes(
+                response.level,
+                response.answers,
+                [RegionQuery(request='[{}, {}]'.format(pt.lon, pt.lat)) for pt in self._request.coordinates],
+                highlights=False
+            )
 
         return self._geocodes
 
-    def _geocode(self):
-        response: Response = GeocodingService().do_request(self._request)
-
-        if not isinstance(response, SuccessResponse):
-            _raise_exception(response)
-
-        return Geocodes(
-            response.level,
-            response.answers,
-            [
-                RegionQuery(request='[{}, {}]'.format(pt.lon, pt.lat)) for pt in self._request.coordinates
-            ],
-            False
-        )
-
-
 
 class NamesGeocoder(Geocoder):
     def __init__(self,

python-package/lets_plot/geo_data/geocodes.py

@@ -14,14 +14,13 @@
 NO_OBJECTS_FOUND_EXCEPTION_TEXT = 'No objects were found.'
 MULTIPLE_OBJECTS_FOUND_EXCEPTION_TEXT = "Multiple objects were found. Use all_result=True to see them."
 
-DF_REQUEST = 'request'
-DF_ID = 'id'
-DF_FOUND_NAME = 'found name'
-DF_HIGHLIGHTS = 'highlights'
-DF_GROUP = 'group'
-DF_PARENT_COUNTRY = 'country'
-DF_PARENT_STATE = 'state'
-DF_PARENT_COUNTY = 'county'
+DF_COLUMN_ID = 'id'
+DF_COLUMN_FOUND_NAME = 'found name'
+DF_COLUMN_HIGHLIGHTS = 'highlights'
+DF_COLUMN_CITY = 'city'
+DF_COLUMN_COUNTRY = 'country'
+DF_COLUMN_STATE = 'state'
+DF_COLUMN_COUNTY = 'county'
 
 
 class Resolution(enum.Enum):
@@ -55,6 +54,19 @@ def select_request_string(request: Optional[str], name: str) -> str:
     return request
 
 
+def level_to_column_name(level_kind: LevelKind):
+    if level_kind == LevelKind.city:
+        return DF_COLUMN_CITY
+    elif level_kind == LevelKind.county:
+        return DF_COLUMN_COUNTY
+    elif level_kind == LevelKind.state:
+        return DF_COLUMN_STATE
+    elif level_kind == LevelKind.country:
+        return DF_COLUMN_COUNTRY
+    else:
+        raise ValueError('Unknown level kind: {}'.format(level_kind))
+
+
 def zip_answers(queries: List, answers: List):
     if len(queries) > 0:
         return zip(queries, answers)
@@ -63,7 +75,8 @@ def zip_answers(queries: List, answers: List):
 
 
 class PlacesDataFrameBuilder:
-    def __init__(self):
+    def __init__(self, level_kind: LevelKind):
+        self.level_kind: LevelKind = level_kind
         self._request: List[str] = []
         self._found_name: List[str] = []
         self._county: List[Optional[str]] = []
@@ -88,22 +101,25 @@ def contains_values(column):
             return any(v is not None for v in column)
 
         data = {}
-        data[DF_REQUEST] = self._request
-        data[DF_FOUND_NAME] = self._found_name
+
+        request_column = level_to_column_name(self.level_kind)
+
+        data[request_column] = self._request
+        data[DF_COLUMN_FOUND_NAME] = self._found_name
 
         if contains_values(self._county):
-            data[DF_PARENT_COUNTY] = self._county
+            data[DF_COLUMN_COUNTY] = self._county
 
         if contains_values(self._state):
-            data[DF_PARENT_STATE] = self._state
+            data[DF_COLUMN_STATE] = self._state
 
         if contains_values(self._country):
-            data[DF_PARENT_COUNTRY] = self._country
+            data[DF_COLUMN_COUNTRY] = self._country
 
         return data
 
     @abstractmethod
-    def to_data_frame(self, answers: List[Answer], queries: List[RegionQuery] = []) -> DataFrame:
+    def to_data_frame(self, answers: List[Answer], queries: List[RegionQuery], level_kind: LevelKind) -> DataFrame:
         raise ValueError('Not implemented')
 
 
@@ -283,10 +299,10 @@ def centroids(self):
         )
 
     def to_data_frame(self) -> DataFrame:
-        places = PlacesDataFrameBuilder()
+        places = PlacesDataFrameBuilder(self._level_kind)
 
         data = {}
-        data[DF_ID] = [feature.id for feature in self._geocoded_features]
+        data[DF_COLUMN_ID] = [feature.id for feature in self._geocoded_features]
 
         # for us-48 queries doesnt' count
         for query, answer in zip_answers(self._queries, self._answers):
@@ -296,7 +312,7 @@ def to_data_frame(self) -> DataFrame:
         data = {**data, **places.build_dict()}
 
         if self._highlights:
-            data[DF_HIGHLIGHTS] = [feature.highlights for feature in self._geocoded_features]
+            data[DF_COLUMN_HIGHLIGHTS] = [feature.highlights for feature in self._geocoded_features]
 
         return DataFrame(data)
 
@@ -313,7 +329,7 @@ def _execute(self, request_builder: RequestBuilder, df_converter):
 
         self._join_payload(features)
 
-        return df_converter.to_data_frame(self._answers, self._queries)
+        return df_converter.to_data_frame(self._answers, self._queries, self._level_kind)
 
     def _request_builder(self, payload_kind: PayloadKind) -> RequestBuilder:
         assert_type(payload_kind, PayloadKind)
@@ -343,6 +359,21 @@ def _get_features(self, feature_id: str) -> List[GeocodedFeature]:
         return [feature for feature in self._geocoded_features if feature.id == feature_id]
 
 
+    @classmethod
+    def find_name_columns(cls, geocodes_df) -> List[str]:
+        names = []
+        if DF_COLUMN_CITY in geocodes_df:
+            names.append(DF_COLUMN_CITY)
+        if DF_COLUMN_COUNTY in geocodes_df:
+            names.append(DF_COLUMN_COUNTY)
+        if DF_COLUMN_STATE in geocodes_df:
+            names.append(DF_COLUMN_STATE)
+        if DF_COLUMN_COUNTRY in geocodes_df:
+            names.append(DF_COLUMN_COUNTRY)
+
+        return names
+
+
 request_types = Optional[Union[str, List[str], Series]]
 
 

python-package/lets_plot/geo_data/to_geo_data_frame.py

@@ -5,8 +5,8 @@
 from pandas import DataFrame
 from shapely.geometry import box
 
-from lets_plot.geo_data import PlacesDataFrameBuilder, zip_answers, select_request_string, abstractmethod
-from lets_plot.geo_data.gis.request import RegionQuery
+from lets_plot.geo_data import PlacesDataFrameBuilder, zip_answers, abstractmethod
+from lets_plot.geo_data.gis.request import RegionQuery, LevelKind
 from lets_plot.geo_data.gis.response import Answer, GeocodedFeature, GeoRect, Boundary, Multipolygon, Polygon, GeoPoint
 
 ShapelyPoint = shapely.geometry.Point
@@ -40,9 +40,9 @@ def __init__(self):
         self._lonmax: List[float] = []
         self._latmax: List[float] = []
 
-    def to_data_frame(self, answers: List[Answer], queries: List[RegionQuery]) -> DataFrame:
+    def to_data_frame(self, answers: List[Answer], queries: List[RegionQuery], level_kind: LevelKind) -> DataFrame:
         assert len(answers) == len(queries)
-        places = PlacesDataFrameBuilder()
+        places = PlacesDataFrameBuilder(level_kind)
 
         for query, answer in zip_answers(queries, answers):
             for feature in answer.features:
@@ -80,8 +80,8 @@ def __init__(self):
         self._lons: List[float] = []
         self._lats: List[float] = []
 
-    def to_data_frame(self, answers: List[Answer], queries: List[RegionQuery]) -> DataFrame:
-        places = PlacesDataFrameBuilder()
+    def to_data_frame(self, answers: List[Answer], queries: List[RegionQuery], level_kind: LevelKind) -> DataFrame:
+        places = PlacesDataFrameBuilder(level_kind)
 
         for query, answer in zip_answers(queries, answers):
             for feature in answer.features:
@@ -97,8 +97,8 @@ class BoundariesGeoDataFrame:
     def __init__(self):
         super().__init__()
 
-    def to_data_frame(self, answers: List[Answer], queries: List[RegionQuery]) -> DataFrame:
-        places = PlacesDataFrameBuilder()
+    def to_data_frame(self, answers: List[Answer], queries: List[RegionQuery], level_kind: LevelKind) -> DataFrame:
+        places = PlacesDataFrameBuilder(level_kind)
 
         geometry = []
         for query, answer in zip_answers(queries, answers):