gtfs-parser 0.1.0__py3-none-any.whl

gtfs_parser/__init__.py

@@ -0,0 +1,2 @@
+from .gtfs import GTFS
+from . import aggregate, parse

gtfs_parser/__main__.py

@@ -0,0 +1,128 @@
+import json
+import os
+import zipfile
+import tempfile
+import argparse
+import shutil
+
+from .gtfs import GTFS
+from .parse import read_routes, read_stops
+from .aggregate import Aggregator
+
+
+def load_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("mode")
+    parser.add_argument("src")
+    parser.add_argument("dst")
+    parser.add_argument("--parse_ignoreshapes", action="store_true")
+    parser.add_argument("--parse_ignorenoroute", action="store_true")
+    parser.add_argument("--aggregate_yyyymmdd")
+    parser.add_argument("--aggregate_nounifystops", action="store_true")
+    parser.add_argument("--aggregate_delimiter")
+    parser.add_argument("--aggregate_begintime")
+    parser.add_argument("--aggregate_endtime")
+    args = parser.parse_args()
+    return args
+
+
+def validate_args(args):
+    if args.aggregate_yyyymmdd:
+        if len(args.aggregate_yyyymmdd) != 8:
+            raise RuntimeError(
+                f"yyyymmdd must be 8 characters string, for example 20210401, \
+                    your is {args.aggregate_yyyymmdd} ({len(args.aggregate_yyyymmdd)} characters)"
+            )
+
+    if args.aggregate_begintime:
+        if len(args.aggregate_begintime) != 6:
+            raise RuntimeError(
+                f'begintime must be "hhmmss", your is {args.aggregate_begintime}'
+            )
+        if not args.aggregate_endtime:
+            raise RuntimeError("endtime is not set.")
+
+    if args.aggregate_endtime:
+        if len(args.aggregate_endtime) != 6:
+            raise RuntimeError(
+                f'endtime must be "hhmmss", your is {args.aggregate_endtime}'
+            )
+        if not args.aggregate_begintime:
+            raise RuntimeError("begintime is not set.")
+
+
+def main():
+    args = load_args()
+    validate_args(args)
+
+    if args.src.endswith(".zip"):  # TODO: wiser checking
+        print("extracting zipfile...")
+        temp_dir = os.path.join(tempfile.gettempdir(), "gtfs_parser")
+        if os.path.exists(temp_dir):
+            shutil.rmtree(temp_dir)
+        os.mkdir(temp_dir)
+        with zipfile.ZipFile(args.zip) as z:
+            z.extractall(temp_dir)
+        output_dir = temp_dir
+    else:
+        output_dir = args.src
+
+    gtfs = GTFS(output_dir)
+    print("GTFS loaded.")
+
+    os.makedirs(args.dst, exist_ok=True)
+
+    if args.mode == "aggregate":
+        aggregator = Aggregator(
+            gtfs,
+            no_unify_stops=args.aggregate_nounifystops,
+            delimiter=args.aggregate_delimiter,
+            yyyymmdd=args.aggregate_yyyymmdd,
+            begin_time=args.aggregate_begintime,
+            end_time=args.aggregate_endtime,
+        )
+        aggregated_routes_geojson = {
+            "type": "FeatureCollection",
+            "features": aggregator.read_route_frequency(),
+        }
+        aggregated_stops_geojson = {
+            "type": "FeatureCollection",
+            "features": aggregator.read_interpolated_stops(),
+        }
+
+        with open(
+            os.path.join(args.dst, "aggregated_routes.geojson"),
+            mode="w",
+            encoding="utf-8",
+        ) as f:
+            json.dump(aggregated_routes_geojson, f, ensure_ascii=False)
+        with open(
+            os.path.join(args.dst, "aggregated_stops.geojson"),
+            mode="w",
+            encoding="utf-8",
+        ) as f:
+            json.dump(aggregated_stops_geojson, f, ensure_ascii=False)
+    elif args.mode == "parse":
+        routes_geojson = {
+            "type": "FeatureCollection",
+            "features": read_routes(gtfs, ignore_shapes=args.parse_ignoreshapes),
+        }
+        stops_geojson = {
+            "type": "FeatureCollection",
+            "features": read_stops(gtfs, ignore_no_route=args.parse_ignorenoroute),
+        }
+
+        with open(
+            os.path.join(args.dst, "routes.geojson"), mode="w", encoding="utf-8"
+        ) as f:
+            json.dump(routes_geojson, f, ensure_ascii=False)
+        with open(
+            os.path.join(args.dst, "stops.geojson"), mode="w", encoding="utf-8"
+        ) as f:
+            json.dump(stops_geojson, f, ensure_ascii=False)
+    else:
+        raise RuntimeError("mode must be 'parse' or 'aggregate")
+
+
+if __name__ == "__main__":
+    main()

