kvk-connect 0.1.6__py3-none-any.whl

kvk_connect/db/vestigingenprofiel_reader.py

@@ -0,0 +1,66 @@
+from sqlalchemy import select
+from sqlalchemy.orm import Session
+
+from kvk_connect.models.orm.kvkvestigingen_orm import VestigingenORM
+from kvk_connect.models.orm.signaal_orm import SignaalORM
+from kvk_connect.models.orm.vestigingsprofiel_orm import VestigingsProfielORM
+
+
+class VestigingsProfielReader:
+    def __init__(self, engine):
+        self.engine = engine
+
+    def get_vestigingen_zonder_vestigingsprofielen(self) -> list[str]:
+        """Haalt alle vestigingsnummers op die wel in kvk_vestigingen staan maar nog niet in vestigingsprofielen.
+
+        Returns:
+            list[str]: Lijst met vestigingsnummers zonder vestigingsprofiel
+        """
+        with Session(self.engine) as session:
+            stmt = (
+                select(VestigingenORM.vestigingsnummer)
+                .outerjoin(
+                    VestigingsProfielORM, VestigingenORM.vestigingsnummer == VestigingsProfielORM.vestigingsnummer
+                )
+                .where(VestigingsProfielORM.vestigingsnummer.is_(None))
+                .where(VestigingenORM.vestigingsnummer != VestigingenORM.SENTINEL_VESTIGINGSNUMMER)
+                .distinct()
+            )
+
+            result = session.execute(stmt)
+            return [row[0] for row in result.fetchall()]
+
+    def get_outdated_vestigingen(self) -> list[str]:
+        """Return lijst van vestigingsnummers met vestiging nieuwer dan de lastupdated van het vestigingenprofiel."""
+
+        with Session(self.engine) as session:
+            stmt = (
+                select(VestigingenORM.vestigingsnummer)
+                .join(VestigingsProfielORM, VestigingenORM.vestigingsnummer == VestigingsProfielORM.vestigingsnummer)
+                .where(VestigingenORM.last_updated > VestigingsProfielORM.last_updated)
+                .where(VestigingenORM.vestigingsnummer != VestigingenORM.SENTINEL_VESTIGINGSNUMMER)
+                .distinct()
+            )
+
+            result = session.execute(stmt).scalars().all()
+            return list(result)
+
+    def get_outdated_vestigingen_signaal(self) -> list[str]:
+        """Return lijst van vestigingsnummers met signaal nieuwer is dan de last_updated van het vestigingenprofiel.
+
+        Returns:
+            list[str]: Lijst met vestigingsnummers die een update nodig hebben
+        """
+        with Session(self.engine) as session:
+            stmt = (
+                select(SignaalORM.vestigingsnummer)
+                .join(VestigingsProfielORM, SignaalORM.vestigingsnummer == VestigingsProfielORM.vestigingsnummer)
+                .where(
+                    SignaalORM.timestamp > VestigingsProfielORM.last_updated,
+                    SignaalORM.vestigingsnummer.is_not(None),  # Alleen vestigingsprofielen, geen basisprofielen
+                )
+                .distinct()
+            )
+
+            result = session.execute(stmt).scalars().all()
+            return [v for v in result if v is not None]  # filter out possible None values

kvk_connect/db/vestigingsprofiel_writer.py

