r5py 1.1.0__py3-none-any.whl

r5py/r5/street_layer.py

@@ -0,0 +1,90 @@
+#!/usr/bin/env python3
+
+
+"""Wraps a com.conveyal.r5.streets.StreetLayer."""
+
+import functools
+
+import jpype
+import jpype.types
+import shapely
+
+from .transport_mode import TransportMode
+from ..util import start_jvm
+
+import com.conveyal.r5
+
+__all__ = ["StreetLayer"]
+
+
+start_jvm()
+
+
+EMPTY_POINT = shapely.Point()
+
+
+class StreetLayer:
+    """Wrap a com.conveyal.r5.streets.StreetLayer."""
+
+    @classmethod
+    def from_r5_street_layer(cls, street_layer):
+        """
+        Create a StreetLayer from a com.conveyal.r5.streets.StreetLayer.
+
+        Arguments
+        ---------
+        street_layer : com.conveyal.r5.streets.StreetLayer
+        """
+        instance = cls()
+        instance._street_layer = street_layer
+        return instance
+
+    @functools.cached_property
+    def extent(self):
+        """The geographic area covered, as a `shapely.box`."""
+        envelope = self._street_layer.envelope
+        return shapely.box(
+            envelope.getMinX(),
+            envelope.getMinY(),
+            envelope.getMaxX(),
+            envelope.getMaxY(),
+        )
+
+    def find_split(
+        self,
+        point,
+        radius=com.conveyal.r5.streets.StreetLayer.LINK_RADIUS_METERS,
+        street_mode=TransportMode.WALK,
+    ):
+        """
+        Find a location on an existing street near `point`.
+
+        Arguments
+        ---------
+        point : shapely.Point
+            Find a location close to this point
+        radius : float
+            Search radius around `point`
+        street_mode : travel mode that the snapped-to street should allow
+
+        Returns
+        -------
+        shapely.Point
+            Closest location on the street network or `POINT EMPTY` if no
+            such location could be found within `radius`
+        """
+        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,
+            )
+        except (AttributeError, TypeError):
+            return EMPTY_POINT
+
+
+@jpype._jcustomizer.JConversion(
+    "com.conveyal.r5.streets.StreetLayer", exact=StreetLayer
+)
+def _cast_StreetLayer(java_class, object_):
+    return object_._street_layer

r5py/r5/street_segment.py

@@ -0,0 +1,39 @@
+#!/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 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/transfer_leg.py

@@ -0,0 +1,12 @@
+#!/usr/bin/env python3
+
+
+"""Represent one leg of a trip: transfers between public transport vehicles."""
+
+from .direct_leg import DirectLeg
+
+__all__ = ["TransferLeg"]
+
+
+class TransferLeg(DirectLeg):
+    """Represent one leg of a trip: transfers between public transport vehicles."""

r5py/r5/transit_layer.py

