pyquity 1.0.0__tar.gz

pyquity-1.0.0/PKG-INFO

@@ -0,0 +1,28 @@
+Metadata-Version: 2.4
+Name: pyquity
+Version: 1.0.0
+Summary: PyQuity is a compact Python toolkit for building and analyzing multimodal street and transit networks with a focus on accessibility and distributive equity
+Author: pannawatr
+License: MIT
+Project-URL: Homepage, https://github.com/pannawatr/pyquity
+Classifier: Programming Language :: Python :: 3.9
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: osmnx>=2.0.0
+Requires-Dist: geopandas>=1.0.0
+Requires-Dist: shapely>=2.0.0
+Requires-Dist: networkx>=3.2
+Requires-Dist: numpy>=1.23
+Requires-Dist: pandas>=2.0
+Requires-Dist: scipy>=1.10
+Requires-Dist: matplotlib>=3.7
+Requires-Dist: pyproj>=3.5
+
+## PyQuity
+PyQuity is a compact Python toolkit for building and analyzing multimodal street and transit networks with a focus on accessibility and distributive equity. Quickly generate graphs and grids, attach POIs/GTFS, compute route-based accessibility, and evaluate equity (sufficientarianism, egalitarianism) with seamless GeoPandas/NetworkX integration.
+
+## Installation
+PyQuity can be installed via PyPI:
+```bash
+pip install pyquity
+```

pyquity-1.0.0/README.md

@@ -0,0 +1,8 @@
+## PyQuity
+PyQuity is a compact Python toolkit for building and analyzing multimodal street and transit networks with a focus on accessibility and distributive equity. Quickly generate graphs and grids, attach POIs/GTFS, compute route-based accessibility, and evaluate equity (sufficientarianism, egalitarianism) with seamless GeoPandas/NetworkX integration.
+
+## Installation
+PyQuity can be installed via PyPI:
+```bash
+pip install pyquity
+```

pyquity-1.0.0/pyproject.toml

@@ -0,0 +1,17 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pyquity"
+version = "1.0.0"
+description = "PyQuity is a compact Python toolkit for building and analyzing multimodal street and transit networks with a focus on accessibility and distributive equity"
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+authors = [{ name="pannawatr"}]
+classifiers = ["Programming Language :: Python :: 3.9"]
+dependencies = ["osmnx>=2.0.0", "geopandas>=1.0.0", "shapely>=2.0.0", "networkx>=3.2", "numpy>=1.23", "pandas>=2.0", "scipy>=1.10", "matplotlib>=3.7", "pyproj>=3.5"]
+
+[project.urls]
+Homepage = "https://github.com/pannawatr/pyquity"

pyquity-1.0.0/pyquity/__init__.py

@@ -0,0 +1,4 @@
+from .plot import *
+from .graph import *
+from .utils import *
+from .equity import *

pyquity-1.0.0/pyquity/equity.py