gtfs_parser/aggregate.py

@@ -0,0 +1,452 @@
+from functools import lru_cache
+import datetime
+
+import pandas as pd
+
+
+def latlon_to_str(latlon):
+    return "".join(list(map(lambda coord: str(round(coord, 4)), latlon)))
+
+
+class Aggregator:
+    def __init__(
+        self,
+        gtfs: dict,
+        no_unify_stops=False,
+        delimiter="",
+        max_distance_degree=0.01,
+        yyyymmdd="",
+        begin_time="",
+        end_time="",
+    ):
+        self.gtfs = gtfs
+        self.similar_stops_df = None
+
+        self.__aggregate_similar_stops(
+            delimiter,
+            max_distance_degree,
+            no_unify_stops,
+            yyyymmdd=yyyymmdd,
+            begin_time=begin_time,
+            end_time=end_time,
+        )
+
+    def __aggregate_similar_stops(
+        self,
+        delimiter: str,
+        max_distance_degree: float,
+        no_unify_stops: bool,
+        yyyymmdd="",
+        begin_time="",
+        end_time="",
+    ):
+        """
+        this method occurs side-effect to modify self.gtfs and self.similar_stops_df
+        """
+        # filter stop_times by whether serviced or not
+        if yyyymmdd:
+            trips_filtered_by_day = self.__get_trips_on_a_date(yyyymmdd)
+            self.gtfs["stop_times"] = pd.merge(
+                self.gtfs["stop_times"],
+                trips_filtered_by_day,
+                on="trip_id",
+                how="left",
+            )
+            self.gtfs["stop_times"] = self.gtfs["stop_times"][
+                self.gtfs["stop_times"]["service_flag"] == 1
+            ]
+
+        # time filter
+        if begin_time and end_time:
+            # departure_time is nullable and expressed in "hh:mm:ss" or "h:mm:ss" format.
+            # Hour can be mor than 24.
+            # Therefore, drop null records and convert times to integers.
+            int_dep_times = (
+                self.gtfs["stop_times"].departure_time.str.replace(":", "").astype(int)
+            )
+            self.gtfs["stop_times"] = self.gtfs["stop_times"][
+                self.gtfs["stop_times"].departure_time != ""
+            ][(int_dep_times >= int(begin_time)) & (int_dep_times < int(end_time))]
+
+        if no_unify_stops:
+            # no unifying stops
+            self.gtfs["stops"]["similar_stop_id"] = self.gtfs["stops"]["stop_id"]
+            self.gtfs["stops"]["similar_stop_name"] = self.gtfs["stops"]["stop_name"]
+            self.gtfs["stops"]["similar_stops_centroid"] = self.gtfs["stops"][
+                ["stop_lon", "stop_lat"]
+            ].values.tolist()
+            self.gtfs["stops"]["position_count"] = 1
+            self.similar_stops_df = self.gtfs["stops"][
+                [
+                    "similar_stop_id",
+                    "similar_stop_name",
+                    "similar_stops_centroid",
+                    "position_count",
+                ]
+            ].copy()
+        else:
+            parent_ids = self.gtfs["stops"]["parent_station"].unique()
+            self.gtfs["stops"]["is_parent"] = self.gtfs["stops"]["stop_id"].map(
+                lambda stop_id: 1 if stop_id in parent_ids else 0
+            )
+
+            self.gtfs["stops"][
+                ["similar_stop_id", "similar_stop_name", "similar_stops_centroid"]
+            ] = (
+                self.gtfs["stops"]["stop_id"]
+                .map(
+                    lambda stop_id: self.__get_similar_stop_tuple(
+                        stop_id, delimiter, max_distance_degree
+                    )
+                )
+                .apply(pd.Series)
+            )
+            self.gtfs["stops"]["position_id"] = self.gtfs["stops"][
+                "similar_stops_centroid"
+            ].map(latlon_to_str)
+            self.gtfs["stops"]["unique_id"] = (
+                self.gtfs["stops"]["similar_stop_id"]
+                + self.gtfs["stops"]["position_id"]
+            )
+
+            # sometimes stop_name accidently becomes pd.Series instead of str.
+            self.gtfs["stops"]["similar_stop_name"] = self.gtfs["stops"][
+                "similar_stop_name"
+            ].map(lambda val: val if type(val) == str else val.stop_name)
+
+            position_count = (
+                self.gtfs["stop_times"]
+                .merge(self.gtfs["stops"], on="stop_id", how="left")
+                .groupby("position_id")
+                .size()
+                .to_frame()
+                .reset_index()
+            )
+            position_count.columns = ["position_id", "position_count"]
+
+            self.similar_stops_df = pd.merge(
+                self.gtfs["stops"].drop_duplicates(subset="position_id")[
+                    [
+                        "position_id",
+                        "similar_stop_id",
+                        "similar_stop_name",
+                        "similar_stops_centroid",
+                    ]
+                ],
+                position_count,
+                on="position_id",
+                how="left",
+            )
+
+    @lru_cache(maxsize=None)
+    def __get_similar_stop_tuple(
+        self, stop_id: str, delimiter="", max_distance_degree=0.01
+    ):
+        """
+        With one stop_id, group stops by parent, stop_id, or stop_name and each distance.
+        - parent: if stop has parent_station, the 'centroid' is parent_station lat-lon
+        - stop_id: by delimiter seperate stop_id into prefix and suffix, and group stops having same stop_id-prefix
+        - name and distance: group stops by stop_name, excluding stops are far than max_distance_degree
+
+        Args:
+            stop_id (str): target stop_id
+            max_distance_degree (float, optional): distance limit on grouping, Defaults to 0.01.
+        Returns:
+            str, str, [float, float]: similar_stop_id, similar_stop_name, similar_stops_centroid
+        """
+        stops_df = self.gtfs["stops"].sort_values("stop_id")
+        stop = stops_df[stops_df["stop_id"] == stop_id].iloc[0]
+
+        if stop["is_parent"] == 1:
+            return (
+                stop["stop_id"],
+                stop["stop_name"],
+                [stop["stop_lon"], stop["stop_lat"]],
+            )
+
+        if str(stop["parent_station"]) != "nan":
+            similar_stop_id = stop["parent_station"]
+            similar_stop = stops_df[stops_df["stop_id"] == similar_stop_id]
+            similar_stop_name = similar_stop[["stop_name"]].iloc[0]
+            similar_stop_centroid = (
+                similar_stop[["stop_lon", "stop_lat"]].iloc[0].values.tolist()
+            )
+            return similar_stop_id, similar_stop_name, similar_stop_centroid
+
+        if delimiter:
+            stops_df_id_delimited = self.__get_stops_id_delimited(delimiter)
+            stop_id_prefix = stop_id.rsplit(delimiter, 1)[0]
+            if stop_id_prefix != stop_id:
+                similar_stop_id = stop_id_prefix
+                seperated_only_stops = stops_df_id_delimited[
+                    stops_df_id_delimited["delimited"]
+                ]
+                similar_stops = seperated_only_stops[
+                    seperated_only_stops["stop_id_prefix"] == stop_id_prefix
+                ][
+                    [
+                        "stop_name",
+                        "similar_stops_centroid_lon",
+                        "similar_stops_centroid_lat",
+                    ]
+                ]
+                similar_stop_name = similar_stops[["stop_name"]].iloc[0]
+                similar_stop_centroid = similar_stops[
+                    ["similar_stops_centroid_lon", "similar_stops_centroid_lat"]
+                ].values.tolist()[0]
+                return similar_stop_id, similar_stop_name, similar_stop_centroid
+            else:
+                # when cannot seperate stop_id, grouping by name and distance
+                stops_df = stops_df_id_delimited[~stops_df_id_delimited["delimited"]]
+
+        # grouping by name and distance
+        similar_stops = stops_df[stops_df["stop_name"] == stop["stop_name"]][
+            ["stop_id", "stop_name", "stop_lon", "stop_lat"]
+        ]
+        similar_stops = similar_stops.query(
+            f'(stop_lon - {stop["stop_lon"]}) ** 2 + (stop_lat - {stop["stop_lat"]}) ** 2  < {max_distance_degree ** 2}'
+        )
+        similar_stop_centroid = (
+            similar_stops[["stop_lon", "stop_lat"]].mean().values.tolist()
+        )
+        similar_stop_id = similar_stops["stop_id"].iloc[0]
+        similar_stop_name = stop["stop_name"]
+        return similar_stop_id, similar_stop_name, similar_stop_centroid
+
+    @lru_cache(maxsize=None)
+    def __get_stops_id_delimited(self, delimiter: str):
+        stops_df = self.gtfs.get("stops")[
+            ["stop_id", "stop_name", "stop_lon", "stop_lat", "parent_station"]
+        ].copy()
+        stops_df["stop_id_prefix"] = stops_df["stop_id"].map(
+            lambda stop_id: stop_id.rsplit(delimiter, 1)[0]
+        )
+        stops_df["delimited"] = stops_df["stop_id"] != stops_df["stop_id_prefix"]
+        grouped_by_prefix = (
+            stops_df[["stop_id_prefix", "stop_lon", "stop_lat"]]
+            .groupby("stop_id_prefix")
+            .mean()
+            .reset_index()
+        )
+        grouped_by_prefix.columns = [
+            "stop_id_prefix",
+            "similar_stops_centroid_lon",
+            "similar_stops_centroid_lat",
+        ]
+        stops_df_with_centroid = pd.merge(
+            stops_df, grouped_by_prefix, on="stop_id_prefix", how="left"
+        )
+        return stops_df_with_centroid
+
+    def read_interpolated_stops(self):
+        """
+        Read stops "interpolated" by parent station or stop_id or stop_name and distance.
+        There are many similar stops that are near to each, has same name, or has same prefix in stop_id.
+        In traffic analyzing, it is good for that similar stops to be grouped as same stop.
+        This method group them by some elements, parent, id, name and distance.
+
+        Args:
+            delimiter (str, optional): stop_id delimiter, sample_A, sample_B, then delimiter is '_'. Defaults to ''.
+            max_distance_degree (float, optional): distance limit in grouping by stop_name. Defaults to 0.01.
+
+        Returns:
+            [type]: [description]
+        """
+
+        stop_dicts = self.similar_stops_df[
+            [
+                "similar_stop_id",
+                "similar_stop_name",
+                "similar_stops_centroid",
+                "position_count",
+            ]
+        ].to_dict(orient="records")
+        return [
+            {
+                "type": "Feature",
+                "geometry": {
+                    "type": "Point",
+                    "coordinates": stop["similar_stops_centroid"],
+                },
+                "properties": {
+                    "similar_stop_name": stop["similar_stop_name"],
+                    "similar_stop_id": stop["similar_stop_id"],
+                    "count": stop["position_count"],
+                },
+            }
+            for stop in stop_dicts
+        ]
+
+    def read_route_frequency(self):
+        """
+        By grouped stops, aggregate route frequency.
+        Filtering trips by a date, you can aggregate frequency only route serviced on the date.
+
+        Args:
+            yyyymmdd (str, optional): date, like 20210401. Defaults to ''.
+            begin_time (str, optional): 'hhmmss' <= departure time, like 030000. Defaults to ''.
+            end_time (str, optional): 'hhmmss' > departure time, like 280000. Defaults to ''.
+
+        Returns:
+            [type]: [description]
+        """
+        stop_times_df = (
+            self.gtfs.get("stop_times")[
+                ["stop_id", "trip_id", "stop_sequence", "departure_time"]
+            ]
+            .sort_values(["trip_id", "stop_sequence"])
+            .copy()
+        )
+
+        # join agency info)
+        stop_times_df = pd.merge(
+            stop_times_df,
+            self.gtfs["trips"][["trip_id", "route_id"]],
+            on="trip_id",
+            how="left",
+        )
+        stop_times_df = pd.merge(
+            stop_times_df,
+            self.gtfs["routes"][["route_id", "agency_id"]],
+            on="route_id",
+            how="left",
+        )
+        stop_times_df = pd.merge(
+            stop_times_df,
+            self.gtfs["agency"][["agency_id", "agency_name"]],
+            on="agency_id",
+            how="left",
+        )
+
+        # get prev and next stops_id, stop_name, trip_id
+        stop_times_df = pd.merge(
+            stop_times_df,
+            self.gtfs["stops"][
+                [
+                    "stop_id",
+                    "similar_stop_id",
+                    "similar_stop_name",
+                    "similar_stops_centroid",
+                ]
+            ],
+            on="stop_id",
+            how="left",
+        )
+        stop_times_df["prev_stop_id"] = stop_times_df["similar_stop_id"]
+        stop_times_df["prev_trip_id"] = stop_times_df["trip_id"]
+        stop_times_df["prev_stop_name"] = stop_times_df["similar_stop_name"]
+        stop_times_df["prev_similar_stops_centroid"] = stop_times_df[
+            "similar_stops_centroid"
+        ]
+        stop_times_df["next_stop_id"] = stop_times_df["similar_stop_id"].shift(-1)
+        stop_times_df["next_trip_id"] = stop_times_df["trip_id"].shift(-1)
+        stop_times_df["next_stop_name"] = stop_times_df["similar_stop_name"].shift(-1)
+        stop_times_df["next_similar_stops_centroid"] = stop_times_df[
+            "similar_stops_centroid"
+        ].shift(-1)
+
+        # drop last stops (-> stops has no next stop)
+        stop_times_df = stop_times_df.drop(
+            index=stop_times_df.query("prev_trip_id != next_trip_id").index
+        )
+
+        # define path_id by prev-stops-centroid and next-stops-centroid
+        stop_times_df["path_id"] = (
+            stop_times_df["prev_stop_id"]
+            + stop_times_df["next_stop_id"]
+            + stop_times_df["prev_similar_stops_centroid"].map(latlon_to_str)
+            + stop_times_df["next_similar_stops_centroid"].map(latlon_to_str)
+        )
+
+        # aggregate path-frequency
+        path_frequency = (
+            stop_times_df[["similar_stop_id", "path_id"]]
+            .groupby("path_id")
+            .count()
+            .reset_index()
+        )
+        path_frequency.columns = ["path_id", "path_count"]
+        path_data = pd.merge(
+            path_frequency,
+            stop_times_df.drop_duplicates(subset="path_id"),
+            on="path_id",
+        )
+        path_data_dict = path_data.to_dict(orient="records")
+
+        return [
+            {
+                "type": "Feature",
+                "geometry": {
+                    "type": "LineString",
+                    "coordinates": (
+                        path["prev_similar_stops_centroid"],
+                        path["next_similar_stops_centroid"],
+                    ),
+                },
+                "properties": {
+                    "frequency": path["path_count"],
+                    "prev_stop_id": path["prev_stop_id"],
+                    "prev_stop_name": path["prev_stop_name"],
+                    "next_stop_id": path["next_stop_id"],
+                    "next_stop_name": path["next_stop_name"],
+                    "agency_id": path["agency_id"],
+                    "agency_name": path["agency_name"],
+                },
+            }
+            for path in path_data_dict
+        ]
+
+    def __get_trips_on_a_date(self, yyyymmdd: str):
+        """
+        get trips are on service on a date.
+
+        Args:
+            yyyymmdd (str): [description]
+
+        Returns:
+            [type]: [description]
+        """
+        # sunday, monday, tuesday...
+        day_of_week = (
+            datetime.date(int(yyyymmdd[0:4]), int(yyyymmdd[4:6]), int(yyyymmdd[6:8]))
+            .strftime("%A")
+            .lower()
+        )
+
+        # filter services by day
+        calendar_df = self.gtfs["calendar"].copy()
+        calendar_df = calendar_df.astype({"start_date": int, "end_date": int})
+        calendar_df = calendar_df[calendar_df[day_of_week] == "1"]
+        calendar_df = calendar_df.query(
+            f"start_date <= {int(yyyymmdd)} and {int(yyyymmdd)} <= end_date",
+            engine="python",
+        )
+
+        services_on_a_day = calendar_df[["service_id"]]
+
+        calendar_dates_df = self.gtfs.get("calendar_dates")
+        if calendar_dates_df is not None:
+            filtered = calendar_dates_df[calendar_dates_df["date"] == yyyymmdd][
+                ["service_id", "exception_type"]
+            ]
+            to_be_removed_services = filtered[filtered["exception_type"] == "2"]
+            to_be_appended_services = filtered[filtered["exception_type"] == "1"][
+                ["service_id"]
+            ]
+
+            services_on_a_day = pd.merge(
+                services_on_a_day, to_be_removed_services, on="service_id", how="left"
+            )
+            services_on_a_day = services_on_a_day[
+                services_on_a_day["exception_type"] != "2"
+            ]
+            services_on_a_day = pd.concat([services_on_a_day, to_be_appended_services])
+
+        services_on_a_day["service_flag"] = 1
+
+        # filter trips
+        trips_df = self.gtfs["trips"].copy()
+        trip_service = pd.merge(trips_df, services_on_a_day, on="service_id")
+        trip_service = trip_service[trip_service["service_flag"] == 1]
+
+        return trip_service[["trip_id", "service_flag"]]

