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

pyvalhalla_git-3.5.1.post185.data/platlib/.load-order-pyvalhalla_git-3.5.1.post185

@@ -0,0 +1,20 @@
+geotiff-e36440f3fa837002abf4656c8a82bee1.dll
+gdal-ef87f613f24439573ac93245419c57fb.dll
+lz4-77ac014ecbb0e1818a064a0c084142a3.dll
+proj_9-0314b900bb5b081106b18666f0921a32.dll
+tiff-2d8ce2b51dc79974e521d680e28b5a30.dll
+geos_c-98a48e4eb33f944d74a394141acb7eaf.dll
+msvcp140-73e7ea186a7d9ab676a764ffa64cf7e6.dll
+liblzma-953b7b97af894314faccc0606d85cede.dll
+libcurl-39889826283c088f2b3897191ab7d21d.dll
+jpeg62-cdecd204dfd888a80dba8d7e15cb5b60.dll
+sqlite3-9f887a0723821b9a01c3c1430763cead.dll
+zlib1-882c7ca16198f8e2a6182b8f5d658a18.dll
+libexpat-0a3bbd6de9307d0020c69673bdb3d5f1.dll
+libpng16-4a1fbc9b57e99b9c7881563565bfd72a.dll
+libprotobuf-lite-ad9267b70ceeab0c301d0a1ec48f2c07.dll
+abseil_dll-1fc67c8668f83d1a5bea7b37c99ca6c3.dll
+geos-6c521f6a54fa614211eebaea0a890f5e.dll
+Lerc-5492e53a634552d158814335bfd5508b.dll
+json-c-520fb69b2bfce9e17f4c6595040d996f.dll
+qhull_r-4c36dd0bc4600521ef29dec0973a8da6.dll

pyvalhalla_git-3.5.1.post185.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-0msw3pke\\cp39-win_amd64\\built_wheel\\pyvalhalla_git-3.5.1.post185-cp39-cp39-win_amd64.whl', '-w', 'C:\\Users\\runneradmin\\AppData\\Local\\Temp\\cibw-run-0msw3pke\\cp39-win_amd64\\repaired_wheel']

pyvalhalla_git-3.5.1.post185.dist-info/METADATA