@@ -0,0 +1,125 @@
+import pyquity
+import osmnx as ox
+import numpy as np
+import networkx as nx
+
+class Equity:
+    def __init__(self, G_walk, G_micromobility, grid, amenity):
+        self.G_walk = G_walk
+        self.G_micromobility = G_micromobility
+        self.grid = grid
+        self.amenity = amenity
+
+        # Ensure amenities are point geometries
+        if not all(self.amenity.geometry.geom_type == "Point"):
+            self.amenity["geometry"] = self.amenity.geometry.centroid
+
+    def sufficientarianism(self, served_time: int = 15):
+        # Map amenities to nearest nodes and map grid centroids to nearest nodes with micromobility
+        self.micromobility_amenity_nodes = ox.distance.nearest_nodes(self.G_micromobility, self.amenity.geometry.centroid.x.values, self.amenity.geometry.centroid.y.values)
+        self.micromobility_grid_nodes = ox.distance.nearest_nodes(self.G_micromobility, self.grid.geometry.centroid.x.values, self.grid.geometry.centroid.y.values)
+
+        # Map amenities to nearest nodes and map grid centroids to nearest nodes with walk
+        self.walk_amenity_nodes = ox.distance.nearest_nodes(self.G_walk, self.amenity.geometry.centroid.x.values, self.amenity.geometry.centroid.y.values)
+        self.walk_grid_nodes = ox.distance.nearest_nodes(self.G_walk, self.grid.geometry.centroid.x.values, self.grid.geometry.centroid.y.values)
+
+        # Assign the nearest network node ID to each grid cell based on micromobility count
+        self.grid["grid_id"] = np.where(self.grid['micromobility_count'] > 0, self.micromobility_grid_nodes, self.walk_grid_nodes)
+        self.grid["served"] = 0
+
+        # Iterate over each grid row to calculate serviceability
+        for idx, grid_row in self.grid.iterrows():
+            grid_node = grid_row['grid_id']
+
+            # Check if the grid has micromobility services or not and select the appropriate graph and nodes
+            if grid_row['micromobility_count'] > 0:
+                G_current = self.G_micromobility
+                amenity_nodes = self.micromobility_amenity_nodes
+            else:
+                G_current = self.G_walk
+                amenity_nodes = self.walk_amenity_nodes
+
+            # Compute shortest paths from the selected grid node to all other nodes
+            paths = nx.single_source_dijkstra_path(G_current, source=grid_node, weight='length', cutoff=served_time * (22 * 1000 / 3600) * 60)
+
+            # Iterate over each amenity node to check if it's reachable within the time limit
+            for amenity_node in amenity_nodes:
+                # If this grid node is already served, no need to check further amenities
+                if self.grid.loc[self.grid["grid_id"] == grid_node, "served"].values[0] == 1:
+                    break
+
+                # Check if the amenity is reachable in the computed paths
+                if amenity_node in paths:
+                    try:
+                        # Get the route as a list of node IDs and calculate distance and travel time using pyquity
+                        route = [int(node) for node in paths[int(amenity_node)]]
+                        distance, travel_time = pyquity.route_length_by_mode(G_current, route)
+                        total_time = sum(travel_time.values())
+
+                        # If total travel time is within the served_time threshold
+                        if total_time <= served_time:
+                            self.grid.loc[self.grid["grid_id"] == grid_node, "served"] = 1
+                            break
+                    except:
+                        continue
+
+        # Return GeoDataFrame of grid
+        return self.grid
+
+    def egalitarianism(self, grid):
+        # Extract 'served' data and compute Lorenz curve and Gini coefficient
+        served_data = grid['served'].values
+
+        # Calculate Lorenz curve and Gini coefficient
+        lorenz_curve = self._lorenz_curve(served_data)
+        gini_index = self._gini_coefficient(lorenz_curve)
+        return gini_index, lorenz_curve
+
+    def _lorenz_curve(self, data):
+        # Calculate Lorenz curve
+        sorted_data = np.sort(data)
+        lorenz_curve = np.insert((np.cumsum(sorted_data) / np.sum(sorted_data)), 0, 0)
+        return lorenz_curve
+
+    def _gini_coefficient(self, lorenz_curve):
+        # Calculate Gini coefficient from Lorenz curve
+        gini_index = ((0.5 - (np.sum(lorenz_curve) / (len(lorenz_curve) - 1))) * 2)
+        return gini_index
+    
+    def utilitarianism(self, served_time, network_type: str='walk'):
+        # Initialize a column to track how many amenities serve each grid cell
+        self.grid["count_served"] = 0
+
+        # Select the correct network, nodes, and grid ID mapping depending on travel mode
+        if network_type == 'walk':
+            self.grid['grid_id'] = self.walk_grid_nodes
+            G_current = self.G_walk
+            amenity_nodes = self.walk_amenity_nodes
+        elif network_type == 'bike':
+            self.grid['grid_id'] = self.micromobility_grid_nodes
+            G_current = self.G_micromobility
+            amenity_nodes = self.micromobility_amenity_nodes
+
+        # Iterate over each grid cell
+        for idx, grid_row in self.grid.iterrows():
+            grid_node = grid_row['grid_id']
+
+            # Compute shortest paths (Dijkstra) from the grid node to all reachable nodes
+            paths = nx.single_source_dijkstra_path(G_current, source=grid_node, weight='length', cutoff=served_time * (22 * 1000 / 3600) * 60)
+
+            # Check each amenity node to see if it is reachable
+            for amenity_node in amenity_nodes:
+                if amenity_node in paths:
+                    try:
+                        # Get the route as a list of node IDs and calculate distance and travel time using pyquity
+                        route = [int(node) for node in paths[int(amenity_node)]]
+                        distance, travel_time = pyquity.route_length_by_mode(G_current, route)
+                        total_time = sum(travel_time.values())
+
+                        # If total travel time is within the served_time threshold
+                        if total_time <= served_time:
+                            self.grid.loc[self.grid["grid_id"] == grid_node, "count_served"] += 1
+                    except:
+                        continue
+        # Return the updated grid with count_served values
+        return self.grid

