Pyrosm

https://pyrosm.readthedocs.io/en/latest/
Admin
Pyrosm is a Python library for reading OpenStreetMap data from PBF files into GeoPandas...
Tokens:34,066
Snippets:283
Trust Score:8.3
Update:9 months ago
Show doc for...
Tokens:
Raw
### Pyrosm: Initialize OSM reader and get help for get_data_by_custom_criteria

Source: https://pyrosm.readthedocs.io/en/latest/custom_filter

Demonstrates how to initialize the Pyrosm OSM reader with a file path and then access the help documentation for the `get_data_by_custom_criteria` method.

```python
from pyrosm import OSM
osm = OSM(fp)
help(osm.get_data_by_custom_criteria)
```

--------------------------------

### List All Available Cities for Download

Source: https://pyrosm.readthedocs.io/en/latest/basics

This snippet demonstrates how to retrieve a comprehensive list of all cities for which downloadable data is available. It uses the `sources.cities.available` attribute to get this list.

```python
# Prints a list of all cities that can be downloaded
print(sources.cities.available)
```

--------------------------------

### Perform In-Place Development Build of pyrosm

Source: https://pyrosm.readthedocs.io/en/latest/contributions

This command performs an in-place development build of the pyrosm package. After navigating to the cloned repository directory and ensuring dependencies are installed, running 'python setup.py develop' installs pyrosm into the current environment while allowing immediate use of any code changes without requiring reinstallation.

```bash
python setup.py develop

```

--------------------------------

### Parse Buildings and List Columns

Source: https://pyrosm.readthedocs.io/en/latest/basics

Demonstrates parsing building data using Pyrosm and then lists the resulting columns in the GeoDataFrame. This example highlights which default tags are present as columns and shows the 'tags' column for any extra attributes.

```python
# Parse buildings
buildings = osm.get_buildings()

# Print columns
buildings.columns
```

--------------------------------

### Initialize Pyrosm and Get Network Data for Helsinki

Source: https://pyrosm.readthedocs.io/en/latest/graphs

This snippet initializes the Pyrosm library to download and access OpenStreetMap data for Helsinki. It then extracts road network nodes and edges, and identifies restaurant points of interest.

```python
from pyrosm import OSM, get_data
import numpy as np
import matplotlib.pyplot as plt
osm = OSM(get_data("helsinki"))
nodes, edges = osm.get_network(network_type="driving", nodes=True)
restaurants = osm.get_pois(custom_filter={"amenity": ["restaurant"]})
```

--------------------------------

### Get and Download OSM Data with Pyrosm

Source: https://pyrosm.readthedocs.io/en/latest/reference

This function retrieves the file path to a specified OpenStreetMap PBF dataset. It automatically downloads the data if it's not found locally, with an option to update existing files. The directory for download can also be specified.

```python
from pyrosm import data

# Get path to administrative boundaries dataset
filepath = data.get_data("administrative_boundaries")

# Download and update if necessary
filepath = data.get_data("buildings", update=True)

# Specify download directory
filepath = data.get_data("pois", directory="/path/to/data")
```

--------------------------------

### Initialize Pyrosm reader for advanced filtering

Source: https://pyrosm.readthedocs.io/en/latest/custom_filter

This snippet shows the initial setup for using Pyrosm's advanced filtering capabilities. It involves importing the necessary libraries and retrieving the data file path, which is a prerequisite for calling `get_data_by_custom_criteria`.

```python
from pyrosm import OSM, get_data
fp = get_data("helsinki_pbf")


```

--------------------------------

### Calculate Shortest Path using NetworkX and OSMnx

Source: https://pyrosm.readthedocs.io/en/latest/graphs

This example illustrates how to calculate the shortest path between two specified addresses using NetworkX and OSMnx. It first geocodes the addresses to obtain coordinates and then proceeds with the shortest path calculation, leveraging the NetworkX graph constructed from Pyrosm data.

```python
source_address = "Bulevardi 5, Helsinki"
target_address = "Unioninkatu 40, Helsinki"

source = ox.geocode(source_address)
target = ox.geocode(target_address)
```

--------------------------------

### Install pyrosm Dependencies using Conda

Source: https://pyrosm.readthedocs.io/en/latest/contributions

This command installs all necessary dependencies for running pyrosm in a development environment using Conda. It configures the Conda environment to prioritize the 'conda-forge' channel for strict channel priority and then installs a comprehensive list of packages, including those for data handling, testing, and code formatting.

