polish-inflection 0.1.0__py3-none-any.whl

polish_inflection/__init__.py

@@ -0,0 +1,58 @@
+"""polish-inflection — odmiana polskich rzeczowników przez przypadki (dane SGJP).
+
+Lekka, czysto-Pythonowa biblioteka: kierunek generacji (``odmien``) i analizy
+zwrotnej (``podaj``), oparta o kompaktowe indeksy DAWG zbudowane z danych SGJP.
+"""
+
+from .const import (
+    BIERNIK,
+    CELOWNIK,
+    DOPEŁNIACZ,
+    LICZBY,
+    MIANOWNIK,
+    MIEJSCOWNIK,
+    MNOGA,
+    NARZĘDNIK,
+    POJEDYNCZA,
+    PRZYPADKI,
+    TEN_SAM_WYRAZ,
+    WOŁACZ,
+)
+from .core import (
+    odmien,
+    odmien_lub_none,
+    odmien_lub_wyraz,
+    odmien_warianty,
+    podaj,
+)
+from .errors import Analiza, BrakOdmiany
+
+__version__ = "0.1.0"
+
+__all__ = [
+    # funkcje
+    "odmien",
+    "odmien_lub_none",
+    "odmien_lub_wyraz",
+    "odmien_warianty",
+    "podaj",
+    # typy / wyjątki
+    "Analiza",
+    "BrakOdmiany",
+    # stałe przypadków
+    "MIANOWNIK",
+    "DOPEŁNIACZ",
+    "CELOWNIK",
+    "BIERNIK",
+    "NARZĘDNIK",
+    "MIEJSCOWNIK",
+    "WOŁACZ",
+    "PRZYPADKI",
+    # liczby
+    "POJEDYNCZA",
+    "MNOGA",
+    "LICZBY",
+    # sentinel
+    "TEN_SAM_WYRAZ",
+    "__version__",
+]

polish_inflection/build.py

