kvk-connect 0.1.6__py3-none-any.whl

kvk_connect/models/orm/vestigingsprofiel_orm.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+from datetime import UTC, datetime
+
+from sqlalchemy import Date, DateTime, Float, Index, Integer, String
+from sqlalchemy.orm import Mapped, mapped_column
+
+from kvk_connect.models.orm.base import Base
+
+
+class VestigingsProfielORM(Base):
+    __tablename__ = "vestigingsprofielen"
+
+    # Primary key
+    vestigingsnummer: Mapped[str] = mapped_column("vestigingsnummer", String(12), primary_key=True, index=True)
+
+    # Correspondentie adres velden
+    cor_adres_volledig: Mapped[str | None] = mapped_column("corAdresVolledig", String(500))
+    cor_adres_postcode: Mapped[str | None] = mapped_column("corAdresPostcode", String(16))
+    cor_adres_postbusnummer: Mapped[int | None] = mapped_column("corAdresPostbusnummer", Integer)
+    cor_adres_plaats: Mapped[str | None] = mapped_column("corAdresPlaats", String(255))
+    cor_adres_land: Mapped[str | None] = mapped_column("corAdresLand", String(100))
+
+    # Bezoek adres velden
+    bzk_adres_volledig: Mapped[str | None] = mapped_column("bzkAdresVolledig", String(500))
+    bzk_adres_straatnaam: Mapped[str | None] = mapped_column("bzkAdresStraatnaam", String(255))
+    bzk_adres_huisnummer: Mapped[int | None] = mapped_column("bzkAdresHuisnummer", Integer)
+    bzk_adres_postcode: Mapped[str | None] = mapped_column("bzkAdresPostcode", String(16))
+    bzk_adres_plaats: Mapped[str | None] = mapped_column("bzkAdresPlaats", String(255))
+    bzk_adres_land: Mapped[str | None] = mapped_column("bzkAdresLand", String(100))
+
+    # GPS coördinaten
+    bzk_adres_gps_latitude: Mapped[float | None] = mapped_column("bzkAdresGpsLatitude", Float)
+    bzk_adres_gps_longitude: Mapped[float | None] = mapped_column("bzkAdresGpsLongitude", Float)
+
+    # Registratie datums
+    registratie_datum_aanvang_vestiging: Mapped[datetime | None] = mapped_column(
+        "RegistratieDatumAanvangVestiging", Date
+    )
+    registratie_datum_einde_vestiging: Mapped[datetime | None] = mapped_column("RegistratieDatumEindeVestiging", Date)
+
+    # Timestamp velden met defaults
+    created_at: Mapped[datetime] = mapped_column(
+        "created_at", DateTime(timezone=True), default=lambda: datetime.now(UTC)
+    )
+
+    last_updated: Mapped[datetime] = mapped_column(
+        "last_updated",
+        DateTime(timezone=True),
+        default=lambda: datetime.now(UTC),
+        onupdate=lambda: datetime.now(UTC),
+        index=True,  # Index voor last_updated filtering
+    )
+
+    __table_args__ = (
+        # Index voor joins met kvkvestigingen
+        Index("ix_vestigingsprofiel_vest_updated", vestigingsnummer, last_updated),
+    )

kvk_connect/services/__init__.py

@@ -0,0 +1,4 @@
+# mappers package initialization
+from .record_service import KVKRecordService
+
+__all__ = ["KVKRecordService"]

kvk_connect/services/record_service.py