```bash
conda config --env --add channels conda-forge
conda config --env --set channel_priority strict
conda install geopandas cython cykhash pyrobuf python-rapidjson requests networkx python-igraph pandana pytest pytest-cov codecov black

```

--------------------------------

### List Available Countries in a Continent (e.g., Africa)

Source: https://pyrosm.readthedocs.io/en/latest/basics

This snippet shows how to list all downloadable country-level datasets within a specific continent. It accesses the continent's data (e.g., `sources.africa`) and then uses the `.available` attribute to get a list of countries.

```python
# Prints a list of countries in Africa that can be downloaded
print(sources.africa.available)
```

--------------------------------

### Export Street Network to Graph (Pandana)

Source: https://pyrosm.readthedocs.io/en/latest/basics

This example demonstrates exporting a street network from Pyrosm into a Pandana graph. Pandana is a library often used for spatial network analysis, and this conversion allows for further analysis using its specific capabilities.

```python
# 1. Retrieve graph elements
nodes, edges = osm.get_network(nodes=True)

# 2. Convert to graph specifying pandana type
graph_pandana = osm.to_graph(nodes, edges, graph_type="pandana")
```

--------------------------------

### Get Cycling Network Using Default Method

Source: https://pyrosm.readthedocs.io/en/latest/custom_filter

This snippet demonstrates retrieving the cycling network using the library's default 'get_network' method, which is equivalent to the custom filtering approach. The resulting network data is then plotted.

```python
cycling2 = osm.get_network("cycling")
cycling2.plot()
```

--------------------------------

### Export Street Network to Graph (igraph)

Source: https://pyrosm.readthedocs.io/en/latest/basics

This example illustrates how to export a street network obtained from Pyrosm into an iGraph format. It involves retrieving network nodes and edges and then converting them into a graph structure suitable for network analysis libraries like iGraph.

```python
# 1. Retrieve graph elements
nodes, edges = osm.get_network(nodes=True)

# 2. Convert to graph (default is igraph)
graph_igraph = osm.to_graph(nodes, edges)
```

--------------------------------

### Access and Parse Extra OSM Tags from Buildings

Source: https://pyrosm.readthedocs.io/en/latest/basics

Shows how to inspect and access extra OSM attributes that were not part of the default tags. These extra attributes are stored in the 'tags' column, often as JSON strings. This example demonstrates how to parse these JSON strings to extract key-value pairs.

```python
import json

# List "extra" tags that were associated with some of the buildings
buildings["tags"].unique()

# Iterate over rows having extra tags and print out the values
rows_with_extra_info = buildings.dropna(subset=["tags"])


i = 0
for row in rows_with_extra_info.itertuples():
    
    # Read the JSON
    tags = json.loads(row.tags)
    
    # Print the keys and values
    for key, value in tags.items():
        print("Key:", key, ", value: ", value)
    
    # Continue only up to first 10 
    if i == 9:
        break
    i+=1
```

--------------------------------

### Create and Activate Conda Development Environment

Source: https://pyrosm.readthedocs.io/en/latest/contributions

This code demonstrates how to create and activate a dedicated Conda development environment for pyrosm. It uses the 'conda create' command to set up a new environment named 'pyrosm_dev' and then uses 'conda activate' to switch to it. This ensures that development work does not interfere with other Python installations.

```bash
conda create -n pyrosm_dev

```

```bash
# Windows users:
activate pyrosm_dev

# macOS and Linux users:
conda activate pyrosm_dev

```

```bash
conda info -e

```

```bash
deactivate

```

--------------------------------

### Calculate Job Accessibility Index with Pyrosm

Source: https://pyrosm.readthedocs.io/en/latest/graphs

This example shows how to calculate a job accessibility index using Pyrosm's `aggregate` function. It involves assigning random employee counts to restaurants, associating these counts with network nodes, and then calculating the cumulative sum of employees within a specified radius. The results can be visualized on a map.

```python
# Assign a random number of workers for each restaurant (between 1-10)
restaurants["employee_cnt"] = np.random.choice([x for x in range(1,11)], size=len(restaurants))
```

```python
# Find the closest node-id for each restaurant
node_ids = G.get_node_ids(restaurants.lon, restaurants.lat)
```

```python
# Add employee counts to the graph
G.set(node_ids, variable=restaurants.employee_cnt, name="employee_cnt")
```

