swegov-opendata 0.1.0__tar.gz

swegov_opendata-0.1.0/PKG-INFO

@@ -0,0 +1,58 @@
+Metadata-Version: 2.4
+Name: swegov-opendata
+Version: 0.1.0
+Summary: Data models for handling Swedish riksdagens öppna data (open data)
+Author: Språkbanken
+Author-email: Språkbanken <sb-info@svenska.gu.se>
+License-Expression: MIT
+Requires-Dist: pydantic>=2.12.5
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+
+# swegov-opendata
+
+[![PyPI version](https://img.shields.io/pypi/v/swegov-opendata/0.1.0.svg)](https://pypi.org/project/swegov-opendata/)
+[![PyPI license](https://img.shields.io/pypi/l/swegov-opendata/0.1.0.svg)](https://pypi.org/project/swegov-opendata/)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/swegov-opendata/0.1.0.svg)](https://pypi.org/project/swegov-opendata)
+
+[![Maturity badge - level 2](https://img.shields.io/badge/Maturity-Level%202%20--%20First%20Release-yellowgreen.svg)](https://github.com/spraakbanken/getting-started/blob/main/scorecard.md)
+[![Stage](https://img.shields.io/pypi/status/swegov-opendata/0.1.0.svg)](https://pypi.org/project/swegov-opendata/)
+
+[![codecov](https://codecov.io/gh/spraakbanken/swegov-opendata-py/graph/badge.svg?token=DUV4CL6AK2)](https://codecov.io/gh/spraakbanken/swegov-opendata-py)
+
+[![CI(check)](https://github.com/spraakbanken/swegov-opendata-py/actions/workflows/check.yml/badge.svg)](https://github.com/spraakbanken/swegov-opendata-py/actions/workflows/check.yml)
+[![CI(release)](https://github.com/spraakbanken/swegov-opendata-py/actions/workflows/release.yml/badge.svg)](https://github.com/spraakbanken/swegov-opendata-py/actions/workflows/release.yml)
+[![CI(scheduled)](https://github.com/spraakbanken/swegov-opendata-py/actions/workflows/rolling.yml/badge.svg)](https://github.com/spraakbanken/swegov-opendata-py/actions/workflows/rolling.yml)
+[![CI(test)](https://github.com/spraakbanken/swegov-opendata-py/actions/workflows/test.yml/badge.svg)](https://github.com/spraakbanken/swegov-opendata-py/actions/workflows/test.yml)
+
+Pydantic models for [Riksdagens Öppna data](http://data.riksdagen.se/).
+
+## Install
+
+Add this to your project with
+
+```shell
+uv add swegov-opendata
+```
+
+## Minimum Supported Python Version Policy
+
+The Minimum Supported Python Version is fixed for a given minor (1.x)
+version. However it can be increased when bumping minor versions, i.e. going
+from 1.0 to 1.1 allows us to increase the Minimum Supported Python Version. Users unable to increase their
+Python version can use an older minor version instead. Below is a list of sparv-sbx-corpus-statistics versions
+and their Minimum Supported Python Version:
+
+- v0.1: Python 3.11.
+
+Note however that sparv-sbx-corpus-statistics also has dependencies, which might have different MSRV
+policies. We try to stick to the above policy when updating dependencies, but
+this is not always possible.
+
+## Changelog
+
+This project keeps a [changelog](https://github.com/spraakbanken/swegov-opendata-py/blob/0.1.0/CHANGELOG.md).
+
+## License
+
+This repository is licensed under the [MIT](https://github.com/spraakbanken/swegov-opendata-py/blob/0.1.0/LICENSE) license.

swegov_opendata-0.1.0/README.md

@@ -0,0 +1,47 @@
+# swegov-opendata
+
+[![PyPI version](https://img.shields.io/pypi/v/swegov-opendata/0.1.0.svg)](https://pypi.org/project/swegov-opendata/)
+[![PyPI license](https://img.shields.io/pypi/l/swegov-opendata/0.1.0.svg)](https://pypi.org/project/swegov-opendata/)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/swegov-opendata/0.1.0.svg)](https://pypi.org/project/swegov-opendata)
+
+[![Maturity badge - level 2](https://img.shields.io/badge/Maturity-Level%202%20--%20First%20Release-yellowgreen.svg)](https://github.com/spraakbanken/getting-started/blob/main/scorecard.md)
+[![Stage](https://img.shields.io/pypi/status/swegov-opendata/0.1.0.svg)](https://pypi.org/project/swegov-opendata/)
+
+[![codecov](https://codecov.io/gh/spraakbanken/swegov-opendata-py/graph/badge.svg?token=DUV4CL6AK2)](https://codecov.io/gh/spraakbanken/swegov-opendata-py)
+
+[![CI(check)](https://github.com/spraakbanken/swegov-opendata-py/actions/workflows/check.yml/badge.svg)](https://github.com/spraakbanken/swegov-opendata-py/actions/workflows/check.yml)
+[![CI(release)](https://github.com/spraakbanken/swegov-opendata-py/actions/workflows/release.yml/badge.svg)](https://github.com/spraakbanken/swegov-opendata-py/actions/workflows/release.yml)
+[![CI(scheduled)](https://github.com/spraakbanken/swegov-opendata-py/actions/workflows/rolling.yml/badge.svg)](https://github.com/spraakbanken/swegov-opendata-py/actions/workflows/rolling.yml)
+[![CI(test)](https://github.com/spraakbanken/swegov-opendata-py/actions/workflows/test.yml/badge.svg)](https://github.com/spraakbanken/swegov-opendata-py/actions/workflows/test.yml)
+
+Pydantic models for [Riksdagens Öppna data](http://data.riksdagen.se/).
+
+## Install
+
+Add this to your project with
+
+```shell
+uv add swegov-opendata
+```
+
+## Minimum Supported Python Version Policy
+
+The Minimum Supported Python Version is fixed for a given minor (1.x)
+version. However it can be increased when bumping minor versions, i.e. going
+from 1.0 to 1.1 allows us to increase the Minimum Supported Python Version. Users unable to increase their
+Python version can use an older minor version instead. Below is a list of sparv-sbx-corpus-statistics versions
+and their Minimum Supported Python Version:
+
+- v0.1: Python 3.11.
+
+Note however that sparv-sbx-corpus-statistics also has dependencies, which might have different MSRV
+policies. We try to stick to the above policy when updating dependencies, but
+this is not always possible.
+
+## Changelog
+
+This project keeps a [changelog](https://github.com/spraakbanken/swegov-opendata-py/blob/0.1.0/CHANGELOG.md).
+
+## License
+
+This repository is licensed under the [MIT](https://github.com/spraakbanken/swegov-opendata-py/blob/0.1.0/LICENSE) license.

swegov_opendata-0.1.0/pyproject.toml

@@ -0,0 +1,36 @@
+[project]
+name = "swegov-opendata"
+version = "0.1.0"
+description = "Data models for handling Swedish riksdagens öppna data (open data)"
+readme = "README.md"
+requires-python = ">= 3.11"
+license = "MIT"
+dependencies = ["pydantic>=2.12.5"]
+
+[[project.authors]]
+name = "Språkbanken"
+email = "sb-info@svenska.gu.se"
+
+[dependency-groups]
+lint = [
+    "ruff>=0.16.9",
+    "ty>=0.0.84",
+]
+test = [
+    "pytest>=9.0.3",
+    "pytest-cov>=7.0.0",
+    "syrupy>=6.0.0",
+]
+
+[[dependency-groups.dev]]
+include-group = "lint"
+
+[[dependency-groups.dev]]
+include-group = "test"
+
+[build-system]
+requires = ["uv_build>=0.12,<0.13"]
+build-backend = "uv_build"
+
+[tool.uv]
+exclude-newer = "P7D"

swegov_opendata-0.1.0/pyproject.toml.orig

@@ -0,0 +1,32 @@
+[project]
+name = "swegov-opendata"
+version = "0.1.0"
+description = "Data models for handling Swedish riksdagens öppna data (open data)"
+readme = "README.md"
+requires-python = ">= 3.11"
+license = "MIT"
+authors = [
+  { name = "Språkbanken", email = "sb-info@svenska.gu.se" },
+]
+dependencies = [
+  "pydantic>=2.12.5",
+]
+
+[dependency-groups]
+dev = [{ include-group = "lint" }, { include-group = "test" }]
+lint = [
+  "ruff>=0.16.9",
+  "ty>=0.0.84",
+]
+test = [
+  "pytest>=9.0.3",
+  "pytest-cov>=7.0.0",
+  "syrupy>=6.0.0",
+]
+
+[build-system]
+requires = ["uv_build>=0.12,<0.13"]
+build-backend = "uv_build"
+
+[tool.uv]
+exclude-newer = "P7D"

swegov_opendata-0.1.0/src/swegov_opendata/dokument/aktivitet.py

@@ -0,0 +1,24 @@
+import datetime
+import typing as t
+
+import pydantic
+
+from swegov_opendata import shared
+
+
+class Aktivitet(pydantic.BaseModel):
+    datum: datetime.datetime
+    hangar_id: str | None = None
+    kod: str
+    namn: str
+    status: str | None
+    ordning: str
+    process: str | None
+
+    model_config = pydantic.ConfigDict(extra="forbid")
+
+
+class DokAktivitet(pydantic.BaseModel):
+    aktivitet: t.Annotated[list[Aktivitet], pydantic.BeforeValidator(shared.ensure_list)]
+
+    model_config = pydantic.ConfigDict(extra="forbid")

swegov_opendata-0.1.0/src/swegov_opendata/dokument/bilaga.py

@@ -0,0 +1,44 @@
+import enum
+import typing as t
+
+import pydantic
+
+from swegov_opendata import shared
+
+
+class FilTyp(enum.StrEnum):
+    Doc = "doc"
+    Docx = "docx"
+    Htm = "htm"
+    Pdf = "pdf"
+
+    def __str__(self) -> str:
+        return self.value
+
+    def __repr__(self) -> str:
+        return str(self)
+
+    @classmethod
+    def _missing_(cls, value) -> t.Self:
+        for member in cls:
+            if member.value == value.lower():
+                return member
+        raise ValueError("Unknown value '{value}'")
+
+
+class Bilaga(pydantic.BaseModel):
+    dok_id: str
+    titel: str | None = None
+    subtitel: str | None
+    filnamn: str
+    filstorlek: str
+    filtyp: FilTyp
+    fil_url: pydantic.HttpUrl
+
+    model_config = pydantic.ConfigDict(extra="forbid")
+
+
+class DokBilaga(pydantic.BaseModel):
+    bilaga: t.Annotated[list[Bilaga], pydantic.BeforeValidator(shared.ensure_list)]
+
+    model_config = pydantic.ConfigDict(extra="forbid")

swegov_opendata-0.1.0/src/swegov_opendata/dokument/datasetlista.py

@@ -0,0 +1,59 @@
+import enum
+import xml.etree.ElementTree as ET
+from dataclasses import dataclass
+from xml.etree.ElementTree import Element
+
+from pydantic import HttpUrl
+
+
+class DataFormat(enum.StrEnum):
+    json = "json"
+    csv = "csv"
+    csvt = "csvt"
+    html = "html"
+    sql = "sql"
+    text = "text"
+    xml = "xml"
+
+
+@dataclass
+class Dataset:
+    format: DataFormat
+    url: HttpUrl
+    uppdaterad: str
+
+    @classmethod
+    def from_elem(cls, elem: Element) -> "Dataset":
+        if elem.tag != "dataset":
+            raise RuntimeError(f"Expected <dataset>, found <{elem.tag}>")
+        format_ = None
+        url = None
+        uppdaterad = None
+        for child in elem:
+            if child.tag == "format":
+                format_ = DataFormat(child.text)
+            elif child.tag == "url":
+                url = child.text
+            elif child.tag == "uppdaterad":
+                uppdaterad = child.text
+
+        if format_ is None:
+            raise RuntimeError("Dataset is missing 'format'")
+        if url is None:
+            raise RuntimeError("Dataset is missing 'url'")
+        if uppdaterad is None:
+            raise RuntimeError("Dataset is missing 'uppdaterad'")
+        return cls(format=format_, url=HttpUrl(url), uppdaterad=uppdaterad)
+
+
+@dataclass
+class DatasetLista:
+    datasets: list[Dataset]
+
+    @classmethod
+    def from_xml(cls, xml: str) -> "DatasetLista":
+        root = ET.fromstring(xml)
+        if root.tag != "datasetlista":
+            raise RuntimeError(f"Expected <datasetlista>, found <{root.tag}>")
+        datasets = [Dataset.from_elem(child) for child in root]
+        return cls(datasets=datasets)

swegov_opendata-0.1.0/src/swegov_opendata/dokument/debatt.py

@@ -0,0 +1,54 @@
+import datetime
+import typing as t
+
+import pydantic
+
+from swegov_opendata import shared
+
+
+class Anforande(pydantic.BaseModel):
+    anf_beteckning: str | None
+    anf_datum: datetime.datetime
+    anf_hangar_id: t.Annotated[int | None, pydantic.BeforeValidator(shared.ensure_int_opt)]
+    anf_id: str | None = None
+    anf_klockslag: str | None
+    anf_nummer: str
+    anf_rm: str | None
+    anf_sekunder: int
+    anf_text: str | None = None
+    anf_typ: str | None
+    anf_video_id: str
+    datumtid: datetime.datetime
+    debatt_id: str | None = None
+    debatt_titel: str | None = None
+    debatt_typ: str | None = None
+    dok_beteckning: str | None = None
+    dok_id: str | None = None
+    dok_intressent: str | None = None
+    intressent_id: str | None = None
+    kon: str | None = None
+    parent_id: str | None = None
+    parti: str | None = None
+    startpos: int | None = None
+    systemdatum: datetime.datetime | None = None
+    talare: str | None
+    talare_kort: str | None = None
+    tumnagel: t.Annotated[list[str] | None, pydantic.BeforeValidator(shared.ensure_list_opt)] = (
+        None
+    )
+    tumnagel_mini: str | None = None
+    tumnagel_liten: str | None = None
+    tumnagel_medium: str | None = None
+    tumnagel_stor: str | None = None
+    video_id: str | None
+    video_url: str
+    videostatus: int | None = None
+    voteringspunkt: str | None = None
+
+    model_config = pydantic.ConfigDict(extra="forbid")
+
+
+class Debatt(pydantic.BaseModel):
+    anforande: t.Annotated[list[Anforande], pydantic.BeforeValidator(shared.ensure_list)]
+
+    model_config = pydantic.ConfigDict(extra="forbid")

swegov_opendata-0.1.0/src/swegov_opendata/dokument/dokument.py

@@ -0,0 +1,235 @@
+import datetime
+import enum
+import typing as t
+from pathlib import Path
+
+import pydantic
+
+from swegov_opendata.dokument.aktivitet import DokAktivitet
+from swegov_opendata.dokument.bilaga import DokBilaga
+from swegov_opendata.dokument.debatt import Debatt
+from swegov_opendata.dokument.forslag import (
+    DokForslag,
+    DokMotForslag,
+    DokUtskottsForslag,
+)
+from swegov_opendata.dokument.intressent import DokIntressent
+from swegov_opendata.dokument.media import WebbMedia
+from swegov_opendata.dokument.referens import DokReferens
+from swegov_opendata.dokument.uppgift import DokUppgift
+
+_DOKUMENT_TYP_MAP: dict[str, str] = {
+    "bet": "betänkande",
+    "dir": "kommittéedirektiv",
+    "ds": "departementsserien",
+    "eundok": "utskottsdokument",
+    "f-lista": "föredragningslista",
+    "fr": "skriftlig fråga",
+    "frs": "svar på skriftlig fråga",
+    "frsrdg": "framställningar",
+    "ip": "interpellation",
+    "kf-lista": "kallelser och föredragningslistor",
+    "KOM": "EU-förslag",
+    "komm": "kommittéeberättelser",
+    "prop": "proposition",
+    "prot": "protokoll",
+    "rfr": "rapporter från riksdagen",
+    "rir": "riksrevisionens granskningsrapporter",
+    "rskr": "riksdagsskrivelse",
+    "sou": "statens offentliga utredningar",
+    "t-lista": "talarlista",
+    "urf": "utredningar från Riksdagsförvaltningen",
+    "utskottsdokument": "utskottsdokument",
+    "yttr": "yttrande",
+}
+
+
+class DokumentTyp(enum.StrEnum):
+    Bet = "bet"
+    Diarie = "diarie"
+    Dir = "dir"
+    Ds = "ds"
+    EuDokument = "eu-dokument"
+    Eunbil = "eunbil"
+    Eundok = "eundok"
+    FLista = "f-lista"
+    Fpm = "fpm"
+    Fr = "fr"
+    Frs = "frs"
+    Frsrdg = "frsrdg"
+    Ip = "ip"
+    Kalakt = "kalakt"
+    Kammakt = "kammakt"
+    KfLista = "kf-lista"
+    Kom = "KOM"
+    Komm = "komm"
+    Mot = "mot"
+    Prop = "prop"
+    Prot = "prot"
+    Rfr = "rfr"
+    Rir = "rir"
+    Rskr = "rskr"
+    Samtr = "samtr"
+    Sfs = "sfs"
+    Skrsam = "skrsam"
+    Sou = "sou"
+    TLista = "t-lista"
+    Urf = "urf"
+    Utskottsdokument = "utskottsdokument"
+    Uttag = "uttag"
+    Yttr = "yttr"
+
+    @classmethod
+    def _missing_(cls, value) -> t.Self:
+        for member in cls:
+            if member.value == value.lower():
+                return member
+        raise ValueError(f"Unknown value '{value}'.")
+
+    def short_name(self) -> str:
+        return self.value
+
+    def long_name(self) -> str:
+        return _DOKUMENT_TYP_MAP.get(self.value) or self.value
+
+
+def split_space_take_first(value: t.Any) -> t.Any:
+    if isinstance(value, str):
+        return "" if not value else value.split()[0]
+    return value
+
+
+def ensure_none_if_empty(value: t.Any) -> t.Any:
+    if isinstance(value, str):
+        return None if value == "" else value
+    return value
+
+
+def ensure_string(value: t.Any) -> t.Any:
+    def _ensure_str(v: t.Any) -> str:
+        return v if isinstance(v, str) else str(v)
+
+    if isinstance(value, list):
+        if len(value) == 0:
+            return ""
+        return _ensure_str(value[0])
+    return _ensure_str(value)
+
+
+class Dokument(pydantic.BaseModel):
+    beteckning: str | None
+    datum: t.Annotated[
+        datetime.date | None,
+        pydantic.BeforeValidator(split_space_take_first),
+        pydantic.BeforeValidator(ensure_none_if_empty),
+    ]
+    debattnamn: str | None = None
+    dok_id: str
+    doktyp: t.Annotated[str, pydantic.BeforeValidator(ensure_string)]
+    dokument_url_html: pydantic.HttpUrl
+    dokument_url_text: pydantic.HttpUrl
+    dokumentnamn: str | None = None
+    dokumentstatus_url_xml: pydantic.HttpUrl
+    hangar_id: str
+    html: str | None = None
+    htmlformat: str | None
+    images: str | None = None
+    metadata: str | None = None
+    mottagare: str | None
+    nummer: str | None
+    organ: str | None
+    pretext: str | None = None
+    publicerad: t.Annotated[
+        datetime.datetime | None, pydantic.BeforeValidator(ensure_none_if_empty)
+    ]
+    relaterat_id: str | None
+    rm: str | None
+    rubriker: str | None = None
+    slutnummer: str | None
+    source: str | None
+    sourceid: str | None
+    status: str | None
+    subtitel: str | None
+    subtyp: str | None
+    # systemdatum: datetime.datetime
+    systemdatum: t.Annotated[
+        datetime.datetime | None,
+        pydantic.BeforeValidator(split_space_take_first),
+        pydantic.BeforeValidator(ensure_none_if_empty),
+    ]
+    tempbeteckning: str | None
+    text: str | None = None
+    titel: str | None
+    typ: t.Annotated[DokumentTyp | None, pydantic.BeforeValidator(ensure_none_if_empty)]
+    typrubrik: str | None = None
+    utskottsforslag_url_xml: str | None = None
+
+    model_config = pydantic.ConfigDict(extra="forbid")
+
+    def get_rm(self) -> str:
+        return self.rm or "missing"
+
+    def get_typ_short_name(self) -> str:
+        return self.typ.short_name() if self.typ else "missing"
+
+    def get_typ_long_name(self) -> str:
+        return self.typ.long_name() if self.typ else "missing"
+
+
+class DokumentStatus(pydantic.BaseModel):
+    debatt: Debatt | None = None
+    dokaktivitet: DokAktivitet | None = None
+    dokbilaga: DokBilaga | None = None
+    dokforslag: DokForslag | None = None
+    dokintressent: DokIntressent | None = None
+    dokmotforslag: DokMotForslag | None = None
+    dokreferens: DokReferens | None = None
+    dokument: Dokument
+    dokuppgift: DokUppgift | None = None
+    dokutskottsforslag: DokUtskottsForslag | None = None
+    webbmedia: WebbMedia | None = None
+
+    model_config = pydantic.ConfigDict(extra="forbid")
+
+
+class DokumentStatusPage(pydantic.BaseModel):
+    dokumentstatus: DokumentStatus | None
+
+    @classmethod
+    def deserialize_from_str(cls, src: str | bytes | bytearray) -> "DokumentStatusPage":
+        try:
+            return DokumentStatusPage.model_validate_json(src)
+        except pydantic.ValidationError as exc:
+            print(f"error type: '{exc.errors()[0]['type']}'")
+            exc_msg = exc.errors()[0]["msg"]
+            print(f"error msg: '{exc_msg}'")
+            print(f"{exc=}")
+            if exc.errors()[0]["type"] != "json_invalid":
+                raise
+                column = int(exc_msg.split()[-1])
+                print(f"{src[column - 50:column + 50]=}")
+            new_src: str = src if isinstance(src, str) else src.decode("utf-8")
+            new_src = (
+                new_src.replace("{/* RESERVATIONSTEXT */}", r'""')
+                .replace("/* RESERVATIONSTEXT */", "")
+                .replace('\\"', "TEMPSLASH")
+                .replace(r"\"", '"')
+                .replace("TEMPSLASH", r"\"")
+                .replace(r"\\r\\n", r"\r\n")
+                .replace('"p":}', '"p":""}')
+            )
+            try:
+                return DokumentStatusPage.model_validate_json(new_src)
+            except pydantic.ValidationError as exc:
+                dt = datetime.datetime.now(tz=datetime.UTC).strftime("%Y-%m-%dT%H%M%S")
+                Path(f"new_src-{dt}.json").write_text(new_src)
+                print(f"error type: '{exc.errors()[0]['type']}'")
+                exc_msg = exc.errors()[0]["msg"]
+                print(f"error msg: '{exc_msg}'")
+                print(f"{exc=}")
+                if exc.errors()[0]["type"] != "json_invalid":
+                    raise
+                column = int(exc_msg.split()[-1])
+                print(f"{new_src[column - 50:column + 50]=}")
+                # new_src = src.replace("{/* RESERVATIONSTEXT */}", "")
+                raise

swegov_opendata-0.1.0/src/swegov_opendata/dokument/dokumentlista.py

@@ -0,0 +1,147 @@
+import datetime
+import typing as t
+
+import pydantic
+
+from swegov_opendata import shared
+from swegov_opendata.dokument.dokument import DokumentTyp
+
+
+class Fil(pydantic.BaseModel):
+    typ: str
+    namn: str
+    storlek: int
+    url: str
+
+    model_config = pydantic.ConfigDict(extra="forbid")
+
+
+class FilBilaga(pydantic.BaseModel):
+    fil: t.Annotated[list[Fil] | None, pydantic.BeforeValidator(shared.ensure_list_opt)]
+
+    model_config = pydantic.ConfigDict(extra="forbid")
+
+
+class SokData(pydantic.BaseModel):
+    titel: str
+    undertitel: str
+    soktyp: str | None
+    statusrad: str
+    brodsmula: str | None
+    parti_kod: str | None
+    parti_namn: str | None
+    parti_website_url: str | None
+    parti_website_namn: str | None
+    parti_epost: str | None
+    parti_telefon: str | None
+    parti_telefontider: str | None
+    parti_logotyp_img_id: str | None
+    parti_logotyp_img_url: str | None
+    parti_logotyp_img_alt: str | None
+    parti_mandat: str | None
+    kalenderprio: str | None
+
+    model_config = pydantic.ConfigDict(extra="forbid")
+
+
+class DokumentListaDokument(pydantic.BaseModel):
+    ardometyp: str | None
+    audio: str | None
+    avdelning: str
+    avdelningar: shared.Avdelningar | None
+    beredningsdag: str | None
+    beslutad: str | None
+    beslutsdag: str | None
+    beteckning: str | None
+    database: str
+    datum: datetime.date
+    debatt: str | None
+    debattdag: str | None
+    debattgrupp: str | None
+    debattnamn: str
+    debattsekunder: str | None
+    dok_id: str
+    dokintressent: str | None
+    doktyp: str
+    dokument_url_html: str
+    dokument_url_text: str
+    dokumentformat: str | None
+    dokumentnamn: str
+    domain: str
+    filbilaga: FilBilaga | None
+    id: str
+    inlamnad: str | None
+    justeringsdag: str | None
+    kall_id: str | None
+    kalla: str | None
+    klockslag: str | None
+    lang: str | None
+    motionstid: str | None
+    notis: str | None
+    notisrubrik: str
+    nummer: str | None
+    organ: str | None
+    plats: str | None
+    # TODO this field can contain date (2018-03-07) and datetime (2016-02-11 15:28:15)
+    publicerad: str
+    rddata: str | None
+    rdrest: str | None
+    relaterat_id: str | None
+    relurl: str | None
+    reservationer: str | None
+    rm: str
+    score: str
+    slutdatum: str | None
+    sokdata: SokData
+    status: str | None
+    struktur: str | None
+    subtyp: str
+    summary: str | None
+    systemdatum: datetime.datetime
+    tempbeteckning: str | None
+    tilldelat: str | None
+    titel: str
+    traff: int
+    typ: DokumentTyp
+    undertitel: str | None
+    url: str | None
+    video: str | None
+
+    model_config = pydantic.ConfigDict(extra="forbid")
+
+    def get_rm(self) -> str:
+        return self.rm or "missing"
+
+    def get_typ_short_name(self) -> str:
+        return self.typ.short_name() if self.typ else "missing"
+
+    def get_typ_long_name(self) -> str:
+        return self.typ.long_name() if self.typ else "missing"
+
+
+class DokumentLista(pydantic.BaseModel):
+    d_dt: str = pydantic.Field(alias="@dDt")
+    d_pre: str = pydantic.Field(alias="@dPre")
+    d_r: str = pydantic.Field(alias="@dR")
+    d_sol: str = pydantic.Field(alias="@dSol")
+    datum: datetime.datetime = pydantic.Field(alias="@datum")
+    ms: str = pydantic.Field(alias="@ms")
+    nasta_sida: str | None = pydantic.Field(alias="@nasta_sida")
+    q: str = pydantic.Field(alias="@q")
+    sida: int = pydantic.Field(alias="@sida")
+    sidor: int = pydantic.Field(alias="@sidor")
+    traff_fran: int = pydantic.Field(alias="@traff_fran")
+    traff_till: int = pydantic.Field(alias="@traff_till")
+    traffar: int = pydantic.Field(alias="@traffar")
+    varning: str | None = pydantic.Field(None, alias="@varning")
+    version: str = pydantic.Field(alias="@version")
+    facettlista: str | None
+    dokument: list[DokumentListaDokument]
+
+    model_config = pydantic.ConfigDict(extra="forbid")
+
+
+class DokumentListaPage(pydantic.BaseModel):
+    dokumentlista: DokumentLista
+
+    model_config = pydantic.ConfigDict(extra="forbid")

swegov_opendata-0.1.0/src/swegov_opendata/dokument/forslag.py

@@ -0,0 +1,73 @@
+import typing as t
+
+import pydantic
+
+from swegov_opendata import shared
+
+
+class Forslag(pydantic.BaseModel):
+    hangar_id: str | None = None
+    nummer: int
+    beteckning: str | None
+    lydelse: t.Annotated[str, pydantic.BeforeValidator(shared.ensure_str)]
+    lydelse2: str | None
+    utskottet: str | None
+    kammaren: str | None
+    behandlas_i: str | None
+    behandlas_i_punkt: str | None = None
+    kammarbeslutstyp: str | None
+    intressent: str | None = None
+    avsnitt: str | None = None
+    grundforfattning: str | None = None
+    andringsforfattning: str | None = None
+
+    model_config = pydantic.ConfigDict(extra="forbid")
+
+
+class DokForslag(pydantic.BaseModel):
+    forslag: t.Annotated[list[Forslag], pydantic.BeforeValidator(shared.ensure_list)]
+
+    model_config = pydantic.ConfigDict(extra="forbid")
+
+
+class MotForslag(pydantic.BaseModel):
+    nummer: int
+    rubrik: str | None = None
+    forslag: str | None = None
+    partier: str | None
+    typ: str
+    utskottsforslag_punkt: int
+    id: str | None = None
+
+
+class DokMotForslag(pydantic.BaseModel):
+    motforslag: t.Annotated[list[MotForslag], pydantic.BeforeValidator(shared.ensure_list)]
+
+
+class UtskottsForslag(pydantic.BaseModel):
+    punkt: int
+    rubrik: str | None
+    forslag: str | None = None
+    forslag_del2: str | None = None
+    beteckning: str | None = None
+    beslut: str | None = None
+    beslutstyp: str | None = None
+    motforslag_nummer: int
+    motforslag_partier: str | None = None
+    votering_id: str | None = None
+    votering_sammanfattning_html: dict[str, t.Any] | None = None
+    votering_ledamot_url_xml: str | None = None
+    votering_url_xml: str | None = None
+    rm: str
+    bet: str
+    vinnare: str | None = None
+    voteringskrav: str | None = None
+    beslutsregelkvot: str | None = None
+    beslutsregelparagraf: str | None = None
+    punkttyp: str | None = None
+
+
+class DokUtskottsForslag(pydantic.BaseModel):
+    utskottsforslag: t.Annotated[
+        list[UtskottsForslag], pydantic.BeforeValidator(shared.ensure_list)
+    ]

swegov_opendata-0.1.0/src/swegov_opendata/dokument/intressent.py

@@ -0,0 +1,19 @@
+import typing as t
+
+import pydantic
+
+from swegov_opendata import shared
+
+
+class Intressent(pydantic.BaseModel):
+    roll: str | None
+    namn: str | None
+    partibet: str | None
+    intressent_id: str | None
+    ordning: str
+
+    model_config = pydantic.ConfigDict(extra="forbid")
+
+
+class DokIntressent(pydantic.BaseModel):
+    intressent: t.Annotated[list[Intressent], pydantic.BeforeValidator(shared.ensure_list)]

swegov_opendata-0.1.0/src/swegov_opendata/dokument/media.py

@@ -0,0 +1,33 @@
+import datetime
+import typing as t
+
+import pydantic
+
+from swegov_opendata import shared
+
+
+class Media(pydantic.BaseModel):
+    dok_id: str
+    url: str
+    videofileurl: str
+    audiofileurl: str | None
+    downloadurl: str | None
+    thumbnailurl: str | None
+    debateurl: str
+    debattsekunder: int
+    debatt_rm: str | None
+    debatt_typ: str | None
+    dok_beteckning: str | None
+    datum: datetime.datetime | None
+    videostatus: int
+    source: str
+    inspelningstyp: str
+    systemdatum: datetime.datetime
+
+    model_config = pydantic.ConfigDict(extra="forbid")
+
+
+class WebbMedia(pydantic.BaseModel):
+    media: t.Annotated[list[Media], pydantic.BeforeValidator(shared.ensure_list)]
+
+    model_config = pydantic.ConfigDict(extra="forbid")

swegov_opendata-0.1.0/src/swegov_opendata/dokument/referens.py

@@ -0,0 +1,23 @@
+import typing as t
+
+import pydantic
+
+from swegov_opendata import shared
+
+
+class Referens(pydantic.BaseModel):
+    hangar_id: str | None = None
+    referenstyp: str | None
+    uppgift: str | None
+    ref_dok_id: str
+    ref_dok_typ: str
+    ref_dok_rm: str | None
+    ref_dok_bet: str | None
+    ref_dok_titel: str | None = pydantic.Field(default="")
+    ref_dok_subtitel: str | None
+    ref_dok_subtyp: str | None = None
+    ref_dok_dokumentnamn: str | None = None
+
+
+class DokReferens(pydantic.BaseModel):
+    referens: t.Annotated[list[Referens], pydantic.BeforeValidator(shared.ensure_list)]

swegov_opendata-0.1.0/src/swegov_opendata/dokument/uppgift.py

@@ -0,0 +1,22 @@
+import datetime
+import typing as t
+
+import pydantic
+
+from swegov_opendata import shared
+
+
+class Uppgift(pydantic.BaseModel):
+    systemdatum: datetime.datetime | None = None
+    dok_id: str | None = None
+    kod: str
+    namn: str
+    text: str | None
+
+    model_config = pydantic.ConfigDict(extra="forbid")
+
+
+class DokUppgift(pydantic.BaseModel):
+    uppgift: t.Annotated[list[Uppgift], pydantic.BeforeValidator(shared.ensure_list)]
+
+    model_config = pydantic.ConfigDict(extra="forbid")

swegov_opendata-0.1.0/src/swegov_opendata/dokument/votering.py

@@ -0,0 +1,34 @@
+import pydantic
+
+
+class Votering(pydantic.BaseModel):
+    rm: str
+    beteckning: str
+    hangar_id: str
+    votering_id: str
+    punkt: str
+    namn: str
+    intressent_id: str
+    parti: str
+    valkrets: str | None
+    valkretsnummer: str
+    iort: str | None
+    rost: str
+    avser: str
+    votering: str
+    banknummer: str
+    fornamn: str
+    efternamn: str
+    kon: str
+    fodd: str
+    datum: str | None
+
+    model_config = pydantic.ConfigDict(extra="forbid")
+
+
+class DokVotering(pydantic.BaseModel):
+    votering: list[Votering]
+
+
+class DokVoteringPage(pydantic.BaseModel):
+    dokvotering: DokVotering | None

swegov_opendata-0.1.0/src/swegov_opendata/shared.py

@@ -0,0 +1,56 @@
+import typing as t
+
+import pydantic
+
+
+def ensure_int_opt(value: t.Any) -> int | None:
+    if value == "":
+        return None
+    return value
+
+
+def ensure_list(value: t.Any) -> list[t.Any]:
+    if not isinstance(value, list):
+        return [value]
+    return value
+
+
+def ensure_list_opt(value: t.Any) -> list[t.Any] | None:
+    if value is None:
+        return None
+    return ensure_list(value)
+
+
+def ensure_str(value: t.Any) -> str:
+    if value is None:
+        return ""
+    if isinstance(value, str):
+        return value
+    if isinstance(value, list):
+        if len(value) == 0:
+            return ""
+        if len(value) == 1:
+            return ensure_str(value[0])
+        nonempty_values: set[str] = {v for v in value if isinstance(v, str) and len(v) > 0}
+        if len(nonempty_values) == 0:
+            return ""
+        if len(nonempty_values) == 1:
+            return next(iter(nonempty_values))
+        raise ValueError(f"Too many unique values: {list(nonempty_values)}")
+
+    return str(value)
+
+
+def ensure_str_opt(value: t.Any) -> str | None:
+    if value is None:
+        return None
+
+    return ensure_str(value)
+
+
+class Avdelning(pydantic.BaseModel):
+    text: str
+
+
+class Avdelningar(pydantic.BaseModel):
+    avdelning: list[str]