@@ -0,0 +1,87 @@
+#!/usr/bin/env python3
+
+
+"""Wraps a com.conveyal.r5.transit.TransitLayer."""
+
+import functools
+
+import jpype
+import jpype.types
+
+import java.time
+
+__all__ = ["TransitLayer"]
+
+
+class TransitLayer:
+    """Wrap a com.conveyal.r5.transit.TransitLayer."""
+
+    @classmethod
+    def from_r5_transit_layer(cls, transit_layer):
+        """
+        Create a TransitLayer from a com.conveyal.r5.transit.TransitLayer.
+
+        Arguments
+        ---------
+        transit_layer : com.conveyal.r5.transit.TransitLayer
+        """
+        instance = cls()
+        instance._transit_layer = transit_layer
+        return instance
+
+    def covers(self, date):
+        """
+        Check whether `date` is covered by GTFS data sets.
+
+        Arguments:
+        ----------
+        date : datetime.date
+            date for which to check whether a GTFS service exists.
+
+        Returns:
+        --------
+        bool
+            Whether or not any services exist on `date`.
+        """
+        date = java.time.LocalDate.of(date.year, date.month, date.day)
+        return True in set(
+            [service.activeOn(date) for service in self._transit_layer.services]
+        )
+
+    def get_street_vertex_for_stop(self, stop):
+        """
+        Get the street layer’s vertex corresponding to `stop`.
+
+        Arguments
+        ---------
+        stop : int
+            ID of the public transport stop for which to find a vertex
+
+        Returns
+        -------
+        int
+            ID of the vertex corresponding to the public transport stop
+        """
+        street_vertex = self._transit_layer.streetVertexForStop.get(stop)
+        return street_vertex
+
+    @functools.cached_property
+    def routes(self):
+        """Return a list of GTFS routes."""
+        return list(self._transit_layer.routes)
+
+    @functools.cached_property
+    def trip_patterns(self):
+        """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
+)
+def _cast_TransitLayer(java_class, object_):
+    return object_._transit_layer

r5py/r5/transit_leg.py

@@ -0,0 +1,12 @@
+#!/usr/bin/env python3
+
+
+"""Represent one leg of a public transport trip."""
+
+from .trip_leg import TripLeg
+
+__all__ = ["TransitLeg"]
+
+
+class TransitLeg(TripLeg):
+    """Represent one leg of a public transport trip."""

r5py/r5/transport_mode.py

@@ -0,0 +1,148 @@
+#!/usr/bin/env python3
+
+
+"""The transport modes supported by R5 (Leg, Street, Transit, combined)."""
+
+import enum
+
+import jpype
+
+from ..util import start_jvm
+
+import com.conveyal.r5
+
+__all__ = ["TransportMode"]
+
+
+start_jvm()
+
+
+TRANSIT_MODES = [
+    "AIR",
+    "BUS",
+    "CABLE_CAR",
+    "FERRY",
+    "FUNICULAR",
+    "GONDOLA",
+    "RAIL",
+    "SUBWAY",
+    "TRAM",
+    "TRANSIT",
+]
+
+STREET_MODES = [
+    "BICYCLE",
+    "CAR",
+    "WALK",
+]
+
+LEG_MODES = STREET_MODES + [
+    "BICYCLE_RENT",
+    "CAR_PARK",
+]
+
+
+class TransportMode(enum.Enum):
+    """
+    Transport modes.
+
+    TransportMode.AIR, TransportMode.TRAM, TransportMode.SUBWAY,
+    TransportMode.RAIL, TransportMode.BUS, TransportMode.FERRY,
+    TransportMode.CABLE_CAR, TransportMode.GONDOLA, TransportMode.FUNICULAR,
+    TransportMode.TRANSIT (translate into R5’s TransitMode)
+
+    TransportMode.WALK, TransportMode.BICYCLE, TransportMode.CAR (translate into
+    R5’s StreetMode or LegMode)
+
+    TransportMode.BICYCLE_RENT, TransportMode.CAR_PARK (translate into R5’s LegMode)
+    """
+
+    @classmethod
+    def _missing_(cls, value):
+        value = str(value).upper()
+        for member in cls:
+            if value == member.value:
+                return member
+        return None
+
+    def __add__(self, other):
+        """Combine two transport modes."""
+        if isinstance(other, self.__class__):
+            return [self, other]
+        elif isinstance(other, list):
+            return [self] + other
+        else:
+            raise TypeError(
+                "unsupported operand type(s) for '+': "
+                f"'{type(other)}' and '{type(self)}'"
+            )
+
+    def __radd__(self, other):
+        """Combine two transport modes."""
+        if other == 0:  # first iteration of sum()
+            return self
+        elif isinstance(other, list):
+            return other + [self]
+        else:
+            return self.__add__(other)
+
+    @property
+    def is_leg_mode(self):
+        """Can this TransportMode function as a LegMode?."""
+        return self.name in LEG_MODES
+
+    @property
+    def is_street_mode(self):
+        """Can this TransportMode function as a StreetMode?."""
+        return self.name in STREET_MODES
+
+    @property
+    def is_transit_mode(self):
+        """Can this TransportMode function as a TransitMode?."""
+        return self.name in TRANSIT_MODES
+
+    AIR = "AIR"
+    BUS = "BUS"
+    CABLE_CAR = "CABLE_CAR"
+    FERRY = "FERRY"
+    FUNICULAR = "FUNICULAR"
+    GONDOLA = "GONDOLA"
+    RAIL = "RAIL"
+    SUBWAY = "SUBWAY"
+    TRAM = "TRAM"
+    TRANSIT = "TRANSIT"
+
+    BICYCLE = "BICYCLE"
+    CAR = "CAR"
+    WALK = "WALK"
+
+    BICYCLE_RENT = "BICYCLE_RENT"
+    CAR_PARK = "CAR_PARK"
+
+
+@jpype._jcustomizer.JConversion("com.conveyal.r5.api.util.LegMode", exact=TransportMode)
+def _cast_LegMode(java_class, object_):
+    if object_.name in LEG_MODES:
+        return com.conveyal.r5.api.util.LegMode.valueOf(object_.name)
+    else:
+        raise ValueError(f"{object_.name} is not a valid R5 LegMode")
+
+
+@jpype._jcustomizer.JConversion(
+    "com.conveyal.r5.profile.StreetMode", exact=TransportMode
+)
+def _cast_StreetMode(java_class, object_):
+    if object_.name in STREET_MODES:
+        return com.conveyal.r5.profile.StreetMode.valueOf(object_.name)
+    else:
+        raise ValueError(f"{object_.name} is not a valid R5 StreetMode")
+
+
+@jpype._jcustomizer.JConversion(
+    "com.conveyal.r5.api.util.TransitModes", exact=TransportMode
+)
+def _cast_TransitMode(java_class, object_):
+    if object_.name in TRANSIT_MODES:
+        return com.conveyal.r5.api.util.TransitModes.valueOf(object_.name)
+    else:
+        raise ValueError(f"{object_.name} is not a valid R5 TransitModes")

r5py/r5/transport_network.py

@@ -0,0 +1,299 @@
+#!/usr/bin/env python3
+
+
+"""Wraps a com.conveyal.r5.transit.TransportNetwork."""
+
+import functools
+import hashlib
+import pathlib
+import warnings
+
+import jpype
+import jpype.types
+
+from .elevation_cost_function import ElevationCostFunction
+from .elevation_model import ElevationModel
+from .street_layer import StreetLayer
+from .transit_layer import TransitLayer
+from .transport_mode import TransportMode
+from ..util import Config, contains_gtfs_data, FileDigest, start_jvm, WorkingCopy
+from ..util.exceptions import GtfsFileError
+
+import com.conveyal.analysis
+import com.conveyal.gtfs
+import com.conveyal.osmlib
+import com.conveyal.r5
+import java.io
+
+__all__ = ["TransportNetwork"]
+
+
+PACKAGE = __package__.split(".", maxsplit=1)[0]
+
+
+start_jvm()
+
+
+class TransportNetwork:
+    """Wrap a com.conveyal.r5.transit.TransportNetwork."""
+
+    def __init__(
+        self,
+        osm_pbf,
+        gtfs=[],  # noqa: B006
+        elevation_model=None,
+        elevation_cost_function=ElevationCostFunction.TOBLER,
+        allow_errors=False,
+    ):
+        """
+        Load a transport network.
+
+        Arguments
+        ---------
+        osm_pbf : str | pathlib.Path
+            file path of an OpenStreetMap extract in PBF format
+        gtfs : str | pathlib.Path | list[str] | list[pathlib.Path]
+            path(s) to public transport schedule information in GTFS format
+        elevation_model : str | pathlib.Path
+            file path to a digital elevation model in TIF format,
+            single-band, the value of which is the elevation in metres
+        elevation_cost_function : r5py.ElevationCostFunction
+            which algorithm to use to compute the added effort and travel time
+            of slopes
+        allow_errors : bool
+            try to proceed with loading the transport network even if input data
+            contain errors
+        """
+        osm_pbf = WorkingCopy(osm_pbf)
+        if isinstance(gtfs, (str, pathlib.Path)):
+            gtfs = [gtfs]
+        gtfs = [WorkingCopy(path) for path in gtfs]
+
+        # a hash representing all input files
+        digest = hashlib.sha256(
+            "".join(
+                [FileDigest(osm_pbf)]
+                + [FileDigest(path) for path in gtfs]
+                + [FileDigest(elevation_model) if elevation_model is not None else ""]
+            ).encode("utf-8")
+        ).hexdigest()
+
+        try:
+            transport_network = self._load_pickled_transport_network(
+                Config().CACHE_DIR / f"{digest}.transport_network"
+            )
+        except (FileNotFoundError, java.io.IOError, java.lang.RuntimeException):
+            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.saveShapes = True
+            transport_network.transitLayer.parentNetwork = transport_network
+            # GtfsTransferLoader(transitLayer, OSM_ONLY)
+            gtfs_transfer_loader = com.conveyal.r5.transit.GtfsTransferLoader(
+                transport_network.transitLayer,
+                com.conveyal.r5.analyst.cluster.TransportNetworkConfig.TransferConfig.OSM_ONLY,  # noqa: E501
+            )
+            for gtfs_file in gtfs:
+                gtfs_feed = com.conveyal.gtfs.GTFSFeed.writableTempFileFromGtfs(
+                    f"{gtfs_file}"
+                )
+                if gtfs_feed.errors.size() > 0:
+                    errors = [
+                        f"{error.errorType}: {error.getMessageWithContext()}"
+                        for error in gtfs_feed.errors
+                    ]
+                    if allow_errors:
+                        warnings.warn(
+                            (
+                                "R5 reported the following issues with "
+                                f"GTFS file {gtfs_file.name}: \n"
+                                + ("\n- ".join(errors))
+                            ),
+                            RuntimeWarning,
+                            stacklevel=1,
+                        )
+                    else:
+                        raise GtfsFileError(
+                            (
+                                f"Could not load GTFS file {gtfs_file.name}. \n"
+                                + ("\n- ".join(errors))
+                            )
+                        )
+
+                transport_network.transitLayer.loadFromGtfs(
+                    gtfs_feed,
+                    gtfs_transfer_loader,
+                )
+                gtfs_feed.close()
+
+            transport_network.streetLayer.associateStops(transport_network.transitLayer)
+            transport_network.streetLayer.buildEdgeLists()
+
+            transport_network.transitLayer.rebuildTransientIndexes()
+
+            transfer_finder = com.conveyal.r5.transit.TransferFinder(
+                transport_network,
+                gtfs_transfer_loader,
+            )
+            transfer_finder.findTransfers()
+            transfer_finder.findParkRideTransfer()
+
+            transport_network.transitLayer.buildDistanceTables(None)
+
+            if elevation_model is not None:
+                ElevationModel(
+                    elevation_model,
+                    elevation_cost_function,
+                ).apply_to(transport_network)
+
+            osm_file.close()  # not needed after here?
+
+            self._save_pickled_transport_network(
+                transport_network, Config().CACHE_DIR / f"{digest}.transport_network"
+            )
+
+        self._transport_network = transport_network
+
+    @classmethod
+    def from_directory(cls, path):
+        """
+        Find input data in `path`, load an `r5py.TransportNetwork`.
+
+        This mimicks r5r’s behaviour to accept a directory path
+        as the only input to `setup_r5()`.
+
+        If more than one OpenStreetMap extract (`.osm.pbf`) is
+        found in `path`, the (alphabetically) first one is used.
+        In case *no* OpenStreetMap extract is found, a `FileNotFound`
+        exception is raised. Any and all GTFS data files are used.
+
+        Arguments
+        ---------
+        path : str
+            directory path in which to search for GTFS and .osm.pbf files
+
+        Returns
+        -------
+        TransportNetwork
+            A fully initialised r5py.TransportNetwork
+        """
+        path = pathlib.Path(path)
+        try:
+            potential_osm_pbf_files = sorted(path.glob("*.osm.pbf"))
+            osm_pbf = potential_osm_pbf_files[0]
+            if len(potential_osm_pbf_files) > 1:
+                warnings.warn(
+                    (
+                        f"Found more than one OpenStreetMap extract file (`.osm.pbf`), "
+                        f"using alphabetically first one ({osm_pbf.name})"
+                    ),
+                    RuntimeWarning,
+                    stacklevel=1,
+                )
+        except IndexError as exception:
+            raise FileNotFoundError(
+                "Could not find any OpenStreetMap extract file (`.osm.pbf`) "
+                f"in {path.absolute()}"
+            ) from exception
+        gtfs = [
+            potential_gtfs_file
+            for potential_gtfs_file in path.glob("*.zip")
+            if contains_gtfs_data(potential_gtfs_file)
+        ]
+
+        return cls(osm_pbf, gtfs)
+
+    def __enter__(self):
+        """Provide a context."""
+        return self
+
+    def __exit__(self, exception_type, exception_value, traceback):
+        """Exit context."""
+        return False
+
+    @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
+
+    @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 as exception:
+            raise FileNotFoundError from exception
+
+    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,
+        radius=com.conveyal.r5.streets.StreetLayer.LINK_RADIUS_METERS,
+        street_mode=TransportMode.WALK,
+    ):
+        """
+        Snap `points` to valid locations on the network.
+
+        Arguments
+        ---------
+        points : geopandas.GeoSeries
+            point geometries that will be snapped to the network
+        radius : float
+            Search radius around each `point`
+        street_mode : travel mode that the snapped-to street should allow
+
+        Returns
+        -------
+        geopandas.GeoSeries
+            point geometries that have been snapped to the network,
+            using the same index and order as the input `points`
+        """
+        return points.apply(
+            functools.partial(
+                self.street_layer.find_split,
+                radius=radius,
+                street_mode=street_mode,
+            )
+        )
+
+    @functools.cached_property
+    def street_layer(self):
+        """Expose the `TransportNetwork`’s `streetLayer` to Python."""
+        return StreetLayer.from_r5_street_layer(self._transport_network.streetLayer)
+
+    @property
+    def timezone(self):
+        """Determine the timezone of the GTFS data."""
+        return self._transport_network.getTimeZone()
+
+    @functools.cached_property
+    def transit_layer(self):
+        """Expose the `TransportNetwork`’s `transitLayer` to Python."""
+        return TransitLayer.from_r5_transit_layer(self._transport_network.transitLayer)
+
+
+@jpype._jcustomizer.JConversion(
+    "com.conveyal.r5.transit.TransportNetwork", exact=TransportNetwork
+)
+def _cast_TransportNetwork(java_class, object_):
+    return object_._transport_network