ruian-import 0.1.0__tar.gz

ruian_import-0.1.0/.gitignore

@@ -0,0 +1,7 @@
+__pycache__/
+*.pyc
+*.egg-info/
+dist/
+build/
+.venv/
+*.egg

ruian_import-0.1.0/PKG-INFO

@@ -0,0 +1,116 @@
+Metadata-Version: 2.4
+Name: ruian-import
+Version: 0.1.0
+Summary: Download and parse Czech RUIAN (ČÚZK) data: municipalities, districts, and regions
+Project-URL: Repository, https://gitlab.com/alexandra.tapkova/ruian-import
+Author-email: Alexandra Ťapková <git@ouppy.space>
+License: MIT
+Keywords: cuzk,czech,gis,municipalities,ruian
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.10
+Requires-Dist: requests>=2.28
+Provides-Extra: coordinates
+Requires-Dist: pyproj>=3.4; extra == 'coordinates'
+Provides-Extra: dev
+Requires-Dist: pyproj>=3.4; extra == 'dev'
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: responses; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# ruian-import
+
+Python knihovna pro stahování a parsování číselníků ČÚZK (RÚIAN): kraje, okresy a obce.
+
+## Instalace
+
+```bash
+pip install ruian-import
+# s podporou souřadnic (JTSK -> WGS84):
+pip install "ruian-import[coordinates]"
+```
+
+## Použití
+
+```python
+from ruian_import import fetch_kraje, fetch_okresy, fetch_obce
+
+kraje = fetch_kraje()   # list[Kraj]
+okresy = fetch_okresy() # list[Okres]
+obce = fetch_obce()     # list[Obec]
+```
+
+### Datové třídy
+
+```python
+@dataclass
+class Kraj:
+    kod: str          # např. "19"
+    nazev: str        # např. "Hlavní město Praha"
+    nuts_lau: str | None  # např. "CZ010"
+    zrusen: str | None    # datum zrušení "YYYY-MM-DD" nebo None
+
+@dataclass
+class Okres:
+    kod: str
+    nazev: str
+    kraj_kod: str
+    nuts_lau: str | None
+    zrusen: str | None
+
+@dataclass
+class Obec:
+    kod: str          # 6místný kód obce, např. "554979"
+    nazev: str
+    okres_kod: str
+    lat: float | None  # WGS84, dostupné jen s [coordinates]
+    lon: float | None
+    zrusen: str | None
+```
+
+Zrušené záznamy mají vyplněné pole `zrusen`; platné záznamy mají `zrusen = None`.
+
+### Souřadnice obcí
+
+`UI_OBEC.csv` souřadnice neobsahuje. Pro doplnění souřadnic použij `fetch_obce_with_coordinates()`, které provede druhý dotaz na ArcGIS REST API ČÚZK a vrátí centroidy polygonů (přesnost ~100 m, jeden HTTP request pro všechny obce):
+
+```python
+from ruian_import import fetch_obce_with_coordinates
+
+obce = fetch_obce_with_coordinates()  # lat/lon vyplněné
+```
+
+Nebo načti souřadnice samostatně:
+
+```python
+from ruian_import import fetch_obec_coordinates
+
+coords = fetch_obec_coordinates()  # dict[str, tuple[float, float]] - kod -> (lat, lon)
+```
+
+### Vlastní URL / lokální soubory
+
+```python
+from ruian_import._parse import parse_obce
+
+data = Path("UI_OBEC.zip").read_bytes()
+obce = parse_obce(data)
+```
+
+## Zdroje dat
+
+Číselníky ČÚZK se aktualizují denně:
+
+- **Kraje**: `https://services.cuzk.cz/sestavy/cis/UI_VUSC.zip`
+- **Okresy**: `https://services.cuzk.cz/sestavy/cis/UI_OKRES.zip`
+- **Obce**: `https://services.cuzk.cz/sestavy/cis/UI_OBEC.zip`
+
+## Licence
+
+MIT

ruian_import-0.1.0/README.md

