r5py 0.1.2__py3-none-any.whl → 1.0.0__py3-none-any.whl

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/transit_layer.py

@@ -98,6 +98,10 @@ class TransitLayer:
         """Return a list of GTFS trip patterns."""
         return list(self._transit_layer.tripPatterns)
 
+    def get_stop_id_from_index(self, stop_index):
+        """Get the GTFS stop id for the `stop_index`-th stop of this transit layer."""
+        return self._transit_layer.stopIdForIndex[stop_index]
+
 
 @jpype._jcustomizer.JConversion(
     "com.conveyal.r5.transit.TransitLayer", exact=TransitLayer

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_computer.py → travel_time_matrix.py}

@@ -4,24 +4,83 @@
 
 import copy
 
+try:
+    from warnings import deprecated
+except ImportError:  # Python<=3.12
+    from typing_extensions import deprecated
+
 import pandas
 
-from .base_travel_time_matrix_computer import BaseTravelTimeMatrixComputer
+from .base_travel_time_matrix import BaseTravelTimeMatrix
 from ..util import start_jvm
 
 import com.conveyal.r5
 
 
-__all__ = ["TravelTimeMatrixComputer"]
+__all__ = ["TravelTimeMatrix", "TravelTimeMatrixComputer"]
 
 
 start_jvm()
 
 
-class TravelTimeMatrixComputer(BaseTravelTimeMatrixComputer):
+class TravelTimeMatrix(BaseTravelTimeMatrix):
     """Compute travel times between many origins and destinations."""
 
-    def compute_travel_times(self):
+    def __init__(
+        self,
+        transport_network,
+        origins=None,
+        destinations=None,
+        snap_to_network=False,
+        **kwargs,
+    ):
+        """
+        Compute travel times between many origins and destinations.
+
+        ``r5py.TravelTimeMatrix`` are child classes of ``pandas.DataFrame`` and
+        support all of their methods and properties,
+        see https://pandas.pydata.org/docs/
+
+        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
+            Places to find a route _from_
+            Has to have a point geometry, and at least an `id` column
+        destinations : geopandas.GeoDataFrame (optional)
+            Places to find a route _to_
+            Has to have a point geometry, and at least an `id` column
+            If omitted, use same data set as for origins
+        snap_to_network : bool or int, default False
+            Should origin an destination points be snapped to the street network
+            before routing? If `True`, the default search radius (defined in
+            `com.conveyal.r5.streets.StreetLayer.LINK_RADIUS_METERS`) is used,
+            if `int`, use `snap_to_network` meters as the search radius.
+        **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``
+        """
+        super().__init__(
+            transport_network,
+            origins,
+            destinations,
+            snap_to_network,
+            **kwargs,
+        )
+        data = self._compute()
+        for column in data.columns:
+            self[column] = data[column]
+        del self.transport_network
+
+    def _compute(self):
         """
         Compute travel times from all origins to all destinations.
 
@@ -76,17 +135,16 @@ class TravelTimeMatrixComputer(BaseTravelTimeMatrixComputer):
             travel time.
         """
         # First, create an empty DataFrame (this forces column types)