pyquity-1.0.0/pyquity/graph.py

@@ -0,0 +1,215 @@
+import osmnx as ox
+import numpy as np
+import pandas as pd
+import networkx as nx
+import geopandas as gpd
+import partridge as ptg
+from shapely import ops as sops
+from scipy.spatial import cKDTree
+from geopy.distance import distance
+from shapely.geometry import Point, Polygon, LineString
+
+def multimodal_graph(G_osm: nx.MultiDiGraph, G_gtfs: nx.MultiDiGraph, k: int=1):
+    # Relabel GTFS nodes with unique integers to avoid ID collisions with OSM graph
+    G_gtfs = nx.relabel_nodes(G_gtfs, {node: i for i, node in enumerate(G_gtfs.nodes())}, copy=True)
+
+    # Get OSM node coordinates
+    osm_nodes, _ = ox.graph_to_gdfs(G_osm)
+    osm_coords = np.array(list(zip(osm_nodes["y"], osm_nodes["x"])))
+
+    # Get GTFS stop coordinates
+    gtfs_nodes = [(n, data["x"], data["y"]) for n, data in G_gtfs.nodes(data=True)]
+    gtfs_coords = np.array([(y, x) for _, x, y in gtfs_nodes])
+
+    # Build KD-tree for nearest-neighbor search
+    tree = cKDTree(osm_coords)
+
+     # Combine OSM and GTFS graphs
+    G = nx.compose(G_osm, G_gtfs)
+
+    # Connect each GTFS stop to its nearest OSM node(s)
+    for (stop_id, x, y), (dist, idx) in zip(gtfs_nodes, zip(*tree.query(gtfs_coords, k=k))):
+        osm_node = osm_nodes.iloc[idx].name
+        point_u = (y, x)
+        point_v = (osm_nodes.iloc[idx].y, osm_nodes.iloc[idx].x)
+
+        length = distance(point_u, point_v).m
+        G.add_edge(stop_id, osm_node, mode="transfer", length=length)
+        G.add_edge(osm_node, stop_id, mode="transfer", length=length)
+
+    # Return the graph
+    G.graph["crs"] = "EPSG:4326"
+    return G
+
+def graph_from_gtfs(gtfs: str) -> nx.MultiDiGraph:
+    # Read available service dates
+    date = ptg.read_service_ids_by_date(gtfs)
+    if not date:
+        raise ValueError("No valid service date found in GTFS.")
+
+    # Select the first available service date
+    target_date = sorted(date.keys())[0]
+    feed = ptg.load_geo_feed(gtfs, view={'trips.txt': {'service_id': date[target_date]}, 'shapes.txt': {}})
+
+    # Extract GTFS tables
+    stop_times = feed.stop_times
+    trips = feed.trips
+    stops = feed.stops
+    shapes = feed.shapes
+
+    # Initialize a multidirected graph
+    G = nx.MultiDiGraph()
+
+    # Add each transit stop as a node in the graph
+    for _, row in stops.iterrows():
+        G.add_node(row['stop_id'], name=row['stop_name'], x=row['geometry'].x, y=row['geometry'].y)
+
+    # Ensure all shape geometries are LineString
+    shapes['geometry'] = shapes['geometry'].apply( lambda geoms: geoms if isinstance(geoms, LineString) else LineString(geoms))
+    shapes = shapes.set_index('shape_id').geometry
+
+    # Create edges from trips, grouped by shape_id
+    for shape_id, group in trips.groupby('shape_id'):
+        if shape_id not in shapes.index or shapes[shape_id] is None:
+            continue
+        geoms = shapes[shape_id]
+
+        # Take the first trip in the group as representative
+        trip_id = group.iloc[0]['trip_id']
+
+        # Get the stop sequence for the trip
+        stop_sequence = stop_times[stop_times.trip_id == trip_id].sort_values('stop_sequence')
+        stop_id = stop_sequence['stop_id'].tolist()
+
+        # Add edges between consecutive stops
+        for i in range(len(stop_id) - 1):
+            u, v = stop_id[i], stop_id[i + 1]
+
+            # Retrieve the coordinates of the two stops
+            point_u = stops.loc[stops.stop_id == u, 'geometry'].values[0]
+            point_v = stops.loc[stops.stop_id == v, 'geometry'].values[0]
+            length = distance((point_u.y, point_u.x), (point_v.y, point_v.x)).m
+
+            # Get geometry for the edge
+            try:
+                orig = geoms.project(point_u)
+                dest = geoms.project(point_v)
+                low, high = sorted([orig, dest])
+                segment = sops.substring(geoms, low, high, normalized=False)
+                if segment.is_empty or segment.length == 0:
+                    segment = LineString([pu, pv])
+            except:
+                LineString([point_u, point_v])
+
+            # Add edge only if it does not already exist, and add geometry
+            if not G.has_edge(u, v, key=trip_id):
+                G.add_edge(
+                    u, v,
+                    trip_id=trip_id,
+                    geometry=segment,
+                    length=length,
+                    mode='transit'
+                )
+
+    # Return the graph
+    G.graph['crs'] = "EPSG:4326"
+    return G
+
+def graph_from_place(place_name: str, network_type: str):
+    # Return a graph from OSMnx
+    G = ox.graph_from_place(place_name, network_type=network_type)
+
+    # Add mode to each edge in the graph
+    for u, v, k, data in G.edges(keys=True, data=True):
+        data['mode'] = network_type
+
+    return G
+
+def grid_from_place(place_name: str, grid_size: float) -> gpd.GeoDataFrame:
+    # Read boundary from OpenStreetMap(OSM)
+    boundary = ox.geocode_to_gdf(place_name)
+    boundary = boundary.to_crs(epsg=3857) # Project boundary to Web Mercator(EPSG:3857) from default(EPSG:4326)
+    minx, miny, maxx, maxy = boundary.total_bounds
+
+    # Initialize a grid and Add into GeoDataFrame 
+    polygons = [Polygon([(x, y), (x + grid_size, y), (x + grid_size, y + grid_size), (x, y + grid_size)]) for x in np.arange(minx, maxx, grid_size) for y in np.arange(miny, maxy, grid_size)]
+    gdf = gpd.GeoDataFrame(geometry=polygons, crs=boundary.crs)
+    grid = gpd.overlay(gdf, boundary, how='intersection')
+
+    # Reproject the grid back to WGS84 (EPSG:4326) and return it
+    return grid.to_crs(epsg=4326)
+
+def amenity_from_place(place_name: str, amenity_type: str) -> gpd.GeoDataFrame:
+    # Define categories of amenities with their corresponding OSM tags
+    amenity = {
+        'education': ['college', 'dancing_school', 'driving_school', 'first_aid_school', 'kindergarten', 'language_school', 'library', 'surf_school', 'toy_library', 'research_institute', 'training', 'music_school', 'school', 'traffic_park', 'university'],
+        'financial': ['atm', 'bank', 'bureau_de_change'],
+        'healthcare': ['baby_hatch', 'clinic', 'dentist', 'doctors', 'hospital', 'nursing_home', 'pharmacy', 'social_facility', 'veterinary' ]
+        }
+    
+    # Get the list of amenity tags for the selected amenity type
+    amenity = amenity[amenity_type.lower()]
+
+    # Query OpenStreetMap for features matching the selected amenity tags within the specified place
+    gdf = ox.features.features_from_place(place_name, tags={'amenity': amenity})
+
+    # Return the resulting GeoDataFrame
+    return gdf
+
+def amenity_in_grid(grid: gpd.GeoDataFrame, amenity: gpd.GeoDataFrame) -> gpd.GeoDataFrame:
+    # Reproject amenities to Web Mercator (EPSG:3857) and convert geometry to centroids (points)
+    amenity = amenity.to_crs(epsg=3857)
+    amenity['geometry'] = amenity.geometry.centroid
+
+    # Reproject grid to Web Mercator
+    grid = grid.to_crs(epsg=3857)
+
+    # Ensure both layers have the same CRS before spatial operations
+    if grid.crs == amenity.crs:
+        grid['amenity_count'] = 0 # Initialize 'amenity_count' column in the grid
+
+        # Count amenities within each grid cell
+        for index, x in grid.iterrows():
+            for _, y in amenity.iterrows():
+                if x.geometry.contains(y.geometry): 
+                    grid.at[index, 'amenity_count'] += 1
+    
+    # Reproject the grid back to WGS84 (EPSG:4326) and return it
+    return grid.to_crs(epsg=4326)
+
+def micromobility_in_grid(grid: gpd.GeoDataFrame, amenity: gpd.GeoDataFrame, micromobility_size: int, alpha: float = 1.0) -> gpd.GeoDataFrame:
+    # If amenity counts are not present, initialize counts and return zeros
+    if 'amenity_count' not in grid.columns:
+        grid['micromobility_count'] = 0
+        return grid
+
+    # Prepare counts and ensure numeric
+    counts = grid['amenity_count'].fillna(0).astype(float)
+
+    # Compute weights: raise counts to the power of alpha to control emphasis
+    weights = counts ** alpha
+
+    total_weight = weights.sum()
+    # If there are no amenities at all, assign zero everywhere
+    if total_weight == 0 or micromobility_size <= 0:
+        grid['micromobility_count'] = 0
+        return grid
+
+    # Normalize weights to form a probability distribution
+    probs = weights / total_weight
+
+    # Expected (real-valued) allocation per cell
+    expected = probs * micromobility_size
+
+    # Assign integer allocations by flooring expected values
+    grid['micromobility_count'] = np.floor(expected).astype(int)
+
+    # Distribute the remaining units by largest fractional parts (prioritizes high-amenity cells)
+    remainder = int(micromobility_size - grid['micromobility_count'].sum())
+    if remainder > 0:
+        fractional = expected - np.floor(expected)
+        indices = fractional.sort_values(ascending=False).index[:remainder]
+        for idx in indices:
+            grid.at[idx, 'micromobility_count'] += 1
+
+    return grid