@@ -0,0 +1,90 @@
+# ruian-import
+
+Python knihovna pro stahování a parsování číselníků ČÚZK (RÚIAN): kraje, okresy a obce.
+
+## Instalace
+
+```bash
+pip install ruian-import
+# s podporou souřadnic (JTSK -> WGS84):
+pip install "ruian-import[coordinates]"
+```
+
+## Použití
+
+```python
+from ruian_import import fetch_kraje, fetch_okresy, fetch_obce
+
+kraje = fetch_kraje()   # list[Kraj]
+okresy = fetch_okresy() # list[Okres]
+obce = fetch_obce()     # list[Obec]
+```
+
+### Datové třídy
+
+```python
+@dataclass
+class Kraj:
+    kod: str          # např. "19"
+    nazev: str        # např. "Hlavní město Praha"
+    nuts_lau: str | None  # např. "CZ010"
+    zrusen: str | None    # datum zrušení "YYYY-MM-DD" nebo None
+
+@dataclass
+class Okres:
+    kod: str
+    nazev: str
+    kraj_kod: str
+    nuts_lau: str | None
+    zrusen: str | None
+
+@dataclass
+class Obec:
+    kod: str          # 6místný kód obce, např. "554979"
+    nazev: str
+    okres_kod: str
+    lat: float | None  # WGS84, dostupné jen s [coordinates]
+    lon: float | None
+    zrusen: str | None
+```
+
+Zrušené záznamy mají vyplněné pole `zrusen`; platné záznamy mají `zrusen = None`.
+
+### Souřadnice obcí
+
+`UI_OBEC.csv` souřadnice neobsahuje. Pro doplnění souřadnic použij `fetch_obce_with_coordinates()`, které provede druhý dotaz na ArcGIS REST API ČÚZK a vrátí centroidy polygonů (přesnost ~100 m, jeden HTTP request pro všechny obce):
+
+```python
+from ruian_import import fetch_obce_with_coordinates
+
+obce = fetch_obce_with_coordinates()  # lat/lon vyplněné
+```
+
+Nebo načti souřadnice samostatně:
+
+```python
+from ruian_import import fetch_obec_coordinates
+
+coords = fetch_obec_coordinates()  # dict[str, tuple[float, float]] - kod -> (lat, lon)
+```
+
+### Vlastní URL / lokální soubory
+
+```python
+from ruian_import._parse import parse_obce
+
+data = Path("UI_OBEC.zip").read_bytes()
+obce = parse_obce(data)
+```
+
+## Zdroje dat
+
+Číselníky ČÚZK se aktualizují denně:
+
+- **Kraje**: `https://services.cuzk.cz/sestavy/cis/UI_VUSC.zip`
+- **Okresy**: `https://services.cuzk.cz/sestavy/cis/UI_OKRES.zip`
+- **Obce**: `https://services.cuzk.cz/sestavy/cis/UI_OBEC.zip`
+
+## Licence
+
+MIT

ruian_import-0.1.0/pyproject.toml

@@ -0,0 +1,39 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "ruian-import"
+version = "0.1.0"
+description = "Download and parse Czech RUIAN (ČÚZK) data: municipalities, districts, and regions"
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.10"
+authors = [{ name = "Alexandra Ťapková", email = "git@ouppy.space" }]
+keywords = ["ruian", "cuzk", "czech", "municipalities", "gis"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Software Development :: Libraries",
+]
+
+dependencies = ["requests>=2.28"]
+
+[project.optional-dependencies]
+coordinates = ["pyproj>=3.4"]
+dev = ["pytest", "responses", "pyproj>=3.4"]
+
+[project.urls]
+Repository = "https://gitlab.com/alexandra.tapkova/ruian-import"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/ruian_import"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+markers = ["network: requires internet access"]

ruian_import-0.1.0/src/ruian_import/__init__.py