@@ -0,0 +1,321 @@
+"""Pipeline BUILD (offline): SGJP ``.tab`` -> dwa indeksy ``BytesDAWG``.
+
+Uruchamiany u autora / w CI, NIGDY przy ``pip install``. Buduje kompaktowy,
+w pełni wyliczony indeks — runtime niczego nie generuje, tylko wyszukuje.
+
+Zależności buildu (extra ``build``): ``dawg2`` (import ``dawg``) do zapisu,
+``requests`` do ``refresh_sgjp``. Runtime tego nie potrzebuje.
+
+Schemat wyjścia — patrz CONTRACT §D / :mod:`polish_inflection.core`.
+"""
+
+from __future__ import annotations
+
+import argparse
+import gzip
+import hashlib
+import io
+import json
+import re
+import sys
+from collections.abc import Iterable, Iterator
+from pathlib import Path
+from typing import NamedTuple
+
+from .const import LICZBY_SET, PRZYPADKI_SET
+
+# ── Model rekordu po ekspansji ─────────────────────────────────────────────
+
+
+class Rekord(NamedTuple):
+    forma: str
+    lemat: str  # goły lemat (bez sufiksu fleksemu)
+    liczba: str  # "sg"/"pl"
+    przypadek: str  # "nom".."voc"
+    rodzaj: str  # "m1","f","n",...
+    depr: bool  # True dla form deprecjatywnych (tag depr:)
+
+
+# ── Parsowanie + EKSPANSJA tagu SGJP ───────────────────────────────────────
+
+
+def goly_lemat(lemat: str) -> str:
+    """Utnij sufiks fleksemu/homonimu: ``profesor:Sm1`` -> ``profesor``."""
+    return lemat.split(":", 1)[0]
+
+
+def parsuj_linie(linie: Iterable[str]) -> Iterator[Rekord]:
+    """Parsuj i ROZWIŃ linie SGJP ``.tab`` na pojedyncze rekordy.
+
+    Tag NIE jest 1:1: pola ``liczby`` i ``przypadki`` to kropkowo sklejone
+    podzbiory (``subst:sg:nom.acc:m3`` -> dwa rekordy). Pomija nagłówki (``#``),
+    tagi inne niż ``subst``/``depr`` oraz wpisy niekompletne/nietypowe.
+    """
+    for linia in linie:
+        linia = linia.rstrip("\n")
+        if not linia or linia.startswith("#"):
+            continue
+        pola = linia.split("\t")
+        if len(pola) < 3:
+            continue
+        forma, lemat, tag = pola[0], pola[1], pola[2]
+        if not forma or not tag:
+            continue
+
+        czesci = tag.split(":")
+        pos = czesci[0]
+        if pos not in ("subst", "depr"):
+            continue
+        if len(czesci) < 4:
+            continue
+
+        depr = pos == "depr"
+        bare = goly_lemat(lemat)
+        liczby = czesci[1].split(".")
+        przypadki = czesci[2].split(".")
+        rodzaj = czesci[3].split(".")[0]  # rodzaj bywa kropkowany — bierz główny
+
+        for liczba in liczby:
+            if liczba not in LICZBY_SET:
+                continue
+            for przypadek in przypadki:
+                if przypadek not in PRZYPADKI_SET:
+                    continue
+                yield Rekord(forma, bare, liczba, przypadek, rodzaj, depr)
+
+
+# ── Budowa indeksów (marisa-trie BytesTrie) ────────────────────────────────
+
+
+def _pary_dawg(rekordy: Iterable[Rekord]):
+    """Zwróć (pary_odmien, pary_podaj) jako listy (klucz:str, wartosc:bytes).
+
+    odmien: tylko subst (formy główne). podaj: subst + depr.
+    Deduplikacja identycznych par.
+    """
+    odmien_set: set[tuple[str, bytes]] = set()
+    podaj_set: set[tuple[str, bytes]] = set()
+    for r in rekordy:
+        wart_podaj = f"{r.lemat}\t{r.przypadek}\t{r.liczba}\t{r.rodzaj}".encode()
+        podaj_set.add((r.forma, wart_podaj))
+        if not r.depr:
+            klucz = f"{r.lemat}\t{r.przypadek}\t{r.liczba}"
+            odmien_set.add((klucz, r.forma.encode("utf-8")))
+    return sorted(odmien_set), sorted(podaj_set)
+
+
+def zbuduj_dawgi(rekordy: Iterable[Rekord]):
+    """Zbuduj i zwróć oba ``marisa_trie.BytesTrie`` (odmien, podaj)."""
+    import marisa_trie
+
+    pary_odmien, pary_podaj = _pary_dawg(rekordy)
+    return marisa_trie.BytesTrie(pary_odmien), marisa_trie.BytesTrie(pary_podaj)
+
+
+# ── Czytanie źródła ────────────────────────────────────────────────────────
+
+
+def _otworz_tab(sciezka: Path) -> Iterator[str]:
+    """Otwórz ``.tab`` lub ``.tab.gz`` jako strumień linii (utf-8)."""
+    if sciezka.suffix == ".gz":
+        with gzip.open(sciezka, "rt", encoding="utf-8") as f:
+            yield from f
+    else:
+        with open(sciezka, encoding="utf-8") as f:
+            yield from f
+
+
+_DICT_ID_RE = re.compile(r"#!DICT-ID\s+(\S+)")
+
+
+def wersja_sgjp(sciezka: Path) -> str | None:
+    """Odczytaj wersję z nagłówka ``#!DICT-ID pl.sgjp.sgjp-YYYY.MM.DD``."""
+    for linia in _otworz_tab(sciezka):
+        m = _DICT_ID_RE.search(linia)
+        if m:
+            return m.group(1)
+        if not linia.startswith("#"):
+            break
+    return None
+
+
+# ── Pełny bieg buildu ──────────────────────────────────────────────────────
+
+
+def zbuduj_z_tab(sciezka_tab: Path, out_dir: Path, *, data_build: str | None = None) -> dict:
+    """Zbuduj ``odmien.marisa``/``podaj.marisa`` + ``BUILD_INFO.json`` w ``out_dir``.
+
+    Zwraca słownik BUILD_INFO. ``data_build`` przekazuje wywołujący (brak zegara
+    w bibliotece); ``None`` -> pole pominięte.
+    """
+    sciezka_tab = Path(sciezka_tab)
+    out_dir = Path(out_dir)
+    out_dir.mkdir(parents=True, exist_ok=True)
+
+    rekordy = list(parsuj_linie(_otworz_tab(sciezka_tab)))
+    odmien_trie, podaj_trie = zbuduj_dawgi(rekordy)
+
+    odmien_path = out_dir / "odmien.marisa"
+    podaj_path = out_dir / "podaj.marisa"
+    odmien_trie.save(str(odmien_path))
+    podaj_trie.save(str(podaj_path))
+
+    lematy = {r.lemat for r in rekordy}
+    formy = {(r.forma, r.lemat, r.liczba, r.przypadek) for r in rekordy}
+    info = {
+        "wersja_sgjp": wersja_sgjp(sciezka_tab),
+        "data_build": data_build,
+        "liczba_lematow": len(lematy),
+        "liczba_form": len(formy),
+        "liczba_rekordow": len(rekordy),
+        "rozmiar_odmien_marisa": odmien_path.stat().st_size,
+        "rozmiar_podaj_marisa": podaj_path.stat().st_size,
+    }
+    (out_dir / "BUILD_INFO.json").write_text(
+        json.dumps(info, ensure_ascii=False, indent=2) + "\n", encoding="utf-8"
+    )
+    return info
+
+
+# ── refresh-sgjp (jedyne miejsce sięgające do sieci) ───────────────────────
+
+_BAZA_URL = "https://download.sgjp.pl/morfeusz"
+_KATALOG_RE = re.compile(r'href="(\d{8})/"')
+
+
+def _najnowsza_wersja(sesja) -> str:
+    """Znajdź najnowszy katalog dat (``YYYYMMDD``) w indeksie SGJP."""
+    r = sesja.get(f"{_BAZA_URL}/", timeout=60)
+    r.raise_for_status()
+    daty = sorted(set(_KATALOG_RE.findall(r.text)))
+    if not daty:
+        raise RuntimeError("Nie znaleziono katalogów wersji SGJP.")
+    return daty[-1]
+
+
+def _wytnij_licencje(naglowek: str) -> str | None:
+    """Wytnij blok ``#<COPYRIGHT> ... #</COPYRIGHT>`` (verbatim) z nagłówka."""
+    linie = []
+    zapisuj = False
+    for linia in naglowek.splitlines():
+        if linia.startswith("#<COPYRIGHT>"):
+            zapisuj = True
+            continue
+        if linia.startswith("#</COPYRIGHT>"):
+            break
+        if zapisuj:
+            linie.append(linia)
+    return "\n".join(linie).strip() + "\n" if linie else None
+
+
+def refresh_sgjp(dane_dir: Path, *, wersja: str | None = None, data_pobrania: str | None = None):
+    """Pobierz najnowszy (lub wskazany) SGJP ``.tab.gz``, zwendoruj, zaktualizuj pin.
+
+    Zapisuje ``sgjp-<wersja>.tab.gz``, ``PIN.json`` i ``LICENSE.sgjp``.
+    """
+    import requests
+
+    dane_dir = Path(dane_dir)
+    dane_dir.mkdir(parents=True, exist_ok=True)
+    sesja = requests.Session()
+
+    if wersja is None:
+        wersja = _najnowsza_wersja(sesja)
+    url = f"{_BAZA_URL}/{wersja}/sgjp-{wersja}.tab.gz"
+
+    print(f"Pobieram {url} ...", file=sys.stderr)
+    r = sesja.get(url, timeout=600)
+    r.raise_for_status()
+    dane = r.content
+    sha256 = hashlib.sha256(dane).hexdigest()
+
+    plik = dane_dir / f"sgjp-{wersja}.tab.gz"
+    plik.write_bytes(dane)
+
+    # Nagłówek do wersji i licencji. UWAGA: treść bloku #<COPYRIGHT>..#</COPYRIGHT>
+    # to zwykłe linie BEZ prefiksu '#', więc nie można przerywać na pierwszej
+    # linii bez '#'; czytamy dalej dopóki jesteśmy wewnątrz bloku licencji.
+    with gzip.open(io.BytesIO(dane), "rt", encoding="utf-8") as f:
+        naglowek_linie = []
+        wewnatrz_licencji = False
+        for linia in f:
+            s = linia.rstrip("\n")
+            if not wewnatrz_licencji and not s.startswith("#"):
+                break
+            naglowek_linie.append(linia)
+            if s.startswith("#<COPYRIGHT>"):
+                wewnatrz_licencji = True
+            elif s.startswith("#</COPYRIGHT>"):
+                wewnatrz_licencji = False
+    naglowek = "".join(naglowek_linie)
+    m = _DICT_ID_RE.search(naglowek)
+    dict_id = m.group(1) if m else None
+
+    licencja = _wytnij_licencje(naglowek)
+    if licencja:
+        (dane_dir / "LICENSE.sgjp").write_text(licencja, encoding="utf-8")
+
+    pin = {
+        "wersja": wersja,
+        "dict_id": dict_id,
+        "data_pobrania": data_pobrania,
+        "sha256": sha256,
+        "url_zrodlowy": url,
+        "plik": plik.name,
+    }
+    (dane_dir / "PIN.json").write_text(
+        json.dumps(pin, ensure_ascii=False, indent=2) + "\n", encoding="utf-8"
+    )
+    print(f"Zapisano {plik.name} (sha256={sha256[:12]}…), zaktualizowano PIN.json", file=sys.stderr)
+    return pin
+
+
+# ── CLI ────────────────────────────────────────────────────────────────────
+
+
+def _domyslny_pin_tab(dane_dir: Path) -> Path:
+    """Znajdź vendorowany ``.tab.gz`` wg ``PIN.json`` (lub jedyny w katalogu)."""
+    pin_path = dane_dir / "PIN.json"
+    if pin_path.exists():
+        pin = json.loads(pin_path.read_text(encoding="utf-8"))
+        nazwa = pin.get("plik")
+        if nazwa and (dane_dir / nazwa).exists():
+            return dane_dir / nazwa
+    kandydaci = sorted(dane_dir.glob("*.tab.gz"))
+    if not kandydaci:
+        raise SystemExit(f"Brak vendorowanego SGJP w {dane_dir}. Uruchom `refresh-sgjp`.")
+    return kandydaci[-1]
+
+
+def main(argv: list[str] | None = None) -> int:
+    repo = Path(__file__).resolve().parents[2]
+    parser = argparse.ArgumentParser(prog="polish-inflection-build")
+    sub = parser.add_subparsers(dest="cmd", required=True)
+
+    p_build = sub.add_parser("build", help="Zbuduj indeksy z vendorowanego pinu (bez sieci).")
+    p_build.add_argument("--tab", type=Path, default=None, help="Ścieżka do .tab/.tab.gz")
+    p_build.add_argument("--out", type=Path, default=repo / "src" / "polish_inflection" / "data")
+    p_build.add_argument("--data-build", default=None, help="Data buildu (do BUILD_INFO).")
+
+    p_refresh = sub.add_parser("refresh-sgjp", help="Pobierz najnowszy SGJP i zaktualizuj pin.")
+    p_refresh.add_argument("--wersja", default=None, help="Konkretna wersja YYYYMMDD.")
+    p_refresh.add_argument("--data-pobrania", default=None)
+    p_refresh.add_argument("--dane-dir", type=Path, default=repo / "data" / "sgjp")
+
+    args = parser.parse_args(argv)
+
+    if args.cmd == "build":
+        tab = args.tab or _domyslny_pin_tab(repo / "data" / "sgjp")
+        info = zbuduj_z_tab(tab, args.out, data_build=args.data_build)
+        print(json.dumps(info, ensure_ascii=False, indent=2))
+        return 0
+
+    if args.cmd == "refresh-sgjp":
+        refresh_sgjp(args.dane_dir, wersja=args.wersja, data_pobrania=args.data_pobrania)
+        return 0
+
+    return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