```python
# Calculate the number of employees (cumulative sum) from each node up to 500 meters
result = G.aggregate(500, type="sum", decay="linear", name="employee_cnt")
result = result.to_frame(name="cum_employees")
```

```python
# Attach the information from nodes
result = nodes.merge(result, left_on="id", right_on=result.index)
```

```python
# Visualize the results
plt.style.use('dark_background')
ax = result.plot(column="cum_employees", cmap='BrBG', markersize=0.1, legend=True, figsize=(20, 20))
```

--------------------------------

### Initialize Pyrosm Reader with Test Data

Source: https://pyrosm.readthedocs.io/en/latest/basics

Sets up the Pyrosm reader by first obtaining test data and then initializing the OSM object with the provided file path. This is a prerequisite for using Pyrosm's parsing capabilities.

```python
from pyrosm import OSM, get_data
# Get test data 
fp = get_data("test_pbf")

# Initialize the reader
osm = OSM(fp)
```

--------------------------------

### Initializing Pyrosm and Inspecting Configuration Tags

Source: https://pyrosm.readthedocs.io/en/latest/basics

This code snippet initializes the Pyrosm OSM reader with test data and then prints the names of the configuration attributes available in the osm.conf object. This helps in understanding the default settings for network filters and tags that Pyrosm uses.

```python
from pyrosm import OSM, get_data

# Initialize the OSM reader with test data
fp = get_data("test_pbf")
osm = OSM(fp)

# The instance has a configuration attribute containing:
print([item for item in osm.conf.__dict__.keys() if not item.startswith("_")])
```

--------------------------------

### Initialize Pyrosm OSM Reader Object - Python

Source: https://pyrosm.readthedocs.io/en/latest/basics

This Python code shows the basic steps to initialize the `OSM` reader object from the `pyrosm` library. It includes importing the library, retrieving a test PBF dataset file path using `get_data()`, and then instantiating the `OSM` object with the file path.

```python
import pyrosm

# Get filepath to test PBF dataset
fp = pyrosm.get_data("test_pbf")
print("Filepath to test data:", fp)

# Initialize the OSM object 
osm = pyrosm.OSM(fp)

# See the type
print("Type of 'osm' instance: ", type(osm))

# Example output:
# Filepath to test data: /home/user/miniconda3/envs/pyrosm/lib/python3.8/site-packages/pyrosm/data/test.osm.pbf
# Type of 'osm' instance:  <class 'pyrosm.pyrosm.OSM'>
```

--------------------------------

### Load and Initialize Pyrosm with Greater London Data

Source: https://pyrosm.readthedocs.io/en/latest/basics

This snippet demonstrates downloading and initializing Pyrosm with a specific regional dataset (Greater London). It first fetches the data using `get_data` and then creates an `OSM` object to parse it. This is a prerequisite for performing subsequent data extraction and filtering operations on that dataset.

```python
from pyrosm import OSM, get_data

# Download a dataset for Greater London (update if exists in the temp already)
fp = get_data("Greater London", update=True)
osm = OSM(fp)
```

--------------------------------

### Get and Plot Driving Network with Pyrosm

Source: https://pyrosm.readthedocs.io/en/latest/basics

This snippet demonstrates how to fetch the driving network data using Pyrosm and visualize it. It accesses the 'length' column which contains road lengths in meters. The data is represented as MultiLineString geometries.

```python
from pyrosm import OSM
from pyrosm import get_data

fp = get_data("test_pbf")
# Initialize the OSM parser object
osm = OSM(fp)

drive_net = osm.get_network(network_type="driving")
drive_net.plot()

# Displaying the head of the network DataFrame to show columns like 'length'
drive_net.head(2)
```

--------------------------------

### Access Pyrosm Configuration Tags

Source: https://pyrosm.readthedocs.io/en/latest/reference

This snippet demonstrates how to access the configuration tags within the Pyrosm library. It shows how to print all available OSM keys that Pyrosm can process and how to view typical tags associated with a specific category, like 'tourism'. This is useful for understanding what data can be parsed.

```python
from pyrosm.config import Conf

# Print all available OSM keys that Pyrosm can process
print("All available OSM keys", Conf.tags.available)

# Print typical tags associated with tourism
print("Typical tags associated with tourism:", Conf.tags.tourism)
```

--------------------------------

### Get Unique Values from mml:class Column

Source: https://pyrosm.readthedocs.io/en/latest/basics

This Python code demonstrates how to access and print the unique values present in the 'mml:class' column of the 'buildings2' GeoDataFrame. This helps in understanding the range of classification values available for buildings.

