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

r5py/r5/{travel_time_matrix_computer.py → travel_time_matrix.py}

@@ -4,25 +4,82 @@
 
 import copy
 
-import joblib
+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]
+
+    def _compute(self):
         """
         Compute travel times from all origins to all destinations.
 
@@ -40,20 +97,10 @@ class TravelTimeMatrixComputer(BaseTravelTimeMatrixComputer):
         self._prepare_origins_destinations()
         self.request.destinations = self.destinations
 
-        # loop over all origins, modify the request, and compute the times
-        # to all destinations.
-        with joblib.Parallel(
-            prefer="threads",
-            verbose=(10 * self.verbose),  # joblib has a funny verbosity scale
-            n_jobs=self.NUM_THREADS,
-        ) as parallel:
-            od_matrix = pandas.concat(
-                parallel(
-                    joblib.delayed(self._travel_times_per_origin)(from_id)
-                    for from_id in self.origins.id
-                ),
-                ignore_index=True,
-            )
+        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)
@@ -132,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

@@ -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):

r5py/r5/trip_leg.py

@@ -4,6 +4,11 @@
 """Represent one leg of a trip."""
 
 
+import datetime
+import numpy
+import shapely
+
+
 __all__ = ["TripLeg"]
 
 
@@ -21,39 +26,56 @@ class TripLeg:
         "distance",
         "travel_time",
         "wait_time",
-        "route",
+        "feed",
+        "agency_id",
+        "route_id",
+        "start_stop_id",
+        "end_stop_id",
         "geometry",
     ]
 
     def __init__(
         self,
         transport_mode=None,
-        departure_time=None,
+        departure_time=numpy.datetime64("NaT"),
         distance=None,
-        travel_time=None,
-        wait_time=None,
-        route=None,
-        geometry=None,
+        travel_time=datetime.timedelta(seconds=0),
+        wait_time=datetime.timedelta(seconds=0),
+        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
         """
@@ -62,10 +84,15 @@ 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):
+        """Trip-chain `other` to `self`."""
         from .trip import Trip
 
         if isinstance(other, self.__class__):
@@ -80,6 +107,7 @@ class TripLeg:
             )
 
     def __radd__(self, other):
+        """Trip-chain `self` to `other`."""
         from .trip import Trip
 
         if other == 0:  # first iteration of sum()
@@ -90,31 +118,43 @@ class TripLeg:
         else:
             return self.__add__(other)
 
+    def __eq__(self, other):
+        """Check if `other` is an equal `TripLeg`."""
+        if isinstance(other, self.__class__):
+            return False not in [
+                self._are_columns_equal(other, column) for column in self.COLUMNS
+            ]
+
     def __gt__(self, other):
+        """Check if `other` has a longer travel time."""
         if isinstance(other, TripLeg):
             return (self.travel_time + self.wait_time) > (
                 other.travel_time + other.wait_time
             )
 
     def __ge__(self, other):
+        """Check if `other` has a longer or equal travel time."""
         if isinstance(other, TripLeg):
             return (self.travel_time + self.wait_time) >= (
                 other.travel_time + other.wait_time
             )
 
     def __lt__(self, other):
+        """Check if `other` has a shorter travel time."""
         if isinstance(other, TripLeg):
             return (self.travel_time + self.wait_time) < (
                 other.travel_time + other.wait_time
             )
 
     def __le__(self, other):
+        """Check if `other` has a shorter or equal travel time."""
         if isinstance(other, TripLeg):
             return (self.travel_time + self.wait_time) <= (
                 other.travel_time + other.wait_time
             )
 
     def __repr__(self):
+        """Return a string representation."""
         try:
             first_point = self.geometry.coords[0]
             last_point = self.geometry.coords[-1]
@@ -127,10 +167,30 @@ class TripLeg:
                 f"{first_point} -> {last_point}"
                 ">"
             )
-        except AttributeError:
+        except (AttributeError, IndexError):
             _repr = f"<{self.__class__.__name__}>"
         return _repr
 
