denckring-fr-data 0.1.0__py3-none-any.whl

denckring_fr_data/__init__.py

@@ -0,0 +1,368 @@
+"""French lexicon data for denckring.
+
+Installing this gives the French pack `lexicon.words`, `lexicon.nouns`,
+`lexicon.glosses` and `lexicon.graded_words`. Nothing branches on whether it is
+present — the same procedures answer the same calls, in a third language.
+
+Two sources, both CC BY-SA 4.0: Lexique 3.82 for membership, nouns and frequency,
+and French Wiktionary for definitions. ADR 0032 records why Wikidata Lexemes,
+which supplies German, could not supply French.
+"""
+
+from __future__ import annotations
+
+import gzip
+import re
+from collections.abc import Mapping, Sequence
+from functools import lru_cache
+from importlib.resources import files
+from pathlib import Path
+from types import MappingProxyType
+from typing import ClassVar, TypeVar
+
+from denckring.core.errors import MissingCapability
+from denckring.lang.base import (
+    ALPHABET,
+    FOLD_DIACRITICS,
+    GLOSSES,
+    GRADED_WORDS,
+    LETTER_SHAPES,
+    NOUNS,
+    PHONEMES,
+    SYLLABLES,
+    SYLLABLES_DICTIONARY,
+    SYLLABLES_HEURISTIC,
+    TOKENS,
+    WORDS,
+)
+from denckring.lang.fr import FrenchPack
+from denckring_fr_data.elision import count_line
+from denckring_fr_data.sampa import IPA_VOWELS, to_phonemes
+
+#: Orthographic vowel runs, for the estimate a word outside Lexique gets.
+#: Answers "roughly how long is this unknown word" from spelling alone --
+#: deliberately not shared with `elision.py`'s pattern (Task 6), which answers
+#: "does this known word end in a mute e" over a different alphabet of
+#: concerns entirely.
+_VOWEL_RUN = re.compile(r"[aeiouyàâäéèêëîïôöùûüÿœæ]+")
+
+#: What `look_up` returns is whatever the table holds, and the caller must get
+#: its own type back. The same shape as `denckring_de_wiktionary.look_up`.
+_V = TypeVar("_V", bound=Sequence[str])
+
+WORDS_PATH = Path(str(files("denckring_fr_data") / "data" / "words.txt.gz"))
+NOUNS_PATH = Path(str(files("denckring_fr_data") / "data" / "nouns.txt.gz"))
+GRADED_WORDS_PATH = Path(str(files("denckring_fr_data") / "data" / "graded_words.txt.gz"))
+GLOSSES_PATH = Path(str(files("denckring_fr_data") / "data" / "glosses.txt.gz"))
+SYLLABLES_PATH = Path(str(files("denckring_fr_data") / "data" / "syllables.txt.gz"))
+H_ASPIRE_PATH = Path(str(files("denckring_fr_data") / "data" / "h_aspire.txt.gz"))
+
+__version__ = "0.1.0"
+
+
+def _read(path: Path) -> tuple[str, ...]:
+    """Every line of a gzipped list.
+
+    A truncated file raises rather than returning a short list: a short noun list
+    makes N+7 quietly wrong, and a wrong answer is worse than an exception.
+    """
+    with gzip.open(path, "rt", encoding="utf-8") as handle:
+        return tuple(line for line in handle.read().split("\n") if line)
+
+
+@lru_cache(maxsize=1)
+def noun_list() -> tuple[str, ...]:
+    """Every noun form, in dictionary order. N+7 walks this, so order is the point."""
+    return _read(NOUNS_PATH)
+
+
+@lru_cache(maxsize=1)
+def noun_positions() -> dict[str, int]:
+    return {word.casefold(): index for index, word in enumerate(noun_list())}
+
+
+@lru_cache(maxsize=1)
+def known_words() -> frozenset[str]:
+    """Membership, from every form Lexique carries."""
+    return frozenset(_read(WORDS_PATH))
+
+
+@lru_cache(maxsize=1)
+def graded_words() -> Mapping[str, int]:
+    """Word to band, where **larger means less common** — SCOWL's direction."""
+    table: dict[str, int] = {}
+    with gzip.open(GRADED_WORDS_PATH, mode="rt", encoding="utf-8") as handle:
+        for line in handle:
+            word, _, band = line.rstrip("\n").partition("\t")
+            if band:
+                table[word] = int(band)
+    return table
+
+
+@lru_cache(maxsize=1)
+def gloss_table() -> dict[str, tuple[str, ...]]:
+    """Headword to every sense's definition, in Wiktionary's order.
+
+    Split on `" | "` rather than `"|"`, because a definition may contain a bare
+    pipe and the build rejects any that contains the spaced separator.
+    """
+    with gzip.open(GLOSSES_PATH, mode="rt", encoding="utf-8") as handle:
+        return {
+            key: tuple(values.split(" | "))
+            for key, _, values in (line.rstrip("\n").partition("\t") for line in handle)
+            if values
+        }
+
+
+@lru_cache(maxsize=1)
+def syllable_table() -> Mapping[str, tuple[int, str, str]]:
+    """spelling -> (citation syllables, Lexique SAMPA, orthographic syllabation).
+
+    The third element is the segmented spelling (`car-ros-se`), which serves two
+    callers: `syllables()` returns its segments, and the mute-e rules compare
+    its segment count against `nbsyll` to judge a final `-ent`.
+    """
+    table: dict[str, tuple[int, str, str]] = {}
+    for line in _read(SYLLABLES_PATH):
+        ortho, nbsyll, phon, osyll = line.split("\t")
+        table[ortho] = (int(nbsyll), phon, osyll)
+    return MappingProxyType(table)
+
+
+def _table_entry(word: str) -> tuple[int, str, str] | None:
+    """The table entry for `word`, falling back past a leading elision.
+
+    Task 6's tokeniser (`elision._TOKEN_RE`) deliberately keeps an
+    apostrophe-bearing token whole -- `aujourd'hui` and `prud'homme` are 94
+    real Lexique entries, and splitting every apostrophe unconditionally
+    would silently misread those as a proclitic plus a word. So the whole
+    lowercased form is tried first, exactly as before.
+
+    But not every apostrophe-bearing form is one of those 94: `d'espoir`,
+    `l'amour`, `qu'un` are ordinary elision, the proclitic written onto the
+    following word, and were never table entries themselves. A whole-form-only
+    lookup made `phonemes`/`rhyme_key`/`rhyme_keys`/`syllable_count` fail on
+    them with `MissingCapability`, which is a routine event elsewhere but
+    silently starved `rhyme_scheme` and `ghazal` of exactly the line-ending
+    words French verse ends on most often (fix round 2). The rhyme- and
+    syllable-bearing unit of an elided form is what follows the apostrophe,
+    so a whole-form miss retries there -- the segment after the LAST
+    apostrophe, in case of a chained elision -- before giving up.
+    """
+    table = syllable_table()
+    lower = word.casefold()
+    entry = table.get(lower)
+    if entry is not None:
+        return entry
+    if "'" not in lower and "’" not in lower:  # noqa: RUF001
+        return None
+    tail = re.split(r"['’]", lower)[-1]  # noqa: RUF001
+    return table.get(tail)
+
+
+@lru_cache(maxsize=1)
+def h_aspire() -> frozenset[str]:
+    """Words whose initial h blocks elision. Lexique cannot answer this."""
+    return frozenset(_read(H_ASPIRE_PATH))
+
+
+def look_up(table: Mapping[str, _V], word: str) -> _V | None:
+    """The token as written, then case-flipped.
+
+    French Wiktionary titles are case-sensitive, and the build stores them as
+    written: `France`, `Paris` and `Toulouse` are the titles, not `france`,
+    `paris`, `toulouse`. Looking a headword up through `_lemma` — which
+    casefolds and drops every non-letter — therefore misses every capitalised
+    and every hyphenated title. Measured over the shipped table: 261,638 of
+    510,973 headwords (51.2%) were unreachable that way, 121,388 of them to case
+    alone, and proper nouns are the material loss. Trying the flipped case
+    recovers them, and the reverse direction recovers a proper noun someone
+    lowercased.
+
+    On the word **as written**, never `_lemma`'d: accents are meaning here, and
+    folding them would collide `côte` with `cote`. Same reason ADR 0009 makes
+    folding a decision of the procedure rather than of the lexicon. This is the
+    shape `denckring_de_wiktionary.look_up` already uses; French diverged from it
+    only by oversight, which is the same key/lookup mismatch fixed for the noun
+    list in fdad0c8.
+    """
+    for candidate in (word, word.capitalize(), word.lower(), word.upper()):
+        found = table.get(candidate)
+        if found:
+            return found
+    return None
+
+
+class FrenchDataPack(FrenchPack):
+    """French with a lexicon behind it: membership, nouns, glosses and frequency.
+
+    A fixed `ClassVar`, as on every pack but German's: German's `pack()` factory
+    (`denckring_de_data`) exists because two distributions carry German data
+    under two different licences and the registry allows only one `de` entry
+    point to win. This distribution is the only source of French lexicon data,
+    under one licence, so there is nothing for the install to choose between —
+    a plain class is the honest shape.
+    """
+
+    capabilities: ClassVar[frozenset[str]] = frozenset(
+        {
+            TOKENS,
+            ALPHABET,
+            FOLD_DIACRITICS,
+            LETTER_SHAPES,
+            NOUNS,
+            WORDS,
+            GLOSSES,
+            GRADED_WORDS,
+            SYLLABLES,
+            SYLLABLES_DICTIONARY,
+            SYLLABLES_HEURISTIC,
+            PHONEMES,
+        }
+    )
+
+    def is_word(self, word: str) -> bool:
+        return self._lemma(word) in known_words()
+
+    def syllable_count(self, word: str) -> tuple[int, bool]:
+        """Lexique's citation count, or a vowel-run estimate outside it.
+
+        The count is the *citation* one: `femme` is one syllable here and
+        frequently two in verse. The line rules, not this method, are where
+        verse is answered -- spec D3.
+
+        `_table_entry` tries the whole form first and only then falls back
+        past a leading elision (`d'espoir` -> `espoir`), so `aujourd'hui`
+        still resolves whole and an ordinary elided form no longer falls
+        through to the vowel-run estimate for no reason (fix round 2).
+        """
+        entry = _table_entry(word)
+        if entry is not None:
+            return entry[0], True
+        return max(len(_VOWEL_RUN.findall(word.casefold())), 1), False
+
+    def line_syllables(self, line: str) -> tuple[int, int]:
+        """French counts a line, not a bag of words. Spec D3, ADR 0034."""
+        return count_line(line, syllable_table(), h_aspire())
+
+    def syllables(self, word: str) -> list[str]:
+        """The orthographic segments, or `MissingCapability` for a word
+        Lexique does not carry.
+
+        Not `KeyError`: a plain `KeyError` here would repeat exactly the
+        crash fix-round 1 found in `phonemes` and `rhyme_key`/`rhyme_keys`,
+        and `MissingCapability` on an out-of-vocabulary word is a routine
+        event in real verse rather than an edge case, the same convention
+        every other lookup on this pack follows.
+
+        Task 6 shipped in ADR 0034 and its line rules do not call this
+        method -- `line_syllables` reads `syllable_table()` directly (see
+        `elision.count_line`), because it needs `nbsyll` and `phon` together
+        and `syllables()` exposes neither. As of the whole-branch review
+        (2026-09-01) nothing outside the test suite calls `syllables()` at
+        all; it exists to answer the `syllables` capability directly, for a
+        caller that wants the segmentation itself rather than a count.
+
+        It diverges from every other lookup on this pack in one respect:
+        it is the only one of the four (`syllables`, `phonemes`,
+        `syllable_count`, `rhyme_key`) not routed through `_table_entry`, so
+        it does not fall back past a leading elision. `phonemes("d'espoir")`
+        succeeds (`_table_entry` retries on `espoir` after the whole form
+        misses) while `syllables("d'espoir")` raises `MissingCapability` --
+        looking the whole elided form up directly, with no retry. This
+        divergence is deliberate, not an oversight: `_table_entry`'s retry
+        returns the *following* word's entry, and `syllables()`'s job is to
+        segment the word exactly as it was asked for, so returning
+        `espoir`'s segments (`es-poir`) for the token `d'espoir` would be
+        answering a question that was not asked -- silently dropping the
+        `d'` rather than reporting that the whole elided form is not one of
+        Lexique's 125,653 orthographic keys. No test exercises this path,
+        because nothing calls it outside the test suite.
+        """
+        entry = syllable_table().get(word.casefold())
+        if entry is None:
+            raise MissingCapability(f"<word {word!r}>", self.lang, SYLLABLES)
+        return entry[2].split("-")
+
+    def phonemes(self, word: str) -> list[str]:
+        """The IPA transcription, or `MissingCapability` for a word Lexique
+        does not carry.
+
+        Not `KeyError`: `core/prosody.py`'s `word_rhyme_keys` and
+        `assonance_constraint`/`spoonerism`'s own lookups catch only
+        `MissingCapability` around a pack call, reading it as "this word is
+        undecidable" rather than letting it propagate. A plain `KeyError`
+        went uncaught there -- `check('assonance_constraint', ..., lang='fr')`
+        crashed outright on the first unknown word, which is routine in real
+        French text, not an edge case. Matches the convention
+        `denckring-en-data` and `denckring-de-wiktionary` already established
+        for exactly this call.
+
+        `_table_entry` tries the whole form first and only then falls back
+        past a leading elision (fix round 2) -- see its docstring. `rhyme_key`
+        and `rhyme_keys` both call this method, so the fallback reaches them
+        for free.
+        """
+        entry = _table_entry(word)
+        if entry is None:
+            raise MissingCapability(f"<word {word!r}>", self.lang, PHONEMES)
+        return to_phonemes(entry[1])
+
+    def is_vowel_phoneme(self, phoneme: str) -> bool:
+        return phoneme in IPA_VOWELS
+
+    def rhyme_key(self, word: str) -> str:
+        """Phonemes from the last vowel to the end of the word.
+
+        The base definition says "from the last primary-stressed vowel", but
+        French has no lexical stress (spec D2), so the final vowel is the
+        rhyme-bearing one -- the *rime suffisante* every French prosodist
+        assumes. Feminine/masculine alternation is NOT modelled here; this
+        project's `rhyme_scheme` models it in no language, and that stays a
+        separate, recorded gap rather than something this method papers over.
+
+        Raises `MissingCapability` for a word Lexique does not carry, via
+        `phonemes()` -- a guessed rhyme is worse than an unknown one, and
+        `core.prosody.word_rhyme_keys` catches exactly that exception around
+        `rhyme_keys` and reads it as "this word is undecidable", which is what
+        makes an unknown word in a French poem non-fatal rather than an
+        uncaught crash (fix-round 1: it was `KeyError` and unhandled there).
+        """
+        phones = self.phonemes(word)
+        for index in range(len(phones) - 1, -1, -1):
+            if self.is_vowel_phoneme(phones[index]):
+                return "".join(phones[index:])
+        return "".join(phones)
+
+    def rhyme_keys(self, word: str) -> list[str]:
+        """Every pronunciation's rhyme key -- one, since the table holds a
+        single transcription per spelling (ADR 0034 records the homograph
+        cost that comes with that)."""
+        return [self.rhyme_key(word)]
+
+    def nouns(self) -> tuple[str, ...]:
+        return noun_list()
+
+    def noun_index(self, word: str) -> int | None:
+        return noun_positions().get(self._lemma(word))
+
+    def glosses(self, word: str) -> tuple[str, ...]:
+        """Every sense, or nothing. Empty rather than raising, matching English."""
+        return look_up(gloss_table(), word) or ()
+
+    def graded_words(self) -> Mapping[str, int]:
+        """A read-only view over the cached table, for the reason English gives:
+        the module function is `lru_cache`d and shared, so handing the dict out
+        would let one caller's mutation corrupt it for all the others."""
+        return MappingProxyType(graded_words())
+
+    @staticmethod
+    def _lemma(word: str) -> str:
+        """Casefold, and keep accents.
+
+        English strips to ASCII here. French must not: `fold_diacritics` would
+        collide `côte` with `cote` and `pêcheur` with `pecheur`, and ADR 0009
+        makes folding a parameter of the procedure rather than a property of the
+        lexicon. German keeps its umlauts for the same reason.
+        """
+        return "".join(ch for ch in word.casefold() if ch.isalpha())

