fix: remove unit conversion logic, add km and mi properties (#139)

In details:
- removes the (erroneous) conversion logic as well as the `units` property on Valhalla and OpenRouteService `directions` functions,
- adds two new properties to `Direction` class (`km` and `mi`).

Fixes #138.

Author: mthh

routingpy/direction.py

@@ -114,6 +114,14 @@ def distance(self) -> int:
         """
         return self._distance
 
+    @property
+    def km(self) -> float:
+        return self.distance / 1000
+
+    @property
+    def mi(self) -> float:
+        return self.distance * 0.0006213712
+
     @property
     def raw(self) -> Optional[dict]:
         """

routingpy/routers/openrouteservice.py

@@ -106,7 +106,6 @@ def directions(  # noqa: C901
         format: Optional[str] = "geojson",
         preference: Optional[str] = None,
         alternative_routes: Optional[dict] = None,
-        units: Optional[str] = None,
         language: Optional[str] = None,
         geometry: Optional[bool] = None,
         geometry_simplify: Optional[bool] = None,
@@ -151,9 +150,6 @@ def directions(  # noqa: C901
             and "weight_factor".
         :type alternative_routes: dict
 
-        :param units: Specifies the distance unit. One of ["m", "km", "mi"]. Default "m".
-        :type units: str
-
         :param language: Language for routing instructions. One of ["en", "de", "cn",
             "es", "ru", "dk", "fr", "it", "nl", "br", "se", "tr", "gr"].
         :type language: str
@@ -254,9 +250,6 @@ def directions(  # noqa: C901
                 )
             params["alternative_routes"] = alternative_routes
 
-        if units:
-            params["units"] = units
-
         if language:
             params["language"] = language
 
@@ -315,21 +308,14 @@ def directions(  # noqa: C901
                 dry_run=dry_run,
             ),
             format,
-            units,
             alternative_routes,
         )
 
     @staticmethod
-    def parse_direction_json(response, format, units, alternative_routes):
+    def parse_direction_json(response, format, alternative_routes):
         if response is None:  # pragma: no cover
             return Direction()
 
-        units_factor = 1
-        if units == "mi":
-            units_factor = 0.621371 * 1000
-        elif units == "km":
-            units_factor = 1000
-
         if format == "geojson":
             if alternative_routes:
                 routes = []
@@ -346,9 +332,7 @@ def parse_direction_json(response, format, units, alternative_routes):
             else:
                 geometry = response["features"][0]["geometry"]["coordinates"]
                 duration = int(response["features"][0]["properties"]["summary"]["duration"])
-                distance = int(
-                    response["features"][0]["properties"]["summary"]["distance"] * units_factor
-                )
+                distance = int(response["features"][0]["properties"]["summary"]["distance"])
                 return Direction(geometry=geometry, duration=duration, distance=distance, raw=response)
         elif format == "json":
             if alternative_routes:
@@ -360,7 +344,7 @@ def parse_direction_json(response, format, units, alternative_routes):
                     routes.append(
                         Direction(
                             geometry=geometry,
-                            distance=int(route["summary"]["distance"] * units_factor),
+                            distance=int(route["summary"]["distance"]),
                             duration=int(route["summary"]["duration"]),
                             raw=route,
                         )
@@ -369,7 +353,7 @@ def parse_direction_json(response, format, units, alternative_routes):
             else:
                 geometry = utils.decode_polyline5(response["routes"][0]["geometry"])
                 duration = int(response["routes"][0]["summary"]["duration"])
-                distance = int(response["routes"][0]["summary"]["distance"] * units_factor)
+                distance = int(response["routes"][0]["summary"]["distance"])
 
                 return Direction(geometry=geometry, duration=duration, distance=distance, raw=response)
 
@@ -379,7 +363,6 @@ def isochrones(
         profile: str,
         intervals: List[int],
         interval_type: Optional[str] = "time",
-        units: Optional[str] = None,
         location_type: Optional[str] = "start",
         smoothing: Optional[float] = None,
         attributes: Optional[List[str]] = None,
@@ -405,10 +388,6 @@ def isochrones(
             a list of multiple ranges, e.g. [600, 1200, 1400]. In meters or seconds.
         :type intervals: list of int
 
-        :param units: Specifies the unit system to use when displaying results.
-            One of ["m", "km", "m"]. Default "m".
-        :type units: str
-
         :param location_type: 'start' treats the location(s) as starting point,
             'destination' as goal. Default 'start'.
         :type location_type: str
@@ -441,9 +420,6 @@ def isochrones(
         if interval_type:
             params["range_type"] = interval_type
 
-        if units:
-            params["units"] = units
-
         if location_type:
             params["location_type"] = location_type
 
@@ -492,7 +468,6 @@ def matrix(
         destinations: Optional[List[int]] = None,
         metrics: Optional[List[str]] = None,
         resolve_locations: Optional[bool] = None,
-        units: Optional[str] = None,
         dry_run: Optional[bool] = None,
     ):
         """Gets travel distance and time for a matrix of origins and destinations.
@@ -524,10 +499,6 @@ def matrix(
             Default False.
         :type resolve_locations: bool
 
-        :param units: Specifies the unit system to use when displaying results.
-            One of ["m", "km", "m"]. Default "m".
-        :type units: str
-
         :param dry_run: Print URL and parameters without sending the request.
         :param dry_run: bool
 
@@ -549,9 +520,6 @@ def matrix(
         if resolve_locations is not None:
             params["resolve_locations"] = resolve_locations
 
-        if units:
-            params["units"] = units
-
         return self.parse_matrix_json(
             self.client._request(
                 "/v2/matrix/" + profile + "/json", get_params={}, post_params=params, dry_run=dry_run

routingpy/routers/valhalla.py

@@ -115,7 +115,6 @@ def directions(
         profile: str,
         preference: Optional[str] = None,
         options: Optional[dict] = None,
-        units: Optional[str] = None,
         instructions: Optional[bool] = False,
         language: Optional[str] = None,
         directions_type: Optional[str] = None,
@@ -149,8 +148,6 @@ def directions(
             will be filled automatically. For more information, visit:
             https://github.com/valhalla/valhalla/blob/master/docs/api/turn-by-turn/api-reference.md#costing-options
 
-        :param units: Distance units for output. One of ['mi', 'km']. Default km.
-
         :param instructions: Whether to return turn-by-turn instructions. Named for compatibility with other
             providers. Valhalla's parameter here is 'narrative'.
 
@@ -189,7 +186,6 @@ def directions(
             profile,
             preference,
             options,
-            units,
             instructions,
             language,
             directions_type,
@@ -201,8 +197,7 @@ def directions(
         )
 
         return self.parse_direction_json(
-            self.client._request("/route", post_params=params, dry_run=dry_run),
-            units,
+            self.client._request("/route", post_params=params, dry_run=dry_run)
         )
 
     @staticmethod
@@ -211,7 +206,6 @@ def get_direction_params(
         profile,
         preference=None,
         options=None,
-        units=None,
         instructions=False,
         language=None,
         directions_type=None,
@@ -238,10 +232,8 @@ def get_direction_params(
             if preference == "shortest":
                 params["costing_options"][profile]["shortest"] = True
 
-        if any((units, language, directions_type)):
+        if any((language, directions_type)):
             params["directions_options"] = dict()
-            if units:
-                params["directions_options"]["units"] = units
             if language:
                 params["directions_options"]["language"] = language
             if directions_type:
@@ -265,17 +257,17 @@ def get_direction_params(
         return params
 
     @staticmethod
-    def parse_direction_json(response, units):
+    def parse_direction_json(response):
         if response is None:  # pragma: no cover
             return Direction()
 
         geometry, duration, distance = [], 0, 0
         for leg in response["trip"]["legs"]:
             geometry.extend(utils.decode_polyline6(leg["shape"]))
             duration += leg["summary"]["time"]
+            distance += leg["summary"]["length"]
 
-            factor = 0.621371 if units == "mi" else 1
-            distance += int(leg["summary"]["length"] * 1000 * factor)
+        distance *= 1000  # convert to meters
 
         return Direction(geometry=geometry, duration=int(duration), distance=int(distance), raw=response)
 
@@ -504,7 +496,6 @@ def matrix(
         options: Optional[dict] = None,
         avoid_locations: Optional[List[List[float]]] = None,
         avoid_polygons: Optional[List[List[List[float]]]] = None,
-        units: Optional[str] = None,
         date_time: Optional[dict] = None,
         id: Optional[str] = None,
         dry_run: Optional[bool] = None,
@@ -546,8 +537,6 @@ def matrix(
             efficient to use avoid_locations. Valhalla will close open rings (i.e. copy the first coordingate to the
             last position).
 
-        :param units: Distance units for output. One of ['mi', 'km']. Default km.
-
         :param date_time: This is the local date and time at the location. Field ``type``: 0: Current departure time,
             1: Specified departure time. Field ``value```: the date and time is specified
             in format YYYY-MM-DDThh:mm, local time.
@@ -569,15 +558,13 @@ def matrix(
             options,
             avoid_locations,
             avoid_polygons,
-            units,
             date_time,
             id,
             **kwargs
         )
 
         return self.parse_matrix_json(
-            self.client._request("/sources_to_targets", post_params=params, dry_run=dry_run),
-            units,
+            self.client._request("/sources_to_targets", post_params=params, dry_run=dry_run)
         )
 
     @staticmethod
@@ -590,7 +577,6 @@ def get_matrix_params(
         options=None,
         avoid_locations=None,
         avoid_polygons=None,
-        units=None,
         date_time=None,
         id=None,
         **kwargs
@@ -634,9 +620,6 @@ def get_matrix_params(
         if avoid_polygons:
             params["avoid_polygons"] = avoid_polygons
 
-        if units:
-            params["units"] = units
-
         if date_time:
             params["date_time"] = date_time
 
@@ -648,19 +631,16 @@ def get_matrix_params(
         return params
 
     @staticmethod
-    def parse_matrix_json(response, units):
+    def parse_matrix_json(response):
         if response is None:  # pragma: no cover
             return Matrix()
 
-        factor = 0.621371 if units == "mi" else 1
         durations = [
             [destination["time"] for destination in origin] for origin in response["sources_to_targets"]
         ]
         distances = [
             [
-                int(destination["distance"] * 1000 * factor)
-                if destination["distance"] is not None
-                else None
+                destination["distance"] * 1000 if destination["distance"] is not None else None
                 for destination in origin
             ]
             for origin in response["sources_to_targets"]