monumenten 0.1.0__py3-none-any.whl

monumenten/__init__.py

@@ -0,0 +1,5 @@
+"""Package for retrieving monument data from various Dutch government APIs."""
+
+from .client import MonumentenClient
+
+__all__ = ["MonumentenClient"]

monumenten/_api/_cultureel_erfgoed.py

@@ -0,0 +1,161 @@
+import asyncio
+import logging
+from typing import Any, Dict, List, Optional
+
+import aiohttp
+
+# Create a module-level logger
+logger = logging.getLogger("monumenten.api.cultureel_erfgoed")
+
+_CULTUREEL_ERFGOED_SPARQL_ENDPOINT = (
+    "https://api.linkeddata.cultureelerfgoed.nl/datasets/rce/cho/sparql"
+)
+
+_RIJKSMONUMENTEN_QUERY_TEMPLATE = """
+PREFIX ceo:<https://linkeddata.cultureelerfgoed.nl/def/ceo#>
+PREFIX bag:<http://bag.basisregistraties.overheid.nl/bag/id/>
+PREFIX rn:<https://data.cultureelerfgoed.nl/term/id/rn/>
+SELECT ?identificatie (MAX(?nummer) as ?rijksmonument_nummer)
+WHERE {{
+    ?monument ceo:heeftJuridischeStatus rn:b2d9a59a-fe1e-4552-9a05-3c2acddff864 ;
+              ceo:rijksmonumentnummer ?nummer ;
+              ceo:heeftBasisregistratieRelatie ?basisregistratieRelatie .
+    ?basisregistratieRelatie ceo:heeftBAGRelatie ?bagRelatie .
+    ?bagRelatie ceo:verblijfsobjectIdentificatie ?identificatie .
+    VALUES ?identificatie {{ {identificaties} }}
+}}
+GROUP BY ?identificatie
+"""
+
+_BESCHERMDE_GEZICHTEN_QUERY = """
+PREFIX ceo:<https://linkeddata.cultureelerfgoed.nl/def/ceo#>
+PREFIX rn:<https://data.cultureelerfgoed.nl/term/id/rn/>
+PREFIX geo: <http://www.opengis.net/ont/geosparql#>
+SELECT DISTINCT ?gezicht ?beschermd_gezicht_naam ?gezichtWKT
+WHERE {{
+  ?gezicht
+      ceo:heeftGeometrie ?gezichtGeometrie ;
+      ceo:heeftGezichtsstatus rn:fd968529-bf70-4afa-8564-7c6c2fcfcc54;
+      ceo:heeftNaam/ceo:naam ?beschermd_gezicht_naam.
+  ?gezichtGeometrie geo:asWKT ?gezichtWKT.
+}}
+"""
+
+_cultureel_erfgoed_semaphore: Optional[asyncio.Semaphore] = None
+
+
+def _get_semaphore(loop: asyncio.AbstractEventLoop) -> asyncio.Semaphore:
+    """
+    Verkrijgt een semaphore voor het beperken van gelijktijdige aanvragen naar de Cultureel Erfgoed API.
+
+    Args:
+        loop (asyncio.AbstractEventLoop): De asyncio event loop
+
+    Returns:
+        asyncio.Semaphore: Een asyncio.Semaphore object dat het aantal gelijktijdige aanvragen beperkt tot 4
+    """
+    global _cultureel_erfgoed_semaphore
+    if _cultureel_erfgoed_semaphore is None:
+        _cultureel_erfgoed_semaphore = asyncio.Semaphore(4)
+    return _cultureel_erfgoed_semaphore
+
+
+async def _query_rijksmonumenten(
+    session: aiohttp.ClientSession, identificaties: List[str]
+) -> List[Dict[str, Any]]:
+    """
+    Voert een SPARQL-query uit om rijksmonumenten op te halen voor gegeven BAG-identificaties.
+
+    Args:
+        session (aiohttp.ClientSession): De aiohttp ClientSession voor het uitvoeren van de HTTP-aanvraag
+        identificaties (List[str]): Lijst van BAG-identificaties waarvoor rijksmonumenten worden opgezocht
+
+    Returns:
+        List[Dict[str, Any]]: Lijst van dictionaries met informatie over gevonden rijksmonumenten
+
+    Raises:
+        aiohttp.ClientResponseError: Bij fouten in de HTTP-aanvraag na 3 pogingen
+    """
+    async with _get_semaphore(asyncio.get_running_loop()):
+        identificaties_str = " ".join(
+            f'"{identificatie}"' for identificatie in identificaties
+        )
+        query = _RIJKSMONUMENTEN_QUERY_TEMPLATE.format(
+            identificaties=identificaties_str
+        )
+        data = {"query": query, "format": "json"}
+        retries = 3
+        for poging in range(retries):
+            try:
+                async with session.post(
+                    _CULTUREEL_ERFGOED_SPARQL_ENDPOINT, data=data
+                ) as response:
+                    response.raise_for_status()
+                    resultaat = await response.json()
+                    if isinstance(resultaat, list):
+                        return resultaat
+                    else:
+                        logger.warning(
+                            "Unexpected response format on attempt %d: %s",
+                            poging + 1,
+                            resultaat,
+                        )
+            except aiohttp.ClientResponseError as e:
+                if poging != retries - 1:
+                    logger.warning(
+                        "Poging %d/%d voor rijksmonumenten query mislukt: %s. Opnieuw proberen over 1 seconde...",
+                        poging + 1,
+                        retries,
+                        str(e),
+                    )
+                    await asyncio.sleep(1)
+                else:
+                    raise
+        return List[Dict[str, Any]]()
+
+
+async def _query_beschermde_gebieden(
+    session: aiohttp.ClientSession,
+) -> List[Dict[str, Any]]:
+    """
+    Voert een SPARQL-query uit om beschermde stads- en dorpsgezichten op te halen.
+
+    Args:
+        session (aiohttp.ClientSession): De aiohttp ClientSession voor het uitvoeren van de HTTP-aanvraag
+
+    Returns:
+        List[Dict[str, Any]]: Lijst van dictionaries met informatie over beschermde stads- en dorpsgezichten
+
+    Raises:
+        aiohttp.ClientResponseError: Bij fouten in de HTTP-aanvraag na 3 pogingen
+    """
+    retries = 3
+    for poging in range(retries):
+        try:
+            data = {"query": _BESCHERMDE_GEZICHTEN_QUERY, "format": "json"}
+
+            async with session.post(
+                _CULTUREEL_ERFGOED_SPARQL_ENDPOINT, data=data
+            ) as response:
+                response.raise_for_status()
+                resultaat = await response.json()
+                if isinstance(resultaat, list):
+                    return resultaat
+                else:
+                    logger.warning(
+                        "Onverwacht response formaat bij poging %d: %s",
+                        poging + 1,
+                        resultaat,
+                    )
+        except aiohttp.ClientResponseError as e:
+            if poging != retries - 1:
+                logger.warning(
+                    "Poging %d/%d voor beschermde gebieden query mislukt: %s. Opnieuw proberen over 1 seconde...",
+                    poging + 1,
+                    retries,
+                    str(e),
+                )
+                await asyncio.sleep(1)
+            else:
+                raise
+    return List[Dict[str, Any]]()