@@ -0,0 +1,67 @@
+"""
+ruian-import: stahování a parsování číselníků ČÚZK (RÚIAN).
+
+Základní použití::
+
+    from ruian_import import fetch_kraje, fetch_okresy, fetch_obce
+
+    kraje = fetch_kraje()
+    okresy = fetch_okresy()
+    obce = fetch_obce()
+
+Každá funkce vrátí seznam dataclass objektů (Kraj, Okres, Obec).
+Zrušené záznamy mají vyplněné pole ``zrusen`` (datum jako řetězec).
+
+Geolokace obcí (lat/lon) je k dispozici jen pokud je nainstalován
+volitelný balíček ``pyproj`` (``pip install ruian-import[coordinates]``).
+"""
+
+from ._arcgis import fetch_obec_coordinates
+from ._http import download
+from ._models import Kraj, Obec, Okres
+from ._parse import OBCE_URL, OKRESY_URL, KRAJE_URL, parse_kraje, parse_obce, parse_okresy
+
+__all__ = [
+    "Kraj",
+    "Okres",
+    "Obec",
+    "fetch_kraje",
+    "fetch_okresy",
+    "fetch_obce",
+    "fetch_obec_coordinates",
+    "KRAJE_URL",
+    "OKRESY_URL",
+    "OBCE_URL",
+]
+
+
+def fetch_kraje(url: str = KRAJE_URL) -> list[Kraj]:
+    """Stáhne a naparsuje číselník krajů z ČÚZK."""
+    return parse_kraje(download(url))
+
+
+def fetch_okresy(url: str = OKRESY_URL) -> list[Okres]:
+    """Stáhne a naparsuje číselník okresů z ČÚZK."""
+    return parse_okresy(download(url))
+
+
+def fetch_obce(url: str = OBCE_URL) -> list[Obec]:
+    """Stáhne a naparsuje číselník obcí z ČÚZK. Pole lat/lon bude None."""
+    return parse_obce(download(url))
+
+
+def fetch_obce_with_coordinates(
+    obce_url: str = OBCE_URL,
+) -> list[Obec]:
+    """
+    Stáhne číselník obcí i jejich souřadnice (WGS84) a vrátí je sloučené.
+
+    Provede dva HTTP dotazy: jeden na ČÚZK číselník, jeden na ArcGIS REST API.
+    Souřadnice jsou centroidy polygonů územních celků (přesnost ~100 m).
+    """
+    obce = parse_obce(download(obce_url))
+    coords = fetch_obec_coordinates()
+    for obec in obce:
+        if obec.kod in coords:
+            obec.lat, obec.lon = coords[obec.kod]
+    return obce

ruian_import-0.1.0/src/ruian_import/_arcgis.py

@@ -0,0 +1,50 @@
+"""
+Stahování souřadnic obcí z ArcGIS REST API ČÚZK.
+
+Endpoint vrací polygony územních celků ve WGS84; centroid se počítá průměrem
+vrcholů vnějšího prstence (dostatečná přesnost pro polohový bod obce).
+
+URL: https://ags.cuzk.cz/arcgis/rest/services/RUIAN/MapServer/12
+"""
+
+import json
+from typing import Optional
+
+from ._http import download
+
+_QUERY_URL = (
+    "https://ags.cuzk.cz/arcgis/rest/services/RUIAN/MapServer/12/query"
+    "?where=platido+IS+NULL"
+    "&outFields=kod"
+    "&returnGeometry=true"
+    "&geometryPrecision=5"
+    "&outSR=4326"
+    "&f=json"
+)
+
+
+def _ring_centroid(ring: list[list[float]]) -> tuple[float, float]:
+    """Průměr souřadnic vrcholů vnějšího prstence polygonu."""
+    lons = [pt[0] for pt in ring]
+    lats = [pt[1] for pt in ring]
+    return sum(lats) / len(lats), sum(lons) / len(lons)
+
+
+def fetch_obec_coordinates(
+    url: str = _QUERY_URL,
+) -> dict[str, tuple[float, float]]:
+    """
+    Stáhne souřadnice (WGS84) všech platných obcí z ArcGIS REST API ČÚZK.
+
+    Vrací slovník ``{kod_obce: (lat, lon)}``.
+    Jeden HTTP dotaz - vrací ~6 200 obcí najednou.
+    """
+    data = json.loads(download(url))
+    result: dict[str, tuple[float, float]] = {}
+    for feature in data.get("features", []):
+        kod = str(feature.get("attributes", {}).get("kod", "")).strip()
+        rings = (feature.get("geometry") or {}).get("rings")
+        if not kod or not rings or not rings[0]:
+            continue
+        result[kod] = _ring_centroid(rings[0])
+    return result

