SYMBOL INDEX (784 symbols across 47 files)

FILE: bench/conftest.py
  function clean_db (line 12) | def clean_db():
  function datadir (line 31) | def datadir():
  function empty_db (line 36) | def empty_db(clean_db, tmp_path):
  function mock_lmf (line 45) | def mock_lmf():
  function mock_db_dir (line 67) | def mock_db_dir(mock_lmf, tmp_path_factory):
  function mock_db (line 78) | def mock_db(monkeypatch, mock_db_dir):
  function _make_synsets (line 85) | def _make_synsets(pos: str, n: int) -> list[lmf.Synset]:
  function _words (line 120) | def _words() -> Iterator[str]:
  function _make_entries (line 127) | def _make_entries(synsets: list[lmf.Synset]) -> list[lmf.LexicalEntry]:

FILE: bench/test_bench.py
  function test_load (line 8) | def test_load(datadir, benchmark):
  function test_add_lexical_resource (line 14) | def test_add_lexical_resource(mock_lmf, benchmark):
  function test_add_lexical_resource_no_progress (line 28) | def test_add_lexical_resource_no_progress(mock_lmf, benchmark):
  function test_synsets (line 43) | def test_synsets(benchmark):
  function test_words (line 49) | def test_words(benchmark):
  function test_word_senses_no_wordnet (line 55) | def test_word_senses_no_wordnet(benchmark):
  function test_word_senses_with_wordnet (line 62) | def test_word_senses_with_wordnet(benchmark):

FILE: tests/_config_test.py
  function test_envvar_data_dir (line 6) | def test_envvar_data_dir(monkeypatch, tmp_path):

FILE: tests/_util_test.py
  function test_flatten (line 10) | def test_flatten():
  function test_unique_list (line 20) | def test_unique_list():
  function test_normalize_form (line 32) | def test_normalize_form():
  function test_format_lexicon_specifier (line 39) | def test_format_lexicon_specifier():
  function test_split_lexicon_specifier (line 46) | def test_split_lexicon_specifier():

FILE: tests/compat_sensekey_test.py
  function test_unescape_oewn_sense_key (line 7) | def test_unescape_oewn_sense_key():
  function test_escape_oewn_sense_key (line 36) | def test_escape_oewn_sense_key():
  function test_unescape_oewn_v2_sense_key (line 58) | def test_unescape_oewn_v2_sense_key():
  function test_escape_oewn_v2_sense_key (line 88) | def test_escape_oewn_v2_sense_key():
  function test_sense_key_getter (line 112) | def test_sense_key_getter(datadir):
  function test_sense_getter (line 138) | def test_sense_getter(datadir):

FILE: tests/conftest.py
  function datadir (line 10) | def datadir():
  function uninitialized_datadir (line 15) | def uninitialized_datadir(monkeypatch, tmp_path: Path):
  function empty_db (line 22) | def empty_db(tmp_path_factory):
  function mini_db_dir (line 34) | def mini_db_dir(datadir, tmp_path_factory):
  function mini_lmf_compressed (line 46) | def mini_lmf_compressed(datadir, tmp_path):
  function mini_db_1_1_dir (line 55) | def mini_db_1_1_dir(datadir, tmp_path_factory):
  function mini_db_1_4_dir (line 67) | def mini_db_1_4_dir(datadir, tmp_path_factory):
  function mini_db (line 79) | def mini_db(monkeypatch, mini_db_dir):
  function mini_db_1_1 (line 87) | def mini_db_1_1(monkeypatch, mini_db_1_1_dir):
  function mini_db_1_4 (line 95) | def mini_db_1_4(monkeypatch, mini_db_1_4_dir):

FILE: tests/db_test.py
  function test_schema_compatibility (line 11) | def test_schema_compatibility():
  function test_db_multithreading (line 18) | def test_db_multithreading():
  function test_remove_extension (line 48) | def test_remove_extension(datadir, tmp_path):
  function test_add_lexical_resource (line 68) | def test_add_lexical_resource(datadir, tmp_path):
  function test_reset_database (line 82) | def test_reset_database(datadir):

FILE: tests/export_test.py
  function test_export (line 9) | def test_export(datadir, tmp_path):
  function test_export_1_1 (line 26) | def test_export_1_1(datadir, tmp_path):
  function test_export_1_4 (line 47) | def test_export_1_4(datadir, tmp_path):

FILE: tests/ic_test.py
  function test_compute_nodistribute_nosmoothing (line 43) | def test_compute_nodistribute_nosmoothing():
  function test_compute_nodistribute_smoothing (line 66) | def test_compute_nodistribute_smoothing():
  function test_compute_distribute_smoothing (line 89) | def test_compute_distribute_smoothing():
  function test_load (line 112) | def test_load(tmp_path):
  function test_information_content (line 134) | def test_information_content():

FILE: tests/ili_test.py
  function test_is_ili_tsv (line 11) | def test_is_ili_tsv(datadir: Path) -> None:
  function test_load_tsv (line 18) | def test_load_tsv(datadir: Path) -> None:
  function test_get (line 32) | def test_get() -> None:
  function test_get_proposed (line 60) | def test_get_proposed() -> None:

FILE: tests/lmf_test.py
  function test_is_lmf (line 6) | def test_is_lmf(datadir):
  function test_scan_lexicons (line 14) | def test_scan_lexicons(datadir):
  function test_load_1_0 (line 49) | def test_load_1_0(datadir):
  function test_load_1_1 (line 93) | def test_load_1_1(datadir):
  function test_load_1_3 (line 112) | def test_load_1_3(datadir):
  function test_load_1_4 (line 130) | def test_load_1_4(datadir):
  function test_dump (line 160) | def test_dump(datadir, tmp_path):

FILE: tests/morphy_test.py
  function test_morphy_uninitialized (line 7) | def test_morphy_uninitialized():
  function test_morphy_initialized (line 31) | def test_morphy_initialized():
  function test_issue_154 (line 47) | def test_issue_154():

FILE: tests/primary_query_test.py
  function test_lexicons_uninitialized (line 7) | def test_lexicons_uninitialized():
  function test_lexicons_empty (line 12) | def test_lexicons_empty():
  function test_lexicons_mini (line 17) | def test_lexicons_mini():
  function test_lexicons_unknown (line 53) | def test_lexicons_unknown():
  function test_words_empty (line 61) | def test_words_empty():
  function test_words_mini (line 66) | def test_words_mini():
  function test_lemmas_empty (line 106) | def test_lemmas_empty():
  function test_lemmas_mini_1_4 (line 111) | def test_lemmas_mini_1_4():
  function test_word_empty (line 161) | def test_word_empty():
  function test_word_mini (line 167) | def test_word_mini():
  function test_senses_empty (line 182) | def test_senses_empty():
  function test_senses_mini (line 187) | def test_senses_mini():
  function test_sense_empty (line 224) | def test_sense_empty():
  function test_sense_mini (line 230) | def test_sense_mini():
  function test_synsets_empty (line 245) | def test_synsets_empty():
  function test_synsets_mini (line 250) | def test_synsets_mini():
  function test_synset_empty (line 288) | def test_synset_empty():
  function test_synset_mini (line 294) | def test_synset_mini():
  function test_mini_1_1 (line 309) | def test_mini_1_1():
  function test_mini_1_1_lexicons (line 346) | def test_mini_1_1_lexicons():
  function test_mini_1_4 (line 375) | def test_mini_1_4():

FILE: tests/project_test.py
  function test_is_package_directory (line 4) | def test_is_package_directory(datadir):
  function test_is_collection_directory (line 9) | def test_is_collection_directory(datadir):
  function test_get_project (line 15) | def test_get_project(datadir):
  function test_iterpackages (line 31) | def test_iterpackages(datadir):
  function test_compressed_iterpackages (line 46) | def test_compressed_iterpackages(mini_lmf_compressed):