gtfs_parser/gtfs.py

@@ -0,0 +1,32 @@
+import glob
+import os
+
+import pandas as pd
+
+
+def GTFS(gtfs_dir: list) -> dict:
+    tables = {}
+    table_files = glob.glob(os.path.join(gtfs_dir, "*.txt"))
+    for table_file in table_files:
+        datatype = os.path.basename(table_file).split(".")[0]
+        with open(table_file, encoding="utf-8_sig") as f:
+            df = pd.read_csv(f, dtype=str)
+            if len(df) == 0:
+                print(f"{datatype}.txt is empty, skipping...")
+                continue
+            tables[datatype] = df
+
+    # cast some numeric columns from str to numeric
+    tables["stops"] = tables["stops"].astype({"stop_lon": float, "stop_lat": float})
+    tables["stop_times"] = tables["stop_times"].astype({"stop_sequence": int})
+    if tables.get("shapes") is not None:
+        tables["shapes"] = tables["shapes"].astype(
+            {"shape_pt_lon": float, "shape_pt_lat": float, "shape_pt_sequence": int}
+        )
+
+    # parent_station is optional column on GTFS but use in this module
+    # when parent_station is not in stops, fill by 'nan' (not NaN)
+    if "parent_station" not in tables.get("stops").columns:
+        tables["stops"]["parent_station"] = "nan"
+
+    return tables