ruian_import-0.1.0/src/ruian_import/_coordinates.py

@@ -0,0 +1,45 @@
+"""
+Převod S-JTSK (EPSG:5514) na WGS84 (EPSG:4326).
+
+Vyžaduje volitelnou závislost pyproj; pokud není nainstalována, funkce
+vrací None a koordináty se vynechají.
+"""
+
+from typing import Optional
+
+try:
+    from pyproj import Transformer as _Transformer
+
+    _transformer = _Transformer.from_crs("EPSG:5514", "EPSG:4326", always_xy=True)
+    _PYPROJ_AVAILABLE = True
+except ImportError:
+    _PYPROJ_AVAILABLE = False
+
+
+def _normalize_jtsk(
+    first: Optional[float], second: Optional[float]
+) -> tuple[Optional[float], Optional[float]]:
+    """
+    Vrátí (X, Y) v S-JTSK. Pořadí sloupců souřadnic není spolehlivé,
+    ale rozsahy os se v ČR nepřekrývají (X ⊂ ⟨935, 1230⟩ km, Y ⊂ ⟨430, 905⟩ km).
+    """
+    if first is None or second is None:
+        return None, None
+    return (first, second) if first > second else (second, first)
+
+
+def sjtsk_to_wgs84(
+    first: Optional[float], second: Optional[float]
+) -> tuple[Optional[float], Optional[float]]:
+    """
+    Převede souřadnice S-JTSK (libovolné pořadí) na (lat, lon) WGS84.
+    Vrátí (None, None) pokud nejsou vstupní hodnoty nebo pyproj není nainstalován.
+    """
+    if not _PYPROJ_AVAILABLE:
+        return None, None
+    jtsk_x, jtsk_y = _normalize_jtsk(first, second)
+    if jtsk_x is None or jtsk_y is None:
+        return None, None
+    # EPSG:5514 používá záporné souřadnice
+    lon, lat = _transformer.transform(-jtsk_y, -jtsk_x)
+    return lat, lon

ruian_import-0.1.0/src/ruian_import/_http.py

@@ -0,0 +1,16 @@
+import requests
+
+_TIMEOUT = 30
+_RETRIES = 2
+
+
+def download(url: str, timeout: int = _TIMEOUT, retries: int = _RETRIES) -> bytes:
+    last_error: Exception | None = None
+    for _ in range(1 + retries):
+        try:
+            response = requests.get(url, timeout=timeout)
+            response.raise_for_status()
+            return response.content
+        except requests.RequestException as exc:
+            last_error = exc
+    raise last_error  # type: ignore[misc]

ruian_import-0.1.0/src/ruian_import/_models.py

@@ -0,0 +1,32 @@
+from dataclasses import dataclass
+from typing import Optional
+
+
+@dataclass
+class Kraj:
+    kod: str
+    nazev: str
+    nuts_lau: Optional[str]
+    # None = platný, str = datum zrušení "YYYY-MM-DD"
+    zrusen: Optional[str]
+
+
+@dataclass
+class Okres:
+    kod: str
+    nazev: str
+    kraj_kod: str
+    nuts_lau: Optional[str]
+    zrusen: Optional[str]
+
+
+@dataclass
+class Obec:
+    kod: str
+    nazev: str
+    okres_kod: str
+    # WGS84; None pokud nejsou k dispozici (UI_OBEC.csv souřadnice neobsahuje;
+    # lze doplnit z VDP API nebo vlastní tabulky)
+    lat: Optional[float]
+    lon: Optional[float]
+    zrusen: Optional[str]

ruian_import-0.1.0/src/ruian_import/_parse.py