FILE: tests/relations_test.py
  function test_word_derived_words (line 7) | def test_word_derived_words():
  function test_synset_hypernyms (line 13) | def test_synset_hypernyms():
  function test_synset_hypernyms_expand_default (line 19) | def test_synset_hypernyms_expand_default():
  function test_synset_hypernyms_expand_empty (line 25) | def test_synset_hypernyms_expand_empty():
  function test_synset_hypernyms_expand_specified (line 31) | def test_synset_hypernyms_expand_specified():
  function test_synset_relations (line 37) | def test_synset_relations():
  function test_sense_get_related (line 46) | def test_sense_get_related():
  function test_sense_relations (line 54) | def test_sense_relations():
  function test_extension_relations (line 62) | def test_extension_relations():
  function test_sense_synset_issue_168 (line 96) | def test_sense_synset_issue_168():
  function test_synset_relations_issue_169 (line 104) | def test_synset_relations_issue_169():
  function test_synset_relations_issue_177 (line 113) | def test_synset_relations_issue_177():
  function test_sense_relation_data_true (line 119) | def test_sense_relation_data_true():
  function test_synset_relations_data_true (line 133) | def test_synset_relations_data_true():

FILE: tests/secondary_query_test.py
  function test_word_senses (line 7) | def test_word_senses():
  function test_word_synsets (line 13) | def test_word_synsets():
  function test_word_translate (line 19) | def test_word_translate():
  function test_word_translate_issue_316 (line 25) | def test_word_translate_issue_316():
  function test_word_lemma_tags (line 35) | def test_word_lemma_tags():
  function test_word_lemma_pronunciations (line 45) | def test_word_lemma_pronunciations():
  function test_sense_word (line 56) | def test_sense_word():
  function test_sense_synset (line 66) | def test_sense_synset():
  function test_sense_issue_157 (line 76) | def test_sense_issue_157():
  function test_sense_examples (line 86) | def test_sense_examples():
  function test_sense_counts (line 92) | def test_sense_counts():
  function test_sense_lexicalized (line 101) | def test_sense_lexicalized():
  function test_sense_frames (line 107) | def test_sense_frames():
  function test_sense_frames_issue_156 (line 116) | def test_sense_frames_issue_156():
  function test_sense_translate (line 125) | def test_sense_translate():
  function test_sense_translate_issue_316 (line 131) | def test_sense_translate_issue_316():
  function test_synset_senses (line 139) | def test_synset_senses():
  function test_synset_words (line 145) | def test_synset_words():
  function test_synset_lemmas (line 151) | def test_synset_lemmas():
  function test_synset_ili (line 157) | def test_synset_ili():
  function test_synset_definition (line 163) | def test_synset_definition():
  function test_synset_definitions (line 172) | def test_synset_definitions():
  function test_synset_examples (line 180) | def test_synset_examples():
  function test_synset_lexicalized (line 189) | def test_synset_lexicalized():
  function test_synset_translate (line 195) | def test_synset_translate():
  function test_synset_translate_issue_316 (line 201) | def test_synset_translate_issue_316():
  function test_word_sense_order (line 212) | def test_word_sense_order(datadir):
  function test_synset_member_order (line 225) | def test_synset_member_order(datadir):
  function test_confidence (line 238) | def test_confidence():

FILE: tests/similarity_test.py
  function get_synsets (line 11) | def get_synsets(w):
  function test_path (line 48) | def test_path():
  function test_wup (line 67) | def test_wup():
  function test_lch (line 89) | def test_lch():
  function test_res (line 117) | def test_res():
  function test_jcn (line 142) | def test_jcn():
  function test_lin (line 164) | def test_lin():

FILE: tests/taxonomy_test.py
  function test_roots (line 16) | def test_roots():
  function test_leaves (line 43) | def test_leaves():
  function test_taxonomy_depth (line 57) | def test_taxonomy_depth():
  function test_hypernym_paths (line 64) | def test_hypernym_paths():
  function test_interlingual_hypernym_paths (line 76) | def test_interlingual_hypernym_paths():
  function test_shortest_path (line 88) | def test_shortest_path():
  function test_min_depth (line 111) | def test_min_depth():
  function test_max_depth (line 119) | def test_max_depth():

FILE: tests/util_test.py
  function test_synset_id_formatter (line 4) | def test_synset_id_formatter():

FILE: tests/validate_test.py
  function test_validate (line 19) | def test_validate(datadir, code: str, i: int) -> None:

FILE: tests/wordnet_test.py
  function test_wordnet_lexicons (line 9) | def test_wordnet_lexicons():
  function test_wordnet_normalize (line 40) | def test_wordnet_normalize():
  function test_wordnet_lemmatize (line 57) | def test_wordnet_lemmatize():
  function test_portable_entities_issue_226 (line 86) | def test_portable_entities_issue_226(monkeypatch, tmp_path, datadir):

FILE: wn/__main__.py
  function _download (line 14) | def _download(args: argparse.Namespace) -> None:
  function _cache (line 21) | def _cache(args: argparse.Namespace) -> None:
  function _lexicons (line 40) | def _lexicons(args: argparse.Namespace) -> None:
  function _projects (line 45) | def _projects(args: argparse.Namespace) -> None:
  function _validate (line 63) | def _validate(args: argparse.Namespace) -> None:
  function _path_type (line 95) | def _path_type(arg):
  function _file_path_type (line 99) | def _file_path_type(arg):

