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
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
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

    async def async_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 = await self._get_async_client().get(url, headers=headers, timeout=self._timeout)
        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/"

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

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 
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
async def async_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 = await self._get_async_client().get(url, headers=headers, timeout=self._timeout)
    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

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