@@ -0,0 +1,92 @@
+# ruff: noqa: D102
+import logging
+from datetime import UTC, datetime
+
+from sqlalchemy.orm import Session, sessionmaker
+
+from kvk_connect.models.domain.vestigingsprofiel_domain import VestigingsProfielDomain
+from kvk_connect.models.orm.vestigingsprofiel_orm import VestigingsProfielORM
+from kvk_connect.utils.tools import parse_kvk_datum
+
+logger = logging.getLogger(__name__)
+
+
+class VestigingsProfielWriter:
+    def __init__(self, engine, batch_size: int = 1):
+        logger.info("Initializing BasisProfielWriter, met batch size: %d", batch_size)
+        self.Session = sessionmaker(bind=engine)
+        self.batch_size = batch_size
+        self._session: Session | None = None
+        self._count = 0
+
+    def __enter__(self):
+        """Start een nieuwe database sessie."""
+        self._session = self.Session()
+        return self
+
+    def __exit__(self, exc_type, exc, tb):
+        """Commit changes on successful exit, rollback on exception."""
+        try:
+            if exc is None:
+                self.flush()
+            else:
+                if self._session:
+                    self._session.rollback()
+        finally:
+            if self._session:
+                self._session.close()
+            self._session = None
+
+    def flush(self) -> None:
+        if self._session:
+            self._session.commit()
+
+    def add(self, domain_vestigingsprofiel: VestigingsProfielDomain) -> None:
+        if not self._session:
+            raise RuntimeError("Session not initialized. Use context manager.")
+
+        orm_obj = self._to_orm(domain_vestigingsprofiel)
+        orm_obj.last_updated = datetime.now(UTC)
+
+        self._session.merge(orm_obj)
+        self._count += 1
+
+        if self._count % self.batch_size == 0:
+            self._session.commit()
+
+    @staticmethod
+    def _to_orm(domein_obj: VestigingsProfielDomain) -> VestigingsProfielORM:
+        # Convert GPS coordinates from string to float (handle comma decimal separator)
+        gps_lat = None
+        gps_lon = None
+
+        if domein_obj.bzk_adres_gps_latitude:
+            try:
+                gps_lat = float(domein_obj.bzk_adres_gps_latitude.replace(",", "."))
+            except (ValueError, AttributeError):
+                logger.warning("Invalid latitude value: %s", domein_obj.bzk_adres_gps_latitude)
+
+        if domein_obj.bzk_adres_gps_longitude:
+            try:
+                gps_lon = float(domein_obj.bzk_adres_gps_longitude.replace(",", "."))
+            except (ValueError, AttributeError):
+                logger.warning("Invalid longitude value: %s", domein_obj.bzk_adres_gps_longitude)
+
+        return VestigingsProfielORM(
+            vestigingsnummer=domein_obj.vestigingsnummer,
+            cor_adres_volledig=domein_obj.cor_adres_volledig,
+            cor_adres_postcode=domein_obj.cor_adres_postcode,
+            cor_adres_postbusnummer=domein_obj.cor_adres_postbusnummer,
+            cor_adres_plaats=domein_obj.cor_adres_plaats,
+            cor_adres_land=domein_obj.cor_adres_land,
+            bzk_adres_volledig=domein_obj.bzk_adres_volledig,
+            bzk_adres_straatnaam=domein_obj.bzk_adres_straatnaam,
+            bzk_adres_huisnummer=domein_obj.bzk_adres_huisnummer,
+            bzk_adres_postcode=domein_obj.bzk_adres_postcode,
+            bzk_adres_plaats=domein_obj.bzk_adres_plaats,
+            bzk_adres_land=domein_obj.bzk_adres_land,
+            bzk_adres_gps_latitude=gps_lat,
+            bzk_adres_gps_longitude=gps_lon,
+            registratie_datum_aanvang_vestiging=parse_kvk_datum(domein_obj.registratie_datum_aanvang_vestiging),
+            registratie_datum_einde_vestiging=parse_kvk_datum(domein_obj.registratie_datum_einde_vestiging),
+        )

kvk_connect/logging_config.py

@@ -0,0 +1,27 @@
+import logging
+from datetime import UTC, datetime
+
+
+class LocalTimezoneFormatter(logging.Formatter):
+    """Formatter that converts UTC timestamps to local system timezone."""
+
+    def formatTime(self, record, datefmt=None):  # noqa: N802, overrides base method
+        """Convert UTC timestamp to timezone-aware datetime, then to local time."""
+        dt_utc = datetime.fromtimestamp(record.created, tz=UTC)
+        dt_local = dt_utc.astimezone()
+
+        if datefmt:
+            return dt_local.strftime(datefmt)
+        else:
+            return dt_local.strftime("%Y-%m-%d %H:%M:%S")
+
+
+def configure(level: int = logging.INFO):
+    """Configure logging with local timezone formatter."""
+    handler = logging.StreamHandler()
+    formatter = LocalTimezoneFormatter(
+        fmt="%(asctime)s [%(levelname)s] %(name)s: %(message)s", datefmt="%Y-%m-%d %H:%M:%S"
+    )
+    handler.setFormatter(formatter)
+
+    logging.basicConfig(level=level, handlers=[handler], force=True)

kvk_connect/mappers/__init__.py

