pyvalhalla-git 3.5.1.post132__cp39-cp39-win_amd64.whl

valhalla/actor.py

@@ -0,0 +1,118 @@
+import json
+import tempfile
+from pathlib import Path
+from typing import Union
+
+try:
+    from ._valhalla import _Actor
+except ModuleNotFoundError:
+    from _valhalla import _Actor
+
+
+# TODO: wasteful for dict input/output; more reasonable would be to extend
+#   the Actor's action C++ interfaces with a JSON arg
+def dict_or_str(func):
+    def wrapped(*args):
+        # /status doesn't take any parameters
+        if not len(args) > 1:
+            return func(*args)
+
+        if isinstance(args[1], dict):
+            return json.loads(func(args[0], json.dumps(args[1])))
+        elif not isinstance(args[1], str):
+            raise ValueError("Request must be either of type str or dict")
+        return func(*args)
+
+    return wrapped
+
+
+class Actor(_Actor):
+    def __init__(self, config: Union[Path, str, dict]):
+        """
+        Valhalla's Actor class is used to call its actions, like route, isochrone, matrix etc.
+
+        Configuration passed in either by an existing configuration JSON file path or in `dict` form,
+        e.g. by calling valhalla.config.get_config(). In the latter case a temp file will be
+        created.
+
+        For details on parameters for each function consult Valhalla's documentation:
+        https://github.com/valhalla/valhalla/blob/master/docs/api
+        """
+        # make sure there's a valhalla.json file
+        if isinstance(config, dict):
+            with tempfile.NamedTemporaryFile(
+                "w", suffix=".json", prefix="valhalla_config_", delete=False
+            ) as f:
+                json.dump(config, f)
+                self._config_path = f.name
+        elif isinstance(config, str):
+            if not Path(config).is_file():
+                raise FileNotFoundError(f"Valhalla JSON config file doesn't exist: {config}")
+            self._config_path = config
+        elif isinstance(config, Path):
+            self._config_path = str(config.resolve())
+        else:
+            raise AttributeError(f"Valhalla JSON config can't be of type {type(config)}")
+
+        # test if there's an extract or tile_dir
+        with open(self._config_path) as f:
+            config = json.load(f)
+        tile_extract_fp = config.get("mjolnir", {}).get("tile_extract")
+        tile_dir = config.get("mjolnir", {}).get("tile_dir")
+
+        # raise if neither exists
+        if not tile_extract_fp and not tile_dir:
+            raise AttributeError(
+                "Valhalla config JSON is not valid: mjolnir.tile_extract and mjolnir.tile_dir are missing."
+            )
+        if not Path(config["mjolnir"]["tile_extract"]).is_file():
+            if not Path(config["mjolnir"]["tile_dir"]).is_dir():
+                raise FileNotFoundError(
+                    f"Neither mjolnir.tile_extract ({Path(tile_extract_fp).resolve()}) nor mjolnir.tile_dir ({Path(tile_dir).resolve()}) exists. Can't load graph."
+                )
+
+        super(Actor, self).__init__(self._config_path)
+
+    @dict_or_str
+    def route(self, req: Union[str, dict]):
+        return super().route(req)
+
+    @dict_or_str
+    def locate(self, req: Union[str, dict]):
+        return super().locate(req)
+
+    @dict_or_str
+    def isochrone(self, req: Union[str, dict]):
+        return super().isochrone(req)
+
+    @dict_or_str
+    def matrix(self, req: Union[str, dict]):
+        return super().matrix(req)
+
+    @dict_or_str
+    def trace_route(self, req: Union[str, dict]):
+        return super().trace_route(req)
+
+    @dict_or_str
+    def trace_attributes(self, req: Union[str, dict]):
+        return super().trace_attributes(req)
+
+    @dict_or_str
+    def height(self, req: Union[str, dict]):
+        return super().height(req)
+
+    @dict_or_str
+    def transit_available(self, req: Union[str, dict]):
+        return super().transit_available(req)
+
+    @dict_or_str
+    def expansion(self, req: Union[str, dict]):
+        return super().expansion(req)
+
+    @dict_or_str
+    def centroid(self, req: Union[str, dict]):
+        return super().centroid(req)
+
+    @dict_or_str
+    def status(self, req: Union[str, dict] = ""):
+        return super().status(req)