@@ -0,0 +1,110 @@
+Metadata-Version: 2.4
+Name: pyvalhalla-git
+Version: 3.5.1.post185
+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 :: MIT License
+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 package 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`
+
+### 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
+
+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": [...]})
+```
+
+### 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.12
+```
+
+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
+# specifiers from https://cibuildwheel.pypa.io/en/stable/options/#build-skip
+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. In the end, you'll find the wheel in `./wheelhouse`.

pyvalhalla_git-3.5.1.post185.dist-info/RECORD

@@ -0,0 +1,36 @@
+_valhalla.cp39-win_amd64.pyd,sha256=R_giYOmQdETJ9CZr8aoN4Km08wvMsAO6YrFo_1huz8U,8123392
+pyvalhalla_git-3.5.1.post185.data/platlib/.load-order-pyvalhalla_git-3.5.1.post185,sha256=jvUwJnatZM67VpJwtCTbaZE4lKRN8buoHOp_ocCoyyw,893
+pyvalhalla_git-3.5.1.post185.data/platlib/abseil_dll-1fc67c8668f83d1a5bea7b37c99ca6c3.dll,sha256=JxC8gzXY3ULA4kzXVPmiGAH8pYggofnRKpuKI8RWs5Q,1887744
+pyvalhalla_git-3.5.1.post185.data/platlib/gdal-ef87f613f24439573ac93245419c57fb.dll,sha256=1ShlE9E_IYmbSDJaq7KruNMv0w_hbJ7q-2X93ePtcas,18052096
+pyvalhalla_git-3.5.1.post185.data/platlib/geos-6c521f6a54fa614211eebaea0a890f5e.dll,sha256=MRf-bLrP82WB92IKnuwkM6YMvd8gnIE9gp6S_B9kL-Y,2582016
+pyvalhalla_git-3.5.1.post185.data/platlib/geos_c-98a48e4eb33f944d74a394141acb7eaf.dll,sha256=M4Tea5iyOgcuTHtAb6UxjC8TDYETx6EWrNCFcxjhq90,457728
+pyvalhalla_git-3.5.1.post185.data/platlib/geotiff-e36440f3fa837002abf4656c8a82bee1.dll,sha256=OtzL5DG5Yi0MlvFQB-mgDiCkHtR98V8EGY9kAzWDEOc,161792
+pyvalhalla_git-3.5.1.post185.data/platlib/jpeg62-cdecd204dfd888a80dba8d7e15cb5b60.dll,sha256=3Njm9u2ynTA5_AON3ui6APK5bExn3Nxci_IYMuE4XUE,683520
+pyvalhalla_git-3.5.1.post185.data/platlib/json-c-520fb69b2bfce9e17f4c6595040d996f.dll,sha256=eSo-EsI3ISu3UGQcLEdRA4a84mOs_6PsWuNo7aW2Qfg,58880
+pyvalhalla_git-3.5.1.post185.data/platlib/Lerc-5492e53a634552d158814335bfd5508b.dll,sha256=hi5fqms3kpEnvFhz1eJdYYq4omMI_1Ve7iAUU-2iUv4,526848
+pyvalhalla_git-3.5.1.post185.data/platlib/libcurl-39889826283c088f2b3897191ab7d21d.dll,sha256=tf01uKIBv0LrQFBKzzhTuhnCANJLcKFMREepfIjbpDI,595456
+pyvalhalla_git-3.5.1.post185.data/platlib/libexpat-0a3bbd6de9307d0020c69673bdb3d5f1.dll,sha256=YNDK4-_p_xUPZU_U9i2iUKSxzk5w6sT9_RUtbFnggYQ,159232
+pyvalhalla_git-3.5.1.post185.data/platlib/liblzma-953b7b97af894314faccc0606d85cede.dll,sha256=v3x9ERcMQ_qQiLQoPeDBqEMIM4sdL14w9jjL7_WmqOc,185856
+pyvalhalla_git-3.5.1.post185.data/platlib/libpng16-4a1fbc9b57e99b9c7881563565bfd72a.dll,sha256=jCssnGKi0ui84VBxahsYSZZxNocwdJcUyncZehtkcoU,201216
+pyvalhalla_git-3.5.1.post185.data/platlib/libprotobuf-lite-ad9267b70ceeab0c301d0a1ec48f2c07.dll,sha256=3RbsupqD_7SrGoF7_zBSFthIDVFl7wRhoSuEhLi3Q2A,1502208
+pyvalhalla_git-3.5.1.post185.data/platlib/lz4-77ac014ecbb0e1818a064a0c084142a3.dll,sha256=2tUogjKUHWJga91pezGBczrFXVBsCa63N86rAuLdapA,127488
+pyvalhalla_git-3.5.1.post185.data/platlib/msvcp140-73e7ea186a7d9ab676a764ffa64cf7e6.dll,sha256=cDrXxV8uCWYH7Gp3qLX1LVNdvnH93wIel8vLvCP3SSo,576128
+pyvalhalla_git-3.5.1.post185.data/platlib/proj_9-0314b900bb5b081106b18666f0921a32.dll,sha256=L01PdfyGtx3E3xgrYj8cph5zdVgUgukGX47WK7KJZkw,3414528
+pyvalhalla_git-3.5.1.post185.data/platlib/qhull_r-4c36dd0bc4600521ef29dec0973a8da6.dll,sha256=2yVG47tZEHYsgZfdIUDfTrElFKNn94cQgx9iONqk34o,451072
+pyvalhalla_git-3.5.1.post185.data/platlib/sqlite3-9f887a0723821b9a01c3c1430763cead.dll,sha256=gtLH4aBFxIb9cG1YzUfDpKOkE6B3rxcWKIA16kdhNBY,1118208
+pyvalhalla_git-3.5.1.post185.data/platlib/tiff-2d8ce2b51dc79974e521d680e28b5a30.dll,sha256=0JvOzW9tXCUaTcNxVwbALYxb2ddgj-dFLUEFJ7AUXpc,468480
+pyvalhalla_git-3.5.1.post185.data/platlib/zlib1-882c7ca16198f8e2a6182b8f5d658a18.dll,sha256=u74_0pDv2tbGlcORzlK00nsSnRUSKelODkN9ZgZ_CjM,90624
+pyvalhalla_git-3.5.1.post185.dist-info/DELVEWHEEL,sha256=adas86Zdyo6kAydYUP7oiF6f-Lvcl4lEfC3EaeDxmrk,429
+pyvalhalla_git-3.5.1.post185.dist-info/METADATA,sha256=ynQpTzm9qzUBSalHcSXqLLv0gOOG0p_Yo5Xljm1KKKY,4693
+pyvalhalla_git-3.5.1.post185.dist-info/RECORD,,
+pyvalhalla_git-3.5.1.post185.dist-info/top_level.txt,sha256=mU472JpF5fOfpVQ8UxZ_dwLmecLogajAMO5RmYsU1gw,19
+pyvalhalla_git-3.5.1.post185.dist-info/WHEEL,sha256=XkFE14KmFh7mutkkb-qn_ueuH2lwfT8rLdfc5xpQ7wE,99
+pyvalhalla_git-3.5.1.post185.dist-info/licenses/AUTHORS,sha256=zfqnWlS9zAHTcyIVTaquUA0hwOLARt8RbHyxV8ksIdo,176
+pyvalhalla_git-3.5.1.post185.dist-info/licenses/COPYING,sha256=0-hXmYGEWqvizZa7uHZz_AefTiGcyE6O9mZH1e9Pf10,1157
+pyvalhalla_git-3.5.1.post185.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/__init__.py,sha256=etDcceS9RncpgO4bwZN2mvEaYu5n0n63-TgvDAnxE5k,1790
+valhalla/__version__.py,sha256=NEZ8_VH-6rB5Hq0XCK288QS_i6stUqATL1XXhhGTsps,551

pyvalhalla_git-3.5.1.post185.dist-info/WHEEL

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

pyvalhalla_git-3.5.1.post185.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.post185.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.post185.dist-info/licenses/LICENSE.md

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

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

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

valhalla/__init__.py

@@ -0,0 +1,38 @@
+"""""" # start delvewheel patch
+def _delvewheel_patch_1_10_1():
+    import ctypes
+    import os
+    import platform
+    import sys
+    libs_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), os.pardir, '.'))
+    is_conda_cpython = platform.python_implementation() == 'CPython' and (hasattr(ctypes.pythonapi, 'Anaconda_GetVersion') or 'packaged by conda-forge' in sys.version)
+    if sys.version_info[:2] >= (3, 8) and not is_conda_cpython or sys.version_info[:2] >= (3, 10):
+        if os.path.isdir(libs_dir):
+            os.add_dll_directory(libs_dir)
+    else:
+        load_order_filepath = os.path.join(libs_dir, '.load-order-pyvalhalla_git-3.5.1.post185')
+        if os.path.isfile(load_order_filepath):
+            import ctypes.wintypes
+            with open(os.path.join(libs_dir, '.load-order-pyvalhalla_git-3.5.1.post185')) as file:
+                load_order = file.read().split()
+            kernel32 = ctypes.WinDLL('kernel32', use_last_error=True)
+            kernel32.LoadLibraryExW.restype = ctypes.wintypes.HMODULE
+            kernel32.LoadLibraryExW.argtypes = ctypes.wintypes.LPCWSTR, ctypes.wintypes.HANDLE, ctypes.wintypes.DWORD
+            for lib in load_order:
+                lib_path = os.path.join(os.path.join(libs_dir, lib))
+                if os.path.isfile(lib_path) and not kernel32.LoadLibraryExW(lib_path, None, 8):
+                    raise OSError('Error loading {}; {}'.format(lib, ctypes.FormatError(ctypes.get_last_error())))
+
+
+_delvewheel_patch_1_10_1()
+del _delvewheel_patch_1_10_1
+# end delvewheel patch
+
+try:
+    from ._valhalla import *
+except ModuleNotFoundError:
+    from _valhalla import *
+
+from .actor import Actor
+from .config import get_config, get_help
+from .__version__ import __version__

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.post185'
+__version_tuple__ = version_tuple = (3, 5, 1, 'post185')

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