@@ -0,0 +1,66 @@
+import logging
+
+from kvk_connect.api.client import KVKApiClient
+from kvk_connect.mappers.kvk_record_mapper import map_kvkbasisprofiel_api_to_kvkrecord
+from kvk_connect.mappers.map_vestigingen_api_to_vestigingsnummers import map_vestigingen_api_to_vestigingsnummers
+from kvk_connect.mappers.map_vestigingsprofiel_api_to_vestigingsprofiel_domain import (
+    map_vestigingsprofiel_api_to_vestigingsprofiel_domain,
+)
+from kvk_connect.models.domain import KvKVestigingsNummersDomain
+from kvk_connect.models.domain.basisprofiel import BasisProfielDomain
+from kvk_connect.models.domain.vestigingsprofiel_domain import VestigingsProfielDomain
+from kvk_connect.utils.tools import clean_and_pad
+
+logger = logging.getLogger(__name__)
+
+
+class KVKRecordService:
+    """Service for fetching and mapping KVK records to domain models."""
+
+    def __init__(self, client: KVKApiClient) -> None:
+        self.client = client
+
+    def get_basisprofiel(self, kvk_nummer: str) -> BasisProfielDomain | None:
+        """Fetch and map basisprofiel for a given KVK number.
+
+        Returns:
+            BasisProfielDomain if found, None otherwise.
+        """
+        kvk_nummer = clean_and_pad(kvk_nummer)
+        bp_api = self.client.get_basisinformatie(kvk_nummer)
+
+        if bp_api is None:
+            logger.info("No basisprofiel found for KVK number %s", kvk_nummer)
+            return None
+
+        return map_kvkbasisprofiel_api_to_kvkrecord(bp_api)
+
+    def get_vestigingen(self, kvk_nummer: str) -> KvKVestigingsNummersDomain | None:
+        """Fetch and map vestigingen for a given KVK number.
+
+        Returns:
+            KvKVestigingsNummersDomain if found, None otherwise.
+        """
+        kvk_nummer = clean_and_pad(kvk_nummer)
+        vn_api = self.client.get_vestigingen(kvk_nummer)
+
+        if vn_api is None:
+            logger.info("No vestigingen found for KVK number %s", kvk_nummer)
+            return None
+
+        return map_vestigingen_api_to_vestigingsnummers(vn_api)
+
+    def get_vestigingsprofiel(self, vestigings_nummer: str) -> VestigingsProfielDomain | None:
+        """Fetch and map vestigingsprofiel for a given vestigingsnummer.
+
+        Returns:
+            VestigingsProfielDomain if found, None otherwise.
+        """
+        vestigings_nummer = clean_and_pad(vestigings_nummer)
+        vp_api = self.client.get_vestigingsprofiel(vestigings_nummer, geo_data=True)
+
+        if vp_api is None:
+            logger.info("No vestigingsprofiel found for vestigingsnummer %s", vestigings_nummer)
+            return None
+
+        return map_vestigingsprofiel_api_to_vestigingsprofiel_domain(vp_api)

kvk_connect/utils/__init__.py

@@ -0,0 +1,5 @@
+from .env import get_env
+from .formatting import truncate_float
+from .rate_limit import global_rate_limit
+
+__all__ = ["get_env", "truncate_float", "global_rate_limit"]

kvk_connect/utils/env.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+import os
+
+from dotenv import load_dotenv
+
+load_dotenv()
+
+
+def get_env(name: str, default: str | None = None, required: bool = False) -> str | None:
+    """Haal een omgevingsvariabele op."""
+
+    value = os.getenv(name, default)
+    if required and value is None:
+        raise RuntimeError(f"Missing required environment variable: {name}")
+    return value

kvk_connect/utils/formatting.py

@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+
+def truncate_float(value: float | None, digits: int = 5) -> str:
+    """Truncate a float to a given number of digits after the decimal point and return as string."""
+
+    if value is None or value == 0.0:
+        return ""
+    factor = 10**digits
+    truncated = int(value * factor) / factor
+    return f"{truncated:.{digits}f}".replace(".", ",")

kvk_connect/utils/rate_limit.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+import os
+
+from ratelimit import limits, sleep_and_retry
+
+RATE_LIMIT_CALLS = int(os.getenv("RATE_LIMIT_CALLS", "100"))
+
+
+def global_rate_limit(calls: int = RATE_LIMIT_CALLS, period: int = 1):
+    """Decorator to apply a global rate limit to a function."""
+
+    def deco(func):
+        @sleep_and_retry
+        @limits(calls=calls, period=period)
+        def wrapper(*args, **kwargs):
+            return func(*args, **kwargs)
+
+        return wrapper
+
+    return deco

kvk_connect/utils/tools.py