FILE: wn/_add.py
  function add (line 85) | def add(
  function _add_lmf (line 121) | def _add_lmf(
  function add_lexical_resource (line 143) | def add_lexical_resource(
  function _add_lexical_resource (line 180) | def _add_lexical_resource(
  function _precheck (line 239) | def _precheck(
  function _sum_counts (line 272) | def _sum_counts(lex: _AnyLexicon) -> int:
  function _update_lookup_tables (line 308) | def _update_lookup_tables(lexicon: _AnyLexicon, cur: sqlite3.Cursor) -> ...
  function _insert_lexicon (line 333) | def _insert_lexicon(
  function _build_lexid_map (line 402) | def _build_lexid_map(lexicon: _AnyLexicon, lexid: int, extid: int) -> _L...
  function _batch (line 422) | def _batch(sequence: Iterable[T]) -> Iterator[list[T]]:
  function _insert_synsets (line 430) | def _insert_synsets(
  function _insert_synset_definitions (line 509) | def _insert_synset_definitions(
  function _insert_synset_relations (line 540) | def _insert_synset_relations(
  function _insert_entries (line 570) | def _insert_entries(
  function _insert_index (line 587) | def _insert_index(
  function _insert_forms (line 609) | def _insert_forms(
  function _insert_pronunciations (line 663) | def _insert_pronunciations(
  function _insert_tags (line 730) | def _insert_tags(
  function _insert_senses (line 776) | def _insert_senses(
  function _insert_adjpositions (line 837) | def _insert_adjpositions(
  function _insert_counts (line 855) | def _insert_counts(
  function _collect_frames (line 880) | def _collect_frames(lexicon: _AnyLexicon) -> list[lmf.SyntacticBehaviour]:
  function _insert_syntactic_behaviours (line 919) | def _insert_syntactic_behaviours(
  function _insert_sense_relations (line 955) | def _insert_sense_relations(
  function _insert_examples (line 1008) | def _insert_examples(
  function _add_ili (line 1039) | def _add_ili(
  function remove (line 1073) | def remove(lexicon: str, progress_handler: type[ProgressHandler] = Progr...
  function _entries (line 1122) | def _entries(lex: _AnyLexicon) -> Sequence[_AnyEntry]:
  function _forms (line 1126) | def _forms(e: _AnyEntry) -> Sequence[_AnyForm]:
  function _senses (line 1130) | def _senses(e: _AnyEntry) -> Sequence[_AnySense]:
  function _synsets (line 1134) | def _synsets(lex: _AnyLexicon) -> Sequence[_AnySynset]:
  function _is_external (line 1138) | def _is_external(x: _AnyForm | _AnyLemma | _AnyEntry | _AnySense | _AnyS...
  function _local_synsets (line 1142) | def _local_synsets(synsets: Sequence[_AnySynset]) -> Iterator[lmf.Synset]:
  function _local_entries (line 1149) | def _local_entries(entries: Sequence[_AnyEntry]) -> Iterator[lmf.Lexical...
  function _local_senses (line 1156) | def _local_senses(senses: Sequence[_AnySense]) -> Iterator[lmf.Sense]:

FILE: wn/_config.py
  class ResourceType (line 36) | class ResourceType(str, Enum):
  class VersionInfo (line 41) | class VersionInfo(TypedDict):
  class ProjectInfo (line 47) | class ProjectInfo(TypedDict):
  class ResolvedProjectInfo (line 56) | class ResolvedProjectInfo(TypedDict):
  class CacheEntry (line 67) | class CacheEntry(TypedDict):
  class WNConfig (line 74) | class WNConfig:
    method __init__ (line 77) | def __init__(self):
    method data_directory (line 84) | def data_directory(self) -> Path:
    method data_directory (line 102) | def data_directory(self, path: AnyPath) -> None:
    method database_path (line 110) | def database_path(self) -> Path:
    method downloads_directory (line 120) | def downloads_directory(self) -> Path:
    method index (line 132) | def index(self) -> dict[str, ProjectInfo]:
    method add_project (line 136) | def add_project(
    method add_project_version (line 169) | def add_project_version(
    method get_project_info (line 203) | def get_project_info(self, arg: str) -> ResolvedProjectInfo:
    method get_cache_path (line 251) | def get_cache_path(self, url: str) -> Path:
    method list_cache_entries (line 261) | def list_cache_entries(self, arg: str = "*") -> list[CacheEntry]:
    method update (line 297) | def update(self, data: dict[str, Any]) -> None:
    method _update_index (line 319) | def _update_index(self, index: dict[str, Any]) -> None:
    method load_index (line 350) | def load_index(self, path: AnyPath) -> None:
  function _get_cache_path_for_urls (line 381) | def _get_cache_path_for_urls(
  function _cache_map (line 392) | def _cache_map(config: WNConfig) -> dict[Path, tuple[str, str, str]]:

FILE: wn/_core.py
  class _EntityType (line 49) | class _EntityType(str, enum.Enum):
  class _LexiconDataElement (line 69) | class _LexiconDataElement(LexiconElementWithMetadata):
    method __init__ (line 82) | def __init__(
    method __eq__ (line 92) | def __eq__(self, other) -> bool:
    method __hash__ (line 97) | def __hash__(self) -> int:
    method _get_lexicons (line 100) | def _get_lexicons(self) -> tuple[str, ...]:
  class Pronunciation (line 112) | class Pronunciation(LexiconElement):
  class Tag (line 126) | class Tag(LexiconElement):
  class Form (line 137) | class Form(LexiconElement):
    method pronunciations (line 151) | def pronunciations(self) -> list[Pronunciation]:
    method tags (line 154) | def tags(self) -> list[Tag]:
  function _make_form (line 158) | def _make_form(
  class Word (line 176) | class Word(_LexiconDataElement):
    method __init__ (line 186) | def __init__(
    method __repr__ (line 196) | def __repr__(self) -> str:
    method lemma (line 200) | def lemma(self, *, data: Literal[False] = False) -> str: ...
    method lemma (line 202) | def lemma(self, *, data: Literal[True] = True) -> Form: ...
    method lemma (line 206) | def lemma(self, *, data: bool) -> str | Form: ...
    method lemma (line 208) | def lemma(self, *, data: bool = False) -> str | Form:
    method forms (line 231) | def forms(self, *, data: Literal[False] = False) -> list[str]: ...
    method forms (line 233) | def forms(self, *, data: Literal[True] = True) -> list[Form]: ...
    method forms (line 237) | def forms(self, *, data: bool) -> list[str] | list[Form]: ...
    method forms (line 239) | def forms(self, *, data: bool = False) -> list[str] | list[Form]:
    method senses (line 261) | def senses(self) -> list[Sense]:
    method metadata (line 274) | def metadata(self) -> Metadata:
    method synsets (line 278) | def synsets(self) -> list[Synset]:
    method derived_words (line 289) | def derived_words(self) -> list[Word]:
    method translate (line 304) | def translate(
  class Relation (line 333) | class Relation(LexiconElementWithMetadata):
    method __init__ (line 344) | def __init__(
    method __repr__ (line 359) | def __repr__(self) -> str:
    method __eq__ (line 365) | def __eq__(self, other) -> bool:
    method __hash__ (line 376) | def __hash__(self) -> int:
    method subtype (line 381) | def subtype(self) -> str | None:
  class _Relatable (line 394) | class _Relatable(_LexiconDataElement):
    method relations (line 396) | def relations(
    method relations (line 400) | def relations(
    method relations (line 406) | def relations(
    method relations (line 410) | def relations(
    method get_related (line 415) | def get_related(self: T, *args: str) -> list[T]:
    method closure (line 418) | def closure(self: T, *args: str) -> Iterator[T]:
    method relation_paths (line 428) | def relation_paths(self: T, *args: str, end: T | None = None) -> Itera...
  class Example (line 454) | class Example(LexiconElementWithMetadata):
    method metadata (line 464) | def metadata(self) -> Metadata:
  class Definition (line 470) | class Definition(LexiconElementWithMetadata):
    method metadata (line 481) | def metadata(self) -> Metadata:
  class Synset (line 486) | class Synset(_Relatable):
    method __init__ (line 497) | def __init__(
    method empty (line 510) | def empty(
    method __eq__ (line 519) | def __eq__(self, other) -> bool:
    method __hash__ (line 529) | def __hash__(self) -> int:
    method __repr__ (line 532) | def __repr__(self) -> str:
    method ili (line 536) | def ili(self) -> str | None:
    method definition (line 540) | def definition(self, *, data: Literal[False] = False) -> str | None: ...
    method definition (line 542) | def definition(self, *, data: Literal[True] = True) -> Definition | No...
    method definition (line 546) | def definition(self, *, data: bool) -> str | Definition | None: ...
    method definition (line 548) | def definition(self, *, data: bool = False) -> str | Definition | None:
    method definitions (line 580) | def definitions(self, *, data: Literal[False] = False) -> list[str]: ...
    method definitions (line 582) | def definitions(self, *, data: Literal[True] = True) -> list[Definitio...
    method definitions (line 586) | def definitions(self, *, data: bool) -> list[str] | list[Definition]: ...
    method definitions (line 588) | def definitions(self, *, data: bool = False) -> list[str] | list[Defin...
    method examples (line 621) | def examples(self, *, data: Literal[False] = False) -> list[str]: ...
    method examples (line 623) | def examples(self, *, data: Literal[True] = True) -> list[Example]: ...
    method examples (line 627) | def examples(self, *, data: bool) -> list[str] | list[Example]: ...
    method examples (line 629) | def examples(self, *, data: bool = False) -> list[str] | list[Example]:
    method senses (line 652) | def senses(self) -> list[Sense]:
    method lexicalized (line 665) | def lexicalized(self) -> bool:
    method lexfile (line 669) | def lexfile(self) -> str | None:
    method metadata (line 673) | def metadata(self) -> Metadata:
    method words (line 677) | def words(self) -> list[Word]:
    method lemmas (line 689) | def lemmas(self, *, data: Literal[False] = False) -> list[str]: ...
    method lemmas (line 691) | def lemmas(self, *, data: Literal[True] = True) -> list[Form]: ...
    method lemmas (line 695) | def lemmas(self, *, data: bool) -> list[str] | list[Form]: ...
    method lemmas (line 697) | def lemmas(self, *, data: bool = False) -> list[str] | list[Form]:
    method relations (line 720) | def relations(
    method relations (line 724) | def relations(
    method relations (line 730) | def relations(
    method relations (line 734) | def relations(
    method get_related (line 772) | def get_related(self, *args: str) -> list[Synset]:
    method _iter_relations (line 792) | def _iter_relations(self, *args: str) -> Iterator[tuple[Relation, Syns...
    method _iter_local_relations (line 799) | def _iter_local_relations(
    method _iter_expanded_relations (line 819) | def _iter_expanded_relations(
    method hypernym_paths (line 846) | def hypernym_paths(self, simulate_root: bool = False) -> list[list[Syn...
    method min_depth (line 850) | def min_depth(self, simulate_root: bool = False) -> int:
    method max_depth (line 854) | def max_depth(self, simulate_root: bool = False) -> int:
    method shortest_path (line 858) | def shortest_path(self, other: Synset, simulate_root: bool = False) ->...
    method common_hypernyms (line 862) | def common_hypernyms(
    method lowest_common_hypernyms (line 868) | def lowest_common_hypernyms(
    method holonyms (line 876) | def holonyms(self) -> list[Synset]:
    method meronyms (line 893) | def meronyms(self) -> list[Synset]:
    method hypernyms (line 910) | def hypernyms(self) -> list[Synset]:
    method hyponyms (line 919) | def hyponyms(self) -> list[Synset]:
    method translate (line 928) | def translate(
  class Count (line 959) | class Count(LexiconElementWithMetadata):
  class Sense (line 969) | class Sense(_Relatable):
    method __init__ (line 977) | def __init__(
    method __repr__ (line 989) | def __repr__(self) -> str:
    method word (line 992) | def word(self) -> Word:
    method synset (line 1005) | def synset(self) -> Synset:
    method examples (line 1019) | def examples(self, *, data: Literal[False] = False) -> list[str]: ...
    method examples (line 1021) | def examples(self, *, data: Literal[True] = True) -> list[Example]: ...
    method examples (line 1025) | def examples(self, *, data: bool) -> list[str] | list[Example]: ...
    method examples (line 1027) | def examples(self, *, data: bool = False) -> list[str] | list[Example]:
    method lexicalized (line 1044) | def lexicalized(self) -> bool:
    method adjposition (line 1048) | def adjposition(self) -> str | None:
    method frames (line 1061) | def frames(self) -> list[str]:
    method counts (line 1067) | def counts(self, *, data: Literal[False] = False) -> list[int]: ...
    method counts (line 1069) | def counts(self, *, data: Literal[True] = True) -> list[Count]: ...
    method counts (line 1073) | def counts(self, *, data: bool) -> list[int] | list[Count]: ...
    method counts (line 1075) | def counts(self, *, data: bool = False) -> list[int] | list[Count]:
    method metadata (line 1087) | def metadata(self) -> Metadata:
    method relations (line 1092) | def relations(
    method relations (line 1096) | def relations(
    method relations (line 1102) | def relations(
    method relations (line 1106) | def relations(
    method synset_relations (line 1137) | def synset_relations(
    method synset_relations (line 1141) | def synset_relations(
    method synset_relations (line 1147) | def synset_relations(
    method synset_relations (line 1151) | def synset_relations(
    method get_related (line 1181) | def get_related(self, *args: str) -> list[Sense]:
    method get_related_synsets (line 1199) | def get_related_synsets(self, *args: str) -> list[Synset]:
    method _iter_sense_relations (line 1205) | def _iter_sense_relations(self, *args: str) -> Iterator[tuple[Relation...
    method _iter_sense_synset_relations (line 1213) | def _iter_sense_synset_relations(
    method translate (line 1224) | def translate(

FILE: wn/_db.py
  function _adapt_dict (line 44) | def _adapt_dict(d: dict) -> bytes:
  function _convert_dict (line 48) | def _convert_dict(s: bytes) -> dict:
  function _convert_boolean (line 52) | def _convert_boolean(s: bytes) -> bool:
  function connect (line 69) | def connect(check_schema: bool = True) -> sqlite3.Connection:
  function _init_db (line 94) | def _init_db(conn: sqlite3.Connection) -> None:
  function _check_schema_compatibility (line 104) | def _check_schema_compatibility(conn: sqlite3.Connection, dbpath: Path) ...
  function list_lexicons_safe (line 135) | def list_lexicons_safe(conn: sqlite3.Connection | None = None) -> list[s...
  function schema_hash (line 146) | def schema_hash(conn: sqlite3.Connection) -> str:
  function clear_connections (line 158) | def clear_connections() -> None:

FILE: wn/_download.py
  function download (line 20) | def download(
  function _get_cache_path_and_urls (line 81) | def _get_cache_path_and_urls(project_or_url: str) -> tuple[Path | None, ...
  function _download (line 89) | def _download(urls: Sequence[str], progress: ProgressHandler) -> Path:

FILE: wn/_exceptions.py
  class Error (line 1) | class Error(Exception):
  class DatabaseError (line 8) | class DatabaseError(Error):
  class ConfigurationError (line 14) | class ConfigurationError(Error):
  class ProjectError (line 20) | class ProjectError(Error):
  class WnWarning (line 26) | class WnWarning(Warning):

FILE: wn/_export.py
  function export (line 42) | def export(
  function _precheck (line 71) | def _precheck(lexicons: Sequence[Lexicon]) -> None:
  class _LexSpecs (line 88) | class _LexSpecs(NamedTuple):
  class _LMFExporter (line 93) | class _LMFExporter:
    method __init__ (line 102) | def __init__(self, version: str) -> None:
    method export (line 111) | def export(self, lexicon: Lexicon) -> lmf.Lexicon | lmf.LexiconExtension:
    method _lexicon (line 124) | def _lexicon(self, lexicon: Lexicon) -> lmf.Lexicon:
    method _requires (line 145) | def _requires(self) -> list[lmf.Dependency]:
    method _dependency (line 152) | def _dependency(self, id: str, version: str, url: str | None) -> lmf.D...
    method _entries (line 156) | def _entries(
    method _entries (line 161) | def _entries(self, extension: Literal[False]) -> Iterator[lmf.LexicalE...
    method _entries (line 163) | def _entries(
    method _entry (line 174) | def _entry(self, id: str, pos: str) -> lmf.LexicalEntry:
    method _lemma (line 197) | def _lemma(self, form: Form, pos: str) -> lmf.Lemma:
    method _form (line 206) | def _form(self, form: Form) -> lmf.Form:
    method _pronunciations (line 215) | def _pronunciations(self, prons: list[Pronunciation]) -> list[lmf.Pron...
    method _tags (line 229) | def _tags(self, tags: list[Tag]) -> list[lmf.Tag]:
    method _senses (line 238) | def _senses(
    method _senses (line 243) | def _senses(
    method _senses (line 247) | def _senses(
    method _sense (line 259) | def _sense(self, sense: Sense, index: str | None, i: int) -> lmf.Sense:
    method _sense_relations (line 276) | def _sense_relations(self, sense_id: str) -> list[lmf.Relation]:
    method _examples (line 294) | def _examples(self, id: str, table: str) -> list[lmf.Example]:
    method _counts (line 301) | def _counts(self, sense_id: str) -> list[lmf.Count]:
    method _synsets (line 309) | def _synsets(
    method _synsets (line 314) | def _synsets(self, extension: Literal[False]) -> Iterator[lmf.Synset]:...
    method _synsets (line 316) | def _synsets(
    method _synset (line 327) | def _synset(self, id: str, pos: str, ili: str) -> lmf.Synset:
    method _definitions (line 350) | def _definitions(self, synset_id: str) -> list[lmf.Definition]:
    method _ili_definition (line 364) | def _ili_definition(self, synset: str) -> lmf.ILIDefinition | None:
    method _synset_relations (line 378) | def _synset_relations(
    method _syntactic_behaviours_1_0 (line 391) | def _syntactic_behaviours_1_0(
    method _syntactic_behaviours_1_1 (line 409) | def _syntactic_behaviours_1_1(self) -> list[lmf.SyntacticBehaviour]:
    method _metadata (line 416) | def _metadata(self, id: str, table: str) -> lmf.Metadata:
    method _lexicon_extension (line 421) | def _lexicon_extension(
    method _ext_entry (line 448) | def _ext_entry(self, id: str) -> lmf.ExternalLexicalEntry | None:
    method _ext_lemma (line 465) | def _ext_lemma(self, lemma: Form) -> lmf.ExternalLemma | None:
    method _ext_forms (line 477) | def _ext_forms(self, forms: list[Form]) -> list[lmf.Form | lmf.Externa...
    method _ext_form (line 487) | def _ext_form(self, form: Form) -> lmf.ExternalForm | None:
    method _ext_sense (line 502) | def _ext_sense(self, id: str) -> lmf.ExternalSense | None:
    method _ext_synset (line 516) | def _ext_synset(self, id: str) -> lmf.ExternalSynset | None:
  function _build_sbmap (line 539) | def _build_sbmap(lexicons: Sequence[str]) -> _SBMap:
  function _get_entry_forms (line 549) | def _get_entry_forms(id: str, lexicons: Sequence[str]) -> tuple[Form, li...
  function _get_sense_n (line 555) | def _get_sense_n(id: str, lexspec: str, index: str | None, i: int) -> int:
  function _get_external_sense_ids (line 568) | def _get_external_sense_ids(lexspecs: _LexSpecs) -> set[str]:
  function _get_external_synset_ids (line 575) | def _get_external_synset_ids(lexspecs: _LexSpecs) -> set[str]:

FILE: wn/_lexicon.py
  class Lexicon (line 31) | class Lexicon(HasMetadata):
    method from_specifier (line 49) | def from_specifier(cls: type[Self], specifier: str) -> Self:
    method __repr__ (line 66) | def __repr__(self):
    method specifier (line 69) | def specifier(self) -> str:
    method confidence (line 73) | def confidence(self) -> float:
    method modified (line 80) | def modified(self) -> bool:
    method requires (line 84) | def requires(self) -> dict[str, Lexicon | None]:
    method extends (line 91) | def extends(self) -> Lexicon | None:
    method extensions (line 101) | def extensions(self, depth: int = 1) -> list[Lexicon]:
    method describe (line 117) | def describe(self, full: bool = True) -> str:
  function _desc_counts (line 149) | def _desc_counts(query: Callable, lexspecs: Sequence[str]) -> str:
  class LexiconElement (line 160) | class LexiconElement(Protocol):
    method lexicon (line 165) | def lexicon(self) -> Lexicon:
  class LexiconElementWithMetadata (line 170) | class LexiconElementWithMetadata(LexiconElement, HasMetadata, Protocol):
    method confidence (line 173) | def confidence(self) -> float:
  class LexiconConfiguration (line 185) | class LexiconConfiguration(NamedTuple):

FILE: wn/_metadata.py
  class Metadata (line 4) | class Metadata(TypedDict, total=False):
  class HasMetadata (line 26) | class HasMetadata(Protocol):
    method _metadata (line 28) | def _metadata(self) -> Metadata | None:
    method metadata (line 31) | def metadata(self) -> Metadata:
    method confidence (line 35) | def confidence(self) -> float:

FILE: wn/_module_functions.py
  function projects (line 13) | def projects() -> list[ResolvedProjectInfo]:
  function lexicons (line 39) | def lexicons(*, lexicon: str | None = "*", lang: str | None = None) -> l...
  function reset_database (line 56) | def reset_database(rebuild: bool = False) -> None:
  function word (line 86) | def word(id: str, *, lexicon: str | None = None, lang: str | None = None...
  function words (line 100) | def words(
  function lemmas (line 125) | def lemmas(
  function lemmas (line 136) | def lemmas(
  function lemmas (line 147) | def lemmas(
  function lemmas (line 157) | def lemmas(
  function synset (line 186) | def synset(id: str, *, lexicon: str | None = None, lang: str | None = No...
  function synsets (line 200) | def synsets(
  function senses (line 223) | def senses(
  function sense (line 245) | def sense(id: str, *, lexicon: str | None = None, lang: str | None = Non...

FILE: wn/_queries.py
  function resolve_lexicon_specifiers (line 114) | def resolve_lexicon_specifiers(
  function get_lexicon (line 139) | def get_lexicon(lexicon: str) -> _Lexicon:
  function get_modified (line 152) | def get_modified(lexicon: str) -> bool:
  function get_lexicon_dependencies (line 157) | def get_lexicon_dependencies(lexicon: str) -> list[tuple[str, str, bool]]:
  function get_lexicon_extension_bases (line 170) | def get_lexicon_extension_bases(lexicon: str, depth: int = -1) -> list[s...
  function get_lexicon_extensions (line 190) | def get_lexicon_extensions(lexicon: str, depth: int = -1) -> list[str]:
  function get_ili (line 210) | def get_ili(id: str) -> _ExistingILI | None:
  function find_ilis (line 221) | def find_ilis(
  function find_proposed_ilis (line 253) | def find_proposed_ilis(
  function find_entries (line 276) | def find_entries(
  function _load_lemmas_with_details (line 310) | def _load_lemmas_with_details(
  function find_lemmas (line 370) | def find_lemmas(
  function find_senses (line 413) | def find_senses(
  function find_synsets (line 464) | def find_synsets(
  function get_entry_forms (line 529) | def get_entry_forms(id: str, lexicons: Sequence[str]) -> Iterator[Form]:
  function get_synsets_for_ilis (line 565) | def get_synsets_for_ilis(
  function get_synset_relations (line 583) | def get_synset_relations(
  function get_expanded_synset_relations (line 638) | def get_expanded_synset_relations(
  function get_definitions (line 684) | def get_definitions(
  function get_examples (line 710) | def get_examples(
  function find_syntactic_behaviours (line 730) | def find_syntactic_behaviours(
  function get_syntactic_behaviours (line 761) | def get_syntactic_behaviours(
  function _get_senses (line 779) | def _get_senses(
  function get_entry_senses (line 807) | def get_entry_senses(
  function get_synset_members (line 813) | def get_synset_members(
  function get_sense_relations (line 819) | def get_sense_relations(
  function get_sense_synset_relations (line 868) | def get_sense_synset_relations(
  function get_relation_targets (line 916) | def get_relation_targets(
  function get_metadata (line 965) | def get_metadata(id: str, lexicon: str, table: str) -> Metadata:
  function get_ili_metadata (line 982) | def get_ili_metadata(id: str) -> Metadata:
  function get_proposed_ili_metadata (line 990) | def get_proposed_ili_metadata(synset: str, lexicon: str) -> Metadata:
  function get_lexicalized (line 1011) | def get_lexicalized(id: str, lexicon: str, table: str) -> bool:
  function get_adjposition (line 1030) | def get_adjposition(sense_id: str, lexicon: str) -> str | None:
  function get_sense_counts (line 1046) | def get_sense_counts(sense_id: str, lexicons: Sequence[str]) -> list[_Co...
  function get_lexfile (line 1060) | def get_lexfile(synset_id: str, lexicon: str) -> str | None:
  function get_entry_index (line 1076) | def get_entry_index(entry_id: str, lexicon: str) -> str | None:
  function get_sense_n (line 1092) | def get_sense_n(sense_id: str, lexicon: str) -> int | None:
  function _qs (line 1107) | def _qs(xs: Collection) -> str:
  function _vs (line 1111) | def _vs(xs: Collection) -> str:
  function _kws (line 1115) | def _kws(xs: Collection) -> str:
  function _query_forms (line 1119) | def _query_forms(
  function _build_entry_conditions (line 1147) | def _build_entry_conditions(

FILE: wn/_util.py
  function version_info (line 12) | def version_info(version_string: str) -> VersionInfo:
  function is_url (line 16) | def is_url(string: str) -> bool:
  function is_gzip (line 22) | def is_gzip(path: Path) -> bool:
  function is_lzma (line 27) | def is_lzma(path: Path) -> bool:
  function is_xml (line 32) | def is_xml(path: Path) -> bool:
  function is_str_key_dict (line 37) | def is_str_key_dict(obj: Any) -> TypeGuard[dict[str, Any]]:
  function _inspect_file_signature (line 41) | def _inspect_file_signature(path: Path, signature: bytes) -> bool:
  function short_hash (line 48) | def short_hash(string: str) -> str:
  function flatten (line 58) | def flatten(iterable: Iterable[Iterable[T]]) -> list[T]:
  function unique_list (line 65) | def unique_list(items: Iterable[H]) -> list[H]:
  function normalize_form (line 71) | def normalize_form(s: str) -> str:
  function format_lexicon_specifier (line 75) | def format_lexicon_specifier(id: str, version: str) -> str:
  function split_lexicon_specifier (line 79) | def split_lexicon_specifier(lexicon: str) -> tuple[str, str]:

FILE: wn/_wordnet.py
  class Wordnet (line 27) | class Wordnet:
    method __init__ (line 91) | def __init__(
    method lexicons (line 129) | def lexicons(self) -> list[Lexicon]:
    method expanded_lexicons (line 133) | def expanded_lexicons(self) -> list[Lexicon]:
    method word (line 137) | def word(self, id: str) -> Word:
    method words (line 146) | def words(self, form: str | None = None, pos: str | None = None) -> li...
    method lemmas (line 158) | def lemmas(
    method lemmas (line 166) | def lemmas(
    method lemmas (line 176) | def lemmas(
    method lemmas (line 180) | def lemmas(
    method synset (line 222) | def synset(self, id: str) -> Synset:
    method synsets (line 231) | def synsets(
    method sense (line 247) | def sense(self, id: str) -> Sense:
    method senses (line 256) | def senses(self, form: str | None = None, pos: str | None = None) -> l...
    method describe (line 267) | def describe(self) -> str:
  function _resolve_lexicon_dependencies (line 295) | def _resolve_lexicon_dependencies(
  function _find_lemmas (line 320) | def _find_lemmas(
  function _query_with_forms (line 354) | def _query_with_forms(
  function _find_helper (line 379) | def _find_helper(

FILE: wn/compat/sensekey.py
  function unescape (line 129) | def unescape(s: str, /, flavor: str = "oewn-v2") -> str:
  function _unescape_oewn (line 161) | def _unescape_oewn(s: str, escape_sequences: list[tuple[str, str]]) -> str:
  function escape (line 172) | def escape(sense_key: str, /, flavor: str = "oewn-v2") -> str:
  function _escape_oewn (line 196) | def _escape_oewn(sense_key: str, escape_sequences: list[tuple[str, str]]...
  function sense_key_getter (line 207) | def sense_key_getter(lexicon: str) -> SensekeyGetter:
  function sense_getter (line 255) | def sense_getter(lexicon: str, wordnet: wn.Wordnet | None = None) -> Sen...

FILE: wn/ic.py
  function information_content (line 22) | def information_content(synset: Synset, freq: Freq) -> float:
  function synset_probability (line 32) | def synset_probability(synset: Synset, freq: Freq) -> float:
  function _initialize (line 47) | def _initialize(
  function compute (line 70) | def compute(
  function load (line 155) | def load(
  function _parse_ic_file (line 203) | def _parse_ic_file(icfile: TextIO) -> Iterator[tuple[int, str, float, bo...

FILE: wn/ili.py
  class ILIStatus (line 33) | class ILIStatus(str, Enum):
  class ILIDefinition (line 43) | class ILIDefinition(HasMetadata):
    method metadata (line 52) | def metadata(self) -> Metadata:
    method confidence (line 56) | def confidence(self) -> float:
  class ILIProtocol (line 69) | class ILIProtocol(Protocol):
    method id (line 74) | def id(self) -> str | None:
    method status (line 79) | def status(self) -> ILIStatus:
    method definition (line 84) | def definition(self, *, data: Literal[False] = False) -> str | None: ...
    method definition (line 86) | def definition(self, *, data: Literal[True] = True) -> ILIDefinition |...
    method definition (line 90) | def definition(self, *, data: bool) -> str | ILIDefinition | None: ...
    method definition (line 92) | def definition(self, *, data: bool = False) -> str | ILIDefinition | N...
  class ILI (line 115) | class ILI(ILIProtocol):
  class ProposedILI (line 133) | class ProposedILI(LexiconElementWithMetadata, ILIProtocol):
    method id (line 146) | def id(self) -> Literal[None]:
    method status (line 156) | def status(self) -> Literal[ILIStatus.PROPOSED]:
    method synset (line 164) | def synset(self) -> Synset:
  function get (line 169) | def get(id: str) -> ILI | None:
  function get_all (line 198) | def get_all(
  function get_proposed (line 232) | def get_proposed(synset: Synset) -> ProposedILI | None:
  function get_all_proposed (line 262) | def get_all_proposed(lexicon: str | None = None) -> list[ProposedILI]:
  function is_ili_tsv (line 282) | def is_ili_tsv(source: AnyPath) -> bool:
  function load_tsv (line 300) | def load_tsv(source: AnyPath) -> Iterator[dict[str, str]]:

FILE: wn/lmf.py
  class LMFError (line 19) | class LMFError(Error):
  class LMFWarning (line 23) | class LMFWarning(Warning):
  class _HasId (line 171) | class _HasId(TypedDict):
  class _HasILI (line 175) | class _HasILI(TypedDict):
  class _HasSynset (line 179) | class _HasSynset(TypedDict):
  class _MaybeId (line 183) | class _MaybeId(TypedDict, total=False):
  class _HasText (line 187) | class _HasText(TypedDict):
  class _MaybeScript (line 191) | class _MaybeScript(TypedDict, total=False):
  class _HasMeta (line 195) | class _HasMeta(TypedDict, total=False):
  class _External (line 199) | class _External(TypedDict):
  class ILIDefinition (line 203) | class ILIDefinition(_HasText, _HasMeta): ...
  class Definition (line 206) | class Definition(_HasText, _HasMeta, total=False):
  class Relation (line 211) | class Relation(_HasMeta):
  class Example (line 216) | class Example(_HasText, _HasMeta, total=False):
  class Synset (line 220) | class Synset(_HasId, _HasILI, _HasMeta, total=False):
  class ExternalSynset (line 231) | class ExternalSynset(_HasId, _External, total=False):
  class Count (line 237) | class Count(_HasMeta):
  class Sense (line 241) | class Sense(_HasId, _HasSynset, _HasMeta, total=False):
  class ExternalSense (line 251) | class ExternalSense(_HasId, _External, total=False):
  class Pronunciation (line 257) | class Pronunciation(_HasText, total=False):
  class Tag (line 264) | class Tag(_HasText):
  class _FormChildren (line 268) | class _FormChildren(TypedDict, total=False):
  class Lemma (line 273) | class Lemma(_MaybeScript, _FormChildren):
  class ExternalLemma (line 278) | class ExternalLemma(_FormChildren, _External): ...
  class Form (line 281) | class Form(_MaybeId, _MaybeScript, _FormChildren):
  class ExternalForm (line 285) | class ExternalForm(_HasId, _FormChildren, _External): ...
  class _SyntacticBehaviourBase (line 288) | class _SyntacticBehaviourBase(_MaybeId):
  class SyntacticBehaviour (line 292) | class SyntacticBehaviour(_SyntacticBehaviourBase, total=False):
  class _LexicalEntryBase (line 296) | class _LexicalEntryBase(_HasId, _HasMeta, total=False):
  class LexicalEntry (line 303) | class LexicalEntry(_LexicalEntryBase):
  class ExternalLexicalEntry (line 307) | class ExternalLexicalEntry(_HasId, _External, total=False):
  class LexiconSpecifier (line 313) | class LexiconSpecifier(_HasId):  # public but not an LMF entry
  class Dependency (line 317) | class Dependency(LexiconSpecifier, total=False):
  class _LexiconRequired (line 321) | class _LexiconRequired(LexiconSpecifier, _HasMeta):
  class _LexiconBase (line 328) | class _LexiconBase(_LexiconRequired, total=False):
  class Lexicon (line 334) | class Lexicon(_LexiconBase, total=False):
  class _LexiconExtensionBase (line 341) | class _LexiconExtensionBase(_LexiconBase):
  class LexiconExtension (line 345) | class LexiconExtension(_LexiconExtensionBase, total=False):
  class LexicalResource (line 352) | class LexicalResource(TypedDict):
  function is_lmf (line 360) | def is_lmf(source: AnyPath) -> bool:
  function _read_header (line 373) | def _read_header(fh: BinaryIO) -> str:
  class ScanInfo (line 389) | class ScanInfo(LexiconSpecifier):
  function scan_lexicons (line 394) | def scan_lexicons(source: AnyPath) -> list[ScanInfo]:
  function load (line 438) | def load(
  function _quick_scan (line 476) | def _quick_scan(source: Path) -> tuple[str, int]:
  function _make_parser (line 485) | def _make_parser(root, version, progress):  # noqa: C901
  function _unexpected (line 540) | def _unexpected(name: str, p: xml.parsers.expat.XMLParserType) -> LMFError:
  function _validate (line 547) | def _validate(elem: _Elem) -> Lexicon | LexiconExtension:
  function _validate_lexicon (line 561) | def _validate_lexicon(elem: _Elem, extension: bool) -> None:
  function _validate_entries (line 574) | def _validate_entries(elems: list[_Elem], extension: bool) -> None:
  function _validate_forms (line 593) | def _validate_forms(elems: list[_Elem], extension: bool) -> None:
  function _validate_senses (line 608) | def _validate_senses(elems: list[_Elem], extension: bool) -> None:
  function _validate_frames (line 635) | def _validate_frames(elems: list[_Elem]) -> None:
  function _validate_synsets (line 642) | def _validate_synsets(elems: list[_Elem], extension: bool) -> None:
  function _validate_metadata (line 666) | def _validate_metadata(elem: _Elem) -> None:
  function dump (line 674) | def dump(resource: LexicalResource, destination: AnyPath) -> None:
  function _dump_lexicon (line 696) | def _dump_lexicon(
  function _build_lexicon_attrib (line 728) | def _build_lexicon_attrib(
  function _dump_dependency (line 749) | def _dump_dependency(
  function _dump_lexical_entry (line 760) | def _dump_lexical_entry(
  function _build_lemma (line 790) | def _build_lemma(lemma: Lemma | ExternalLemma, version: VersionInfo) -> ...
  function _build_form (line 808) | def _build_form(form: Form | ExternalForm, version: VersionInfo) -> ET.E...
  function _build_pronunciation (line 828) | def _build_pronunciation(pron: Pronunciation) -> ET.Element:
  function _build_tag (line 843) | def _build_tag(tag: Tag) -> ET.Element:
  function _build_sense (line 849) | def _build_sense(
  function _build_example (line 877) | def _build_example(example: Example) -> ET.Element:
  function _build_count (line 887) | def _build_count(count: Count) -> ET.Element:
  function _dump_synset (line 893) | def _dump_synset(
  function _build_definition (line 924) | def _build_definition(definition: Definition) -> ET.Element:
  function _build_ili_definition (line 936) | def _build_ili_definition(ili_definition: ILIDefinition) -> ET.Element:
  function _build_relation (line 942) | def _build_relation(relation: Relation, elemtype: str) -> ET.Element:
  function _dump_syntactic_behaviour (line 948) | def _dump_syntactic_behaviour(
  function _build_syntactic_behaviour (line 955) | def _build_syntactic_behaviour(
  function _tostring (line 966) | def _tostring(elem: ET.Element, level: int, short_empty_elements: bool =...
  function _indent (line 973) | def _indent(elem: ET.Element, level: int) -> None:
  function _meta_dict (line 986) | def _meta_dict(meta: Metadata | None) -> dict[str, str]:

FILE: wn/metrics.py
  function ambiguity (line 6) | def ambiguity(word: Word) -> int:
  function average_ambiguity (line 10) | def average_ambiguity(synset: Synset) -> float:

FILE: wn/morphy.py
  class _System (line 14) | class _System(Flag):
  class Morphy (line 67) | class Morphy:
    method __init__ (line 95) | def __init__(self, wordnet: wn.Wordnet | None = None):
    method __call__ (line 121) | def __call__(self, form: str, pos: str | None = None) -> LemmatizeResult:
    method _morphstr (line 141) | def _morphstr(self, form: str, pos: str) -> set[str]:

FILE: wn/project.py
  function is_package_directory (line 22) | def is_package_directory(path: AnyPath) -> bool:
  function _package_directory_types (line 28) | def _package_directory_types(path: Path) -> list[tuple[Path, str]]:
  function _resource_file_type (line 38) | def _resource_file_type(path: Path) -> str | None:
  function is_collection_directory (line 46) | def is_collection_directory(path: AnyPath) -> bool:
  class Project (line 54) | class Project:
    method __init__ (line 59) | def __init__(self, path: AnyPath):
    method path (line 63) | def path(self) -> Path:
    method readme (line 73) | def readme(self) -> Path | None:
    method license (line 77) | def license(self) -> Path | None:
    method citation (line 81) | def citation(self) -> Path | None:
    method _find_file (line 85) | def _find_file(self, base: Path, suffixes: tuple[str, ...]) -> Path | ...
  class Package (line 93) | class Package(Project):
    method type (line 102) | def type(self) -> str | None:
    method resource_file (line 112) | def resource_file(self) -> Path:
  class ResourceOnlyPackage (line 122) | class ResourceOnlyPackage(Package):
    method resource_file (line 132) | def resource_file(self) -> Path:
    method readme (line 135) | def readme(self):
    method license (line 138) | def license(self):
    method citation (line 141) | def citation(self):
  class Collection (line 145) | class Collection(Project):
    method packages (line 152) | def packages(self) -> list[Package]:
  function get_project (line 159) | def get_project(
  function _get_project_from_path (line 199) | def _get_project_from_path(
  function iterpackages (line 237) | def iterpackages(path: AnyPath, delete: bool = True) -> Iterator[Package]:
  function _get_decompressed (line 282) | def _get_decompressed(
  function _check_tar (line 312) | def _check_tar(tar: tarfile.TarFile) -> None:

FILE: wn/schema.sql
  type ilis (line 4) | CREATE TABLE ilis (
  type ili_id_index (line 12) | CREATE INDEX ili_id_index ON ilis (id)
  type proposed_ilis (line 14) | CREATE TABLE proposed_ilis (
  type proposed_ili_synset_rowid_index (line 21) | CREATE INDEX proposed_ili_synset_rowid_index ON proposed_ilis (synset_ro...
  type lexicons (line 26) | CREATE TABLE lexicons (
  type lexicon_specifier_index (line 43) | CREATE INDEX lexicon_specifier_index ON lexicons (specifier)
  type lexicon_dependencies (line 45) | CREATE TABLE lexicon_dependencies (
  type lexicon_dependent_index (line 52) | CREATE INDEX lexicon_dependent_index ON lexicon_dependencies(dependent_r...
  type lexicon_extensions (line 54) | CREATE TABLE lexicon_extensions (
  type lexicon_extension_index (line 62) | CREATE INDEX lexicon_extension_index ON lexicon_extensions(extension_rowid)
  type entry_index (line 67) | CREATE TABLE entry_index (
  type entry_index_entry_index (line 72) | CREATE INDEX entry_index_entry_index ON entry_index(entry_rowid)
  type entry_index_lemma_index (line 73) | CREATE INDEX entry_index_lemma_index ON entry_index(lemma)
  type entries (line 79) | CREATE TABLE entries (
  type entry_id_index (line 87) | CREATE INDEX entry_id_index ON entries (id)
  type forms (line 89) | CREATE TABLE forms (
  type form_entry_index (line 100) | CREATE INDEX form_entry_index ON forms (entry_rowid)
  type form_index (line 101) | CREATE INDEX form_index ON forms (form)
  type form_norm_index (line 102) | CREATE INDEX form_norm_index ON forms (normalized_form)
  type pronunciations (line 104) | CREATE TABLE pronunciations (
  type pronunciation_form_index (line 113) | CREATE INDEX pronunciation_form_index ON pronunciations (form_rowid)
  type tags (line 115) | CREATE TABLE tags (
  type tag_form_index (line 121) | CREATE INDEX tag_form_index ON tags (form_rowid)
  type synsets (line 126) | CREATE TABLE synsets (
  type synset_id_index (line 135) | CREATE INDEX synset_id_index ON synsets (id)
  type synset_ili_rowid_index (line 136) | CREATE INDEX synset_ili_rowid_index ON synsets (ili_rowid)
  type unlexicalized_synsets (line 138) | CREATE TABLE unlexicalized_synsets (
  type unlexicalized_synsets_index (line 141) | CREATE INDEX unlexicalized_synsets_index ON unlexicalized_synsets (synse...
  type synset_relations (line 143) | CREATE TABLE synset_relations (
  type synset_relation_source_index (line 151) | CREATE INDEX synset_relation_source_index ON synset_relations (source_ro...
  type synset_relation_target_index (line 152) | CREATE INDEX synset_relation_target_index ON synset_relations (target_ro...
  type definitions (line 154) | CREATE TABLE definitions (
  type definition_rowid_index (line 163) | CREATE INDEX definition_rowid_index ON definitions (synset_rowid)
  type definition_sense_index (line 164) | CREATE INDEX definition_sense_index ON definitions (sense_rowid)
  type synset_examples (line 166) | CREATE TABLE synset_examples (
  type synset_example_rowid_index (line 174) | CREATE INDEX synset_example_rowid_index ON synset_examples(synset_rowid)
  type senses (line 179) | CREATE TABLE senses (
  type sense_id_index (line 189) | CREATE INDEX sense_id_index ON senses(id)
  type sense_entry_rowid_index (line 190) | CREATE INDEX sense_entry_rowid_index ON senses (entry_rowid)
  type sense_synset_rowid_index (line 191) | CREATE INDEX sense_synset_rowid_index ON senses (synset_rowid)
  type unlexicalized_senses (line 193) | CREATE TABLE unlexicalized_senses (
  type unlexicalized_senses_index (line 196) | CREATE INDEX unlexicalized_senses_index ON unlexicalized_senses (sense_r...
  type sense_relations (line 198) | CREATE TABLE sense_relations (
  type sense_relation_source_index (line 206) | CREATE INDEX sense_relation_source_index ON sense_relations (source_rowid)
  type sense_relation_target_index (line 207) | CREATE INDEX sense_relation_target_index ON sense_relations (target_rowid)
  type sense_synset_relations (line 209) | CREATE TABLE sense_synset_relations (
  type sense_synset_relation_source_index (line 217) | CREATE INDEX sense_synset_relation_source_index ON sense_synset_relation...
  type sense_synset_relation_target_index (line 218) | CREATE INDEX sense_synset_relation_target_index ON sense_synset_relation...
  type adjpositions (line 220) | CREATE TABLE adjpositions (
  type adjposition_sense_index (line 224) | CREATE INDEX adjposition_sense_index ON adjpositions (sense_rowid)
  type sense_examples (line 226) | CREATE TABLE sense_examples (
  type sense_example_index (line 234) | CREATE INDEX sense_example_index ON sense_examples (sense_rowid)
  type counts (line 236) | CREATE TABLE counts (
  type count_index (line 243) | CREATE INDEX count_index ON counts(sense_rowid)
  type syntactic_behaviours (line 248) | CREATE TABLE syntactic_behaviours (
  type syntactic_behaviour_id_index (line 256) | CREATE INDEX syntactic_behaviour_id_index ON syntactic_behaviours (id)
  type syntactic_behaviour_senses (line 258) | CREATE TABLE syntactic_behaviour_senses (
  type syntactic_behaviour_sense_sb_index (line 262) | CREATE INDEX syntactic_behaviour_sense_sb_index
  type syntactic_behaviour_sense_sense_index (line 264) | CREATE INDEX syntactic_behaviour_sense_sense_index
  type relation_types (line 270) | CREATE TABLE relation_types (
  type relation_type_index (line 275) | CREATE INDEX relation_type_index ON relation_types (type)
  type ili_statuses (line 277) | CREATE TABLE ili_statuses (
  type ili_status_index (line 282) | CREATE INDEX ili_status_index ON ili_statuses (status)
  type lexfiles (line 284) | CREATE TABLE lexfiles (
  type lexfile_index (line 289) | CREATE INDEX lexfile_index ON lexfiles (name)

FILE: wn/similarity.py
  function path (line 11) | def path(synset1: Synset, synset2: Synset, simulate_root: bool = False) ...
  function wup (line 49) | def wup(synset1: Synset, synset2: Synset, simulate_root=False) -> float:
  function lch (line 87) | def lch(
  function res (line 125) | def res(synset1: Synset, synset2: Synset, ic: Freq) -> float:
  function jcn (line 150) | def jcn(synset1: Synset, synset2: Synset, ic: Freq) -> float:
  function lin (line 183) | def lin(synset1: Synset, synset2: Synset, ic: Freq) -> float:
  function _least_common_subsumers (line 215) | def _least_common_subsumers(
  function _most_informative_lcs (line 224) | def _most_informative_lcs(synset1: Synset, synset2: Synset, ic: Freq) ->...
  function _check_if_pos_compatible (line 230) | def _check_if_pos_compatible(pos1: str, pos2: str) -> None:

FILE: wn/taxonomy.py
  function roots (line 12) | def roots(wordnet: wn.Wordnet, pos: str | None = None) -> list[wn.Synset]:
  function leaves (line 34) | def leaves(wordnet: wn.Wordnet, pos: str | None = None) -> list[wn.Synset]:
  function taxonomy_depth (line 55) | def taxonomy_depth(wordnet: wn.Wordnet, pos: str) -> int:
  function _synsets_for_pos (line 86) | def _synsets_for_pos(wordnet: wn.Wordnet, pos: str | None) -> list[wn.Sy...
  function _hypernym_paths (line 99) | def _hypernym_paths(
  function hypernym_paths (line 115) | def hypernym_paths(
  function min_depth (line 161) | def min_depth(synset: wn.Synset, simulate_root: bool = False) -> int:
  function max_depth (line 185) | def max_depth(synset: wn.Synset, simulate_root: bool = False) -> int:
  function _shortest_hyp_paths (line 209) | def _shortest_hyp_paths(
  function shortest_path (line 253) | def shortest_path(
  function common_hypernyms (line 286) | def common_hypernyms(
  function lowest_common_hypernyms (line 324) | def lowest_common_hypernyms(

FILE: wn/util.py
  function synset_id_formatter (line 8) | def synset_id_formatter(fmt: str = "{prefix}-{offset:08}-{pos}", **kwarg...
  class ProgressHandler (line 36) | class ProgressHandler:
    method __init__ (line 57) | def __init__(
    method update (line 79) | def update(self, n: int = 1, force: bool = False) -> None:
    method set (line 92) | def set(self, **kwargs) -> None:
    method flash (line 103) | def flash(self, message: str) -> None:
    method close (line 112) | def close(self) -> None:
  class ProgressBar (line 122) | class ProgressBar(ProgressHandler):
    method update (line 138) | def update(self, n: int = 1, force: bool = False) -> None:
    method format (line 149) | def format(self) -> str:
    method flash (line 187) | def flash(self, message: str) -> None:
    method close (line 191) | def close(self) -> None:

FILE: wn/validate.py
  class _Check (line 54) | class _Check(TypedDict):
  function _non_unique_id (line 62) | def _non_unique_id(lex: lmf.Lexicon, ids: _Ids) -> _Result:
  function _has_no_senses (line 76) | def _has_no_senses(lex: lmf.Lexicon, ids: _Ids) -> _Result:
  function _redundant_sense (line 81) | def _redundant_sense(lex: lmf.Lexicon, ids: _Ids) -> _Result:
  function _redundant_entry (line 94) | def _redundant_entry(lex: lmf.Lexicon, ids: _Ids) -> _Result:
  function _missing_synset (line 104) | def _missing_synset(lex: lmf.Lexicon, ids: _Ids) -> _Result:
  function _empty_synset (line 115) | def _empty_synset(lex: lmf.Lexicon, ids: _Ids) -> _Result:
  function _repeated_ili (line 121) | def _repeated_ili(lex: lmf.Lexicon, ids: _Ids) -> _Result:
  function _missing_ili_definition (line 131) | def _missing_ili_definition(lex: lmf.Lexicon, ids: _Ids) -> _Result:
  function _spurious_ili_definition (line 140) | def _spurious_ili_definition(lex: lmf.Lexicon, ids: _Ids) -> _Result:
  function _blank_synset_definition (line 149) | def _blank_synset_definition(lex: lmf.Lexicon, ids: _Ids) -> _Result:
  function _blank_synset_example (line 158) | def _blank_synset_example(lex: lmf.Lexicon, ids: _Ids) -> _Result:
  function _repeated_synset_definition (line 167) | def _repeated_synset_definition(lex: lmf.Lexicon, ids: _Ids) -> _Result:
  function _missing_relation_target (line 179) | def _missing_relation_target(lex: lmf.Lexicon, ids: _Ids) -> _Result:
  function _invalid_relation_type (line 194) | def _invalid_relation_type(lex: lmf.Lexicon, ids: _Ids) -> _Result:
  function _redundant_relation (line 210) | def _redundant_relation(lex: lmf.Lexicon, ids: _Ids) -> _Result:
  function _missing_reverse_relation (line 230) | def _missing_reverse_relation(lex: lmf.Lexicon, ids: _Ids) -> _Result:
  function _hypernym_wrong_pos (line 248) | def _hypernym_wrong_pos(lex: lmf.Lexicon, ids: _Ids) -> _Result:
  function _self_loop (line 258) | def _self_loop(lex: lmf.Lexicon, ids: _Ids) -> _Result:
  function _multiples (line 271) | def _multiples(iterable):
  function _entries (line 276) | def _entries(lex: lmf.Lexicon) -> list[lmf.LexicalEntry]:
  function _forms (line 280) | def _forms(e: lmf.LexicalEntry) -> list[lmf.Form]:
  function _senses (line 284) | def _senses(e: lmf.LexicalEntry) -> list[lmf.Sense]:
  function _synsets (line 288) | def _synsets(lex: lmf.Lexicon) -> list[lmf.Synset]:
  function _sense_relations (line 292) | def _sense_relations(lex: lmf.Lexicon) -> Iterator[tuple[lmf.Sense, lmf....
  function _synset_relations (line 299) | def _synset_relations(lex: lmf.Lexicon) -> Iterator[tuple[lmf.Synset, lm...
  function _get_dc_type (line 305) | def _get_dc_type(r: lmf.Relation) -> str | None:
  function _select_checks (line 348) | def _select_checks(select: Sequence[str]) -> list[tuple[str, _CheckFunct...
  function validate (line 360) | def validate(