denckring_fr_data/data/metadata.json

@@ -0,0 +1,12 @@
+{
+  "counts": {
+    "glosses.txt.gz": 510973,
+    "graded_words.txt.gz": 125343,
+    "h_aspire.txt.gz": 3370,
+    "nouns.txt.gz": 44746,
+    "syllables.txt.gz": 125653,
+    "words.txt.gz": 125343
+  },
+  "generated": "2026-09-01",
+  "source": "Lexique 3.82 (lexique.org), CC BY-SA 4.0, and French Wiktionary, CC BY-SA 4.0 - see LICENSE-LEXIQUE, LICENSE-WIKTIONARY and scripts/build_lexicon.py"
+}

denckring_fr_data/elision.py

@@ -0,0 +1,329 @@
+"""French verse counts a line, not a sequence of words (spec D3).
+
+A final mute e is a syllable before a consonant, elides before a vowel or a
+mute h, and never counts at the end of a line. Lexique gives citation forms --
+`femme`, `une`, `belle` and `porte` are all one syllable there and frequently
+two in verse -- so summing them undercounts systematically.
+"""
+
+from __future__ import annotations
+
+import re
+from collections.abc import Mapping
+
+VOWELS = frozenset("aeiouyàâéèêëîïôöùûüœæ")
+_VOWEL_RUN = re.compile(r"[aeiouyàâéèêëîïôöùûüœæ]+")
+
+#: SAMPA consonants (Lexique's alphabet, `sampa.SAMPA_TO_IPA` minus the
+#: vowels and the three glides j/w/8). Used only by the diérèse pass below.
+_SAMPA_CONSONANTS = frozenset("bdfgklmnNpRsStvzZGx")
+
+
+def _dierese_extra(ortho: str, phon: str) -> int:
+    """Extra syllables classical diérèse adds to Lexique's citation count.
+
+    ADR 0034. Classical French diérèse -- whether a Latin/Greek-derived `i`
+    or `u` glide (`diadème`, `division`) counts as its own syllable, as
+    against a native word's fixed glide (`pied`, `moindre`) that never does
+    -- is etymological, not spelling-derived (Task 7 brief). The rule
+    shipped here: every `j` after any consonant, single or a cluster, is an
+    extra syllable, gated on the word ending in the `-ion(s)` noun suffix
+    (the textbook diérèse site: Latin `-io`/`-ionem`) or starting with
+    `dia-`. Measured against Racine's *Mithridate* and Hugo's *Hernani*
+    (interior lines only; the harness that produced the table below was a
+    throwaway script, per spec, and is not shipped -- ADR 0034 D5 carries
+    the rule and the table, not the method), this is **Racine 89.3% ->
+    90.3%, Hugo 79.3% -> 80.2%**, against a
+    diérèse ceiling of 96.6%/84.8% -- a mechanical rule takes about 1.0 of
+    the 7.3 points a perfect per-site oracle would.
+
+    Three mechanical variants were measured on the way here, none of which
+    ships unchanged:
+
+    - a glide after a consonant CLUSTER ending in a liquid (R, l): worse
+      than no rule at all on both texts (84.5%/74.7% against the
+      89.3%/79.3% baseline);
+    - every `j` after a single consonant, excluding verb-inflection and
+      adjective endings that are reliably synérèse (`-iez`, `-ions`, `-ier`,
+      `-ien`, `-iable`, `-iant`, `-iance` and their plurals/feminines) --
+      those grammatical endings are the plurality of every "j after a single
+      consonant" site in the whole Lexique table, which is why a still
+      blunter blanket rule scored a catastrophic 49.5%/36.6%; excluding them
+      only brought it to 86.7%/70.0%, still below baseline on Hugo;
+    - `j` after a single consonant, narrowed further to the `-ion(s)` noun
+      suffix and the `dia-` prefix: the only variant that beat baseline on
+      BOTH texts, measured **as tried, with the single-consonant
+      restriction still in place, at 90.3%/80.0%**.
+
+    The `-ion(s)`/`dia-` gate is the shape that third variant kept. Its
+    single-consonant restriction was not: fix round 1 found it carried over
+    from the first, rejected variant (cluster-ending-in-a-liquid) without
+    independent justification, isolated it, and measured it as actively
+    costing 0.2 points on Hugo -- for no gain on Racine -- by wrongly
+    suppressing `factions` and `predictions`, both genuine `-ion` diérèse
+    sites whose `j` follows a `ks`/`ts` cluster. It was dropped; every `j`
+    after any consonant now counts once the gate passes, which is the
+    90.3%/80.2% above, not the 90.3%/80.0% the gated variant measured.
+
+    None of the three reached the 94% accept bar -- this is a STOP, not an
+    ACCEPT -- so it ships as the honest ceiling of a three-variant budget,
+    not a solved rule: `line_syllables`'s count stays an estimate
+    (spec D4), never dictionary-exact. `w` and `8` are left out entirely:
+    they overwhelmingly spell native `oi`/`ou`/`ui` digraphs that are never
+    split, and no variant that touched them improved on one that ignored
+    them.
+
+    Whole-branch review (2026-09-01) found an undocumented `-iation`/`-iations`
+    exclusion on the `-ion(s)` gate -- present in code, named nowhere: not
+    here, not in ADR 0034 D5, not in the plan. Re-measured against Racine and
+    Hugo interior lines with and without it: **identical to four significant
+    figures both ways, 90.3%/80.2%**, because neither corpus contains a
+    French `-iation`/`-iations` word at all (the only hits are English
+    "appreciation"/"abbreviation"/"associations" in Hugo's front matter,
+    outside any verse block). An exclusion with no measured effect and no
+    citable justification earns nothing, so it was dropped rather than
+    documented: `aviation`, `association` and `initiation` now take diérèse
+    like any other `-ion(s)` word, on the same unverified footing as the
+    rest of the gate.
+    """
+    is_ion = ortho.endswith(("ion", "ions"))
+    if not (is_ion or ortho.startswith("dia")):
+        return 0
+    extra = 0
+    for index, char in enumerate(phon):
+        if char != "j" or index == 0 or phon[index - 1] not in _SAMPA_CONSONANTS:
+            continue
+        extra += 1
+    return extra
+
+
+#: Proclitics whose own vowel is already elided in the spelling. They carry no
+#: syllable, but they are CONSONANTS for the word in front of them: in
+#: "ne t'attendais" the schwa of `ne` cannot elide across the `t'`. Dropping
+#: them from the token stream cost six points in the go/no-go prototype.
+ELIDED_ZERO: frozenset[str] = frozenset({"l", "d", "j", "n", "m", "t", "s", "c", "qu"})
+#: Same, but these carry syllables: `lorsqu'il` is lors-qu'il.
+ELIDED_WORD: dict[str, str] = {
+    "lorsqu": "lorsque",
+    "puisqu": "puisque",
+    "quoiqu": "quoique",
+    "jusqu": "jusque",
+}
+
+#: Word-shaped tokens, keeping an internal apostrophe joined rather than
+#: splitting on it -- the same shape as `denckring.lang.base.WORD_RE`. Fix
+#: round 1: splitting unconditionally corrupted the 94 Lexique entries keyed
+#: WITH an internal apostrophe (`aujourd'hui`, `prud'homme`), which are real
+#: single words, not a proclitic plus a word -- `count_line` tries the whole
+#: token against the table first and only falls back to splitting when that
+#: fails (`l'ami` is not a table entry, so it still splits). Hyphens and
+#: whitespace both fall outside `\w` in a Unicode pattern, so a compound like
+#: "dit-elle" tokenises as two tokens without any special case for the hyphen.
+_TOKEN_RE = re.compile(r"[^\W\d_]+(?:['’][^\W\d_]+)*")  # noqa: RUF001
+
+
+def latent_schwa(ortho: str, nbsyll: int, phon: str, orthosyll: str) -> tuple[int, bool]:
+    """(syllables excluding any mute e, whether a mute e is pending).
+
+    Lexique's SAMPA `@` is the nasal /ɑ̃/, NOT a schwa -- `dans` is `d@`.
+    Schwa is `2`, which also spells /ø/, so `de` and `deux` are both `d2` and
+    only the bare orthographic -e separates them.
+    """
+    suffix = next((s for s in ("ent", "es", "e") if ortho.endswith(s)), None)
+    if suffix is None:
+        return nbsyll, False
+    if suffix == "e" and phon[-1:] in ("2", "°"):
+        # `le`, `je`, `que`: Lexique counted the schwa, so take it back out.
+        return max(nbsyll - 1, 0), True
+    if len(orthosyll.split("-")) > nbsyll:
+        # `bel-le` against 1 shows the mute e; `sou-vent` against 2 does not.
+        return nbsyll, True
+    if suffix == "ent":
+        # orthosyll already judged it. `vient` strips to `vi`, whose one vowel
+        # run matches nbsyll 1, so the fallback below would invent a mute e.
+        return nbsyll, False
+    # orthosyll merges the mute e after a vowel (`vie`, `joie`, `an-née`), so
+    # fall back to vowel letter-runs. `qu`/`gu` carry a silent u.
+    stripped = ortho[: -len(suffix)].replace("qu", "k").replace("gu", "g")
+    return nbsyll, len(_VOWEL_RUN.findall(stripped)) == nbsyll
+
+
+def _estimate(ortho: str) -> tuple[int, bool]:
+    """A vowel-run guess for a word Lexique does not carry.
+
+    `line_syllables` must degrade gracefully rather than raise -- unlike
+    `syllables()`/`phonemes()`, which raise `MissingCapability` for exactly
+    this case (Task 5). A real line of French routinely holds a word outside
+    Lexique's 125,653 rows, and one unknown word must not blank the count for
+    the whole line. Deliberately excludes `-ent` from the suffix check TRAP 3
+    warns about: with no `orthosyll` to consult, there is no way to tell
+    `chantent` from `vient`, so the safer default is to never invent a mute e
+    there at all.
+    """
+    suffix = next((s for s in ("es", "e") if ortho.endswith(s) and ortho != s), None)
+    if suffix is None:
+        return max(len(_VOWEL_RUN.findall(ortho)), 1), False
+    stripped = ortho[: -len(suffix)]
+    return max(len(_VOWEL_RUN.findall(stripped)), 1), True
+
+
+def _judge(ortho: str, entry: tuple[int, str, str]) -> tuple[int, bool, bool]:
+    """(syllables excluding a pending mute e, mute e pending, judged).
+
+    A table hit's `nbsyll` is a citation fact, not a guess -- Lexique's
+    dictionary count for a known spelling is exact. What sits on top of it is
+    not: whether a mute e is pending (elides or counts depending on the next
+    word) and whether classical diérèse adds a syllable are both editorial
+    judgments the spelling alone does not settle (`extraordinaire` is five
+    syllables or six depending on the poet, D5's own example). Finding 3 of
+    the whole-branch review: spec D4 and ADR 0034 both say the French line
+    count is `exact=False`, always, and before this the flag only fired on an
+    out-of-vocabulary word -- a line entirely of known words with a pending
+    mute e or a diérèse site reported `estimated_words == 0`, confidently
+    wrong in the D4/`test_prosody_robustness`-flagged sense. `judged` is True
+    when either call was made, so `count_line` can fold it into the same
+    `estimated_words` counter it already keeps for out-of-vocabulary words.
+    """
+    nbsyll, phon, orthosyll = entry
+    count, pending = latent_schwa(ortho, nbsyll, phon, orthosyll)
+    extra = _dierese_extra(ortho, phon)
+    return count + extra, pending, pending or extra > 0
+
+
+def _lookup(ortho: str, table: Mapping[str, tuple[int, str, str]]) -> tuple[int, bool, bool]:
+    """(syllables excluding a pending mute e, mute e pending, estimated).
+
+    Diérèse (Task 7, ADR 0034) is added here rather than at the caller: it is
+    a property of the word's own phonetics, the same footing as the mute-e
+    count it sits beside, and an unknown word (`_estimate`) has no `phon` to
+    judge it by, so the diérèse pass only ever runs on a table hit.
+
+    `estimated` covers two different reasons now (Finding 3): a word outside
+    Lexique altogether (`_estimate`, always estimated), and a table hit whose
+    count rests on a mute-e or diérèse judgment (`_judge`, delegated to it).
+    """
+    entry = table.get(ortho)
+    if entry is None:
+        count, pending = _estimate(ortho)
+        return count, pending, True
+    return _judge(ortho, entry)
+
+
+def starts_with_vowel(word: str, aspire: frozenset[str]) -> bool:
+    """Whether the token that follows lets a preceding mute e elide.
+
+    A word starting with a vowel letter elides a schwa in front of it, and so
+    does a mute h -- silent, letting the vowel behind it show. An aspirated h
+    (Task 3's list) behaves as a consonant instead: "je hais" keeps `je`'s
+    schwa where "une heure" loses `une`'s.
+    """
+    if not word:
+        return False
+    if word[0] in VOWELS:
+        return True
+    return word[0] == "h" and word not in aspire
+
+
+def _split_at_apostrophe(word: str) -> tuple[str, str]:
+    """(stem before the first apostrophe, everything after it).
+
+    Called only once the whole token has already failed a table lookup, so
+    this never runs on `aujourd'hui` or `prud'homme` -- both are single
+    Lexique entries and are used whole (fix round 1).
+    """
+    for index, ch in enumerate(word):
+        if ch in ("'", "’"):  # noqa: RUF001
+            return word[:index], word[index + 1 :]
+    return word, ""
+
+
+def count_line(
+    line: str, table: Mapping[str, tuple[int, str, str]], aspire: frozenset[str]
+) -> tuple[int, int]:
+    """(syllables in the line, words whose count was estimated).
+
+    "Estimated" covers three cases now, all folded into one counter (Finding
+    3 of the whole-branch review, spec D4): a word outside Lexique
+    (`_estimate`'s vowel-run guess), a word carrying a pending mute e, and a
+    word whose diérèse gate fired. The first is out-of-vocabulary; the other
+    two are in-vocabulary but their contribution to the count rests on an
+    editorial judgment the spelling does not settle -- which is exactly what
+    D4 means by "estimated, never exact." Before this fix a line built
+    entirely from known words could carry a mute-e or diérèse judgment and
+    still report `estimated_words == 0`, the confidently-wrong shape D4
+    exists to rule out.
+
+    A token that carries an internal apostrophe is tried WHOLE against the
+    table first: 94 Lexique entries are keyed with one (`aujourd'hui`,
+    `prud'homme`), and splitting them unconditionally silently returned a
+    confidently wrong count with `estimated` left at 0 -- fix round 1's
+    finding, and the failure mode this project cares most about, a wrong
+    answer reported as certain. Only a token the table does not recognise
+    whole falls back to splitting at the apostrophe and treating the stem as
+    a proclitic ("t'", "d'", "qu'") -- a zero-syllable, consonant-initial
+    token that survives in the stream rather than being dropped, which is
+    TRAP 2: dropping it would let the preceding word's schwa see the vowel
+    behind the proclitic and elide across it, which it must not.
+
+    Walks the tokens once, adding one syllable for each pending mute e whose
+    successor is consonant-initial. A pending mute e with no successor -- the
+    line's last token -- is never added, which is how "the final e never
+    counts at the end of a line" falls out of "not last" rather than needing
+    a separate rule.
+    """
+    tokens = _TOKEN_RE.findall(line)
+    # Each entry: (syllables carried, mute e pending, was estimated, text
+    # used to judge whether the NEXT word starts with a vowel).
+    parsed: list[tuple[int, bool, bool, str]] = []
+    for token in tokens:
+        lower = token.casefold()
+        if "'" not in lower and "’" not in lower:  # noqa: RUF001
+            count, pending, estimated = _lookup(lower, table)
+            parsed.append((count, pending, estimated, lower))
+            continue
+        entry = table.get(lower)
+        if entry is not None:
+            # `aujourd'hui`, `prud'homme`: a fused word, not a proclitic plus
+            # a word -- 94 Lexique entries carry an internal apostrophe.
+            count, pending, judged = _judge(lower, entry)
+            parsed.append((count, pending, judged, lower))
+            continue
+        # The whole form isn't a table entry, so it wasn't a fused word like
+        # those -- read the apostrophe as an elision boundary instead.
+        stem, rest = _split_at_apostrophe(lower)
+        if stem in ELIDED_ZERO:
+            parsed.append((0, False, False, stem))
+        elif (full := ELIDED_WORD.get(stem)) is not None and (
+            word_entry := table.get(full)
+        ) is not None:
+            # `lorsqu'il` etc: already elided in the spelling, so the mute e
+            # is gone, not merely pending -- `pending` stays False regardless
+            # of what `latent_schwa` would say about `full` on its own. A
+            # diérèse site is still a live judgment here, so it alone decides
+            # `estimated` (Finding 3).
+            nbsyll, phon, orthosyll = word_entry
+            count, _pending = latent_schwa(full, nbsyll, phon, orthosyll)
+            extra = _dierese_extra(full, phon)
+            parsed.append((count + extra, False, extra > 0, stem))
+        else:
+            # An elided proclitic neither list recognises -- there is no
+            # basis for a confident zero, so flag it estimated rather than
+            # silently asserting one (fix round 1, same defect as the
+            # whole-token case above, now on the proclitic path).
+            parsed.append((0, False, True, stem))
+        if rest:
+            count, pending, estimated = _lookup(rest, table)
+            parsed.append((count, pending, estimated, rest))
+
+    total = 0
+    estimated_words = 0
+    last = len(parsed) - 1
+    for index, (count, pending, was_estimated, _text) in enumerate(parsed):
+        total += count
+        if was_estimated:
+            estimated_words += 1
+        if pending and index < last:
+            successor = parsed[index + 1][3]
+            if not starts_with_vowel(successor, aspire):
+                total += 1
+    return total, estimated_words