@@ -0,0 +1 @@
+# mappers package initialization

kvk_connect/mappers/kvk_record_mapper.py

@@ -0,0 +1,100 @@
+from __future__ import annotations
+
+from kvk_connect.models.api.basisprofiel_api import Adres, BasisProfielAPI, Hoofdvestiging, SBIActiviteit
+from kvk_connect.models.domain import BasisProfielDomain
+from kvk_connect.utils.tools import clean_and_pad, formatteer_datum, truncate_float
+
+
+def _select_adres(adressen: list[Adres] | None) -> Adres | None:
+    if not adressen:
+        return None
+    # Prefer "bezoekadres", else fall back to "correspondentieadres", else first
+    bezoek = next((a for a in adressen if a and a.type == "bezoekadres"), None)
+    if bezoek:
+        return bezoek
+    corr = next((a for a in adressen if a and a.type == "correspondentieadres"), None)
+    return corr or adressen[0]
+
+
+def _format_straatnaam(adres: Adres) -> str:
+    if not adres or not adres.straatnaam:
+        return ""
+    parts = [adres.straatnaam]
+    if adres.huisnummer is not None:
+        parts.append(str(adres.huisnummer))
+    # The parser used 'toevoegingAdres'; our model has 'huisletter'. Prefer huisletter if present.
+    if adres.huisletter:
+        parts[-1] = f"{parts[-1]}{adres.huisletter}" if parts else adres.huisletter
+    return " ".join(parts)
+
+
+def _map_sbi(api: BasisProfielAPI) -> tuple[str, str, str]:
+    hoofd_code = ""
+    hoofd_oms = ""
+    overige_codes: list[str] = []
+
+    activiteiten: list[SBIActiviteit] = api.sbi_activiteiten or []
+    for act in activiteiten:
+        if (act.ind_hoofdactiviteit or "").lower() == "ja":
+            hoofd_code = clean_and_pad(act.sbi_code, 5) if act.sbi_code else ""
+            hoofd_oms = act.sbi_omschrijving or ""
+        else:
+            if act.sbi_code:
+                overige_codes.append(clean_and_pad(act.sbi_code, 5))
+
+    return hoofd_code, hoofd_oms, ", ".join(overige_codes)
+
+
+def _map_hoofdvestiging(hv: Hoofdvestiging | None, out: BasisProfielDomain) -> None:
+    if not hv:
+        return
+
+    out.eerste_handelsnaam = hv.eerste_handelsnaam or ""
+    out.vestigingsnummer = hv.vestigingsnummer or ""
+    out.totaal_werkzame_personen = hv.totaal_werkzame_personen if hv.totaal_werkzame_personen is not None else None
+    out.websites = ", ".join(hv.websites or [])
+
+    # Adres
+    adres = _select_adres(hv.adressen or [])
+    if adres:
+        out.adres_type = adres.type or ""
+        # The Adres model has no 'postbusnummer' field; keep empty to match parser behavior when absent.
+        out.postbusnummer = ""
+        out.adres_straatnaam = _format_straatnaam(adres)
+        out.adres_toevoeging = ""  # parser used 'toevoegingAdres', not present in model; keep empty
+        out.adres_postcode = adres.postcode or ""
+        out.adres_plaats = adres.plaats or ""
+        if adres.geo_data:
+            out.gps_latitude = truncate_float(adres.geo_data.gps_latitude)
+            out.gps_longitude = truncate_float(adres.geo_data.gps_longitude)
+
+
+def map_kvkbasisprofiel_api_to_kvkrecord(api: BasisProfielAPI) -> BasisProfielDomain:
+    """Map a KVKRecordAPI model (Basisprofiel) to a KVKRecord (BasisprofielOutput).
+
+    This function is mirroring the logic from parsers.kvkparser.parse_basisprofiel.
+    """
+    out = BasisProfielDomain()
+
+    # Top-level
+    out.kvk_nummer = api.kvk_nummer or ""
+    out.naam = api.naam or ""
+
+    # SBI activiteiten
+    out.hoofdactiviteit, out.hoofdactiviteit_omschrijving, out.activiteit_overig = _map_sbi(api)
+
+    # Eigenaar
+    if api.embedded and api.embedded.eigenaar:
+        out.rechtsvorm = api.embedded.eigenaar.rechtsvorm or ""
+        out.rechtsvorm_uitgebreid = api.embedded.eigenaar.uitgebreide_rechtsvorm or ""
+
+    # Registratie
+    if api.materiele_registratie:
+        out.registratie_datum_aanvang = formatteer_datum(str(api.materiele_registratie.datum_aanvang or ""))
+        out.registratie_datum_einde = formatteer_datum(str(api.materiele_registratie.datum_einde or ""))
+
+    # Hoofdvestiging
+    hv = api.embedded.hoofdvestiging if api.embedded else None
+    _map_hoofdvestiging(hv, out)
+
+    return out