```python
# Get unique values in the "mml:class" column
print(buildings2["mml:class"].unique())
```

--------------------------------

### Get Nearest Graph Nodes with OSMnx

Source: https://pyrosm.readthedocs.io/en/latest/graphs

This snippet shows how to find the closest graph nodes to given source and target coordinates. It utilizes the `ox.get_nearest_node` function from the OSMnx library, which requires a graph object `G` and a tuple of (x, y) coordinates.

```python
# Find the closest nodes from the graph
source_node = ox.get_nearest_node(G, source)
target_node = ox.get_nearest_node(G, target)
```

--------------------------------

### Initialize OSM Reader with Pyrosm

Source: https://pyrosm.readthedocs.io/en/latest/reference

The OSM class provides an interface to read OpenStreetMap PBF files. It can optionally filter data spatially using a bounding box defined as a list of coordinates or a Shapely geometry object.

```python
from pyrosm import OSM

# Initialize with a PBF file path
osm = OSM("/path/to/your/osm.pbf")

# Initialize with a bounding box filter
bbox = [8.68, 50.11, 8.70, 50.13]
osm = OSM("/path/to/your/osm.pbf", bounding_box=bbox)
```

--------------------------------

### Initialize OSM Reader with Bounding Box - Python

Source: https://pyrosm.readthedocs.io/en/latest/basics

Illustrates how to initialize the `pyrosm.OSM` object by providing a bounding box to filter data spatially. The bounding box can be specified as a list of coordinates [minx, miny, maxx, maxy] or a Shapely geometry object.

```python
from pyrosm import OSM
from pyrosm import get_data

# Get filepath to test PBF dataset
fp = get_data("test_pbf")

# Define a bounding box (example coordinates)
# bounding_box = [10.0, 50.0, 11.0, 51.0] # Example: [minx, miny, maxx, maxy]

# Initialize the OSM object with a bounding box
# osm = OSM(fp, bounding_box=bounding_box)

# For demonstration, initializing without bounding box first:
osm = OSM(fp)
print(type(osm)) # Output: <class 'pyrosm.pyrosm.OSM'>
```

--------------------------------

### Exclude OSM Nodes in Pyrosm Queries

Source: https://pyrosm.readthedocs.io/en/latest/custom_filter

This example shows how to exclude 'node' type OSM elements when querying for schools. By setting `keep_nodes=False`, the results will only contain 'ways' and 'relations' tagged as schools, effectively filtering for polygons or multipolygons.

```python
from pyrosm import OSM

osm = OSM("path/to/your/osm_file.pbf")

custom_filter = {"amenity": ["school"]}

# Pass keep_nodes=False to filter out nodes
schools_that_are_not_nodes = osm.get_data_by_custom_criteria(custom_filter=custom_filter,
                                                             keep_nodes=False)

print("Number of schools that are not nodes:", len(schools_that_are_not_nodes))
```

--------------------------------

### Fork pyrosm Git Repository using Command Line

Source: https://pyrosm.readthedocs.io/en/latest/contributions

This snippet demonstrates how to fork the pyrosm Git repository and set up a local development copy. It involves cloning the repository, changing the directory, and adding an upstream remote to connect to the main project repository. This is useful for users who prefer using the command line for Git operations.

```bash
git clone git@github.com:your-user-name/pyrosm.git pyrosm-yourname
cd pyrosm-yourname
git remote add upstream git://github.com/htenkanen/pyrosm.git

```

--------------------------------

### pyrosm.pyrosm.OSM

Source: https://pyrosm.readthedocs.io/en/latest/reference

Initializes an OSM reader object with a specified PBF file path. Supports optional spatial filtering using a bounding box.

```APIDOC
## POST /OSM/initialize

### Description
OpenStreetMap PBF reader object initialization.

### Method
POST

### Endpoint
/OSM/initialize

### Parameters
#### Request Body
- **filepath** (str) - Required - Filepath to input OSM dataset ( *.osm.pbf ).
- **bounding_box** (list or shapely geometry) - Optional - Filtering OSM data spatially is allowed by passing a bounding box either as a list [minx, miny, maxx, maxy] or as a Shapely Polygon/MultiPolygon or closed LineString/LinearRing.

### Request Example
```json
{
  "filepath": "path/to/your/data.osm.pbf",
  "bounding_box": [ -74.0, 40.7, -73.9, 40.8 ]
}
```

### Response
#### Success Response (200)
- **osm_reader_id** (str) - An identifier for the initialized OSM reader object.

#### Response Example
```json
{
  "osm_reader_id": "osm_reader_123"
}
```
```