monumenten/_api/_kadaster.py

@@ -0,0 +1,77 @@
+import asyncio
+import logging
+from typing import Any, Dict, List, Optional
+
+import aiohttp
+
+_KADASTER_SPARQL_ENDPOINT = (
+    "https://api.labs.kadaster.nl/datasets/dst/kkg/services/default/sparql"
+)
+
+_VERBLIJFSOBJECTEN_QUERY_TEMPLATE = """
+PREFIX sor: <https://data.kkg.kadaster.nl/sor/model/def/>
+PREFIX nen3610: <https://data.kkg.kadaster.nl/nen3610/model/def/>
+PREFIX geo: <http://www.opengis.net/ont/geosparql#>
+SELECT DISTINCT ?identificatie ?verblijfsobjectWKT
+WHERE {{
+  ?verblijfsobject sor:geregistreerdMet/nen3610:identificatie ?identificatie .
+  ?verblijfsobject geo:hasGeometry/geo:asWKT ?verblijfsobjectWKT.
+  FILTER (?identificatie IN ( {identificaties} ))
+}}
+"""
+
+_kadaster_semaphore: Optional[asyncio.Semaphore] = None
+
+# Create a module-level logger
+logger = logging.getLogger("monumenten.api.kadaster")
+
+
+def _get_semaphore(loop: asyncio.AbstractEventLoop) -> asyncio.Semaphore:
+    global _kadaster_semaphore
+    if _kadaster_semaphore is None:
+        _kadaster_semaphore = asyncio.Semaphore(4)
+    return _kadaster_semaphore
+
+
+async def _query_verblijfsobjecten(
+    session: aiohttp.ClientSession, identificaties: List[str]
+) -> List[Dict[str, Any]]:
+    async with _get_semaphore(asyncio.get_running_loop()):
+        identificaties_str = ", ".join(
+            f'"{identificatie}"' for identificatie in identificaties
+        )
+        query = _VERBLIJFSOBJECTEN_QUERY_TEMPLATE.format(
+            identificaties=identificaties_str
+        )
+        data = {"query": query, "format": "json"}
+        retries = 3
+        for poging in range(retries):
+            try:
+                async with session.post(
+                    _KADASTER_SPARQL_ENDPOINT, data=data
+                ) as response:
+                    response.raise_for_status()
+                    resultaat = await response.json()
+                    if isinstance(resultaat, list):
+                        return resultaat
+                    else:
+                        logger.warning(
+                            "Onverwacht response formaat bij poging %d: %s",
+                            poging + 1,
+                            resultaat,
+                        )
+            except aiohttp.ClientResponseError as e:
+                if poging != retries - 1:
+                    logger.warning(
+                        "Poging %d/%d voor verblijfsobjecten query mislukt: %s. Opnieuw proberen over 1 seconde...",
+                        poging + 1,
+                        retries,
+                        str(e),
+                    )
+                    await asyncio.sleep(1)
+                else:
+                    logger.error(
+                        "Alle pogingen voor verblijfsobjecten query mislukt: %s", str(e)
+                    )
+                    raise
+        return List[Dict[str, Any]]()