@@ -0,0 +1,142 @@
+"""
+Parsování CSV číselníků ČÚZK.
+
+Zdroje (denní aktualizace):
+  Kraje:  https://services.cuzk.cz/sestavy/cis/UI_VUSC.zip
+  Okresy: https://services.cuzk.cz/sestavy/cis/UI_OKRES.zip
+  Obce:   https://services.cuzk.cz/sestavy/cis/UI_OBEC.zip
+
+Formát: ZIP s jedním CSV souborem, oddělovač `;`.
+Kódování: UTF-8 nebo cp1250 (soubory ČÚZK nemají jednotné kódování).
+Sloupce jsou stabilní ale neúplné - UI_OBEC.csv souřadnice neobsahuje.
+"""
+
+import csv
+import io
+import zipfile
+from typing import Optional
+
+from ._coordinates import sjtsk_to_wgs84
+from ._models import Kraj, Obec, Okres
+
+KRAJE_URL = "https://services.cuzk.cz/sestavy/cis/UI_VUSC.zip"
+OKRESY_URL = "https://services.cuzk.cz/sestavy/cis/UI_OKRES.zip"
+OBCE_URL = "https://services.cuzk.cz/sestavy/cis/UI_OBEC.zip"
+
+
+def decode_csv(data: bytes) -> str:
+    """Dekóduje bytes ze ČÚZK; zkouší UTF-8, padne zpět na cp1250."""
+    try:
+        text = data.decode("utf-8")
+    except UnicodeDecodeError:
+        text = data.decode("cp1250")
+    return text.lstrip("")
+
+
+def read_zipped_csvs(data: bytes) -> list[str]:
+    with zipfile.ZipFile(io.BytesIO(data)) as zf:
+        return [
+            decode_csv(zf.read(name))
+            for name in zf.namelist()
+            if name.lower().endswith(".csv")
+        ]
+
+
+def _parse_float(value: Optional[str]) -> Optional[float]:
+    value = (value or "").strip().replace(",", ".")
+    if not value:
+        return None
+    try:
+        return float(value)
+    except ValueError:
+        return None
+
+
+def _plati_do(row: dict) -> Optional[str]:
+    """Vrátí datum zrušení jako 'YYYY-MM-DD' nebo None (stále platný)."""
+    raw = (row.get("PLATI_DO") or "").strip()
+    if not raw:
+        return None
+    return raw.split(" ")[0]
+
+
+def parse_kraje(data: bytes) -> list[Kraj]:
+    """
+    Sloupce UI_VUSC.csv:
+    KOD;NAZEV;REGSOUDR_KOD;NUTS_LAU;PLATI_OD;PLATI_DO;DATUM_VZNIKU
+    """
+    result: list[Kraj] = []
+    for text in read_zipped_csvs(data):
+        for row in csv.DictReader(io.StringIO(text), delimiter=";"):
+            kod = (row.get("KOD") or "").strip()
+            nazev = (row.get("NAZEV") or "").strip()
+            if not kod or not nazev:
+                continue
+            result.append(
+                Kraj(
+                    kod=kod,
+                    nazev=nazev,
+                    nuts_lau=(row.get("NUTS_LAU") or "").strip() or None,
+                    zrusen=_plati_do(row),
+                )
+            )
+    return result
+
+
+def parse_okresy(data: bytes) -> list[Okres]:
+    """
+    Sloupce UI_OKRES.csv:
+    KOD;NAZEV;VUSC_KOD;NUTS_LAU;PLATI_OD;PLATI_DO;DATUM_VZNIKU
+    """
+    result: list[Okres] = []
+    for text in read_zipped_csvs(data):
+        for row in csv.DictReader(io.StringIO(text), delimiter=";"):
+            kod = (row.get("KOD") or "").strip()
+            nazev = (row.get("NAZEV") or "").strip()
+            kraj_kod = (row.get("VUSC_KOD") or "").strip()
+            if not kod or not nazev or not kraj_kod:
+                continue
+            result.append(
+                Okres(
+                    kod=kod,
+                    nazev=nazev,
+                    kraj_kod=kraj_kod,
+                    nuts_lau=(row.get("NUTS_LAU") or "").strip() or None,
+                    zrusen=_plati_do(row),
+                )
+            )
+    return result
+
+
+def parse_obce(data: bytes) -> list[Obec]:
+    """
+    Sloupce UI_OBEC.csv:
+    KOD;NAZEV;STATUS_KOD;POU_KOD;OKRES_KOD;CLENENI_SM_ROZSAH_KOD;CLENENI_SM_TYP_KOD;PLATI_OD;PLATI_DO;DATUM_VZNIKU
+
+    Souřadnice v tomto CSV nejsou; lat/lon bude None pokud nejsou dodány externě.
+    Pro doplnění souřadnic použij fetch_obec_coordinates() nebo vlastní tabulku.
+    """
+    result: list[Obec] = []
+    for text in read_zipped_csvs(data):
+        for row in csv.DictReader(io.StringIO(text), delimiter=";"):
+            kod = (row.get("KOD") or "").strip()
+            nazev = (row.get("NAZEV") or "").strip()
+            okres_kod = (row.get("OKRES_KOD") or "").strip()
+            if not kod or not nazev or not okres_kod:
+                continue
+            # Pokud by budoucí export souřadnice přidal, zpracujeme je zde
+            lat, lon = sjtsk_to_wgs84(
+                _parse_float(row.get("SOURADNICE_X")),
+                _parse_float(row.get("SOURADNICE_Y")),
+            )
+            result.append(
+                Obec(
+                    kod=kod,
+                    nazev=nazev,
+                    okres_kod=okres_kod,
+                    lat=lat,
+                    lon=lon,
+                    zrusen=_plati_do(row),
+                )
+            )
+    return result