pyquity-1.0.0/pyquity/plot.py

@@ -0,0 +1,40 @@
+import osmnx as ox
+import networkx as nx
+import matplotlib.pyplot as plt
+
+def plot_grid(grid, ax=None, linewidth: float=0.5, figsize: tuple[float, float]=(10, 10), legend: bool=True, show: bool=True, **kwargs):
+    # Create a new figure and axes if none provided
+    if ax is None:
+        fig, ax = plt.subplots(figsize=figsize)
+    
+    # Plot the GeoDataFrame on the axes
+    ax = grid.plot(ax=ax, edgecolor='k', color='white', linewidth=linewidth, legend=legend, **kwargs)
+
+    # Display the plot if requested
+    if show:
+        plt.show()
+
+    return ax
+
+def plot_graph_route_by_mode(G, route, ax=None, show: bool=True, legend: bool=True, node_size: float=0, edge_color: str='lightgray'):
+    mode_colors = {'walk': 'green', 'transit': 'red', 'bike': 'blue', 'transfer': 'yellow'}
+
+    # Convert the route into a GeoDataFrame (one row per edge) using OSMnx
+    gdf = ox.routing.route_to_gdf(G, route)
+
+    # Create a new figure and axes if none provided
+    if ax is None:
+        fig, ax = ox.plot_graph(G, show=False, close=False, node_size=node_size, edge_color=edge_color)
+    
+    # Plot each segment of the route, color-coded by its mode
+    for mode, data in gdf.groupby('mode'):
+        color = mode_colors.get(mode, 'gray')
+        data.plot(ax=ax, linewidth=3.5, edgecolor=color, label=mode)
+
+    # Show the legend and plot if requested
+    if show:
+        plt.show()
+    if legend:
+        ax.legend()
+
+    return ax

