osmexp 0.2.0__tar.gz

osmexp-0.2.0/LICENSE

@@ -0,0 +1,26 @@
+3-Clause BSD License
+
+Copyright (c) 2015, Ronaldo "Racum" Ferreira
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of Ronaldo "Racum" Ferreira nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL RONALDO "RACUM" FERREIRA BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

osmexp-0.2.0/PKG-INFO

@@ -0,0 +1,104 @@
+Metadata-Version: 2.4
+Name: osmexp
+Version: 0.2.0
+Summary: OpenStreetMap GeoJSON Exporter
+Author-email: Ronaldo Ferreira <ronaldo@racum.com>
+License-Expression: BSD-3-Clause
+Project-URL: Source, https://github.com/racum/osmexp
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Natural Language :: English
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests
+Requires-Dist: shapely
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-recording; extra == "dev"
+Requires-Dist: vcrpy; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Dynamic: license-file
+
+# osmexp - OpenStreetMap GeoJSON Exporter
+
+The [OSM API](https://wiki.openstreetmap.org/wiki/API_v0.6) uses a specific format for their geometric primitive types based on nodes, ways and relations; and those unfortunately don’t translate 1:1 with [GeoJSON types](https://datatracker.ietf.org/doc/html/rfc7946#section-3.1), thus a conversion is needed.
+
+## Installation:
+
+Make sure you have at least Python 3.11, and install it with:
+
+```
+$ pip install osmexp
+```
+
+The only requirements are `Requests` and `Shapely`.
+
+## Usage
+
+For all exports, this is the format:
+
+```
+$ osmexp [element_type] [element_id]
+```
+
+Where `element_type` can be `node`, `way` or `rel` (for "relation"). And the ID is the numerical identifier used by OSM, if you don’t know how to get the OSM ID, [follow this article](https://racum.blog/articles/osm-to-geojson/#features-on-openstreetmap).
+
+The output is set to `STDOUT`, and it is recommended to be piped into a file or another command. On failure, an error message is sent to `STDERR` and the process exits with a non-zero status.
+
+### Exporting Nodes:
+
+```
+$ osmexp node 9589344640 > outdoor_seating.geojson
+```
+
+This returns a GeoJSON with a `Point` as a root type.
+
+### Exporting Ways:
+
+```
+$ osmexp way 398987317 > canal_grande.geojson
+```
+
+This returns a GeoJSON with a `LineString` as a root type if the line is “open” or `Polygon` if the line is “closed”.
+
+### Exporting Relations:
+
+```
+$ osmexp rel 4817103 > venice.geojson
+```
+
+This returns a GeoJSON with a `FeatureCollection` as a root, and the internal features as `LineString` or `Polygon`, depending if they can self-close, or fail the polygon transformation by other means (self crossing, etc).
+
+## Development
+
+Clone the repository and install in editable mode with the `dev` extras (tests, linter):
+
+```
+$ pip install -e '.[dev]'
+```
+
+All dependencies are declared in `pyproject.toml`; there are no separate requirements files.
+
+Run the test suite (it replays recorded HTTP responses, so no network is needed):
+
+```
+$ pytest
+```
+
+Lint and format with [Ruff](https://docs.astral.sh/ruff/):
+
+```
+$ ruff check .
+$ ruff format .
+```
+
+## License
+
+This library is released under the **3-Clause BSD License**.
+
+**tl;dr**: *"free to use as long as you credit me"*.

osmexp-0.2.0/README.md

@@ -0,0 +1,78 @@
+# osmexp - OpenStreetMap GeoJSON Exporter
+
+The [OSM API](https://wiki.openstreetmap.org/wiki/API_v0.6) uses a specific format for their geometric primitive types based on nodes, ways and relations; and those unfortunately don’t translate 1:1 with [GeoJSON types](https://datatracker.ietf.org/doc/html/rfc7946#section-3.1), thus a conversion is needed.
+
+## Installation:
+
+Make sure you have at least Python 3.11, and install it with:
+
+```
+$ pip install osmexp
+```
+
+The only requirements are `Requests` and `Shapely`.
+
+## Usage
+
+For all exports, this is the format:
+
+```
+$ osmexp [element_type] [element_id]
+```
+
+Where `element_type` can be `node`, `way` or `rel` (for "relation"). And the ID is the numerical identifier used by OSM, if you don’t know how to get the OSM ID, [follow this article](https://racum.blog/articles/osm-to-geojson/#features-on-openstreetmap).
+
+The output is set to `STDOUT`, and it is recommended to be piped into a file or another command. On failure, an error message is sent to `STDERR` and the process exits with a non-zero status.
+
+### Exporting Nodes:
+
+```
+$ osmexp node 9589344640 > outdoor_seating.geojson
+```
+
+This returns a GeoJSON with a `Point` as a root type.
+
+### Exporting Ways:
+
+```
+$ osmexp way 398987317 > canal_grande.geojson
+```
+
+This returns a GeoJSON with a `LineString` as a root type if the line is “open” or `Polygon` if the line is “closed”.
+
+### Exporting Relations:
+
+```
+$ osmexp rel 4817103 > venice.geojson
+```
+
+This returns a GeoJSON with a `FeatureCollection` as a root, and the internal features as `LineString` or `Polygon`, depending if they can self-close, or fail the polygon transformation by other means (self crossing, etc).
+
+## Development
+
+Clone the repository and install in editable mode with the `dev` extras (tests, linter):
+
+```
+$ pip install -e '.[dev]'
+```
+
+All dependencies are declared in `pyproject.toml`; there are no separate requirements files.
+
+Run the test suite (it replays recorded HTTP responses, so no network is needed):
+
+```
+$ pytest
+```
+
+Lint and format with [Ruff](https://docs.astral.sh/ruff/):
+
+```
+$ ruff check .
+$ ruff format .
+```
+
+## License
+
+This library is released under the **3-Clause BSD License**.
+
+**tl;dr**: *"free to use as long as you credit me"*.

osmexp-0.2.0/osmexp/__main__.py

@@ -0,0 +1,32 @@
+#!/usr/bin/env python
+
+import argparse
+import sys
+
+from .geojson import ExportError, export_node, export_relation, export_way
+
+EXPORTERS = {
+    'node': export_node,
+    'way': export_way,
+    'rel': export_relation,
+}
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        prog='osmexp',
+        description='Export an OpenStreetMap element as GeoJSON to STDOUT.',
+    )
+    parser.add_argument('element', choices=EXPORTERS, help='The OSM element type.')
+    parser.add_argument('id', type=int, help='The OSM element ID (an integer).')
+    args = parser.parse_args()
+
+    try:
+        print(EXPORTERS[args.element](args.id))
+    except ExportError as error:
+        print(error, file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == '__main__':
+    main()

osmexp-0.2.0/osmexp/fetcher.py

@@ -0,0 +1,87 @@
+import itertools
+
+import requests
+from shapely import get_parts, polygonize_full
+from shapely.geometry import GeometryCollection, LineString, Point, Polygon
+
+API_URL = 'https://api.openstreetmap.org/api/0.6'
+USER_AGENT = 'osmexp/0.2.0 (+https://github.com/racum/osmexp)'
+TIMEOUT = 30
+MIN_LINESTRING_NODES = 2
+
+
+def fetch_elements(path: str) -> list[dict] | None:
+    "Fetches an OSM API endpoint and returns its `elements`, or `None` on any failure."
+    try:
+        response = requests.get(
+            f'{API_URL}/{path}',
+            headers={'User-Agent': USER_AGENT},
+            timeout=TIMEOUT,
+        )
+        response.raise_for_status()
+        elements = response.json().get('elements')
+    except (requests.RequestException, ValueError):
+        return None
+    return elements or None
+
+
+def parse_geometries(elements: list[dict]) -> tuple[dict[int, Point], dict[int, LineString]]:
+    "Builds Shapely geometries keyed by OSM id: nodes as `Point`, ways as `LineString`."
+    nodes = {e['id']: Point(e['lon'], e['lat']) for e in elements if e['type'] == 'node'}
+    ways = {
+        e['id']: LineString([nodes[n] for n in e['nodes']])
+        for e in elements
+        if e['type'] == 'way' and len(e['nodes']) >= MIN_LINESTRING_NODES
+    }
+    return nodes, ways
+
+
+def fetch_node(node_id: int) -> Point | None:
+    elements = fetch_elements(f'node/{node_id}.json')
+    if elements is None:
+        return None
+    nodes, _ = parse_geometries(elements)
+    return next(iter(nodes.values()), None)
+
+
+def fetch_way(way_id: int) -> LineString | Polygon | None:
+    elements = fetch_elements(f'way/{way_id}/full.json')
+    if elements is None:
+        return None
+    _, ways = parse_geometries(elements)
+    way = next(iter(ways.values()), None)
+    if way is None:
+        return None
+    return Polygon(way) if way.is_ring else way
+
+
+def fetch_relation(relation_id: int) -> GeometryCollection | None:
+    elements = fetch_elements(f'relation/{relation_id}/full.json')
+    if elements is None:
+        return None
+    _, ways = parse_geometries(elements)
+    relation = next((e for e in elements if e['type'] == 'relation'), None)
+    if relation is None:
+        return None
+
+    outer, inner = [], []
+    for member in relation['members']:
+        if member['type'] != 'way':
+            continue
+        line = ways.get(member['ref'])
+        if line is None:
+            continue
+        (inner if member['role'] == 'inner' else outer).append(line)
+
+    outer_polygons, *outer_leftovers = polygonize_full(outer)
+    inner_rings = [p.exterior for p in get_parts(polygonize_full(inner)[0])]
+
+    parts = []
+    for polygon in get_parts(outer_polygons):
+        holes = [ring for ring in inner_rings if polygon.contains(ring)]
+        parts.append(Polygon(polygon.exterior, holes) if holes else polygon)
+
+    # Ways that could not be assembled into polygons (e.g. self-crossing) stay as lines.
+    parts.extend(itertools.chain.from_iterable(get_parts(leftover) for leftover in outer_leftovers))
+
+    return GeometryCollection(parts)

osmexp-0.2.0/osmexp/geojson.py

@@ -0,0 +1,55 @@
+import json
+
+from shapely import get_parts, to_geojson
+from shapely.geometry import MultiPolygon
+from shapely.geometry.base import BaseGeometry
+from shapely.geometry.polygon import orient
+
+from .fetcher import fetch_node, fetch_relation, fetch_way
+
+
+class ExportError(Exception):
+    "Raised when an OSM element cannot be fetched or exported."
+
+
+def right_hand_rule(geometry: BaseGeometry) -> BaseGeometry:
+    'Enforces the "right hand rule" as defined by the GeoJSON spec (RFC-7946, Section 3.1.6).'
+    if geometry.geom_type == 'Polygon':
+        return orient(geometry, sign=1)
+    if geometry.geom_type == 'MultiPolygon':
+        return MultiPolygon([right_hand_rule(p) for p in geometry.geoms])
+    return geometry
+
+
+def export_node(node_id: int) -> str:
+    node = fetch_node(node_id)
+    if node is None:
+        raise ExportError(f'Could not export node {node_id}.')
+    return to_geojson(node)
+
+
+def export_way(way_id: int) -> str:
+    way = fetch_way(way_id)
+    if way is None:
+        raise ExportError(f'Could not export way {way_id}.')
+    return to_geojson(right_hand_rule(way))
+
+
+def wrap_feature(part: BaseGeometry) -> dict:
+    return {
+        'type': 'Feature',
+        'properties': {},
+        'geometry': json.loads(to_geojson(right_hand_rule(part))),
+    }
+
+
+def export_relation(relation_id: int) -> str:
+    relation = fetch_relation(relation_id)
+    if relation is None:
+        raise ExportError(f'Could not export relation {relation_id}.')
+    return json.dumps(
+        {
+            'type': 'FeatureCollection',
+            'features': [wrap_feature(p) for p in get_parts(relation)],
+        }
+    )

osmexp-0.2.0/osmexp.egg-info/PKG-INFO

@@ -0,0 +1,104 @@
+Metadata-Version: 2.4
+Name: osmexp
+Version: 0.2.0
+Summary: OpenStreetMap GeoJSON Exporter
+Author-email: Ronaldo Ferreira <ronaldo@racum.com>
+License-Expression: BSD-3-Clause
+Project-URL: Source, https://github.com/racum/osmexp
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Natural Language :: English
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests
+Requires-Dist: shapely
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-recording; extra == "dev"
+Requires-Dist: vcrpy; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Dynamic: license-file
+
+# osmexp - OpenStreetMap GeoJSON Exporter
+
+The [OSM API](https://wiki.openstreetmap.org/wiki/API_v0.6) uses a specific format for their geometric primitive types based on nodes, ways and relations; and those unfortunately don’t translate 1:1 with [GeoJSON types](https://datatracker.ietf.org/doc/html/rfc7946#section-3.1), thus a conversion is needed.
+
+## Installation:
+
+Make sure you have at least Python 3.11, and install it with:
+
+```
+$ pip install osmexp
+```
+
+The only requirements are `Requests` and `Shapely`.
+
+## Usage
+
+For all exports, this is the format:
+
+```
+$ osmexp [element_type] [element_id]
+```
+
+Where `element_type` can be `node`, `way` or `rel` (for "relation"). And the ID is the numerical identifier used by OSM, if you don’t know how to get the OSM ID, [follow this article](https://racum.blog/articles/osm-to-geojson/#features-on-openstreetmap).
+
+The output is set to `STDOUT`, and it is recommended to be piped into a file or another command. On failure, an error message is sent to `STDERR` and the process exits with a non-zero status.
+
+### Exporting Nodes:
+
+```
+$ osmexp node 9589344640 > outdoor_seating.geojson
+```
+
+This returns a GeoJSON with a `Point` as a root type.
+
+### Exporting Ways:
+
+```
+$ osmexp way 398987317 > canal_grande.geojson
+```
+
+This returns a GeoJSON with a `LineString` as a root type if the line is “open” or `Polygon` if the line is “closed”.
+
+### Exporting Relations:
+
+```
+$ osmexp rel 4817103 > venice.geojson
+```
+
+This returns a GeoJSON with a `FeatureCollection` as a root, and the internal features as `LineString` or `Polygon`, depending if they can self-close, or fail the polygon transformation by other means (self crossing, etc).
+
+## Development
+
+Clone the repository and install in editable mode with the `dev` extras (tests, linter):
+
+```
+$ pip install -e '.[dev]'
+```
+
+All dependencies are declared in `pyproject.toml`; there are no separate requirements files.
+
+Run the test suite (it replays recorded HTTP responses, so no network is needed):
+
+```
+$ pytest
+```
+
+Lint and format with [Ruff](https://docs.astral.sh/ruff/):
+
+```
+$ ruff check .
+$ ruff format .
+```
+
+## License
+
+This library is released under the **3-Clause BSD License**.
+
+**tl;dr**: *"free to use as long as you credit me"*.

osmexp-0.2.0/osmexp.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+LICENSE
+README.md
+pyproject.toml
+osmexp/__init__.py
+osmexp/__main__.py
+osmexp/fetcher.py
+osmexp/geojson.py
+osmexp.egg-info/PKG-INFO
+osmexp.egg-info/SOURCES.txt
+osmexp.egg-info/dependency_links.txt
+osmexp.egg-info/entry_points.txt
+osmexp.egg-info/requires.txt
+osmexp.egg-info/top_level.txt
+tests/test_fetcher.py
+tests/test_geojson.py

osmexp-0.2.0/osmexp.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

osmexp-0.2.0/osmexp.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+osmexp = osmexp.__main__:main

osmexp-0.2.0/osmexp.egg-info/requires.txt

@@ -0,0 +1,8 @@
+requests
+shapely
+
+[dev]
+pytest
+pytest-recording
+vcrpy
+ruff

osmexp-0.2.0/osmexp.egg-info/top_level.txt

@@ -0,0 +1 @@
+osmexp

osmexp-0.2.0/pyproject.toml

@@ -0,0 +1,59 @@
+[build-system]
+requires = ["setuptools>=61", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "osmexp"
+version = "0.2.0"
+description = "OpenStreetMap GeoJSON Exporter"
+readme = "README.md"
+license = "BSD-3-Clause"
+requires-python = ">=3.11"
+authors = [{ name = "Ronaldo Ferreira", email = "ronaldo@racum.com" }]
+dependencies = ["requests", "shapely"]
+classifiers = [
+    "Development Status :: 2 - Pre-Alpha",
+    "Intended Audience :: Developers",
+    "Natural Language :: English",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+]
+
+[project.urls]
+Source = "https://github.com/racum/osmexp"
+
+[project.optional-dependencies]
+dev = ["pytest", "pytest-recording", "vcrpy", "ruff"]
+
+[project.scripts]
+osmexp = "osmexp.__main__:main"
+
+[tool.setuptools]
+packages = ["osmexp"]
+
+[tool.black]
+line-length = 120
+target-version = ['py311']
+include = '\.pyi?$'
+skip-string-normalization = true
+
+[tool.ruff]
+target-version = "py311"
+line-length = 120
+lint.select = ["E", "F", "TID", "I", "B", "PGH", "UP", "A", "C4", "PIE", "T20", "RSE", "RET", "SIM", "ARG", "PTH", "ERA", "PL", "RUF"]
+
+[tool.ruff.format]
+quote-style = "single"
+
+[tool.ruff.lint.per-file-ignores]
+"tests/*" = ["PLR2004"]
+"osmexp/__main__.py" = ["PLR2004", "T201"]
+
+[[tool.mypy.overrides]]
+module = "shapely.*"
+ignore_missing_imports = true
+
+[tool.pytest.ini_options]
+addopts = "--record-mode=none"

osmexp-0.2.0/setup.cfg

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

osmexp-0.2.0/tests/test_fetcher.py

@@ -0,0 +1,52 @@
+import pytest
+
+from osmexp.fetcher import fetch_node, fetch_relation, fetch_way
+
+
+@pytest.mark.vcr()
+def test_fetch_node_as_point():
+    node = fetch_node(9589344640)  # Outdoor seating.
+    assert node.geom_type == 'Point'
+    assert (node.x, node.y) == (12.3394685, 45.4331611)
+
+
+@pytest.mark.vcr()
+def test_fetch_open_way_as_linestring():
+    way = fetch_way(398987317)  # Canal Grande.
+    assert way.geom_type == 'LineString'
+    assert len(way.coords) == 125
+    assert way.length == pytest.approx(0.049109547915808335)  # Point units, not meters.
+
+
+@pytest.mark.vcr()
+def test_fetch_closed_way_as_polygon():
+    way = fetch_way(430963095)  # Column of Saint Mark.
+    assert way.geom_type == 'Polygon'
+    assert way.area == pytest.approx(3.089739999806592e-09)  # Point units, not meters.
+
+
+@pytest.mark.vcr()
+def test_fetch_single_relation_as_polygon():
+    rel = fetch_relation(4817103)  # Venice.
+    assert rel.geom_type == 'GeometryCollection'
+    assert rel.geoms[0].geom_type == 'Polygon'
+    assert len(rel.geoms[0].exterior.coords) == 849
+    assert rel.geoms[0].area == pytest.approx(0.0006893646889149643)  # Point units, not meters.
+
+
+@pytest.mark.vcr()
+def test_fetch_split_relation_as_many_polygons():
+    rel = fetch_relation(1850539)  # Parque Estadual Paulo César Vinha
+    assert rel.geom_type == 'GeometryCollection'
+    assert len(rel.geoms) == 9
+    assert {g.geom_type for g in rel.geoms} == {'Polygon'}
+    assert sum(g.area for g in rel.geoms) == pytest.approx(0.0013636596847249436)
+
+
+@pytest.mark.vcr()
+def test_fetch_self_crossing_relation_as_many_linestrings():
+    rel = fetch_relation(284570)  # Suzuka
+    assert rel.geom_type == 'GeometryCollection'
+    assert len(rel.geoms) == 2
+    assert {g.geom_type for g in rel.geoms} == {'LineString'}
+    assert sum(g.area for g in rel.geoms) == 0

osmexp-0.2.0/tests/test_geojson.py

@@ -0,0 +1,48 @@
+import json
+
+import pytest
+
+from osmexp.geojson import export_node, export_relation, export_way
+
+
+@pytest.mark.vcr()
+def test_export_node():
+    geojson = json.loads(export_node(9589344640))
+    assert geojson['type'] == 'Point'
+    assert geojson['coordinates'] == [12.3394685, 45.4331611]
+
+
+@pytest.mark.vcr()
+def test_export_open_way():
+    geojson = json.loads(export_way(398987317))
+    assert geojson['type'] == 'LineString'
+
+
+@pytest.mark.vcr()
+def test_export_closed_way():
+    geojson = json.loads(export_way(430963095))
+    assert geojson['type'] == 'Polygon'
+
+
+@pytest.mark.vcr()
+def test_export_single_relation():
+    geojson = json.loads(export_relation(4817103))
+    assert geojson['type'] == 'FeatureCollection'
+    assert len(geojson['features']) == 1
+    assert {f['geometry']['type'] for f in geojson['features']} == {'Polygon'}
+
+
+@pytest.mark.vcr()
+def test_export_split_relation():
+    geojson = json.loads(export_relation(1850539))
+    assert geojson['type'] == 'FeatureCollection'
+    assert len(geojson['features']) == 9
+    assert {f['geometry']['type'] for f in geojson['features']} == {'Polygon'}
+
+
+@pytest.mark.vcr()
+def test_export_self_crossing_relation():
+    geojson = json.loads(export_relation(284570))
+    assert geojson['type'] == 'FeatureCollection'
+    assert len(geojson['features']) == 2
+    assert {f['geometry']['type'] for f in geojson['features']} == {'LineString'}