gtfs_parser/parse.py

@@ -0,0 +1,178 @@
+import pandas as pd
+
+def read_stops(gtfs:dict, ignore_no_route=False) -> list:
+    """
+    read stops by stops table
+
+    Args:
+        ignore_no_route (bool, optional): stops unconnected to routes are skipped. Defaults to False.
+
+    Returns:
+        list: [description]
+    """
+
+    # get unique list of route_id related to each stop
+    stop_times_trip_df = pd.merge(
+        gtfs["stop_times"],
+        gtfs["trips"],
+        on="trip_id",
+    )
+    route_ids_on_stops = stop_times_trip_df.groupby("stop_id")["route_id"].unique()
+    route_ids_on_stops.apply(lambda x: x.sort())
+
+    # parse stops to GeoJSON-Features
+    features = []
+    for stop in gtfs["stops"][
+        ["stop_id", "stop_lat", "stop_lon", "stop_name"]
+    ].itertuples():
+        # get all route_id related to the stop
+        route_ids = []
+        if stop.stop_id in route_ids_on_stops:
+            route_ids = route_ids_on_stops.at[stop.stop_id].tolist()
+
+        if len(route_ids) == 0 and ignore_no_route:
+            # skip to output the stop
+            continue
+
+        features.append(
+            {
+                "type": "Feature",
+                "geometry": {
+                    "type": "Point",
+                    "coordinates": (stop.stop_lon, stop.stop_lat),
+                },
+                "properties": {
+                    "stop_id": stop.stop_id,
+                    "stop_name": stop.stop_name,
+                    "route_ids": route_ids,
+                },
+            }
+        )
+    return features
+
+
+def read_routes(gtfs:dict, ignore_shapes=False) -> list:
+    """
+    read routes by shapes or stop_times
+    First, this method try to load shapes and parse it into routes,
+    but shapes is optional table in GTFS. Then is shapes does not exist or no_shapes is True,
+    this parse routes by stop_time, stops, trips, and routes.
+
+    Args:
+        no_shapes (bool, optional): ignore shapes table. Defaults to False.
+
+    Returns:
+        [list]: list of GeoJSON-Feature-dict
+    """
+    features = []
+
+    if gtfs.get("shapes") is None or ignore_shapes:
+        # trip-route-merge:A
+        trips_routes = pd.merge(
+            gtfs["trips"][["trip_id", "route_id"]],
+            gtfs["routes"][
+                ["route_id", "route_long_name", "route_short_name"]
+            ],
+            on="route_id",
+        )
+
+        # stop_times-stops-merge:B
+        stop_times_stop = pd.merge(
+            gtfs["stop_times"][["stop_id", "trip_id", "stop_sequence"]],
+            gtfs.get("stops")[["stop_id", "stop_lon", "stop_lat"]],
+            on="stop_id",
+        )
+
+        # A-B-merge
+        merged = pd.merge(stop_times_stop, trips_routes, on="trip_id")
+        merged["route_concat_name"] = merged["route_long_name"].fillna("") + merged[
+            "route_short_name"
+        ].fillna("")
+
+        # parse routes
+        for route_id in merged["route_id"].unique():
+            route = merged[merged["route_id"] == route_id]
+            trip_id = route["trip_id"].unique()[0]
+            route = route[route["trip_id"] == trip_id].sort_values("stop_sequence")
+            features.append(
+                {
+                    "type": "Feature",
+                    "geometry": {
+                        "type": "LineString",
+                        "coordinates": route[
+                            ["stop_lon", "stop_lat"]
+                        ].values.tolist(),
+                    },
+                    "properties": {
+                        "route_id": str(route_id),
+                        "route_name": route.route_concat_name.values.tolist()[0],
+                    },
+                }
+            )
+    else:
+        # get_shapeids_on route
+        trips_with_shape_df = gtfs["trips"][["route_id", "shape_id"]].dropna(
+            subset=["shape_id"]
+        )
+        shape_ids_on_routes = trips_with_shape_df.groupby("route_id")["shape_id"].unique()
+        shape_ids_on_routes.apply(lambda x: x.sort())
+
+        #get shape coordinate
+        shapes_df = gtfs["shapes"].copy()
+        shapes_df.sort_values("shape_pt_sequence")
+        shapes_df["pt"] = shapes_df[["shape_pt_lon", "shape_pt_lat"]].values.tolist()
+        shape_coords = shapes_df.groupby("shape_id")["pt"].apply(tuple)
+
+        # list-up already loaded shape_ids
+        loaded_shape_ids = set()
+        for route in gtfs.get("routes").itertuples():
+            if shape_ids_on_routes.get(route.route_id) is None:
+                continue
+
+            # get coords by route_id
+            coordinates = []
+            for shape_id in shape_ids_on_routes[route.route_id]:
+                coordinates.append(shape_coords.at[shape_id])
+                loaded_shape_ids.add(shape_id)  # update loaded shape_ids
+
+            #get_route_name_from_tupple
+            if not pd.isna(route.route_short_name):
+                route_name = route.route_short_name
+            elif not pd.isna(route.route_long_name):
+                route_name = route.route_long_name
+            else:
+                ValueError(f'{route} have neither "route_long_name" or "route_short_time".')
+
+            features.append(
+                {
+                    "type": "Feature",
+                    "geometry": {
+                        "type": "MultiLineString",
+                        "coordinates": coordinates,
+                    },
+                    "properties": {
+                        "route_id": str(route.route_id),
+                        "route_name": route_name,
+                    },
+                }
+            )
+
+        # load shapes unloaded yet
+        for shape_id in list(
+            filter(lambda id: id not in loaded_shape_ids, shape_coords.index)
+        ):
+            features.append(
+                {
+                    "type": "Feature",
+                    "geometry": {
+                        "type": "MultiLineString",
+                        "coordinates": [shape_coords.at[shape_id]],
+                    },
+                    "properties": {
+                        "route_id": None,
+                        "route_name": str(shape_id),
+                    },
+                }
+            )
+
+    return features