--------------------------------

### Get Cycling Roads Using Custom Filter

Source: https://pyrosm.readthedocs.io/en/latest/custom_filter

This snippet shows how to retrieve cycling roads by applying a custom filter and specifying which OSM keys to retain. The filtered data is then plotted. It assumes the 'OSM' class is initialized and 'get_data' is available.

```python
osm = OSM(get_data("test_pbf"))
cycling = osm.get_data_by_custom_criteria(custom_filter=custom_filter, 
                                          osm_keys_to_keep=osm_keys_to_keep,
                                          filter_type=filter_type)
cycling.plot()
```

--------------------------------

### OSM.to_graph()

Source: https://pyrosm.readthedocs.io/en/latest/reference

Constructs a graph from the loaded data. This function allows for various configurations regarding edge and node properties, bidirectionality, and network types.

```APIDOC
## POST /OSM/to_graph

### Description
Constructs a graph from the loaded data with configurable options for edge and node IDs, bidirectionality, network type, and compatibility with other libraries like OSMnx.

### Method
POST

### Endpoint
/OSM/to_graph

### Parameters
#### Query Parameters
- **from_id_col** (str) - Required - Name for the column having the from-node-ids of edges.
- **to_id_col** (str) - Required - Name for the column having the to-node-ids of edges.
- **edge_id_col** (str) - Required - Name for the column having the unique id for edges.
- **node_id_col** (str) - Required - Name for the column having the unique id for nodes.
- **force_bidirectional** (bool) - Optional - If True, all edges will be created as bidirectional.
- **network_type** (str) - Optional - Network type for the given data. Determines how the graph will be constructed. Possible values are: ‘walking’, ‘cycling’, ‘driving’, ‘driving+service’, ‘all’.
- **retain_all** (bool) - Optional - If True, return the entire graph even if it is not connected. Otherwise, retain only the connected edges.
- **osmnx_compatible** (bool) - Optional - If True, modifies the edge and node-attribute naming to be compatible with OSMnx. Default is True.
- **pandana_weights** (list) - Optional - Columns that are used as weights when exporting to Pandana graph. By default uses “length” column.

### Request Example
```json
{
  "from_id_col": "from_osm_id",
  "to_id_col": "to_osm_id",
  "edge_id_col": "edge_osm_id",
  "node_id_col": "node_osm_id",
  "force_bidirectional": false,
  "network_type": "driving",
  "retain_all": true,
  "osmnx_compatible": true,
  "pandana_weights": ["length", "speed"]
}
```

### Response
#### Success Response (200)
- **graph** (networkx.MultiDiGraph or similar) - The constructed graph object.
```

--------------------------------

### Getting Camden Borough Boundaries with Pyrosm

Source: https://pyrosm.readthedocs.io/en/latest/basics

This code snippet demonstrates how to retrieve the geographical boundaries for a specific administrative region, 'London Borough of Camden', using the Pyrosm library. It utilizes the get_boundaries() function with a 'name' parameter. The resulting boundary data is then plotted.

```python
# Get the borough of Camden as our bounding box
bounding_box = osm.get_boundaries(name="London Borough of Camden")
bounding_box.plot()
```

--------------------------------

### Search Boundaries by Partial Name with Pyrosm

Source: https://pyrosm.readthedocs.io/en/latest/basics

Demonstrates how to retrieve boundary data using partial name matching. This is useful when the exact name is unknown or when searching for a common substring across multiple boundary names. It takes a string for the partial name as input and returns GeoDataFrames of matching boundaries.

```python
from pyrosm import OSM
from pyrosm import get_data

fp = get_data("helsinki_pbf")
osm = OSM(fp)

# Use a partial name "vuori" to look for data
selected_boundary = osm.get_boundaries(name="vuori")
selected_boundary.plot()
```

--------------------------------

### Read Boundaries with Pyrosm

Source: https://pyrosm.readthedocs.io/en/latest/basics

This code demonstrates how to read administrative boundaries using Pyrosm's get_boundaries() function. It shows how to load all default boundaries and plot them, as well as how to filter for specific boundary types or names using parameters like 'boundary_type' and 'name'.

