lets-plot 4.8.1rc1__cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl

lets_plot/geo_data/gis/fluent_dict.py

@@ -0,0 +1,201 @@
+from enum import Enum
+from typing import Union, Callable, Any, Dict, Optional, Type, List, Generic, TypeVar
+
+
+class FluentDict:
+
+    def __init__(self, dict: Optional[Dict] = None):
+        if dict is not None:
+            self._dict = dict
+        else:
+            self._dict = {}
+
+    def contains(self, key: Union[str, Enum]) -> bool:
+        str_key: str = self._key_to_str(key)
+        return str_key in self._dict and self.get(str_key) is not None
+
+    def put(self, key: Union[str, Enum], value: Any) -> 'FluentDict':
+        if value is None:
+            pass
+        elif isinstance(value, (int, float, str, dict)):
+            pass
+        elif isinstance(value, FluentDict):
+            value = value.to_dict()
+        elif isinstance(value, Enum):
+            value = value.value
+        elif isinstance(value, (list, tuple)):
+            if len(value) > 0:
+                if isinstance(value[0], Enum):
+                    value = list(map(lambda enum: enum.value, value))
+        else:
+            raise ValueError('Not supported type: ' + str(value.__class__))
+
+        self._dict[self._key_to_str(key)] = value
+        return self
+
+    def visit(self, key: Union[str, Enum], consumer: Callable[[Any], Any]) -> 'FluentDict':
+        consumer(self._dict[self._key_to_str(key)])
+        return self
+
+    def visit_str(self, key: Union[str, Enum], consumer: Callable[[str], Any]) -> 'FluentDict':
+        consumer(str(self.get(key)))
+        return self
+
+    def visit_str_existing(self, key: Union[str, Enum], consumer: Callable[[str], Any]) -> 'FluentDict':
+        if self._is_not_none(key):
+            consumer(self.get(key))
+        return self
+
+    def visit_int(self, key: Union[str, Enum], consumer: Callable[[int], Any]) -> 'FluentDict':
+        consumer(int(self.get(key)))
+        return self
+
+    def get_float(self, key: Union[str, Enum]) -> float:
+        return float(self.get(key))
+
+    def visit_float(self, key: Union[str, Enum], consumer: Callable[[float], Any]) -> 'FluentDict':
+        consumer(self.get_float(key))
+        return self
+
+    def visit_float_optional(self, key: Union[str, Enum], consumer: Callable[[float], Any]) -> 'FluentDict':
+        if self._is_not_none(key):
+            self.visit_float(key, consumer)
+        return self
+
+    def visit_int_optional(self, key: Union[str, Enum], consumer: Callable[[int], Any]) -> 'FluentDict':
+        if self._is_not_none(key):
+            self.visit_int(key, consumer)
+        return self
+
+    def visit_dict(self, key: Union[str, Enum], consumer: Callable[['FluentDict'], Any]) -> 'FluentDict':
+        consumer(self.get_object(key))
+        return self
+
+    def visit_object_optional(self, key: Union[str, Enum], consumer: Callable[['FluentDict'], Any]) -> 'FluentDict':
+        if self._is_not_none(key):
+            self.visit_dict(key, consumer)
+        return self
+
+    def visit_list_optional(self, key: Union[str, Enum], consumer: Callable[['FluentList'], Any]) -> 'FluentDict':
+        if self._is_not_none(key):
+            self.visit_list(key, consumer)
+        return self
+
+    def get_enum(self, key: Union[str, Enum], enum_type: Type[Enum]):
+        return self._to_enum(self.get(key), enum_type)
+
+    def visit_enum(self, key: Union[str, Enum], enum_type: Type[Enum], consumer: Callable[[Enum], Any]) -> 'FluentDict':
+        consumer(self.get_enum(key, enum_type))
+        return self
+
+    def visit_enums(self, key: Union[str, Enum], enum_type: Type[Enum], consumer: Callable[[List[Enum]], Any]) -> 'FluentDict':
+        consumer(
+            self.get_fluent_list(key)
+                .map(lambda enum_str: self._to_enum(enum_str, enum_type))
+                .list()
+        )
+        return self
+
+    def visit_enum_existing(self, key: Union[str, Enum], enum_type: Type[Enum], consumer: Callable[[Enum], Any]) -> 'FluentDict':
+        if self._is_not_none(key):
+            consumer(self.get_enum(key, enum_type))
+
+        return self
+
+    def visit_objects(self, key: Union[str, Enum], consumer: Callable[['FluentDict'], Any]) -> 'FluentDict':
+        for d in self.get(key):
+            consumer(FluentDict(d))
+        return self
+
+    def visit_object(self, key: Union[str, Enum], consumer: Callable[['FluentDict'], Any]) -> 'FluentDict':
+        consumer(FluentDict(self.get(key)))
+        return self
+
+    def visit_list(self, key: Union[str, Enum], consumer: Callable[['FluentList'], Any]) -> 'FluentDict':
+        consumer(self.get_fluent_list(key))
+        return self
+
+    def get(self, key: Union[str, Enum]) -> Any:
+        return self._dict[self._key_to_str(key)]
+
+    def get_bool(self, key: Union[str, Enum]) -> bool:
+        return bool(self.get(key))
+
+    def visit_bool(self, key: Union[str, Enum], consumer: Callable[[bool], Any]) -> 'FluentDict':
+        consumer(self.get_bool(key))
+        return self
+
+    def get_fluent_list(self, key: Union[str, Enum]) -> 'FluentList':
+        return FluentList(self.get(key))
+
+    def get_list(self, key: Union[str, Enum]) -> list:
+        value = self.get(key)
+        assert isinstance(value, list)
+        return value
+
+    def get_object(self, key: Union[str, Enum]) -> 'FluentDict':
+        return FluentDict(self.get(key))
+
+    def get_objects(self, key: Union[str, Enum]) -> 'FluentList[FluentDict]':
+        return FluentList(self._dict[self._key_to_str(key)]).map(lambda v: FluentDict(v))
+
+    def to_dict(self) -> Dict:
+        return self._dict
+
+    def _is_not_none(self, key: Union[str, Enum]):
+        return self._key_to_str(key) in self._dict and self.get(key) is not None
+
+    @staticmethod
+    def _key_to_str(key: Union[str, Enum]) -> str:
+        if isinstance(key, str):
+            return key
+        elif isinstance(key, Enum):
+            return key.value
+        else:
+            raise ValueError('Unknown key type: ' + str(key.__class__))
+
+    @staticmethod
+    def _to_enum(enum_str: str, enum_type: Type[Enum]):
+        for e in enum_type:
+            if e.value == enum_str:
+                return e
+        raise ValueError('Unknown emum value: ' + enum_str)
+
+    def visit_str_list(self, key: Union[str, Enum], consumer: Callable[[List[str]], Any]) -> 'FluentDict':
+        consumer(self.get(key))
+        return self
+
+    def visit_str_list_optional(self, key: Union[str, Enum], consumer: Callable[[List[str]], Any]) -> 'FluentDict':
+        if self._is_not_none(key):
+            consumer(self.get(key))
+
+        return self
+
+
+T = TypeVar('T')
+TOut = TypeVar('TOut')
+
+
+class FluentList(Generic[T]):
+
+    def __init__(self, list: List[T] = None):
+        if list is None:
+            self._list: List[T] = []
+        else:
+            self._list: List[T] = list
+
+    def add(self, obj: T) -> 'FluentList[T]':
+        self._list.append(obj)
+        return self
+
+    def list(self) -> List[T]:
+        return self._list
+
+    TOut = TypeVar('TOut')
+
+    def map(self, func: Callable[[T], TOut]) -> 'FluentList[TOut]':
+        out = []
+        for v in self._list:
+            out.append(func(v))
+
+        return FluentList(out)

