iduedu 0.1.0__tar.gz

iduedu-0.1.0/PKG-INFO

@@ -0,0 +1,59 @@
+Metadata-Version: 2.1
+Name: iduedu
+Version: 0.1.0
+Summary: IduEdu is a Python package for the creation and manipulation of complex city networks from OpenStreetMap.
+License: BSD-3-Clause
+Author: Danila
+Author-email: 63115678+DDonnyy@users.noreply.github.com
+Requires-Python: >=3.10,<3.13
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: geopandas (>=0.14.4,<0.15.0)
+Requires-Dist: loguru (>=0.7.2,<0.8.0)
+Requires-Dist: networkit (>=11.0,<12.0)
+Requires-Dist: networkx (>=3.3,<4.0)
+Requires-Dist: numpy (>=1.23.5,<2.0.0)
+Requires-Dist: osm2geojson (>=0.2.4,<0.3.0)
+Requires-Dist: osmnx (>=1.9.4,<2.0.0)
+Requires-Dist: pandas (>=2.2.0,<3.0.0)
+Requires-Dist: pydantic (>=2.6.1,<3.0.0)
+Requires-Dist: scipy (>=1.13.1,<2.0.0)
+Requires-Dist: tqdm (>=4.66.2,<5.0.0)
+Description-Content-Type: text/markdown
+
+# IduEdu
+
+[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
+
+### IduEdu is an open-source Python library for the creation and manipulation of complex city networks from OpenStreetMap.
+
+## Features and how to use
+
+1. **[Graphs from OSM/Polygon/Name](./examples/get_any_graph.ipynb)** - Functions for building a graph of roads,
+   pedestrians and public transport based on OpenStreetMap (OSM), as well as creating an intermodal (public transport +
+   pedestrians) graph.
+2. **[Adjacency matrix](./examples/calc_adj_matrix.ipynb)** - Calculate adjacency matrix based on the provided graph and
+   edge weight type (_time_min_ or _length_meter_). 
+
+## Installation
+
+**IduEdu** can be installed with ``pip``:
+
+```
+pip install IduEdu
+```
+
+### Configuration changes
+
+```python
+from iduedu import config
+
+config.set_timeout(10)  # Timeout for overpass queries
+config.change_logger_lvl('INFO')  # To mute all debug msgs
+config.set_enable_tqdm(False)  # To mute all tqdm's progress bars
+config.set_overpass_url('http://your.overpass-api.de/interpreter/URL')
+```
+

iduedu-0.1.0/README.md

@@ -0,0 +1,32 @@
+# IduEdu
+
+[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
+
+### IduEdu is an open-source Python library for the creation and manipulation of complex city networks from OpenStreetMap.
+
+## Features and how to use
+
+1. **[Graphs from OSM/Polygon/Name](./examples/get_any_graph.ipynb)** - Functions for building a graph of roads,
+   pedestrians and public transport based on OpenStreetMap (OSM), as well as creating an intermodal (public transport +
+   pedestrians) graph.
+2. **[Adjacency matrix](./examples/calc_adj_matrix.ipynb)** - Calculate adjacency matrix based on the provided graph and
+   edge weight type (_time_min_ or _length_meter_). 
+
+## Installation
+
+**IduEdu** can be installed with ``pip``:
+
+```
+pip install IduEdu
+```
+
+### Configuration changes
+
+```python
+from iduedu import config
+
+config.set_timeout(10)  # Timeout for overpass queries
+config.change_logger_lvl('INFO')  # To mute all debug msgs
+config.set_enable_tqdm(False)  # To mute all tqdm's progress bars
+config.set_overpass_url('http://your.overpass-api.de/interpreter/URL')
+```

iduedu-0.1.0/pyproject.toml

@@ -0,0 +1,62 @@
+[tool.poetry]
+name = "iduedu"
+version = "0.1.0"
+license = "BSD-3-Clause"
+description = "IduEdu is a Python package for the creation and manipulation of complex city networks from OpenStreetMap."
+authors = ["Danila <63115678+DDonnyy@users.noreply.github.com>"]
+readme = "README.md"
+
+packages = [{ include = "iduedu", from = "src" }]
+
+[tool.poetry.dependencies]
+python = ">=3.10,<3.13"
+osmnx = "^1.9.4"
+tqdm = "^4.66.2"
+osm2geojson = "^0.2.4"
+pydantic = "^2.6.1"
+networkit = "^11.0"
+numpy = "^1.23.5"
+pandas = "^2.2.0"
+geopandas = "^0.14.4"
+networkx = "^3.3"
+loguru = "^0.7.2"
+scipy = "^1.13.1"
+
+[tool.poetry.group.dev.dependencies]
+black = "^24.2.0"
+pylint = "^3.0.3"
+isort = "^5.13.2"
+jupyter = "^1.0.0"
+ortools = "^9.9.3963"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.black]
+line-length = 120
+target-version = ['py310']
+
+[tool.pylint.format]
+max-line-length = 120
+expected-line-ending-format = "LF"
+max-locals = 20
+extension-pkg-allow-list = ["networkit"]
+disable = [
+    "duplicate-code",
+    "missing-module-docstring",
+    "missing-function-docstring",
+    "too-many-locals",
+    "too-many-branches",
+    "too-many-statements",
+    "too-many-arguments"
+]
+
+[tool.isort]
+multi_line_output = 3
+include_trailing_comma = true
+force_grid_wrap = 0
+use_parentheses = true
+ensure_newline_before_comments = true
+line_length = 120
+split_on_trailing_comma = true

iduedu-0.1.0/src/iduedu/__init__.py

@@ -0,0 +1,11 @@
+"""
+IduEdu
+========
+
+IduEdu is a Python package for the creation and manipulation of complex city networks from OpenStreetMap.
+
+Homepage https://github.com/DDonnyy/IduEdu.
+"""
+from ._config import config
+from ._api import *
+from ._version import VERSION as __version__

iduedu-0.1.0/src/iduedu/_api.py

@@ -0,0 +1,7 @@
+# pylint: disable=unused-import
+from .modules.downloaders import get_boundary
+from .modules.drive_walk_builder import get_drive_graph, get_walk_graph
+from .modules.intermodal_builder import get_intermodal_graph
+from .modules.matrix_builder import get_adj_matrix_gdf_to_gdf
+from .modules.pt_walk_joiner import join_pt_walk_graph
+from .modules.public_transport_builder import get_all_public_transport_graph, get_single_public_transport_graph

iduedu-0.1.0/src/iduedu/_config.py

@@ -0,0 +1,58 @@
+import sys
+from typing import Literal
+
+from loguru import logger
+
+
+class Config:
+    """
+    A configuration class to manage global settings for the application, such as Overpass API URL, timeouts, and logging options.
+
+    Attributes
+    ----------
+    overpass_url : str
+        URL for accessing the Overpass API. Defaults to "http://lz4.overpass-api.de/api/interpreter".
+    timeout : int or None
+        Timeout in seconds for API requests. If None, no timeout is applied.
+    enable_tqdm_bar : bool
+        Enables or disables progress bars (via tqdm). Defaults to True.
+    logger : Logger
+        Logging instance to handle application logging.
+
+    Methods
+    -------
+    change_logger_lvl(lvl: Literal["TRACE", "DEBUG", "INFO", "WARN", "ERROR"])
+        Changes the logging level to the specified value.
+    set_overpass_url(url: str)
+        Sets a new Overpass API URL.
+    set_timeout(timeout: int)
+        Sets the timeout for API requests.
+    set_enable_tqdm(enable: bool)
+        Enables or disables progress bars in the application.
+    """
+    def __init__(
+        self,
+        overpass_url="http://lz4.overpass-api.de/api/interpreter",
+        timeout=None,
+        enable_tqdm_bar=True,
+    ):
+        self.overpass_url = overpass_url
+        self.timeout = timeout
+        self.enable_tqdm_bar = enable_tqdm_bar
+        self.logger = logger
+
+    def change_logger_lvl(self, lvl: Literal["TRACE", "DEBUG", "INFO", "WARN", "ERROR"]):
+        self.logger.remove()
+        self.logger.add(sys.stderr, level=lvl)
+
+    def set_overpass_url(self, url: str):
+        self.overpass_url = url
+
+    def set_timeout(self, timeout: int):
+        self.timeout = timeout
+
+    def set_enable_tqdm(self, enable: bool):
+        self.enable_tqdm_bar = enable
+
+
+config = Config()

iduedu-0.1.0/src/iduedu/_version.py

@@ -0,0 +1 @@
+VERSION = "0.1.0"

iduedu-0.1.0/src/iduedu/enums/drive_enums.py

@@ -0,0 +1,73 @@
+from enum import Enum
+from typing import Literal
+
+
+class RegistrationStatus(Enum):
+    """
+    Enum for registration status of the road.
+    """
+
+    FEDERAL = 1
+    REGIONAL = 2
+    LOCAL = 3
+
+
+class HighwayType(Enum):
+    """
+    Enum of highway types. Properties contain registration status & max speeds
+    """
+
+    MOTORWAY = "motorway"
+    TRUNK = "trunk"
+    PRIMARY = "primary"
+    SECONDARY = "secondary"
+    TERTIARY = "tertiary"
+    UNCLASSIFIED = "unclassified"
+    RESIDENTIAL = "residential"
+    MOTORWAY_LINK = "motorway_link"
+    TRUNK_LINK = "trunk_link"
+    PRIMARY_LINK = "primary_link"
+    SECONDARY_LINK = "secondary_link"
+    TERTIARY_LINK = "tertiary_link"
+    LIVING_STREET = "living_street"
+
+    @property
+    def reg_status(self) -> Literal[1, 2, 3]:
+        reg_status = {
+            HighwayType.MOTORWAY: RegistrationStatus.FEDERAL,
+            HighwayType.TRUNK: RegistrationStatus.FEDERAL,
+            HighwayType.PRIMARY: RegistrationStatus.REGIONAL,
+            HighwayType.SECONDARY: RegistrationStatus.REGIONAL,
+            HighwayType.TERTIARY: RegistrationStatus.LOCAL,
+            HighwayType.UNCLASSIFIED: RegistrationStatus.LOCAL,
+            HighwayType.RESIDENTIAL: RegistrationStatus.LOCAL,
+            HighwayType.MOTORWAY_LINK: RegistrationStatus.FEDERAL,
+            HighwayType.TRUNK_LINK: RegistrationStatus.FEDERAL,
+            HighwayType.PRIMARY_LINK: RegistrationStatus.REGIONAL,
+            HighwayType.SECONDARY_LINK: RegistrationStatus.REGIONAL,
+            HighwayType.TERTIARY_LINK: RegistrationStatus.LOCAL,
+            HighwayType.LIVING_STREET: RegistrationStatus.LOCAL,
+        }
+        return reg_status[self].value
+
+    @property
+    def max_speed(self) -> float:
+        """
+        Average speed in m/min.
+        """
+        speeds = {  # km/h
+            HighwayType.MOTORWAY: 110,
+            HighwayType.TRUNK: 90,
+            HighwayType.PRIMARY: 60,
+            HighwayType.SECONDARY: 60,
+            HighwayType.TERTIARY: 60,
+            HighwayType.UNCLASSIFIED: 40,
+            HighwayType.RESIDENTIAL: 40,
+            HighwayType.MOTORWAY_LINK: 90,
+            HighwayType.TRUNK_LINK: 90,
+            HighwayType.PRIMARY_LINK: 60,
+            HighwayType.SECONDARY_LINK: 60,
+            HighwayType.TERTIARY_LINK: 60,
+            HighwayType.LIVING_STREET: 20,
+        }
+        return speeds[self] * 1000 / 60  # metres per minute

iduedu-0.1.0/src/iduedu/enums/pt_enums.py

@@ -0,0 +1,25 @@
+from enum import Enum
+
+
+class PublicTrasport(Enum):
+    """
+    Enumeration class for edge types in graphs.
+    """
+
+    SUBWAY = "subway"
+    BUS = "bus"
+    TRAM = "tram"
+    TROLLEYBUS = "trolleybus"
+
+    @property
+    def avg_speed(self) -> float:
+        """
+        Average speed in m/min.
+        """
+        speeds = {  # km/h
+            PublicTrasport.SUBWAY: 40,
+            PublicTrasport.BUS: 20,
+            PublicTrasport.TRAM: 20,
+            PublicTrasport.TROLLEYBUS: 18,
+        }
+        return speeds[self] * 1000 / 60

iduedu-0.1.0/src/iduedu/modules/downloaders.py

@@ -0,0 +1,126 @@
+import geopandas as gpd
+import osm2geojson
+import osmnx as ox
+import pandas as pd
+import requests
+from shapely import MultiPolygon, Polygon, unary_union
+
+from iduedu._config import config
+
+logger = config.logger
+
+
+class RequestError(RuntimeError):
+    def __init__(self, message, status_code=None, reason=None, response_text=None, response_content=None):
+        super().__init__(message)
+        self.status_code = status_code
+        self.reason = reason
+        self.response_text = response_text
+        self.response_content = response_content
+
+    def __str__(self):
+        return f"{super().__str__()} (status: {self.status_code}, reason: {self.reason})"
+
+
+def get_boundary_by_osm_id(osm_id) -> MultiPolygon | Polygon:
+    overpass_query = f"""
+            [out:json];
+                    (
+                        relation({osm_id});
+                    );
+            out geom;
+            """
+    logger.debug(f"Downloading territory bounds with osm_id <{osm_id}> ...")
+    result = requests.get(config.overpass_url, params={"data": overpass_query}, timeout=config.timeout)
+    if result.status_code == 200:
+        json_result = result.json()
+        boundary = osm2geojson.json2geojson(json_result)
+        boundary = gpd.GeoDataFrame.from_features(boundary["features"]).set_crs(4326)
+        poly = unary_union(boundary.geometry)
+        return poly
+    raise RequestError(
+        message=f"Request failed with status code {result.status_code}, reason: {result.reason}",
+        status_code=result.status_code,
+        reason=result.reason,
+        response_text=result.text,
+        response_content=result.content,
+    )
+
+
+def get_boundary_by_name(territory_name: str) -> Polygon | MultiPolygon:
+    logger.debug(f"Downloading territory bounds with name <{territory_name}> ...")
+    place = ox.geocode_to_gdf(territory_name)
+    return unary_union(place.geometry)
+
+
+def get_boundary(
+    osm_id: int | None = None, territory_name: str | None = None, polygon: Polygon | MultiPolygon | None = None
+) -> Polygon:
+    """
+    Retrieve the boundary polygon for a given territory, either by OSM ID, territory name, or an existing polygon.
+    If a MultiPolygon is provided, it will be converted to a convex hull.
+
+    Parameters
+    ----------
+    osm_id : int, optional
+        OpenStreetMap ID of the territory to retrieve the boundary for.
+        Either this or `territory_name` must be provided.
+    territory_name : str, optional
+        Name of the territory to retrieve the boundary for. Either this or `osm_id` must be provided.
+    polygon : Polygon | MultiPolygon, optional
+        A custom polygon or MultiPolygon to use instead of querying by `osm_id` or `territory_name`.
+
+    Returns
+    -------
+    Polygon
+        The boundary polygon for the specified territory.
+        If a MultiPolygon was provided, it will return the convex hull.
+
+    Raises
+    ------
+    ValueError
+        If neither `osm_id`, `territory_name`, nor `polygon` are provided.
+
+    Examples
+    --------
+    >>> boundary = get_boundary(osm_id=123456)
+    >>> boundary = get_boundary(territory_name="New York")
+    >>> boundary = get_boundary(polygon=some_polygon)
+    """
+
+    if osm_id is None and territory_name is None and polygon is None:
+        raise ValueError("Either osm_id or name or polygon must be specified")
+    if osm_id:
+        polygon: Polygon = get_boundary_by_osm_id(osm_id)
+    elif territory_name:
+        polygon: Polygon = get_boundary_by_name(territory_name)
+
+    if isinstance(polygon, MultiPolygon):
+        polygon: Polygon = polygon.convex_hull
+
+    return polygon
+
+
+def get_routes_by_poly(polygon: Polygon, public_transport_type: str) -> pd.DataFrame:
+    polygon_coords = " ".join(f"{y} {x}" for x, y in polygon.exterior.coords[:-1])
+    overpass_query = f"""
+        [out:json];
+                (
+                    relation(poly:"{polygon_coords}")['route'='{public_transport_type}'];
+                );
+        out geom;
+        """
+    logger.debug(f"Downloading routes from OSM with type <{public_transport_type}> ...")
+    result = requests.post(config.overpass_url, data={"data": overpass_query}, timeout=config.timeout)
+    if result.status_code == 200:
+        json_result = result.json()["elements"]
+        data = pd.DataFrame(json_result)
+        data["transport_type"] = public_transport_type
+        return data
+    raise RequestError(
+        message=f"Request failed with status code {result.status_code}, reason: {result.reason}",
+        status_code=result.status_code,
+        reason=result.reason,
+        response_text=result.text,
+        response_content=result.content,
+    )