polish_inflection/const.py

@@ -0,0 +1,37 @@
+"""Nazwane stałe przypadków i liczby (mapowane 1:1 na tagi SGJP) oraz sentinel
+``TEN_SAM_WYRAZ`` dla trybu passthrough w :func:`polish_inflection.core.odmien`.
+"""
+
+# Przypadki — wartości identyczne z tagami SGJP.
+MIANOWNIK = "nom"  # kto? co?
+DOPEŁNIACZ = "gen"  # kogo? czego?
+CELOWNIK = "dat"  # komu? czemu?
+BIERNIK = "acc"  # kogo? co?
+NARZĘDNIK = "inst"  # (z) kim? (z) czym?
+MIEJSCOWNIK = "loc"  # o kim? o czym?
+WOŁACZ = "voc"  # o!
+
+# Liczba.
+POJEDYNCZA = "sg"
+MNOGA = "pl"
+
+PRZYPADKI = (MIANOWNIK, DOPEŁNIACZ, CELOWNIK, BIERNIK, NARZĘDNIK, MIEJSCOWNIK, WOŁACZ)
+LICZBY = (POJEDYNCZA, MNOGA)
+
+# Zbiory do szybkiej walidacji w buildzie/runtime.
+PRZYPADKI_SET = frozenset(PRZYPADKI)
+LICZBY_SET = frozenset(LICZBY)
+
+
+class _TenSamWyraz:
+    """Sentinel: gdy przekazany jako ``default`` do ``odmien`` i brak formy —
+    zwróć wejściowy wyraz zamiast rzucać wyjątek."""
+
+    __slots__ = ()
+
+    def __repr__(self) -> str:
+        return "TEN_SAM_WYRAZ"
+
+
+#: Wartownik dla ``odmien(..., default=TEN_SAM_WYRAZ)`` — passthrough wejścia.
+TEN_SAM_WYRAZ = _TenSamWyraz()