lets_plot/geo_data/gis/geocoding_service.py

@@ -0,0 +1,42 @@
+import gzip
+import json
+import urllib.parse
+import urllib.request
+from urllib.error import HTTPError
+
+from .json_request import RequestFormatter
+from .json_response import ResponseParser
+from .request import Request
+from .response import Response
+from lets_plot._global_settings import has_global_value, get_global_str, GEOCODING_ROUTE
+from lets_plot.settings_utils import GEOCODING_PROVIDER_URL
+
+
+class GeocodingService:
+    def do_request(self, request: Request) -> Response:
+        if not has_global_value(GEOCODING_PROVIDER_URL):
+            raise ValueError('Geocoding server url is not defined')
+
+        try:
+            request_json = RequestFormatter().format(request).to_dict()
+            request_str = json.dumps(request_json)
+
+            request = urllib.request.Request(
+                url=get_global_str(GEOCODING_PROVIDER_URL) + GEOCODING_ROUTE,
+                headers={'Content-Type': 'application/json', 'Accept-Encoding': 'gzip'},
+                method='POST',
+                data=bytearray(request_str, 'utf-8')
+            )
+            response = urllib.request.urlopen(request)
+            if response.info().get('Content-Encoding') == 'gzip':
+                content = response.read()
+                response_str = gzip.decompress(content).decode('utf-8')
+            else:
+                response_str = response.read().decode('utf-8')
+
+            response_json = json.loads(response_str)
+            return ResponseParser().parse(response_json)
+
+        except HTTPError as e:
+            raise ValueError(
+                'Geocoding server connection failure: {} {} ({})'.format(e.code, e.msg, e.filename)) from None