```python
from pyrosm import OSM
from pyrosm import get_data

fp = get_data("helsinki_region_pbf")
osm = OSM(fp)

# Read all boundaries using the default settings
boundaries = osm.get_boundaries()
boundaries.plot(facecolor="none", edgecolor="blue")

# Example of filtering for a specific boundary name (not fully implemented in snippet but described)
# boundaries_specific = osm.get_boundaries(name="some_region_name")
```

--------------------------------

### Export OSM Network to Routable Graphs (igraph, networkx, pandana)

Source: https://pyrosm.readthedocs.io/en/latest/reference

This function exports parsed OpenStreetMap network data (nodes and edges) into different graph formats. It supports 'igraph', 'networkx', and 'pandana'. Directionality is handled, defaulting to bidirectional for walking/cycling and respecting OSM 'oneway' tags for driving. Additional weights can be specified for 'pandana'.

```python
from pyrosm import OSM

osm = OSM("your_osm_data.pbf",
            # Specify which network types to load
            # e.g., "driving", "walking", "cycling", "all"
            network_types="all")

# Get nodes and edges for a specific network type
nodes, edges = osm.get_network(nodes=True, network_type="driving")

# Export to igraph (default)
graph_igraph = osm.to_graph(nodes, edges)

# Export to networkx
graph_networkx = osm.to_graph(nodes, edges, graph_type="networkx")

# Export to pandana with specific weights
graph_pandana = osm.to_graph(nodes, edges, graph_type="pandana", pandana_weights=["length", "speed_kph"])
```

--------------------------------

### Exclude Cycling Roads with Pyrosm Custom Filters

Source: https://pyrosm.readthedocs.io/en/latest/custom_filter

This example illustrates using `filter_type='exclude'` in Pyrosm to find cycling roads. It defines a custom filter to exclude specific highway types, bicycle restrictions, and private service roads, mimicking the functionality of `get_network('cycling')`.

```python
from pyrosm import OSM, get_data

osm = OSM("path/to/your/osm_file.pbf")

# First level of filtering: keep only data having 'highway' tag
osm_keys_to_keep = "highway"

# Second level of filtering: custom criteria to exclude non-cycling roads
custom_filter = dict(
        area=['yes'],
        highway=['footway', 'steps', 'corridor', 'elevator', 'escalator', 'motor', 'proposed',
                 'construction', 'abandoned', 'platform', 'raceway', 'motorway', 'motorway_link'],
        bicycle=['no'],
        service=['private']
    )

# Specify that the filters should be used for exclusion
filter_type = "exclude"

# Query for cycling roads by excluding the specified criteria
cycling_roads = osm.get_data_by_custom_criteria(custom_filter=custom_filter,
                                                  osm_keys_to_keep=osm_keys_to_keep,
                                                  filter_type=filter_type)

print("Number of cycling roads found:", len(cycling_roads))
```

--------------------------------

### Initializing Pyrosm with a Bounding Box

Source: https://pyrosm.readthedocs.io/en/latest/basics

This code initializes the Pyrosm OSM reader with a specified bounding box geometry. It first extracts the Shapely geometry from a GeoDataFrame containing boundary information and then uses this geometry to initialize the OSM object, ensuring subsequent data reads are spatially filtered.

```python
# Get the shapely geometry from GeoDataFramebox_geom = bounding_box['geometry'].values[0]

# Initiliaze with bounding boxosm = OSM(fp, bounding_box=bbox_geom)
```

--------------------------------

### List Countries with Available Subregions

Source: https://pyrosm.readthedocs.io/en/latest/basics

This snippet illustrates how to identify and list countries that have downloadable sub-region data. It accesses the subregions data via `sources.subregions.available.keys()` to display these countries.

```python
# Check all countries having sub-regions
print("All countries with sub-regions:", sources.subregions.available.keys())
```

--------------------------------

### Parse specific POIs (alcohol shops, restaurants, bars, dance leisure) with custom_filter

Source: https://pyrosm.readthedocs.io/en/latest/custom_filter

This example demonstrates how to use a highly specific `custom_filter` to extract POIs like alcohol shops, restaurants, bars, and dance-related leisure activities. It processes and plots the data, consolidating types into a 'poi_type' column.