ruian_import-0.1.0/tests/test_parse.py

@@ -0,0 +1,75 @@
+from pathlib import Path
+
+import pytest
+
+from ruian_import._arcgis import fetch_obec_coordinates
+from ruian_import._parse import parse_kraje, parse_obce, parse_okresy
+
+FIXTURES = Path(__file__).parent / "fixtures"
+
+
+def test_parse_kraje():
+    data = (FIXTURES / "UI_VUSC.zip").read_bytes()
+    kraje = parse_kraje(data)
+    assert len(kraje) > 0
+    kody = {k.kod for k in kraje}
+    assert "19" in kody  # Hlavní město Praha
+    for k in kraje:
+        assert k.kod
+        assert k.nazev
+    # platné kraje nemají datum zrušení
+    platne = [k for k in kraje if k.zrusen is None]
+    assert len(platne) > 0
+
+
+def test_parse_okresy():
+    data = (FIXTURES / "UI_OKRES.zip").read_bytes()
+    okresy = parse_okresy(data)
+    assert len(okresy) > 0
+    for o in okresy:
+        assert o.kod
+        assert o.nazev
+        assert o.kraj_kod
+
+
+def test_parse_obce():
+    data = (FIXTURES / "UI_OBEC.zip").read_bytes()
+    obce = parse_obce(data)
+    assert len(obce) > 5000  # ČR má ~6 200 obcí
+    for o in obce:
+        assert o.kod
+        assert o.nazev
+        assert o.okres_kod
+
+
+def test_kraj_nuts():
+    data = (FIXTURES / "UI_VUSC.zip").read_bytes()
+    kraje = parse_kraje(data)
+    nuts = {k.nuts_lau for k in kraje if k.nuts_lau}
+    assert any(n.startswith("CZ") for n in nuts)
+
+
+def test_okres_kraj_vazba():
+    kraje_data = (FIXTURES / "UI_VUSC.zip").read_bytes()
+    okresy_data = (FIXTURES / "UI_OKRES.zip").read_bytes()
+    kraj_kody = {k.kod for k in parse_kraje(kraje_data)}
+    for okres in parse_okresy(okresy_data):
+        assert okres.kraj_kod in kraj_kody, f"Okres {okres.nazev} má neznámý kraj_kod {okres.kraj_kod}"
+
+
+def test_obec_okres_vazba():
+    okresy_data = (FIXTURES / "UI_OKRES.zip").read_bytes()
+    obce_data = (FIXTURES / "UI_OBEC.zip").read_bytes()
+    okres_kody = {o.kod for o in parse_okresy(okresy_data)}
+    for obec in parse_obce(obce_data):
+        assert obec.okres_kod in okres_kody, f"Obec {obec.nazev} má neznámý okres_kod {obec.okres_kod}"
+
+
+@pytest.mark.network
+def test_fetch_obec_coordinates():
+    coords = fetch_obec_coordinates()
+    assert len(coords) > 5000
+    # Abertamy - kód 554979
+    lat, lon = coords["554979"]
+    assert 49 < lat < 51, f"Neočekávaná šířka: {lat}"
+    assert 12 < lon < 19, f"Neočekávaná délka: {lon}"