valhalla/config.py

@@ -0,0 +1,45 @@
+from pathlib import Path
+from typing import Union, Dict
+
+from .valhalla_build_config import config as default_config, Optional, help_text
+
+
+def _sanitize_config(dict_: dict = None) -> dict:
+    """remove the "Optional" values from the config."""
+    int_dict_ = dict_.copy()
+    for k, v in int_dict_.items():
+        if isinstance(v, Optional):
+            del dict_[k]
+        elif isinstance(v, dict):
+            _sanitize_config(v)
+
+    return dict_
+
+
+def get_help() -> Dict[str, Union[Dict[str, str], str]]:
+    """
+    Returns the help dictionary with the same keys as the config JSON.
+    """
+    return help_text
+
+
+def get_config(
+    tile_extract: Union[str, Path] = "valhalla_tiles.tar",
+    tile_dir: Union[str, Path] = "valhalla_tiles",
+    verbose: bool = False,
+) -> dict:
+    """
+    Returns a default Valhalla configuration.
+
+    :param tile_extract: The file path (with .tar extension) of the tile extract (mjolnir.tile_extract), if present. Preferred over tile_dir.
+    :param tile_dir: The directory path where the graph tiles are stored (mjolnir.tile_dir), if present.
+    :param verbose: Whether you want to see Valhalla's logs on stdout (mjolnir.logging). Default False.
+    """
+
+    config = _sanitize_config(default_config.copy())
+
+    config["mjolnir"]["tile_dir"] = str(Path(tile_dir).resolve())
+    config["mjolnir"]["tile_extract"] = str(Path(tile_extract).resolve())
+    config["mjolnir"]["logging"]["type"] = "std_out" if verbose else ""
+
+    return config

valhalla/utils.py

@@ -0,0 +1,62 @@
+from typing import List, Tuple
+
+
+def decode_polyline(
+    polyline: str, precision: int = 6, order: str = "lnglat"
+) -> List[Tuple[float, float]]:
+    """Decodes an encoded ``polyline`` string with ``precision`` to a list of coordinate tuples.
+    The coordinate ``order`` of the output can be ``lnglat`` or ``latlng``."""
+
+    return _decode(polyline, precision=precision, order=order, is3d=False)
+
+
+def _trans(value, index):
+    """
+    Copyright (c) 2014 Bruno M. Custódio
+    Copyright (c) 2016 Frederick Jansen
+    https://github.com/hicsail/polyline/commit/ddd12e85c53d394404952754e39c91f63a808656
+    """
+    byte, result, shift = None, 0, 0
+
+    while byte is None or byte >= 0x20:
+        byte = ord(value[index]) - 63
+        index += 1
+        result |= (byte & 0x1F) << shift
+        shift += 5
+        comp = result & 1
+
+    return ~(result >> 1) if comp else (result >> 1), index
+
+
+def _decode(expression, precision=5, order="lnglat", is3d=False):
+    """
+    Copyright (c) 2014 Bruno M. Custódio
+    Copyright (c) 2016 Frederick Jansen
+    https://github.com/hicsail/polyline/commit/ddd12e85c53d394404952754e39c91f63a808656
+
+    Modified to be able to work with 3D polylines and a specified coordinate order.
+    """
+    coordinates, index, lat, lng, z, length, factor = (
+        [],
+        0,
+        0,
+        0,
+        0,
+        len(expression),
+        float(10**precision),
+    )
+
+    while index < length:
+        lat_change, index = _trans(expression, index)
+        lng_change, index = _trans(expression, index)
+        lat += lat_change
+        lng += lng_change
+        coord = (lat / factor, lng / factor) if order == "latlng" else (lng / factor, lat / factor)
+        if not is3d:
+            coordinates.append(coord)
+        else:
+            z_change, index = _trans(expression, index)
+            z += z_change
+            coordinates.append((*coord, z / 100))
+
+    return coordinates