kvk_connect/mappers/map_mutatie_abonnement_api_to_mutatieabonnement.py

@@ -0,0 +1,11 @@
+from kvk_connect.models.api.mutatie_abonnementen_api import MutatieAbonnementenAPI
+from kvk_connect.models.domain.mutatie_abonnement import MutatieAbonnementDomain
+
+
+def map_mutatie_abonnement_api_to_mutatieabonnement(api_model: MutatieAbonnementenAPI) -> MutatieAbonnementDomain:
+    """Maps MutatieAbonnementenAPI to MutatieAbonnement.
+
+    Extracts abonnement IDs from the API model.
+    """
+    abonnement_ids = [abonnement.id for abonnement in api_model.abonnementen]
+    return MutatieAbonnementDomain(abonnement_ids=abonnement_ids)

kvk_connect/mappers/map_vestigingen_api_to_vestigingsnummers.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+
+from ..models.api.vestigingen_api import VestigingenAPI
+from ..models.domain import KvKVestigingsNummersDomain
+
+
+def map_vestigingen_api_to_vestigingsnummers(api_model: VestigingenAPI) -> KvKVestigingsNummersDomain:
+    """Zet een VestigingenAPI (API-model) om naar ons domeinmodel KvKVestigingsnummers.
+
+    Haalt de lijst van 'vestigingsnummer' waarden op in de originele volgorde.
+    """
+    nummers: list[str] = [v.vestigingsnummer for v in (api_model.vestigingen or []) if v and v.vestigingsnummer]
+
+    return KvKVestigingsNummersDomain(kvk_nummer=api_model.kvk_nummer or "", vestigingsnummers=nummers)

kvk_connect/mappers/map_vestigingsprofiel_api_to_vestigingsprofiel_domain.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+from kvk_connect.models.api.vestigingsprofiel_api import VestigingsProfielAPI
+from kvk_connect.models.domain.vestigingsprofiel_domain import VestigingsProfielDomain
+from kvk_connect.utils.tools import formatteer_datum, truncate_float
+
+
+def map_vestigingsprofiel_api_to_vestigingsprofiel_domain(api_model: VestigingsProfielAPI) -> VestigingsProfielDomain:
+    """Zet een VestigingsProfielAPI (API-model) om naar een VestigingsProfielDomain.
+
+    Extracteert correspondentieadres en bezoekadres uit de adressen lijst.
+    """
+    cor_adres = next((a for a in (api_model.adressen or []) if a.type == "correspondentieadres"), None)
+    bzk_adres = next((a for a in (api_model.adressen or []) if a.type == "bezoekadres"), None)
+
+    return VestigingsProfielDomain(
+        vestigingsnummer=api_model.vestigingsnummer if api_model.vestigingsnummer else None,
+        cor_adres_volledig=cor_adres.volledig_adres if cor_adres and cor_adres.volledig_adres else None,
+        cor_adres_postcode=cor_adres.postcode if cor_adres and cor_adres.postcode else None,
+        cor_adres_postbusnummer=getattr(cor_adres, "postbusnummer", None) if cor_adres else None,
+        cor_adres_plaats=cor_adres.plaats if cor_adres and cor_adres.plaats else None,
+        cor_adres_land=cor_adres.land if cor_adres and cor_adres.land else None,
+        bzk_adres_volledig=bzk_adres.volledig_adres if bzk_adres and bzk_adres.volledig_adres else None,
+        bzk_adres_straatnaam=bzk_adres.straatnaam if bzk_adres else None,
+        bzk_adres_huisnummer=getattr(bzk_adres, "huisnummer", None) if bzk_adres else None,
+        bzk_adres_postcode=bzk_adres.postcode if bzk_adres and bzk_adres.postcode else None,
+        bzk_adres_plaats=bzk_adres.plaats if bzk_adres and bzk_adres.plaats else None,
+        bzk_adres_land=bzk_adres.land if bzk_adres and bzk_adres.land else None,
+        bzk_adres_gps_latitude=truncate_float(bzk_adres.geo_data.gps_latitude)
+        if bzk_adres and bzk_adres.geo_data and bzk_adres.geo_data.gps_latitude
+        else None,
+        bzk_adres_gps_longitude=truncate_float(bzk_adres.geo_data.gps_longitude)
+        if bzk_adres and bzk_adres.geo_data and bzk_adres.geo_data.gps_longitude
+        else None,
+        registratie_datum_aanvang_vestiging=formatteer_datum(str(api_model.materiele_registratie.datum_aanvang or ""))
+        if api_model.materiele_registratie
+        else None,
+        registratie_datum_einde_vestiging=formatteer_datum(str(api_model.materiele_registratie.datum_einde or ""))
+        if api_model.materiele_registratie
+        else None,
+    )