monumenten/_processing.py

@@ -0,0 +1,151 @@
+"""Interne processing functies voor de monumenten package."""
+
+import asyncio
+from typing import Any, Dict, List, Tuple
+
+import aiohttp
+import geopandas as gpd
+import pandas as pd
+from tqdm.asyncio import tqdm_asyncio
+
+from monumenten._api._cultureel_erfgoed import (
+    _query_beschermde_gebieden,
+    _query_rijksmonumenten,
+)
+from monumenten._api._kadaster import _query_verblijfsobjecten
+
+_QUERY_BATCH_GROOTTE = 500  # lijkt meest optimaal qua performance
+
+
+async def _verzamel_data(
+    session: aiohttp.ClientSession,
+    identificaties_batch: List[str],
+) -> Tuple[List[Dict[str, Any]], List[Dict[str, Any]]]:
+    """Verzamel data van verschillende API's voor een batch verblijfsobjecten.
+
+    Args:
+        session (aiohttp.ClientSession): De sessie voor HTTP requests
+        identificaties_batch (List[str]): Lijst met verblijfsobject ID's
+
+    Returns:
+        Tuple[List[Dict[str, Any]], List[Dict[str, Any]]]: Tuple met rijksmonumenten en verblijfsobjecten data
+    """
+    rijksmonumenten_taak = _query_rijksmonumenten(session, identificaties_batch)
+    verblijfsobjecten_taak = _query_verblijfsobjecten(session, identificaties_batch)
+    return await asyncio.gather(rijksmonumenten_taak, verblijfsobjecten_taak)
+
+
+async def _process_batch(
+    session: aiohttp.ClientSession, batch: List[str], bg_df: gpd.GeoDataFrame
+) -> Tuple[List[Dict[str, Any]], List[Dict[str, Any]], int]:
+    """Verwerk een batch verblijfsobjecten.
+
+    Args:
+        session (aiohttp.ClientSession): De sessie voor HTTP requests
+        batch (List[str]): Lijst met verblijfsobject ID's
+        bg_df (gpd.GeoDataFrame): GeoDataFrame met beschermde gezichten
+
+    Returns:
+        Tuple[List[Dict[str, Any]], List[Dict[str, Any]], int]: Tuple met rijksmonumenten,
+            beschermde gezichten en aantal verwerkte objecten
+    """
+    # Get the current event loop
+    loop = asyncio.get_running_loop()
+
+    # Create tasks using the current loop
+    rijksmonumenten_taak = loop.create_task(_query_rijksmonumenten(session, batch))
+    verblijfsobjecten_taak = loop.create_task(_query_verblijfsobjecten(session, batch))
+
+    # Wait for both tasks to complete
+    rijksmonumenten, verblijfsobjecten = await asyncio.gather(
+        rijksmonumenten_taak, verblijfsobjecten_taak
+    )
+
+    # Process 'verblijfsobjecten' into GeoDataFrame
+    if verblijfsobjecten:
+        vo_df = pd.DataFrame(verblijfsobjecten)
+        vo_df["geometry"] = gpd.GeoSeries.from_wkt(vo_df["verblijfsobjectWKT"])
+        vo_df = gpd.GeoDataFrame(
+            vo_df[["identificatie", "geometry"]], geometry="geometry"
+        )
+    else:
+        vo_df = gpd.GeoDataFrame(columns=["identificatie", "geometry"])
+
+    # Perform spatial join
+    if not vo_df.empty:
+        joined_df = gpd.sjoin(vo_df, bg_df, how="left", predicate="within")
+
+        verblijfsobjecten_in_beschermd_gezicht = joined_df[
+            ["identificatie", "beschermd_gezicht_naam"]
+        ].to_dict("records")
+    else:
+        verblijfsobjecten_in_beschermd_gezicht = List[Dict[str, Any]]()
+
+    return rijksmonumenten, verblijfsobjecten_in_beschermd_gezicht, len(batch)
+
+
+async def _query(
+    session: aiohttp.ClientSession, verblijfsobject_ids: List[str]
+) -> pd.DataFrame:
+    """Voer queries uit voor een lijst verblijfsobjecten.
+
+    Args:
+        session (aiohttp.ClientSession): De sessie voor HTTP requests
+        verblijfsobject_ids (List[str]): Lijst met verblijfsobject ID's
+
+    Returns:
+        pd.DataFrame: DataFrame met monumentinformatie
+    """
+    # Load 'beschermde_gebieden' and convert to GeoDataFrame
+    beschermde_gebieden = await _query_beschermde_gebieden(session)
+    bg_df = gpd.GeoDataFrame()
+
+    if beschermde_gebieden:
+        bg_df = pd.DataFrame(beschermde_gebieden)
+        bg_df["geometry"] = gpd.GeoSeries.from_wkt(bg_df["gezichtWKT"])
+        bg_df = gpd.GeoDataFrame(
+            bg_df[["beschermd_gezicht_naam", "geometry"]], geometry="geometry"
+        )
+
+    # Ensure spatial index is built
+    bg_df.sindex
+
+    rijksmonumenten_result = list[Dict[str, Any]]()
+    verblijfsobjecten_in_beschermd_gezicht_result = list[Dict[str, Any]]()
+
+    # Prepare batches
+    batches = [
+        verblijfsobject_ids[i : i + _QUERY_BATCH_GROOTTE]
+        for i in range(0, len(verblijfsobject_ids), _QUERY_BATCH_GROOTTE)
+    ]
+
+    # Create tasks for each batch
+    tasks = [_process_batch(session, batch, bg_df) for batch in batches]
+
+    progress_bar = tqdm_asyncio(total=len(verblijfsobject_ids))
+
+    for task in asyncio.as_completed(tasks):
+        result = await task
+        rijksmonumenten_result.extend(result[0])
+        verblijfsobjecten_in_beschermd_gezicht_result.extend(result[1])
+        progress_bar.update(result[2])
+
+    progress_bar.close()
+
+    df_rijksmonumenten = (
+        pd.DataFrame(rijksmonumenten_result)
+        if rijksmonumenten_result
+        else pd.DataFrame({"identificatie": [], "rijksmonument_nummer": []})
+    )
+
+    df_beschermd_gezicht = (
+        pd.DataFrame(verblijfsobjecten_in_beschermd_gezicht_result)
+        if verblijfsobjecten_in_beschermd_gezicht_result
+        else pd.DataFrame({"identificatie": [], "beschermd_gezicht_naam": []})
+    )
+
+    result = pd.merge(
+        df_rijksmonumenten, df_beschermd_gezicht, on="identificatie", how="outer"
+    )
+
+    return result