denckring_fr_data/sampa.py

@@ -0,0 +1,83 @@
+"""Lexique 3.82's SAMPA, in the IPA this project uses everywhere else.
+
+Lexique's alphabet is its own: `@` is the nasal /ɑ̃/ rather than a schwa, `§`
+is /ɔ̃/, and `2`/`9` split /ø/ from /œ/. Reading `@` as a schwa costs fifteen
+points of line accuracy and looks like a plausible one-syllable undercount, so
+this table is tested against hand-checked words before anything reads it
+(spec F0).
+"""
+
+from __future__ import annotations
+
+#: Two-character sequences do not occur in Lexique's phon column, so a
+#: character-by-character walk is complete.
+SAMPA_TO_IPA: dict[str, str] = {
+    # Oral vowels
+    "a": "a",
+    "A": "ɑ",
+    "e": "e",
+    "E": "ɛ",
+    "i": "i",
+    "o": "o",
+    "O": "ɔ",
+    "u": "u",
+    "y": "y",
+    "2": "ø",
+    "9": "œ",
+    "°": "ə",
+    # Nasal vowels
+    "@": "ɑ̃",
+    "5": "ɛ̃",
+    "1": "œ̃",
+    "§": "ɔ̃",
+    # Glides
+    "j": "j",
+    "w": "w",
+    "8": "ɥ",
+    # Consonants
+    "b": "b",
+    "d": "d",
+    "f": "f",
+    "g": "g",
+    "k": "k",
+    "l": "l",
+    "m": "m",
+    "n": "n",
+    "N": "ɲ",
+    "p": "p",
+    "R": "ʁ",
+    "s": "s",
+    "S": "ʃ",
+    "t": "t",
+    "v": "v",
+    "z": "z",
+    "Z": "ʒ",
+    "G": "ŋ",
+    "x": "x",
+}
+
+#: A glide is written with a vowel symbol in some schemes but carries no
+#: syllable of its own, so it is not here. ADR 0030 is the reason this is a
+#: property of the transcription rather than of the phoneme string.
+IPA_VOWELS: frozenset[str] = frozenset(
+    {"a", "ɑ", "e", "ɛ", "i", "o", "ɔ", "u", "y", "ø", "œ", "ə", "ɑ̃", "ɛ̃", "œ̃", "ɔ̃"}
+)
+
+
+def to_ipa(sampa: str) -> str:
+    """Convert one Lexique transcription. An unmapped symbol raises.
+
+    Passing an unknown symbol through would let a scheme leak silently into a
+    syllable count, which is the defect ADR 0030 fixed twice in one day.
+    """
+    return "".join(SAMPA_TO_IPA[ch] for ch in sampa)
+
+
+def to_phonemes(sampa: str) -> list[str]:
+    """The transcription as a list of IPA phonemes.
+
+    Lexique writes one symbol per phoneme, so the split is the walk itself and
+    no re-segmentation of the IPA string is needed -- `d@` is ["d", "ɑ̃"], and
+    the nasal stays one phoneme rather than a vowel plus a combining tilde.
+    """
+    return [SAMPA_TO_IPA[ch] for ch in sampa]