polish_inflection/core.py

@@ -0,0 +1,159 @@
+"""Runtime API: odmiana (``odmien``) i analiza zwrotna (``podaj``).
+
+Czyta gotowe indeksy ``odmien.marisa`` / ``podaj.marisa`` (marisa-trie
+``BytesTrie``) leniwie i przez ``mmap`` (stała pamięć — import nie ładuje
+słownika do RAM). Schemat kluczy/wartości opisuje CONTRACT §D:
+
+    odmien.marisa:  klucz "lemat\\tprzypadek\\tliczba"  -> wartość: forma (utf-8)
+    podaj.marisa:   klucz "forma"  -> wartość: "lemat\\tprzypadek\\tliczba\\trodzaj"
+"""
+
+from __future__ import annotations
+
+from importlib.resources import files
+from pathlib import Path
+
+import marisa_trie
+
+from .const import POJEDYNCZA, TEN_SAM_WYRAZ
+from .errors import Analiza, BrakOdmiany
+
+__all__ = [
+    "odmien",
+    "odmien_lub_none",
+    "odmien_lub_wyraz",
+    "odmien_warianty",
+    "podaj",
+]
+
+# Wewnętrzny wartownik: "default nie podany -> rzuć BrakOdmiany".
+_BRAK = object()
+
+# Leniwie ładowane, mmapowane indeksy. Cache modułowy.
+_odmien_dawg = None
+_podaj_dawg = None
+
+# Katalog z danymi — domyślnie pakietowy ``polish_inflection/data``.
+# Testy podmieniają go przez ``_ustaw_katalog_danych``.
+_katalog_danych: Path | None = None
+
+
+def _domyslny_katalog_danych() -> Path:
+    return Path(str(files("polish_inflection") / "data"))
+
+
+def _ustaw_katalog_danych(sciezka) -> None:
+    """Wskaż inny katalog z ``odmien.dawg``/``podaj.dawg`` i wyczyść cache.
+
+    Używane w testach (fixture DAWG budowany do tmp) oraz w integracji.
+    ``None`` przywraca katalog pakietowy.
+    """
+    global _katalog_danych, _odmien_dawg, _podaj_dawg
+    _katalog_danych = Path(sciezka) if sciezka is not None else None
+    _odmien_dawg = None
+    _podaj_dawg = None
+
+
+def _wczytaj(nazwa: str):
+    katalog = _katalog_danych or _domyslny_katalog_danych()
+    sciezka = katalog / nazwa
+    if not sciezka.exists():
+        raise RuntimeError(
+            f"Brak zbudowanego indeksu {sciezka}. "
+            "Uruchom build: `polish-inflection-build build` (patrz docs/budowanie.md)."
+        )
+    trie = marisa_trie.BytesTrie()
+    trie.mmap(str(sciezka))  # memory-mapped — stała pamięć, bez wczytywania do RAM
+    return trie
+
+
+def _dawg_odmien():
+    global _odmien_dawg
+    if _odmien_dawg is None:
+        _odmien_dawg = _wczytaj("odmien.marisa")
+    return _odmien_dawg
+
+
+def _dawg_podaj():
+    global _podaj_dawg
+    if _podaj_dawg is None:
+        _podaj_dawg = _wczytaj("podaj.marisa")
+    return _podaj_dawg
+
+
+def _formy(wyraz: str, przypadek: str, liczba: str) -> list[str]:
+    """Posortowana lista poprawnych form w slocie (może być pusta)."""
+    klucz = f"{wyraz}\t{przypadek}\t{liczba}"
+    wartosci = _dawg_odmien().get(klucz)
+    if not wartosci:
+        return []
+    return sorted(v.decode("utf-8") for v in wartosci)
+
+
+def odmien(wyraz: str, przypadek: str, liczba: str = POJEDYNCZA, *, default=_BRAK):
+    """Zwróć główną formę ``wyraz`` w danym przypadku i liczbie.
+
+    Zachowanie przy braku formy (słowo spoza słownika lub liczba nieistniejąca
+    dla lematu, np. ``sg`` dla plurale tantum):
+
+    - ``default`` niepodany         -> ``raise BrakOdmiany``
+    - ``default is TEN_SAM_WYRAZ``  -> zwróć ``wyraz`` (passthrough)
+    - ``default is None``           -> zwróć ``None``
+    - ``default = <cokolwiek>``     -> zwróć ``default``
+
+    Główna forma = pierwsza po sortowaniu bajtowym wartości slotu (deterministyczna).
+
+    >>> odmien("wydział", "gen")
+    'wydziału'
+    >>> odmien("wydział", "gen", "pl")
+    'wydziałów'
+    """
+    formy = _formy(wyraz, przypadek, liczba)
+    if formy:
+        return formy[0]
+    if default is _BRAK:
+        raise BrakOdmiany((wyraz, przypadek, liczba))
+    if default is TEN_SAM_WYRAZ:
+        return wyraz
+    return default
+
+
+def odmien_lub_none(wyraz: str, przypadek: str, liczba: str = POJEDYNCZA):
+    """Jak ``odmien``, ale przy braku formy zwraca ``None`` (nie rzuca)."""
+    return odmien(wyraz, przypadek, liczba, default=None)
+
+
+def odmien_lub_wyraz(wyraz: str, przypadek: str, liczba: str = POJEDYNCZA) -> str:
+    """Jak ``odmien``, ale przy braku formy zwraca wejściowy ``wyraz`` (passthrough)."""
+    return odmien(wyraz, przypadek, liczba, default=TEN_SAM_WYRAZ)
+
+
+def odmien_warianty(wyraz: str, przypadek: str, liczba: str = POJEDYNCZA) -> list[str]:
+    """Wszystkie poprawne formy w slocie (oboczności), posortowane. ``[]`` gdy brak."""
+    return _formy(wyraz, przypadek, liczba)
+
+
+def podaj(wyraz: str, liczba: str | None = None) -> list[Analiza]:
+    """Kierunek zwrotny: forma -> lista analiz.
+
+    Zwraca LISTĘ, bo polszczyzna ma synkretyzm (jedna forma = wiele przypadków)
+    i homografię (jedna forma = wiele lematów). Uwzględnia też formy
+    deprecjatywne (``depr``). Opcjonalny ``liczba`` ("sg"/"pl") zawęża wynik.
+    Nieznana forma -> ``[]``.
+
+    >>> podaj("jednostki")  # doctest: +SKIP
+    [Analiza('jednostka','gen','sg','f'), Analiza('jednostka','nom','pl','f'), ...]
+    """
+    wartosci = _dawg_podaj().get(wyraz)
+    if not wartosci:
+        return []
+    analizy: set[Analiza] = set()
+    for w in wartosci:
+        pola = w.decode("utf-8").split("\t")
+        if len(pola) != 4:
+            continue
+        lemat, przypadek, lb, rodzaj = pola
+        if liczba is not None and lb != liczba:
+            continue
+        analizy.add(Analiza(lemat, przypadek, lb, rodzaj))
+    return sorted(analizy, key=lambda a: (a.liczba, a.przypadek, a.lemat, a.rodzaj))