+    def _are_columns_equal(self, other, column):
+        """
+        Check if a column equals the same column of a different `Trip`.
+
+        Compare if attribute `column` of self equals attribute `column` of
+        other. Also True if both values are None or NaN or NaT.
+        """
+        self_column = getattr(self, column)
+        other_column = getattr(other, column)
+
+        return (
+            self_column == other_column
+            or (self_column is None and other_column is None)
+            or (self_column == numpy.nan and other_column == numpy.nan)
+            or (
+                self_column == numpy.datetime64("NaT")
+                and other_column == numpy.datetime64("NaT")
+            )
+        )
+
     def as_table_row(self):
         """
         Return a table row (list) of this trip leg’s details.
@@ -138,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

@@ -43,9 +43,7 @@ ZERO_SECONDS = datetime.timedelta(seconds=0)
 
 
 class TripPlanner:
-    """
-    Find detailed routes between two points.
-    """
+    """Find detailed routes between two points."""
 
     MAX_ACCESS_TIME = datetime.timedelta(hours=1)
     MAX_EGRESS_TIME = MAX_ACCESS_TIME
@@ -72,7 +70,7 @@ class TripPlanner:
     @property
     def trips(self):
         """
-        Find detailed routes between two points.
+        Detailed routes between two points.
 
         Returns
         =======
@@ -84,6 +82,15 @@ class TripPlanner:
 
     @property
     def direct_paths(self):
+        """
+        Detailed routes between two points using direct modes.
+
+        Returns
+        =======
+        list[r5py.r5.Trip]
+            Detailed routes that meet the requested parameters, using direct
+            modes (walking, cycling, driving).
+        """
         direct_paths = []
         request = copy.copy(self.request)
 
@@ -143,11 +150,16 @@ class TripPlanner:
                             ]
                         )
                     )
-                except java.lang.NullPointerException:
+                except (
+                    java.lang.NullPointerException,
+                    java.util.NoSuchElementException,
+                ):
                     warnings.warn(
                         f"Could not find route between origin "
-                        f"({self.request.fromLon}, {self.request.fromLat}) "
-                        f"and destination ({self.request.toLon}, {self.request.toLat})",
+                        f"({self.request._regional_task.fromLon}, "
+                        f"{self.request._regional_task.fromLat}) "
+                        f"and destination ({self.request._regional_task.toLon}, "
+                        f"{self.request._regional_task.toLat})",
                         RuntimeWarning,
                     )
         return direct_paths
@@ -168,6 +180,15 @@ class TripPlanner:
 
     @functools.cached_property
     def transit_paths(self):
+        """
+        Detailed routes between two points on public transport.
+
+        Returns
+        =======
+        list[r5py.r5.Trip]
+            Detailed routes that meet the requested parameters, on public
+            transport.
+        """
         transit_paths = []
 
         # if any transit mode requested:
@@ -195,7 +216,6 @@ class TripPlanner:
                                 distance=0.0,
                                 travel_time=ZERO_SECONDS,
                                 wait_time=ZERO_SECONDS,
-                                route=None,
                                 geometry=shapely.LineString(((lon, lat), (lon, lat))),
                             )
                         ]
@@ -214,8 +234,8 @@ class TripPlanner:
                     com.conveyal.r5.profile.McRaptorSuboptimalPathProfileRouter(
                         self.transport_network,
                         request,
-                        self.transit_access_times,
-                        self.transit_egress_times,
+                        self._transit_access_times,
+                        self._transit_egress_times,
                         list_supplier_callback,
                         None,
                         True,
@@ -234,18 +254,26 @@ class TripPlanner:
                     for state in list(states)  # some departure times yield no results
                 }
 
+                # keep another cache layer of shortest access and egress legs
+                access_legs_by_stop = {}
+                egress_legs_by_stop = {}
+
                 for departure_time, state in final_states.items():
                     trip = Trip()
                     while state:
                         if state.stop == -1:  # EgressLeg