denckring_fr_data-0.1.0.dist-info/METADATA

@@ -0,0 +1,57 @@
+Metadata-Version: 2.5
+Name: denckring-fr-data
+Version: 0.1.0
+Summary: French lexicon and prosody data for denckring: word membership, nouns, frequency bands, glosses, syllables and phonemes
+Author-email: Dennis Senzel <dennis.senzel@posteo.com>
+License-Expression: Apache-2.0 AND CC-BY-SA-4.0
+License-File: LICENSE
+License-File: LICENSE-LEXIQUE
+License-File: LICENSE-WIKTIONARY
+License-File: NOTICE
+Classifier: Intended Audience :: Science/Research
+Classifier: Natural Language :: French
+Classifier: Topic :: Text Processing :: Linguistic
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Requires-Dist: denckring==0.1.0
+Description-Content-Type: text/markdown
+
+# denckring-fr-data
+
+French lexicon and prosody data for [denckring](https://github.com/senzelden/denckring):
+word membership, an ordered noun list, frequency bands, glosses, a syllable and
+phoneme table, and an aspirated-*h* list.
+
+```console
+pip install denckring[fr]
+```
+
+Installing this gives the French pack `lexicon.words`, `lexicon.nouns`,
+`lexicon.glosses`, `lexicon.graded_words`, `syllables`, `syllables.dictionary`,
+`syllables.heuristic` and `phonemes`. The lexicon capabilities are what
+`charade`, `semordnilap`, `word_square`, `n_plus_7`, `s_plus_7`, `tmesis`,
+`word_ladder`, `kangaroo_word` and the two definitional rows need in order to
+run in French — and what `apply anagram` needs in order to generate in it. The
+prosody capabilities, plus the line-level elision rules `FrenchDataPack`
+overrides `line_syllables` with, are what the 23 syllabic rows
+(`alexandrine`, `syllable_count`, `rhyme_scheme`, `haiku`, `hemeling`, and the
+rest — ADR 0034) need in order to run in French. Without this package, all of
+it raises `MissingCapability` for `fr`, exactly as for any unmet capability.
+French still has no lexical stress, so the 18 rows that need `stress` stay
+blocked regardless — see ADR 0034 D3.
+
+**125,653 syllable/phoneme rows and 3,370 aspirated-*h* entries**, alongside
+the lexicon: 46,947 lemmas, 48,234 noun forms and a Wiktionary gloss slice.
+Both sources are **CC BY-SA 4.0** — attribution *and* share-alike — Lexique
+3.82 for the lexicon and the prosody table, French Wiktionary for the glosses
+and the aspirated-*h* list. See `LICENSE-LEXIQUE` and `LICENSE-WIKTIONARY`.
+Regenerate the vendored files with `scripts/build_lexicon.py`.
+
+Accents are preserved rather than folded. `côte` and `cote` are different words,
+and whether they should be treated alike is a decision ADR 0009 leaves to the
+procedure, not to the lexicon.
+
+The French line count is **estimated, never exact** (ADR 0034 D4): a final
+mute *e* elides or counts depending on what follows it, and classical
+diérèse is not decidable from spelling alone. Every syllabic report carries
+`estimated_words` accordingly.

denckring_fr_data-0.1.0.dist-info/RECORD

@@ -0,0 +1,19 @@
+denckring_fr_data/__init__.py,sha256=xYZIJzAUm8RCG4CsXQNRtu9aewtOQkrFb797ZGgUZ8Q,16141
+denckring_fr_data/elision.py,sha256=FGoUF2iVhJvn1t1CSYneWGXBZDLlU6zbpvKLxLZhArQ,16839
+denckring_fr_data/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+denckring_fr_data/sampa.py,sha256=o8APJPRtynzfPoailbcZ-Ag3fcP2fikMyQDabCDAU5Q,2279
+denckring_fr_data/data/glosses.txt.gz,sha256=SVt_oCYayaOfK3EJkxihPJqhpL7umpn8ABbCXZKmWPk,15270003
+denckring_fr_data/data/graded_words.txt.gz,sha256=r3X-d0OH05x_wpVXpatsDFJ3eU3b8-fqFm0OwYIdpa0,413181
+denckring_fr_data/data/h_aspire.txt.gz,sha256=LX8DhJQ0GsnYKpJZZyx61mArKrW-Y4qVOwiAY4yyypk,10124
+denckring_fr_data/data/metadata.json,sha256=qoTCjj-_wyK83ehXNfcUTAG3c25Pcf6FehQN3yy1-Uk,395
+denckring_fr_data/data/nouns.txt.gz,sha256=HtExMdJqsFWQmUda4ckDf_aHwkvE6sxJPP1BWti7x18,126711
+denckring_fr_data/data/syllables.txt.gz,sha256=X-H3_yulQKQGmAe9SbI9HP2u6q6QOQbSXCWToqn8YxI,1001801
+denckring_fr_data/data/words.txt.gz,sha256=TzUtEd2knOAN54sbkG5IyFsoqRs3xYIK_29HL8VX87w,329843
+denckring_fr_data-0.1.0.dist-info/METADATA,sha256=rpIqeMUgIeb9M-zyjKAmjGV6f0Cyhv8_SUPdlBSyHKw,2782
+denckring_fr_data-0.1.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+denckring_fr_data-0.1.0.dist-info/entry_points.txt,sha256=1Bg8TfE8IxB3sS1w4XHjy757vrSflnYqCja7xDkgQTY,55
+denckring_fr_data-0.1.0.dist-info/licenses/LICENSE,sha256=qsc7MUj20dcRHbyjIJn2jSbGRMaBOuHk8F9leaomY_4,11360
+denckring_fr_data-0.1.0.dist-info/licenses/LICENSE-LEXIQUE,sha256=c-BZFUDwVcpZH5TlVEsrLKAIAte34uH4_3ULVvmH10w,879
+denckring_fr_data-0.1.0.dist-info/licenses/LICENSE-WIKTIONARY,sha256=HnQjmLvaM6hU9xrrNknD0_U5vIyniYqR5vVkgXRRjqc,691
+denckring_fr_data-0.1.0.dist-info/licenses/NOTICE,sha256=rSQ_EtW_ZbopAnsN1JnN42bSnJaKGzSmINsBCaDP4eY,607
+denckring_fr_data-0.1.0.dist-info/RECORD,,

denckring_fr_data-0.1.0.dist-info/WHEEL

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

denckring_fr_data-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[denckring.lang]
+fr = denckring_fr_data:FrenchDataPack

denckring_fr_data-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        https://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       https://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

denckring_fr_data-0.1.0.dist-info/licenses/LICENSE-LEXIQUE

@@ -0,0 +1,20 @@
+The French word list, noun list and frequency bands in this distribution are
+derived from Lexique 3.82.
+
+    New, B., Pallier, C., Ferrand, L., Matos, R. (2001). Une base de données
+    lexicales du français contemporain sur internet: LEXIQUE. L'Année
+    Psychologique, 101, 447-462.
+    http://www.lexique.org
+
+Lexique is licensed under the Creative Commons Attribution-ShareAlike 4.0
+International licence, as stated in the README bundled with Lexique382.zip:
+
+    https://creativecommons.org/licenses/by-sa/4.0/
+
+Attribution: Boris New and Christophe Pallier, and the Lexique contributors.
+
+Share-alike: the derived data files in this distribution
+(`src/denckring_fr_data/data/`) are offered under the same CC BY-SA 4.0 licence.
+The code in this distribution is Apache-2.0 and is not a derivative of the data.
+
+Regenerate the vendored files with scripts/build_lexicon.py.

denckring_fr_data-0.1.0.dist-info/licenses/LICENSE-WIKTIONARY

@@ -0,0 +1,17 @@
+The French glosses in this distribution are derived from French Wiktionary
+(https://fr.wiktionary.org), specifically from the
+`frwiktionary-latest-pages-articles` XML dump published by the Wikimedia
+Foundation.
+
+Wiktionary text is licensed under the Creative Commons
+Attribution-ShareAlike 4.0 International licence:
+
+    https://creativecommons.org/licenses/by-sa/4.0/
+
+Attribution: the French Wiktionary contributors. Page histories, which name
+them, are at https://fr.wiktionary.org/wiki/<headword> under "Historique".
+
+Share-alike: the derived data files in this distribution are offered under the
+same CC BY-SA 4.0 licence.
+
+Regenerate the vendored files with scripts/build_lexicon.py.

denckring_fr_data-0.1.0.dist-info/licenses/NOTICE

@@ -0,0 +1,15 @@
+denckring-fr-data
+Copyright 2026 senzelden
+
+The code in this distribution is licensed under the Apache License, Version 2.0.
+See LICENSE.
+
+The data in this distribution comes from two sources, both licensed under the
+Creative Commons Attribution-ShareAlike 4.0 International licence:
+
+  - Lexique 3.82 (lexique.org) — see LICENSE-LEXIQUE
+  - French Wiktionary — see LICENSE-WIKTIONARY
+
+Both impose attribution and share-alike. That they agree is why this is one
+distribution where German needs two: ADR 0013 quarantines a data licence per
+distribution, and there is only one licence here to quarantine.