def __get(self, data):
url = Utils.build_url(self._base_url, extra_params=data)
response = requests.get(url, timeout=self._timeout)
try:
json_data = json.loads(response.content.decode('utf8'))
if json_data.get('Response') != None:
return GeocoderResponse.new_from_jsondict(json_data)
else:
raise HEREError(json_data.get('Details', 'Error occured on function ' + sys._getframe(1).f_code.co_name))
except ValueError as err:
raise HEREError('Error occured on function ' + sys._getframe(1).f_code.co_name + ' ' + str(err))
def __get(self, data, path, json_node):
url = Utils.build_url(self._base_url + path, extra_params=data)
response = requests.get(url, timeout=self._timeout)
json_data = json.loads(response.content.decode('utf8'))
if json_node in json_data.get('Res', {}):
return PublicTransitResponse.new_from_jsondict(json_data)
elif 'text' in json_data.get('Res', {}).get('Message', {}):
return HEREError(
json_data['Res']['Message']['text'],
'Error occured on ' + sys._getframe(1).f_code.co_name)
else:
return HEREError('Error occured on ' +
sys._getframe(1).f_code.co_name)
def error_from_ev_charging_service_error(json_data: dict):
"""Return the correct subclass for ev charging errors"""
if "Type" in json_data:
error_type = json_data["Type"]
message = json_data["Message"]
if error_type == "Unauthorized":
return UnauthorizedError(message)
elif "error" in json_data and "error_description" in json_data:
return HEREError("Error occured: " + json_data["error"] +
", description: " + json_data["error_description"])
# pylint: disable=W0212
return HEREError("Error occured on " + sys._getframe(1).f_code.co_name)
def forecast_astronomy(self,
destination,
product=WeatherProductType.observation):
"""Request forecast for given destination.
Args:
destination (str):
Destination name.
product (str):
A parameter identifying the type of report to obtain. Default value `observation`.
Returns:
DestinationWeatherResponse instance or HEREError
"""
data = {
'app_id': self._app_id,
'app_code': self._app_code,
'product': product.__str__(),
'name': destination
}
url = Utils.build_url(self._base_url, extra_params=data)
response = requests.get(url, timeout=self._timeout)
json_data = json.loads(response.content.decode('utf8'))
if json_data.get(self._product_node(product)) != None:
return DestinationWeatherResponse.new_from_jsondict(
json_data, param_defaults={self._product_node(product): None})
else:
return HEREError(
json_data.get(
'Message',
'Error occured on ' + sys._getframe(1).f_code.co_name))
def __get(
self,
base_url,
data,
key,
response_cls,
manipulation_key: str = None,
keys_for_manipulation: List = None,
):
url = Utils.build_url(base_url, extra_params=data)
if manipulation_key and keys_for_manipulation:
for k in keys_for_manipulation:
url = url.replace(k, manipulation_key)
response = requests.get(url, timeout=self._timeout)
json_data = json.loads(response.content.decode("utf8"))
if response.status_code == requests.codes.OK:
if json_data.get(key) is not None:
return response_cls.new_from_jsondict(json_data)
else:
raise error_from_routing_service_error(json_data)
else:
raise HEREError("Error occurred on routing_api __get " +
sys._getframe(1).f_code.co_name +
" response status code " +
str(response.status_code))
def __get_categories(self, data):
url = Utils.build_url(self._base_url + 'categories/places', extra_params=data)
response = requests.get(url, timeout=self._timeout)
json_data = json.loads(response.content.decode('utf8'))
if json_data.get('items') != None:
return PlaceCategoriesResponse.new_from_jsondict(json_data)
else:
raise HEREError(json_data.get('message', 'Error occured on ' + sys._getframe(1).f_code.co_name))
def __get(self, data):
url = Utils.build_url(self._base_url, extra_params=data)
response = requests.get(url, timeout=self._timeout)
try:
json_data = json.loads(response.content.decode("utf8"))
if json_data.get("TracePoints") != None:
return RmeResponse.new_from_jsondict(json_data)
else:
raise HEREError(
json_data.get(
"Details",
"Error occurred on function " +
sys._getframe(1).f_code.co_name,
))
except ValueError as err:
raise HEREError("Error occurred on function " +
sys._getframe(1).f_code.co_name + " " + str(err))
def __get(self, data, path, json_node):
url = Utils.build_url(self._base_url + path, extra_params=data)
response = requests.get(url, timeout=self._timeout)
json_data = json.loads(response.content.decode("utf8"))
if json_node in json_data.get("Res", {}):
return PublicTransitResponse.new_from_jsondict(json_data)
elif "text" in json_data.get("Res", {}).get("Message", {}):
raise HEREError(
json_data["Res"]["Message"]["text"],
"Error occurred on " + sys._getframe(1).f_code.co_name,
)
elif "error" in json_data:
if json_data["error"] == "Unauthorized":
raise UnauthorizedError(json_data["error_description"])
else:
raise HEREError("Error occurred on " +
sys._getframe(1).f_code.co_name)
def __is_correct_response(self, response):
status_code = response.status_code
json_data = response.json()
if json_data.get("matrix") is not None:
return json_data
elif json_data.get("status") is not None:
print("Matrix {} calculation {}".format(json_data["matrixId"],
json_data["status"]))
return False
elif json_data.get("error") is not None and json_data.get(
"error_description"):
raise HEREError("Error occurred on __is_correct_response: " +
json_data["error"] + ", description: " +
json_data["error_description"])
elif json_data.get("title") is not None and json_data.get("status"):
raise HEREError("Error occurred on __is_correct_response: " +
json_data["title"] + ", status: " +
json_data["status"])
def _get_error_from_response(self, json_data):
error_type = json_data.get("Type")
error_message = json_data.get(
"Message", "Error occured on " + sys._getframe(1).f_code.co_name)
if error_type == "Unauthorized":
return UnauthorizedError(error_message)
elif error_type == "Invalid Request":
return InvalidRequestError(error_message)
else:
return HEREError(error_message)
def __get(self, data):
url = Utils.build_url(self._base_url, extra_params=data)
response = requests.get(url, timeout=self._timeout)
json_data = json.loads(response.content.decode('utf8'))
if json_data.get('response') != None:
return RoutingResponse.new_from_jsondict(json_data)
else:
return HEREError(
json_data.get(
'details',
'Error occured on ' + sys._getframe(1).f_code.co_name))
def __get(self, data):
url = Utils.build_url(self._base_url, extra_params=data)
response = requests.get(url, timeout=self._timeout)
json_data = json.loads(response.content.decode('utf8'))
if json_data.get('suggestions') != None:
return GeocoderAutoCompleteResponse.new_from_jsondict(json_data)
else:
raise HEREError(
json_data.get(
'error_description',
'Error occured on ' + sys._getframe(1).f_code.co_name))
def __get(self, data):
url = Utils.build_url(self._base_url, extra_params=data)
response = requests.get(url, timeout=self._timeout)
try:
json_data = json.loads(response.content.decode("utf8"))
if json_data.get("items") != None:
return GeocoderReverseResponse.new_from_jsondict(json_data)
elif "error" in json_data:
if json_data["error"] == "Unauthorized":
raise UnauthorizedError(json_data["error_description"])
else:
raise HEREError(
json_data.get(
"Details",
"Error occurred on function " +
sys._getframe(1).f_code.co_name,
))
except ValueError as err:
raise HEREError("Error occurred on function " +
sys._getframe(1).f_code.co_name + " " + str(err))
def __get(self, data, path, headers=None):
url = Utils.build_url(self._base_url + path, extra_params=data)
if headers != None:
response = requests.get(url, timeout=self._timeout, headers=headers)
else:
response = requests.get(url, timeout=self._timeout)
json_data = json.loads(response.content.decode('utf8'))
if json_data.get('results') != None:
return PlacesResponse.new_from_jsondict(json_data)
else:
raise HEREError(json_data.get('message', 'Error occured on ' + sys._getframe(1).f_code.co_name))
def error_from_fleet_telematics_service_error(json_data: dict):
"""Return the correct subclass for sequence errors"""
if "error" in json_data:
error_type = json_data["error"]
message = json_data["error_description"]
if error_type == "Unauthorized":
return UnauthorizedError(message)
# pylint: disable=W0212
return HEREError("Error occured on " + sys._getframe(1).f_code.co_name)
def __get_error_from_response(self, json_data):
if "error" in json_data:
if json_data["error"] == "Unauthorized":
return UnauthorizedError(json_data["error_description"])
error_type = json_data.get("Type")
error_message = json_data.get(
"Message", "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 reverse_direction_isoline(
self,
transport_mode: IsolineRoutingTransportMode,
ranges: List[int],
origin: Optional[List[float]] = None,
destination: Optional[List[float]] = None,
):
"""Calculates an isoline in the reverse direction. To trigger calculation in reverse direction,
use the destination parameter instead of origin.
Args:
transport_mode (IsolineRoutingTransportMode):
Transport mode of routing.
ranges (List):
Range values for isoline routing.
origin (List):
List including latitude and longitude in order.
destination (List):
List including latitude and longitude in order.
Returns:
IsolineRoutingResponse
Raises:
HEREError"""
string_ranges = [str(int) for int in ranges]
if origin:
data = {
"transportMode": transport_mode.__str__(),
"origin": str.format("{0},{1}", origin[0], origin[1]),
"range[type]": IsolineRoutingRangeType.time.__str__(),
"range[values]": ",".join(string_ranges),
"apiKey": self._api_key,
}
return self.__get(self._base_url, data, "departure")
elif destination:
data = {
"transportMode":
transport_mode.__str__(),
"destination":
str.format("{0},{1}", destination[0], destination[1]),
"range[type]":
IsolineRoutingRangeType.time.__str__(),
"range[values]":
range,
"apiKey":
self._api_key,
}
return self.__get(self._base_url, data, "arrival")
else:
raise HEREError(
"Please provide values for origin or destination parameter.")
def __get(self, data):
url = Utils.build_url(self._base_url, extra_params=data)
response = requests.get(url, timeout=self._timeout)
json_data = json.loads(response.content.decode("utf8"))
if json_data.get("items") != None:
return PlacesResponse.new_from_jsondict(json_data)
elif "error" in json_data:
if json_data["error"] == "Unauthorized":
raise UnauthorizedError(json_data["error_description"])
else:
raise HEREError(
json_data.get(
"message",
"Error occurred on " + sys._getframe(1).f_code.co_name))
def multi_range_routing(
self,
transport_mode: IsolineRoutingTransportMode,
ranges: List[int],
origin: Optional[List[float]] = None,
destination: Optional[List[float]] = None,
):
"""Isoline routing can be requested with multiple ranges which allows for the calculation
of many isolines with the same start or destination.
Args:
transport_mode (IsolineRoutingTransportMode):
Transport mode of routing.
ranges (List):
Range values for isoline routing.
origin (List):
List including latitude and longitude in order.
destination (List):
List including latitude and longitude in order.
Returns:
IsolineRoutingResponse
Raises:
HEREError"""
string_ranges = [str(int) for int in ranges]
if origin:
data = {
"transportMode": transport_mode.__str__(),
"origin": str.format("{0},{1}", origin[0], origin[1]),
"range[type]": IsolineRoutingRangeType.distance.__str__(),
"range[values]": ",".join(string_ranges),
"apiKey": self._api_key,
}
return self.__get(self._base_url, data, "departure")
elif destination:
data = {
"transportMode":
transport_mode.__str__(),
"destination":
str.format("{0},{1}", destination[0], destination[1]),
"range[type]":
IsolineRoutingRangeType.distance.__str__(),
"range[values]":
",".join(string_ranges),
"apiKey":
self._api_key,
}
return self.__get(self._base_url, data, "arrival")
else:
raise HEREError(
"Please provide values for origin or destination parameter.")
def encode_parameters(parameters):
"""Return a string in key=value&key=value form.
Values of None are not included in the output string.
Args:
parameters (dict):
dictionary of query parameters to be converted.
Returns:
A URL-encoded string in "key=value&key=value" form
"""
if parameters is None:
return None
if not isinstance(parameters, dict):
raise HEREError("`parameters` must be a dict.")
else:
return urlencode(dict((k, v) for k, v in parameters.items() if v is not None))
def _route(self,
waypoint_a,
waypoint_b,
modes=None,
departure=None,
arrival=None):
if isinstance(waypoint_a, str):
waypoint_a = self._get_coordinates_for_location_name(waypoint_a)
if isinstance(waypoint_b, str):
waypoint_b = self._get_coordinates_for_location_name(waypoint_b)
data = {
"waypoint0": self.__list_to_waypoint(waypoint_a),
"waypoint1": self.__list_to_waypoint(waypoint_b),
"mode": self.__prepare_mode_values(modes),
"apikey": self._api_key,
}
if departure is not None and arrival is not None:
raise HEREError("Specify either departure or arrival, not both.")
if departure is not None:
departure = self._convert_datetime_to_isoformat(departure)
data["departure"] = departure
if arrival is not None:
arrival = self._convert_datetime_to_isoformat(arrival)
data["arrival"] = arrival
response = self.__get(self.URL_CALCULATE_ROUTE, data, "response",
RoutingResponse)
route = response.response["route"]
maneuver = route[0]["leg"][0]["maneuver"]
if any(mode in modes for mode in [RouteMode.car, RouteMode.truck]):
# Get Route for Car and Truck
response.route_short = self._get_route_from_vehicle_maneuver(
maneuver)
elif any(
mode in modes for mode in
[RouteMode.publicTransport, RouteMode.publicTransportTimeTable]):
# Get Route for Public Transport
public_transport_line = route[0]["publicTransportLine"]
response.route_short = self._get_route_from_public_transport_line(
public_transport_line)
elif any(mode in modes
for mode in [RouteMode.pedestrian, RouteMode.bicycle]):
# Get Route for Pedestrian and Biyclce
response.route_short = self._get_route_from_non_vehicle_maneuver(
maneuver)
return response
def error_from_routing_service_error(json_data):
"""Return the correct subclass for routing errors"""
if 'subtype' in json_data:
subtype = json_data['subtype']
details = json_data['details']
if subtype == 'InvalidCredentials':
return InvalidCredentialsError(details)
if subtype == 'InvalidInputData':
return InvalidInputDataError(details)
if subtype == 'WaypointNotFound':
return WaypointNotFoundError(details)
if subtype == 'NoRouteFound':
return NoRouteFoundError(details)
if subtype == 'LinkIdNotFound':
return LinkIdNotFoundError(details)
if subtype == 'RouteNotReconstructed':
return RouteNotReconstructedError(details)
# pylint: disable=W0212
return HEREError('Error occured on ' + sys._getframe(1).f_code.co_name)
def error_from_routing_service_error(json_data):
"""Return the correct subclass for routing errors"""
if "error" in json_data:
if json_data["error"] == "Unauthorized":
return InvalidCredentialsError(json_data["error_description"])
if "subtype" in json_data:
subtype = json_data["subtype"]
details = json_data["details"]
if subtype == "InvalidInputData":
return InvalidInputDataError(details)
if subtype == "WaypointNotFound":
return WaypointNotFoundError(details)
if subtype == "NoRouteFound":
return NoRouteFoundError(details)
if subtype == "LinkIdNotFound":
return LinkIdNotFoundError(details)
if subtype == "RouteNotReconstructed":
return RouteNotReconstructedError(details)
# pylint: disable=W0212
return HEREError("Error occurred on " + sys._getframe(1).f_code.co_name)
def forecast_astronomy(self, destination):
"""Request forecast for given destination.
Args:
destination (str):
Destination name.
Returns:
DestinationWeatherResponse instance or HEREError
"""
data = {
'app_id': self._app_id,
'app_code': self._app_code,
'product': destination
}
url = Utils.build_url(self._base_url, extra_params=data)
response = requests.get(url, timeout=self._timeout)
json_data = json.loads(response.content.decode('utf8'))
if json_data.get('astronomy') != None:
return DestinationWeatherResponse.new_from_jsondict(json_data)
else:
return HEREError(
json_data.get(
'Message',
'Error occured on ' + sys._getframe(1).f_code.co_name))
def sync_matrix(
self,
origins: Union[List[float], str],
destinations: Union[List[float], str],
matrix_type: MatrixRoutingType = MatrixRoutingType.world,
center: Optional[List[float]] = None,
radius: Optional[int] = None,
profile: Optional[MatrixRoutingProfile] = None,
departure: str = None,
routing_mode: Optional[MatrixRoutingMode] = None,
transport_mode: Optional[MatrixRoutingTransportMode] = None,
avoid: Optional[Avoid] = None,
truck: Optional[Truck] = None,
matrix_attributes: Optional[List[MatrixSummaryAttribute]] = None,
) -> Optional[RoutingMatrixResponse]:
"""Sync request a matrix of route summaries between M starts and N destinations.
Args:
origins (List):
List of lists of coordinates [lat,long] of start waypoints.
or list of string with the location names.
destinations (List):
List of lists of coordinates [lat,long] of destination waypoints.
or list of string with the location names.
matrix_type (MatrixRoutingType):
Routing type used in definition of a region in which the matrix will be calculated.
center (Optional[List]):
Center of region definition, latitude and longitude.
radius (Optional[int]):
Center of region definition.
profile (Optional[MatrixRoutingProfile]):
A profile ID enables the calculation of matrices with routes of arbitrary length.
departure (str):
time when travel is expected to start, e.g.: '2013-07-04T17:00:00+02'
routing_mode (Optional[MatrixRoutingMode]):
Route mode used in optimization of route calculation.
transport_mode (Optional[MatrixRoutingTransportMode]):
Depending on the transport mode special constraints, speed attributes and weights
are taken into account during route calculation.
avoid (Optional[Avoid]):
Avoid routes that violate these properties.
truck (Optional[Truck]):
Different truck options to use during route calculation when transportMode = truck.
matrix_attributes (List):
List of MatrixSummaryAttribute enums.
Returns:
RoutingMatrixResponse
Raises:
HEREError: If an error is received from the server.
"""
query_params = {
"apiKey": self._api_key,
"async": "false",
}
request_body = self.__prepare_matrix_request_body(
origins=origins,
destinations=destinations,
matrix_type=matrix_type,
center=center,
radius=radius,
profile=profile,
departure=departure,
routing_mode=routing_mode,
transport_mode=transport_mode,
avoid=avoid,
truck=truck,
matrix_attributes=matrix_attributes,
)
url = Utils.build_url(self.URL_CALCULATE_MATRIX,
extra_params=query_params)
headers = {"Content-Type": "application/json"}
response = requests.post(url,
json=request_body,
headers=headers,
timeout=self._timeout)
json_data = json.loads(response.content.decode("utf8"))
if response.status_code == requests.codes.OK:
if json_data.get("matrix") is not None:
return RoutingMatrixResponse.new_from_jsondict(json_data)
else:
raise HEREError("Error occurred on routing_api sync_matrix " +
sys._getframe(1).f_code.co_name +
" response status code " +
str(response.status_code))
else:
if "title" in json_data and "cause" in json_data:
raise HEREError(
str.format(
"routing_api sync_matrix failed! title: {0}, cause: {1}",
json_data["title"],
json_data["cause"],
))
else:
raise HEREError("Error occurred on routing_api sync_matrix " +
sys._getframe(1).f_code.co_name)
def async_matrix(
self,
token: str,
origins: Union[List[float], str],
destinations: Union[List[float], str],
matrix_type: MatrixRoutingType = MatrixRoutingType.world,
center: Optional[List[float]] = None,
radius: Optional[int] = None,
profile: Optional[MatrixRoutingProfile] = None,
departure: str = None,
routing_mode: Optional[MatrixRoutingMode] = None,
transport_mode: Optional[MatrixRoutingTransportMode] = None,
avoid: Optional[Avoid] = None,
truck: Optional[Truck] = None,
matrix_attributes: Optional[List[MatrixSummaryAttribute]] = None,
) -> Optional[RoutingMatrixResponse]:
"""Async request a matrix of route summaries between M starts and N destinations.
Args:
token (str):
Bearer token required for async calls. This is the only working solution for now.
How to create a bearer token:
https://developer.here.com/documentation/identity-access-management/dev_guide/topics/sdk.html#step-1-register-your-application
https://developer.here.com/documentation/identity-access-management/dev_guide/topics/postman.html
origins (List):
List of lists of coordinates [lat,long] of start waypoints.
or list of string with the location names.
destinations (List):
List of lists of coordinates [lat,long] of destination waypoints.
or list of string with the location names.
matrix_type (MatrixRoutingType):
Routing type used in definition of a region in which the matrix will be calculated.
center (Optional[List]):
Center of region definition, latitude and longitude.
radius (Optional[int]):
Center of region definition.
profile (Optional[MatrixRoutingProfile]):
A profile ID enables the calculation of matrices with routes of arbitrary length.
departure (str):
time when travel is expected to start, e.g.: '2013-07-04T17:00:00+02'
routing_mode (Optional[MatrixRoutingMode]):
Route mode used in optimization of route calculation.
transport_mode (Optional[MatrixRoutingTransportMode]):
Depending on the transport mode special constraints, speed attributes and weights
are taken into account during route calculation.
avoid (Optional[Avoid]):
Avoid routes that violate these properties.
truck (Optional[Truck]):
Different truck options to use during route calculation when transportMode = truck.
matrix_attributes (List):
List of MatrixSummaryAttribute enums.
Returns:
RoutingMatrixResponse.
Raises:
HEREError: If an error is received from the server.
"""
query_params = {}
request_body = self.__prepare_matrix_request_body(
origins=origins,
destinations=destinations,
matrix_type=matrix_type,
center=center,
radius=radius,
profile=profile,
departure=departure,
routing_mode=routing_mode,
transport_mode=transport_mode,
avoid=avoid,
truck=truck,
matrix_attributes=matrix_attributes,
)
url = Utils.build_url(self.URL_CALCULATE_MATRIX,
extra_params=query_params)
headers = {
"Content-Type": "application/json",
"Authorization": str.format("Bearer {0}", token),
}
json_data = json.dumps(request_body)
response = requests.post(url,
json=request_body,
headers=headers,
timeout=self._timeout)
if response.status_code == requests.codes.ACCEPTED:
json_data = response.json()
print("Matrix {} calculation {}".format(json_data["matrixId"],
json_data["status"]))
poll_url = json_data["statusUrl"]
headers = {"Authorization": str.format("Bearer {0}", token)}
print("Polling matrix calculation started!")
result = polling.poll(
lambda: requests.get(poll_url, headers=headers),
check_success=self.__is_correct_response,
step=5,
poll_forever=True,
)
print("Polling matrix calculation completed!")
poll_data = result.json()
return RoutingMatrixResponse.new_from_jsondict(poll_data)
else:
json_data = response.json()
if (json_data.get("error") is not None
and json_data.get("error_description") is not None):
raise HEREError("Error occurred on async_matrix: " +
json_data["error"] + ", description: " +
json_data["error_description"])
elif (json_data.get("title") is not None
and json_data.get("cause") is not None):
raise HEREError("Error occurred on async_matrix: " +
json_data["title"] + ", cause: " +
json_data["cause"])
else:
raise HEREError("Error occurred on async_matrix " +
sys._getframe(1).f_code.co_name)
def isoline_routing_at_specific_time(
self,
transport_mode: IsolineRoutingTransportMode,
ranges: List[int],
origin: Optional[List[float]] = None,
departure_time: Optional[str] = None,
destination: Optional[List[float]] = None,
arrival_time: Optional[str] = None,
):
"""To calculate an isoline around an origin with a specific time, use departureTime.
For a reverse isoline, that is, when using destination, you can use arrivalTime.
If departureTime or arrivalTime are specified as "any", the isoline calculation will
not take traffic flow and other time-dependent effects into account. This can be useful
when it is not certain for what time of the day the isoline needs to be computed.
Args:
transport_mode (IsolineRoutingTransportMode):
Transport mode of routing.
ranges (List):
List of range values for isoline (in meters).
origin (List):
List including latitude and longitude in order.
departure_time (str):
Departure time of the routing in format yyyy-MM-ddThh:mm:ss.
destination (List):
List including latitude and longitude in order.
arrival_time (str):
Arrival time of the planned routing in format yyyy-MM-ddThh:mm:ss.
Returns:
IsolineRoutingResponse
Raises:
HEREError"""
string_ranges = [str(int) for int in ranges]
if origin and departure_time:
data = {
"transportMode": transport_mode.__str__(),
"origin": str.format("{0},{1}", origin[0], origin[1]),
"departureTime": departure_time,
"range[type]": IsolineRoutingRangeType.time.__str__(),
"range[values]": ",".join(string_ranges),
"apiKey": self._api_key,
}
return self.__get(self._base_url, data, "departure")
elif destination and arrival_time:
data = {
"transportMode":
transport_mode.__str__(),
"destination":
str.format("{0},{1}", destination[0], destination[1]),
"arrivalTime":
arrival_time,
"range[type]":
IsolineRoutingRangeType.time.__str__(),
"range[values]":
",".join(string_ranges),
"apiKey":
self._api_key,
}
return self.__get(self._base_url, data, "arrival")
else:
raise HEREError(
"Please provide either origin & departure_time or destination & arrival_time."
)
def __get_client_error_from_response(self, json_data):
if "title" in json_data and "cause" in json_data:
return HEREError("Error on client: " + json_data["title"] +
" cause: " + json_data["cause"])
else:
return HEREError("herepy got a 400 from isoline router API")
def calculate_route(
self,
departure: List[float],
arrival: List[float],
time: str,
max_connections: int = 3,
changes: int = -1,
lang: str = "en",
include_modes: List[PublicTransitModeType] = None,
exclude_modes: List[PublicTransitModeType] = None,
units: str = "metric",
max_walking_distance: int = 2000,
walking_speed: int = 100,
show_arrival_times: bool = True,
graph: bool = False,
routing_mode: PublicTransitRoutingMode = PublicTransitRoutingMode.
schedule,
) -> Optional[PublicTransitResponse]:
"""Request a public transit route between any two places.
Args:
departure (List):
List contains latitude and longitude in order.
arrival (List):
List contains latitude and longitude in order.
time (str):
time formatted in yyyy-mm-ddThh:mm:ss.
max_connections (int):
Specifies the number of following departure/arrivals the response should include.
The possible values are: 1-6.
changes (int):
Specifies the maximum number of changes or transfers allowed in a route.
0-6 or -1.
The default is -1 (which disables the filter, or unlimited no of changes permitted).
lang (str):
Specifies the language of the response.
include_modes (List[PublicTransitModeType]):
Specifies the transit type filter used to determine which types of transit to include in the response.
exclude_modes (List[PublicTransitModeType]):
Specifies the transit type filter used to determine which types of transit to exclude in the response.
units (str):
Units of measurement used. metric oder imperial.
max_walking_distance (int):
Specifies a maximum walking distance in meters. Allowed values are 0-6000.
walking_speed (int):
Specifies the walking speed in percent of normal walking speed. Allowed values are 50-200.
show_arrival_times (boolean):
flag to indicate if response should show arrival times or departure times.
graph (boolean):
flag to indicate if response should contain coordinate pairs to allow the drawing of a polyline for the route.
routing_type (PublicTransitRoutingType):
type of routing. Default is time_tabled.
Returns:
PublicTransitResponse
Raises:
HEREError
"""
data = {
"dep": str.format("{0},{1}", departure[0], departure[1]),
"arr": str.format("{0},{1}", arrival[0], arrival[1]),
"max": max_connections,
"time": time,
"changes": changes,
"lang": lang,
"units": units,
"walk": ",".join([str(max_walking_distance),
str(walking_speed)]),
"arrival": 1 if show_arrival_times == True else 0,
"apikey": self._api_key,
"graph": 1 if graph == True else 0,
"routingMode": routing_mode.__str__(),
}
modes = None
if include_modes is not None and exclude_modes is not None:
raise HEREError(
"Specify either include_modes or exclude_modes, not both.")
if include_modes is not None:
modes = ",".join(mode.__str__() for mode in include_modes)
if exclude_modes is not None:
modes = ",".join("-" + mode.__str__() for mode in exclude_modes)
if modes is not None:
data["modes"] = modes
response = self.__get(data, "route.json", "Connections")
response_with_short_route = self._get_response_with_short_route(
response)
return response_with_short_route