monumenten/_version.py

@@ -0,0 +1,16 @@
+# file generated by setuptools_scm
+# don't change, don't track in version control
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple, Union
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '0.1.0'
+__version_tuple__ = version_tuple = (0, 1, 0)

monumenten/client.py

@@ -0,0 +1,110 @@
+"""Client voor monumenten package."""
+
+from typing import Any, Dict, List, Optional
+
+import aiohttp
+import pandas as pd
+
+from monumenten._processing import _query
+
+
+class MonumentenClient:
+    """Client voor het ophalen van monumentgegevens van verschillende Nederlandse overheids-API's.
+
+    Args:
+        session (Optional[aiohttp.ClientSession]): Optionele aiohttp.ClientSession. Indien niet opgegeven wordt
+                een nieuwe sessie aangemaakt en beheerd door de client.
+    """
+
+    def __init__(self, session: Optional[aiohttp.ClientSession] = None) -> None:
+        self._session = session
+        self._owns_session = session is None
+
+    async def __aenter__(self) -> "MonumentenClient":
+        if self._owns_session:
+            self._session = aiohttp.ClientSession()
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: Optional[type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[Any],
+    ) -> None:
+        if self._owns_session and self._session:
+            await self._session.close()
+
+    async def process_from_df(
+        self,
+        df: pd.DataFrame,
+        verblijfsobject_id_col: str,
+    ) -> pd.DataFrame:
+        """Verwerk een DataFrame met verblijfsobject ID's.
+
+        Args:
+            df (pd.DataFrame): Input DataFrame met verblijfsobject ID's
+            verblijfsobject_id_col (str): Naam van de kolom met de verblijfsobject ID's
+
+        Returns:
+            pd.DataFrame: DataFrame met toegevoegde monumentinformatie
+
+        Raises:
+            RuntimeError: Als de client niet als context manager wordt gebruikt
+        """
+        if not self._session:
+            raise RuntimeError("Client must be used as a context manager")
+
+        results = await _query(
+            self._session, df[verblijfsobject_id_col].drop_duplicates()
+        )
+        merged = pd.merge(
+            df, results, left_on=verblijfsobject_id_col, right_on="identificatie"
+        )
+
+        if "identificatie" not in df.columns:
+            merged = merged.drop(columns=["identificatie"])
+
+        rijksmonument_nummer_position = merged.columns.get_loc("rijksmonument_nummer")
+        merged.insert(
+            rijksmonument_nummer_position + 1,
+            "rijksmonument_url",
+            "https://monumenten.nl/monument/"
+            + merged["rijksmonument_nummer"]
+            .fillna("")
+            .astype(str)
+            .where(merged["rijksmonument_nummer"].notna(), None),
+        )
+
+        merged.insert(
+            rijksmonument_nummer_position,
+            "is_rijksmonument",
+            merged["rijksmonument_nummer"].notna(),
+        )
+
+        beschermd_gezicht_naam_position = merged.columns.get_loc(
+            "beschermd_gezicht_naam"
+        )
+
+        merged.insert(
+            beschermd_gezicht_naam_position,
+            "is_beschermd_gezicht",
+            merged["beschermd_gezicht_naam"].notna(),
+        )
+
+        return merged
+
+    async def process_from_list(
+        self, verblijfsobject_ids: List[str]
+    ) -> List[Dict[str, Any]]:
+        """Verwerk een lijst met verblijfsobject ID's.
+
+        Args:
+            verblijfsobject_ids (List[str]): Lijst met te verwerken ID's
+
+        Returns:
+            List[Dict[str, Any]]: Lijst met dictionaries met monumentinformatie
+        """
+        df = pd.DataFrame({"bag_verblijfsobject_id": verblijfsobject_ids})
+        result = await self.process_from_df(df, "bag_verblijfsobject_id")
+        result = result.replace({pd.NA: None, pd.NaT: None})
+        return list(result.to_dict(orient="records"))