lets_plot/geo_data/gis/geometry.py

@@ -0,0 +1,91 @@
+from typing import List
+
+from ..type_assertion import assert_list_type
+
+
+class GeometryBase:
+    pass
+
+
+class GeoPoint(GeometryBase):
+    def __init__(self, lon: float, lat: float):
+        self.lon: float = lon
+        self.lat: float = lat
+
+    def __eq__(self, other):
+        return isinstance(other, GeoPoint) \
+               and self.lon == other.lon \
+               and self.lat == other.lat
+
+    def __ne__(self, other):
+        return not self == other
+
+
+class GeoRect(GeometryBase):
+    def __init__(self, start_lon: float, min_lat: float, end_lon: float, max_lat: float):
+        self.start_lon: float = start_lon
+        self.min_lat: float = min_lat
+        self.end_lon: float = end_lon
+        self.max_lat: float = max_lat
+
+    def crosses_antimeridian(self):
+        return self.start_lon > self.end_lon
+
+    def __eq__(self, other):
+        return isinstance(other, GeoRect) \
+               and self.start_lon == other.start_lon \
+               and self.min_lat == other.min_lat \
+               and self.end_lon == other.end_lon \
+               and self.max_lat == other.max_lat
+
+    def __ne__(self, other):
+        return not self == other
+
+
+class Ring(GeometryBase):
+    def __init__(self, points: List[GeoPoint]):
+        assert_list_type(points, GeoPoint)
+        self.points: List[GeoPoint] = points
+
+    def __eq__(self, other):
+        return isinstance(other, Ring) \
+               and self.points == other.points
+
+    def __ne__(self, other):
+        return not self == other
+
+
+class Polygon(GeometryBase):
+    def __init__(self, rings: List[Ring]):
+        assert_list_type(rings, Ring)
+        self.rings: List[Ring] = rings
+
+    def __eq__(self, other):
+        if not isinstance(other, Polygon):
+            return False
+
+        for r, o in zip(self.rings, other.rings):
+            if r != o:
+                return False
+        return True
+
+    def __ne__(self, other):
+        return not self == other
+
+
+class Multipolygon(GeometryBase):
+    def __init__(self, polygons: List[Polygon]):
+        assert_list_type(polygons, Polygon)
+        self.polygons: List[Polygon] = polygons
+
+    def __eq__(self, other):
+        if not isinstance(other, Multipolygon):
+            return False
+
+        for p, o in zip(self.polygons, other.polygons):
+            if p != o:
+                return False
+        return True
+
+    def __ne__(self, other):
+        return not self == other

lets_plot/geo_data/gis/json_request.py

