pyvalhalla-git 3.5.1.post132__cp311-cp311-manylinux_2_28_x86_64.whl

valhalla/__init__.py

@@ -0,0 +1,11 @@
+from pathlib import Path
+
+try:
+    from ._valhalla import *
+except ModuleNotFoundError:
+    from _valhalla import *
+from .actor import Actor
+from .config import get_config, get_help
+from .__version__ import __version__
+
+PYVALHALLA_DIR = Path(__file__).parent.resolve()

valhalla/__main__.py

@@ -0,0 +1,72 @@
+import subprocess
+import sys
+from typing import Optional
+
+from ._scripts import PYVALHALLA_BIN_DIR, run
+
+try:
+    from .__version__ import version as __version__
+except ImportError:
+    __version__ = "undefined"
+
+PRINT_BIN_PATH = "print_bin_path"
+
+
+def print_help():
+    # left-align executable names
+    exe_names = [p.name for p in PYVALHALLA_BIN_DIR.iterdir()]
+    fixed_width = len(max(exe_names, key=lambda x: len(x)))
+
+    # TODO: we also want the git commit to show here, probably written to __version__.py by setup.py's BDistWheelCommand
+    print(
+        F"""
+valhalla Python package {__version__}
+
+pyvalhalla package provides a CLI to run Valhalla C++ executables. Arguments are simply passed on as they are.
+One notable exception is --quiet/-q, which will forward the C++ executable's stdout to /dev/null.
+'python -m valhalla --help' will print this help.
+
+Example usage: 'python -m valhalla --quiet valhalla_build_tiles -c valhalla.json -s initialize -e build test.pbf'
+
+Available commands (in {PYVALHALLA_BIN_DIR}):
+\t{PRINT_BIN_PATH:<{fixed_width}} - Print the absolute path of directory containing the C++ executables
+"""
+    )
+
+
+def main():
+    if len(sys.argv) < 2:
+        print("[FATAL] command needs arguments, see 'python -m valhalla --help': \n")
+        print_help()
+        sys.exit(1)
+
+    prog_or_opt = sys.argv[1]
+
+    if prog_or_opt in ("--help", "-h"):
+        print_help()
+        sys.exit(0)
+    elif prog_or_opt == PRINT_BIN_PATH:
+        # useful when another script wants to run the executables directly for some reason
+        print(PYVALHALLA_BIN_DIR)
+    else:
+        exc: Optional[Exception] = None
+        try:
+            run(from_main=True)
+        except (FileNotFoundError, subprocess.CalledProcessError) as e:
+            exc = e
+        finally:
+            if not exc:
+                sys.exit(0)
+
+            if isinstance(exc, subprocess.CalledProcessError):
+                print(f"Failed calling command '{exc.cmd}'\n")
+
+            print_help()
+            print("Sub-command failed with:\n")
+            print(exc, file=sys.stderr)
+
+            sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

valhalla/__version__.py

@@ -0,0 +1,21 @@
+# file generated by setuptools-scm
+# don't change, don't track in version control
+
+__all__ = ["__version__", "__version_tuple__", "version", "version_tuple"]
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple
+    from typing import Union
+
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '3.5.1.post132'
+__version_tuple__ = version_tuple = (3, 5, 1, 'post132')

valhalla/_scripts.py

@@ -0,0 +1,46 @@
+from pathlib import Path
+from shutil import which
+import subprocess
+import sys
+
+from . import PYVALHALLA_DIR
+
+PYVALHALLA_BIN_DIR = PYVALHALLA_DIR.joinpath("bin").resolve()
+
+
+def run(from_main=False) -> None:
+    """
+    Parses the command line arguments and runs the Valhalla executables with the
+    provided arguments. Note, by default we assume this is not being called by
+    __main__.py via e.g. 'python -m valhalla ...', but directly with e.g.d
+    'valhalla_build_tiles -h'. sys.argv relates to different executables for
+    both scenarios.
+
+    :param from_main: We parse sys.argv differently if it's called from __main__.py
+    """
+    prog = sys.argv[1] if from_main else Path(sys.argv[0]).name
+    prog_args = sys.argv[2:] if from_main else sys.argv[1:]
+
+    if not which(prog):
+        raise FileNotFoundError(f"Can't find executable at {prog}")
+    prog_path = PYVALHALLA_BIN_DIR.joinpath(prog).resolve()
+
+    print(f"[INFO] Running {prog_path} with args: {prog_args}...")
+
+    # --quiet/-q is our option, don't pass it to the executables
+    is_quiet = False
+    for arg in prog_args:
+        if arg not in ("--quiet", "-q"):
+            continue
+        prog_args.pop(prog_args.index(arg))
+        is_quiet = True
+
+    # recommended way to call exe
+    proc = subprocess.run(
+        [str(prog_path)] + prog_args,
+        stderr=sys.stderr,
+        stdout=subprocess.DEVNULL if is_quiet else sys.stdout,
+    )
+
+    # raises CalledProcessError if not successful
+    proc.check_returncode()