gtfs_parser-0.1.0.dist-info/LICENSE

@@ -0,0 +1,7 @@
+Copyright 2020 MIERUNE Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

gtfs_parser-0.1.0.dist-info/METADATA

@@ -0,0 +1,67 @@
+Metadata-Version: 2.1
+Name: gtfs-parser
+Version: 0.1.0
+Summary: parse and aggregate GTFS
+Home-page: https://github.com/MIERUNE
+License: MIT
+Author: MIERUNE Inc.
+Requires-Python: >=3.7.1
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Dist: pandas (>=1.3.3)
+Project-URL: Repository, https://github.com/MIERUNE/{project-name}
+Description-Content-Type: text/markdown
+
+# gtfs_parser
+
+## LICENSE
+
+MIT License
+
+## Installation
+
+TODO
+
+## API
+
+TODO
+
+## CLI
+
+```
+usage: __main__.py [-h] [--parse_ignoreshapes] [--parse_ignorenoroute]
+                   [--aggregate_yyyymmdd AGGREGATE_YYYYMMDD]
+                   [--aggregate_nounifystops]
+                   [--aggregate_delimiter AGGREGATE_DELIMITER]
+                   [--aggregate_begintime AGGREGATE_BEGINTIME]
+                   [--aggregate_endtime AGGREGATE_ENDTIME]
+                   mode src dst
+
+positional arguments:
+  mode
+  src
+  dst
+
+optional arguments:
+  -h, --help            show this help message and exit
+  --parse_ignoreshapes
+  --parse_ignorenoroute
+  --aggregate_yyyymmdd AGGREGATE_YYYYMMDD
+  --aggregate_nounifystops
+  --aggregate_delimiter AGGREGATE_DELIMITER
+  --aggregate_begintime AGGREGATE_BEGINTIME
+  --aggregate_endtime AGGREGATE_ENDTIME
+```
+
+### Example
+
+```sh
+python -m gtfs_parser parse gtfs.zip output
+python -m gtfs_parser parse gtfs_dir output --parse_ignoreshapes
+python -m gtfs_parser aggregate gtfs.zip output
+python -m gtfs_parser aggregate gtfs_dir output --aggregate_nounifystops
+```

