r5py 1.0.0.dev11__py3-none-any.whl → 1.0.1__py3-none-any.whl

r5py/__init__.py

@@ -2,12 +2,13 @@
 
 """Python wrapper for the R5 routing analysis engine."""
 
-__version__ = "1.0.0.dev11"
+__version__ = "1.0.1"
 
 
 from .r5 import (
     DetailedItineraries,
     DetailedItinerariesComputer,
+    Isochrones,
     RegionalTask,
     TransportMode,
     TransportNetwork,
@@ -18,6 +19,7 @@ from .r5 import (
 __all__ = [
     "DetailedItineraries",
     "DetailedItinerariesComputer",
+    "Isochrones",
     "RegionalTask",
     "TransportMode",
     "TransportNetwork",

r5py/r5/__init__.py

@@ -7,6 +7,7 @@ from .breakdown_stat import BreakdownStat
 from .detailed_itineraries import DetailedItineraries, DetailedItinerariesComputer
 from .direct_leg import DirectLeg
 from .egress_leg import EgressLeg
+from .isochrones import Isochrones
 from .regional_task import RegionalTask
 from .scenario import Scenario
 from .street_layer import StreetLayer
@@ -25,6 +26,7 @@ __all__ = [
     "DetailedItinerariesComputer",
     "DirectLeg",
     "EgressLeg",
+    "Isochrones",
     "RegionalTask",
     "Scenario",
     "SpeedConfig",

r5py/r5/detailed_itineraries.py

@@ -84,7 +84,7 @@ class DetailedItineraries(BaseTravelTimeMatrix):
             ``access_modes``, ``egress_modes``, ``max_time``, ``max_time_walking``,
             ``max_time_cycling``, ``max_time_driving``, ``speed_cycling``, ``speed_walking``,
             ``max_public_transport_rides``, ``max_bicycle_traffic_stress``
-            Not that not all arguments might make sense in this context, and the
+            Note that not all arguments might make sense in this context, and the
             underlying R5 engine might ignore some of them.
         """
         super().__init__(
@@ -122,11 +122,20 @@ class DetailedItineraries(BaseTravelTimeMatrix):
 
         data = self._compute()
         with warnings.catch_warnings():
-            warnings.simplefilter("ignore", category=FutureWarning)
+            warnings.filterwarnings(
+                "ignore",
+                message=(
+                    "You are adding a column named 'geometry' to a GeoDataFrame "
+                    "constructed without an active geometry column"
+                ),
+                category=FutureWarning,
+            )
             for column in data.columns:
                 self[column] = data[column]
             self.set_geometry("geometry")
 
+        del self.transport_network
+
     def _compute(self):
         """
         Compute travel times from all origins to all destinations.

r5py/r5/isochrones.py

@@ -0,0 +1,351 @@
+#!/usr/bin/env python3
+
+
+"""Compute polygons of equal travel time from a destination."""
+
+
+import datetime
+import warnings
+
+import geohexgrid
+import geopandas
+import pandas
+import pyproj
+import shapely
+import simplification.cutil
+
+from .base_travel_time_matrix import BaseTravelTimeMatrix
+from .transport_mode import TransportMode
+from .travel_time_matrix import TravelTimeMatrix
+from ..util import GoodEnoughEquidistantCrs, SpatiallyClusteredGeoDataFrame
+
+
+__all__ = ["Isochrones"]
+
+
+EMPTY_POINT = shapely.Point()
+R5_CRS = "EPSG:4326"
+
+CONCAVE_HULL_BUFFER_SIZE = 20.0  # metres
+CONCAVE_HULL_RATIO = 0.3
+
+VERY_SMALL_BUFFER_SIZE = 0.001  # turn points into polygons
+
+
+class Isochrones(BaseTravelTimeMatrix):
+    """Compute polygons of equal travel time from a destination."""
+
+    _r5py_attributes = BaseTravelTimeMatrix._r5py_attributes + [
+        "_isochrones",
+        "isochrones",
+        "point_grid_resolution",
+        "point_grid_sample_ratio",
+    ]
+
+    def __init__(
+        self,
+        transport_network,
+        origins,
+        isochrones=pandas.timedelta_range(
+            start=datetime.timedelta(minutes=0),
+            end=datetime.timedelta(hours=1),
+            freq=datetime.timedelta(minutes=15),
+        ),
+        point_grid_resolution=100,
+        point_grid_sample_ratio=1.0,
+        **kwargs,
+    ):
+        """
+        Compute polygons of equal travel time from one or more destinations.
+
+        ``r5py.Isochrones`` are child classes of ``geopandas.GeoDataFrame`` and
+        support all of their methods and properties, see
+        https://geopandas.org/en/stable/docs.html
+
+        Arguments
+        ---------
+        transport_network : r5py.TransportNetwork | tuple(str, list(str), dict)
+            The transport network to route on. This can either be a readily
+            initialised r5py.TransportNetwork or a tuple of the parameters
+            passed to ``TransportNetwork.__init__()``: the path to an OpenStreetMap
+            extract in PBF format, a list of zero of more paths to GTFS transport
+            schedule files, and a dict with ``build_config`` options.
+        origins : geopandas.GeoDataFrame | shapely.Point
+            Place(s) to find a route _from_
+            Must be/have a point geometry. If multiple origin points are passed,
+            isochrones will be computed as minimum travel time from any of them.
+        isochrones : pandas.TimedeltaIndex | collections.abc.Iterable[int]
+            For which interval to compute isochrone polygons. An iterable of
+            integers is interpreted as minutes.
+        point_grid_resolution : int
+            Distance in meters between points in the regular grid of points laid over the
+            transport network’s extent that is used to compute isochrones.
+            Increase this value for performance, decrease it for precision.
+        point_grid_sample_ratio : float
+            Share of points of the point grid that are used in computation,
+            ranging from 0.01 to 1.0.
+            Increase this value for performance, decrease it for precision.
+        **kwargs : mixed
+            Any arguments than can be passed to r5py.RegionalTask:
+            ``departure``, ``departure_time_window``, ``percentiles``, ``transport_modes``,
+            ``access_modes``, ``egress_modes``, ``max_time``, ``max_time_walking``,
+            ``max_time_cycling``, ``max_time_driving``, ``speed_cycling``, ``speed_walking``,
+            ``max_public_transport_rides``, ``max_bicycle_traffic_stress``
+            Note that not all arguments might make sense in this context, and the
+            underlying R5 engine might ignore some of them.
+            If percentiles are specified, the lowest one will be used for
+            isochrone computation.
+        """
+        geopandas.GeoDataFrame.__init__(self)
+        BaseTravelTimeMatrix.__init__(
+            self,
+            transport_network,
+            **kwargs,
+        )
+
+        self.EQUIDISTANT_CRS = GoodEnoughEquidistantCrs(self.transport_network.extent)
+
+        if isinstance(origins, shapely.Geometry):
+            origins = geopandas.GeoDataFrame(
+                {
+                    "id": [
+                        "origin",
+                    ],
+                    "geometry": [
+                        origins,
+                    ],
+                },
+                crs=R5_CRS,
+            )
+        self.origins = origins
+        self.isochrones = isochrones
+
+        self.point_grid_resolution = point_grid_resolution
+        self.point_grid_sample_ratio = max(0.01, min(1.0, point_grid_sample_ratio))
+
+        travel_times = TravelTimeMatrix(
+            transport_network,
+            origins=self.origins,
+            destinations=self.destinations,
+            max_time=self.isochrones.max(),
+            **kwargs,
+        )
+
+        data = self._compute_isochrones_from_travel_times(travel_times)
+
+        with warnings.catch_warnings():
+            warnings.filterwarnings(
+                "ignore",
+                message=(
+                    "You are adding a column named 'geometry' to a GeoDataFrame "
+                    "constructed without an active geometry column"
+                ),
+                category=FutureWarning,
+            )
+            for column in data.columns:
+                self[column] = data[column]
+            self.set_geometry("geometry")
+
+        del self.transport_network
+
+    def _compute_isochrones_from_travel_times(self, travel_times):
+        travel_times = travel_times.dropna().groupby("to_id").min().reset_index()
+
+        if self.request.percentiles == [50]:
+            travel_time_column = "travel_time"
+        else:
+            travel_time_column = f"travel_time_p{self.request.percentiles[0]:d}"
+
+        isochrones = {
+            "travel_time": [],
+            "geometry": [],
+        }
+
+        for isochrone in self.isochrones:
+            reached_nodes = (
+                self.destinations.set_index("id")
+                .join(
+                    travel_times[
+                        travel_times[travel_time_column]
+                        <= (isochrone.total_seconds() / 60)
+                    ].set_index("to_id"),
+                    how="inner",
+                )
+                .reset_index()
+            )
+
+            # isochrone polygons might be disjoint (e.g., around metro stops)
+            if not reached_nodes.empty:
+                reached_nodes = SpatiallyClusteredGeoDataFrame(
+                    reached_nodes, eps=(2.0 * self.point_grid_resolution)
+                ).to_crs(self.EQUIDISTANT_CRS)
+                isochrone_polygons = pandas.concat(
+                    [
+                        (
+                            reached_nodes[reached_nodes["cluster"] != -1]
+                            .dissolve(by="cluster")
+                            .concave_hull(ratio=CONCAVE_HULL_RATIO)
+                            .buffer(VERY_SMALL_BUFFER_SIZE)
+                        ),
+                        (
+                            reached_nodes[reached_nodes["cluster"] == -1].buffer(
+                                VERY_SMALL_BUFFER_SIZE
+                            )
+                        ),
+                    ]
+                ).union_all()
+
+                isochrones["travel_time"].append(isochrone)
+                isochrones["geometry"].append(isochrone_polygons)
+
+        isochrones = geopandas.GeoDataFrame(
+            isochrones, geometry="geometry", crs=self.EQUIDISTANT_CRS
+        )
+
+        # clip smaller isochrones by larger isochrones
+        # (concave_hull’s ratio parameter depends on input shapes and does not
+        # produce the same results, e.g., around bridges or at the coast line)
+        for row in range(len(isochrones) - 2, 0, -1):
+            isochrones.loc[row, "geometry"] = shapely.intersection(
+                isochrones.loc[row, "geometry"], isochrones.loc[row + 1, "geometry"]
+            )
+
+        isochrones["geometry"] = (
+            isochrones["geometry"]
+            .buffer(CONCAVE_HULL_BUFFER_SIZE)
+            .boundary.apply(
+                lambda geometry: (
+                    geometry
+                    if isinstance(geometry, shapely.MultiLineString)
+                    else shapely.MultiLineString([geometry])
+                )
+            )
+            .apply(
+                lambda multilinestring: (
+                    shapely.MultiLineString(
+                        [
+                            simplification.cutil.simplify_coords_vwp(
+                                linestring.coords,
+                                self.point_grid_resolution * 5.0,
+                            )
+                            for linestring in multilinestring.geoms
+                        ]
+                    )
+                )
+            )
+            .to_crs(R5_CRS)
+        )
+
+        return isochrones
+
+    @property
+    def destinations(self):
+        """A regular grid of points covering the range of the chosen transport mode."""
+        try:
+            return self._destinations
+        except AttributeError:
+            destinations = self._regular_point_grid
+            destinations["geometry"] = self.transport_network.snap_to_network(
+                destinations["geometry"]
+            )
+            destinations = destinations[destinations["geometry"] != EMPTY_POINT]
+            destinations["geometry"] = destinations["geometry"].normalize()
+            destinations = destinations.drop_duplicates()
+
+            # with snapping, sometimes we end up with clumps of points
+            # below, we try to form clusters, from all clusters we retain
+            # one geometry, only
+            destinations = SpatiallyClusteredGeoDataFrame(
+                destinations, eps=(0.5 * self.point_grid_resolution)
+            )
+            destinations = pandas.concat(
+                [
+                    (
+                        destinations[destinations["cluster"] != -1]
+                        .groupby("cluster")
+                        .first()
+                        .set_crs(R5_CRS)
+                    ),
+                    destinations[destinations["cluster"] == -1],
+                ]
+            )[["id", "geometry"]].copy()
+
+            if self.point_grid_sample_ratio < 1.0:
+                destinations = destinations.sample(frac=self.point_grid_sample_ratio)
+
+            self._destinations = destinations
+
+            return destinations
+
+    @destinations.setter
+    def destinations(self, destinations):
+        # https://bugs.python.org/issue14965
+        super(self.__class__, self.__class__).destinations.__set__(self, destinations)
+
+    @property
+    def isochrones(self):
+        """
+        Compute isochrones for these travel times.
+
+        pandas.TimedeltaIndex | collections.abc.Iterable[int]
+        An iterable of integers is interpreted as minutes.
+        """
+        try:
+            return self._isochrones
+        except AttributeError:
+            raise
+
+    @isochrones.setter
+    def isochrones(self, isochrones):
+        if not isinstance(isochrones, pandas.TimedeltaIndex):
+            isochrones = pandas.to_timedelta(isochrones, unit="minutes")
+        try:
+            # do not compute for 0 travel time
+            isochrones = isochrones.drop(datetime.timedelta(0))
+        except KeyError:
+            pass
+        self._isochrones = isochrones
+
+    @property
+    def _regular_point_grid(self):
+        extent = shapely.ops.transform(
+            pyproj.Transformer.from_crs(
+                R5_CRS,
+                self.EQUIDISTANT_CRS,
+                always_xy=True,
+            ).transform,
+            self.transport_network.extent,
+        )
+
+        grid = geohexgrid.make_grid_from_bounds(
+            *extent.bounds,
+            self.point_grid_resolution,
+            crs=self.EQUIDISTANT_CRS,
+        )
+        grid["geometry"] = grid["geometry"].centroid
+        grid["id"] = grid.index
+        grid = grid[["id", "geometry"]].to_crs(R5_CRS)
+
+        # for walking and cycling, we can clip the extent to an area reachable
+        # by the (well-defined) travel speeds:
+        if set(self.request.transport_modes) <= set(
+            (TransportMode.WALK, TransportMode.BICYCLE)
+        ):
+            if TransportMode.WALK in self.request.transport_modes:
+                speed = self.request.speed_walking
+            if TransportMode.BICYCLE in self.request.transport_modes:
+                speed = self.request.speed_cycling
+
+            speed = speed * (1000.0 / 3600.0) * 1.1  # km/h -> m/s, plus a bit of buffer
+
+            grid = grid.clip(
+                (
+                    pandas.concat([self.origins] * 2)  # workaround until
+                    # https://github.com/pyproj4/pyproj/issues/1309 is fixed
+                    .to_crs(self.EQUIDISTANT_CRS)
+                    .buffer(speed * max(self.isochrones).total_seconds())
+                    .to_crs(R5_CRS)
+                )
+            )
+
+        return grid.copy()

r5py/r5/street_layer.py

@@ -22,6 +22,9 @@ __all__ = ["StreetLayer"]
 start_jvm()
 
 
+EMPTY_POINT = shapely.Point()
+
+
 class StreetLayer:
     """Wrap a com.conveyal.r5.streets.StreetLayer."""
 
@@ -72,13 +75,14 @@ class StreetLayer:
             Closest location on the street network or `POINT EMPTY` if no
             such location could be found within `radius`
         """
-        if split := self._street_layer.findSplit(point.y, point.x, radius, street_mode):
+        try:
+            split = self._street_layer.findSplit(point.y, point.x, radius, street_mode)
             return shapely.Point(
                 split.fixedLon / com.conveyal.r5.streets.VertexStore.FIXED_FACTOR,
                 split.fixedLat / com.conveyal.r5.streets.VertexStore.FIXED_FACTOR,
             )
-        else:
-            return shapely.Point()
+        except (AttributeError, TypeError):
+            return EMPTY_POINT
 
 
 @jpype._jcustomizer.JConversion(

r5py/r5/street_segment.py

@@ -0,0 +1,41 @@
+#!/usr/bin/env python3
+
+"""A less complex representation of com.conveyal.r5.api.util.StreetSegment."""
+
+
+import datetime
+
+import shapely
+
+
+__all__ = ["StreetSegment"]
+
+
+class StreetSegment:
+    """A less complex representation of com.conveyal.r5.api.util.StreetSegment."""
+
+    distance = 0
+    duration = datetime.timedelta()
+    geometry = shapely.LineString()
+
+    def __init__(self, street_path):
+        """
+        Initialise a less complex representation of com.conveyal.r5.api.util.StreetSegment.
+
+        Arguments
+        ---------
+        street_path : com.conveyal.r5.profile.StreetPath
+            StreetPath, obtained, e.g., from StreetRouter state
+        """
+        self.distance = street_path.getDistance()
+        self.duration = street_path.getDuration()
+        self.geometry = shapely.line_merge(
+            shapely.MultiLineString(
+                [
+                    shapely.from_wkt(
+                        str(street_path.getEdge(edge).getGeometry().toText())
+                    )
+                    for edge in street_path.getEdges()
+                ]
+            )
+        )

r5py/r5/transport_network.py

@@ -5,24 +5,22 @@
 
 
 import functools
+import hashlib
 import pathlib
-import random
-import shutil
-import time
 import warnings
 
-import filelock
 import jpype
 import jpype.types
 
 from .street_layer import StreetLayer
 from .transit_layer import TransitLayer
 from .transport_mode import TransportMode
-from ..util import Config, contains_gtfs_data, start_jvm
+from ..util import Config, contains_gtfs_data, FileDigest, start_jvm, WorkingCopy
 
 import com.conveyal.gtfs
 import com.conveyal.osmlib
 import com.conveyal.r5
+import java.io
 
 
 __all__ = ["TransportNetwork"]
@@ -48,114 +46,63 @@ class TransportNetwork:
         gtfs : str | pathlib.Path | list[str] | list[pathlib.Path]
             path(s) to public transport schedule information in GTFS format
         """
-        osm_pbf = self._working_copy(pathlib.Path(osm_pbf)).absolute()
+        osm_pbf = WorkingCopy(osm_pbf)
         if isinstance(gtfs, (str, pathlib.Path)):
             gtfs = [gtfs]
-        gtfs = [str(self._working_copy(path).absolute()) for path in gtfs]
+        gtfs = [WorkingCopy(path) for path in gtfs]
 
-        transport_network = com.conveyal.r5.transit.TransportNetwork()
-        transport_network.scenarioId = PACKAGE
-
-        osm_mapdb = pathlib.Path(f"{osm_pbf}.mapdb")
-        osm_file = com.conveyal.osmlib.OSM(f"{osm_mapdb}")
-        osm_file.intersectionDetection = True
-        osm_file.readFromFile(f"{osm_pbf}")
-
-        self.osm_file = osm_file  # keep the mapdb open, close in destructor
-
-        transport_network.streetLayer = com.conveyal.r5.streets.StreetLayer()
-        transport_network.streetLayer.loadFromOsm(osm_file)
-        transport_network.streetLayer.parentNetwork = transport_network
-        transport_network.streetLayer.indexStreets()
-
-        transport_network.transitLayer = com.conveyal.r5.transit.TransitLayer()
-        for gtfs_file in gtfs:
-            gtfs_feed = com.conveyal.gtfs.GTFSFeed.readOnlyTempFileFromGtfs(gtfs_file)
-            transport_network.transitLayer.loadFromGtfs(gtfs_feed)
-            gtfs_feed.close()
-        transport_network.transitLayer.parentNetwork = transport_network
-
-        transport_network.streetLayer.associateStops(transport_network.transitLayer)
-        transport_network.streetLayer.buildEdgeLists()
-
-        transport_network.transitLayer.rebuildTransientIndexes()
+        # a hash representing all input files
+        digest = hashlib.sha256(
+            "".join([FileDigest(osm_pbf)] + [FileDigest(path) for path in gtfs]).encode(
+                "utf-8"
+            )
+        ).hexdigest()
 
-        transfer_finder = com.conveyal.r5.transit.TransferFinder(transport_network)
-        transfer_finder.findTransfers()
-        transfer_finder.findParkRideTransfer()
+        try:
+            transport_network = self._load_pickled_transport_network(
+                Config().CACHE_DIR / f"{digest}.transport_network"
+            )
+        except FileNotFoundError:
+            transport_network = com.conveyal.r5.transit.TransportNetwork()
+            transport_network.scenarioId = PACKAGE
+
+            osm_mapdb = Config().CACHE_DIR / f"{digest}.mapdb"
+            osm_file = com.conveyal.osmlib.OSM(f"{osm_mapdb}")
+            osm_file.intersectionDetection = True
+            osm_file.readFromFile(f"{osm_pbf}")
+
+            transport_network.streetLayer = com.conveyal.r5.streets.StreetLayer()
+            transport_network.streetLayer.parentNetwork = transport_network
+            transport_network.streetLayer.loadFromOsm(osm_file)
+            transport_network.streetLayer.indexStreets()
+
+            transport_network.transitLayer = com.conveyal.r5.transit.TransitLayer()
+            transport_network.transitLayer.parentNetwork = transport_network
+            for gtfs_file in gtfs:
+                gtfs_feed = com.conveyal.gtfs.GTFSFeed.readOnlyTempFileFromGtfs(
+                    f"{gtfs_file}"
+                )
+                transport_network.transitLayer.loadFromGtfs(gtfs_feed)
+                gtfs_feed.close()
 
-        transport_network.transitLayer.buildDistanceTables(None)
+            transport_network.streetLayer.associateStops(transport_network.transitLayer)
+            transport_network.streetLayer.buildEdgeLists()
 
-        self._transport_network = transport_network
+            transport_network.transitLayer.rebuildTransientIndexes()
 
-    def __del__(self):
-        """Delete all temporary files upon destruction."""
-        MAX_TRIES = 10
+            transfer_finder = com.conveyal.r5.transit.TransferFinder(transport_network)
+            transfer_finder.findTransfers()
+            transfer_finder.findParkRideTransfer()
 
-        # first, close the open osm_file,
-        # delete Java objects, and
-        # trigger Java garbage collection
-        try:
-            self.osm_file.close()
-        except jpype.JVMNotRunning:
-            # JVM was stopped already, file should be closed
-            pass
-        try:
-            del self.street_layer
-        except AttributeError:  # might not have been accessed a single time
-            pass
-        try:
-            del self.transit_layer
-        except AttributeError:
-            pass
-        try:
-            del self._transport_network
-        except AttributeError:
-            pass
+            transport_network.transitLayer.buildDistanceTables(None)
 
-        time.sleep(1.0)
-        try:
-            jpype.java.lang.System.gc()
-        except jpype.JVMNotRunning:
-            pass
+            osm_file.close()  # not needed after here?
 
-        # then, try to delete all files in cache directory
-        try:
-            temporary_files = [child for child in self._cache_directory.iterdir()]
-        except FileNotFoundError:  # deleted in the meantime/race condition
-            temporary_files = []
-
-        for _ in range(MAX_TRIES):
-            for temporary_file in temporary_files:
-                try:
-                    temporary_file.unlink()
-                    temporary_files.remove(temporary_file)
-                except (FileNotFoundError, IOError, OSError):
-                    print(
-                        f"could not delete {temporary_file}, keeping in {temporary_files}"
-                    )
-                    pass
-
-            if not temporary_files:  # empty
-                break
-
-            # there are still files open, let’s wait a moment and try again
-            time.sleep(0.1)
-        else:
-            remaining_files = ", ".join(
-                [f"{temporary_file}" for temporary_file in temporary_files]
-            )
-            warnings.warn(
-                f"Failed to clean cache directory ‘{self._cache_directory}’. "
-                f"Remaining file(s): {remaining_files}",
-                RuntimeWarning,
+            self._save_pickled_transport_network(
+                transport_network, Config().CACHE_DIR / f"{digest}.transport_network"
             )
 
-        # finally, try to delete the cache directory itself
-        try:
-            self._cache_directory.rmdir()
-        except OSError:  # not empty
-            pass  # the JVM destructor is going to take care of this
+        self._transport_network = transport_network
 
     @classmethod
     def from_directory(cls, path):
@@ -219,56 +166,22 @@ class TransportNetwork:
         # then find the smaller extent of the two (or the larger one?)
         return self.street_layer.extent
 
-    @functools.cached_property
-    def _cache_directory(self):
-        cache_dir = (
-            pathlib.Path(Config().TEMP_DIR)
-            / f"{self.__class__.__name__:s}_{id(self):x}_{random.randrange(16**5):07x}"
-        )
-        cache_dir.mkdir(exist_ok=True)
-        return cache_dir
-
-    def _working_copy(self, input_file):
-        """Create a copy or link of an input file in a cache directory.
-
-        This method exists because R5 creates temporary files in the
-        directory of input files. This can not only be annoying clutter,
-        but also create problems of concurrency, performance, etc., for
-        instance, when the data comes from a shared network drive or a
-        read-only file system.
-
-        Arguments
-        ---------
-        input_file : str or pathlib.Path
-            The file to create a copy or link of in a cache directory
-
-        Returns
-        -------
-        pathlib.Path
-            The path to the copy or link created
-        """
-        # try to first create a symbolic link, if that fails (e.g., on Windows),
-        # copy the file to a cache directory
-        input_file = pathlib.Path(input_file).absolute()
-        destination_file = pathlib.Path(
-            self._cache_directory / input_file.name
-        ).absolute()
-
-        with filelock.FileLock(
-            destination_file.parent / f"{destination_file.name}.lock"
-        ):
-            if not destination_file.exists():
-                try:
-                    destination_file.symlink_to(input_file)
-                except OSError:
-                    shutil.copyfile(str(input_file), str(destination_file))
-        return destination_file
-
     @property
     def linkage_cache(self):
         """Expose the `TransportNetwork`’s `linkageCache` to Python."""
         return self._transport_network.linkageCache
 
+    def _load_pickled_transport_network(self, path):
+        try:
+            input_file = java.io.File(f"{path}")
+            return com.conveyal.r5.kryo.KryoNetworkSerializer.read(input_file)
+        except java.io.FileNotFoundException:
+            raise FileNotFoundError
+
+    def _save_pickled_transport_network(self, transport_network, path):
+        output_file = java.io.File(f"{path}")
+        com.conveyal.r5.kryo.KryoNetworkSerializer.write(transport_network, output_file)
+
     def snap_to_network(
         self,
         points,

r5py/r5/travel_time_matrix.py

@@ -78,6 +78,7 @@ class TravelTimeMatrix(BaseTravelTimeMatrix):
         data = self._compute()
         for column in data.columns:
             self[column] = data[column]
+        del self.transport_network
 
     def _compute(self):
         """

r5py/r5/trip_planner.py

@@ -17,6 +17,7 @@ import shapely
 from .access_leg import AccessLeg
 from .direct_leg import DirectLeg
 from .egress_leg import EgressLeg
+from .street_segment import StreetSegment
 from .transfer_leg import TransferLeg
 from .transit_leg import TransitLeg
 from .transport_mode import TransportMode
@@ -64,7 +65,9 @@ class TripPlanner:
 
         EQUIDISTANT_CRS = GoodEnoughEquidistantCrs(self.transport_network.extent)
         self._crs_transformer_function = pyproj.Transformer.from_crs(
-            R5_CRS, EQUIDISTANT_CRS
+            R5_CRS,
+            EQUIDISTANT_CRS,
+            always_xy=True,
         ).transform
 
     @property
@@ -165,17 +168,13 @@ class TripPlanner:
         return direct_paths
 
     def _street_segment_from_router_state(self, router_state, transport_mode):
-        """Retrieve a com.conveyal.r5.street.StreetSegment for a route."""
+        """Retrieve a StreetSegment for a route."""
         street_path = com.conveyal.r5.profile.StreetPath(
             router_state,
             self.transport_network,
             False,
         )
-        street_segment = com.conveyal.r5.api.util.StreetSegment(
-            street_path,
-            transport_mode,
-            self.transport_network.street_layer,
-        )
+        street_segment = StreetSegment(street_path)
         return street_segment
 
     @functools.cached_property

r5py/util/__init__.py

@@ -8,18 +8,24 @@ from .camel_to_snake_case import camel_to_snake_case
 from .config import Config
 from .contains_gtfs_data import contains_gtfs_data
 from .data_validation import check_od_data_set
+from .file_digest import FileDigest
 from .good_enough_equidistant_crs import GoodEnoughEquidistantCrs
 from .jvm import start_jvm
 from .parse_int_date import parse_int_date
 from .snake_to_camel_case import snake_to_camel_case
+from .spatially_clustered_geodataframe import SpatiallyClusteredGeoDataFrame
+from .working_copy import WorkingCopy
 
 __all__ = [
     "camel_to_snake_case",
     "check_od_data_set",
     "Config",
     "contains_gtfs_data",
+    "FileDigest",
     "GoodEnoughEquidistantCrs",
     "parse_int_date",
     "snake_to_camel_case",
+    "SpatiallyClusteredGeoDataFrame",
     "start_jvm",
+    "WorkingCopy",
 ]

r5py/util/config.py

@@ -2,6 +2,7 @@
 
 """Handle configuration options and command line options."""
 
+import datetime
 import functools
 import importlib.resources
 import os
@@ -19,6 +20,7 @@ PACKAGE = __package__.split(".")[0]
 CONFIG_FILE_TEMPLATE = importlib.resources.files(f"{PACKAGE}.util").joinpath(
     f"{PACKAGE}.yml.template"
 )
+CACHE_MAX_AGE = datetime.timedelta(weeks=2)
 
 if "HOME" not in os.environ:  # e.g., testing environment or container
     os.environ["HOME"] = "."
@@ -73,11 +75,25 @@ class Config:
             pathlib.Path(
                 os.environ.get("LOCALAPPDATA")
                 or os.environ.get("XDG_CACHE_HOME")
-                or (pathlib.Path(os.environ["HOME"]) / ".cache")
+                or (pathlib.Path(os.environ.get("HOME")) / ".cache")
             )
             / PACKAGE
         )
         cache_dir.mkdir(parents=True, exist_ok=True)
+
+        # clean old files to keep cache dir from growing too much
+        cache_treshold = (datetime.datetime.now() - CACHE_MAX_AGE).timestamp()
+        for cached_file in cache_dir.glob("**/*"):
+            try:
+                *_, atime, mtime, _ = cached_file.stat()
+                assert max(atime, mtime) > cache_treshold
+            except (
+                AssertionError,  # expired
+                FileNotFoundError,  # broken symlink
+                PermissionError,
+            ):
+                cached_file.unlink()
+
         return cache_dir
 
     @functools.cached_property
@@ -88,7 +104,7 @@ class Config:
             pathlib.Path(
                 os.environ.get("APPDATA")
                 or os.environ.get("XDG_CONFIG_HOME")
-                or (pathlib.Path(os.environ["HOME"]) / ".config")
+                or (pathlib.Path(os.environ.get("HOME")) / ".config")
             )
             / f"{PACKAGE}.yml",
         ]

r5py/util/file_digest.py

@@ -0,0 +1,42 @@
+#!/usr/bin/env python3
+
+"""Create a hash sum of a file."""
+
+
+import hashlib
+import pathlib
+
+
+__all__ = ["FileDigest"]
+
+
+BUFFER_SIZE = 64 * 1024
+
+
+class FileDigest(str):
+    """Create a hash sum of a file."""
+
+    def __new__(cls, input_file, digest="blake2s"):
+        """
+        Create a hash sum of a file.
+
+        Arguments
+        ---------
+        input_file : pathlib.Path | str
+            for which file to compute a hash digest
+        digest : str | func
+            name of hash algorithm (s.
+            https://docs.python.org/3/library/hashlib.html) or function that
+            returns a hash sum
+        """
+        input_file = pathlib.Path(input_file)
+        try:
+            with input_file.open("rb") as f:
+                hashdigest = hashlib.file_digest(f, digest)
+        except AttributeError:  # Python<=3.10
+            hashdigest = hashlib.new(digest)
+            with input_file.open("rb") as f:
+                while data := f.read(BUFFER_SIZE):
+                    hashdigest.update(data)
+
+        return hashdigest.hexdigest()

r5py/util/good_enough_equidistant_crs.py

@@ -10,6 +10,11 @@ import shapely
 from .exceptions import UnexpectedCrsError
 
 
+FALLBACK_CRS = 3857
+DATUM_NAME = "WGS 84"
+VERY_SMALL_BUFFER_SIZE = 0.001
+
+
 class GoodEnoughEquidistantCrs(pyproj.CRS):
     """
     Find the most appropriate UTM reference system for the current extent.
@@ -33,13 +38,13 @@ class GoodEnoughEquidistantCrs(pyproj.CRS):
         """
         if GoodEnoughEquidistantCrs._is_plausible_in_epsg4326(extent):
             # default CRS in case we do not find any better match
-            crs = pyproj.CRS.from_epsg(3857)
+            crs = pyproj.CRS.from_epsg(FALLBACK_CRS)
 
             # buffer extent (so everything is a polygon)
-            extent = extent.buffer(0.1)
+            extent = extent.buffer(VERY_SMALL_BUFFER_SIZE)
 
             crsinfo = pyproj.database.query_utm_crs_info(
-                datum_name="WGS 84",
+                datum_name=DATUM_NAME,
                 area_of_interest=pyproj.aoi.AreaOfInterest(*extent.bounds),
             )
             for candidate_crs in crsinfo:

r5py/util/spatially_clustered_geodataframe.py

@@ -0,0 +1,78 @@
+#!/usr/bin/env python3
+
+
+"""Assign a cluster label column to a point-geometry GeoDataFrame."""
+
+
+import warnings
+
+import geopandas
+import numpy
+import shapely
+import sklearn.cluster
+
+from .good_enough_equidistant_crs import GoodEnoughEquidistantCrs
+
+
+__all__ = ["SpatiallyClusteredGeoDataFrame"]
+
+
+class SpatiallyClusteredGeoDataFrame(geopandas.GeoDataFrame):
+    """Assign a cluster label column to a point-geometry GeoDataFrame."""
+
+    def __init__(self, data, *args, eps=200.0, min_cluster_size=3, **kwargs):
+        """
+        Assign a cluster label column to a point-geometry GeoDataFrame.
+
+        Arguments:
+        ----------
+        data : geopandas.GeoDataFrame
+            input data set
+        eps : int | float
+            EPS parameter to a DBSCAN cluster algorithm, the maximum
+            intra-cluster distance between two points
+        *args, **kwargs: passed to geopandas.GeoDataFrame.__init__()
+        """
+        geopandas.GeoDataFrame.__init__(self, *args, **kwargs)
+
+        EQUIDISTANT_CRS = GoodEnoughEquidistantCrs(
+            shapely.box(*data.to_crs("EPSG:4326").geometry.total_bounds)
+        )
+
+        # loosely based on:
+        # https://github.com/geopandas/scipy2018-geospatial-data/blob/master/08-clustering.ipynb
+
+        coordinates = numpy.vstack(
+            data.to_crs(EQUIDISTANT_CRS)["geometry"]
+            .apply(lambda geometry: numpy.hstack(geometry.xy))
+            .values
+        )
+
+        with warnings.catch_warnings():
+            warnings.filterwarnings(
+                "ignore",
+                "Could not find the number of physical cores",
+                category=UserWarning,
+            )
+            data["cluster"] = (
+                sklearn.cluster.DBSCAN(
+                    eps=eps,
+                    min_samples=min_cluster_size,
+                    n_jobs=-1,
+                )
+                .fit(coordinates)
+                .labels_
+            )
+
+        with warnings.catch_warnings():
+            warnings.filterwarnings(
+                "ignore",
+                message=(
+                    "You are adding a column named 'geometry' to a GeoDataFrame "
+                    "constructed without an active geometry column"
+                ),
+                category=FutureWarning,
+            )
+            for column in data.columns:
+                self[column] = data[column]
+            self.set_geometry("geometry")

r5py/util/working_copy.py

@@ -0,0 +1,44 @@
+#!/usr/bin/env python3
+
+"""Create a copy or link of an input file in a cache directory."""
+
+
+import filelock
+import pathlib
+import shutil
+
+from .config import Config
+
+
+__all__ = ["WorkingCopy"]
+
+
+class WorkingCopy(pathlib.Path):
+    """Create a copy or link of an input file in a cache directory."""
+
+    def __new__(cls, path):
+        """
+        Create a copy or link of an input file in a cache directory.
+
+        This exists because R5 creates temporary files in the directory of input
+        files. This can not only be annoying clutter, but also create problems
+        of concurrency, performance, etc., for instance, when the data comes
+        from a shared network drive or a read-only file system.
+
+        Arguments
+        ---------
+        path : str or pathlib.Path
+            The file to create a copy or link of in a cache directory
+        """
+        # try to first create a symbolic link, if that fails (e.g., on Windows),
+        # copy the file to a cache directory
+        path = pathlib.Path(path).absolute()
+        destination = pathlib.Path(Config().CACHE_DIR / path.name).absolute()
+
+        with filelock.FileLock(destination.parent / f"{destination.name}.lock"):
+            if not destination.exists():
+                try:
+                    destination.symlink_to(path)
+                except OSError:
+                    shutil.copyfile(f"{path}", f"{destination}")
+        return destination

{r5py-1.0.0.dev11.dist-info → r5py-1.0.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: r5py
-Version: 1.0.0.dev11
+Version: 1.0.1
 Summary: Python wrapper for the R5 routing analysis engine
 Author: Christoph Fink, Willem Klumpenhouwer, Marcus Sairava, Rafael Pereira, Henrikki Tenkanen
 License: GPL-3.0-or-later or MIT
@@ -13,12 +13,12 @@ Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
-Requires-Python: >=3.9
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: ConfigArgParse
 Requires-Dist: filelock
-Requires-Dist: fiona
+Requires-Dist: geohexgrid
 Requires-Dist: geopandas
 Requires-Dist: joblib
 Requires-Dist: jpype1
@@ -27,7 +27,10 @@ Requires-Dist: pandas>=2.1.0
 Requires-Dist: psutil
 Requires-Dist: pyproj
 Requires-Dist: requests
+Requires-Dist: scikit-learn
 Requires-Dist: shapely>=2.0
+Requires-Dist: simplification
+Requires-Dist: typing_extensions; python_version < "3.13"
 Provides-Extra: docs
 Requires-Dist: contextily; extra == "docs"
 Requires-Dist: folium; extra == "docs"
@@ -68,7 +71,7 @@ Requires-Dist: typing-extensions; extra == "tests"
 [![downloads (pypi)][downloads-pypi-badge]][downloads-pypi-link]
 [![downloads (conda-forge)][downloads-conda-forge-badge]][downloads-conda-forge-link]
 <br />
-[![Trunk build status][build-status-badge]][build-status-link]
+[![Unit tests][test-status-badge]][test-status-link]
 [![Documentation Status][rtd-status-badge]][rtd-status-link]
 [![Coverage][coverage-badge]][coverage-link]
 <br />
@@ -135,9 +138,7 @@ your project better.
 
 <!-- (1) badges -->
 [binder-badge]: https://img.shields.io/badge/Try%20r5py%20with-binder-F5A252.svg?logo=data:image/png;base64,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
-[binder-link]: https://notebooks.gesis.org/binder/v2/gh/r5py/r5py/stable?urlpath=tree/docs/user-guide/user-manual/quickstart.md
-[build-status-badge]: https://github.com/r5py/r5py/actions/workflows/build-merged-pull-requests.yml/badge.svg
-[build-status-link]: https://github.com/r5py/r5py/actions/workflows/build-merged-pull-requests.yml
+[binder-link]: https://mybinder.org/v2/gh/r5py/r5py/stable?urlpath=tree/docs/user-guide/user-manual/quickstart.md
 [coverage-badge]: https://codecov.io/gh/r5py/r5py/branch/main/graph/badge.svg?token=WG8RBMZBK6
 [coverage-link]: https://codecov.io/gh/r5py/r5py
 [doi-badge]: https://zenodo.org/badge/DOI/10.5281/zenodo.7060437.svg
@@ -150,11 +151,13 @@ your project better.
 [rtd-status-link]: https://r5py.readthedocs.io/
 [stable-version-badge]: https://img.shields.io/pypi/v/r5py?label=Stable
 [stable-version-link]: https://github.com/r5py/r5py/releases
+[test-status-badge]: https://github.com/r5py/r5py/actions/workflows/test.yml/badge.svg
+[test-status-link]: https://github.com/r5py/r5py/actions/workflows/test.yml
 
 <!-- (2) other links -->
 [conda-create-env-from-yml]: https://docs.conda.io/projects/conda/en/latest/user-guide/tasks/manage-environments.html#creating-an-environment-from-an-environment-yml-file
 [conveyal]: https://www.conveyal.com/
-[env-file]: https://github.com/r5py/r5py/blob/main/ci/r5py_distro.yaml
+[env-file]: https://github.com/r5py/r5py/blob/main/ci/r5py.yaml
 [geopandas]: https://geopandas.org/
 [r5-github]: https://github.com/conveyal/r5/
 [r5r-github]: https://github.com/ipeaGIT/r5r/

{r5py-1.0.0.dev11.dist-info → r5py-1.0.1.dist-info}/RECORD

@@ -1,42 +1,47 @@
-r5py/__init__.py,sha256=Ox4bOJgqUvWbaRmVEBBaNPpg6rP3OwlVdAbWMfIOueA,518
+r5py/__init__.py,sha256=G4_W_JrAJL28AYFzW0kImNgE-wAfjb15kpCwQulRuNc,546
 r5py/__main__.py,sha256=Wvn0ChD7E-dCSZ8b8k_HhHG0KMOk0qMNFkijGuSH3-0,81
-r5py/r5/__init__.py,sha256=N_55XlwBDUtljFEHIDYSFb4pPPHXsHdPfF-8qu9IjhQ,1071
+r5py/r5/__init__.py,sha256=6IQpvStxKeNxflizfRWh05USpdM18KBSB3UZ8Z_cGY4,1124
 r5py/r5/access_leg.py,sha256=W3GfPEpqmWD1c4xipd6UcVIaBC-yb6srGCZV30E2dPY,293
 r5py/r5/base_travel_time_matrix.py,sha256=Vl82Wkk2iANNy6L3r937yXNnQ9lmMOErGT_-fQnb1Ms,6978
 r5py/r5/breakdown_stat.py,sha256=ZQkWA0hXlcRH3KVgtxPSNHP0FUDri8MWqdFk8EUdDMU,533
-r5py/r5/detailed_itineraries.py,sha256=kLIlMMMGC3pbjzkhIQDx9AdQ7wFBcMzCteB8E7JLdQQ,10964
+r5py/r5/detailed_itineraries.py,sha256=Oo8JnF5jM2FsYFR1ma9r4y3evOmU7itDYs5M4vbqrZo,11245
 r5py/r5/direct_leg.py,sha256=T7wX8puhOVIssCpflXthYs-G9OA8pasFbdz9p8k8teg,1054
 r5py/r5/egress_leg.py,sha256=9rsCIcwlZUzoZE6q4imNY3VWpjJepO1IJvheVrlPi90,297
+r5py/r5/isochrones.py,sha256=NNpV3Df4NeLdDksGERkb2Eos33ziMBGEeaWyCKPt5P8,12974
 r5py/r5/regional_task.py,sha256=wTNx2NT3-GCEvDyz0e-_YYkVWtpE66dg2IlXTA1gI-4,23234
 r5py/r5/scenario.py,sha256=nUNAlN3cO7E_b4sMpNqdL0FD7WQaQ49iIvh-k8l4YRM,763
-r5py/r5/street_layer.py,sha256=iGlAWftzmwzaRUpXngis7prVuH3Oq8i-AXS8-pnVXMk,2259
+r5py/r5/street_layer.py,sha256=2AWhIE0-aTNGQenX6bF1xv5bmhR_LV0CgqM4BKgVYfk,2329
+r5py/r5/street_segment.py,sha256=0O0QV8Eyfss-xHJShKGSQV1IusZfTrrxzu_AWl3KACo,1109
 r5py/r5/transfer_leg.py,sha256=_IpzQJAyW4hDPO5V4k-ZjIPd3uyxhHPa4U6_b8UbKt4,311
 r5py/r5/transit_layer.py,sha256=vVo_o10yDCzpujOQ99xdzmznwVjAbANjdDflQy2QOpI,3223
 r5py/r5/transit_leg.py,sha256=R0Qc9YLMEXYu51NIdo7Q0bdmpYIJf5irEDXWrW6pZWE,221
 r5py/r5/transport_mode.py,sha256=zHSqXb0R4oyjTp069CzO69IgoCKt0nmOAwsSy272rGo,3675
-r5py/r5/transport_network.py,sha256=d4PPBEBk3t2QbUI5KMS9zM-a4s4E4zEYOHIV6txCnYg,10777
-r5py/r5/travel_time_matrix.py,sha256=jrOt4n9kfShYGF5dou7xgKCEw8FBfyqc0wZeQZqD4wQ,7968
+r5py/r5/transport_network.py,sha256=wy7jsIqcladee6FdUiOu0kJgMhGYymtJpfyjX9RRnNU,7925
+r5py/r5/travel_time_matrix.py,sha256=Z_ErylB8mMD_eO2BogV3K_OFdYFVCcmIPmcMe7GGRiU,8003
 r5py/r5/trip.py,sha256=AqhlhgYaGRL5jVzV08BhsqgWxe8f4wAb5HMP8HIGwc8,2944
 r5py/r5/trip_leg.py,sha256=9E4vZpBEJCXIVqAXWJvnPloC-upEASKhFnjiuen8i8A,6495
-r5py/r5/trip_planner.py,sha256=qUzzTA3PHcHkN7kNzAywhLFQswGDyPSgtkkvPZ9eJVQ,23819
-r5py/util/__init__.py,sha256=S-agt-08twU7hFIH1_x_VjuNC-WHfP6844n0xM0E8t8,714
+r5py/r5/trip_planner.py,sha256=QM3kSx-EC1VWtmReMtwxzG0CdbtlRi3-PpLxOAoHGrA,23754
+r5py/util/__init__.py,sha256=3iqzebRt7RE1TMzzuGNzyXca0SBcBx1rHLs8eW3ijo4,940
 r5py/util/camel_to_snake_case.py,sha256=zj5F3PNBvsuS6vqN4USeeo8NI-3hnscGhwun0G95AK0,673
 r5py/util/classpath.py,sha256=b16xL94pDxTpc0vrf68R1nvZHnHqZXGcFJaN36eW3wc,2773
-r5py/util/config.py,sha256=sAT3jJI69KH80fQsy9xi9-PkEUoOabLvLys9djRBils,4667
+r5py/util/config.py,sha256=5jz42iUaftgBfJ2HNnktZw5oXIPE2ytl3Nxt2RjjDoM,5267
 r5py/util/contains_gtfs_data.py,sha256=ooX4hfVDKK0aqX1MI46jSFZ7dZ6riyXaORrgF6PUFrk,1211
 r5py/util/data_validation.py,sha256=H5Mcp2nS4vu5RKym20mPnGpl-8d0SDchzDRJBrrL6WE,1039
 r5py/util/environment.py,sha256=cbSM8TKTuhbXsTIIB06pMtydBOiqLkitF2Lj2asVTho,1082
 r5py/util/exceptions.py,sha256=r65XUg_AJ_bTw8ARNj7A2-GbFZlSTrOAjDynx1pSD2Y,1049
-r5py/util/good_enough_equidistant_crs.py,sha256=1aqJLghNwcd2FbLfODcht_6pyOEqhsrE2KPaC3NLoek,2354
+r5py/util/file_digest.py,sha256=95UbaxbTZLa54j1CupsKria028xZ8f6ueZsTupnjlYE,1061
+r5py/util/good_enough_equidistant_crs.py,sha256=7FX3Ly3qegSV_YRA4OFk49LC29xUyTte1Gc5qOEi_9E,2458
 r5py/util/jvm.py,sha256=NCwoYLDznXydcIRAZl2kzUQA6D6NCvzjVG74pm6ioR0,5027
 r5py/util/memory_footprint.py,sha256=p8efCUs4UXRg6P1GrRxVs71m7SpEw2mASoz6PVTRvgQ,4672
 r5py/util/parse_int_date.py,sha256=JmnV8TwdUdUp3kSp2e73ZSxCbRyqv2FmQzNt0I_MsM0,667
 r5py/util/sample_data_set.py,sha256=aqUCx6drWD-WbCauewO4EzgOGnFr35mAZt-YHlqb92k,2463
 r5py/util/snake_to_camel_case.py,sha256=uJ5hTCVDUEmIxTyy4LGFTbpGC_rtnjDZVQ2vmVRTQ4k,485
+r5py/util/spatially_clustered_geodataframe.py,sha256=FxG8V3SSeK-PuCep565p1b3TNcl8oCkY764tk1L0sKM,2410
 r5py/util/validating_requests_session.py,sha256=sH5FgpS9eGax5DG2qA2GrGuiwgTJgh8tKsZ9OiXKmvk,1807
 r5py/util/warnings.py,sha256=CvxKWKlNO_p3riB4SkNqbU5AGPsaY_3-OzqaBObE3B8,139
-r5py-1.0.0.dev11.dist-info/LICENSE,sha256=VAnuGDX1TPylSN9G2xLa-urDpj_SQwn-qqs068dx4tk,51
-r5py-1.0.0.dev11.dist-info/METADATA,sha256=RKg-im_y_9gT08QQyGjYGtJAyb43OYza9PNNz2YyoLY,9915
-r5py-1.0.0.dev11.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-r5py-1.0.0.dev11.dist-info/top_level.txt,sha256=fOH1R85dkNDOI7jkg-lIsl5CQIO4fE5X868K9dTqs9U,5
-r5py-1.0.0.dev11.dist-info/RECORD,,
+r5py/util/working_copy.py,sha256=sbLbRCi39LtC-0tXxvh2y7ZN2D15chbhleCZXzHAFSc,1432
+r5py-1.0.1.dist-info/LICENSE,sha256=VAnuGDX1TPylSN9G2xLa-urDpj_SQwn-qqs068dx4tk,51
+r5py-1.0.1.dist-info/METADATA,sha256=URprsHGGXPJ0Ve6vCwJHw7R4iEZ7d7y84fJvmNdTrV4,9954
+r5py-1.0.1.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
+r5py-1.0.1.dist-info/top_level.txt,sha256=fOH1R85dkNDOI7jkg-lIsl5CQIO4fE5X868K9dTqs9U,5
+r5py-1.0.1.dist-info/RECORD,,

{r5py-1.0.0.dev11.dist-info → r5py-1.0.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.8.0)
+Generator: setuptools (76.0.0)
 Root-Is-Purelib: true
 Tag: py3-none-any