valhalla/_valhalla.cc

@@ -0,0 +1,81 @@
+#include "baldr/rapidjson_utils.h"
+#include "midgard/logging.h"
+#include "midgard/util.h"
+#include "tyr/actor.h"
+
+#include <boost/make_shared.hpp>
+#include <boost/noncopyable.hpp>
+#include <boost/property_tree/ptree.hpp>
+#include <pybind11/pybind11.h>
+
+#include <string>
+
+namespace vt = valhalla::tyr;
+namespace {
+
+// configuring multiple times is wasteful/ineffectual but not harmful
+// TODO: make this threadsafe just in case its abused
+const boost::property_tree::ptree configure(const std::string& config) {
+  boost::property_tree::ptree pt;
+  try {
+    // parse the config and configure logging
+    rapidjson::read_json(config, pt);
+
+    auto logging_subtree = pt.get_child_optional("mjolnir.logging");
+    if (logging_subtree) {
+      auto logging_config = valhalla::midgard::ToMap<const boost::property_tree::ptree&,
+                                                     std::unordered_map<std::string, std::string>>(
+          logging_subtree.get());
+      valhalla::midgard::logging::Configure(logging_config);
+    }
+  } catch (...) { throw std::runtime_error("Failed to load config from: " + config); }
+
+  return pt;
+}
+} // namespace
+
+namespace py = pybind11;
+
+PYBIND11_MODULE(_valhalla, m) {
+  py::class_<vt::actor_t>(m, "_Actor", "Valhalla Actor class")
+      .def(py::init<>([](std::string config) { return vt::actor_t(configure(config), true); }))
+      .def(
+          "route", [](vt::actor_t& self, std::string& req) { return self.route(req); },
+          "Calculates a route.")
+      .def(
+          "locate", [](vt::actor_t& self, std::string& req) { return self.locate(req); },
+          "Provides information about nodes and edges.")
+      .def(
+          "optimized_route",
+          [](vt::actor_t& self, std::string& req) { return self.optimized_route(req); },
+          "Optimizes the order of a set of waypoints by time.")
+      .def(
+          "matrix", [](vt::actor_t& self, std::string& req) { return self.matrix(req); },
+          "Computes the time and distance between a set of locations and returns them as a matrix table.")
+      .def(
+          "isochrone", [](vt::actor_t& self, std::string& req) { return self.isochrone(req); },
+          "Calculates isochrones and isodistances.")
+      .def(
+          "trace_route", [](vt::actor_t& self, std::string& req) { return self.trace_route(req); },
+          "Map-matching for a set of input locations, e.g. from a GPS.")
+      .def(
+          "trace_attributes",
+          [](vt::actor_t& self, std::string& req) { return self.trace_attributes(req); },
+          "Returns detailed attribution along each portion of a route calculated from a set of input locations, e.g. from a GPS trace.")
+      .def(
+          "height", [](vt::actor_t& self, std::string& req) { return self.height(req); },
+          "Provides elevation data for a set of input geometries.")
+      .def(
+          "transit_available",
+          [](vt::actor_t& self, std::string& req) { return self.transit_available(req); },
+          "Lookup if transit stops are available in a defined radius around a set of input locations.")
+      .def(
+          "expansion", [](vt::actor_t& self, std::string& req) { return self.expansion(req); },
+          "Returns all road segments which were touched by the routing algorithm during the graph traversal.")
+      .def(
+          "centroid", [](vt::actor_t& self, std::string& req) { return self.centroid(req); },
+          "Returns routes from all the input locations to the minimum cost meeting point of those paths.")
+      .def(
+          "status", [](vt::actor_t& self, std::string& req) { return self.status(req); },
+          "Returns nothing or optionally details about Valhalla's configuration.");
+}

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