```python
from pyrosm import OSM, get_data
# Get test data 
fp = get_data("helsinki_pbf")

# Initialize the reader
osm = OSM(fp)

# Read POIs with custom filter C
my_filter={"shop": ["alcohol"], "tourism": True, "amenity": ["restaurant", "bar"], "leisure": ["dance"]}
pois = osm.get_pois(custom_filter=my_filter)

# Merge poi type information into a single column
pois["shop"] = pois["shop"].fillna(' ')
pois["amenity"] = pois["amenity"].fillna(' ')
pois["leisure"] = pois["leisure"].fillna(' ')
pois["tourism"] = pois["tourism"].fillna(' ')
pois["poi_type"] = pois["amenity"] + pois["shop"] + pois["leisure"] + pois["tourism"] 

# Plot
ax = pois.plot(column="poi_type", legend=True, markersize=4, figsize=(14,8), legend_kwds=dict(loc='upper left', ncol=2, bbox_to_anchor=(1, 1)))

```

--------------------------------

### Show Default Tags for Building Features

Source: https://pyrosm.readthedocs.io/en/latest/basics

Retrieves and displays the default tags (OSM keys) that Pyrosm converts into columns when parsing building data. This list includes specific building-related tags as well as common attributes like address information and contact details.

```python
# Show all tags that are converted into columns from building features
osm.conf.tags.building
```

--------------------------------

### List Available Data Source Categories

Source: https://pyrosm.readthedocs.io/en/latest/basics

This snippet demonstrates how to retrieve and display the top-level categories of available datasets. It utilizes the `sources.available.keys()` method to list categories such as continents, cities, and subregions.

```python
# Print available source categories
sources.available.keys()
```

--------------------------------

### pyrosm.data.get_data

Source: https://pyrosm.readthedocs.io/en/latest/reference

Retrieves the file path to a specified PBF dataset and downloads it if necessary. Allows for updating existing datasets and specifying a download directory.

```APIDOC
## GET /data/get_data

### Description
Get the path to a PBF data file, and download the data if needed.

### Method
GET

### Endpoint
/data/get_data

### Parameters
#### Query Parameters
- **dataset** (str) - Required - The name of the dataset. Run `pyrosm.data.available` for all available options.
- **update** (bool) - Optional - Whether the PBF file should be downloaded/updated if the dataset with the same name exists in the temp.
- **directory** (str) - Optional - Path to a directory where the PBF data will be downloaded. (does not apply for test data sets bundled with the package).

### Response
#### Success Response (200)
- **filepath** (str) - The file path to the requested PBF dataset.

#### Response Example
{
  "filepath": "/path/to/downloaded/dataset.osm.pbf"
}
```

--------------------------------

### Read Points of Interest with Pyrosm

Source: https://pyrosm.readthedocs.io/en/latest/basics

This snippet demonstrates reading Points of Interest (POIs) such as amenities and shops using Pyrosm. It shows how to apply a custom filter to select specific types of POIs and how to combine tag information into a 'poi_type' column for plotting.

```python
from pyrosm import OSM
from pyrosm import get_data

fp = get_data("helsinki_pbf")
# Initialize the OSM parser object
osm = OSM(fp)

# By default pyrosm reads all elements having "amenity", "shop" or "tourism" tag
# Here, let's read only "amenity" and "shop" by applying a custom filter that
# overrides the default filtering mechanism
custom_filter = {'amenity': True, "shop": True}
pois = osm.get_pois(custom_filter=custom_filter)

# Gather info about POI type (combines the tag info from "amenity" and "shop")
pois["poi_type"] = pois["amenity"]
pois["poi_type"] = pois["poi_type"].fillna(pois["shop"])

# Plot
ax = pois.plot(column='poi_type', markersize=3, figsize=(12,12), legend=True, legend_kwds=dict(loc='upper left', ncol=5, bbox_to_anchor=(1, 1)))
```

--------------------------------

### Print Building Data Columns and Tags

Source: https://pyrosm.readthedocs.io/en/latest/basics

This snippet demonstrates how to print the existing columns and unique values within the 'tags' column of a buildings GeoDataFrame. It helps in understanding the available data and identifying potential additional attributes.

```python
print("Existing columns:\n", buildings.columns)
print("\nAdditional attributes in the 'tags': \n", buildings.tags.unique())
```

--------------------------------

### Read Buildings with Pyrosm

Source: https://pyrosm.readthedocs.io/en/latest/basics

This code shows how to read building data from OpenStreetMap using Pyrosm. It initializes the OSM parser with a file path and then calls the get_buildings() method. The resulting GeoDataFrame can be plotted to visualize building footprints.

```python
from pyrosm import OSM
from pyrosm import get_data

fp = get_data("test_pbf")
# Initialize the OSM parser object
osm = OSM(fp)

buildings = osm.get_buildings()
buildings.plot()
```