kvk_connect/models/api/abonnementen_api.py

@@ -0,0 +1,42 @@
+# ruff: noqa: D102
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass
+class Contract:
+    id: str
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "Contract":
+        return cls(id=data.get("id", ""))
+
+
+@dataclass
+class Abonnement:
+    id: str
+    contract: Contract
+    start_datum: str
+    actief: bool
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "Abonnement":
+        return cls(
+            id=data.get("id", ""),
+            contract=Contract.from_dict(data.get("contract", {})),
+            start_datum=data.get("startDatum", ""),
+            actief=data.get("actief", False),
+        )
+
+
+@dataclass
+class AbonnementenAPI:
+    klant_id: str
+    abonnementen: list[Abonnement] = field(default_factory=list)
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "AbonnementenAPI":
+        return cls(
+            klant_id=data.get("klantId", ""),
+            abonnementen=[Abonnement.from_dict(a) for a in data.get("abonnementen", [])],
+        )

kvk_connect/models/api/basisprofiel_api.py

@@ -0,0 +1,233 @@
+# ruff: noqa: D102
+from __future__ import annotations
+
+import json
+from dataclasses import asdict, dataclass, field
+from typing import Any
+
+"""
+Naming conventions voor API models is appenden van *API
+"""
+
+
+@dataclass
+class Link:
+    rel: str = ""
+    href: str = ""
+
+    @staticmethod
+    def from_dict(d: dict[str, Any] | None) -> Link | None:
+        if not d:
+            return None
+        return Link(rel=d.get("rel", "") or "", href=d.get("href", "") or "")
+
+
+@dataclass
+class GeoData:
+    addresseerbaar_object_id: str | None = None
+    nummer_aanduiding_id: str | None = None
+    gps_latitude: float | None = None
+    gps_longitude: float | None = None
+    rijksdriehoek_x: float | None = None
+    rijksdriehoek_y: float | None = None
+    rijksdriehoek_z: float | None = None
+
+    @staticmethod
+    def from_dict(d: dict[str, Any] | None) -> GeoData | None:
+        if not d:
+            return None
+        return GeoData(
+            addresseerbaar_object_id=d.get("addresseerbaarObjectId"),
+            nummer_aanduiding_id=d.get("nummerAanduidingId"),
+            gps_latitude=d.get("gpsLatitude"),
+            gps_longitude=d.get("gpsLongitude"),
+            rijksdriehoek_x=d.get("rijksdriehoekX"),
+            rijksdriehoek_y=d.get("rijksdriehoekY"),
+            rijksdriehoek_z=d.get("rijksdriehoekZ"),
+        )
+
+
+@dataclass
+class Adres:
+    type: str = ""
+    ind_afgeschermd: str = ""
+    volledig_adres: str = ""
+    straatnaam: str = ""
+    huisnummer: int | None = None
+    huisletter: str | None = None
+    postbusnummer: int | None = None
+    postcode: str = ""
+    plaats: str = ""
+    land: str = ""
+    geo_data: GeoData | None = None
+
+    @staticmethod
+    def from_dict(d: dict[str, Any] | None) -> Adres | None:
+        if not d:
+            return None
+        return Adres(
+            type=d.get("type", "") or "",
+            ind_afgeschermd=d.get("indAfgeschermd", "") or "",
+            volledig_adres=d.get("volledigAdres", "") or "",
+            straatnaam=d.get("straatnaam", "") or "",
+            huisnummer=d.get("huisnummer"),
+            huisletter=d.get("huisletter"),
+            postbusnummer=d.get("postbusnummer"),
+            postcode=d.get("postcode", "") or "",
+            plaats=d.get("plaats", "") or "",
+            land=d.get("land", "") or "",
+            geo_data=GeoData.from_dict(d.get("geoData")),
+        )
+
+
+@dataclass
+class MaterieleRegistratie:
+    datum_aanvang: str | None = None
+    datum_einde: str | None = None
+
+    @staticmethod
+    def from_dict(d: dict[str, Any] | None) -> MaterieleRegistratie | None:
+        if not d:
+            return None
+        return MaterieleRegistratie(datum_aanvang=d.get("datumAanvang"), datum_einde=d.get("datumEinde"))
+
+
+@dataclass
+class HandelNaam:
+    naam: str = ""
+    volgorde: int | None = None
+
+    @staticmethod
+    def from_dict(d: dict[str, Any] | None) -> HandelNaam | None:
+        if not d:
+            return None
+        return HandelNaam(naam=d.get("naam", "") or "", volgorde=d.get("volgorde"))
+
+
+@dataclass
+class SBIActiviteit:
+    sbi_code: str = ""
+    sbi_omschrijving: str = ""
+    ind_hoofdactiviteit: str = ""
+
+    @staticmethod
+    def from_dict(d: dict[str, Any] | None) -> SBIActiviteit | None:
+        if not d:
+            return None
+        return SBIActiviteit(
+            sbi_code=d.get("sbiCode", "") or "",
+            sbi_omschrijving=d.get("sbiOmschrijving", "") or "",
+            ind_hoofdactiviteit=d.get("indHoofdactiviteit", "") or "",
+        )
+
+
+@dataclass
+class Hoofdvestiging:
+    vestigingsnummer: str = ""
+    kvk_nummer: str = ""
+    formele_registratiedatum: str = ""
+    materiele_registratie: MaterieleRegistratie | None = None
+    eerste_handelsnaam: str = ""
+    ind_hoofdvestiging: str = ""
+    ind_commerciele_vestiging: str = ""
+    totaal_werkzame_personen: int | None = None
+    adressen: list[Adres] = field(default_factory=list)
+    websites: list[str] = field(default_factory=list)
+    links: list[Link] = field(default_factory=list)
+
+    @staticmethod
+    def from_dict(d: dict[str, Any] | None) -> Hoofdvestiging | None:  # noqa: D102
+        if not d:
+            return None
+        return Hoofdvestiging(
+            vestigingsnummer=d.get("vestigingsnummer", "") or "",
+            kvk_nummer=d.get("kvkNummer", "") or "",
+            formele_registratiedatum=d.get("formeleRegistratiedatum", "") or "",
+            materiele_registratie=MaterieleRegistratie.from_dict(d.get("materieleRegistratie")),
+            eerste_handelsnaam=d.get("eersteHandelsnaam", "") or "",
+            ind_hoofdvestiging=d.get("indHoofdvestiging", "") or "",
+            ind_commerciele_vestiging=d.get("indCommercieleVestiging", "") or "",
+            totaal_werkzame_personen=d.get("totaalWerkzamePersonen"),
+            adressen=[a for a in (Adres.from_dict(x) for x in d.get("adressen", [])) if a],
+            websites=list(d.get("websites", []) or []),
+            links=[link for link in (Link.from_dict(x) for x in d.get("links", [])) if link],
+        )
+
+
+@dataclass
+class Eigenaar:
+    rechtsvorm: str = ""
+    uitgebreide_rechtsvorm: str = ""
+    links: list[Link] = field(default_factory=list)
+
+    @staticmethod
+    def from_dict(d: dict[str, Any] | None) -> Eigenaar | None:  # noqa: D102
+        if not d:
+            return None
+        return Eigenaar(
+            rechtsvorm=d.get("rechtsvorm", "") or "",
+            uitgebreide_rechtsvorm=d.get("uitgebreideRechtsvorm", "") or "",
+            links=[link for link in (Link.from_dict(x) for x in d.get("links", [])) if link],
+        )
+
+
+@dataclass
+class Embedded:
+    hoofdvestiging: Hoofdvestiging | None = None
+    eigenaar: Eigenaar | None = None
+
+    @staticmethod
+    def from_dict(d: dict[str, Any] | None) -> Embedded | None:  # noqa: D102
+        if not d:
+            return None
+        return Embedded(
+            hoofdvestiging=Hoofdvestiging.from_dict(d.get("hoofdvestiging")),
+            eigenaar=Eigenaar.from_dict(d.get("eigenaar")),
+        )
+
+
+@dataclass
+class BasisProfielAPI:
+    kvk_nummer: str = ""
+    ind_non_mailing: str = ""
+    naam: str = ""
+    formele_registratiedatum: str = ""
+    materiele_registratie: MaterieleRegistratie | None = None
+    totaal_werkzame_personen: int | None = None
+    handelsnamen: list[HandelNaam] = field(default_factory=list)
+    sbi_activiteiten: list[SBIActiviteit] = field(default_factory=list)
+    links: list[Link] = field(default_factory=list)
+    embedded: Embedded | None = None
+
+    @staticmethod
+    def from_dict(d: dict[str, Any]) -> BasisProfielAPI:  # noqa: D102
+        return BasisProfielAPI(
+            kvk_nummer=d.get("kvkNummer", "") or "",
+            ind_non_mailing=d.get("indNonMailing", "") or "",
+            naam=d.get("naam", "") or "",
+            formele_registratiedatum=d.get("formeleRegistratiedatum", "") or "",
+            materiele_registratie=MaterieleRegistratie.from_dict(d.get("materieleRegistratie")),
+            totaal_werkzame_personen=d.get("totaalWerkzamePersonen"),
+            handelsnamen=[h for h in (HandelNaam.from_dict(x) for x in d.get("handelsnamen", [])) if h],
+            sbi_activiteiten=[a for a in (SBIActiviteit.from_dict(x) for x in d.get("sbiActiviteiten", [])) if a],
+            links=[link for link in (Link.from_dict(x) for x in d.get("links", [])) if link],
+            embedded=Embedded.from_dict(d.get("_embedded")),
+        )
+
+    @staticmethod
+    def load_from_file(path: str, encoding: str = "utf-8") -> BasisProfielAPI:  # noqa: D102
+        with open(path, encoding=encoding) as f:
+            data = json.load(f)
+        return BasisProfielAPI.from_dict(data)
+
+    @staticmethod
+    def load_from_json(json_str: str) -> BasisProfielAPI:  # noqa: D102
+        data = json.loads(json_str)
+        return BasisProfielAPI.from_dict(data)
+
+    @staticmethod
+    def load_from_dict(data: dict[str, Any]) -> BasisProfielAPI:  # noqa: D102
+        return BasisProfielAPI.from_dict(data)
+
+    def to_dict(self) -> dict[str, Any]:  # noqa: D102
+        return asdict(self)

kvk_connect/models/api/mutatie_abonnementen_api.py

@@ -0,0 +1,40 @@
+# ruff: noqa: D102
+from dataclasses import dataclass
+
+
+@dataclass
+class Contract:
+    id: str
+
+    @staticmethod
+    def from_dict(data: dict) -> "Contract":  # noqa: D102
+        return Contract(id=data["id"])
+
+
+@dataclass
+class Abonnement:
+    id: str
+    contract: Contract
+    start_datum: str
+    actief: bool
+
+    @staticmethod
+    def from_dict(data: dict) -> "Abonnement":  # noqa: D102
+        return Abonnement(
+            id=data["id"],
+            contract=Contract.from_dict(data["contract"]),
+            start_datum=data["startDatum"],
+            actief=data["actief"],
+        )
+
+
+@dataclass
+class MutatieAbonnementenAPI:
+    klant_id: str
+    abonnementen: list[Abonnement]
+
+    @staticmethod
+    def from_dict(data: dict) -> "MutatieAbonnementenAPI":  # noqa: D102
+        return MutatieAbonnementenAPI(
+            klant_id=data["klantId"], abonnementen=[Abonnement.from_dict(a) for a in data["abonnementen"]]
+        )