monumenten-0.1.0.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Woonstad Rotterdam
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

monumenten-0.1.0.dist-info/METADATA

@@ -0,0 +1,169 @@
+Metadata-Version: 2.1
+Name: monumenten
+Version: 0.1.0
+Summary: Checkt op basis van BAG verblijfsobject-ids of het verblijfsobject een monument en/of beschermd stadsgezicht is.
+Author-email: Woonstad Rotterdam <info@woonstadrotterdam.nl>, Ben Verhees <ben.verhees@woonstadrotterdam.nl>, Tomer Gabay <tomer.gabay@woonstadrotterdam.nl>
+License: MIT License
+        
+        Copyright (c) 2024 Woonstad Rotterdam
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/woonstadrotterdam/monumenten
+Project-URL: Issues, https://github.com/woonstadrotterdam/monumenten/issues
+Keywords: monument,bag,stadsgezicht,monumentenregister,beschermd
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9.5
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aiohttp>=3.10.10
+Requires-Dist: Shapely>=2.0.6
+Requires-Dist: tqdm>=4.66.5
+Requires-Dist: pandas>=2.0.0
+Requires-Dist: geopandas>=1.0.1
+Provides-Extra: dev
+Requires-Dist: monumenten[test]; extra == "dev"
+Requires-Dist: ruff==0.4.8; extra == "dev"
+Provides-Extra: test
+Requires-Dist: pre-commit==3.*; extra == "test"
+Requires-Dist: pytest==8.*; extra == "test"
+Requires-Dist: pytest-cov==5.*; extra == "test"
+Requires-Dist: pytest-asyncio==0.24.*; extra == "test"
+
+# Monumenten
+
+Een Python package voor het ophalen van monumentgegevens van Nederlandse overheids-API's. Momenteel is het mogelijk om rijksmonumenten en beschermd gezichten op te halen.
+
+Door middel van dit package is het mogelijk om, indienst gewenst, voor tienduizenden verblijfsobjecten per seconde monumentgegevens op te halen. Er zijn geen API-keys nodig.
+
+## Installatie
+
+`pip install monumenten`
+
+## Gebruik
+
+### Python-native 🐍
+
+```python
+import asyncio
+
+from monumenten import MonumentenClient
+
+async def main():
+    bag_verblijfsobject_ids = [
+        "0599010000360091",
+        "0599010000486642",
+        "0599010000281115",
+    ]
+
+    async with MonumentenClient() as client:
+        result = await client.process_from_list(bag_verblijfsobject_ids)
+        print(result)
+
+# in een .py file"
+if __name__ == "__main__":
+    asyncio.run(main())
+
+# in een .ipynb file (notebook):
+await main()
+```
+
+```python
+# OUTPUT
+[
+    {
+        'bag_verblijfsobject_id': '0599010000360091',
+        'is_rijksmonument': True,
+        'rijksmonument_nummer': '524327',
+        'rijksmonument_url': 'https://monumenten.nl/monument/524327',
+        'is_beschermd_gezicht': False,
+        'beschermd_gezicht_naam': None
+    },
+    {
+        'bag_verblijfsobject_id': '0599010000486642',
+        'is_rijksmonument': False,
+        'rijksmonument_nummer': None,
+        'rijksmonument_url': None,
+        'is_beschermd_gezicht': False,
+        'beschermd_gezicht_naam': None
+    },
+    {
+        'bag_verblijfsobject_id': '0599010000281115',
+        'is_rijksmonument': False,
+        'rijksmonument_nummer': None,
+        'rijksmonument_url': None,
+        'is_beschermd_gezicht': True,
+        'beschermd_gezicht_naam': 'Kralingen - Midden'
+    }
+]
+```
+
+### Met pandas 🐼
+
+```python
+import asyncio
+
+import pandas as pd
+from monumenten import MonumentenClient
+
+
+async def main():
+
+    input_df = pd.DataFrame(
+        {
+            "bag_verblijfsobject_id": [
+                "0599010000360091",
+                "0599010000486642",
+                "0599010000360022",
+                "0599010000360096",
+                "0599010000183527",
+                "0599010400025880",
+                "0599010000281115",
+            ]
+        }
+    ) # of lees van een csv of een ander bestand in
+
+    async with MonumentenClient() as client:
+        result = await client.process_from_df(
+            df=input_df, verblijfsobject_id_col="bag_verblijfsobject_id"
+        )
+        result.to_csv("monumenten.csv", index=False)
+
+# in een .py file"
+if __name__ == "__main__":
+    asyncio.run(main())
+
+# in een .ipynb file (notebook):
+await main()
+```
+
+| bag_verblijfsobject_id | is_rijksmonument | rijksmonument_nummer | rijksmonument_url                     | is_beschermd_gezicht | beschermd_gezicht_naam          |
+| ---------------------- | ---------------- | -------------------- | ------------------------------------- | -------------------- | ------------------------------- |
+| 0599010000360091       | True             | 524327               | https://monumenten.nl/monument/524327 | False                |                                 |
+| 0599010000486642       | False            |                      |                                       | False                |                                 |
+| 0599010000360022       | True             | 524327               | https://monumenten.nl/monument/524327 | False                |                                 |
+| 0599010000360096       | True             | 524327               | https://monumenten.nl/monument/524327 | False                |                                 |
+| 0599010000183527       | True             | 32807                | https://monumenten.nl/monument/32807  | True                 | Rotterdam - Scheepvaartkwartier |
+| 0599010400025880       | False            |                      |                                       | False                |                                 |
+| 0599010000281115       | False            |                      |                                       | True                 | Kralingen - Midden              |