--------------------------------

### Visualize NetworkX Graph with OSMnx

Source: https://pyrosm.readthedocs.io/en/latest/graphs

This snippet demonstrates how to visualize the NetworkX graph created from Pyrosm data using the OSMnx library. It generates a plot of the street network, allowing for visual inspection of the graph structure.

```python
# Plot the graph with OSMnx
ox.plot_graph(G)
```

--------------------------------

### Parse OSM Boundaries with Pyrosm

Source: https://pyrosm.readthedocs.io/en/latest/reference

This method parses boundary data from an OSM PBF file. It supports various boundary types such as 'administrative', 'national_park', and 'postal_code'. Custom filters and extra OSM tags can be specified, and data can be retrieved for a specific timestamp if using OSH.PBF files.

```python
from pyrosm import OSM

osm = OSM("/path/to/your/osm.pbf")

# Get administrative boundaries
admin_boundaries = osm.get_boundaries(boundary_type="administrative")

# Get national parks with specific attributes
national_parks = osm.get_boundaries(boundary_type="national_park", extra_attributes=["name", "source"])

# Filter by name
berlin_boundaries = osm.get_boundaries(name="Berlin")
```

--------------------------------

### Create Directed Graph for Estonia Network (Python)

Source: https://pyrosm.readthedocs.io/en/latest/graphs

This snippet shows how to convert the retrieved network nodes and edges into a directed graph format using pyrosm's `to_graph()` method. This graph representation is essential for performing network analysis algorithms.

```python
# Create graph
G = osm.to_graph(nodes, edges)

```

--------------------------------

### Extract Walkable Roads for NetworkX Graph

Source: https://pyrosm.readthedocs.io/en/latest/graphs

This snippet shows how to initialize Pyrosm, extract walkable road data (nodes and edges) from an OSM PBF file, and prepare it for conversion into a NetworkX graph. It utilizes Pyrosm for data extraction and assumes the 'helsinki_pbf' dataset is available.

```python
from pyrosm import OSM, get_data
import osmnx as ox

# Initialize the reader
osm = OSM(get_data("helsinki_pbf"))

# Get all walkable roads and the nodes 
nodes, edges = osm.get_network(nodes=True)

# Check first rows in the edge 
edges.head()
```

--------------------------------

### Check Available Sub-regions in Brazil - Python

Source: https://pyrosm.readthedocs.io/en/latest/basics

This snippet demonstrates how to check and print the available sub-regions for a specific country, in this case, Brazil, using the pyrosm library. It also shows how to list all countries that have sub-regions available.

```python
from pyrosm import OSM
from pyrosm import get_data

# Check sub-regions in Brazil
print("Sub-regions in Brazil:", OSM.subregions.brazil.available)

# Print all countries with sub-regions
print("All countries with sub-regions:", OSM.subregions.available)

# Example output:
# Sub-regions in Brazil: ['centro_oeste', 'nordeste', 'norte', 'sudeste', 'sul']
# All countries with sub-regions: dict_keys(['brazil', 'canada', 'france', 'germany', 'great_britain', 'italy', 'japan', 'netherlands', 'poland', 'russia', 'usa'])
```

--------------------------------

### Calculate and Plot Shortest Path with NetworkX and OSMnx

Source: https://pyrosm.readthedocs.io/en/latest/graphs

This snippet demonstrates how to calculate the shortest path between two graph nodes using NetworkX's `shortest_path` function, considering edge 'length' as the weight. It then uses OSMnx's `plot_graph_route` to visualize the calculated path on the graph.

```python
# Find shortest path (by distance)
import networkx as nx
route = nx.shortest_path(G, source_node, target_node, weight="length")
fig, ax = ox.plot_graph_route(G, route, route_linewidth=6, node_size=0, bgcolor='k')
```

--------------------------------

### Handling Place Name Variations with get_data() - Python

Source: https://pyrosm.readthedocs.io/en/latest/basics

Demonstrates pyrosm's ability to handle variations in place names when downloading data. It shows that providing 'Rio de Janeiro' works even if the internal name in the `cities.available` list is 'RiodeJaneiro'.

```python
from pyrosm import get_data

# Passing names in slightly different style does not matter
fp = get_data("Rio de Janeiro")
print(fp)

# Example output:
# /tmp/pyrosm/RiodeJaneiro.osm.pbf
```
Tokens:
Raw