@@ -0,0 +1,131 @@
+from __future__ import annotations
+
+import json
+import logging
+import re
+from datetime import UTC, date, datetime, timedelta
+
+logger = logging.getLogger(__name__)
+
+
+def parse_kvk_datum(datum_str: str | None) -> date | None:
+    """Parse een KVK datum string naar een date object.
+
+    Ondersteunt:
+    - DD-MM-YYYY (standaard KVK formaat)
+    - YYYYMMDD (8 cijfers)
+    - YYYYMM00 (6 cijfers + 00, zet dag op 1)
+    - YYYY0000 (4 cijfers + 0000, zet maand en dag op 1)
+
+    Args:
+        datum_str: Datum string of None
+
+    Returns:
+        date object of None bij ongeldige/lege input
+    """
+    if datum_str is None or str(datum_str).strip() in ("", "None"):
+        return None
+
+    datum_str = str(datum_str).strip()
+
+    # Probeer standaard DD-MM-YYYY formaat
+    try:
+        return datetime.strptime(datum_str, "%d-%m-%Y").date()
+    except ValueError:
+        pass
+
+    # Probeer YYYYMMDD formaat (8 cijfers)
+    if datum_str.isdigit() and len(datum_str) == 8:
+        try:
+            year = int(datum_str[0:4])
+            month = int(datum_str[4:6])
+            day = int(datum_str[6:8])
+
+            # Als maand of dag 0 is, zet op 1
+            if month == 0:
+                month = 1
+            if day == 0:
+                day = 1
+
+            return date(year, month, day)
+        except (ValueError, OverflowError) as e:
+            logger.warning("Ongeldige datum conversie voor '%s': {%s}", datum_str, e)
+            return None
+
+    logger.warning("Ongeldige datum conversie voor '%s': geen geldig formaat", datum_str)
+    return None
+
+
+def truncate_float(value: float | None, digits: int = 5) -> str:
+    """Truncate a float to a given number of digits after the decimal point and return as string.
+
+    If value is None, return empty string.
+    """
+    if value is None or value == 0.0:
+        return ""
+    factor = 10**digits
+    truncated = int(value * factor) / factor
+    # Format with fixed number of digits en gebruik komma als decimaalteken
+    return f"{truncated:.{digits}f}".replace(".", ",")
+
+
+def clean_and_pad(s, fill=8):
+    """Strip non-digit characters from start/end and pad to given length with leading zeros."""
+
+    cleaned = re.sub(r"[^\d]", "", s)
+    # Pad to 8 digits
+    return cleaned.zfill(fill)
+
+
+def formatteer_datum(datum_str):
+    """Formatteer een datum string van YYYYMMDD naar DD-MM-YYYY. Retourneer None bij "None"."""
+
+    if datum_str != "None":
+        try:
+            return datetime.strptime(datum_str, "%Y%m%d").strftime("%d-%m-%Y")
+        except ValueError:
+            return datum_str
+    else:
+        return None
+
+
+def print_response(_response):
+    """Prints the response from a requests call in a formatted way. Handles JSON and non-JSON responses."""
+
+    print("url:", _response.url)
+    print("Status code:", _response.status_code)
+    try:
+        data = _response.json()
+        print("Response data (JSON):")
+        print(json.dumps(data, indent=4))
+    except ValueError:
+        print("Response data (text):")
+        print(_response.text)
+
+
+def get_timeselector(selected_from: datetime, selected_to: datetime) -> list[dict[str, datetime]]:
+    """Gegeven twee datetime timestamps.Returned een lijst met from-to dicts terug van maximaal een week.
+
+    Wordt gebruikt om pagination van mutaties op te halen deze mogen maximaal per week opgehaald worden
+    """
+
+    def to_utc(dt: datetime) -> datetime:
+        return dt.astimezone(UTC) if dt.tzinfo else dt.replace(tzinfo=UTC)
+
+    def split_into_chunks(start: datetime, end: datetime, days: int = 7) -> list[dict[str, datetime]]:
+        out: list[dict[str, datetime]] = []
+        cur = start
+        step = timedelta(days=days)
+        while cur < end:
+            nxt = min(cur + step, end)
+            out.append({"from": cur, "to": nxt})
+            cur = nxt
+        return out
+
+    # Normalize selection to UTC and ensure ascending order
+    sf, st = to_utc(selected_from), to_utc(selected_to)
+    if st < sf:
+        logger.warning("Selected time from is farther into the future than the selected time to.")
+        return []
+    else:
+        return split_into_chunks(sf, st)