monumenten-0.1.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+monumenten/__init__.py,sha256=RsPjyAQJ3mi43ICefZQUEnqqWrwXk9xQXIq_VxnQwKk,149
+monumenten/_processing.py,sha256=mSionFmOoIbQxmcASiDjRmCeOD_aib1EefDSwkFCsYg,5292
+monumenten/_version.py,sha256=IMl2Pr_Sy4LVRKy_Sm4CdwUl1Gryous6ncL96EMYsnM,411
+monumenten/client.py,sha256=6VsQbxpf_aMeEfYQVT3guFGSCOFGm6r4SGcqic0nd0Q,3585
+monumenten/logging.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+monumenten/_api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+monumenten/_api/_cultureel_erfgoed.py,sha256=zJkkhM1xUrBFOJ16eVfrPv071vCHuc4IDXO_Dz4b8EI,5975
+monumenten/_api/_kadaster.py,sha256=8aBJ4Et2QDpJuxq-CX2wX4z10MYsLhHhZHq5J2no6Sw,2808
+monumenten-0.1.0.dist-info/LICENSE,sha256=XHXrWnYTM8HAM7azt1zAhsP6aD-sM-2DPoUAfoYx57Y,1075
+monumenten-0.1.0.dist-info/METADATA,sha256=GRhssvq7fAODyiCGga_LflQoWmAL6xYY61HcKTZj55M,6795
+monumenten-0.1.0.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
+monumenten-0.1.0.dist-info/top_level.txt,sha256=evniMq34R8O_etXp8lHeRW7ESy32fbZvjUmDtMrLg2s,11
+monumenten-0.1.0.dist-info/RECORD,,

monumenten-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.3.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

monumenten-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+monumenten