linkbikenet 0.5.0__tar.gz

linkbikenet-0.5.0/PKG-INFO

@@ -0,0 +1,90 @@
+Metadata-Version: 2.4
+Name: linkbikenet
+Version: 0.5.0
+Summary: BikeNetKit Python package to link disconnected bicycle network components
+Author: Manuel Knepper, Michael Szell
+Maintainer-email: Manuel Knepper <manuel.knepper@gmx.net>
+License-Expression: AGPL-3.0-or-later
+Project-URL: Repository, https://github.com/BikeNetKit/LinkBikeNet
+Project-URL: Issues, https://github.com/BikeNetKit/LinkBikeNet/issues
+Keywords: Bicycle network planning,Networks,OpenStreetMap,Urban Planning,Urban Mobility
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Natural Language :: English
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: geopandas>=0.14
+Requires-Dist: matplotlib
+Requires-Dist: osmnx>=1.9.4
+Requires-Dist: geojson
+Requires-Dist: pip
+Requires-Dist: numpy
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Provides-Extra: doc
+Requires-Dist: sphinx; extra == "doc"
+Requires-Dist: momepy; extra == "doc"
+
+# Bike Net Kit / Link Bike Net
+
+[![Docs](https://github.com/BikeNetKit/LinkBikeNet/actions/workflows/docs.yml/badge.svg)](https://bikenetkit.github.io/FixBikeNet/)
+[![Test](https://github.com/BikeNetKit/LinkBikeNet/actions/workflows/test.yml/badge.svg?branch=main)](https://github.com/BikeNetKit/FixBikeNet/actions/workflows/test.yml)
+[![PyPI - Version](https://img.shields.io/pypi/v/linkbikenet)](https://pypi.org/project/LinkBikeNet/)
+[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
+![Human created](https://raw.githubusercontent.com/BikeNetKit/.github/refs/heads/main/profile/_static/badge_humancreated.svg)
+
+The Python package `linkbikenet` finds links between the disconnected components in a city's bicycle network. 
+
+The software downloads and pre-processes data from OpenStreetMap, identifies the components and the needed links and saves the results. The source code builds on (https://github.com/nateraluis/bicycle-network-growth).
+
+
+<!--**Publication**: [https://doi.org/10.1111/gean.12324](https://doi.org/10.1111/gean.12324)-->
+
+
+## Installation
+
+### The easy way
+
+The currently default way to install LinkBikeNet is using pip:
+
+```
+pip install linkbikenet
+```
+
+<!-- > [!IMPORTANT]  
+> As of 2026-07-27, the conda-forge installation is not yet working. We will remove this note once it works.
+
+The best way to install LinkBikeNet is using [`conda`](https://docs.conda.io/projects/conda/en/latest/index.html) and the `conda-forge` channel:
+
+```
+conda install -c conda-forge linkbikenet
+``` -->
+
+<!--If this does not work, consult our [installation docs](https://bikenetkit.github.io/FixBikeNet/installation/).
+
+### Advanced and development installations
+ See our [installation docs](https://bikenetkit.github.io/FixBikeNet/installation/) for details.
+
+## Usage
+
+We provide a minimum working example in two formats:
+
+- Python script ([examples/mwe.py](examples/mwe.py))
+- Jupyter notebook ([examples/mwe.ipynb](examples/mwe.ipynb))
+
+## Docs
+Find more information in our docs: [https://bikenetkit.github.io/FixBikeNet/](https://bikenetkit.github.io/FixBikeNet/)
+-->
+
+## Supported by
+Development of BikeNetKit/LinkBikeNet was supported by the [Innovation Fund Denmark](https://innovationsfonden.dk/en) and the EU HORIZON project [JUST STREETS](https://www.just-streets.eu).
+
+
+[![Innovation Fund Denmark](https://raw.githubusercontent.com/BikeNetKit/.github/refs/heads/main/profile/_static/logo_innovationfund.png)](https://innovationsfonden.dk/en) &emsp;&emsp; [![European Union](https://raw.githubusercontent.com/BikeNetKit/.github/refs/heads/main/profile/_static/logo_eu.png)](https://commission.europa.eu/index_en) &ensp; [![JUST STREETS](https://raw.githubusercontent.com/BikeNetKit/.github/refs/heads/main/profile/_static/logo_juststreets.png)](https://www.just-streets.eu/) 

linkbikenet-0.5.0/README.md

@@ -0,0 +1,56 @@
+# Bike Net Kit / Link Bike Net
+
+[![Docs](https://github.com/BikeNetKit/LinkBikeNet/actions/workflows/docs.yml/badge.svg)](https://bikenetkit.github.io/FixBikeNet/)
+[![Test](https://github.com/BikeNetKit/LinkBikeNet/actions/workflows/test.yml/badge.svg?branch=main)](https://github.com/BikeNetKit/FixBikeNet/actions/workflows/test.yml)
+[![PyPI - Version](https://img.shields.io/pypi/v/linkbikenet)](https://pypi.org/project/LinkBikeNet/)
+[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
+![Human created](https://raw.githubusercontent.com/BikeNetKit/.github/refs/heads/main/profile/_static/badge_humancreated.svg)
+
+The Python package `linkbikenet` finds links between the disconnected components in a city's bicycle network. 
+
+The software downloads and pre-processes data from OpenStreetMap, identifies the components and the needed links and saves the results. The source code builds on (https://github.com/nateraluis/bicycle-network-growth).
+
+
+<!--**Publication**: [https://doi.org/10.1111/gean.12324](https://doi.org/10.1111/gean.12324)-->
+
+
+## Installation
+
+### The easy way
+
+The currently default way to install LinkBikeNet is using pip:
+
+```
+pip install linkbikenet
+```
+
+<!-- > [!IMPORTANT]  
+> As of 2026-07-27, the conda-forge installation is not yet working. We will remove this note once it works.
+
+The best way to install LinkBikeNet is using [`conda`](https://docs.conda.io/projects/conda/en/latest/index.html) and the `conda-forge` channel:
+
+```
+conda install -c conda-forge linkbikenet
+``` -->
+
+<!--If this does not work, consult our [installation docs](https://bikenetkit.github.io/FixBikeNet/installation/).
+
+### Advanced and development installations
+ See our [installation docs](https://bikenetkit.github.io/FixBikeNet/installation/) for details.
+
+## Usage
+
+We provide a minimum working example in two formats:
+
+- Python script ([examples/mwe.py](examples/mwe.py))
+- Jupyter notebook ([examples/mwe.ipynb](examples/mwe.ipynb))
+
+## Docs
+Find more information in our docs: [https://bikenetkit.github.io/FixBikeNet/](https://bikenetkit.github.io/FixBikeNet/)
+-->
+
+## Supported by
+Development of BikeNetKit/LinkBikeNet was supported by the [Innovation Fund Denmark](https://innovationsfonden.dk/en) and the EU HORIZON project [JUST STREETS](https://www.just-streets.eu).
+
+
+[![Innovation Fund Denmark](https://raw.githubusercontent.com/BikeNetKit/.github/refs/heads/main/profile/_static/logo_innovationfund.png)](https://innovationsfonden.dk/en) &emsp;&emsp; [![European Union](https://raw.githubusercontent.com/BikeNetKit/.github/refs/heads/main/profile/_static/logo_eu.png)](https://commission.europa.eu/index_en) &ensp; [![JUST STREETS](https://raw.githubusercontent.com/BikeNetKit/.github/refs/heads/main/profile/_static/logo_juststreets.png)](https://www.just-streets.eu/) 

linkbikenet-0.5.0/linkbikenet/__init__.py

@@ -0,0 +1,12 @@
+import contextlib
+from importlib.metadata import PackageNotFoundError, version
+
+from . import config
+from . import functions
+from linkbikenet.linkbikenet import linkbikenet
+
+__author__ = "MS, MK"
+__author_email__ = "email@domain.com"
+
+with contextlib.suppress(PackageNotFoundError):
+    __version__ = version("linkbikenet")

linkbikenet-0.5.0/linkbikenet/config.py

@@ -0,0 +1,23 @@
+cycleway_bike_infra = [
+    'track'
+    ]
+
+cycleway_right_bike_infra = [
+    'track',
+    'opposite_track'
+]
+
+cycleway_left_bike_infra = [
+    'track',
+    'opposite_track'
+]
+
+cycleway_both_bike_infra = [
+    'track',
+    'opposite_track'
+]
+
+highway_bike_infra = [
+    'cycleway',
+    'living_street'
+]

linkbikenet-0.5.0/linkbikenet/functions.py

@@ -0,0 +1,244 @@
+from . import config
+import geopandas as gpd
+import numpy as np
+from scipy.spatial import cKDTree
+from shapely.geometry import LineString
+
+def map_edges_to_bike_infrastructure(g):
+    """
+    map if edges in graph have bike infrastructure as specified in config.py
+
+    Parameters
+    ----------
+    g :networkx.MultiDiGraph
+        simplified graph representing the street network
+
+    Returns
+    -------
+    g : networkx.MultiDiGraph
+        simplified graph representing the street network, with added binary edge attribute "pbi"
+    """
+
+    # add binary edge attribute "pbi" (protected bike infra: True/False)
+    for edge in g.edges(keys=True):
+        if g.edges[edge].get("cycleway") in config.cycleway_bike_infra:
+            g.edges[edge]["pbi"] = 1
+        elif g.edges[edge].get("cycleway:right") in config.cycleway_right_bike_infra:
+            g.edges[edge]["pbi"] = 1
+        elif g.edges[edge].get("cycleway:left") in config.cycleway_left_bike_infra:
+            g.edges[edge]["pbi"] = 1
+        elif g.edges[edge].get("cycleway:both") in config.cycleway_both_bike_infra:
+            g.edges[edge]["pbi"] = 1
+        elif g.edges[edge].get("highway") in config.highway_bike_infra:
+            g.edges[edge]["pbi"] = 1
+        else:
+            g.edges[edge]["pbi"] = 0
+    return g
+
+def find_edges_to_drop(g):
+    """
+    find parallel edges that have different pbi values, list the ones with pbi=0
+
+    Parameters
+    ----------
+    g : networkx.MultiDiGraph
+        simplified graph representing the street network, with added binary edge attribute "pbi"
+
+    Returns
+    -------
+    edges_to_drop: list
+        unique list of edges to drop-> edges where pbi values differ and pbi value=0 gets dropped
+    """
+    # to find parallel edges, get all u,v tuples for which u,v,w>0 exists:
+    uvs = [edge[:2] for edge in list(g.edges) if edge[2] > 0]  # >0 includes key=1, key=2, ...
+    uvs = list(set(uvs))
+    edges_to_drop = []
+
+    for uv in uvs:
+        # collect all parallel edges for u-v node pair;
+        # account for the fact that edges are directed! uv[::-1]==vu might also be on the list
+        parallel_edges = [edge for edge in list(g.edges) if (edge[:2] == uv) or (edge[:2] == uv[::-1])]
+
+        # get set of PBIs for this u-v parallel edge list
+        pbis = set([g.edges[e]["pbi"] for e in parallel_edges])
+
+        # if we have both pbi==0 and pbi==1,
+        if len(pbis) == 2:
+            # add edges with pbi==0 to edges_to_drop list
+            to_drop = [e for e in parallel_edges if g.edges[e]["pbi"] == 0]
+            edges_to_drop += to_drop
+
+    edges_to_drop = list(set(edges_to_drop))
+    return edges_to_drop
+
+def graph_edges_to_gdf(G):
+    """
+    creates a geodataframe with edges attributes from a simple nx graph
+    Parameters
+    ----------
+    G: networkx.Graph
+        undirected simple graph representing the street network with weighted edges
+
+    Returns
+    -------
+    edges_gdf: geopandas.GeoDataFrame
+        geodataframe with edges from G, including edge attributes
+    """
+    rows = []
+    for u, v, data in G.edges(data=True):
+        # if geometry already exists on the edge, use it
+        if "geometry" in data:
+            geom = data["geometry"]
+        else:
+            # otherwise build a straight line from node coordinates
+            geom = LineString([
+                (G.nodes[u]["x"], G.nodes[u]["y"]),
+                (G.nodes[v]["x"], G.nodes[v]["y"])
+            ])
+        rows.append({
+            "u": u,
+            "v": v,
+            **data,
+            "geometry": geom
+        })
+    edges_gdf = gpd.GeoDataFrame(
+        rows,
+        geometry="geometry",
+        crs=G.graph.get("crs")
+    ).set_index(["u", "v"])
+
+    return edges_gdf
+
+def pair_between_largest_components(wcc):
+    """
+    Find the closest pair of nodes between the two largest components
+    using a KD-tree.
+    Parameters
+    ----------
+    components : list of networkx.Graph
+        Components sorted with the largest first.
+    Returns
+    -------
+    closest_pair : tuple
+        The two nodes that should be connected
+    """
+    G1 = wcc[0]
+    G2 = wcc[1]
+
+    # Coordinates of nodes in the second component
+    nodes2 = list(G2.nodes())
+    coords2 = np.array([
+        (G2.nodes[n]["x"], G2.nodes[n]["y"])
+        for n in nodes2
+    ])
+    # Build KD-tree
+    tree = cKDTree(coords2)
+    closest_pair = None
+    min_dist = np.inf
+
+    # Query the nearest node in G2 for every node in G1
+    for n1, data in G1.nodes(data=True):
+        coord = np.array([data["x"], data["y"]])
+        dist, idx = tree.query(coord)
+        if dist < min_dist:
+            min_dist = dist
+            closest_pair = (n1, nodes2[idx])
+
+    return closest_pair
+
+def pair_between_nearest_components(wcc):
+    """
+    Find the pair of nodes connecting the largest component to the
+    geographically nearest remaining component.
+
+    Parameters
+    ----------
+    wcc : list of nx.Graph
+        Connected components sorted with the largest first.
+
+    Returns
+    -------
+    closest_pair : tuple
+        The two nodes that should be connected
+    """
+
+    largest = wcc[0]
+
+    # Build KD-tree for the largest component
+    largest_nodes = list(largest.nodes())
+    largest_xy = np.array([
+        (largest.nodes[n]["x"], largest.nodes[n]["y"])
+        for n in largest_nodes
+    ])
+    tree = cKDTree(largest_xy)
+
+    closest_pair = None
+    best_distance = np.inf
+    # Compare every remaining component to the largest
+    for comp in wcc[1:]:
+        comp_nodes = list(comp.nodes())
+        comp_xy = np.array([
+            (comp.nodes[n]["x"], comp.nodes[n]["y"])
+            for n in comp_nodes
+        ])
+        distances, indices = tree.query(comp_xy)
+        i = np.argmin(distances)
+        if distances[i] < best_distance:
+            best_distance = distances[i]
+            closest_pair = (
+                largest_nodes[indices[i]],
+                comp_nodes[i]
+            )
+    return closest_pair
+
+def get_correct_edgetuples(edge_gdf, nodelist):
+    """
+    helper function that maps a node list (output of nx.shortest_paths)
+    to the correct set of edge tuples that can be used for INDEXING THE EDGE GDF
+
+    Parameters
+    ----------
+    edge_gdf: geopandas.geodataframe.GeoDataFrame
+        The street network, in a projected coordinate reference system
+    nodelist: list
+        A list of nodes that make up source and targets of edges
+
+    Returns
+    -------
+    edgelist_final: list
+        List of edge tuples that can be used for INDEXING THE EDGE GDF
+    """
+    edgelist_prelim = zip(nodelist, nodelist[1:])
+    edgelist_final = []
+    temp_gdf = edge_gdf.sort_index() # To circumvent PerformanceWarning, see https://stackoverflow.com/questions/54307300/what-causes-indexing-past-lexsort-depth-warning-in-pandas
+    for edge_prelim in edgelist_prelim:
+        if edge_prelim in temp_gdf.index:
+            edgelist_final.append(edge_prelim)
+        else:
+            edgelist_final.append(tuple([edge_prelim[1], edge_prelim[0]]))
+    return edgelist_final
+
+def create_gdf_with_geoms(df, edges):
+    """
+    Parameters
+    ----------
+    df: pandas.DataFrame
+        Dataframe with path nodes and path edges
+    edges: geopandas.GeoDataFrame
+        The street network, in a projected coordinate reference system
+
+    Returns
+    -------
+    gdf: geopandas.GeoDataFrame
+        projected GeoDataFrame with path nodes and path edges and merged geometries
+    """
+    # get geometry by merging all geoms from edge gdf
+    df = df.copy()
+    df["geometry"] = df.edge_list.apply(
+        lambda x: edges.loc[x].geometry.union_all()
+    )
+    # convert edges into a gdf
+    gdf = gpd.GeoDataFrame(df, crs=edges.crs, geometry="geometry")
+    # merge multilinestring into linestring where possible (should be possible everywhere)
+    gdf["geometry"] = gdf.line_merge()
+    return gdf

linkbikenet-0.5.0/linkbikenet/linkbikenet.py

@@ -0,0 +1,157 @@
+# imports
+import os
+import osmnx as ox
+import networkx as nx
+import pandas as pd
+
+from linkbikenet.functions import *
+
+def linkbikenet(
+        city_name,
+        connection_strategy = "largest",
+        proj_crs = "3857",
+        export_data = True,
+        export_file_format = "geojson"
+):
+    """
+    Creates links between components of bicycle networks in cities. How components are connected depends on the connection strategy that was chosen.
+    Parameters
+    ----------
+    city_name : str
+        name of the city that the analysis should be performed on
+    connection_strategy : str, default="largest
+        strategy to use for connecting between components. Default is "largest", second option is "closest"
+    proj_crs : str, default '3857'
+        coordinate reference system that is used to project osm data. Default is '3857' (WGS 84 / Pseudo-Mercator)
+    export_data : bool, optional, default True
+        If set to True, data will be saved to a file. The filename is [slug].gpkg, where slug is a string id made out of city_name
+    export_file_format : str, optional, default "geojson"
+        File format for the data export, relevant if export_data set to True. Default "geojson", also possible "gpkg". If exporting as geojson, generates extra files for street network and city boundary. If exporting as gkpg, these are added all in one file as extra layers.
+    Returns
+    -------
+    gdf: geopandas.GeoDataFrame
+        geodataframe with the proposed links, ordered after strategy chosen
+    """
+    # check if user input is valid
+    if type(city_name) != str:
+        raise TypeError("city_name must be a string")
+    if type(proj_crs) != str:
+        raise TypeError("proj_crs must be a string")
+    if connection_strategy != "largest" and connection_strategy != "closest":
+        raise TypeError("connection_strategy must be 'largest' or 'closest'")
+    if type(export_data) is not bool:
+        raise TypeError("export_data must be a boolean")
+    if export_file_format != "geojson" and export_file_format != "gpkg":
+        raise ValueError("export_file_format must be 'geojson' or 'gpkg'")
+
+    ### downloading and preprocessing data from OSM
+    print("Downloading OSM data..")
+
+    ox.settings.useful_tags_way = ["highway", "cycleway", "cycleway:right", "cycleway:left", "cycleway:both",
+                                   "cyclestreet"]
+
+    # fetch street network from OSM
+    g = ox.graph_from_place(
+        city_name, network_type='all_public', simplify=False, retain_all=True
+    )
+    g = ox.simplify_graph(
+        g,
+        edge_attrs_differ=['cycleway', 'highway', 'cycleway:right', 'cycleway:left', 'cycleway:both'],
+    )
+
+    # project graph for distance calculations
+    g = ox.project_graph(g, to_crs=proj_crs)
+
+    # check which edges have existing bicycle infrastructure and assign "pbi = 1" to them, all other edges get "pbi = 0".
+    g = map_edges_to_bike_infrastructure(g)
+
+    # finding parallel edges and dropping them
+    print("Dropping parallel edges..")
+    edges_to_drop = find_edges_to_drop(g)
+    g.remove_edges_from(edges_to_drop)
+
+    # Capital-G: the Graph() object we will be working with from now on
+    G = nx.Graph(g)
+
+    # build graph that only contains edges with protected bicycle infrastructure
+    edges = [
+        (u, v)
+        for u, v, data in G.edges(data=True)
+        if data.get("pbi") == 1
+    ]
+
+    H = G.edge_subgraph(edges).copy()
+
+    # computing all weakly connected components to find out how many there are. This informs the amount of loops later
+    wcc = [H.subgraph(c).copy() for c in sorted(nx.connected_components(H), key=lambda c: sum(
+        [l[-1] for l in H.subgraph(c).copy().edges.data('length')]), reverse=True)]
+
+    to_iterate = len(wcc) - 1
+    closest_pairs = []
+
+    # check which strategy was chosen and execute the corresponding algorithm
+    print("Calculating links...")
+    if connection_strategy == "largest":
+        for i in range(to_iterate):
+            wcc = [H.subgraph(c).copy() for c in sorted(nx.connected_components(H), key=lambda c: sum(
+                [l[-1] for l in H.subgraph(c).copy().edges.data('length')]), reverse=True)]
+            pair = pair_between_largest_components(wcc)
+            closest_pairs.append(pair)
+            H.add_edge(pair[0], pair[1], length=0)
+
+    elif connection_strategy == "closest":
+        for i in range(to_iterate):
+            wcc = [H.subgraph(c).copy() for c in sorted(nx.connected_components(H), key=lambda c: sum(
+                [l[-1] for l in H.subgraph(c).copy().edges.data('length')]), reverse=True)]
+            pair = pair_between_nearest_components(wcc)
+            closest_pairs.append(pair)
+            H.add_edge(pair[0], pair[1], length=0)
+
+    # find paths between node pairs so we can generate geometries
+    paths = []
+    for pair in closest_pairs:
+        try:
+            path = nx.shortest_path(G, pair[0], pair[1], weight='length')
+        except nx.NetworkXNoPath:
+            continue
+        paths.append(path)
+
+    edges_gdf = graph_edges_to_gdf(G)
+    df = pd.DataFrame()
+    df['nodelist'] = paths
+
+    df['edge_list'] = df.nodelist.apply(lambda x: get_correct_edgetuples(edges_gdf, x))
+    gdf = create_gdf_with_geoms(df, edges_gdf)
+
+    edges_pbi_gdf = edges_gdf[edges_gdf["pbi"] == 1]
+
+    # Generate export data filename
+    if export_data:
+        os.makedirs("./results/", exist_ok=True)
+        export_data_filename = (
+                city_name + "." + export_file_format
+        )
+
+    if export_data:
+        ### save data
+        print("Saving data..")
+        edges_pbi_gdf.drop(["osmid"], axis=1, inplace=True)
+        city_boundary = ox.geocoder.geocode_to_gdf(city_name)
+        city_boundary.to_crs(epsg=proj_crs, inplace=True)
+        # We have meter precision, so rounding to integers is fine. Better would be to
+        # change dtypes to int, but this does not seem possible without manual looping.
+        city_boundary.geometry = city_boundary.geometry.set_precision(grid_size=1)
+        edges_pbi_gdf.geometry = edges_pbi_gdf.geometry.set_precision(grid_size=1)
+        gdf.geometry = gdf.geometry.set_precision(grid_size=1)
+        if export_file_format == "geojson":
+            gdf.to_file("./results/" + export_data_filename, driver="GeoJSON")
+            edges_pbi_gdf.to_file("./results/" + city_name + "-existing_bike_network.geojson", driver="GeoJSON")
+            city_boundary.to_file("./results/" + city_name + "-city_boundary.geojson", driver="GeoJSON")
+        elif export_file_format == "gpkg":
+            gdf.to_file("./results/" + export_data_filename, driver="GPKG", layer="Identified links")
+            edges_pbi_gdf.to_file("./results/" + export_data_filename, driver="GPKG", layer="Existing bike network",
+                                  append=True)
+            city_boundary.to_file("./results/" + export_data_filename, driver="GPKG", layer="City boundary",
+                                  append=True)
+
+    return gdf

linkbikenet-0.5.0/linkbikenet.egg-info/PKG-INFO

@@ -0,0 +1,90 @@
+Metadata-Version: 2.4
+Name: linkbikenet
+Version: 0.5.0
+Summary: BikeNetKit Python package to link disconnected bicycle network components
+Author: Manuel Knepper, Michael Szell
+Maintainer-email: Manuel Knepper <manuel.knepper@gmx.net>
+License-Expression: AGPL-3.0-or-later
+Project-URL: Repository, https://github.com/BikeNetKit/LinkBikeNet
+Project-URL: Issues, https://github.com/BikeNetKit/LinkBikeNet/issues
+Keywords: Bicycle network planning,Networks,OpenStreetMap,Urban Planning,Urban Mobility
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Natural Language :: English
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: geopandas>=0.14
+Requires-Dist: matplotlib
+Requires-Dist: osmnx>=1.9.4
+Requires-Dist: geojson
+Requires-Dist: pip
+Requires-Dist: numpy
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Provides-Extra: doc
+Requires-Dist: sphinx; extra == "doc"
+Requires-Dist: momepy; extra == "doc"
+
+# Bike Net Kit / Link Bike Net
+
+[![Docs](https://github.com/BikeNetKit/LinkBikeNet/actions/workflows/docs.yml/badge.svg)](https://bikenetkit.github.io/FixBikeNet/)
+[![Test](https://github.com/BikeNetKit/LinkBikeNet/actions/workflows/test.yml/badge.svg?branch=main)](https://github.com/BikeNetKit/FixBikeNet/actions/workflows/test.yml)
+[![PyPI - Version](https://img.shields.io/pypi/v/linkbikenet)](https://pypi.org/project/LinkBikeNet/)
+[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
+![Human created](https://raw.githubusercontent.com/BikeNetKit/.github/refs/heads/main/profile/_static/badge_humancreated.svg)
+
+The Python package `linkbikenet` finds links between the disconnected components in a city's bicycle network. 
+
+The software downloads and pre-processes data from OpenStreetMap, identifies the components and the needed links and saves the results. The source code builds on (https://github.com/nateraluis/bicycle-network-growth).
+
+
+<!--**Publication**: [https://doi.org/10.1111/gean.12324](https://doi.org/10.1111/gean.12324)-->
+
+
+## Installation
+
+### The easy way
+
+The currently default way to install LinkBikeNet is using pip:
+
+```
+pip install linkbikenet
+```
+
+<!-- > [!IMPORTANT]  
+> As of 2026-07-27, the conda-forge installation is not yet working. We will remove this note once it works.
+
+The best way to install LinkBikeNet is using [`conda`](https://docs.conda.io/projects/conda/en/latest/index.html) and the `conda-forge` channel:
+
+```
+conda install -c conda-forge linkbikenet
+``` -->
+
+<!--If this does not work, consult our [installation docs](https://bikenetkit.github.io/FixBikeNet/installation/).
+
+### Advanced and development installations
+ See our [installation docs](https://bikenetkit.github.io/FixBikeNet/installation/) for details.
+
+## Usage
+
+We provide a minimum working example in two formats:
+
+- Python script ([examples/mwe.py](examples/mwe.py))
+- Jupyter notebook ([examples/mwe.ipynb](examples/mwe.ipynb))
+
+## Docs
+Find more information in our docs: [https://bikenetkit.github.io/FixBikeNet/](https://bikenetkit.github.io/FixBikeNet/)
+-->
+
+## Supported by
+Development of BikeNetKit/LinkBikeNet was supported by the [Innovation Fund Denmark](https://innovationsfonden.dk/en) and the EU HORIZON project [JUST STREETS](https://www.just-streets.eu).
+
+
+[![Innovation Fund Denmark](https://raw.githubusercontent.com/BikeNetKit/.github/refs/heads/main/profile/_static/logo_innovationfund.png)](https://innovationsfonden.dk/en) &emsp;&emsp; [![European Union](https://raw.githubusercontent.com/BikeNetKit/.github/refs/heads/main/profile/_static/logo_eu.png)](https://commission.europa.eu/index_en) &ensp; [![JUST STREETS](https://raw.githubusercontent.com/BikeNetKit/.github/refs/heads/main/profile/_static/logo_juststreets.png)](https://www.just-streets.eu/) 

linkbikenet-0.5.0/linkbikenet.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+README.md
+pyproject.toml
+setup.py
+linkbikenet/__init__.py
+linkbikenet/config.py
+linkbikenet/functions.py
+linkbikenet/linkbikenet.py
+linkbikenet.egg-info/PKG-INFO
+linkbikenet.egg-info/SOURCES.txt
+linkbikenet.egg-info/dependency_links.txt
+linkbikenet.egg-info/requires.txt
+linkbikenet.egg-info/top_level.txt
+tests/test_functions.py

linkbikenet-0.5.0/linkbikenet.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

linkbikenet-0.5.0/linkbikenet.egg-info/requires.txt

@@ -0,0 +1,13 @@
+geopandas>=0.14
+matplotlib
+osmnx>=1.9.4
+geojson
+pip
+numpy
+
+[doc]
+sphinx
+momepy
+
+[test]
+pytest

linkbikenet-0.5.0/linkbikenet.egg-info/top_level.txt

@@ -0,0 +1 @@
+linkbikenet

linkbikenet-0.5.0/pyproject.toml

@@ -0,0 +1,59 @@
+[build-system]
+requires = ["setuptools >= 77.0.3"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "linkbikenet"
+version = "0.5.0"
+authors = [
+  { name = "Manuel Knepper" },
+  { name = "Michael Szell" },
+]
+maintainers = [{ name = "Manuel Knepper", email = "manuel.knepper@gmx.net" }]
+license = "AGPL-3.0-or-later"
+readme = "README.md"
+description = "BikeNetKit Python package to link disconnected bicycle network components"
+keywords = ["Bicycle network planning", "Networks", "OpenStreetMap", "Urban Planning", "Urban Mobility"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Science/Research",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Natural Language :: English",
+]
+requires-python = ">=3.10"
+dependencies = [
+    "geopandas>=0.14",
+    "matplotlib",
+    "osmnx>=1.9.4",
+    "geojson",
+    "pip",
+    "numpy",
+]
+
+[project.urls]
+Repository = "https://github.com/BikeNetKit/LinkBikeNet"
+Issues = "https://github.com/BikeNetKit/LinkBikeNet/issues"
+
+[project.optional-dependencies]
+test = ["pytest"]
+doc = ["sphinx", "momepy"]
+
+[tool.ruff.lint.extend-per-file-ignores]
+"__init__.py" = ["F401"]  # "Imported but unused: happens with packages
+
+[tool.setuptools.packages.find]
+exclude = [
+    "examples*",
+    "tests*",
+    "results",
+    "docs*",
+    "data*",
+    "scripts*",
+]
+namespaces = false

linkbikenet-0.5.0/setup.cfg

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

linkbikenet-0.5.0/setup.py

@@ -0,0 +1,5 @@
+from setuptools import find_packages, setup
+setup(
+    name="linkbikenet",
+    packages=find_packages(),
+)

linkbikenet-0.5.0/tests/test_functions.py

@@ -0,0 +1,38 @@
+import networkx as nx
+import pytest
+from linkbikenet.functions import *
+
+@pytest.fixture
+def create_test_components_largest():
+    G = nx.Graph()
+    G.add_nodes_from([(1, {"x": 1, "y": 2}), (2, {"x": 5, "y": 6}), (3, {"x": 7, "y": 8}), (4, {"x": 10, "y": 10}), (5, {"x": 11, "y": 11}), (6, {"x": 15, "y": 20})])
+    G.add_edges_from([(1, 2, {'length': 5}), (2, 3, {'length': 2}), (1, 3, {'length': 7}), (4, 5, {'length': 1})])
+    wcc = [G.subgraph(c).copy() for c in sorted(nx.connected_components(G), key=lambda c: sum(
+        [l[-1] for l in G.subgraph(c).copy().edges.data('length')]), reverse=True)]
+    return wcc
+
+@pytest.fixture
+def create_validation_pair_largest():
+    pair = 3,4
+    return pair
+
+def test_pair_between_largest_components(create_test_components_largest, create_validation_pair_largest):
+    assert pair_between_largest_components(create_test_components_largest) == create_validation_pair_largest
+
+
+@pytest.fixture
+def create_test_components_nearest():
+    G = nx.Graph()
+    G.add_nodes_from([(1, {"x": 1, "y": 2}), (2, {"x": 5, "y": 6}), (3, {"x": 7, "y": 8}), (4, {"x": 30, "y": 30}), (5, {"x": 31, "y": 31}), (6, {"x": 10, "y": 10})])
+    G.add_edges_from([(1, 2, {'length': 5}), (2, 3, {'length': 2}), (1, 3, {'length': 7}), (4, 5, {'length': 1})])
+    wcc = [G.subgraph(c).copy() for c in sorted(nx.connected_components(G), key=lambda c: sum(
+        [l[-1] for l in G.subgraph(c).copy().edges.data('length')]), reverse=True)]
+    return wcc
+
+@pytest.fixture
+def create_validation_pair_nearest():
+    pair = 3,6
+    return pair
+
+def test_pair_between_nearest_components(create_test_components_nearest, create_validation_pair_nearest):
+    assert pair_between_nearest_components(create_test_components_nearest) == create_validation_pair_nearest