polish_inflection/data/BUILD_INFO.json

@@ -0,0 +1,9 @@
+{
+  "wersja_sgjp": "pl.sgjp.sgjp-2026.06.29",
+  "data_build": "2026-07-02",
+  "liczba_lematow": 223748,
+  "liczba_form": 3666104,
+  "liczba_rekordow": 3864426,
+  "rozmiar_odmien_marisa": 24431696,
+  "rozmiar_podaj_marisa": 25000464
+}

polish_inflection/errors.py

@@ -0,0 +1,21 @@
+"""Typy wyników i wyjątki publicznego API."""
+
+from __future__ import annotations
+
+from typing import NamedTuple
+
+
+class Analiza(NamedTuple):
+    """Pojedyncza analiza morfologiczna formy (kierunek zwrotny ``podaj``)."""
+
+    lemat: str
+    przypadek: str  # jedna ze stałych PRZYPADKI: "nom".."voc"
+    liczba: str  # "sg" / "pl"
+    rodzaj: str  # tag rodzaju SGJP: "m1","m2","m3","f","n","ncol",...
+
+
+class BrakOdmiany(KeyError):
+    """Brak formy dla (wyraz, przypadek, liczba) i nie podano ``default``.
+
+    Dziedziczy po ``KeyError`` — bo to w istocie brak klucza w słowniku form.
+    """

polish_inflection-0.1.0.dist-info/METADATA