-                            leg = min(
-                                [
-                                    self.transit_egress_paths[transport_mode][
-                                        state.back.stop
+                            try:
+                                leg = egress_legs_by_stop[state.back.stop]
+                            except KeyError:
+                                leg = min(
+                                    [
+                                        self._transit_egress_paths[transport_mode][
+                                            state.back.stop
+                                        ]
+                                        for transport_mode in self._transit_egress_paths.keys()
                                     ]
-                                    for transport_mode in self.transit_egress_paths.keys()
-                                ]
-                            )
+                                )
+                                egress_legs_by_stop[state.back.stop] = leg
                             leg.wait_time = ZERO_SECONDS
                             leg.departure_time = (
                                 midnight
@@ -255,14 +283,18 @@ class TripPlanner:
                             leg.arrival_time = leg.departure_time + leg.travel_time
 
                         elif state.back is None:  # AccessLeg
-                            leg = min(
-                                [
-                                    self.transit_access_paths[transport_mode][
-                                        state.stop
+                            try:
+                                leg = access_legs_by_stop[state.stop]
+                            except KeyError:
+                                leg = min(
+                                    [
+                                        self._transit_access_paths[transport_mode][
+                                            state.stop
+                                        ]
+                                        for transport_mode in self._transit_access_paths.keys()
                                     ]
-                                    for transport_mode in self.transit_access_paths.keys()
-                                ]
-                            )
+                                )
+                                access_legs_by_stop[state.stop] = leg
                             leg.wait_time = ZERO_SECONDS
                             leg.arrival_time = midnight + datetime.timedelta(
                                 seconds=state.time
@@ -274,7 +306,7 @@ class TripPlanner:
                                 departure_stop = state.back.stop
                                 arrival_stop = state.stop
 
-                                leg = self.transit_transfer_path(
+                                leg = self._transit_transfer_path(
                                     departure_stop, arrival_stop
                                 )
 
@@ -294,6 +326,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(
@@ -346,13 +389,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:
@@ -361,12 +408,14 @@ class TripPlanner:
                         trip = leg + trip
                         state = state.back
 
-                    transit_paths.append(trip)
+                    # R5 sometimes reports the same path more than once, skip duplicates
+                    if trip not in transit_paths:
+                        transit_paths.append(trip)
 
         return transit_paths
 
     @functools.cached_property
-    def transit_access_paths(self):
+    def _transit_access_paths(self):
         access_paths = {}
 
         request = copy.copy(self.request)
@@ -406,9 +455,12 @@ class TripPlanner:
         return access_paths
 
     @functools.cached_property
-    def transit_access_times(self):
-        """Times to reached stops in the format required by
-        McRaptorSuboptimalPathProfileRouter."""
+    def _transit_access_times(self):
+        """
+        Times to reached stops.
+
+        In the format required by McRaptorSuboptimalPathProfileRouter.
+        """
         access_times = jpype.JObject(
             {
                 com.conveyal.r5.api.util.LegMode
@@ -419,14 +471,14 @@ class TripPlanner:
                         for transfer_leg in reached_stops.values()
                     ],
                 )
-                for mode, reached_stops in self.transit_access_paths.items()
+                for mode, reached_stops in self._transit_access_paths.items()
             },
             "java.util.Map<com.conveyal.r5.LegMode, gnu.trove.map.TIntIntMap>",
         )
         return access_times
 
     @functools.cached_property
-    def transit_egress_paths(self):
+    def _transit_egress_paths(self):
         egress_paths = {}
 
         request = copy.copy(self.request)
@@ -467,9 +519,12 @@ class TripPlanner:
         return egress_paths
 
     @functools.cached_property
-    def transit_egress_times(self):
-        """Times to reached stops in the format required by
-        McRaptorSuboptimalPathProfileRouter."""
+    def _transit_egress_times(self):
+        """
+        Times to reached stops.
+
+        In the format required by McRaptorSuboptimalPathProfileRouter.
+        """
         egress_times = jpype.JObject(
             {
                 com.conveyal.r5.api.util.LegMode
@@ -480,13 +535,14 @@ class TripPlanner:
                         for transfer_leg in reached_stops.values()
                     ],
                 )
-                for mode, reached_stops in self.transit_egress_paths.items()
+                for mode, reached_stops in self._transit_egress_paths.items()
             },
             "java.util.Map<com.conveyal.r5.LegMode, gnu.trove.map.TIntIntMap>",
         )
         return egress_times
 
-    def transit_transfer_path(self, from_stop, to_stop):
+    def _transit_transfer_path(self, from_stop, to_stop):
+        """Find a transfer path between two transit stops."""
         self._transfer_paths = {}
         while True:
             try:
@@ -524,8 +580,8 @@ class TripPlanner:
                     TransportMode.WALK,
                 )
 
-                transfer_path = self._transfer_paths[
-                    (from_stop, to_stop)
-                ] = TransferLeg(TransportMode.WALK, street_segment)
+                transfer_path = self._transfer_paths[(from_stop, to_stop)] = (
+                    TransferLeg(TransportMode.WALK, street_segment)
+                )
 
                 return transfer_path