@@ -0,0 +1,232 @@
+import enum
+from typing import Dict, List, Optional, Tuple
+
+from .fluent_dict import FluentDict, FluentList
+from .geometry import GeoPoint
+from .request import RegionQuery, MapRegion, MapRegionKind, PayloadKind, RegionQueryBuilder, IgnoringStrategyKind, \
+    MapRegionBuilder
+from .request import Request, GeocodingRequest, ExplicitRequest, RequestBuilder, RequestKind, ReverseGeocodingRequest
+from .response import LevelKind, GeoRect
+
+PROTOCOL_VERSION = 3
+
+
+class Field(enum.Enum):
+    version = 'version'
+    mode = 'mode'
+    requested_payload = 'feature_options'
+    resolution = 'resolution'
+    view_box = 'view_box'
+    fetched_ids = 'fetched_ids'
+    option_kind = 'kind'
+    geo_object_list = 'ids'
+    region_queries = 'region_queries'
+    region_query_names = 'region_query_names'
+    region_query_countries = 'region_query_countries'
+    region_query_states = 'region_query_states'
+    region_query_counties = 'region_query_counties'
+    region_query_parent = 'region_query_parent'
+    scope = 'scope'
+    level = 'level'
+    map_region_kind = 'kind'
+    map_region_values = 'values'
+    match = 'match'
+    namesake_example_limit = 'namesake_example_limit'
+    allow_ambiguous = 'allow_ambiguous'
+    ambiguity_resolver = 'ambiguity_resolver'
+    ambiguity_ignoring_strategy = 'ambiguity_resolver_ignoring_strategy'
+    ambiguity_closest_coord = 'ambiguity_resolver_closest_coord'
+    ambiguity_box = 'ambiguity_resolver_box'
+
+    reverse_level = "level"
+    reverse_coordinates = "reverse_coordinates"
+    reverse_parent = "reverse_parent"
+
+    coord_lon = 'lon'
+    coord_lat = 'lat'
+
+    min_lon = 'min_lon'
+    min_lat = 'min_lat'
+    max_lon = 'max_lon'
+    max_lat = 'max_lat'
+
+
+class RequestFormatter:
+    @staticmethod
+    def format(request: Request) -> FluentDict:
+        if isinstance(request, GeocodingRequest):
+            return RequestFormatter._format_geocoding_request(request)
+        elif isinstance(request, ExplicitRequest):
+            return RequestFormatter._format_explicit_request(request)
+        elif isinstance(request, ReverseGeocodingRequest):
+            return RequestFormatter._format_reverse_geocoding_request(request)
+        else:
+            raise ValueError('Unknown request kind: ' + str(request))
+
+    @staticmethod
+    def _format_geocoding_request(request: 'GeocodingRequest') -> FluentDict:
+        return RequestFormatter \
+            ._common(RequestKind.geocoding, request) \
+            .put(Field.region_queries, RequestFormatter._format_region_queries(request.region_queries)) \
+            .put(Field.scope, RequestFormatter._format_scope(request.scope)) \
+            .put(Field.level, request.level) \
+            .put(Field.namesake_example_limit, request.namesake_example_limit) \
+            .put(Field.allow_ambiguous, request.allow_ambiguous)
+
+    @staticmethod
+    def _format_explicit_request(request: 'ExplicitRequest') -> FluentDict:
+        return RequestFormatter \
+            ._common(RequestKind.explicit, request) \
+            .put(Field.geo_object_list, request.geo_object_list)
+
+    @staticmethod
+    def _format_reverse_geocoding_request(request: 'ReverseGeocodingRequest'):
+        return RequestFormatter \
+            ._common(RequestKind.reverse, request) \
+            .put(Field.reverse_coordinates, [RequestFormatter._format_coord(coord) for coord in request.coordinates]) \
+            .put(Field.reverse_level, request.level) \
+            .put(Field.reverse_parent, RequestFormatter._format_map_region(request.scope))
+
+    @staticmethod
+    def _common(request_kind: RequestKind, request: Request) -> FluentDict:
+        return FluentDict() \
+            .put(Field.version, PROTOCOL_VERSION) \
+            .put(Field.mode, request_kind.value) \
+            .put(Field.requested_payload, request.requested_payload) \
+            .put(Field.resolution, request.resolution) \
+            .put(Field.view_box, None) \
+            .put(Field.fetched_ids, None)
+
+    @staticmethod
+    def _format_region_queries(region_queires: List[RegionQuery]) -> List[Dict]:
+        result = []
+        for query in region_queires:
+            result.append(
+                FluentDict()
+                    .put(Field.region_query_names, [] if query.request is None else [query.request])
+                    .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))
+                         .put(Field.ambiguity_closest_coord, RequestFormatter._format_coord(query.ambiguity_resolver.closest_coord))) \
+                    .put(Field.region_query_parent, RequestFormatter._format_map_region(query.scope))
+                    .to_dict()
+            )
+        return result
+
+    @staticmethod
+    def _format_scope(scope: List[MapRegion]) -> List[Dict]:
+        return [RequestFormatter._format_map_region(s) for s in scope]
+
+    @staticmethod
+    def _format_map_region(parent: Optional[MapRegion]) -> Optional[Dict]:
+        if parent is None:
+            return None
+
+        # special case - place is just a geocoded object with id and extra information, used by client
+        # server doesn't need this extra information
+        if parent.kind.value == 'place':
+            return FluentDict() \
+                .put(Field.map_region_kind, MapRegionKind.id.value) \
+                .put(Field.map_region_values, parent.values) \
+                .to_dict()
+
+        return FluentDict() \
+            .put(Field.map_region_kind, parent.kind.value) \
+            .put(Field.map_region_values, parent.values) \
+            .to_dict()
+
+    @staticmethod
+    def _format_coord(closest_coord: GeoPoint) -> Optional[Tuple[float, float]]:
+        if closest_coord is None:
+            return None
+
+        return closest_coord.lon, closest_coord.lat
+
+    @staticmethod
+    def _format_box(rect: GeoRect) -> Optional[Dict]:
+        if rect is None:
+            return None
+
+        return FluentDict() \
+            .put(Field.min_lon, rect.start_lon) \
+            .put(Field.min_lat, rect.min_lat) \
+            .put(Field.max_lon, rect.end_lon) \
+            .put(Field.max_lat, rect.max_lat) \
+            .to_dict()
+
+
+class RequestParser:
+    @staticmethod
+    def parse(request_json: Dict) -> Request:
+        request = RequestBuilder()
+        request_dict = FluentDict(request_json) \
+            .visit_enum(Field.mode, RequestKind, request.set_request_kind) \
+            .visit_enums(Field.requested_payload, PayloadKind, request.set_requested_payload) \
+            .visit_int_optional(Field.resolution, request.set_resolution)
+
+        if request.request_kind == RequestKind.explicit:
+            request_dict.visit_str_list(Field.geo_object_list, request.set_ids)
+        elif request.request_kind == RequestKind.geocoding:
+            request_dict \
+                .visit_enum_existing(Field.level, LevelKind, request.set_level) \
+                .visit_int(Field.namesake_example_limit, request.set_namesake_limit) \
+                .visit_bool(Field.allow_ambiguous, request.set_allow_ambiguous) \
+                .visit_list(Field.region_queries, lambda regions: request.set_queries(regions.map(RequestParser._parse_region_query).list()))
+        elif request.request_kind == RequestKind.reverse:
+            request_dict \
+                .visit_enum_existing(Field.reverse_level, LevelKind, request.set_level) \
+                .visit_list(Field.reverse_coordinates, lambda coords: request.set_reverse_coordinates(RequestParser._parse_coordinates(coords))) \
+                .visit_object_optional(Field.reverse_parent,
+                                       lambda parent: request.set_reverse_scope(RequestParser._parse_map_region(parent)))
+        else:
+            raise ValueError('Unknown request kind: ' + str(request))
+
+        return request.build()
+
+    @staticmethod
+    def _parse_region_query(region_query: dict) -> RegionQuery:
+        region_q = FluentDict(region_query)
+        assert len(region_q.get_list(Field.region_query_names)) in [0, 1], 'Multirequests are not supported'
+
+        builder = RegionQueryBuilder()
+
+        FluentDict(region_query) \
+            .visit_str_list(Field.region_query_names, lambda names: builder.set_request(names[0] if len(names) == 1 else None)) \
+            .visit_object_optional(Field.ambiguity_resolver, lambda resolver: resolver
+                                   .visit_list_optional(Field.ambiguity_closest_coord,
+                                                        lambda coord: builder.set_closest_coord(RequestParser._parse_coord(coord)))
+                                   .visit_object_optional(Field.ambiguity_box,
+                                                          lambda jsonBox: builder.set_box(RequestParser._parse_geo_rect(jsonBox)))
+                                   .visit_enum_existing(Field.ambiguity_ignoring_strategy, IgnoringStrategyKind, builder.set_ignoring_strategy)) \
+            .visit_object_optional(Field.region_query_parent, lambda parent: builder.set_scope(RequestParser._parse_map_region(parent)))
+
+        return builder.build()
+
+    @staticmethod
+    def _parse_map_region(json: FluentDict) -> MapRegion:
+        builder = MapRegionBuilder()
+        json \
+            .visit_str_list(Field.map_region_values, builder.set_parent_values) \
+            .visit_bool(Field.map_region_kind, builder.set_parent_kind)
+
+        return builder.build()
+
+    @staticmethod
+    def _parse_coord(jsonCoord: FluentList) -> GeoPoint:
+        return GeoPoint(jsonCoord.list()[0], jsonCoord.list()[1])
+
+    @staticmethod
+    def _parse_geo_rect(jsonBox: FluentDict) -> GeoRect:
+        return GeoRect(
+            start_lon=jsonBox.get_float(Field.min_lon),
+            min_lat=jsonBox.get_float(Field.min_lat),
+            end_lon=jsonBox.get_float(Field.max_lon),
+            max_lat=jsonBox.get_float(Field.max_lat),
+        )
+
+    @staticmethod
+    def _parse_coordinates(coordinates: FluentList) -> List[GeoPoint]:
+        return [GeoPoint(coord[0], coord[1]) for coord in coordinates.list()]