pyquity-1.0.0/pyquity/utils.py

@@ -0,0 +1,28 @@
+import osmnx as ox
+import geopandas as gpd
+
+def route_length_by_mode(G, route, verbose: bool = True):
+    # Convert route to GeoDataFrame and project to metric CRS
+    gdf = ox.routing.route_to_gdf(G, route)
+    gdf = gdf.to_crs(epsg=3857)
+
+    # Calculate total distance by mode (km)
+    distance = gdf.groupby('mode')['length'].sum() / 1000
+    distance = round(distance, 2).to_dict()
+
+    # Average speeds by mode (m/s)
+    speed = {
+        'walk': 5 * 1000 / 3600,
+        'bike': 20 * 1000 / 3600,
+        'transfer': 5 * 1000 / 3600,
+        'transit': 22 * 1000 / 3600
+    }
+
+    # Calculate travel time by mode (minutes)
+    travel_time = {}
+    for mode, dist_km in distance.items():
+        if mode in speed:
+            time_sec = (dist_km * 1000) / speed[mode]
+            travel_time[mode] = round(time_sec / 60, 2)
+
+    return distance, travel_time

pyquity-1.0.0/pyquity.egg-info/PKG-INFO

@@ -0,0 +1,28 @@
+Metadata-Version: 2.4
+Name: pyquity
+Version: 1.0.0
+Summary: PyQuity is a compact Python toolkit for building and analyzing multimodal street and transit networks with a focus on accessibility and distributive equity
+Author: pannawatr
+License: MIT
+Project-URL: Homepage, https://github.com/pannawatr/pyquity
+Classifier: Programming Language :: Python :: 3.9
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: osmnx>=2.0.0
+Requires-Dist: geopandas>=1.0.0
+Requires-Dist: shapely>=2.0.0
+Requires-Dist: networkx>=3.2
+Requires-Dist: numpy>=1.23
+Requires-Dist: pandas>=2.0
+Requires-Dist: scipy>=1.10
+Requires-Dist: matplotlib>=3.7
+Requires-Dist: pyproj>=3.5
+
+## PyQuity
+PyQuity is a compact Python toolkit for building and analyzing multimodal street and transit networks with a focus on accessibility and distributive equity. Quickly generate graphs and grids, attach POIs/GTFS, compute route-based accessibility, and evaluate equity (sufficientarianism, egalitarianism) with seamless GeoPandas/NetworkX integration.
+
+## Installation
+PyQuity can be installed via PyPI:
+```bash
+pip install pyquity
+```

pyquity-1.0.0/pyquity.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+README.md
+pyproject.toml
+pyquity/__init__.py
+pyquity/equity.py
+pyquity/graph.py
+pyquity/plot.py
+pyquity/utils.py
+pyquity.egg-info/PKG-INFO
+pyquity.egg-info/SOURCES.txt
+pyquity.egg-info/dependency_links.txt
+pyquity.egg-info/requires.txt
+pyquity.egg-info/top_level.txt

pyquity-1.0.0/pyquity.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pyquity-1.0.0/pyquity.egg-info/requires.txt

@@ -0,0 +1,9 @@
+osmnx>=2.0.0
+geopandas>=1.0.0
+shapely>=2.0.0
+networkx>=3.2
+numpy>=1.23
+pandas>=2.0
+scipy>=1.10
+matplotlib>=3.7
+pyproj>=3.5

pyquity-1.0.0/pyquity.egg-info/top_level.txt

@@ -0,0 +1 @@
+pyquity

pyquity-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+