@@ -0,0 +1,291 @@
+Metadata-Version: 2.4
+Name: polish-inflection
+Version: 0.1.0
+Summary: Lekka odmiana polskich rzeczowników przez przypadki (dane SGJP, indeks marisa-trie, mmap).
+Project-URL: Homepage, https://github.com/mpasternak/polish-inflection
+Project-URL: Repository, https://github.com/mpasternak/polish-inflection
+Author-email: Michał Pasternak <m@iplweb.pl>
+License: BSD-2-Clause
+License-File: LICENSE
+License-File: NOTICE.md
+Keywords: declension,inflection,morphology,nlp,odmiana,polish,przypadki,sgjp
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Natural Language :: Polish
+Classifier: Programming Language :: Python :: 3
+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: Programming Language :: Python :: 3.13
+Classifier: Topic :: Text Processing :: Linguistic
+Requires-Python: >=3.9
+Requires-Dist: marisa-trie>=1.0
+Provides-Extra: build
+Requires-Dist: requests>=2.28; extra == 'build'
+Description-Content-Type: text/markdown
+
+# polish-inflection
+
+[![CI](https://github.com/iplweb/polish-inflection/actions/workflows/ci.yml/badge.svg)](https://github.com/iplweb/polish-inflection/actions/workflows/ci.yml)
+[![License: BSD-2-Clause](https://img.shields.io/badge/License-BSD--2--Clause-blue.svg)](LICENSE)
+
+Lekka, dane-only odmiana polskich **rzeczowników** przez przypadki.
+Dane pochodzą ze [Słownika gramatycznego języka polskiego (SGJP)](https://morfeusz.sgjp.pl/),
+wyszukiwanie oparte jest o kompaktowy indeks `marisa-trie` (mmap, ~1 µs/lookup).
+Instalacja bez kompilatora (gotowe binarne wheele), zero Django, jedna
+zależność runtime.
+
+---
+
+## 🇵🇱 Wersja polska
+
+### Cel
+
+Chcesz z wyrazu `wydział` dostać `wydziału` (dopełniacz), `wydziałowi`
+(celownik), `wydziałów` (dopełniacz liczby mnogiej) — programowo, bez trzymania
+form ręcznie w tabeli. `polish-inflection` odmienia rzeczowniki przez
+**7 przypadków × 2 liczby** w obie strony:
+
+- generacja: `lemat + przypadek + liczba → forma` (`odmien`);
+- analiza (kierunek zwrotny): `forma → [analizy]` (`podaj`).
+
+### Dlaczego — luka w ekosystemie
+
+Nie istniało lekkie, dane-only, przyjazne wdrożeniu rozwiązanie do
+odmiany polskich rzeczowników przez przypadki:
+
+- **gettext / formy mnogie** rozwiązują *inny* problem — wybór wariantu wg
+  **liczby** (`nplurals`), a nie odmianę przez **przypadki**. gettext nie zna
+  pojęcia przypadka i nie potrafi odmienić rzeczownika.
+- **Morfeusz 2** to kanoniczny analizator i generator morfologii polskiej, ale
+  natywny silnik C++ + bindingi SWIG + kompilacja słownika rzędu dziesiątek MB.
+  Armata na muchę i ból wdrożeniowy w kontenerze. Tu nie ma silnika, SWIG-a ani
+  kompilacji słownika — tylko dane i `pip install`.
+- **pymorphy2 / pymorphy3** obsługują tylko rosyjski i ukraiński — nie polski.
+- **inflection / inflect / pyinflect** — tylko angielski.
+
+Kluczowa idea: bierzemy **dane** SGJP (trójki `forma / lemat / tag`), a odrzucamy
+**silnik**. Zbiór form jest zamknięty i w pełni wyliczony — nic nie generujemy
+w locie, tylko indeksujemy i wyszukujemy.
+
+### Instalacja
+
+```bash
+pip install polish-inflection
+```
+
+Jedyna zależność runtime to `marisa-trie` — kompilowane rozszerzenie C++, które
+dostarcza gotowe binarne wheele (Linux/macOS/Windows, cp39–cp313), więc
+`pip install` nie potrzebuje kompilatora ani narzędzi build. Pakiet wiezie gotowe
+indeksy `.marisa` w wheelu — bez SGJP. Czytnik używa **mmap**: import nie ładuje
+słownika do RAM, a pojedynczy lookup stronicuje tylko O(długość słowa) węzłów
+(~1 µs, mierzony narzut RSS ~1,5 MB zamiast ~23 MB pełnego wczytania).
+
+### Przykłady — `odmien`
+
+```python
+from polish_inflection import odmien, DOPEŁNIACZ, MNOGA
+
+odmien("wydział", DOPEŁNIACZ)          # -> "wydziału"
+odmien("wydział", DOPEŁNIACZ, MNOGA)   # -> "wydziałów"
+```
+
+Zachowanie przy słowie spoza słownika jest sterowane parametrem `default`:
+
+```python
+from polish_inflection import (
+    odmien, odmien_lub_none, odmien_lub_wyraz, BrakOdmiany, DOPEŁNIACZ,
+)
+
+odmien("wydział", DOPEŁNIACZ)                 # "wydziału"
+odmien("qwerty", DOPEŁNIACZ)                  # raise BrakOdmiany
+odmien_lub_none("qwerty", DOPEŁNIACZ)         # None
+odmien_lub_wyraz("qwerty", DOPEŁNIACZ)        # "qwerty"  (passthrough wejścia)
+odmien("qwerty", DOPEŁNIACZ, default="—")     # "—"       (dowolny fallback)
+```
+
+Oboczności (kilka poprawnych form w jednym slocie) zwraca `odmien_warianty`:
+
+```python
+from polish_inflection import odmien_warianty, MIEJSCOWNIK
+odmien_warianty("pokój", MIEJSCOWNIK)   # -> lista wszystkich poprawnych form
+```
+
+### Przykłady — `podaj` (kierunek zwrotny)
+
+Polszczyzna ma synkretyzm (jedna forma = wiele przypadków) i homografię (jedna
+forma = wiele lematów), więc `podaj` zwraca **listę** analiz:
+
+```python
+from polish_inflection import podaj
+
+podaj("jednostki")
+# [Analiza(lemat='jednostka', przypadek='gen', liczba='sg', rodzaj='f'),
+#  Analiza(lemat='jednostka', przypadek='nom', liczba='pl', rodzaj='f'),
+#  Analiza(lemat='jednostka', przypadek='acc', liczba='pl', rodzaj='f'),
+#  Analiza(lemat='jednostka', przypadek='voc', liczba='pl', rodzaj='f')]
+
+podaj("jednostki", liczba="pl")   # zawężenie do liczby mnogiej
+```
+
+`Analiza` to lekki `NamedTuple`: `(lemat, przypadek, liczba, rodzaj)`.
+
+### Stałe
+
+Przypadki: `MIANOWNIK`, `DOPEŁNIACZ`, `CELOWNIK`, `BIERNIK`, `NARZĘDNIK`,
+`MIEJSCOWNIK`, `WOŁACZ`. Liczby: `POJEDYNCZA`, `MNOGA` (domyślnie `POJEDYNCZA`).
+Sentinel `TEN_SAM_WYRAZ` służy jako `default` zwracający wejściowy wyraz.
+
+### Źródło danych i atrybucja
+
+Dane fleksyjne pochodzą ze **Słownika gramatycznego języka polskiego (SGJP)**,
+w wersji przypiętej i zwendorowanej w repozytorium (patrz `data/sgjp/`).
+Zbudowane indeksy pokrywają 223 748 lematów / ~3,86 mln rekordów form i ważą
+łącznie ~49 MB (`odmien.marisa` ≈ 24 MB, `podaj.marisa` ≈ 25 MB).
+
+> Copyright © 2007–2026 Marcin Woliński, Zbigniew Bronk, Włodzimierz
+> Gruszczyński, Witold Kieraś, Zygmunt Saloni, Danuta Skowrońska, Robert Wołosz.
+
+SGJP jest udostępniany na licencji 2-clause BSD. Strona licencyjna:
+<https://morfeusz.sgjp.pl/doc/license/en>. Pełny tekst i szczegóły atrybucji —
+patrz [`NOTICE.md`](NOTICE.md) oraz `data/sgjp/LICENSE.sgjp`.
+
+### Licencja
+
+Dwie warstwy, jawnie rozdzielone:
+
+- **Kod pakietu** — BSD-2-Clause, © Michał Pasternak (plik [`LICENSE`](LICENSE)).
+- **Dane SGJP** — BSD-2-Clause, © autorzy wymienieni wyżej. Redystrybucja jest
+  dozwolona pod warunkiem zachowania noty copyright, tekstu licencji i atrybucji
+  (szczegóły w [`NOTICE.md`](NOTICE.md)).
+
+### Ograniczenia (v1)
+
+- Tylko **rzeczowniki**. Bez czasowników, przymiotników, liczebników.
+- Bez guessera słów spoza słownika i bez analizy biegnącego tekstu
+  (segmentacji/tokenizacji) — świadome YAGNI.
+- Zakres: 7 przypadków × 2 liczby, oba kierunki (`odmien` / `podaj`).
+
+---
+
+## 🇬🇧 English version
+
+### Purpose
+
+Turn `wydział` into `wydziału` (genitive), `wydziałowi` (dative), `wydziałów`
+(genitive plural) — programmatically, without keeping inflected forms by hand.
+`polish-inflection` declines Polish **nouns** across **7 cases × 2 numbers** in
+both directions:
+
+- generation: `lemma + case + number → form` (`odmien`);
+- analysis (reverse): `form → [analyses]` (`podaj`).
+
+### Why — a gap in the ecosystem
+
+There was no lightweight, data-only, deployment-friendly way to decline Polish
+nouns by case:
+
+- **gettext / plural forms** solve a *different* problem — picking a variant by
+  **number** (`nplurals`), not declension by **case**. gettext has no concept of
+  grammatical case and cannot decline a noun.
+- **Morfeusz 2** is the canonical Polish morphological analyzer and generator,
+  but ships a native C++ engine + SWIG bindings + a compiled dictionary of tens
+  of MB. Overkill and a container-deployment headache. Here there is no engine,
+  no SWIG and no dictionary compilation — just data and `pip install`.
+- **pymorphy2 / pymorphy3** cover only Russian and Ukrainian — not Polish.
+- **inflection / inflect / pyinflect** — English only.
+
+Core idea: take the SGJP **data** (`form / lemma / tag` triples), drop the
+**engine**. The set of forms is closed and fully enumerated — we generate
+nothing at runtime, we only index and look up.
+
+### Installation
+
+```bash
+pip install polish-inflection
+```
+
+The only runtime dependency is `marisa-trie` — a compiled C++ extension that
+ships prebuilt binary wheels (Linux/macOS/Windows, cp39–cp313), so `pip install`
+needs no compiler and no build tooling. The wheel ships prebuilt `.marisa`
+indices — no SGJP required. The reader uses **mmap**: import does not load the
+dictionary into RAM, and a single lookup pages in only O(word length) nodes
+(~1 µs, measured RSS overhead ~1.5 MB instead of ~23 MB for a full load). The
+indices cover 223,748 lemmas / ~3.86M form records and weigh ~49 MB total
+(`odmien.marisa` ≈ 24 MB, `podaj.marisa` ≈ 25 MB).
+
+### Examples — `odmien`
+
+```python
+from polish_inflection import odmien, DOPEŁNIACZ, MNOGA
+
+odmien("wydział", DOPEŁNIACZ)          # -> "wydziału"
+odmien("wydział", DOPEŁNIACZ, MNOGA)   # -> "wydziałów"
+```
+
+Out-of-dictionary behaviour is controlled by `default`:
+
+```python
+from polish_inflection import (
+    odmien, odmien_lub_none, odmien_lub_wyraz, BrakOdmiany, DOPEŁNIACZ,
+)
+
+odmien("wydział", DOPEŁNIACZ)                 # "wydziału"
+odmien("qwerty", DOPEŁNIACZ)                  # raises BrakOdmiany
+odmien_lub_none("qwerty", DOPEŁNIACZ)         # None
+odmien_lub_wyraz("qwerty", DOPEŁNIACZ)        # "qwerty"  (passthrough)
+odmien("qwerty", DOPEŁNIACZ, default="—")     # "—"       (any fallback)
+```
+
+`odmien_warianty` returns all valid forms in a slot (variants).
+
+### Examples — `podaj` (reverse direction)
+
+Polish has syncretism (one form = many cases) and homography (one form = many
+lemmas), so `podaj` returns a **list** of analyses:
+
+```python
+from polish_inflection import podaj
+
+podaj("jednostki")
+# [Analiza(lemat='jednostka', przypadek='gen', liczba='sg', rodzaj='f'),
+#  Analiza(lemat='jednostka', przypadek='nom', liczba='pl', rodzaj='f'),
+#  Analiza(lemat='jednostka', przypadek='acc', liczba='pl', rodzaj='f'),
+#  Analiza(lemat='jednostka', przypadek='voc', liczba='pl', rodzaj='f')]
+
+podaj("jednostki", liczba="pl")   # narrow to plural
+```
+
+`Analiza` is a lightweight `NamedTuple`: `(lemat, przypadek, liczba, rodzaj)`.
+Constant names stay Polish (`MIANOWNIK`, `DOPEŁNIACZ`, …, `POJEDYNCZA`, `MNOGA`)
+and map to SGJP tags (`nom`, `gen`, …, `sg`, `pl`).
+
+### Data source and attribution
+
+The inflectional data comes from the **Grammatical Dictionary of Polish (SGJP)**,
+pinned and vendored in this repository (see `data/sgjp/`).
+
+> Copyright © 2007–2026 Marcin Woliński, Zbigniew Bronk, Włodzimierz
+> Gruszczyński, Witold Kieraś, Zygmunt Saloni, Danuta Skowrońska, Robert Wołosz.
+
+SGJP is distributed under the 2-clause BSD license. License page:
+<https://morfeusz.sgjp.pl/doc/license/en>. Full text and attribution details are
+in [`NOTICE.md`](NOTICE.md) and `data/sgjp/LICENSE.sgjp`.
+
+### License
+
+Two clearly separated layers:
+
+- **Package code** — BSD-2-Clause, © Michał Pasternak (see [`LICENSE`](LICENSE)).
+- **SGJP data** — BSD-2-Clause, © the authors listed above. Redistribution is
+  permitted provided the copyright notice, license text and attribution are
+  retained (details in [`NOTICE.md`](NOTICE.md)).
+
+### Limitations (v1)
+
+- **Nouns only.** No verbs, adjectives or numerals.
+- No out-of-dictionary guesser and no running-text analysis
+  (segmentation/tokenization) — deliberate YAGNI.
+- Scope: 7 cases × 2 numbers, both directions (`odmien` / `podaj`).

polish_inflection-0.1.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+polish_inflection/__init__.py,sha256=FLtEN1xpgwMCVbjXMjWeCNZXn_ouzyqEdLihPuJuCDM,1079
+polish_inflection/build.py,sha256=caKWROxu9byJ0wnWV5wYIHK870ZtASGzO7uoYHFjkiw,11783
+polish_inflection/const.py,sha256=REPN0ZU3cbwu3Xk2ObvrUapIvX6AcA79ndukd8bwx5g,1089
+polish_inflection/core.py,sha256=kxkc0Y5fGorS8LlMIGQTxEzCyYO7eM5bXead0XNPXNw,5387
+polish_inflection/errors.py,sha256=dExGr0Is-ukrwyP1NYMEfsxWg_UPir2aaXXPKeA_zxc,601
+polish_inflection/data/.gitkeep,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+polish_inflection/data/BUILD_INFO.json,sha256=ZVhYVvZAHHdbSjqn3V-P8qJEGhldC48aIw-GV05lI1A,234
+polish_inflection/data/odmien.marisa,sha256=KazL74jUzrjS22bXTkem0A1rkamFkmaB0sCvqah_tWU,24431696
+polish_inflection/data/podaj.marisa,sha256=fLa2NQ6NaevYLgmObDqUus-WqPaPkQguFo1omEeYOiU,25000464
+polish_inflection-0.1.0.dist-info/METADATA,sha256=nKUfcsoAoOgjA7p8gRStJCSMRPWOXryOpee7ioguwlg,11956
+polish_inflection-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+polish_inflection-0.1.0.dist-info/entry_points.txt,sha256=NYsrpqKqDhRjqpz2GHAAEvP_BGtedwvyCkSZxh773ws,73
+polish_inflection-0.1.0.dist-info/licenses/LICENSE,sha256=wC4FTktT4Qi-N1mkI5oaLMNCXXqFZi1hdfQMUdjan5Q,1306
+polish_inflection-0.1.0.dist-info/licenses/NOTICE.md,sha256=pf3EkpRYcvrh5mZXAsPh9jBCIVGoDuw8BkoSVK673es,3050
+polish_inflection-0.1.0.dist-info/RECORD,,

polish_inflection-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

polish_inflection-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+polish-inflection-build = polish_inflection.build:main

polish_inflection-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,24 @@
+BSD 2-Clause License
+
+Copyright (c) 2026, Michał Pasternak
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

polish_inflection-0.1.0.dist-info/licenses/NOTICE.md

@@ -0,0 +1,68 @@
+# NOTICE — licencje i atrybucja
+
+Pakiet `polish-inflection` łączy dwie warstwy o **osobnych** właścicielach praw
+autorskich i osobnych (choć identycznych co do treści) licencjach. Obie są
+2-clause BSD; obie wymagają zachowania noty copyright i tekstu licencji przy
+redystrybucji.
+
+---
+
+## 1. Kod pakietu
+
+Copyright © 2026 Michał Pasternak.
+Licencja: **BSD-2-Clause**. Pełny tekst: plik [`LICENSE`](LICENSE) w tym repo.
+
+Obejmuje kod źródłowy w `src/polish_inflection/` (runtime, build, CLI), testy
+oraz dokumentację. **Nie** obejmuje danych fleksyjnych ani zbudowanych z nich
+indeksów `.marisa` — te podlegają warstwie 2.
+
+---
+
+## 2. Dane SGJP (Słownik gramatyczny języka polskiego)
+
+Indeksy `.marisa` w `src/polish_inflection/data/` są zbudowane z danych
+fleksyjnych SGJP i stanowią ich utwór zależny. Podlegają licencji i atrybucji
+SGJP.
+
+**Copyright © 2007–2026 Marcin Woliński, Zbigniew Bronk, Włodzimierz
+Gruszczyński, Witold Kieraś, Zygmunt Saloni, Danuta Skowrońska, Robert Wołosz.**
+
+Licencja: **BSD-2-Clause**.
+Strona licencyjna: <https://morfeusz.sgjp.pl/doc/license/en>.
+
+Autorytatywny, verbatim tekst licencji jadący z konkretnym wydaniem SGJP
+znajduje się w pliku **`data/sgjp/LICENSE.sgjp`** (wyodrębniony z nagłówka
+`#<COPYRIGHT>` pobranego pliku `.tab.gz` przez komendę `refresh-sgjp`). W razie
+jakiejkolwiek rozbieżności rozstrzygający jest tamten plik, nie ten dokument.
+
+### Warunki 2-clause BSD (cytat)
+
+```
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+```
+
+### Konsekwencje redystrybucji
+
+Redystrybuując `polish-inflection` (w tym wheel/sdist zawierające `.marisa`),
+zachowujesz notę copyright SGJP, powyższe warunki i atrybucję — co realizuje ten
+plik `NOTICE.md` (dołączany do dystrybucji) wraz z verbatim `data/sgjp/LICENSE.sgjp`
+podróżującym z danymi w repozytorium.