Skip to content

Vector Tile API

Client for the HERE Vector Tile API.

VectorTileApi

Bases: HEREApi

A python interface into the HERE Vector Tile API.

Source code in src/herepy/vector_tile_api.py 
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
class VectorTileApi(HEREApi):
    """A python interface into the HERE Vector Tile API."""

    def __init__(self, api_key: str = None, timeout: int = None):
        """
        Initialize the Vector Tile API client.

        Args:
          api_key (str):
            API key taken from HERE Developer Portal.
          timeout (int):
            Timeout limit for requests.

        """
        super().__init__(api_key, timeout)
        self._base_url = "https://vector.hereapi.com/v2/vectortiles/"

    def __get_error_from_response(self, json_data):
        if "error" in json_data:
            error_description = json_data["error_description"]
            if json_data["error"] == "Unauthorized":
                return UnauthorizedError(error_description)
        error_type = json_data.get("Type")
        error_message = json_data.get(
            "Message",
            error_description + ", error occurred on " + sys._getframe(1).f_code.co_name,
        )
        if error_type == "Invalid Request":
            return InvalidRequestError(error_message)
        else:
            return HEREError(error_message)

    def get_vectortile(
        self,
        latitude: float,
        longitude: float,
        zoom: int,
        layer: VectorMapTileLayer = VectorMapTileLayer.base,
        projection: str = "mc",
        tile_format: str = "omv",
        query_parameters: dict | None = None,
        headers: dict | None = None,
    ) -> bytes | None:
        """
        Retrieve the protocol buffer-encoded binary tile.

        Args:
          latitude (float):
            Latitude value to be used to fetch map tile.
          longitude (float):
            Longitude value to be used to fetch map tile.
          zoom (int):
            Specifies the tile Zoom level. Accepted values range from 0-17. minimum - 0, maximum - 17.
          layer (VectorMapTileLayer):
            Specifies the layers available in the tile. The access to each layer is determined by the contract of the user.
          projection (str):
            Specifies the tile projection. mc - Mercator Projection.
          tile_format (str):
            Specifies the tile format.
            omv - Optimized Map for Visualization (follows Map Vector Tile open specification).
          query_parameters (Optional[Dict]):
            Optional Query Parameters. Refer to the API definition for values.
          headers (Optional[Dict]):
            Optional headers. Refer to the API definition for values.

        Returns:
          Vector tile as bytes.

        Raises:
          HEREError

        """
        column, row = MercatorProjection.get_column_row(latitude=latitude, longitude=longitude, zoom=zoom)
        url = str.format(
            self._base_url + "{}/{}/{}/{}/{}/{}",
            layer.__str__(),
            projection,
            zoom,
            column,
            row,
            tile_format,
        )
        if query_parameters:
            query_parameters.update({"apiKey": self._api_key})
        else:
            query_parameters = {"apiKey": self._api_key}
        url = Utils.build_url(url, extra_params=query_parameters)
        response = requests.get(url, headers=headers, timeout=self._timeout, stream=True)
        if isinstance(response.content, bytes):
            try:
                json_data = json.loads(response.content.decode("utf8"))
                if "error" in json_data:
                    error = self.__get_error_from_response(json_data)
                    raise error
            except UnicodeDecodeError:
                print("Vector tile downloaded")
        return response.content

__init__(api_key=None, timeout=None)

Initialize the Vector Tile API client.

Parameters:

Name Type Description Default
api_key str

API key taken from HERE Developer Portal.

 None
timeout int

Timeout limit for requests.

 None
Source code in src/herepy/vector_tile_api.py 
18
19
20
21
22
23
24
25
26
27
28
29
30
def __init__(self, api_key: str = None, timeout: int = None):
    """
    Initialize the Vector Tile API client.

    Args:
      api_key (str):
        API key taken from HERE Developer Portal.
      timeout (int):
        Timeout limit for requests.

    """
    super().__init__(api_key, timeout)
    self._base_url = "https://vector.hereapi.com/v2/vectortiles/"

get_vectortile(latitude, longitude, zoom, layer=VectorMapTileLayer.base, projection='mc', tile_format='omv', query_parameters=None, headers=None)

Retrieve the protocol buffer-encoded binary tile.

Parameters:

Name Type Description Default
latitude float

Latitude value to be used to fetch map tile.

 required
longitude float

Longitude value to be used to fetch map tile.

 required
zoom int

Specifies the tile Zoom level. Accepted values range from 0-17. minimum - 0, maximum - 17.

 required
layer VectorMapTileLayer

Specifies the layers available in the tile. The access to each layer is determined by the contract of the user.

 base
projection str

Specifies the tile projection. mc - Mercator Projection.

 'mc'
tile_format str

Specifies the tile format. omv - Optimized Map for Visualization (follows Map Vector Tile open specification).

 'omv'
query_parameters Optional[Dict]

Optional Query Parameters. Refer to the API definition for values.

 None
headers Optional[Dict]

Optional headers. Refer to the API definition for values.

 None

Returns:

Type Description
bytes | None

Vector tile as bytes.
Source code in src/herepy/vector_tile_api.py 
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
def get_vectortile(
    self,
    latitude: float,
    longitude: float,
    zoom: int,
    layer: VectorMapTileLayer = VectorMapTileLayer.base,
    projection: str = "mc",
    tile_format: str = "omv",
    query_parameters: dict | None = None,
    headers: dict | None = None,
) -> bytes | None:
    """
    Retrieve the protocol buffer-encoded binary tile.

    Args:
      latitude (float):
        Latitude value to be used to fetch map tile.
      longitude (float):
        Longitude value to be used to fetch map tile.
      zoom (int):
        Specifies the tile Zoom level. Accepted values range from 0-17. minimum - 0, maximum - 17.
      layer (VectorMapTileLayer):
        Specifies the layers available in the tile. The access to each layer is determined by the contract of the user.
      projection (str):
        Specifies the tile projection. mc - Mercator Projection.
      tile_format (str):
        Specifies the tile format.
        omv - Optimized Map for Visualization (follows Map Vector Tile open specification).
      query_parameters (Optional[Dict]):
        Optional Query Parameters. Refer to the API definition for values.
      headers (Optional[Dict]):
        Optional headers. Refer to the API definition for values.

    Returns:
      Vector tile as bytes.

    Raises:
      HEREError

    """
    column, row = MercatorProjection.get_column_row(latitude=latitude, longitude=longitude, zoom=zoom)
    url = str.format(
        self._base_url + "{}/{}/{}/{}/{}/{}",
        layer.__str__(),
        projection,
        zoom,
        column,
        row,
        tile_format,
    )
    if query_parameters:
        query_parameters.update({"apiKey": self._api_key})
    else:
        query_parameters = {"apiKey": self._api_key}
    url = Utils.build_url(url, extra_params=query_parameters)
    response = requests.get(url, headers=headers, timeout=self._timeout, stream=True)
    if isinstance(response.content, bytes):
        try:
            json_data = json.loads(response.content.decode("utf8"))
            if "error" in json_data:
                error = self.__get_error_from_response(json_data)
                raise error
        except UnicodeDecodeError:
            print("Vector tile downloaded")
    return response.content