gtfs_parser-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+gtfs_parser/__init__.py,sha256=AnaeEmVmXQi-AK-U3ZlPedWe-FKi3WXQ-Mj_nWtQLm8,54
+gtfs_parser/__main__.py,sha256=zfE3xyT62Clu1u13q5ESktatcLhaeFOP7md2dVrmjAY,4198
+gtfs_parser/aggregate.py,sha256=WoXZCPYNso0Y1D2xUHcwfYtmrVdWnY_MmetHWM3vSJA,17228
+gtfs_parser/gtfs.py,sha256=rPPEzOPVP3h0wbRzgJutZ5uaX3gDcMlI9Ug7zI9mBqc,1178
+gtfs_parser/parse.py,sha256=9jb32aeu7rMVfl-65KL5cGzAg26ye_CAoKyaEpzk_D4,6135
+gtfs_parser-0.1.0.dist-info/LICENSE,sha256=zLQWXGgmFXub4HDAPU-w8vvRUFSX7tBJszPoYnvN7e0,1051
+gtfs_parser-0.1.0.dist-info/METADATA,sha256=ZFwFJzxzTN9gljr881-5SLqnQOpLWuYXZi7LIu4Link,1732
+gtfs_parser-0.1.0.dist-info/WHEEL,sha256=Zb28QaM1gQi8f4VCBhsUklF61CTlNYfs9YAZn-TOGFk,88
+gtfs_parser-0.1.0.dist-info/entry_points.txt,sha256=UaB49aNvntx4NNQTZ-3G25l2vvghejTcsmhPBXQHxWE,57
+gtfs_parser-0.1.0.dist-info/RECORD,,

gtfs_parser-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 1.6.1
+Root-Is-Purelib: true
+Tag: py3-none-any

gtfs_parser-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+gtfs-parser=gtfs_parser.__main__:main
+