WIP: parents

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

@@ -101,9 +101,9 @@ def _format_region_queries(region_queires: List[RegionQuery]) -> List[Dict]:
  result.append(
  FluentDict()
  .put(Field.region_query_names, [] if query.request is None else [query.request])
- .put(Field.region_query_countries, query.country)
- .put(Field.region_query_states, query.state)
- .put(Field.region_query_counties, query.county)
+ .put(Field.region_query_countries, RequestFormatter._format_map_region(query.country))
+ .put(Field.region_query_states, RequestFormatter._format_map_region(query.state))
+ .put(Field.region_query_counties, RequestFormatter._format_map_region(query.county))
  .put(Field.ambiguity_resolver, None if query.ambiguity_resolver is None else FluentDict()
  .put(Field.ambiguity_ignoring_strategy, query.ambiguity_resolver.ignoring_strategy)
  .put(Field.ambiguity_box, RequestFormatter._format_box(query.ambiguity_resolver.box))

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

@@ -45,42 +45,77 @@ class LevelKind(enum.Enum):
 class MapRegionKind(enum.Enum):
  id = True
  name = False
+ place = 'place'
 
 
 class MapRegion:
+ '''
+ Represents three different entities:
+ scope - ids of already geocoded objects. The only kind of MapRegion allowed to store multiply objects
+ place - already geocoded single place. In addition to id it holds administrative level and requeted name.
+ Used mostly as parent object for geocoding other objects.
+ with_name - single name, not yet geocoded.
+ '''
  @staticmethod
- def with_single_id(parent_ids: List[str]):
- assert_list_type(parent_ids, str)
- assert len(parent_ids) == 1, 'Single id MapRegion expected. Actual number of ids: ' + len(parent_ids)
- return MapRegion(MapRegionKind.id, parent_ids, ids_limit)
+ def request_or_none(place: Optional['MapRegion']):
+ if place is None:
+ return None
+
+ assert place.kind == MapRegionKind.place, 'Only palce MapRegion contains request'
+ return place._request
+
+
+ @staticmethod
+ def place(id: str, request: str, level_kind: LevelKind):
+ assert_type(id, str)
+ assert_type(request, str)
+ assert_type(level_kind, LevelKind)
+ return MapRegion(MapRegionKind.place, [id], request, level_kind)
 
- def with_ids(parent_ids: List[str]):
+ @staticmethod
+ def scope(parent_ids: List[str]):
  assert_list_type(parent_ids, str)
- return MapRegion(MapRegionKind.id, parent_ids, ids_limit)
+ return MapRegion(MapRegionKind.id, parent_ids)
 
  @staticmethod
  def with_name(name: str):
  assert_type(name, str)
  return MapRegion(MapRegionKind.name, [name])
 
- def __init__(self, kind: MapRegionKind, values: List[str]):
+ def __init__(self, kind: MapRegionKind, values: List[str], request: Optional[str] = None, level_kind: Optional[LevelKind] = None):
  assert_type(kind, MapRegionKind)
  assert_list_type(values, str)
+ assert_optional_type(request, str)
+ assert_optional_type(level_kind, LevelKind)
 
  self.kind: MapRegionKind = kind
  self.values: Tuple[str] = tuple(values, )
- self._ids_limit: Optional[int] = ids_limit
+ self._request:Optional[str] = request
+ self._level_kind: Optional[LevelKind] = level_kind
  self._hash = hash((self.values, self.kind))
 
+ def request(self) -> Optional[str]:
+ assert self.kind == MapRegionKind.place, 'Invalid MapRegion kind: only place contains request'
+ return self._request
+
+ def level_kind(self) -> Optional[LevelKind]:
+ assert self.kind == MapRegionKind.place, 'Invalid MapRegion kind: only place contains level_kind'
+ return self._level_kind
+
  def __eq__(self, other: 'MapRegion'):
  return isinstance(other, MapRegion) \
  and self.kind == other.kind \
- and self.values == other.values
+ and self.values == other.values \
+ and self._request == other._request \
+ and self._level_kind == other._level_kind
 
  def __ne__(self, o: object) -> bool:
  return not self == o
 
  def __str__(self):
+ if self.kind == MapRegionKind.place:
+ return '{} {} {}'.format(str(self.values), self._request, self._level_kind)
+
  return str(self.values)
 
  def __hash__(self):
@@ -134,9 +169,9 @@ def __init__(self,
  self.request: Optional[str] = request
  self.scope: Optional[MapRegion] = scope
  self.ambiguity_resolver: AmbiguityResolver = ambiguity_resolver
- self.country = country
- self.state = state
- self.county = county
+ self.country: Optional[MapRegion] = country
+ self.state: Optional[MapRegion] = state
+ self.county: Optional[MapRegion] = county
 
  def __eq__(self, o: object) -> bool:
  return isinstance(o, RegionQuery) \
@@ -284,7 +319,7 @@ def __ne__(self, o: object) -> bool:
 
 class RequestBuilder:
  def __init__(self):
- self.request_kind: RequestKind = None
+ self.request_kind: Optional[RequestKind] = None
  self.requested_payload: List[PayloadKind] = []
  self.resolution: Optional[int] = None
  self.ids: List[str] = []
@@ -294,7 +329,7 @@ def __init__(self):
  self.allow_ambiguous: bool = False
 
  # reverse
- self.reverse_coordinates: List[GeoPoint] = None
+ self.reverse_coordinates: Optional[List[GeoPoint]] = None
  self.reverse_scope: Optional[MapRegion] = None
 
  def set_reverse_coordinates(self, coordinates: List[GeoPoint]) -> 'RequestBuilder':
@@ -387,7 +422,7 @@ def build(self) -> Optional[MapRegion]:
 
 class RegionQueryBuilder:
  def __init__(self):
- self.request: Optional[str] = []
+ self.request: Optional[str] = None
  self.scope: Optional[MapRegion] = None
  self.ignoring_strategy: Optional[IgnoringStrategyKind] = None
  self.closest_coord: Optional[GeoPoint] = None

python-package/lets_plot/geo_data/regions.py

@@ -48,42 +48,28 @@ def contains_values(column):
 def select_not_empty_name(feature: GeocodedFeature) -> str:
  return feature.name if feature.query is None or feature.query == '' else feature.query
 
-def select_parents(queries: List[RegionQuery] = None) -> Dict:
- if queries is None:
- return {}
-
- data = {}
-
- counties = [query.county for query in queries]
- if contains_values(counties):
- data[DF_PARENT_COUNTY] = counties
-
- states = [query.state for query in queries]
- if contains_values(states):
- data[DF_PARENT_STATE] = states
-
- countries = [query.country for query in queries]
- if contains_values(countries):
- data[DF_PARENT_COUNTRY] = countries
-
- return data
-
 
 class PlacesDataFrameBuilder:
  def __init__(self):
  self._request: List[str] = []
  self._found_name: List[str] = []
- self._county: List[str] = []
- self._state: List[str] = []
- self._country: List[str] = []
+ self._county: List[Optional[str]] = []
+ self._state: List[Optional[str]] = []
+ self._country: List[Optional[str]] = []
 
- def append_row(self, request: str, found_name: str, parents: Dict, parent_row: int):
+ def append_row(self, request: str, found_name: str, queries: Optional[List[RegionQuery]], parent_row: int):
  self._request.append(request)
  self._found_name.append(found_name)
 
- self._county.append(parents[DF_PARENT_COUNTY][parent_row] if DF_PARENT_COUNTY in parents else None)
- self._state.append(parents[DF_PARENT_STATE][parent_row] if DF_PARENT_STATE in parents else None)
- self._country.append(parents[DF_PARENT_COUNTRY][parent_row] if DF_PARENT_COUNTRY in parents else None)
+ if queries is None or len(queries) == 0:
+ self._county.append(None)
+ self._state.append(None)
+ self._country.append(None)
+ else:
+ query: RegionQuery = queries[parent_row]
+ self._county.append(MapRegion.request_or_none(query.county))
+ self._state.append(MapRegion.request_or_none(query.state))
+ self._country.append(MapRegion.request_or_none(query.country))
 
 
  def build_dict(self):
@@ -104,12 +90,12 @@ def build_dict(self):
 
 
  @abstractmethod
- def to_data_frame(self, features: List[GeocodedFeature], queries: List[RegionQuery] = None) -> DataFrame:
+ def to_data_frame(self, features: List[GeocodedFeature], queries: List[RegionQuery] = []) -> DataFrame:
  raise ValueError('Not implemented')
 
 
 class Regions(CanToDataFrame):
- def __init__(self, level_kind: LevelKind, features: List[GeocodedFeature], highlights: bool = False, queries: List[RegionQuery] = None):
+ def __init__(self, level_kind: LevelKind, features: List[GeocodedFeature], highlights: bool = False, queries: List[RegionQuery] = []):
  try:
  import geopandas
  except:
@@ -126,6 +112,9 @@ def __repr__(self):
  def __len__(self):
  return len(self._geocoded_features)
 
+ def to_map_regions(self):
+ return [MapRegion.place(feature.id, feature.query, self._level_kind) for feature in self._geocoded_features]
+
  def as_list(self) -> List['Regions']:
  return [Regions(self._level_kind, [feature], self._highlights) for feature in self._geocoded_features]
 
@@ -257,15 +246,17 @@ def centroids(self):
 
  # implements abstract in CanToDataFrame
  def to_data_frame(self) -> DataFrame:
- parents = select_parents(self._queries)
  places = PlacesDataFrameBuilder()
 
  data = {}
  data[DF_ID] = [feature.id for feature in self._geocoded_features]
 
+ # for us-48 queries doesnt' count
+ queries = self._queries if len(self._queries) == len(self._geocoded_features) else None
+
  for i in range(len(self._geocoded_features)):
  feature = self._geocoded_features[i]
- places.append_row(select_not_empty_name(feature), feature.name, parents, i)
+ places.append_row(select_not_empty_name(feature), feature.name, queries, i)
 
  data = {**data, **places.build_dict()}
 
@@ -416,7 +407,8 @@ def _make_parent_region(place: parent_types) -> Optional[MapRegion]:
  return MapRegion.with_name(place)
 
  if isinstance(place, Regions):
- return MapRegion.with_single_id(place.unique_ids())
+ assert len(place.to_map_regions()) == 1, 'Region object used as parent should contain only single record'
+ return place.to_map_regions()[0]
 
  raise ValueError('Unsupported parent type: ' + str(type(place)))
 
@@ -427,7 +419,7 @@ def _to_scope(location: scope_types) -> Optional[Union[List[MapRegion], MapRegio
 
  def _make_region(obj: Union[str, Regions]) -> Optional[MapRegion]:
  if isinstance(obj, Regions):
- return MapRegion.with_ids(obj.unique_ids())
+ return MapRegion.scope(obj.unique_ids())
 
  if isinstance(obj, str):
  return MapRegion.with_name(obj)
@@ -440,20 +432,17 @@ def _make_region(obj: Union[str, Regions]) -> Optional[MapRegion]:
  return _make_region(location)
 
 
-def _ensure_is_list(obj: request_types) -> Optional[List[str]]:
+def _ensure_is_list(obj) -> Optional[List[str]]:
  if obj is None:
  return None
 
  if isinstance(obj, list):
  return obj
 
- if isinstance(obj, str):
- return [obj]
-
  if isinstance(obj, Series):
  return obj.tolist()
 
- raise ValueError("Wrong type")
+ return [obj]
 
 
 def _coerce_resolution(res: int) -> int:

python-package/lets_plot/geo_data/regions_builder.py

@@ -5,8 +5,8 @@
 from .gis.request import MapRegion, RegionQuery, RequestBuilder, RequestKind, PayloadKind, AmbiguityResolver, \
  IgnoringStrategyKind
 from .gis.response import LevelKind, Response, SuccessResponse, GeoRect
-from .regions import _to_level_kind, request_types, scope_types, Regions, _raise_exception, \
- _ensure_is_list, _to_scope
+from .regions import _to_level_kind, request_types, parent_types, scope_types, Regions, _raise_exception, \
+ _ensure_is_list, _make_parent_region, _to_scope
 
 NAMESAKE_MAX_COUNT = 10
 
@@ -86,9 +86,9 @@ def _create_queries(request: request_types, scope: scope_types, ambiguity_resovl
  queries = []
  for i in range(len(requests)):
  name = requests[i] if requests is not None else None
- country = countries[i] if countries is not None else None
- state = states[i] if states is not None else None
- county = counties[i] if counties is not None else None
+ country = _make_parent_region(countries[i]) if countries is not None else None
+ state = _make_parent_region(states[i]) if states is not None else None
+ county = _make_parent_region(counties[i]) if counties is not None else None
 
  query = RegionQuery(request=name, scope=scope, ambiguity_resolver=ambiguity_resovler,
  country=country, state=state, county=county)

python-package/lets_plot/geo_data/to_geo_data_frame.py

@@ -5,7 +5,7 @@
 from pandas import DataFrame
 from shapely.geometry import box
 
-from lets_plot.geo_data import PlacesDataFrameBuilder, select_not_empty_name, select_parents, DF_REQUEST, DF_FOUND_NAME, abstractmethod
+from lets_plot.geo_data import PlacesDataFrameBuilder, select_not_empty_name, DF_REQUEST, DF_FOUND_NAME, abstractmethod
 from lets_plot.geo_data.gis.response import GeocodedFeature, GeoRect, Boundary, Multipolygon, Polygon, GeoPoint
 from lets_plot.geo_data.gis.request import RegionQuery
 
@@ -40,15 +40,14 @@ def __init__(self):
  self._lonmax: List[float] = []
  self._latmax: List[float] = []
 
- def to_data_frame(self, features: List[GeocodedFeature], queries: List[RegionQuery] = None) -> DataFrame:
+ def to_data_frame(self, features: List[GeocodedFeature], queries: List[RegionQuery] = []) -> DataFrame:
  places = PlacesDataFrameBuilder()
 
- parents = select_parents(queries)
  for i in range(len(features)):
  feature = features[i]
- rects: GeoRect = self._read_rect(feature)
+ rects: List[GeoRect] = self._read_rect(feature)
  for rect in rects:
- places.append_row(request=select_not_empty_name(feature), found_name=feature.name, parents=parents, parent_row=i)
+ places.append_row(request=select_not_empty_name(feature), found_name=feature.name, queries=queries, parent_row=i)
  self._lonmin.append(rect.min_lon)
  self._latmin.append(rect.min_lat)
  self._lonmax.append(rect.max_lon)
@@ -79,13 +78,12 @@ def __init__(self):
  self._lons: List[float] = []
  self._lats: List[float] = []
 
- def to_data_frame(self, features: List[GeocodedFeature], queries: List[RegionQuery] = None) -> DataFrame:
+ def to_data_frame(self, features: List[GeocodedFeature], queries: List[RegionQuery] = []) -> DataFrame:
  places = PlacesDataFrameBuilder()
 
- parents = select_parents(queries)
  for i in range(len(features)):
  feature = features[i]
- places.append_row(request=select_not_empty_name(feature), found_name=feature.name, parents=parents, parent_row=i)
+ places.append_row(request=select_not_empty_name(feature), found_name=feature.name, queries=queries, parent_row=i)
  self._lons.append(feature.centroid.lon)
  self._lats.append(feature.centroid.lat)
 
@@ -97,14 +95,13 @@ class BoundariesGeoDataFrame:
  def __init__(self):
  super().__init__()
 
- def to_data_frame(self, features: List[GeocodedFeature], queries: List[RegionQuery] = None) -> DataFrame:
+ def to_data_frame(self, features: List[GeocodedFeature], queries: List[RegionQuery] = []) -> DataFrame:
  places = PlacesDataFrameBuilder()
 
  geometry = []
- parents = select_parents(queries)
  for i in range(len(features)):
  feature = features[i]
- places.append_row(request=select_not_empty_name(feature), found_name=feature.name, parents=parents, parent_row=i)
+ places.append_row(request=select_not_empty_name(feature), found_name=feature.name, queries=queries, parent_row=i)
  geometry.append(self._geo_parse_geometry(feature.boundary))
 
  return _create_geo_data_frame(places.build_dict(), geometry=geometry)