pyvalhalla-git 3.5.1.post132__cp312-cp312-win_amd64.whl

pyvalhalla_git-3.5.1.post132.dist-info/DELVEWHEEL

@@ -0,0 +1,2 @@
+Version: 1.10.1
+Arguments: ['C:\\hostedtoolcache\\windows\\Python\\3.9.13\\x64\\Scripts\\delvewheel', 'repair', '--add-path', 'build/vcpkg_installed/custom-x64-windows/bin', 'C:\\Users\\runneradmin\\AppData\\Local\\Temp\\cibw-run-f0975jq8\\cp312-win_amd64\\built_wheel\\pyvalhalla_git-3.5.1.post132-cp312-cp312-win_amd64.whl', '-w', 'C:\\Users\\runneradmin\\AppData\\Local\\Temp\\cibw-run-f0975jq8\\cp312-win_amd64\\repaired_wheel']

pyvalhalla_git-3.5.1.post132.dist-info/METADATA

@@ -0,0 +1,137 @@
+Metadata-Version: 2.4
+Name: pyvalhalla-git
+Version: 3.5.1.post132
+Summary: High-level bindings to the Valhalla C++ library
+Home-page: https://github.com/valhalla/valhalla
+Author: Nils Nolde
+Author-email: nilsnolde+pyvalhalla@proton.me
+Classifier: License :: OSI Approved :: GNU Lesser General Public License v2 or later (LGPLv2+)
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Requires-Python: >=3.9.0
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+License-File: COPYING
+License-File: AUTHORS
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+Dynamic: summary
+
+
+## Valhalla Python bindings
+
+This folder contains the Python bindings to [Valhalla routing engine](https://github.com/valhalla/valhalla).
+
+> [!NOTE]
+> `pyvalhalla(-git)` packages are currently only published for:
+> - `linux-x86_x64`
+> - `win-amd64`
+> - `macos-arm64`
+
+On top of the (very) high-level Python bindings, we package some data-building Valhalla executables to ease the process of graph creation.
+
+### Installation
+
+We distribute all currently maintained CPython versions as **binary wheels** for Win64, MacOS (`arm64`) and Linux (`x86_64`) distributions with `glibc>=2.28`. We **do not** offer a source distribution on PyPI.
+
+`pip install pyvalhalla` to install the most recent Valhalla **release**.
+`pip install pyvalhalla-git` to install the most recent Valhalla **master commit**.
+
+### Usage
+
+#### Bindings
+
+Find a more extended notebook in `./examples`, e.g. how to [use the actor](./examples/actor_examples.ipynb).
+
+Before using the Python bindings you need to have access to a routable Valhalla graph. Either install Valhalla from source and built the graph from OSM compatible data or use our [Valhalla docker image](https://github.com/gis-ops/docker-valhalla) for a painless experience, e.g. this will build the routing graph for Andorra in `./custom_files`:
+
+```shell
+docker run --rm --name valhalla_gis-ops -p 8002:8002 -v $PWD/custom_files:/custom_files -e tile_urls=https://download.geofabrik.de/europe/andorra-latest.osm.pbf gisops/valhalla:latest
+```
+
+Once you have created a graph locally, you can use it like this:
+
+```python
+from valhalla import Actor, get_config, get_help
+
+# generate configuration
+config = get_config(tile_extract='./custom_files/valhalla_tiles.tar', verbose=True)
+
+# print the help for specific config items (has the same structure as the output of get_config()
+print(get_help()["service_limits"]["auto"]["max_distance"])
+
+# instantiate Actor to load graph and call actions
+actor = Actor(config)
+route = actor.route({"locations": [...]})
+```
+
+#### Valhalla executables (**`linux-x86_x64` only**)
+
+To access the C++ (native) executables, there are 2 options:
+- (recommended) execute the module, e.g. `python -m valhalla valhalla_build_tiles -h`
+- execute the Python wrapper scripts directly, e.g. `valhalla_build_tiles -h`
+
+> [!NOTE]
+> For the latter option to work, the Python environment's `bin/` folder has to be in the `$PATH`. Inside virtual environments, that's always the case.
+
+Executing the scripts directly might also not work properly if there's a system-wide Valhalla installation, unless the Python environment's `bin/` folder has higher priority than system folders in `$PATH`. The module execution uses an explicit Python executable which should be preferred.
+
+There are also some additional commands we added:
+- `--help`: print the help for `python -m valhalla` explicitly
+- `--quiet`: redirect `stdout` of the C++ executables to `/dev/null`; can be added **once** anywhere in the command, will not be forwarded to a C++ executable
+- `print_bin_path`: simply prints the absolute path to the package-internal `bin/` directory where the C++ executables are; useful if the executables should be accessed directly in some script
+
+To find out which Valhalla executables are currently included, run `python -m valhalla --help`. We limit the number of executables to control the wheel size. However, we're open to include any other executable if there's a good reason.
+
+### Building from source
+
+#### Linux
+
+To package arch-dependent Linux bindings we use a `manylinux` fork, where we install all dependencies into the `manylinux_2_28` image, based on AlmaLinux 8. This is necessary to have a broad `glibc` compatibility with many semi-recent Linux distros.
+
+Either pull the `manylinux` image, or build it locally for testing:
+
+```shell
+docker pull ghcr.io/valhalla/manylinux:2_28_valhalla_python
+
+# or pull the image from ghcr.io
+git clone https://github.com/valhalla/manylinux
+cd manylinux
+POLICY=manylinux_2_28 PLATFORM=x86_64 COMMIT_SHA=$(git rev-parse --verify HEAD) BUILDX_BUILDER=builder-docker-container ./build.sh
+docker tag quay.io/pypa/manylinux_2_28_x86_64:$(git rev-parse --verify HEAD) ghcr.io/valhalla/manylinux:2_28_valhalla_python
+```
+
+Once built, start a container to actually build Valhalla using AlmaLinux 8:
+
+```shell
+cd valhalla
+docker run -dt -v $PWD:/valhalla-py --name valhalla-py --workdir /valhalla-py ghcr.io/valhalla/manylinux:2_28_valhalla_python
+docker exec -t valhalla-py /valhalla-py/src/bindings/python/build_linux.sh build_manylinux 3.13
+```
+
+This will also build & install `libvalhalla` before building the bindings. At this point there should be a `wheelhouse` folder with the fixed python wheel, ready to be installed or distributed to arbitrary python 3.12 installations.
+
+### `cibuildwheel`
+
+On our CI, this orchestrates the packaging of all `pyvalhalla` wheels for every supported, minor Python version and every platform. It can also be run locally (obviously only being able to build wheels for _your_ platform), e.g.
+
+```shell
+python -m pip install cibuildwheel
+cibuildwheel --print-build-identifiers
+cibuildwheel --only cp313-manylinux_x86_64
+
+# for windows you'll have to set an env var to the vcpkg win root
+VCPKG_ARCH_ROOT="build/vcpkg_installed/custom-x64-windows" cibuildwheel --only cp313-manylinux_x86_64
+```
+
+On Linux, this might download the [`manylinux` docker image](https://github.com/valhalla/manylinux/pkgs/container/manylinux). In the end, you'll find the wheel in `./wheelhouse`.
+
+### Testing (**`linux-x86_x64` only**)
+
+We have a small [test script](./test/test_pyvalhalla_package.sh) which makes sure that all the executables are working properly. If run locally for some reason, install a `pyvalhalla` wheel first. We run this in CI in a fresh Docker container with no dependencies installed, mostly to verify dynamic linking of the vendored dependencies.

pyvalhalla_git-3.5.1.post132.dist-info/RECORD

@@ -0,0 +1,38 @@
+_valhalla.cp312-win_amd64.pyd,sha256=J28YTAKadKQQadTeNBqirLGsvELMTAgrvFYLKS7eQp0,8132096
+pyvalhalla_git-3.5.1.post132.data/platlib/abseil_dll-bdd8a5a1f5a4da3f67279509940f7994.dll,sha256=1tPsKVjXYxXSMRqiwisqWBZqan9oTY0QdIbO1lkPkKA,1887744
+pyvalhalla_git-3.5.1.post132.data/platlib/gdal-e68c9d36ee94002182307d221cc91ce3.dll,sha256=9hXkACzQk79BuHHgTl-ez5WRfMX1wbSvYKSq-erJW1w,18052096
+pyvalhalla_git-3.5.1.post132.data/platlib/geos-b8640de6faf146d9855a807e72427e47.dll,sha256=rMxgojYCprUIpViJo_yVD_pdo-dMNrJDKjIdw7gDI9w,2582016
+pyvalhalla_git-3.5.1.post132.data/platlib/geos_c-7d79920a3a18ad2c1ff594fcef060f0a.dll,sha256=4Y7CAmrVctYKVXfrZCg0VFvxhKaJHNijLPUdM6OtTTs,457728
+pyvalhalla_git-3.5.1.post132.data/platlib/geotiff-020296779aedd28fd03f34200e6e3c61.dll,sha256=PWk3itN74x-HJAediz-Gjw83Z3NyTwa1cvXxA7h65w0,161792
+pyvalhalla_git-3.5.1.post132.data/platlib/jpeg62-52d863f4f0f8139faf1608976c1d91f6.dll,sha256=SjnGiaIWwMiUwvuTBP_vkfsWjjvVLXkpmC7CFy5iDac,683520
+pyvalhalla_git-3.5.1.post132.data/platlib/json-c-0d6db73c6075abe84a7bdd2a2d393471.dll,sha256=IlPXuHM61ne0troWglvEwMK378fN8duzzNGUog7p6YU,58880
+pyvalhalla_git-3.5.1.post132.data/platlib/Lerc-d4ff05a506ddcfc551c350aa718ab4da.dll,sha256=-DySnPhaoH9nCPkQ2Y7Vq2w3pRWyg9B4NPbM-0l5Vcw,526848
+pyvalhalla_git-3.5.1.post132.data/platlib/libcurl-bfd466d47923540033e77b192031a728.dll,sha256=nB2vYmFVYjnnrOeYwmbtHQY6xCwq6JDToh6oq71Tf0c,595456
+pyvalhalla_git-3.5.1.post132.data/platlib/libexpat-6da76b3644b9424613b6d75323fcdc82.dll,sha256=vxuy9QhoEf_ft2kgIRIdOVVnfj_sVkU-Dhf6VhxZf-c,159232
+pyvalhalla_git-3.5.1.post132.data/platlib/liblzma-9b97b163f3fff34e786ef56c4f919383.dll,sha256=ud-buTBlGnilzkiz-jyM8R8cECpICtG6YIlnRGwuCZU,185856
+pyvalhalla_git-3.5.1.post132.data/platlib/libpng16-45e0d625267ecee5996170051645e533.dll,sha256=MZvYOuWjg9vqE9Vik1Q0bR19UEqakLekRuBBbsCWgCM,201216
+pyvalhalla_git-3.5.1.post132.data/platlib/libprotobuf-lite-2bea258fef20ab8f71dcb2fec86675a8.dll,sha256=z437wWJ5T6V4xBrWjpXjFoXO4KeDXIzWfhJOE-yc1ZY,1502208
+pyvalhalla_git-3.5.1.post132.data/platlib/lz4-cb6b9d0ac653fc68b286ff6ba7ef9bf5.dll,sha256=miEEE0apHQb6DFgVksS8WI1XNUuKI5dLDbp8JI4f_QA,127488
+pyvalhalla_git-3.5.1.post132.data/platlib/msvcp140-73e7ea186a7d9ab676a764ffa64cf7e6.dll,sha256=cDrXxV8uCWYH7Gp3qLX1LVNdvnH93wIel8vLvCP3SSo,576128
+pyvalhalla_git-3.5.1.post132.data/platlib/proj_9-3a2a70c01b92ddd4e14ab2bc22e06ab7.dll,sha256=K4UyFrthaMgtt5JDBbJBcS3fqLz-M4rbB0A_9mm-aL0,3414528
+pyvalhalla_git-3.5.1.post132.data/platlib/qhull_r-46ecfc2e889bb30a2c3af738edb6eeb9.dll,sha256=r4AobL8RQVZlP8WWC5x3ia_Z2LcFwDJNX6g6nNo6k5I,451072
+pyvalhalla_git-3.5.1.post132.data/platlib/sqlite3-219685aef036100e03dd97e60c61281d.dll,sha256=2pgdTUHtB3sMMJDytAVh6Ca83hcPjPK7BLrIBQVbosA,1118208
+pyvalhalla_git-3.5.1.post132.data/platlib/tiff-f8c8a1908722e0556fad08f0b5c1bb6f.dll,sha256=znbA_SkIowGQeQ8bR22yrlCDH9xEcvK8BEVbGNOxlKI,468480
+pyvalhalla_git-3.5.1.post132.data/platlib/zlib1-8425906e295d322425fe840dc45228db.dll,sha256=krva8_8mnj2x_8xU3AcXFXyjJFT0ybZhKiIWURHpYu0,90624
+pyvalhalla_git-3.5.1.post132.dist-info/DELVEWHEEL,sha256=1kYh8ExDuV1OfkRrnvXvVDjnw9-vsg4HU6eN-E0I_b4,433
+pyvalhalla_git-3.5.1.post132.dist-info/METADATA,sha256=6Id03ahAgtjOIeYS3Ycr3iwL6CIXacZB12PZxjN3pEo,6795
+pyvalhalla_git-3.5.1.post132.dist-info/RECORD,,
+pyvalhalla_git-3.5.1.post132.dist-info/top_level.txt,sha256=mU472JpF5fOfpVQ8UxZ_dwLmecLogajAMO5RmYsU1gw,19
+pyvalhalla_git-3.5.1.post132.dist-info/WHEEL,sha256=8UP9x9puWI0P1V_d7K2oMTBqfeLNm21CTzZ_Ptr0NXU,101
+pyvalhalla_git-3.5.1.post132.dist-info/licenses/AUTHORS,sha256=zfqnWlS9zAHTcyIVTaquUA0hwOLARt8RbHyxV8ksIdo,176
+pyvalhalla_git-3.5.1.post132.dist-info/licenses/COPYING,sha256=0-hXmYGEWqvizZa7uHZz_AefTiGcyE6O9mZH1e9Pf10,1157
+pyvalhalla_git-3.5.1.post132.dist-info/licenses/LICENSE.md,sha256=TTSAvGrQ2khsitpI11WKnicjvEODZlalhi8PAzaRrV4,45
+valhalla/actor.py,sha256=_A8eZpk7xk-7C6Xzz5nFE5Qp5GNInFjXurzjlh_ZmFA,4195
+valhalla/config.py,sha256=LnxZ7uA42QOIB68ld_8VhRdTdsfs-sXQlu_AylLLFi4,1533
+valhalla/utils.py,sha256=-hHjEDCftpOlRBib4CSZVDCLAZMqgtOtkX2V3-5bsJg,1985
+valhalla/valhalla_build_config.py,sha256=xx8HY5RnP492PMP_DgJSgrum7OjkGWeUQAkZgag6LQM,43267
+valhalla/_scripts.py,sha256=t7qQvmsbTfw7aVyJtI0o6aClfoC1rt4KUT2C8YQer74,1550
+valhalla/_valhalla.cc,sha256=2PTlFjS5hA_mWn7_43zsSqx_lhjEzJZE2Ud6N3WpvnI,3780
+valhalla/__init__.py,sha256=aV9sb4MMgTlHsEIPkaN4S_V0VXr_1n5cQ_25vrdFA3c,598
+valhalla/__main__.py,sha256=HFxHPQfERuNIsitGTrvCEJ2to6IHDbRBGlCRZ6bZ2p0,2223
+valhalla/__version__.py,sha256=69eEI6SOiFX0ni7aBQt84fKxcPdDq4R7skoBz6EuySU,551

pyvalhalla_git-3.5.1.post132.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: false
+Tag: cp312-cp312-win_amd64
+

pyvalhalla_git-3.5.1.post132.dist-info/licenses/AUTHORS

@@ -0,0 +1,5 @@
+Duane Gearhart <duane@mapzen.com>
+Greg Knisely <greg@mapzen.com>
+Kevin Kreiser <kevinkreiser@gmail.com>
+Kristen DiLuca <kristen@mapzen.com>
+Dave Nesbitt <dave@mapzen.com>

pyvalhalla_git-3.5.1.post132.dist-info/licenses/COPYING

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Valhalla contributors  
+Copyright (c) 2015-2017 Mapillary AB, Mapzen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

pyvalhalla_git-3.5.1.post132.dist-info/licenses/LICENSE.md

@@ -0,0 +1 @@
+For license information see [here](COPYING)

pyvalhalla_git-3.5.1.post132.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+_valhalla
+valhalla

valhalla/__init__.py

@@ -0,0 +1,22 @@
+"""""" # start delvewheel patch
+def _delvewheel_patch_1_10_1():
+    import os
+    if os.path.isdir(libs_dir := os.path.abspath(os.path.join(os.path.dirname(__file__), os.pardir, '.'))):
+        os.add_dll_directory(libs_dir)
+
+
+_delvewheel_patch_1_10_1()
+del _delvewheel_patch_1_10_1
+# end delvewheel patch
+
+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)