r5py 0.1.1.dev2__py3-none-any.whl → 1.0.0__py3-none-any.whl

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,106 +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
+        # a hash representing all input files
+        digest = hashlib.sha256(
+            "".join([FileDigest(osm_pbf)] + [FileDigest(path) for path in gtfs]).encode(
+                "utf-8"
+            )
+        ).hexdigest()
 
-        transport_network.streetLayer.associateStops(transport_network.transitLayer)
-        transport_network.streetLayer.buildEdgeLists()
+        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.rebuildTransientIndexes()
+            transport_network.streetLayer.associateStops(transport_network.transitLayer)
+            transport_network.streetLayer.buildEdgeLists()
 
-        transfer_finder = com.conveyal.r5.transit.TransferFinder(transport_network)
-        transfer_finder.findTransfers()
-        transfer_finder.findParkRideTransfer()
+            transport_network.transitLayer.rebuildTransientIndexes()
 
-        transport_network.transitLayer.buildDistanceTables(None)
+            transfer_finder = com.conveyal.r5.transit.TransferFinder(transport_network)
+            transfer_finder.findTransfers()
+            transfer_finder.findParkRideTransfer()
 
-        self._transport_network = transport_network
+            transport_network.transitLayer.buildDistanceTables(None)
 
-    def __del__(self):
-        """
-        Delete all temporary files upon destruction.
-        """
-        MAX_TRIES = 10
+            osm_file.close()  # not needed after here?
 
-        # 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
-        del self._transport_network
-
-        time.sleep(0.5)
-        jpype.java.lang.System.gc()
-
-        # then, try to delete all files in cache directory
-        temporary_files = [child for child in self._cache_directory.iterdir()]
-        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):
@@ -206,60 +161,27 @@ class TransportNetwork:
 
     @property
     def extent(self):
+        """The geographic area covered, as a `shapely.box`."""
         # TODO: figure out how to get the extent of the GTFS schedule,
         # 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

@@ -0,0 +1,209 @@
+#!/usr/bin/env python3
+
+"""Calculate travel times between many origins and destinations."""
+
+import copy
+
+try:
+    from warnings import deprecated
+except ImportError:  # Python<=3.12
+    from typing_extensions import deprecated
+
+import pandas
+
+from .base_travel_time_matrix import BaseTravelTimeMatrix
+from ..util import start_jvm
+
+import com.conveyal.r5
+
+
+__all__ = ["TravelTimeMatrix", "TravelTimeMatrixComputer"]
+
+
+start_jvm()
+
+
+class TravelTimeMatrix(BaseTravelTimeMatrix):
+    """Compute travel times between many origins and destinations."""
+
+    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.
+
+        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.
+        """
+        self._prepare_origins_destinations()
+        self.request.destinations = self.destinations
+
+        od_matrix = pandas.concat(
+            [self._travel_times_per_origin(from_id) for from_id in self.origins.id],
+            ignore_index=True,
+        )
+
+        try:
+            od_matrix = od_matrix.to_crs(self._origins_crs)
+        except AttributeError:  # (not a GeoDataFrame)
+            pass
+        return od_matrix
+
+    def _parse_results(self, from_id, results):
+        """
+        Parse the results of an R5 TravelTimeMatrix.
+
+        Parse data as returned from `com.conveyal.r5.analyst.TravelTimeComputer.computeTravelTimes()`,
+        cast data to Python types, and return as a `pandas.Dataframe`. Because of the way r5py
+        and R5 interact, this parses the results of routing from one origin to many (all) destinations.
+
+        Arguments
+        ---------
+        from_id : mixed
+            The value of the ID column of the origin record to report on.
+        results : `com.conveyal.r5.OneOriginResult` (Java object)
+
+        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.
+        """
+        # First, create an empty DataFrame (this forces column types)
+        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
+            }
+        )
+
+        # first assign columns with correct length (`to_id`),
+        # only then fill `from_id` (it’s a scalar)
+        od_matrix["to_id"] = self.destinations.id
+        od_matrix["from_id"] = from_id
+
+        for p, percentile in enumerate(self.request.percentiles):
+            travel_times = results.travelTimes.getValues()[p]
+            od_matrix[f"travel_time_p{percentile:d}"] = travel_times
+
+        # rename percentile column if only median requested (the default)
+        if self.request.percentiles == [50]:
+            od_matrix = od_matrix.rename(columns={"travel_time_p50": "travel_time"})
+
+        # R5’s NULL value is MAX_INT32
+        od_matrix = self._fill_nulls(od_matrix)
+
+        # re-index (and don’t keep the old index as a new column)
+        od_matrix = od_matrix.reset_index(drop=True)
+
+        return od_matrix
+
+    def _travel_times_per_origin(self, from_id):
+        request = copy.copy(self.request)
+        request.origin = self.origins[self.origins.id == from_id].geometry.item()
+
+        travel_time_computer = com.conveyal.r5.analyst.TravelTimeComputer(
+            request, self.transport_network
+        )
+        results = travel_time_computer.computeTravelTimes()
+
+        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

@@ -15,9 +15,7 @@ __all__ = ["Trip"]
 
 
 class Trip:
-    """
-    Represent one trip, consisting of one or more `TripLeg`s.
-    """
+    """Represent one trip, consisting of one or more `r5py.r5.TripLeg`."""
 
     COLUMNS = [
         "segment",
@@ -25,7 +23,7 @@ class Trip:
 
     def __init__(self, legs=[]):
         """
-        Represent one trip, consisting of one of more `TripLeg`s.
+        Represent one trip, consisting of one of more `r5py.r5.TripLeg`.
 
         Arguments
         =========
@@ -34,7 +32,13 @@ class Trip:
         """
         self.legs = legs
 
+    def __eq__(self, other):
+        """Check whether `self` and `other` are equal."""
+        if isinstance(other, self.__class__):
+            return self.legs == other.legs
+
     def __repr__(self):
+        """Return a string representation of `self`."""
         legs = ", ".join([str(leg) for leg in self.legs])
         return (
             f"<{self.__class__.__name__}: "
@@ -50,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)]
 
@@ -72,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):