-        travel_time_columns = {
-            "from_id": pandas.Series(dtype=str),
-            "to_id": pandas.Series(dtype=str),
-        }
-        travel_time_columns.update(
+        od_matrix = pandas.DataFrame(
             {
+                "from_id": pandas.Series(dtype=str),
+                "to_id": pandas.Series(dtype=str),
+            }
+            | {
                 f"travel_time_p{percentile:d}": pandas.Series(dtype=float)
                 for percentile in self.request.percentiles
             }
         )
-        od_matrix = pandas.DataFrame(travel_time_columns)
 
         # first assign columns with correct length (`to_id`),
         # only then fill `from_id` (it’s a scalar)
@@ -121,3 +179,31 @@ class TravelTimeMatrixComputer(BaseTravelTimeMatrixComputer):
         od_matrix = self._parse_results(from_id, results)
 
         return od_matrix
+
+
+@deprecated(
+    "Use `TravelTimeMatrix` instead, `TravelTimeMatrixComputer will be deprecated in a future release."
+)
+class TravelTimeMatrixComputer:
+    """Compute travel times between many origins and destinations."""
+
+    def __init__(self, *args, **kwargs):
+        """Compute travel times between many origins and destinations."""
+        self._ttm = TravelTimeMatrix(*args, **kwargs)
+
+    def compute_travel_times(self):
+        """
+        Compute travel times from all origins to all destinations.
+
+        Returns
+        -------
+        pandas.DataFrame
+            A data frame containing the columns ``from_id``, ``to_id``, and
+            ``travel_time``, where ``travel_time`` is the median calculated
+            travel time between ``from_id`` and ``to_id`` or ``numpy.nan``
+            if no connection with the given parameters was found.
+            If non-default ``percentiles`` were requested: one or more columns
+            ``travel_time_p{:02d}`` representing the particular percentile of
+            travel time.
+        """
+        return self._ttm

r5py/r5/trip.py

@@ -54,8 +54,9 @@ class Trip:
         Returns
         =======
         list : detailed information about this trip and its legs (segments):
-        ``segment``, ``transport_mode``, ``departure_time``, ``distance``,
-        ``travel_time``, ``wait_time``, ``route``, ``geometry``
+            ``segment``, ``transport_mode``, ``departure_time``, ``distance``,
+            ``travel_time``, ``wait_time``, ``feed``, ``agency_id``, ``route_id``,
+            ``start_stop_id``, ``end_stop_id``, ``geometry``
         """
         return [[segment] + leg.as_table_row() for segment, leg in enumerate(self.legs)]
 
@@ -76,9 +77,9 @@ class Trip:
         )
 
     @property
-    def routes(self):
+    def route_ids(self):
         """The public transport route(s) used on this trip."""
-        return [leg.route for leg in self.legs]
+        return [leg.route_id for leg in self.legs]
 
     @property
     def transport_modes(self):

r5py/r5/trip_leg.py

@@ -26,7 +26,11 @@ class TripLeg:
         "distance",
         "travel_time",
         "wait_time",
-        "route",
+        "feed",
+        "agency_id",
+        "route_id",
+        "start_stop_id",
+        "end_stop_id",
         "geometry",
     ]
 
@@ -37,28 +41,41 @@ class TripLeg:
         distance=None,
         travel_time=datetime.timedelta(seconds=0),
         wait_time=datetime.timedelta(seconds=0),
-        route=None,
+        feed=None,
+        agency_id=None,
+        route_id=None,
+        start_stop_id=None,
+        end_stop_id=None,
         geometry=shapely.LineString(),
     ):
         """
         Represent one leg of a trip.
 
-        This is a base class, use one the specific classes,
-        e.g., TransitLeg, or DirectLeg
+        This is a base class, use one of the more specific classes, e.g.,
+        TransitLeg, or DirectLeg
 
         Arguments
         =========
         transport_mode : r5py.TransportMode
             mode of transport this trip leg was travelled
-        departure_time : datetime.datetime,
+        departure_time : datetime.datetime
+            departure time of this trip leg
         distance : float
             distance covered by this trip leg, in metres
         travel_time : datetime.timedelta
             time spent travelling on this trip leg
         wait_time : datetime.timedelta
             time spent waiting for a connection on this trip leg
-        route : str
-            public transport route used for this trip leg
+        feed : str
+            the GTFS feed identifier used for this trip leg
+        agency_id : str
+            the GTFS id the agency used for this trip leg
+        route_id : str
+            the GTFS id of the public transport route used for this trip leg
+        start_stop_id : str
+            the GTFS stop_id of the boarding stop used for this trip leg
+        end_stop_id : str
+            the GTFS stop_id of the aligning stop used for this trip leg
         geometry : shapely.LineString
             spatial representation of this trip leg
         """
@@ -67,7 +84,11 @@ class TripLeg:
         self.distance = distance
         self.travel_time = travel_time
         self.wait_time = wait_time
-        self.route = route
+        self.feed = feed
+        self.agency_id = agency_id
+        self.route_id = route_id
+        self.start_stop_id = start_stop_id
+        self.end_stop_id = end_stop_id
         self.geometry = geometry
 
     def __add__(self, other):
@@ -177,7 +198,8 @@ class TripLeg:
         Returns
         =======
         list : detailed information about this trip leg: ``transport_mode``,
-        ``departure_time``, ``distance``, ``travel_time``, ``wait_time``,
-        ``route``, ``geometry``
+            ``departure_time``, ``distance``, ``travel_time``, ``wait_time``,
+            ``feed``, ``agency_id`` ``route_id``, ``start_stop_id``,
+            ``end_stop_id``, ``geometry``
         """
         return [getattr(self, column) for column in self.COLUMNS]

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
@@ -216,7 +215,6 @@ class TripPlanner:
                                 distance=0.0,
                                 travel_time=ZERO_SECONDS,
                                 wait_time=ZERO_SECONDS,
-                                route=None,
                                 geometry=shapely.LineString(((lon, lat), (lon, lat))),
                             )
                         ]
@@ -327,6 +325,17 @@ class TripPlanner:
 
                             else:  # TransitLeg
                                 pattern = transit_layer.trip_patterns[state.pattern]
+
+                                # Use the indices to look up the stop ids, which are scoped by the GTFS feed supplied
+                                start_stop_id = transit_layer.get_stop_id_from_index(
+                                    state.back.stop
+                                ).split(":")[1]
+                                end_stop = transit_layer.get_stop_id_from_index(
+                                    state.stop
+                                )
+                                end_stop_id = end_stop.split(":")[1]
+                                feed = end_stop.split(":")[0]
+
                                 route = transit_layer.routes[pattern.routeIndex]
                                 transport_mode = TransportMode(
                                     com.conveyal.r5.transit.TransitLayer.getTransitModes(
@@ -379,13 +388,17 @@ class TripPlanner:
                                     distance = None
 
                                 leg = TransitLeg(
-                                    transport_mode,
-                                    departure_time,
-                                    distance,
-                                    travel_time,
-                                    wait_time,
-                                    str(route.route_short_name),
-                                    geometry,
+                                    transport_mode=transport_mode,
+                                    departure_time=departure_time,
+                                    distance=distance,
+                                    travel_time=travel_time,
+                                    wait_time=wait_time,
+                                    feed=str(feed),
+                                    agency_id=str(route.agency_id),
+                                    route_id=str(route.route_id),
+                                    start_stop_id=str(start_stop_id),
+                                    end_stop_id=str(end_stop_id),
+                                    geometry=geometry,
                                 )
 
                         # we traverse in reverse order:

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",
 ]