3985 lines
101 KiB
Python
3985 lines
101 KiB
Python
"""
|
|
inflect: english language inflection
|
|
- correctly generate plurals, ordinals, indefinite articles
|
|
- convert numbers to words
|
|
|
|
Copyright (C) 2010 Paul Dyson
|
|
|
|
Based upon the Perl module
|
|
`Lingua::EN::Inflect <https://metacpan.org/pod/Lingua::EN::Inflect>`_.
|
|
|
|
methods:
|
|
classical inflect
|
|
plural plural_noun plural_verb plural_adj singular_noun no num a an
|
|
compare compare_nouns compare_verbs compare_adjs
|
|
present_participle
|
|
ordinal
|
|
number_to_words
|
|
join
|
|
defnoun defverb defadj defa defan
|
|
|
|
INFLECTIONS:
|
|
classical inflect
|
|
plural plural_noun plural_verb plural_adj singular_noun compare
|
|
no num a an present_participle
|
|
|
|
PLURALS:
|
|
classical inflect
|
|
plural plural_noun plural_verb plural_adj singular_noun no num
|
|
compare compare_nouns compare_verbs compare_adjs
|
|
|
|
COMPARISONS:
|
|
classical
|
|
compare compare_nouns compare_verbs compare_adjs
|
|
|
|
ARTICLES:
|
|
classical inflect num a an
|
|
|
|
NUMERICAL:
|
|
ordinal number_to_words
|
|
|
|
USER_DEFINED:
|
|
defnoun defverb defadj defa defan
|
|
|
|
Exceptions:
|
|
UnknownClassicalModeError
|
|
BadNumValueError
|
|
BadChunkingOptionError
|
|
NumOutOfRangeError
|
|
BadUserDefinedPatternError
|
|
BadRcFileError
|
|
BadGenderError
|
|
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import ast
|
|
import collections
|
|
import contextlib
|
|
import functools
|
|
import itertools
|
|
import re
|
|
from numbers import Number
|
|
from typing import (
|
|
TYPE_CHECKING,
|
|
Any,
|
|
Callable,
|
|
Dict,
|
|
Iterable,
|
|
List,
|
|
Match,
|
|
Optional,
|
|
Sequence,
|
|
Tuple,
|
|
Union,
|
|
cast,
|
|
)
|
|
|
|
from more_itertools import windowed_complete
|
|
from typeguard import typechecked
|
|
from typing_extensions import Annotated, Literal
|
|
|
|
|
|
class UnknownClassicalModeError(Exception):
|
|
pass
|
|
|
|
|
|
class BadNumValueError(Exception):
|
|
pass
|
|
|
|
|
|
class BadChunkingOptionError(Exception):
|
|
pass
|
|
|
|
|
|
class NumOutOfRangeError(Exception):
|
|
pass
|
|
|
|
|
|
class BadUserDefinedPatternError(Exception):
|
|
pass
|
|
|
|
|
|
class BadRcFileError(Exception):
|
|
pass
|
|
|
|
|
|
class BadGenderError(Exception):
|
|
pass
|
|
|
|
|
|
def enclose(s: str) -> str:
|
|
return f"(?:{s})"
|
|
|
|
|
|
def joinstem(cutpoint: Optional[int] = 0, words: Optional[Iterable[str]] = None) -> str:
|
|
"""
|
|
Join stem of each word in words into a string for regex.
|
|
|
|
Each word is truncated at cutpoint.
|
|
|
|
Cutpoint is usually negative indicating the number of letters to remove
|
|
from the end of each word.
|
|
|
|
>>> joinstem(-2, ["ephemeris", "iris", ".*itis"])
|
|
'(?:ephemer|ir|.*it)'
|
|
|
|
>>> joinstem(None, ["ephemeris"])
|
|
'(?:ephemeris)'
|
|
|
|
>>> joinstem(5, None)
|
|
'(?:)'
|
|
"""
|
|
return enclose("|".join(w[:cutpoint] for w in words or []))
|
|
|
|
|
|
def bysize(words: Iterable[str]) -> Dict[int, set]:
|
|
"""
|
|
From a list of words, return a dict of sets sorted by word length.
|
|
|
|
>>> words = ['ant', 'cat', 'dog', 'pig', 'frog', 'goat', 'horse', 'elephant']
|
|
>>> ret = bysize(words)
|
|
>>> sorted(ret[3])
|
|
['ant', 'cat', 'dog', 'pig']
|
|
>>> ret[5]
|
|
{'horse'}
|
|
"""
|
|
res: Dict[int, set] = collections.defaultdict(set)
|
|
for w in words:
|
|
res[len(w)].add(w)
|
|
return res
|
|
|
|
|
|
def make_pl_si_lists(
|
|
lst: Iterable[str],
|
|
plending: str,
|
|
siendingsize: Optional[int],
|
|
dojoinstem: bool = True,
|
|
):
|
|
"""
|
|
given a list of singular words: lst
|
|
|
|
an ending to append to make the plural: plending
|
|
|
|
the number of characters to remove from the singular
|
|
before appending plending: siendingsize
|
|
|
|
a flag whether to create a joinstem: dojoinstem
|
|
|
|
return:
|
|
a list of pluralised words: si_list (called si because this is what you need to
|
|
look for to make the singular)
|
|
|
|
the pluralised words as a dict of sets sorted by word length: si_bysize
|
|
the singular words as a dict of sets sorted by word length: pl_bysize
|
|
if dojoinstem is True: a regular expression that matches any of the stems: stem
|
|
"""
|
|
if siendingsize is not None:
|
|
siendingsize = -siendingsize
|
|
si_list = [w[:siendingsize] + plending for w in lst]
|
|
pl_bysize = bysize(lst)
|
|
si_bysize = bysize(si_list)
|
|
if dojoinstem:
|
|
stem = joinstem(siendingsize, lst)
|
|
return si_list, si_bysize, pl_bysize, stem
|
|
else:
|
|
return si_list, si_bysize, pl_bysize
|
|
|
|
|
|
# 1. PLURALS
|
|
|
|
pl_sb_irregular_s = {
|
|
"corpus": "corpuses|corpora",
|
|
"opus": "opuses|opera",
|
|
"genus": "genera",
|
|
"mythos": "mythoi",
|
|
"penis": "penises|penes",
|
|
"testis": "testes",
|
|
"atlas": "atlases|atlantes",
|
|
"yes": "yeses",
|
|
}
|
|
|
|
pl_sb_irregular = {
|
|
"child": "children",
|
|
"chili": "chilis|chilies",
|
|
"brother": "brothers|brethren",
|
|
"infinity": "infinities|infinity",
|
|
"loaf": "loaves",
|
|
"lore": "lores|lore",
|
|
"hoof": "hoofs|hooves",
|
|
"beef": "beefs|beeves",
|
|
"thief": "thiefs|thieves",
|
|
"money": "monies",
|
|
"mongoose": "mongooses",
|
|
"ox": "oxen",
|
|
"cow": "cows|kine",
|
|
"graffito": "graffiti",
|
|
"octopus": "octopuses|octopodes",
|
|
"genie": "genies|genii",
|
|
"ganglion": "ganglions|ganglia",
|
|
"trilby": "trilbys",
|
|
"turf": "turfs|turves",
|
|
"numen": "numina",
|
|
"atman": "atmas",
|
|
"occiput": "occiputs|occipita",
|
|
"sabretooth": "sabretooths",
|
|
"sabertooth": "sabertooths",
|
|
"lowlife": "lowlifes",
|
|
"flatfoot": "flatfoots",
|
|
"tenderfoot": "tenderfoots",
|
|
"romany": "romanies",
|
|
"jerry": "jerries",
|
|
"mary": "maries",
|
|
"talouse": "talouses",
|
|
"rom": "roma",
|
|
"carmen": "carmina",
|
|
}
|
|
|
|
pl_sb_irregular.update(pl_sb_irregular_s)
|
|
# pl_sb_irregular_keys = enclose('|'.join(pl_sb_irregular.keys()))
|
|
|
|
pl_sb_irregular_caps = {
|
|
"Romany": "Romanies",
|
|
"Jerry": "Jerrys",
|
|
"Mary": "Marys",
|
|
"Rom": "Roma",
|
|
}
|
|
|
|
pl_sb_irregular_compound = {"prima donna": "prima donnas|prime donne"}
|
|
|
|
si_sb_irregular = {v: k for (k, v) in pl_sb_irregular.items()}
|
|
for k in list(si_sb_irregular):
|
|
if "|" in k:
|
|
k1, k2 = k.split("|")
|
|
si_sb_irregular[k1] = si_sb_irregular[k2] = si_sb_irregular[k]
|
|
del si_sb_irregular[k]
|
|
si_sb_irregular_caps = {v: k for (k, v) in pl_sb_irregular_caps.items()}
|
|
si_sb_irregular_compound = {v: k for (k, v) in pl_sb_irregular_compound.items()}
|
|
for k in list(si_sb_irregular_compound):
|
|
if "|" in k:
|
|
k1, k2 = k.split("|")
|
|
si_sb_irregular_compound[k1] = si_sb_irregular_compound[k2] = (
|
|
si_sb_irregular_compound[k]
|
|
)
|
|
del si_sb_irregular_compound[k]
|
|
|
|
# si_sb_irregular_keys = enclose('|'.join(si_sb_irregular.keys()))
|
|
|
|
# Z's that don't double
|
|
|
|
pl_sb_z_zes_list = ("quartz", "topaz")
|
|
pl_sb_z_zes_bysize = bysize(pl_sb_z_zes_list)
|
|
|
|
pl_sb_ze_zes_list = ("snooze",)
|
|
pl_sb_ze_zes_bysize = bysize(pl_sb_ze_zes_list)
|
|
|
|
|
|
# CLASSICAL "..is" -> "..ides"
|
|
|
|
pl_sb_C_is_ides_complete = [
|
|
# GENERAL WORDS...
|
|
"ephemeris",
|
|
"iris",
|
|
"clitoris",
|
|
"chrysalis",
|
|
"epididymis",
|
|
]
|
|
|
|
pl_sb_C_is_ides_endings = [
|
|
# INFLAMATIONS...
|
|
"itis"
|
|
]
|
|
|
|
pl_sb_C_is_ides = joinstem(
|
|
-2, pl_sb_C_is_ides_complete + [f".*{w}" for w in pl_sb_C_is_ides_endings]
|
|
)
|
|
|
|
pl_sb_C_is_ides_list = pl_sb_C_is_ides_complete + pl_sb_C_is_ides_endings
|
|
|
|
(
|
|
si_sb_C_is_ides_list,
|
|
si_sb_C_is_ides_bysize,
|
|
pl_sb_C_is_ides_bysize,
|
|
) = make_pl_si_lists(pl_sb_C_is_ides_list, "ides", 2, dojoinstem=False)
|
|
|
|
|
|
# CLASSICAL "..a" -> "..ata"
|
|
|
|
pl_sb_C_a_ata_list = (
|
|
"anathema",
|
|
"bema",
|
|
"carcinoma",
|
|
"charisma",
|
|
"diploma",
|
|
"dogma",
|
|
"drama",
|
|
"edema",
|
|
"enema",
|
|
"enigma",
|
|
"lemma",
|
|
"lymphoma",
|
|
"magma",
|
|
"melisma",
|
|
"miasma",
|
|
"oedema",
|
|
"sarcoma",
|
|
"schema",
|
|
"soma",
|
|
"stigma",
|
|
"stoma",
|
|
"trauma",
|
|
"gumma",
|
|
"pragma",
|
|
)
|
|
|
|
(
|
|
si_sb_C_a_ata_list,
|
|
si_sb_C_a_ata_bysize,
|
|
pl_sb_C_a_ata_bysize,
|
|
pl_sb_C_a_ata,
|
|
) = make_pl_si_lists(pl_sb_C_a_ata_list, "ata", 1)
|
|
|
|
# UNCONDITIONAL "..a" -> "..ae"
|
|
|
|
pl_sb_U_a_ae_list = (
|
|
"alumna",
|
|
"alga",
|
|
"vertebra",
|
|
"persona",
|
|
"vita",
|
|
)
|
|
(
|
|
si_sb_U_a_ae_list,
|
|
si_sb_U_a_ae_bysize,
|
|
pl_sb_U_a_ae_bysize,
|
|
pl_sb_U_a_ae,
|
|
) = make_pl_si_lists(pl_sb_U_a_ae_list, "e", None)
|
|
|
|
# CLASSICAL "..a" -> "..ae"
|
|
|
|
pl_sb_C_a_ae_list = (
|
|
"amoeba",
|
|
"antenna",
|
|
"formula",
|
|
"hyperbola",
|
|
"medusa",
|
|
"nebula",
|
|
"parabola",
|
|
"abscissa",
|
|
"hydra",
|
|
"nova",
|
|
"lacuna",
|
|
"aurora",
|
|
"umbra",
|
|
"flora",
|
|
"fauna",
|
|
)
|
|
(
|
|
si_sb_C_a_ae_list,
|
|
si_sb_C_a_ae_bysize,
|
|
pl_sb_C_a_ae_bysize,
|
|
pl_sb_C_a_ae,
|
|
) = make_pl_si_lists(pl_sb_C_a_ae_list, "e", None)
|
|
|
|
|
|
# CLASSICAL "..en" -> "..ina"
|
|
|
|
pl_sb_C_en_ina_list = ("stamen", "foramen", "lumen")
|
|
|
|
(
|
|
si_sb_C_en_ina_list,
|
|
si_sb_C_en_ina_bysize,
|
|
pl_sb_C_en_ina_bysize,
|
|
pl_sb_C_en_ina,
|
|
) = make_pl_si_lists(pl_sb_C_en_ina_list, "ina", 2)
|
|
|
|
|
|
# UNCONDITIONAL "..um" -> "..a"
|
|
|
|
pl_sb_U_um_a_list = (
|
|
"bacterium",
|
|
"agendum",
|
|
"desideratum",
|
|
"erratum",
|
|
"stratum",
|
|
"datum",
|
|
"ovum",
|
|
"extremum",
|
|
"candelabrum",
|
|
)
|
|
(
|
|
si_sb_U_um_a_list,
|
|
si_sb_U_um_a_bysize,
|
|
pl_sb_U_um_a_bysize,
|
|
pl_sb_U_um_a,
|
|
) = make_pl_si_lists(pl_sb_U_um_a_list, "a", 2)
|
|
|
|
# CLASSICAL "..um" -> "..a"
|
|
|
|
pl_sb_C_um_a_list = (
|
|
"maximum",
|
|
"minimum",
|
|
"momentum",
|
|
"optimum",
|
|
"quantum",
|
|
"cranium",
|
|
"curriculum",
|
|
"dictum",
|
|
"phylum",
|
|
"aquarium",
|
|
"compendium",
|
|
"emporium",
|
|
"encomium",
|
|
"gymnasium",
|
|
"honorarium",
|
|
"interregnum",
|
|
"lustrum",
|
|
"memorandum",
|
|
"millennium",
|
|
"rostrum",
|
|
"spectrum",
|
|
"speculum",
|
|
"stadium",
|
|
"trapezium",
|
|
"ultimatum",
|
|
"medium",
|
|
"vacuum",
|
|
"velum",
|
|
"consortium",
|
|
"arboretum",
|
|
)
|
|
|
|
(
|
|
si_sb_C_um_a_list,
|
|
si_sb_C_um_a_bysize,
|
|
pl_sb_C_um_a_bysize,
|
|
pl_sb_C_um_a,
|
|
) = make_pl_si_lists(pl_sb_C_um_a_list, "a", 2)
|
|
|
|
|
|
# UNCONDITIONAL "..us" -> "i"
|
|
|
|
pl_sb_U_us_i_list = (
|
|
"alumnus",
|
|
"alveolus",
|
|
"bacillus",
|
|
"bronchus",
|
|
"locus",
|
|
"nucleus",
|
|
"stimulus",
|
|
"meniscus",
|
|
"sarcophagus",
|
|
)
|
|
(
|
|
si_sb_U_us_i_list,
|
|
si_sb_U_us_i_bysize,
|
|
pl_sb_U_us_i_bysize,
|
|
pl_sb_U_us_i,
|
|
) = make_pl_si_lists(pl_sb_U_us_i_list, "i", 2)
|
|
|
|
# CLASSICAL "..us" -> "..i"
|
|
|
|
pl_sb_C_us_i_list = (
|
|
"focus",
|
|
"radius",
|
|
"genius",
|
|
"incubus",
|
|
"succubus",
|
|
"nimbus",
|
|
"fungus",
|
|
"nucleolus",
|
|
"stylus",
|
|
"torus",
|
|
"umbilicus",
|
|
"uterus",
|
|
"hippopotamus",
|
|
"cactus",
|
|
)
|
|
|
|
(
|
|
si_sb_C_us_i_list,
|
|
si_sb_C_us_i_bysize,
|
|
pl_sb_C_us_i_bysize,
|
|
pl_sb_C_us_i,
|
|
) = make_pl_si_lists(pl_sb_C_us_i_list, "i", 2)
|
|
|
|
|
|
# CLASSICAL "..us" -> "..us" (ASSIMILATED 4TH DECLENSION LATIN NOUNS)
|
|
|
|
pl_sb_C_us_us = (
|
|
"status",
|
|
"apparatus",
|
|
"prospectus",
|
|
"sinus",
|
|
"hiatus",
|
|
"impetus",
|
|
"plexus",
|
|
)
|
|
pl_sb_C_us_us_bysize = bysize(pl_sb_C_us_us)
|
|
|
|
# UNCONDITIONAL "..on" -> "a"
|
|
|
|
pl_sb_U_on_a_list = (
|
|
"criterion",
|
|
"perihelion",
|
|
"aphelion",
|
|
"phenomenon",
|
|
"prolegomenon",
|
|
"noumenon",
|
|
"organon",
|
|
"asyndeton",
|
|
"hyperbaton",
|
|
)
|
|
(
|
|
si_sb_U_on_a_list,
|
|
si_sb_U_on_a_bysize,
|
|
pl_sb_U_on_a_bysize,
|
|
pl_sb_U_on_a,
|
|
) = make_pl_si_lists(pl_sb_U_on_a_list, "a", 2)
|
|
|
|
# CLASSICAL "..on" -> "..a"
|
|
|
|
pl_sb_C_on_a_list = ("oxymoron",)
|
|
|
|
(
|
|
si_sb_C_on_a_list,
|
|
si_sb_C_on_a_bysize,
|
|
pl_sb_C_on_a_bysize,
|
|
pl_sb_C_on_a,
|
|
) = make_pl_si_lists(pl_sb_C_on_a_list, "a", 2)
|
|
|
|
|
|
# CLASSICAL "..o" -> "..i" (BUT NORMALLY -> "..os")
|
|
|
|
pl_sb_C_o_i = [
|
|
"solo",
|
|
"soprano",
|
|
"basso",
|
|
"alto",
|
|
"contralto",
|
|
"tempo",
|
|
"piano",
|
|
"virtuoso",
|
|
] # list not tuple so can concat for pl_sb_U_o_os
|
|
|
|
pl_sb_C_o_i_bysize = bysize(pl_sb_C_o_i)
|
|
si_sb_C_o_i_bysize = bysize([f"{w[:-1]}i" for w in pl_sb_C_o_i])
|
|
|
|
pl_sb_C_o_i_stems = joinstem(-1, pl_sb_C_o_i)
|
|
|
|
# ALWAYS "..o" -> "..os"
|
|
|
|
pl_sb_U_o_os_complete = {"ado", "ISO", "NATO", "NCO", "NGO", "oto"}
|
|
si_sb_U_o_os_complete = {f"{w}s" for w in pl_sb_U_o_os_complete}
|
|
|
|
|
|
pl_sb_U_o_os_endings = [
|
|
"aficionado",
|
|
"aggro",
|
|
"albino",
|
|
"allegro",
|
|
"ammo",
|
|
"Antananarivo",
|
|
"archipelago",
|
|
"armadillo",
|
|
"auto",
|
|
"avocado",
|
|
"Bamako",
|
|
"Barquisimeto",
|
|
"bimbo",
|
|
"bingo",
|
|
"Biro",
|
|
"bolero",
|
|
"Bolzano",
|
|
"bongo",
|
|
"Boto",
|
|
"burro",
|
|
"Cairo",
|
|
"canto",
|
|
"cappuccino",
|
|
"casino",
|
|
"cello",
|
|
"Chicago",
|
|
"Chimango",
|
|
"cilantro",
|
|
"cochito",
|
|
"coco",
|
|
"Colombo",
|
|
"Colorado",
|
|
"commando",
|
|
"concertino",
|
|
"contango",
|
|
"credo",
|
|
"crescendo",
|
|
"cyano",
|
|
"demo",
|
|
"ditto",
|
|
"Draco",
|
|
"dynamo",
|
|
"embryo",
|
|
"Esperanto",
|
|
"espresso",
|
|
"euro",
|
|
"falsetto",
|
|
"Faro",
|
|
"fiasco",
|
|
"Filipino",
|
|
"flamenco",
|
|
"furioso",
|
|
"generalissimo",
|
|
"Gestapo",
|
|
"ghetto",
|
|
"gigolo",
|
|
"gizmo",
|
|
"Greensboro",
|
|
"gringo",
|
|
"Guaiabero",
|
|
"guano",
|
|
"gumbo",
|
|
"gyro",
|
|
"hairdo",
|
|
"hippo",
|
|
"Idaho",
|
|
"impetigo",
|
|
"inferno",
|
|
"info",
|
|
"intermezzo",
|
|
"intertrigo",
|
|
"Iquico",
|
|
"jumbo",
|
|
"junto",
|
|
"Kakapo",
|
|
"kilo",
|
|
"Kinkimavo",
|
|
"Kokako",
|
|
"Kosovo",
|
|
"Lesotho",
|
|
"libero",
|
|
"libido",
|
|
"libretto",
|
|
"lido",
|
|
"Lilo",
|
|
"limbo",
|
|
"limo",
|
|
"lineno",
|
|
"lingo",
|
|
"lino",
|
|
"livedo",
|
|
"loco",
|
|
"logo",
|
|
"lumbago",
|
|
"macho",
|
|
"macro",
|
|
"mafioso",
|
|
"magneto",
|
|
"magnifico",
|
|
"Majuro",
|
|
"Malabo",
|
|
"manifesto",
|
|
"Maputo",
|
|
"Maracaibo",
|
|
"medico",
|
|
"memo",
|
|
"metro",
|
|
"Mexico",
|
|
"micro",
|
|
"Milano",
|
|
"Monaco",
|
|
"mono",
|
|
"Montenegro",
|
|
"Morocco",
|
|
"Muqdisho",
|
|
"myo",
|
|
"neutrino",
|
|
"Ningbo",
|
|
"octavo",
|
|
"oregano",
|
|
"Orinoco",
|
|
"Orlando",
|
|
"Oslo",
|
|
"panto",
|
|
"Paramaribo",
|
|
"Pardusco",
|
|
"pedalo",
|
|
"photo",
|
|
"pimento",
|
|
"pinto",
|
|
"pleco",
|
|
"Pluto",
|
|
"pogo",
|
|
"polo",
|
|
"poncho",
|
|
"Porto-Novo",
|
|
"Porto",
|
|
"pro",
|
|
"psycho",
|
|
"pueblo",
|
|
"quarto",
|
|
"Quito",
|
|
"repo",
|
|
"rhino",
|
|
"risotto",
|
|
"rococo",
|
|
"rondo",
|
|
"Sacramento",
|
|
"saddo",
|
|
"sago",
|
|
"salvo",
|
|
"Santiago",
|
|
"Sapporo",
|
|
"Sarajevo",
|
|
"scherzando",
|
|
"scherzo",
|
|
"silo",
|
|
"sirocco",
|
|
"sombrero",
|
|
"staccato",
|
|
"sterno",
|
|
"stucco",
|
|
"stylo",
|
|
"sumo",
|
|
"Taiko",
|
|
"techno",
|
|
"terrazzo",
|
|
"testudo",
|
|
"timpano",
|
|
"tiro",
|
|
"tobacco",
|
|
"Togo",
|
|
"Tokyo",
|
|
"torero",
|
|
"Torino",
|
|
"Toronto",
|
|
"torso",
|
|
"tremolo",
|
|
"typo",
|
|
"tyro",
|
|
"ufo",
|
|
"UNESCO",
|
|
"vaquero",
|
|
"vermicello",
|
|
"verso",
|
|
"vibrato",
|
|
"violoncello",
|
|
"Virgo",
|
|
"weirdo",
|
|
"WHO",
|
|
"WTO",
|
|
"Yamoussoukro",
|
|
"yo-yo",
|
|
"zero",
|
|
"Zibo",
|
|
] + pl_sb_C_o_i
|
|
|
|
pl_sb_U_o_os_bysize = bysize(pl_sb_U_o_os_endings)
|
|
si_sb_U_o_os_bysize = bysize([f"{w}s" for w in pl_sb_U_o_os_endings])
|
|
|
|
|
|
# UNCONDITIONAL "..ch" -> "..chs"
|
|
|
|
pl_sb_U_ch_chs_list = ("czech", "eunuch", "stomach")
|
|
|
|
(
|
|
si_sb_U_ch_chs_list,
|
|
si_sb_U_ch_chs_bysize,
|
|
pl_sb_U_ch_chs_bysize,
|
|
pl_sb_U_ch_chs,
|
|
) = make_pl_si_lists(pl_sb_U_ch_chs_list, "s", None)
|
|
|
|
|
|
# UNCONDITIONAL "..[ei]x" -> "..ices"
|
|
|
|
pl_sb_U_ex_ices_list = ("codex", "murex", "silex")
|
|
(
|
|
si_sb_U_ex_ices_list,
|
|
si_sb_U_ex_ices_bysize,
|
|
pl_sb_U_ex_ices_bysize,
|
|
pl_sb_U_ex_ices,
|
|
) = make_pl_si_lists(pl_sb_U_ex_ices_list, "ices", 2)
|
|
|
|
pl_sb_U_ix_ices_list = ("radix", "helix")
|
|
(
|
|
si_sb_U_ix_ices_list,
|
|
si_sb_U_ix_ices_bysize,
|
|
pl_sb_U_ix_ices_bysize,
|
|
pl_sb_U_ix_ices,
|
|
) = make_pl_si_lists(pl_sb_U_ix_ices_list, "ices", 2)
|
|
|
|
# CLASSICAL "..[ei]x" -> "..ices"
|
|
|
|
pl_sb_C_ex_ices_list = (
|
|
"vortex",
|
|
"vertex",
|
|
"cortex",
|
|
"latex",
|
|
"pontifex",
|
|
"apex",
|
|
"index",
|
|
"simplex",
|
|
)
|
|
|
|
(
|
|
si_sb_C_ex_ices_list,
|
|
si_sb_C_ex_ices_bysize,
|
|
pl_sb_C_ex_ices_bysize,
|
|
pl_sb_C_ex_ices,
|
|
) = make_pl_si_lists(pl_sb_C_ex_ices_list, "ices", 2)
|
|
|
|
|
|
pl_sb_C_ix_ices_list = ("appendix",)
|
|
|
|
(
|
|
si_sb_C_ix_ices_list,
|
|
si_sb_C_ix_ices_bysize,
|
|
pl_sb_C_ix_ices_bysize,
|
|
pl_sb_C_ix_ices,
|
|
) = make_pl_si_lists(pl_sb_C_ix_ices_list, "ices", 2)
|
|
|
|
|
|
# ARABIC: ".." -> "..i"
|
|
|
|
pl_sb_C_i_list = ("afrit", "afreet", "efreet")
|
|
|
|
(si_sb_C_i_list, si_sb_C_i_bysize, pl_sb_C_i_bysize, pl_sb_C_i) = make_pl_si_lists(
|
|
pl_sb_C_i_list, "i", None
|
|
)
|
|
|
|
|
|
# HEBREW: ".." -> "..im"
|
|
|
|
pl_sb_C_im_list = ("goy", "seraph", "cherub")
|
|
|
|
(si_sb_C_im_list, si_sb_C_im_bysize, pl_sb_C_im_bysize, pl_sb_C_im) = make_pl_si_lists(
|
|
pl_sb_C_im_list, "im", None
|
|
)
|
|
|
|
|
|
# UNCONDITIONAL "..man" -> "..mans"
|
|
|
|
pl_sb_U_man_mans_list = """
|
|
ataman caiman cayman ceriman
|
|
desman dolman farman harman hetman
|
|
human leman ottoman shaman talisman
|
|
""".split()
|
|
pl_sb_U_man_mans_caps_list = """
|
|
Alabaman Bahaman Burman German
|
|
Hiroshiman Liman Nakayaman Norman Oklahoman
|
|
Panaman Roman Selman Sonaman Tacoman Yakiman
|
|
Yokohaman Yuman
|
|
""".split()
|
|
|
|
(
|
|
si_sb_U_man_mans_list,
|
|
si_sb_U_man_mans_bysize,
|
|
pl_sb_U_man_mans_bysize,
|
|
) = make_pl_si_lists(pl_sb_U_man_mans_list, "s", None, dojoinstem=False)
|
|
(
|
|
si_sb_U_man_mans_caps_list,
|
|
si_sb_U_man_mans_caps_bysize,
|
|
pl_sb_U_man_mans_caps_bysize,
|
|
) = make_pl_si_lists(pl_sb_U_man_mans_caps_list, "s", None, dojoinstem=False)
|
|
|
|
# UNCONDITIONAL "..louse" -> "..lice"
|
|
pl_sb_U_louse_lice_list = ("booklouse", "grapelouse", "louse", "woodlouse")
|
|
|
|
(
|
|
si_sb_U_louse_lice_list,
|
|
si_sb_U_louse_lice_bysize,
|
|
pl_sb_U_louse_lice_bysize,
|
|
) = make_pl_si_lists(pl_sb_U_louse_lice_list, "lice", 5, dojoinstem=False)
|
|
|
|
pl_sb_uninflected_s_complete = [
|
|
# PAIRS OR GROUPS SUBSUMED TO A SINGULAR...
|
|
"breeches",
|
|
"britches",
|
|
"pajamas",
|
|
"pyjamas",
|
|
"clippers",
|
|
"gallows",
|
|
"hijinks",
|
|
"headquarters",
|
|
"pliers",
|
|
"scissors",
|
|
"testes",
|
|
"herpes",
|
|
"pincers",
|
|
"shears",
|
|
"proceedings",
|
|
"trousers",
|
|
# UNASSIMILATED LATIN 4th DECLENSION
|
|
"cantus",
|
|
"coitus",
|
|
"nexus",
|
|
# RECENT IMPORTS...
|
|
"contretemps",
|
|
"corps",
|
|
"debris",
|
|
"siemens",
|
|
# DISEASES
|
|
"mumps",
|
|
# MISCELLANEOUS OTHERS...
|
|
"diabetes",
|
|
"jackanapes",
|
|
"series",
|
|
"species",
|
|
"subspecies",
|
|
"rabies",
|
|
"chassis",
|
|
"innings",
|
|
"news",
|
|
"mews",
|
|
"haggis",
|
|
]
|
|
|
|
pl_sb_uninflected_s_endings = [
|
|
# RECENT IMPORTS...
|
|
"ois",
|
|
# DISEASES
|
|
"measles",
|
|
]
|
|
|
|
pl_sb_uninflected_s = pl_sb_uninflected_s_complete + [
|
|
f".*{w}" for w in pl_sb_uninflected_s_endings
|
|
]
|
|
|
|
pl_sb_uninflected_herd = (
|
|
# DON'T INFLECT IN CLASSICAL MODE, OTHERWISE NORMAL INFLECTION
|
|
"wildebeest",
|
|
"swine",
|
|
"eland",
|
|
"bison",
|
|
"buffalo",
|
|
"cattle",
|
|
"elk",
|
|
"rhinoceros",
|
|
"zucchini",
|
|
"caribou",
|
|
"dace",
|
|
"grouse",
|
|
"guinea fowl",
|
|
"guinea-fowl",
|
|
"haddock",
|
|
"hake",
|
|
"halibut",
|
|
"herring",
|
|
"mackerel",
|
|
"pickerel",
|
|
"pike",
|
|
"roe",
|
|
"seed",
|
|
"shad",
|
|
"snipe",
|
|
"teal",
|
|
"turbot",
|
|
"water fowl",
|
|
"water-fowl",
|
|
)
|
|
|
|
pl_sb_uninflected_complete = [
|
|
# SOME FISH AND HERD ANIMALS
|
|
"tuna",
|
|
"salmon",
|
|
"mackerel",
|
|
"trout",
|
|
"bream",
|
|
"sea-bass",
|
|
"sea bass",
|
|
"carp",
|
|
"cod",
|
|
"flounder",
|
|
"whiting",
|
|
"moose",
|
|
# OTHER ODDITIES
|
|
"graffiti",
|
|
"djinn",
|
|
"samuri",
|
|
"offspring",
|
|
"pence",
|
|
"quid",
|
|
"hertz",
|
|
] + pl_sb_uninflected_s_complete
|
|
# SOME WORDS ENDING IN ...s (OFTEN PAIRS TAKEN AS A WHOLE)
|
|
|
|
pl_sb_uninflected_caps = [
|
|
# ALL NATIONALS ENDING IN -ese
|
|
"Portuguese",
|
|
"Amoyese",
|
|
"Borghese",
|
|
"Congoese",
|
|
"Faroese",
|
|
"Foochowese",
|
|
"Genevese",
|
|
"Genoese",
|
|
"Gilbertese",
|
|
"Hottentotese",
|
|
"Kiplingese",
|
|
"Kongoese",
|
|
"Lucchese",
|
|
"Maltese",
|
|
"Nankingese",
|
|
"Niasese",
|
|
"Pekingese",
|
|
"Piedmontese",
|
|
"Pistoiese",
|
|
"Sarawakese",
|
|
"Shavese",
|
|
"Vermontese",
|
|
"Wenchowese",
|
|
"Yengeese",
|
|
]
|
|
|
|
|
|
pl_sb_uninflected_endings = [
|
|
# UNCOUNTABLE NOUNS
|
|
"butter",
|
|
"cash",
|
|
"furniture",
|
|
"information",
|
|
# SOME FISH AND HERD ANIMALS
|
|
"fish",
|
|
"deer",
|
|
"sheep",
|
|
# ALL NATIONALS ENDING IN -ese
|
|
"nese",
|
|
"rese",
|
|
"lese",
|
|
"mese",
|
|
# DISEASES
|
|
"pox",
|
|
# OTHER ODDITIES
|
|
"craft",
|
|
] + pl_sb_uninflected_s_endings
|
|
# SOME WORDS ENDING IN ...s (OFTEN PAIRS TAKEN AS A WHOLE)
|
|
|
|
|
|
pl_sb_uninflected_bysize = bysize(pl_sb_uninflected_endings)
|
|
|
|
|
|
# SINGULAR WORDS ENDING IN ...s (ALL INFLECT WITH ...es)
|
|
|
|
pl_sb_singular_s_complete = [
|
|
"acropolis",
|
|
"aegis",
|
|
"alias",
|
|
"asbestos",
|
|
"bathos",
|
|
"bias",
|
|
"bronchitis",
|
|
"bursitis",
|
|
"caddis",
|
|
"cannabis",
|
|
"canvas",
|
|
"chaos",
|
|
"cosmos",
|
|
"dais",
|
|
"digitalis",
|
|
"epidermis",
|
|
"ethos",
|
|
"eyas",
|
|
"gas",
|
|
"glottis",
|
|
"hubris",
|
|
"ibis",
|
|
"lens",
|
|
"mantis",
|
|
"marquis",
|
|
"metropolis",
|
|
"pathos",
|
|
"pelvis",
|
|
"polis",
|
|
"rhinoceros",
|
|
"sassafras",
|
|
"trellis",
|
|
] + pl_sb_C_is_ides_complete
|
|
|
|
|
|
pl_sb_singular_s_endings = ["ss", "us"] + pl_sb_C_is_ides_endings
|
|
|
|
pl_sb_singular_s_bysize = bysize(pl_sb_singular_s_endings)
|
|
|
|
si_sb_singular_s_complete = [f"{w}es" for w in pl_sb_singular_s_complete]
|
|
si_sb_singular_s_endings = [f"{w}es" for w in pl_sb_singular_s_endings]
|
|
si_sb_singular_s_bysize = bysize(si_sb_singular_s_endings)
|
|
|
|
pl_sb_singular_s_es = ["[A-Z].*es"]
|
|
|
|
pl_sb_singular_s = enclose(
|
|
"|".join(
|
|
pl_sb_singular_s_complete
|
|
+ [f".*{w}" for w in pl_sb_singular_s_endings]
|
|
+ pl_sb_singular_s_es
|
|
)
|
|
)
|
|
|
|
|
|
# PLURALS ENDING IN uses -> use
|
|
|
|
|
|
si_sb_ois_oi_case = ("Bolshois", "Hanois")
|
|
|
|
si_sb_uses_use_case = ("Betelgeuses", "Duses", "Meuses", "Syracuses", "Toulouses")
|
|
|
|
si_sb_uses_use = (
|
|
"abuses",
|
|
"applauses",
|
|
"blouses",
|
|
"carouses",
|
|
"causes",
|
|
"chartreuses",
|
|
"clauses",
|
|
"contuses",
|
|
"douses",
|
|
"excuses",
|
|
"fuses",
|
|
"grouses",
|
|
"hypotenuses",
|
|
"masseuses",
|
|
"menopauses",
|
|
"misuses",
|
|
"muses",
|
|
"overuses",
|
|
"pauses",
|
|
"peruses",
|
|
"profuses",
|
|
"recluses",
|
|
"reuses",
|
|
"ruses",
|
|
"souses",
|
|
"spouses",
|
|
"suffuses",
|
|
"transfuses",
|
|
"uses",
|
|
)
|
|
|
|
si_sb_ies_ie_case = (
|
|
"Addies",
|
|
"Aggies",
|
|
"Allies",
|
|
"Amies",
|
|
"Angies",
|
|
"Annies",
|
|
"Annmaries",
|
|
"Archies",
|
|
"Arties",
|
|
"Aussies",
|
|
"Barbies",
|
|
"Barries",
|
|
"Basies",
|
|
"Bennies",
|
|
"Bernies",
|
|
"Berties",
|
|
"Bessies",
|
|
"Betties",
|
|
"Billies",
|
|
"Blondies",
|
|
"Bobbies",
|
|
"Bonnies",
|
|
"Bowies",
|
|
"Brandies",
|
|
"Bries",
|
|
"Brownies",
|
|
"Callies",
|
|
"Carnegies",
|
|
"Carries",
|
|
"Cassies",
|
|
"Charlies",
|
|
"Cheries",
|
|
"Christies",
|
|
"Connies",
|
|
"Curies",
|
|
"Dannies",
|
|
"Debbies",
|
|
"Dixies",
|
|
"Dollies",
|
|
"Donnies",
|
|
"Drambuies",
|
|
"Eddies",
|
|
"Effies",
|
|
"Ellies",
|
|
"Elsies",
|
|
"Eries",
|
|
"Ernies",
|
|
"Essies",
|
|
"Eugenies",
|
|
"Fannies",
|
|
"Flossies",
|
|
"Frankies",
|
|
"Freddies",
|
|
"Gillespies",
|
|
"Goldies",
|
|
"Gracies",
|
|
"Guthries",
|
|
"Hallies",
|
|
"Hatties",
|
|
"Hetties",
|
|
"Hollies",
|
|
"Jackies",
|
|
"Jamies",
|
|
"Janies",
|
|
"Jannies",
|
|
"Jeanies",
|
|
"Jeannies",
|
|
"Jennies",
|
|
"Jessies",
|
|
"Jimmies",
|
|
"Jodies",
|
|
"Johnies",
|
|
"Johnnies",
|
|
"Josies",
|
|
"Julies",
|
|
"Kalgoorlies",
|
|
"Kathies",
|
|
"Katies",
|
|
"Kellies",
|
|
"Kewpies",
|
|
"Kristies",
|
|
"Laramies",
|
|
"Lassies",
|
|
"Lauries",
|
|
"Leslies",
|
|
"Lessies",
|
|
"Lillies",
|
|
"Lizzies",
|
|
"Lonnies",
|
|
"Lories",
|
|
"Lorries",
|
|
"Lotties",
|
|
"Louies",
|
|
"Mackenzies",
|
|
"Maggies",
|
|
"Maisies",
|
|
"Mamies",
|
|
"Marcies",
|
|
"Margies",
|
|
"Maries",
|
|
"Marjories",
|
|
"Matties",
|
|
"McKenzies",
|
|
"Melanies",
|
|
"Mickies",
|
|
"Millies",
|
|
"Minnies",
|
|
"Mollies",
|
|
"Mounties",
|
|
"Nannies",
|
|
"Natalies",
|
|
"Nellies",
|
|
"Netties",
|
|
"Ollies",
|
|
"Ozzies",
|
|
"Pearlies",
|
|
"Pottawatomies",
|
|
"Reggies",
|
|
"Richies",
|
|
"Rickies",
|
|
"Robbies",
|
|
"Ronnies",
|
|
"Rosalies",
|
|
"Rosemaries",
|
|
"Rosies",
|
|
"Roxies",
|
|
"Rushdies",
|
|
"Ruthies",
|
|
"Sadies",
|
|
"Sallies",
|
|
"Sammies",
|
|
"Scotties",
|
|
"Selassies",
|
|
"Sherries",
|
|
"Sophies",
|
|
"Stacies",
|
|
"Stefanies",
|
|
"Stephanies",
|
|
"Stevies",
|
|
"Susies",
|
|
"Sylvies",
|
|
"Tammies",
|
|
"Terries",
|
|
"Tessies",
|
|
"Tommies",
|
|
"Tracies",
|
|
"Trekkies",
|
|
"Valaries",
|
|
"Valeries",
|
|
"Valkyries",
|
|
"Vickies",
|
|
"Virgies",
|
|
"Willies",
|
|
"Winnies",
|
|
"Wylies",
|
|
"Yorkies",
|
|
)
|
|
|
|
si_sb_ies_ie = (
|
|
"aeries",
|
|
"baggies",
|
|
"belies",
|
|
"biggies",
|
|
"birdies",
|
|
"bogies",
|
|
"bonnies",
|
|
"boogies",
|
|
"bookies",
|
|
"bourgeoisies",
|
|
"brownies",
|
|
"budgies",
|
|
"caddies",
|
|
"calories",
|
|
"camaraderies",
|
|
"cockamamies",
|
|
"collies",
|
|
"cookies",
|
|
"coolies",
|
|
"cooties",
|
|
"coteries",
|
|
"crappies",
|
|
"curies",
|
|
"cutesies",
|
|
"dogies",
|
|
"eyries",
|
|
"floozies",
|
|
"footsies",
|
|
"freebies",
|
|
"genies",
|
|
"goalies",
|
|
"groupies",
|
|
"hies",
|
|
"jalousies",
|
|
"junkies",
|
|
"kiddies",
|
|
"laddies",
|
|
"lassies",
|
|
"lies",
|
|
"lingeries",
|
|
"magpies",
|
|
"menageries",
|
|
"mommies",
|
|
"movies",
|
|
"neckties",
|
|
"newbies",
|
|
"nighties",
|
|
"oldies",
|
|
"organdies",
|
|
"overlies",
|
|
"pies",
|
|
"pinkies",
|
|
"pixies",
|
|
"potpies",
|
|
"prairies",
|
|
"quickies",
|
|
"reveries",
|
|
"rookies",
|
|
"rotisseries",
|
|
"softies",
|
|
"sorties",
|
|
"species",
|
|
"stymies",
|
|
"sweeties",
|
|
"ties",
|
|
"underlies",
|
|
"unties",
|
|
"veggies",
|
|
"vies",
|
|
"yuppies",
|
|
"zombies",
|
|
)
|
|
|
|
|
|
si_sb_oes_oe_case = (
|
|
"Chloes",
|
|
"Crusoes",
|
|
"Defoes",
|
|
"Faeroes",
|
|
"Ivanhoes",
|
|
"Joes",
|
|
"McEnroes",
|
|
"Moes",
|
|
"Monroes",
|
|
"Noes",
|
|
"Poes",
|
|
"Roscoes",
|
|
"Tahoes",
|
|
"Tippecanoes",
|
|
"Zoes",
|
|
)
|
|
|
|
si_sb_oes_oe = (
|
|
"aloes",
|
|
"backhoes",
|
|
"canoes",
|
|
"does",
|
|
"floes",
|
|
"foes",
|
|
"hoes",
|
|
"mistletoes",
|
|
"oboes",
|
|
"pekoes",
|
|
"roes",
|
|
"sloes",
|
|
"throes",
|
|
"tiptoes",
|
|
"toes",
|
|
"woes",
|
|
)
|
|
|
|
si_sb_z_zes = ("quartzes", "topazes")
|
|
|
|
si_sb_zzes_zz = ("buzzes", "fizzes", "frizzes", "razzes")
|
|
|
|
si_sb_ches_che_case = (
|
|
"Andromaches",
|
|
"Apaches",
|
|
"Blanches",
|
|
"Comanches",
|
|
"Nietzsches",
|
|
"Porsches",
|
|
"Roches",
|
|
)
|
|
|
|
si_sb_ches_che = (
|
|
"aches",
|
|
"avalanches",
|
|
"backaches",
|
|
"bellyaches",
|
|
"caches",
|
|
"cloches",
|
|
"creches",
|
|
"douches",
|
|
"earaches",
|
|
"fiches",
|
|
"headaches",
|
|
"heartaches",
|
|
"microfiches",
|
|
"niches",
|
|
"pastiches",
|
|
"psyches",
|
|
"quiches",
|
|
"stomachaches",
|
|
"toothaches",
|
|
"tranches",
|
|
)
|
|
|
|
si_sb_xes_xe = ("annexes", "axes", "deluxes", "pickaxes")
|
|
|
|
si_sb_sses_sse_case = ("Hesses", "Jesses", "Larousses", "Matisses")
|
|
si_sb_sses_sse = (
|
|
"bouillabaisses",
|
|
"crevasses",
|
|
"demitasses",
|
|
"impasses",
|
|
"mousses",
|
|
"posses",
|
|
)
|
|
|
|
si_sb_ves_ve_case = (
|
|
# *[nwl]ives -> [nwl]live
|
|
"Clives",
|
|
"Palmolives",
|
|
)
|
|
si_sb_ves_ve = (
|
|
# *[^d]eaves -> eave
|
|
"interweaves",
|
|
"weaves",
|
|
# *[nwl]ives -> [nwl]live
|
|
"olives",
|
|
# *[eoa]lves -> [eoa]lve
|
|
"bivalves",
|
|
"dissolves",
|
|
"resolves",
|
|
"salves",
|
|
"twelves",
|
|
"valves",
|
|
)
|
|
|
|
|
|
plverb_special_s = enclose(
|
|
"|".join(
|
|
[pl_sb_singular_s]
|
|
+ pl_sb_uninflected_s
|
|
+ list(pl_sb_irregular_s)
|
|
+ ["(.*[csx])is", "(.*)ceps", "[A-Z].*s"]
|
|
)
|
|
)
|
|
|
|
_pl_sb_postfix_adj_defn = (
|
|
("general", enclose(r"(?!major|lieutenant|brigadier|adjutant|.*star)\S+")),
|
|
("martial", enclose("court")),
|
|
("force", enclose("pound")),
|
|
)
|
|
|
|
pl_sb_postfix_adj: Iterable[str] = (
|
|
enclose(val + f"(?=(?:-|\\s+){key})") for key, val in _pl_sb_postfix_adj_defn
|
|
)
|
|
|
|
pl_sb_postfix_adj_stems = f"({'|'.join(pl_sb_postfix_adj)})(.*)"
|
|
|
|
|
|
# PLURAL WORDS ENDING IS es GO TO SINGULAR is
|
|
|
|
si_sb_es_is = (
|
|
"amanuenses",
|
|
"amniocenteses",
|
|
"analyses",
|
|
"antitheses",
|
|
"apotheoses",
|
|
"arterioscleroses",
|
|
"atheroscleroses",
|
|
"axes",
|
|
# 'bases', # bases -> basis
|
|
"catalyses",
|
|
"catharses",
|
|
"chasses",
|
|
"cirrhoses",
|
|
"cocces",
|
|
"crises",
|
|
"diagnoses",
|
|
"dialyses",
|
|
"diereses",
|
|
"electrolyses",
|
|
"emphases",
|
|
"exegeses",
|
|
"geneses",
|
|
"halitoses",
|
|
"hydrolyses",
|
|
"hypnoses",
|
|
"hypotheses",
|
|
"hystereses",
|
|
"metamorphoses",
|
|
"metastases",
|
|
"misdiagnoses",
|
|
"mitoses",
|
|
"mononucleoses",
|
|
"narcoses",
|
|
"necroses",
|
|
"nemeses",
|
|
"neuroses",
|
|
"oases",
|
|
"osmoses",
|
|
"osteoporoses",
|
|
"paralyses",
|
|
"parentheses",
|
|
"parthenogeneses",
|
|
"periphrases",
|
|
"photosyntheses",
|
|
"probosces",
|
|
"prognoses",
|
|
"prophylaxes",
|
|
"prostheses",
|
|
"preces",
|
|
"psoriases",
|
|
"psychoanalyses",
|
|
"psychokineses",
|
|
"psychoses",
|
|
"scleroses",
|
|
"scolioses",
|
|
"sepses",
|
|
"silicoses",
|
|
"symbioses",
|
|
"synopses",
|
|
"syntheses",
|
|
"taxes",
|
|
"telekineses",
|
|
"theses",
|
|
"thromboses",
|
|
"tuberculoses",
|
|
"urinalyses",
|
|
)
|
|
|
|
pl_prep_list = """
|
|
about above across after among around at athwart before behind
|
|
below beneath beside besides between betwixt beyond but by
|
|
during except for from in into near of off on onto out over
|
|
since till to under until unto upon with""".split()
|
|
|
|
pl_prep_list_da = pl_prep_list + ["de", "du", "da"]
|
|
|
|
pl_prep_bysize = bysize(pl_prep_list_da)
|
|
|
|
pl_prep = enclose("|".join(pl_prep_list_da))
|
|
|
|
pl_sb_prep_dual_compound = rf"(.*?)((?:-|\s+)(?:{pl_prep})(?:-|\s+))a(?:-|\s+)(.*)"
|
|
|
|
|
|
singular_pronoun_genders = {
|
|
"neuter",
|
|
"feminine",
|
|
"masculine",
|
|
"gender-neutral",
|
|
"feminine or masculine",
|
|
"masculine or feminine",
|
|
}
|
|
|
|
pl_pron_nom = {
|
|
# NOMINATIVE REFLEXIVE
|
|
"i": "we",
|
|
"myself": "ourselves",
|
|
"you": "you",
|
|
"yourself": "yourselves",
|
|
"she": "they",
|
|
"herself": "themselves",
|
|
"he": "they",
|
|
"himself": "themselves",
|
|
"it": "they",
|
|
"itself": "themselves",
|
|
"they": "they",
|
|
"themself": "themselves",
|
|
# POSSESSIVE
|
|
"mine": "ours",
|
|
"yours": "yours",
|
|
"hers": "theirs",
|
|
"his": "theirs",
|
|
"its": "theirs",
|
|
"theirs": "theirs",
|
|
}
|
|
|
|
si_pron: Dict[str, Dict[str, Union[str, Dict[str, str]]]] = {
|
|
"nom": {v: k for (k, v) in pl_pron_nom.items()}
|
|
}
|
|
si_pron["nom"]["we"] = "I"
|
|
|
|
|
|
pl_pron_acc = {
|
|
# ACCUSATIVE REFLEXIVE
|
|
"me": "us",
|
|
"myself": "ourselves",
|
|
"you": "you",
|
|
"yourself": "yourselves",
|
|
"her": "them",
|
|
"herself": "themselves",
|
|
"him": "them",
|
|
"himself": "themselves",
|
|
"it": "them",
|
|
"itself": "themselves",
|
|
"them": "them",
|
|
"themself": "themselves",
|
|
}
|
|
|
|
pl_pron_acc_keys = enclose("|".join(pl_pron_acc))
|
|
pl_pron_acc_keys_bysize = bysize(pl_pron_acc)
|
|
|
|
si_pron["acc"] = {v: k for (k, v) in pl_pron_acc.items()}
|
|
|
|
for _thecase, _plur, _gend, _sing in (
|
|
("nom", "they", "neuter", "it"),
|
|
("nom", "they", "feminine", "she"),
|
|
("nom", "they", "masculine", "he"),
|
|
("nom", "they", "gender-neutral", "they"),
|
|
("nom", "they", "feminine or masculine", "she or he"),
|
|
("nom", "they", "masculine or feminine", "he or she"),
|
|
("nom", "themselves", "neuter", "itself"),
|
|
("nom", "themselves", "feminine", "herself"),
|
|
("nom", "themselves", "masculine", "himself"),
|
|
("nom", "themselves", "gender-neutral", "themself"),
|
|
("nom", "themselves", "feminine or masculine", "herself or himself"),
|
|
("nom", "themselves", "masculine or feminine", "himself or herself"),
|
|
("nom", "theirs", "neuter", "its"),
|
|
("nom", "theirs", "feminine", "hers"),
|
|
("nom", "theirs", "masculine", "his"),
|
|
("nom", "theirs", "gender-neutral", "theirs"),
|
|
("nom", "theirs", "feminine or masculine", "hers or his"),
|
|
("nom", "theirs", "masculine or feminine", "his or hers"),
|
|
("acc", "them", "neuter", "it"),
|
|
("acc", "them", "feminine", "her"),
|
|
("acc", "them", "masculine", "him"),
|
|
("acc", "them", "gender-neutral", "them"),
|
|
("acc", "them", "feminine or masculine", "her or him"),
|
|
("acc", "them", "masculine or feminine", "him or her"),
|
|
("acc", "themselves", "neuter", "itself"),
|
|
("acc", "themselves", "feminine", "herself"),
|
|
("acc", "themselves", "masculine", "himself"),
|
|
("acc", "themselves", "gender-neutral", "themself"),
|
|
("acc", "themselves", "feminine or masculine", "herself or himself"),
|
|
("acc", "themselves", "masculine or feminine", "himself or herself"),
|
|
):
|
|
try:
|
|
si_pron[_thecase][_plur][_gend] = _sing # type: ignore
|
|
except TypeError:
|
|
si_pron[_thecase][_plur] = {}
|
|
si_pron[_thecase][_plur][_gend] = _sing # type: ignore
|
|
|
|
|
|
si_pron_acc_keys = enclose("|".join(si_pron["acc"]))
|
|
si_pron_acc_keys_bysize = bysize(si_pron["acc"])
|
|
|
|
|
|
def get_si_pron(thecase, word, gender) -> str:
|
|
try:
|
|
sing = si_pron[thecase][word]
|
|
except KeyError:
|
|
raise # not a pronoun
|
|
try:
|
|
return sing[gender] # has several types due to gender
|
|
except TypeError:
|
|
return cast(str, sing) # answer independent of gender
|
|
|
|
|
|
# These dictionaries group verbs by first, second and third person
|
|
# conjugations.
|
|
|
|
plverb_irregular_pres = {
|
|
"am": "are",
|
|
"are": "are",
|
|
"is": "are",
|
|
"was": "were",
|
|
"were": "were",
|
|
"have": "have",
|
|
"has": "have",
|
|
"do": "do",
|
|
"does": "do",
|
|
}
|
|
|
|
plverb_ambiguous_pres = {
|
|
"act": "act",
|
|
"acts": "act",
|
|
"blame": "blame",
|
|
"blames": "blame",
|
|
"can": "can",
|
|
"must": "must",
|
|
"fly": "fly",
|
|
"flies": "fly",
|
|
"copy": "copy",
|
|
"copies": "copy",
|
|
"drink": "drink",
|
|
"drinks": "drink",
|
|
"fight": "fight",
|
|
"fights": "fight",
|
|
"fire": "fire",
|
|
"fires": "fire",
|
|
"like": "like",
|
|
"likes": "like",
|
|
"look": "look",
|
|
"looks": "look",
|
|
"make": "make",
|
|
"makes": "make",
|
|
"reach": "reach",
|
|
"reaches": "reach",
|
|
"run": "run",
|
|
"runs": "run",
|
|
"sink": "sink",
|
|
"sinks": "sink",
|
|
"sleep": "sleep",
|
|
"sleeps": "sleep",
|
|
"view": "view",
|
|
"views": "view",
|
|
}
|
|
|
|
plverb_ambiguous_pres_keys = re.compile(
|
|
rf"^({enclose('|'.join(plverb_ambiguous_pres))})((\s.*)?)$", re.IGNORECASE
|
|
)
|
|
|
|
|
|
plverb_irregular_non_pres = (
|
|
"did",
|
|
"had",
|
|
"ate",
|
|
"made",
|
|
"put",
|
|
"spent",
|
|
"fought",
|
|
"sank",
|
|
"gave",
|
|
"sought",
|
|
"shall",
|
|
"could",
|
|
"ought",
|
|
"should",
|
|
)
|
|
|
|
plverb_ambiguous_non_pres = re.compile(
|
|
r"^((?:thought|saw|bent|will|might|cut))((\s.*)?)$", re.IGNORECASE
|
|
)
|
|
|
|
# "..oes" -> "..oe" (the rest are "..oes" -> "o")
|
|
|
|
pl_v_oes_oe = ("canoes", "floes", "oboes", "roes", "throes", "woes")
|
|
pl_v_oes_oe_endings_size4 = ("hoes", "toes")
|
|
pl_v_oes_oe_endings_size5 = ("shoes",)
|
|
|
|
|
|
pl_count_zero = ("0", "no", "zero", "nil")
|
|
|
|
|
|
pl_count_one = ("1", "a", "an", "one", "each", "every", "this", "that")
|
|
|
|
pl_adj_special = {"a": "some", "an": "some", "this": "these", "that": "those"}
|
|
|
|
pl_adj_special_keys = re.compile(
|
|
rf"^({enclose('|'.join(pl_adj_special))})$", re.IGNORECASE
|
|
)
|
|
|
|
pl_adj_poss = {
|
|
"my": "our",
|
|
"your": "your",
|
|
"its": "their",
|
|
"her": "their",
|
|
"his": "their",
|
|
"their": "their",
|
|
}
|
|
|
|
pl_adj_poss_keys = re.compile(rf"^({enclose('|'.join(pl_adj_poss))})$", re.IGNORECASE)
|
|
|
|
|
|
# 2. INDEFINITE ARTICLES
|
|
|
|
# THIS PATTERN MATCHES STRINGS OF CAPITALS STARTING WITH A "VOWEL-SOUND"
|
|
# CONSONANT FOLLOWED BY ANOTHER CONSONANT, AND WHICH ARE NOT LIKELY
|
|
# TO BE REAL WORDS (OH, ALL RIGHT THEN, IT'S JUST MAGIC!)
|
|
|
|
A_abbrev = re.compile(
|
|
r"""
|
|
^(?! FJO | [HLMNS]Y. | RY[EO] | SQU
|
|
| ( F[LR]? | [HL] | MN? | N | RH? | S[CHKLMNPTVW]? | X(YL)?) [AEIOU])
|
|
[FHLMNRSX][A-Z]
|
|
""",
|
|
re.VERBOSE,
|
|
)
|
|
|
|
# THIS PATTERN CODES THE BEGINNINGS OF ALL ENGLISH WORDS BEGINING WITH A
|
|
# 'y' FOLLOWED BY A CONSONANT. ANY OTHER Y-CONSONANT PREFIX THEREFORE
|
|
# IMPLIES AN ABBREVIATION.
|
|
|
|
A_y_cons = re.compile(r"^(y(b[lor]|cl[ea]|fere|gg|p[ios]|rou|tt))", re.IGNORECASE)
|
|
|
|
# EXCEPTIONS TO EXCEPTIONS
|
|
|
|
A_explicit_a = re.compile(r"^((?:unabomber|unanimous|US))", re.IGNORECASE)
|
|
|
|
A_explicit_an = re.compile(
|
|
r"^((?:euler|hour(?!i)|heir|honest|hono[ur]|mpeg))", re.IGNORECASE
|
|
)
|
|
|
|
A_ordinal_an = re.compile(r"^([aefhilmnorsx]-?th)", re.IGNORECASE)
|
|
|
|
A_ordinal_a = re.compile(r"^([bcdgjkpqtuvwyz]-?th)", re.IGNORECASE)
|
|
|
|
|
|
# NUMERICAL INFLECTIONS
|
|
|
|
nth = {
|
|
0: "th",
|
|
1: "st",
|
|
2: "nd",
|
|
3: "rd",
|
|
4: "th",
|
|
5: "th",
|
|
6: "th",
|
|
7: "th",
|
|
8: "th",
|
|
9: "th",
|
|
11: "th",
|
|
12: "th",
|
|
13: "th",
|
|
}
|
|
nth_suff = set(nth.values())
|
|
|
|
ordinal = dict(
|
|
ty="tieth",
|
|
one="first",
|
|
two="second",
|
|
three="third",
|
|
five="fifth",
|
|
eight="eighth",
|
|
nine="ninth",
|
|
twelve="twelfth",
|
|
)
|
|
|
|
ordinal_suff = re.compile(rf"({'|'.join(ordinal)})\Z")
|
|
|
|
|
|
# NUMBERS
|
|
|
|
unit = ["", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine"]
|
|
teen = [
|
|
"ten",
|
|
"eleven",
|
|
"twelve",
|
|
"thirteen",
|
|
"fourteen",
|
|
"fifteen",
|
|
"sixteen",
|
|
"seventeen",
|
|
"eighteen",
|
|
"nineteen",
|
|
]
|
|
ten = [
|
|
"",
|
|
"",
|
|
"twenty",
|
|
"thirty",
|
|
"forty",
|
|
"fifty",
|
|
"sixty",
|
|
"seventy",
|
|
"eighty",
|
|
"ninety",
|
|
]
|
|
mill = [
|
|
" ",
|
|
" thousand",
|
|
" million",
|
|
" billion",
|
|
" trillion",
|
|
" quadrillion",
|
|
" quintillion",
|
|
" sextillion",
|
|
" septillion",
|
|
" octillion",
|
|
" nonillion",
|
|
" decillion",
|
|
]
|
|
|
|
|
|
# SUPPORT CLASSICAL PLURALIZATIONS
|
|
|
|
def_classical = dict(
|
|
all=False, zero=False, herd=False, names=True, persons=False, ancient=False
|
|
)
|
|
|
|
all_classical = {k: True for k in def_classical}
|
|
no_classical = {k: False for k in def_classical}
|
|
|
|
|
|
# Maps strings to built-in constant types
|
|
string_to_constant = {"True": True, "False": False, "None": None}
|
|
|
|
|
|
# Pre-compiled regular expression objects
|
|
DOLLAR_DIGITS = re.compile(r"\$(\d+)")
|
|
FUNCTION_CALL = re.compile(r"((\w+)\([^)]*\)*)", re.IGNORECASE)
|
|
PARTITION_WORD = re.compile(r"\A(\s*)(.+?)(\s*)\Z")
|
|
PL_SB_POSTFIX_ADJ_STEMS_RE = re.compile(
|
|
rf"^(?:{pl_sb_postfix_adj_stems})$", re.IGNORECASE
|
|
)
|
|
PL_SB_PREP_DUAL_COMPOUND_RE = re.compile(
|
|
rf"^(?:{pl_sb_prep_dual_compound})$", re.IGNORECASE
|
|
)
|
|
DENOMINATOR = re.compile(r"(?P<denominator>.+)( (per|a) .+)")
|
|
PLVERB_SPECIAL_S_RE = re.compile(rf"^({plverb_special_s})$")
|
|
WHITESPACE = re.compile(r"\s")
|
|
ENDS_WITH_S = re.compile(r"^(.*[^s])s$", re.IGNORECASE)
|
|
ENDS_WITH_APOSTROPHE_S = re.compile(r"^(.*)'s?$")
|
|
INDEFINITE_ARTICLE_TEST = re.compile(r"\A(\s*)(?:an?\s+)?(.+?)(\s*)\Z", re.IGNORECASE)
|
|
SPECIAL_AN = re.compile(r"^[aefhilmnorsx]$", re.IGNORECASE)
|
|
SPECIAL_A = re.compile(r"^[bcdgjkpqtuvwyz]$", re.IGNORECASE)
|
|
SPECIAL_ABBREV_AN = re.compile(r"^[aefhilmnorsx][.-]", re.IGNORECASE)
|
|
SPECIAL_ABBREV_A = re.compile(r"^[a-z][.-]", re.IGNORECASE)
|
|
CONSONANTS = re.compile(r"^[^aeiouy]", re.IGNORECASE)
|
|
ARTICLE_SPECIAL_EU = re.compile(r"^e[uw]", re.IGNORECASE)
|
|
ARTICLE_SPECIAL_ONCE = re.compile(r"^onc?e\b", re.IGNORECASE)
|
|
ARTICLE_SPECIAL_ONETIME = re.compile(r"^onetime\b", re.IGNORECASE)
|
|
ARTICLE_SPECIAL_UNIT = re.compile(r"^uni([^nmd]|mo)", re.IGNORECASE)
|
|
ARTICLE_SPECIAL_UBA = re.compile(r"^u[bcfghjkqrst][aeiou]", re.IGNORECASE)
|
|
ARTICLE_SPECIAL_UKR = re.compile(r"^ukr", re.IGNORECASE)
|
|
SPECIAL_CAPITALS = re.compile(r"^U[NK][AIEO]?")
|
|
VOWELS = re.compile(r"^[aeiou]", re.IGNORECASE)
|
|
|
|
DIGIT_GROUP = re.compile(r"(\d)")
|
|
TWO_DIGITS = re.compile(r"(\d)(\d)")
|
|
THREE_DIGITS = re.compile(r"(\d)(\d)(\d)")
|
|
THREE_DIGITS_WORD = re.compile(r"(\d)(\d)(\d)(?=\D*\Z)")
|
|
TWO_DIGITS_WORD = re.compile(r"(\d)(\d)(?=\D*\Z)")
|
|
ONE_DIGIT_WORD = re.compile(r"(\d)(?=\D*\Z)")
|
|
|
|
FOUR_DIGIT_COMMA = re.compile(r"(\d)(\d{3}(?:,|\Z))")
|
|
NON_DIGIT = re.compile(r"\D")
|
|
WHITESPACES_COMMA = re.compile(r"\s+,")
|
|
COMMA_WORD = re.compile(r", (\S+)\s+\Z")
|
|
WHITESPACES = re.compile(r"\s+")
|
|
|
|
|
|
PRESENT_PARTICIPLE_REPLACEMENTS = (
|
|
(re.compile(r"ie$"), r"y"),
|
|
(
|
|
re.compile(r"ue$"),
|
|
r"u",
|
|
), # TODO: isn't ue$ -> u encompassed in the following rule?
|
|
(re.compile(r"([auy])e$"), r"\g<1>"),
|
|
(re.compile(r"ski$"), r"ski"),
|
|
(re.compile(r"[^b]i$"), r""),
|
|
(re.compile(r"^(are|were)$"), r"be"),
|
|
(re.compile(r"^(had)$"), r"hav"),
|
|
(re.compile(r"^(hoe)$"), r"\g<1>"),
|
|
(re.compile(r"([^e])e$"), r"\g<1>"),
|
|
(re.compile(r"er$"), r"er"),
|
|
(re.compile(r"([^aeiou][aeiouy]([bdgmnprst]))$"), r"\g<1>\g<2>"),
|
|
)
|
|
|
|
DIGIT = re.compile(r"\d")
|
|
|
|
|
|
class Words(str):
|
|
lowered: str
|
|
split_: List[str]
|
|
first: str
|
|
last: str
|
|
|
|
def __init__(self, orig) -> None:
|
|
self.lowered = self.lower()
|
|
self.split_ = self.split()
|
|
self.first = self.split_[0]
|
|
self.last = self.split_[-1]
|
|
|
|
|
|
Falsish = Any # ideally, falsish would only validate on bool(value) is False
|
|
|
|
|
|
_STATIC_TYPE_CHECKING = TYPE_CHECKING
|
|
# ^-- Workaround for typeguard AST manipulation:
|
|
# https://github.com/agronholm/typeguard/issues/353#issuecomment-1556306554
|
|
|
|
if _STATIC_TYPE_CHECKING: # pragma: no cover
|
|
Word = Annotated[str, "String with at least 1 character"]
|
|
else:
|
|
|
|
class _WordMeta(type): # Too dynamic to be supported by mypy...
|
|
def __instancecheck__(self, instance: Any) -> bool:
|
|
return isinstance(instance, str) and len(instance) >= 1
|
|
|
|
class Word(metaclass=_WordMeta): # type: ignore[no-redef]
|
|
"""String with at least 1 character"""
|
|
|
|
|
|
class engine:
|
|
def __init__(self) -> None:
|
|
self.classical_dict = def_classical.copy()
|
|
self.persistent_count: Optional[int] = None
|
|
self.mill_count = 0
|
|
self.pl_sb_user_defined: List[Optional[Word]] = []
|
|
self.pl_v_user_defined: List[Optional[Word]] = []
|
|
self.pl_adj_user_defined: List[Optional[Word]] = []
|
|
self.si_sb_user_defined: List[Optional[Word]] = []
|
|
self.A_a_user_defined: List[Optional[Word]] = []
|
|
self.thegender = "neuter"
|
|
self.__number_args: Optional[Dict[str, str]] = None
|
|
|
|
@property
|
|
def _number_args(self):
|
|
return cast(Dict[str, str], self.__number_args)
|
|
|
|
@_number_args.setter
|
|
def _number_args(self, val):
|
|
self.__number_args = val
|
|
|
|
@typechecked
|
|
def defnoun(self, singular: Optional[Word], plural: Optional[Word]) -> int:
|
|
"""
|
|
Set the noun plural of singular to plural.
|
|
|
|
"""
|
|
self.checkpat(singular)
|
|
self.checkpatplural(plural)
|
|
self.pl_sb_user_defined.extend((singular, plural))
|
|
self.si_sb_user_defined.extend((plural, singular))
|
|
return 1
|
|
|
|
@typechecked
|
|
def defverb(
|
|
self,
|
|
s1: Optional[Word],
|
|
p1: Optional[Word],
|
|
s2: Optional[Word],
|
|
p2: Optional[Word],
|
|
s3: Optional[Word],
|
|
p3: Optional[Word],
|
|
) -> int:
|
|
"""
|
|
Set the verb plurals for s1, s2 and s3 to p1, p2 and p3 respectively.
|
|
|
|
Where 1, 2 and 3 represent the 1st, 2nd and 3rd person forms of the verb.
|
|
|
|
"""
|
|
self.checkpat(s1)
|
|
self.checkpat(s2)
|
|
self.checkpat(s3)
|
|
self.checkpatplural(p1)
|
|
self.checkpatplural(p2)
|
|
self.checkpatplural(p3)
|
|
self.pl_v_user_defined.extend((s1, p1, s2, p2, s3, p3))
|
|
return 1
|
|
|
|
@typechecked
|
|
def defadj(self, singular: Optional[Word], plural: Optional[Word]) -> int:
|
|
"""
|
|
Set the adjective plural of singular to plural.
|
|
|
|
"""
|
|
self.checkpat(singular)
|
|
self.checkpatplural(plural)
|
|
self.pl_adj_user_defined.extend((singular, plural))
|
|
return 1
|
|
|
|
@typechecked
|
|
def defa(self, pattern: Optional[Word]) -> int:
|
|
"""
|
|
Define the indefinite article as 'a' for words matching pattern.
|
|
|
|
"""
|
|
self.checkpat(pattern)
|
|
self.A_a_user_defined.extend((pattern, "a"))
|
|
return 1
|
|
|
|
@typechecked
|
|
def defan(self, pattern: Optional[Word]) -> int:
|
|
"""
|
|
Define the indefinite article as 'an' for words matching pattern.
|
|
|
|
"""
|
|
self.checkpat(pattern)
|
|
self.A_a_user_defined.extend((pattern, "an"))
|
|
return 1
|
|
|
|
def checkpat(self, pattern: Optional[Word]) -> None:
|
|
"""
|
|
check for errors in a regex pattern
|
|
"""
|
|
if pattern is None:
|
|
return
|
|
try:
|
|
re.match(pattern, "")
|
|
except re.error as err:
|
|
raise BadUserDefinedPatternError(pattern) from err
|
|
|
|
def checkpatplural(self, pattern: Optional[Word]) -> None:
|
|
"""
|
|
check for errors in a regex replace pattern
|
|
"""
|
|
return
|
|
|
|
@typechecked
|
|
def ud_match(self, word: Word, wordlist: Sequence[Optional[Word]]) -> Optional[str]:
|
|
for i in range(len(wordlist) - 2, -2, -2): # backwards through even elements
|
|
mo = re.search(rf"^{wordlist[i]}$", word, re.IGNORECASE)
|
|
if mo:
|
|
if wordlist[i + 1] is None:
|
|
return None
|
|
pl = DOLLAR_DIGITS.sub(
|
|
r"\\1", cast(Word, wordlist[i + 1])
|
|
) # change $n to \n for expand
|
|
return mo.expand(pl)
|
|
return None
|
|
|
|
def classical(self, **kwargs) -> None:
|
|
"""
|
|
turn classical mode on and off for various categories
|
|
|
|
turn on all classical modes:
|
|
classical()
|
|
classical(all=True)
|
|
|
|
turn on or off specific claassical modes:
|
|
e.g.
|
|
classical(herd=True)
|
|
classical(names=False)
|
|
|
|
By default all classical modes are off except names.
|
|
|
|
unknown value in args or key in kwargs raises
|
|
exception: UnknownClasicalModeError
|
|
|
|
"""
|
|
if not kwargs:
|
|
self.classical_dict = all_classical.copy()
|
|
return
|
|
if "all" in kwargs:
|
|
if kwargs["all"]:
|
|
self.classical_dict = all_classical.copy()
|
|
else:
|
|
self.classical_dict = no_classical.copy()
|
|
|
|
for k, v in kwargs.items():
|
|
if k in def_classical:
|
|
self.classical_dict[k] = v
|
|
else:
|
|
raise UnknownClassicalModeError
|
|
|
|
def num(
|
|
self, count: Optional[int] = None, show: Optional[int] = None
|
|
) -> str: # (;$count,$show)
|
|
"""
|
|
Set the number to be used in other method calls.
|
|
|
|
Returns count.
|
|
|
|
Set show to False to return '' instead.
|
|
|
|
"""
|
|
if count is not None:
|
|
try:
|
|
self.persistent_count = int(count)
|
|
except ValueError as err:
|
|
raise BadNumValueError from err
|
|
if (show is None) or show:
|
|
return str(count)
|
|
else:
|
|
self.persistent_count = None
|
|
return ""
|
|
|
|
def gender(self, gender: str) -> None:
|
|
"""
|
|
set the gender for the singular of plural pronouns
|
|
|
|
can be one of:
|
|
'neuter' ('they' -> 'it')
|
|
'feminine' ('they' -> 'she')
|
|
'masculine' ('they' -> 'he')
|
|
'gender-neutral' ('they' -> 'they')
|
|
'feminine or masculine' ('they' -> 'she or he')
|
|
'masculine or feminine' ('they' -> 'he or she')
|
|
"""
|
|
if gender in singular_pronoun_genders:
|
|
self.thegender = gender
|
|
else:
|
|
raise BadGenderError
|
|
|
|
def _get_value_from_ast(self, obj):
|
|
"""
|
|
Return the value of the ast object.
|
|
"""
|
|
if isinstance(obj, ast.Num):
|
|
return obj.n
|
|
elif isinstance(obj, ast.Str):
|
|
return obj.s
|
|
elif isinstance(obj, ast.List):
|
|
return [self._get_value_from_ast(e) for e in obj.elts]
|
|
elif isinstance(obj, ast.Tuple):
|
|
return tuple([self._get_value_from_ast(e) for e in obj.elts])
|
|
|
|
# None, True and False are NameConstants in Py3.4 and above.
|
|
elif isinstance(obj, ast.NameConstant):
|
|
return obj.value
|
|
|
|
# Probably passed a variable name.
|
|
# Or passed a single word without wrapping it in quotes as an argument
|
|
# ex: p.inflect("I plural(see)") instead of p.inflect("I plural('see')")
|
|
raise NameError(f"name '{obj.id}' is not defined")
|
|
|
|
def _string_to_substitute(
|
|
self, mo: Match, methods_dict: Dict[str, Callable]
|
|
) -> str:
|
|
"""
|
|
Return the string to be substituted for the match.
|
|
"""
|
|
matched_text, f_name = mo.groups()
|
|
# matched_text is the complete match string. e.g. plural_noun(cat)
|
|
# f_name is the function name. e.g. plural_noun
|
|
|
|
# Return matched_text if function name is not in methods_dict
|
|
if f_name not in methods_dict:
|
|
return matched_text
|
|
|
|
# Parse the matched text
|
|
a_tree = ast.parse(matched_text)
|
|
|
|
# get the args and kwargs from ast objects
|
|
args_list = [
|
|
self._get_value_from_ast(a)
|
|
for a in a_tree.body[0].value.args # type: ignore[attr-defined]
|
|
]
|
|
kwargs_list = {
|
|
kw.arg: self._get_value_from_ast(kw.value)
|
|
for kw in a_tree.body[0].value.keywords # type: ignore[attr-defined]
|
|
}
|
|
|
|
# Call the corresponding function
|
|
return methods_dict[f_name](*args_list, **kwargs_list)
|
|
|
|
# 0. PERFORM GENERAL INFLECTIONS IN A STRING
|
|
|
|
@typechecked
|
|
def inflect(self, text: Word) -> str:
|
|
"""
|
|
Perform inflections in a string.
|
|
|
|
e.g. inflect('The plural of cat is plural(cat)') returns
|
|
'The plural of cat is cats'
|
|
|
|
can use plural, plural_noun, plural_verb, plural_adj,
|
|
singular_noun, a, an, no, ordinal, number_to_words,
|
|
and prespart
|
|
|
|
"""
|
|
save_persistent_count = self.persistent_count
|
|
|
|
# Dictionary of allowed methods
|
|
methods_dict: Dict[str, Callable] = {
|
|
"plural": self.plural,
|
|
"plural_adj": self.plural_adj,
|
|
"plural_noun": self.plural_noun,
|
|
"plural_verb": self.plural_verb,
|
|
"singular_noun": self.singular_noun,
|
|
"a": self.a,
|
|
"an": self.a,
|
|
"no": self.no,
|
|
"ordinal": self.ordinal,
|
|
"number_to_words": self.number_to_words,
|
|
"present_participle": self.present_participle,
|
|
"num": self.num,
|
|
}
|
|
|
|
# Regular expression to find Python's function call syntax
|
|
output = FUNCTION_CALL.sub(
|
|
lambda mo: self._string_to_substitute(mo, methods_dict), text
|
|
)
|
|
self.persistent_count = save_persistent_count
|
|
return output
|
|
|
|
# ## PLURAL SUBROUTINES
|
|
|
|
def postprocess(self, orig: str, inflected) -> str:
|
|
inflected = str(inflected)
|
|
if "|" in inflected:
|
|
word_options = inflected.split("|")
|
|
# When two parts of a noun need to be pluralized
|
|
if len(word_options[0].split(" ")) == len(word_options[1].split(" ")):
|
|
result = inflected.split("|")[self.classical_dict["all"]].split(" ")
|
|
# When only the last part of the noun needs to be pluralized
|
|
else:
|
|
result = inflected.split(" ")
|
|
for index, word in enumerate(result):
|
|
if "|" in word:
|
|
result[index] = word.split("|")[self.classical_dict["all"]]
|
|
else:
|
|
result = inflected.split(" ")
|
|
|
|
# Try to fix word wise capitalization
|
|
for index, word in enumerate(orig.split(" ")):
|
|
if word == "I":
|
|
# Is this the only word for exceptions like this
|
|
# Where the original is fully capitalized
|
|
# without 'meaning' capitalization?
|
|
# Also this fails to handle a capitalizaion in context
|
|
continue
|
|
if word.capitalize() == word:
|
|
result[index] = result[index].capitalize()
|
|
if word == word.upper():
|
|
result[index] = result[index].upper()
|
|
return " ".join(result)
|
|
|
|
def partition_word(self, text: str) -> Tuple[str, str, str]:
|
|
mo = PARTITION_WORD.search(text)
|
|
if mo:
|
|
return mo.group(1), mo.group(2), mo.group(3)
|
|
else:
|
|
return "", "", ""
|
|
|
|
@typechecked
|
|
def plural(self, text: Word, count: Optional[Union[str, int, Any]] = None) -> str:
|
|
"""
|
|
Return the plural of text.
|
|
|
|
If count supplied, then return text if count is one of:
|
|
1, a, an, one, each, every, this, that
|
|
|
|
otherwise return the plural.
|
|
|
|
Whitespace at the start and end is preserved.
|
|
|
|
"""
|
|
pre, word, post = self.partition_word(text)
|
|
if not word:
|
|
return text
|
|
plural = self.postprocess(
|
|
word,
|
|
self._pl_special_adjective(word, count)
|
|
or self._pl_special_verb(word, count)
|
|
or self._plnoun(word, count),
|
|
)
|
|
return f"{pre}{plural}{post}"
|
|
|
|
@typechecked
|
|
def plural_noun(
|
|
self, text: Word, count: Optional[Union[str, int, Any]] = None
|
|
) -> str:
|
|
"""
|
|
Return the plural of text, where text is a noun.
|
|
|
|
If count supplied, then return text if count is one of:
|
|
1, a, an, one, each, every, this, that
|
|
|
|
otherwise return the plural.
|
|
|
|
Whitespace at the start and end is preserved.
|
|
|
|
"""
|
|
pre, word, post = self.partition_word(text)
|
|
if not word:
|
|
return text
|
|
plural = self.postprocess(word, self._plnoun(word, count))
|
|
return f"{pre}{plural}{post}"
|
|
|
|
@typechecked
|
|
def plural_verb(
|
|
self, text: Word, count: Optional[Union[str, int, Any]] = None
|
|
) -> str:
|
|
"""
|
|
Return the plural of text, where text is a verb.
|
|
|
|
If count supplied, then return text if count is one of:
|
|
1, a, an, one, each, every, this, that
|
|
|
|
otherwise return the plural.
|
|
|
|
Whitespace at the start and end is preserved.
|
|
|
|
"""
|
|
pre, word, post = self.partition_word(text)
|
|
if not word:
|
|
return text
|
|
plural = self.postprocess(
|
|
word,
|
|
self._pl_special_verb(word, count) or self._pl_general_verb(word, count),
|
|
)
|
|
return f"{pre}{plural}{post}"
|
|
|
|
@typechecked
|
|
def plural_adj(
|
|
self, text: Word, count: Optional[Union[str, int, Any]] = None
|
|
) -> str:
|
|
"""
|
|
Return the plural of text, where text is an adjective.
|
|
|
|
If count supplied, then return text if count is one of:
|
|
1, a, an, one, each, every, this, that
|
|
|
|
otherwise return the plural.
|
|
|
|
Whitespace at the start and end is preserved.
|
|
|
|
"""
|
|
pre, word, post = self.partition_word(text)
|
|
if not word:
|
|
return text
|
|
plural = self.postprocess(word, self._pl_special_adjective(word, count) or word)
|
|
return f"{pre}{plural}{post}"
|
|
|
|
@typechecked
|
|
def compare(self, word1: Word, word2: Word) -> Union[str, bool]:
|
|
"""
|
|
compare word1 and word2 for equality regardless of plurality
|
|
|
|
return values:
|
|
eq - the strings are equal
|
|
p:s - word1 is the plural of word2
|
|
s:p - word2 is the plural of word1
|
|
p:p - word1 and word2 are two different plural forms of the one word
|
|
False - otherwise
|
|
|
|
>>> compare = engine().compare
|
|
>>> compare("egg", "eggs")
|
|
's:p'
|
|
>>> compare('egg', 'egg')
|
|
'eq'
|
|
|
|
Words should not be empty.
|
|
|
|
>>> compare('egg', '')
|
|
Traceback (most recent call last):
|
|
...
|
|
typeguard.TypeCheckError:...is not an instance of inflect.Word
|
|
"""
|
|
norms = self.plural_noun, self.plural_verb, self.plural_adj
|
|
results = (self._plequal(word1, word2, norm) for norm in norms)
|
|
return next(filter(None, results), False)
|
|
|
|
@typechecked
|
|
def compare_nouns(self, word1: Word, word2: Word) -> Union[str, bool]:
|
|
"""
|
|
compare word1 and word2 for equality regardless of plurality
|
|
word1 and word2 are to be treated as nouns
|
|
|
|
return values:
|
|
eq - the strings are equal
|
|
p:s - word1 is the plural of word2
|
|
s:p - word2 is the plural of word1
|
|
p:p - word1 and word2 are two different plural forms of the one word
|
|
False - otherwise
|
|
|
|
"""
|
|
return self._plequal(word1, word2, self.plural_noun)
|
|
|
|
@typechecked
|
|
def compare_verbs(self, word1: Word, word2: Word) -> Union[str, bool]:
|
|
"""
|
|
compare word1 and word2 for equality regardless of plurality
|
|
word1 and word2 are to be treated as verbs
|
|
|
|
return values:
|
|
eq - the strings are equal
|
|
p:s - word1 is the plural of word2
|
|
s:p - word2 is the plural of word1
|
|
p:p - word1 and word2 are two different plural forms of the one word
|
|
False - otherwise
|
|
|
|
"""
|
|
return self._plequal(word1, word2, self.plural_verb)
|
|
|
|
@typechecked
|
|
def compare_adjs(self, word1: Word, word2: Word) -> Union[str, bool]:
|
|
"""
|
|
compare word1 and word2 for equality regardless of plurality
|
|
word1 and word2 are to be treated as adjectives
|
|
|
|
return values:
|
|
eq - the strings are equal
|
|
p:s - word1 is the plural of word2
|
|
s:p - word2 is the plural of word1
|
|
p:p - word1 and word2 are two different plural forms of the one word
|
|
False - otherwise
|
|
|
|
"""
|
|
return self._plequal(word1, word2, self.plural_adj)
|
|
|
|
@typechecked
|
|
def singular_noun(
|
|
self,
|
|
text: Word,
|
|
count: Optional[Union[int, str, Any]] = None,
|
|
gender: Optional[str] = None,
|
|
) -> Union[str, Literal[False]]:
|
|
"""
|
|
Return the singular of text, where text is a plural noun.
|
|
|
|
If count supplied, then return the singular if count is one of:
|
|
1, a, an, one, each, every, this, that or if count is None
|
|
|
|
otherwise return text unchanged.
|
|
|
|
Whitespace at the start and end is preserved.
|
|
|
|
>>> p = engine()
|
|
>>> p.singular_noun('horses')
|
|
'horse'
|
|
>>> p.singular_noun('knights')
|
|
'knight'
|
|
|
|
Returns False when a singular noun is passed.
|
|
|
|
>>> p.singular_noun('horse')
|
|
False
|
|
>>> p.singular_noun('knight')
|
|
False
|
|
>>> p.singular_noun('soldier')
|
|
False
|
|
|
|
"""
|
|
pre, word, post = self.partition_word(text)
|
|
if not word:
|
|
return text
|
|
sing = self._sinoun(word, count=count, gender=gender)
|
|
if sing is not False:
|
|
plural = self.postprocess(word, sing)
|
|
return f"{pre}{plural}{post}"
|
|
return False
|
|
|
|
def _plequal(self, word1: str, word2: str, pl) -> Union[str, bool]: # noqa: C901
|
|
classval = self.classical_dict.copy()
|
|
self.classical_dict = all_classical.copy()
|
|
if word1 == word2:
|
|
return "eq"
|
|
if word1 == pl(word2):
|
|
return "p:s"
|
|
if pl(word1) == word2:
|
|
return "s:p"
|
|
self.classical_dict = no_classical.copy()
|
|
if word1 == pl(word2):
|
|
return "p:s"
|
|
if pl(word1) == word2:
|
|
return "s:p"
|
|
self.classical_dict = classval.copy()
|
|
|
|
if pl == self.plural or pl == self.plural_noun:
|
|
if self._pl_check_plurals_N(word1, word2):
|
|
return "p:p"
|
|
if self._pl_check_plurals_N(word2, word1):
|
|
return "p:p"
|
|
if pl == self.plural or pl == self.plural_adj:
|
|
if self._pl_check_plurals_adj(word1, word2):
|
|
return "p:p"
|
|
return False
|
|
|
|
def _pl_reg_plurals(self, pair: str, stems: str, end1: str, end2: str) -> bool:
|
|
pattern = rf"({stems})({end1}\|\1{end2}|{end2}\|\1{end1})"
|
|
return bool(re.search(pattern, pair))
|
|
|
|
def _pl_check_plurals_N(self, word1: str, word2: str) -> bool:
|
|
stem_endings = (
|
|
(pl_sb_C_a_ata, "as", "ata"),
|
|
(pl_sb_C_is_ides, "is", "ides"),
|
|
(pl_sb_C_a_ae, "s", "e"),
|
|
(pl_sb_C_en_ina, "ens", "ina"),
|
|
(pl_sb_C_um_a, "ums", "a"),
|
|
(pl_sb_C_us_i, "uses", "i"),
|
|
(pl_sb_C_on_a, "ons", "a"),
|
|
(pl_sb_C_o_i_stems, "os", "i"),
|
|
(pl_sb_C_ex_ices, "exes", "ices"),
|
|
(pl_sb_C_ix_ices, "ixes", "ices"),
|
|
(pl_sb_C_i, "s", "i"),
|
|
(pl_sb_C_im, "s", "im"),
|
|
(".*eau", "s", "x"),
|
|
(".*ieu", "s", "x"),
|
|
(".*tri", "xes", "ces"),
|
|
(".{2,}[yia]n", "xes", "ges"),
|
|
)
|
|
|
|
words = map(Words, (word1, word2))
|
|
pair = "|".join(word.last for word in words)
|
|
|
|
return (
|
|
pair in pl_sb_irregular_s.values()
|
|
or pair in pl_sb_irregular.values()
|
|
or pair in pl_sb_irregular_caps.values()
|
|
or any(
|
|
self._pl_reg_plurals(pair, stems, end1, end2)
|
|
for stems, end1, end2 in stem_endings
|
|
)
|
|
)
|
|
|
|
def _pl_check_plurals_adj(self, word1: str, word2: str) -> bool:
|
|
word1a = word1[: word1.rfind("'")] if word1.endswith(("'s", "'")) else ""
|
|
word2a = word2[: word2.rfind("'")] if word2.endswith(("'s", "'")) else ""
|
|
|
|
return (
|
|
bool(word1a)
|
|
and bool(word2a)
|
|
and (
|
|
self._pl_check_plurals_N(word1a, word2a)
|
|
or self._pl_check_plurals_N(word2a, word1a)
|
|
)
|
|
)
|
|
|
|
def get_count(self, count: Optional[Union[str, int]] = None) -> Union[str, int]:
|
|
if count is None and self.persistent_count is not None:
|
|
count = self.persistent_count
|
|
|
|
if count is not None:
|
|
count = (
|
|
1
|
|
if (
|
|
(str(count) in pl_count_one)
|
|
or (
|
|
self.classical_dict["zero"]
|
|
and str(count).lower() in pl_count_zero
|
|
)
|
|
)
|
|
else 2
|
|
)
|
|
else:
|
|
count = ""
|
|
return count
|
|
|
|
# @profile
|
|
def _plnoun( # noqa: C901
|
|
self, word: str, count: Optional[Union[str, int]] = None
|
|
) -> str:
|
|
count = self.get_count(count)
|
|
|
|
# DEFAULT TO PLURAL
|
|
|
|
if count == 1:
|
|
return word
|
|
|
|
# HANDLE USER-DEFINED NOUNS
|
|
|
|
value = self.ud_match(word, self.pl_sb_user_defined)
|
|
if value is not None:
|
|
return value
|
|
|
|
# HANDLE EMPTY WORD, SINGULAR COUNT AND UNINFLECTED PLURALS
|
|
|
|
if word == "":
|
|
return word
|
|
|
|
word = Words(word)
|
|
|
|
if word.last.lower() in pl_sb_uninflected_complete:
|
|
if len(word.split_) >= 3:
|
|
return self._handle_long_compounds(word, count=2) or word
|
|
return word
|
|
|
|
if word in pl_sb_uninflected_caps:
|
|
return word
|
|
|
|
for k, v in pl_sb_uninflected_bysize.items():
|
|
if word.lowered[-k:] in v:
|
|
return word
|
|
|
|
if self.classical_dict["herd"] and word.last.lower() in pl_sb_uninflected_herd:
|
|
return word
|
|
|
|
# HANDLE COMPOUNDS ("Governor General", "mother-in-law", "aide-de-camp", ETC.)
|
|
|
|
mo = PL_SB_POSTFIX_ADJ_STEMS_RE.search(word)
|
|
if mo and mo.group(2) != "":
|
|
return f"{self._plnoun(mo.group(1), 2)}{mo.group(2)}"
|
|
|
|
if " a " in word.lowered or "-a-" in word.lowered:
|
|
mo = PL_SB_PREP_DUAL_COMPOUND_RE.search(word)
|
|
if mo and mo.group(2) != "" and mo.group(3) != "":
|
|
return (
|
|
f"{self._plnoun(mo.group(1), 2)}"
|
|
f"{mo.group(2)}"
|
|
f"{self._plnoun(mo.group(3))}"
|
|
)
|
|
|
|
if len(word.split_) >= 3:
|
|
handled_words = self._handle_long_compounds(word, count=2)
|
|
if handled_words is not None:
|
|
return handled_words
|
|
|
|
# only pluralize denominators in units
|
|
mo = DENOMINATOR.search(word.lowered)
|
|
if mo:
|
|
index = len(mo.group("denominator"))
|
|
return f"{self._plnoun(word[:index])}{word[index:]}"
|
|
|
|
# handle units given in degrees (only accept if
|
|
# there is no more than one word following)
|
|
# degree Celsius => degrees Celsius but degree
|
|
# fahrenheit hour => degree fahrenheit hours
|
|
if len(word.split_) >= 2 and word.split_[-2] == "degree":
|
|
return " ".join([self._plnoun(word.first)] + word.split_[1:])
|
|
|
|
with contextlib.suppress(ValueError):
|
|
return self._handle_prepositional_phrase(
|
|
word.lowered,
|
|
functools.partial(self._plnoun, count=2),
|
|
'-',
|
|
)
|
|
|
|
# HANDLE PRONOUNS
|
|
|
|
for k, v in pl_pron_acc_keys_bysize.items():
|
|
if word.lowered[-k:] in v: # ends with accusative pronoun
|
|
for pk, pv in pl_prep_bysize.items():
|
|
if word.lowered[:pk] in pv: # starts with a prep
|
|
if word.lowered.split() == [
|
|
word.lowered[:pk],
|
|
word.lowered[-k:],
|
|
]:
|
|
# only whitespace in between
|
|
return word.lowered[:-k] + pl_pron_acc[word.lowered[-k:]]
|
|
|
|
try:
|
|
return pl_pron_nom[word.lowered]
|
|
except KeyError:
|
|
pass
|
|
|
|
try:
|
|
return pl_pron_acc[word.lowered]
|
|
except KeyError:
|
|
pass
|
|
|
|
# HANDLE ISOLATED IRREGULAR PLURALS
|
|
|
|
if word.last in pl_sb_irregular_caps:
|
|
llen = len(word.last)
|
|
return f"{word[:-llen]}{pl_sb_irregular_caps[word.last]}"
|
|
|
|
lowered_last = word.last.lower()
|
|
if lowered_last in pl_sb_irregular:
|
|
llen = len(lowered_last)
|
|
return f"{word[:-llen]}{pl_sb_irregular[lowered_last]}"
|
|
|
|
dash_split = word.lowered.split('-')
|
|
if (" ".join(dash_split[-2:])).lower() in pl_sb_irregular_compound:
|
|
llen = len(
|
|
" ".join(dash_split[-2:])
|
|
) # TODO: what if 2 spaces between these words?
|
|
return (
|
|
f"{word[:-llen]}"
|
|
f"{pl_sb_irregular_compound[(' '.join(dash_split[-2:])).lower()]}"
|
|
)
|
|
|
|
if word.lowered[-3:] == "quy":
|
|
return f"{word[:-1]}ies"
|
|
|
|
if word.lowered[-6:] == "person":
|
|
if self.classical_dict["persons"]:
|
|
return f"{word}s"
|
|
else:
|
|
return f"{word[:-4]}ople"
|
|
|
|
# HANDLE FAMILIES OF IRREGULAR PLURALS
|
|
|
|
if word.lowered[-3:] == "man":
|
|
for k, v in pl_sb_U_man_mans_bysize.items():
|
|
if word.lowered[-k:] in v:
|
|
return f"{word}s"
|
|
for k, v in pl_sb_U_man_mans_caps_bysize.items():
|
|
if word[-k:] in v:
|
|
return f"{word}s"
|
|
return f"{word[:-3]}men"
|
|
if word.lowered[-5:] == "mouse":
|
|
return f"{word[:-5]}mice"
|
|
if word.lowered[-5:] == "louse":
|
|
v = pl_sb_U_louse_lice_bysize.get(len(word))
|
|
if v and word.lowered in v:
|
|
return f"{word[:-5]}lice"
|
|
return f"{word}s"
|
|
if word.lowered[-5:] == "goose":
|
|
return f"{word[:-5]}geese"
|
|
if word.lowered[-5:] == "tooth":
|
|
return f"{word[:-5]}teeth"
|
|
if word.lowered[-4:] == "foot":
|
|
return f"{word[:-4]}feet"
|
|
if word.lowered[-4:] == "taco":
|
|
return f"{word[:-5]}tacos"
|
|
|
|
if word.lowered == "die":
|
|
return "dice"
|
|
|
|
# HANDLE UNASSIMILATED IMPORTS
|
|
|
|
if word.lowered[-4:] == "ceps":
|
|
return word
|
|
if word.lowered[-4:] == "zoon":
|
|
return f"{word[:-2]}a"
|
|
if word.lowered[-3:] in ("cis", "sis", "xis"):
|
|
return f"{word[:-2]}es"
|
|
|
|
for lastlet, d, numend, post in (
|
|
("h", pl_sb_U_ch_chs_bysize, None, "s"),
|
|
("x", pl_sb_U_ex_ices_bysize, -2, "ices"),
|
|
("x", pl_sb_U_ix_ices_bysize, -2, "ices"),
|
|
("m", pl_sb_U_um_a_bysize, -2, "a"),
|
|
("s", pl_sb_U_us_i_bysize, -2, "i"),
|
|
("n", pl_sb_U_on_a_bysize, -2, "a"),
|
|
("a", pl_sb_U_a_ae_bysize, None, "e"),
|
|
):
|
|
if word.lowered[-1] == lastlet: # this test to add speed
|
|
for k, v in d.items():
|
|
if word.lowered[-k:] in v:
|
|
return word[:numend] + post
|
|
|
|
# HANDLE INCOMPLETELY ASSIMILATED IMPORTS
|
|
|
|
if self.classical_dict["ancient"]:
|
|
if word.lowered[-4:] == "trix":
|
|
return f"{word[:-1]}ces"
|
|
if word.lowered[-3:] in ("eau", "ieu"):
|
|
return f"{word}x"
|
|
if word.lowered[-3:] in ("ynx", "inx", "anx") and len(word) > 4:
|
|
return f"{word[:-1]}ges"
|
|
|
|
for lastlet, d, numend, post in (
|
|
("n", pl_sb_C_en_ina_bysize, -2, "ina"),
|
|
("x", pl_sb_C_ex_ices_bysize, -2, "ices"),
|
|
("x", pl_sb_C_ix_ices_bysize, -2, "ices"),
|
|
("m", pl_sb_C_um_a_bysize, -2, "a"),
|
|
("s", pl_sb_C_us_i_bysize, -2, "i"),
|
|
("s", pl_sb_C_us_us_bysize, None, ""),
|
|
("a", pl_sb_C_a_ae_bysize, None, "e"),
|
|
("a", pl_sb_C_a_ata_bysize, None, "ta"),
|
|
("s", pl_sb_C_is_ides_bysize, -1, "des"),
|
|
("o", pl_sb_C_o_i_bysize, -1, "i"),
|
|
("n", pl_sb_C_on_a_bysize, -2, "a"),
|
|
):
|
|
if word.lowered[-1] == lastlet: # this test to add speed
|
|
for k, v in d.items():
|
|
if word.lowered[-k:] in v:
|
|
return word[:numend] + post
|
|
|
|
for d, numend, post in (
|
|
(pl_sb_C_i_bysize, None, "i"),
|
|
(pl_sb_C_im_bysize, None, "im"),
|
|
):
|
|
for k, v in d.items():
|
|
if word.lowered[-k:] in v:
|
|
return word[:numend] + post
|
|
|
|
# HANDLE SINGULAR NOUNS ENDING IN ...s OR OTHER SILIBANTS
|
|
|
|
if lowered_last in pl_sb_singular_s_complete:
|
|
return f"{word}es"
|
|
|
|
for k, v in pl_sb_singular_s_bysize.items():
|
|
if word.lowered[-k:] in v:
|
|
return f"{word}es"
|
|
|
|
if word.lowered[-2:] == "es" and word[0] == word[0].upper():
|
|
return f"{word}es"
|
|
|
|
if word.lowered[-1] == "z":
|
|
for k, v in pl_sb_z_zes_bysize.items():
|
|
if word.lowered[-k:] in v:
|
|
return f"{word}es"
|
|
|
|
if word.lowered[-2:-1] != "z":
|
|
return f"{word}zes"
|
|
|
|
if word.lowered[-2:] == "ze":
|
|
for k, v in pl_sb_ze_zes_bysize.items():
|
|
if word.lowered[-k:] in v:
|
|
return f"{word}s"
|
|
|
|
if word.lowered[-2:] in ("ch", "sh", "zz", "ss") or word.lowered[-1] == "x":
|
|
return f"{word}es"
|
|
|
|
# HANDLE ...f -> ...ves
|
|
|
|
if word.lowered[-3:] in ("elf", "alf", "olf"):
|
|
return f"{word[:-1]}ves"
|
|
if word.lowered[-3:] == "eaf" and word.lowered[-4:-3] != "d":
|
|
return f"{word[:-1]}ves"
|
|
if word.lowered[-4:] in ("nife", "life", "wife"):
|
|
return f"{word[:-2]}ves"
|
|
if word.lowered[-3:] == "arf":
|
|
return f"{word[:-1]}ves"
|
|
|
|
# HANDLE ...y
|
|
|
|
if word.lowered[-1] == "y":
|
|
if word.lowered[-2:-1] in "aeiou" or len(word) == 1:
|
|
return f"{word}s"
|
|
|
|
if self.classical_dict["names"]:
|
|
if word.lowered[-1] == "y" and word[0] == word[0].upper():
|
|
return f"{word}s"
|
|
|
|
return f"{word[:-1]}ies"
|
|
|
|
# HANDLE ...o
|
|
|
|
if lowered_last in pl_sb_U_o_os_complete:
|
|
return f"{word}s"
|
|
|
|
for k, v in pl_sb_U_o_os_bysize.items():
|
|
if word.lowered[-k:] in v:
|
|
return f"{word}s"
|
|
|
|
if word.lowered[-2:] in ("ao", "eo", "io", "oo", "uo"):
|
|
return f"{word}s"
|
|
|
|
if word.lowered[-1] == "o":
|
|
return f"{word}es"
|
|
|
|
# OTHERWISE JUST ADD ...s
|
|
|
|
return f"{word}s"
|
|
|
|
@classmethod
|
|
def _handle_prepositional_phrase(cls, phrase, transform, sep):
|
|
"""
|
|
Given a word or phrase possibly separated by sep, parse out
|
|
the prepositional phrase and apply the transform to the word
|
|
preceding the prepositional phrase.
|
|
|
|
Raise ValueError if the pivot is not found or if at least two
|
|
separators are not found.
|
|
|
|
>>> engine._handle_prepositional_phrase("man-of-war", str.upper, '-')
|
|
'MAN-of-war'
|
|
>>> engine._handle_prepositional_phrase("man of war", str.upper, ' ')
|
|
'MAN of war'
|
|
"""
|
|
parts = phrase.split(sep)
|
|
if len(parts) < 3:
|
|
raise ValueError("Cannot handle words with fewer than two separators")
|
|
|
|
pivot = cls._find_pivot(parts, pl_prep_list_da)
|
|
|
|
transformed = transform(parts[pivot - 1]) or parts[pivot - 1]
|
|
return " ".join(
|
|
parts[: pivot - 1] + [sep.join([transformed, parts[pivot], ''])]
|
|
) + " ".join(parts[(pivot + 1) :])
|
|
|
|
def _handle_long_compounds(self, word: Words, count: int) -> Union[str, None]:
|
|
"""
|
|
Handles the plural and singular for compound `Words` that
|
|
have three or more words, based on the given count.
|
|
|
|
>>> engine()._handle_long_compounds(Words("pair of scissors"), 2)
|
|
'pairs of scissors'
|
|
>>> engine()._handle_long_compounds(Words("men beyond hills"), 1)
|
|
'man beyond hills'
|
|
"""
|
|
inflection = self._sinoun if count == 1 else self._plnoun
|
|
solutions = ( # type: ignore
|
|
" ".join(
|
|
itertools.chain(
|
|
leader,
|
|
[inflection(cand, count), prep], # type: ignore
|
|
trailer,
|
|
)
|
|
)
|
|
for leader, (cand, prep), trailer in windowed_complete(word.split_, 2)
|
|
if prep in pl_prep_list_da # type: ignore
|
|
)
|
|
return next(solutions, None)
|
|
|
|
@staticmethod
|
|
def _find_pivot(words, candidates):
|
|
pivots = (
|
|
index for index in range(1, len(words) - 1) if words[index] in candidates
|
|
)
|
|
try:
|
|
return next(pivots)
|
|
except StopIteration:
|
|
raise ValueError("No pivot found") from None
|
|
|
|
def _pl_special_verb( # noqa: C901
|
|
self, word: str, count: Optional[Union[str, int]] = None
|
|
) -> Union[str, bool]:
|
|
if self.classical_dict["zero"] and str(count).lower() in pl_count_zero:
|
|
return False
|
|
count = self.get_count(count)
|
|
|
|
if count == 1:
|
|
return word
|
|
|
|
# HANDLE USER-DEFINED VERBS
|
|
|
|
value = self.ud_match(word, self.pl_v_user_defined)
|
|
if value is not None:
|
|
return value
|
|
|
|
# HANDLE IRREGULAR PRESENT TENSE (SIMPLE AND COMPOUND)
|
|
|
|
try:
|
|
words = Words(word)
|
|
except IndexError:
|
|
return False # word is ''
|
|
|
|
if words.first in plverb_irregular_pres:
|
|
return f"{plverb_irregular_pres[words.first]}{words[len(words.first) :]}"
|
|
|
|
# HANDLE IRREGULAR FUTURE, PRETERITE AND PERFECT TENSES
|
|
|
|
if words.first in plverb_irregular_non_pres:
|
|
return word
|
|
|
|
# HANDLE PRESENT NEGATIONS (SIMPLE AND COMPOUND)
|
|
|
|
if words.first.endswith("n't") and words.first[:-3] in plverb_irregular_pres:
|
|
return (
|
|
f"{plverb_irregular_pres[words.first[:-3]]}n't"
|
|
f"{words[len(words.first) :]}"
|
|
)
|
|
|
|
if words.first.endswith("n't"):
|
|
return word
|
|
|
|
# HANDLE SPECIAL CASES
|
|
|
|
mo = PLVERB_SPECIAL_S_RE.search(word)
|
|
if mo:
|
|
return False
|
|
if WHITESPACE.search(word):
|
|
return False
|
|
|
|
if words.lowered == "quizzes":
|
|
return "quiz"
|
|
|
|
# HANDLE STANDARD 3RD PERSON (CHOP THE ...(e)s OFF SINGLE WORDS)
|
|
|
|
if (
|
|
words.lowered[-4:] in ("ches", "shes", "zzes", "sses")
|
|
or words.lowered[-3:] == "xes"
|
|
):
|
|
return words[:-2]
|
|
|
|
if words.lowered[-3:] == "ies" and len(words) > 3:
|
|
return words.lowered[:-3] + "y"
|
|
|
|
if (
|
|
words.last.lower() in pl_v_oes_oe
|
|
or words.lowered[-4:] in pl_v_oes_oe_endings_size4
|
|
or words.lowered[-5:] in pl_v_oes_oe_endings_size5
|
|
):
|
|
return words[:-1]
|
|
|
|
if words.lowered.endswith("oes") and len(words) > 3:
|
|
return words.lowered[:-2]
|
|
|
|
mo = ENDS_WITH_S.search(words)
|
|
if mo:
|
|
return mo.group(1)
|
|
|
|
# OTHERWISE, A REGULAR VERB (HANDLE ELSEWHERE)
|
|
|
|
return False
|
|
|
|
def _pl_general_verb(
|
|
self, word: str, count: Optional[Union[str, int]] = None
|
|
) -> str:
|
|
count = self.get_count(count)
|
|
|
|
if count == 1:
|
|
return word
|
|
|
|
# HANDLE AMBIGUOUS PRESENT TENSES (SIMPLE AND COMPOUND)
|
|
|
|
mo = plverb_ambiguous_pres_keys.search(word)
|
|
if mo:
|
|
return f"{plverb_ambiguous_pres[mo.group(1).lower()]}{mo.group(2)}"
|
|
|
|
# HANDLE AMBIGUOUS PRETERITE AND PERFECT TENSES
|
|
|
|
mo = plverb_ambiguous_non_pres.search(word)
|
|
if mo:
|
|
return word
|
|
|
|
# OTHERWISE, 1st OR 2ND PERSON IS UNINFLECTED
|
|
|
|
return word
|
|
|
|
def _pl_special_adjective(
|
|
self, word: str, count: Optional[Union[str, int]] = None
|
|
) -> Union[str, bool]:
|
|
count = self.get_count(count)
|
|
|
|
if count == 1:
|
|
return word
|
|
|
|
# HANDLE USER-DEFINED ADJECTIVES
|
|
|
|
value = self.ud_match(word, self.pl_adj_user_defined)
|
|
if value is not None:
|
|
return value
|
|
|
|
# HANDLE KNOWN CASES
|
|
|
|
mo = pl_adj_special_keys.search(word)
|
|
if mo:
|
|
return pl_adj_special[mo.group(1).lower()]
|
|
|
|
# HANDLE POSSESSIVES
|
|
|
|
mo = pl_adj_poss_keys.search(word)
|
|
if mo:
|
|
return pl_adj_poss[mo.group(1).lower()]
|
|
|
|
mo = ENDS_WITH_APOSTROPHE_S.search(word)
|
|
if mo:
|
|
pl = self.plural_noun(mo.group(1))
|
|
trailing_s = "" if pl[-1] == "s" else "s"
|
|
return f"{pl}'{trailing_s}"
|
|
|
|
# OTHERWISE, NO IDEA
|
|
|
|
return False
|
|
|
|
# @profile
|
|
def _sinoun( # noqa: C901
|
|
self,
|
|
word: str,
|
|
count: Optional[Union[str, int]] = None,
|
|
gender: Optional[str] = None,
|
|
) -> Union[str, bool]:
|
|
count = self.get_count(count)
|
|
|
|
# DEFAULT TO PLURAL
|
|
|
|
if count == 2:
|
|
return word
|
|
|
|
# SET THE GENDER
|
|
|
|
try:
|
|
if gender is None:
|
|
gender = self.thegender
|
|
elif gender not in singular_pronoun_genders:
|
|
raise BadGenderError
|
|
except (TypeError, IndexError) as err:
|
|
raise BadGenderError from err
|
|
|
|
# HANDLE USER-DEFINED NOUNS
|
|
|
|
value = self.ud_match(word, self.si_sb_user_defined)
|
|
if value is not None:
|
|
return value
|
|
|
|
# HANDLE EMPTY WORD, SINGULAR COUNT AND UNINFLECTED PLURALS
|
|
|
|
if word == "":
|
|
return word
|
|
|
|
if word in si_sb_ois_oi_case:
|
|
return word[:-1]
|
|
|
|
words = Words(word)
|
|
|
|
if words.last.lower() in pl_sb_uninflected_complete:
|
|
if len(words.split_) >= 3:
|
|
return self._handle_long_compounds(words, count=1) or word
|
|
return word
|
|
|
|
if word in pl_sb_uninflected_caps:
|
|
return word
|
|
|
|
for k, v in pl_sb_uninflected_bysize.items():
|
|
if words.lowered[-k:] in v:
|
|
return word
|
|
|
|
if self.classical_dict["herd"] and words.last.lower() in pl_sb_uninflected_herd:
|
|
return word
|
|
|
|
if words.last.lower() in pl_sb_C_us_us:
|
|
return word if self.classical_dict["ancient"] else False
|
|
|
|
# HANDLE COMPOUNDS ("Governor General", "mother-in-law", "aide-de-camp", ETC.)
|
|
|
|
mo = PL_SB_POSTFIX_ADJ_STEMS_RE.search(word)
|
|
if mo and mo.group(2) != "":
|
|
return f"{self._sinoun(mo.group(1), 1, gender=gender)}{mo.group(2)}"
|
|
|
|
with contextlib.suppress(ValueError):
|
|
return self._handle_prepositional_phrase(
|
|
words.lowered,
|
|
functools.partial(self._sinoun, count=1, gender=gender),
|
|
' ',
|
|
)
|
|
|
|
with contextlib.suppress(ValueError):
|
|
return self._handle_prepositional_phrase(
|
|
words.lowered,
|
|
functools.partial(self._sinoun, count=1, gender=gender),
|
|
'-',
|
|
)
|
|
|
|
# HANDLE PRONOUNS
|
|
|
|
for k, v in si_pron_acc_keys_bysize.items():
|
|
if words.lowered[-k:] in v: # ends with accusative pronoun
|
|
for pk, pv in pl_prep_bysize.items():
|
|
if words.lowered[:pk] in pv: # starts with a prep
|
|
if words.lowered.split() == [
|
|
words.lowered[:pk],
|
|
words.lowered[-k:],
|
|
]:
|
|
# only whitespace in between
|
|
return words.lowered[:-k] + get_si_pron(
|
|
"acc", words.lowered[-k:], gender
|
|
)
|
|
|
|
try:
|
|
return get_si_pron("nom", words.lowered, gender)
|
|
except KeyError:
|
|
pass
|
|
|
|
try:
|
|
return get_si_pron("acc", words.lowered, gender)
|
|
except KeyError:
|
|
pass
|
|
|
|
# HANDLE ISOLATED IRREGULAR PLURALS
|
|
|
|
if words.last in si_sb_irregular_caps:
|
|
llen = len(words.last)
|
|
return f"{word[:-llen]}{si_sb_irregular_caps[words.last]}"
|
|
|
|
if words.last.lower() in si_sb_irregular:
|
|
llen = len(words.last.lower())
|
|
return f"{word[:-llen]}{si_sb_irregular[words.last.lower()]}"
|
|
|
|
dash_split = words.lowered.split("-")
|
|
if (" ".join(dash_split[-2:])).lower() in si_sb_irregular_compound:
|
|
llen = len(
|
|
" ".join(dash_split[-2:])
|
|
) # TODO: what if 2 spaces between these words?
|
|
return "{}{}".format(
|
|
word[:-llen],
|
|
si_sb_irregular_compound[(" ".join(dash_split[-2:])).lower()],
|
|
)
|
|
|
|
if words.lowered[-5:] == "quies":
|
|
return word[:-3] + "y"
|
|
|
|
if words.lowered[-7:] == "persons":
|
|
return word[:-1]
|
|
if words.lowered[-6:] == "people":
|
|
return word[:-4] + "rson"
|
|
|
|
# HANDLE FAMILIES OF IRREGULAR PLURALS
|
|
|
|
if words.lowered[-4:] == "mans":
|
|
for k, v in si_sb_U_man_mans_bysize.items():
|
|
if words.lowered[-k:] in v:
|
|
return word[:-1]
|
|
for k, v in si_sb_U_man_mans_caps_bysize.items():
|
|
if word[-k:] in v:
|
|
return word[:-1]
|
|
if words.lowered[-3:] == "men":
|
|
return word[:-3] + "man"
|
|
if words.lowered[-4:] == "mice":
|
|
return word[:-4] + "mouse"
|
|
if words.lowered[-4:] == "lice":
|
|
v = si_sb_U_louse_lice_bysize.get(len(word))
|
|
if v and words.lowered in v:
|
|
return word[:-4] + "louse"
|
|
if words.lowered[-5:] == "geese":
|
|
return word[:-5] + "goose"
|
|
if words.lowered[-5:] == "teeth":
|
|
return word[:-5] + "tooth"
|
|
if words.lowered[-4:] == "feet":
|
|
return word[:-4] + "foot"
|
|
|
|
if words.lowered == "dice":
|
|
return "die"
|
|
|
|
# HANDLE UNASSIMILATED IMPORTS
|
|
|
|
if words.lowered[-4:] == "ceps":
|
|
return word
|
|
if words.lowered[-3:] == "zoa":
|
|
return word[:-1] + "on"
|
|
|
|
for lastlet, d, unass_numend, post in (
|
|
("s", si_sb_U_ch_chs_bysize, -1, ""),
|
|
("s", si_sb_U_ex_ices_bysize, -4, "ex"),
|
|
("s", si_sb_U_ix_ices_bysize, -4, "ix"),
|
|
("a", si_sb_U_um_a_bysize, -1, "um"),
|
|
("i", si_sb_U_us_i_bysize, -1, "us"),
|
|
("a", si_sb_U_on_a_bysize, -1, "on"),
|
|
("e", si_sb_U_a_ae_bysize, -1, ""),
|
|
):
|
|
if words.lowered[-1] == lastlet: # this test to add speed
|
|
for k, v in d.items():
|
|
if words.lowered[-k:] in v:
|
|
return word[:unass_numend] + post
|
|
|
|
# HANDLE INCOMPLETELY ASSIMILATED IMPORTS
|
|
|
|
if self.classical_dict["ancient"]:
|
|
if words.lowered[-6:] == "trices":
|
|
return word[:-3] + "x"
|
|
if words.lowered[-4:] in ("eaux", "ieux"):
|
|
return word[:-1]
|
|
if words.lowered[-5:] in ("ynges", "inges", "anges") and len(word) > 6:
|
|
return word[:-3] + "x"
|
|
|
|
for lastlet, d, class_numend, post in (
|
|
("a", si_sb_C_en_ina_bysize, -3, "en"),
|
|
("s", si_sb_C_ex_ices_bysize, -4, "ex"),
|
|
("s", si_sb_C_ix_ices_bysize, -4, "ix"),
|
|
("a", si_sb_C_um_a_bysize, -1, "um"),
|
|
("i", si_sb_C_us_i_bysize, -1, "us"),
|
|
("s", pl_sb_C_us_us_bysize, None, ""),
|
|
("e", si_sb_C_a_ae_bysize, -1, ""),
|
|
("a", si_sb_C_a_ata_bysize, -2, ""),
|
|
("s", si_sb_C_is_ides_bysize, -3, "s"),
|
|
("i", si_sb_C_o_i_bysize, -1, "o"),
|
|
("a", si_sb_C_on_a_bysize, -1, "on"),
|
|
("m", si_sb_C_im_bysize, -2, ""),
|
|
("i", si_sb_C_i_bysize, -1, ""),
|
|
):
|
|
if words.lowered[-1] == lastlet: # this test to add speed
|
|
for k, v in d.items():
|
|
if words.lowered[-k:] in v:
|
|
return word[:class_numend] + post
|
|
|
|
# HANDLE PLURLS ENDING IN uses -> use
|
|
|
|
if (
|
|
words.lowered[-6:] == "houses"
|
|
or word in si_sb_uses_use_case
|
|
or words.last.lower() in si_sb_uses_use
|
|
):
|
|
return word[:-1]
|
|
|
|
# HANDLE PLURLS ENDING IN ies -> ie
|
|
|
|
if word in si_sb_ies_ie_case or words.last.lower() in si_sb_ies_ie:
|
|
return word[:-1]
|
|
|
|
# HANDLE PLURLS ENDING IN oes -> oe
|
|
|
|
if (
|
|
words.lowered[-5:] == "shoes"
|
|
or word in si_sb_oes_oe_case
|
|
or words.last.lower() in si_sb_oes_oe
|
|
):
|
|
return word[:-1]
|
|
|
|
# HANDLE SINGULAR NOUNS ENDING IN ...s OR OTHER SILIBANTS
|
|
|
|
if word in si_sb_sses_sse_case or words.last.lower() in si_sb_sses_sse:
|
|
return word[:-1]
|
|
|
|
if words.last.lower() in si_sb_singular_s_complete:
|
|
return word[:-2]
|
|
|
|
for k, v in si_sb_singular_s_bysize.items():
|
|
if words.lowered[-k:] in v:
|
|
return word[:-2]
|
|
|
|
if words.lowered[-4:] == "eses" and word[0] == word[0].upper():
|
|
return word[:-2]
|
|
|
|
if words.last.lower() in si_sb_z_zes:
|
|
return word[:-2]
|
|
|
|
if words.last.lower() in si_sb_zzes_zz:
|
|
return word[:-2]
|
|
|
|
if words.lowered[-4:] == "zzes":
|
|
return word[:-3]
|
|
|
|
if word in si_sb_ches_che_case or words.last.lower() in si_sb_ches_che:
|
|
return word[:-1]
|
|
|
|
if words.lowered[-4:] in ("ches", "shes"):
|
|
return word[:-2]
|
|
|
|
if words.last.lower() in si_sb_xes_xe:
|
|
return word[:-1]
|
|
|
|
if words.lowered[-3:] == "xes":
|
|
return word[:-2]
|
|
|
|
# HANDLE ...f -> ...ves
|
|
|
|
if word in si_sb_ves_ve_case or words.last.lower() in si_sb_ves_ve:
|
|
return word[:-1]
|
|
|
|
if words.lowered[-3:] == "ves":
|
|
if words.lowered[-5:-3] in ("el", "al", "ol"):
|
|
return word[:-3] + "f"
|
|
if words.lowered[-5:-3] == "ea" and word[-6:-5] != "d":
|
|
return word[:-3] + "f"
|
|
if words.lowered[-5:-3] in ("ni", "li", "wi"):
|
|
return word[:-3] + "fe"
|
|
if words.lowered[-5:-3] == "ar":
|
|
return word[:-3] + "f"
|
|
|
|
# HANDLE ...y
|
|
|
|
if words.lowered[-2:] == "ys":
|
|
if len(words.lowered) > 2 and words.lowered[-3] in "aeiou":
|
|
return word[:-1]
|
|
|
|
if self.classical_dict["names"]:
|
|
if words.lowered[-2:] == "ys" and word[0] == word[0].upper():
|
|
return word[:-1]
|
|
|
|
if words.lowered[-3:] == "ies":
|
|
return word[:-3] + "y"
|
|
|
|
# HANDLE ...o
|
|
|
|
if words.lowered[-2:] == "os":
|
|
if words.last.lower() in si_sb_U_o_os_complete:
|
|
return word[:-1]
|
|
|
|
for k, v in si_sb_U_o_os_bysize.items():
|
|
if words.lowered[-k:] in v:
|
|
return word[:-1]
|
|
|
|
if words.lowered[-3:] in ("aos", "eos", "ios", "oos", "uos"):
|
|
return word[:-1]
|
|
|
|
if words.lowered[-3:] == "oes":
|
|
return word[:-2]
|
|
|
|
# UNASSIMILATED IMPORTS FINAL RULE
|
|
|
|
if word in si_sb_es_is:
|
|
return word[:-2] + "is"
|
|
|
|
# OTHERWISE JUST REMOVE ...s
|
|
|
|
if words.lowered[-1] == "s":
|
|
return word[:-1]
|
|
|
|
# COULD NOT FIND SINGULAR
|
|
|
|
return False
|
|
|
|
# ADJECTIVES
|
|
|
|
@typechecked
|
|
def a(self, text: Word, count: Optional[Union[int, str, Any]] = 1) -> str:
|
|
"""
|
|
Return the appropriate indefinite article followed by text.
|
|
|
|
The indefinite article is either 'a' or 'an'.
|
|
|
|
If count is not one, then return count followed by text
|
|
instead of 'a' or 'an'.
|
|
|
|
Whitespace at the start and end is preserved.
|
|
|
|
"""
|
|
mo = INDEFINITE_ARTICLE_TEST.search(text)
|
|
if mo:
|
|
word = mo.group(2)
|
|
if not word:
|
|
return text
|
|
pre = mo.group(1)
|
|
post = mo.group(3)
|
|
result = self._indef_article(word, count)
|
|
return f"{pre}{result}{post}"
|
|
return ""
|
|
|
|
an = a
|
|
|
|
_indef_article_cases = (
|
|
# HANDLE ORDINAL FORMS
|
|
(A_ordinal_a, "a"),
|
|
(A_ordinal_an, "an"),
|
|
# HANDLE SPECIAL CASES
|
|
(A_explicit_an, "an"),
|
|
(SPECIAL_AN, "an"),
|
|
(SPECIAL_A, "a"),
|
|
# HANDLE ABBREVIATIONS
|
|
(A_abbrev, "an"),
|
|
(SPECIAL_ABBREV_AN, "an"),
|
|
(SPECIAL_ABBREV_A, "a"),
|
|
# HANDLE CONSONANTS
|
|
(CONSONANTS, "a"),
|
|
# HANDLE SPECIAL VOWEL-FORMS
|
|
(ARTICLE_SPECIAL_EU, "a"),
|
|
(ARTICLE_SPECIAL_ONCE, "a"),
|
|
(ARTICLE_SPECIAL_ONETIME, "a"),
|
|
(ARTICLE_SPECIAL_UNIT, "a"),
|
|
(ARTICLE_SPECIAL_UBA, "a"),
|
|
(ARTICLE_SPECIAL_UKR, "a"),
|
|
(A_explicit_a, "a"),
|
|
# HANDLE SPECIAL CAPITALS
|
|
(SPECIAL_CAPITALS, "a"),
|
|
# HANDLE VOWELS
|
|
(VOWELS, "an"),
|
|
# HANDLE y...
|
|
# (BEFORE CERTAIN CONSONANTS IMPLIES (UNNATURALIZED) "i.." SOUND)
|
|
(A_y_cons, "an"),
|
|
)
|
|
|
|
def _indef_article(self, word: str, count: Union[int, str, Any]) -> str:
|
|
mycount = self.get_count(count)
|
|
|
|
if mycount != 1:
|
|
return f"{count} {word}"
|
|
|
|
# HANDLE USER-DEFINED VARIANTS
|
|
|
|
value = self.ud_match(word, self.A_a_user_defined)
|
|
if value is not None:
|
|
return f"{value} {word}"
|
|
|
|
matches = (
|
|
f'{article} {word}'
|
|
for regexen, article in self._indef_article_cases
|
|
if regexen.search(word)
|
|
)
|
|
|
|
# OTHERWISE, GUESS "a"
|
|
fallback = f'a {word}'
|
|
return next(matches, fallback)
|
|
|
|
# 2. TRANSLATE ZERO-QUANTIFIED $word TO "no plural($word)"
|
|
|
|
@typechecked
|
|
def no(self, text: Word, count: Optional[Union[int, str]] = None) -> str:
|
|
"""
|
|
If count is 0, no, zero or nil, return 'no' followed by the plural
|
|
of text.
|
|
|
|
If count is one of:
|
|
1, a, an, one, each, every, this, that
|
|
return count followed by text.
|
|
|
|
Otherwise return count follow by the plural of text.
|
|
|
|
In the return value count is always followed by a space.
|
|
|
|
Whitespace at the start and end is preserved.
|
|
|
|
"""
|
|
if count is None and self.persistent_count is not None:
|
|
count = self.persistent_count
|
|
|
|
if count is None:
|
|
count = 0
|
|
mo = PARTITION_WORD.search(text)
|
|
if mo:
|
|
pre = mo.group(1)
|
|
word = mo.group(2)
|
|
post = mo.group(3)
|
|
else:
|
|
pre = ""
|
|
word = ""
|
|
post = ""
|
|
|
|
if str(count).lower() in pl_count_zero:
|
|
count = 'no'
|
|
return f"{pre}{count} {self.plural(word, count)}{post}"
|
|
|
|
# PARTICIPLES
|
|
|
|
@typechecked
|
|
def present_participle(self, word: Word) -> str:
|
|
"""
|
|
Return the present participle for word.
|
|
|
|
word is the 3rd person singular verb.
|
|
|
|
"""
|
|
plv = self.plural_verb(word, 2)
|
|
ans = plv
|
|
|
|
for regexen, repl in PRESENT_PARTICIPLE_REPLACEMENTS:
|
|
ans, num = regexen.subn(repl, plv)
|
|
if num:
|
|
return f"{ans}ing"
|
|
return f"{ans}ing"
|
|
|
|
# NUMERICAL INFLECTIONS
|
|
|
|
@typechecked
|
|
def ordinal(self, num: Union[Number, Word]) -> str:
|
|
"""
|
|
Return the ordinal of num.
|
|
|
|
>>> ordinal = engine().ordinal
|
|
>>> ordinal(1)
|
|
'1st'
|
|
>>> ordinal('one')
|
|
'first'
|
|
"""
|
|
if DIGIT.match(str(num)):
|
|
if isinstance(num, (float, int)) and int(num) == num:
|
|
n = int(num)
|
|
else:
|
|
if "." in str(num):
|
|
try:
|
|
# numbers after decimal,
|
|
# so only need last one for ordinal
|
|
n = int(str(num)[-1])
|
|
|
|
except ValueError: # ends with '.', so need to use whole string
|
|
n = int(str(num)[:-1])
|
|
else:
|
|
n = int(num) # type: ignore
|
|
try:
|
|
post = nth[n % 100]
|
|
except KeyError:
|
|
post = nth[n % 10]
|
|
return f"{num}{post}"
|
|
else:
|
|
return self._sub_ord(num)
|
|
|
|
def millfn(self, ind: int = 0) -> str:
|
|
if ind > len(mill) - 1:
|
|
raise NumOutOfRangeError
|
|
return mill[ind]
|
|
|
|
def unitfn(self, units: int, mindex: int = 0) -> str:
|
|
return f"{unit[units]}{self.millfn(mindex)}"
|
|
|
|
def tenfn(self, tens, units, mindex=0) -> str:
|
|
if tens != 1:
|
|
tens_part = ten[tens]
|
|
if tens and units:
|
|
hyphen = "-"
|
|
else:
|
|
hyphen = ""
|
|
unit_part = unit[units]
|
|
mill_part = self.millfn(mindex)
|
|
return f"{tens_part}{hyphen}{unit_part}{mill_part}"
|
|
return f"{teen[units]}{mill[mindex]}"
|
|
|
|
def hundfn(self, hundreds: int, tens: int, units: int, mindex: int) -> str:
|
|
if hundreds:
|
|
andword = f" {self._number_args['andword']} " if tens or units else ""
|
|
# use unit not unitfn as simpler
|
|
return (
|
|
f"{unit[hundreds]} hundred{andword}"
|
|
f"{self.tenfn(tens, units)}{self.millfn(mindex)}, "
|
|
)
|
|
if tens or units:
|
|
return f"{self.tenfn(tens, units)}{self.millfn(mindex)}, "
|
|
return ""
|
|
|
|
def group1sub(self, mo: Match) -> str:
|
|
units = int(mo.group(1))
|
|
if units == 1:
|
|
return f" {self._number_args['one']}, "
|
|
elif units:
|
|
return f"{unit[units]}, "
|
|
else:
|
|
return f" {self._number_args['zero']}, "
|
|
|
|
def group1bsub(self, mo: Match) -> str:
|
|
units = int(mo.group(1))
|
|
if units:
|
|
return f"{unit[units]}, "
|
|
else:
|
|
return f" {self._number_args['zero']}, "
|
|
|
|
def group2sub(self, mo: Match) -> str:
|
|
tens = int(mo.group(1))
|
|
units = int(mo.group(2))
|
|
if tens:
|
|
return f"{self.tenfn(tens, units)}, "
|
|
if units:
|
|
return f" {self._number_args['zero']} {unit[units]}, "
|
|
return f" {self._number_args['zero']} {self._number_args['zero']}, "
|
|
|
|
def group3sub(self, mo: Match) -> str:
|
|
hundreds = int(mo.group(1))
|
|
tens = int(mo.group(2))
|
|
units = int(mo.group(3))
|
|
if hundreds == 1:
|
|
hunword = f" {self._number_args['one']}"
|
|
elif hundreds:
|
|
hunword = str(unit[hundreds])
|
|
else:
|
|
hunword = f" {self._number_args['zero']}"
|
|
if tens:
|
|
tenword = self.tenfn(tens, units)
|
|
elif units:
|
|
tenword = f" {self._number_args['zero']} {unit[units]}"
|
|
else:
|
|
tenword = f" {self._number_args['zero']} {self._number_args['zero']}"
|
|
return f"{hunword} {tenword}, "
|
|
|
|
def hundsub(self, mo: Match) -> str:
|
|
ret = self.hundfn(
|
|
int(mo.group(1)), int(mo.group(2)), int(mo.group(3)), self.mill_count
|
|
)
|
|
self.mill_count += 1
|
|
return ret
|
|
|
|
def tensub(self, mo: Match) -> str:
|
|
return f"{self.tenfn(int(mo.group(1)), int(mo.group(2)), self.mill_count)}, "
|
|
|
|
def unitsub(self, mo: Match) -> str:
|
|
return f"{self.unitfn(int(mo.group(1)), self.mill_count)}, "
|
|
|
|
def enword(self, num: str, group: int) -> str:
|
|
# import pdb
|
|
# pdb.set_trace()
|
|
|
|
if group == 1:
|
|
num = DIGIT_GROUP.sub(self.group1sub, num)
|
|
elif group == 2:
|
|
num = TWO_DIGITS.sub(self.group2sub, num)
|
|
num = DIGIT_GROUP.sub(self.group1bsub, num, 1)
|
|
elif group == 3:
|
|
num = THREE_DIGITS.sub(self.group3sub, num)
|
|
num = TWO_DIGITS.sub(self.group2sub, num, 1)
|
|
num = DIGIT_GROUP.sub(self.group1sub, num, 1)
|
|
elif int(num) == 0:
|
|
num = self._number_args["zero"]
|
|
elif int(num) == 1:
|
|
num = self._number_args["one"]
|
|
else:
|
|
num = num.lstrip().lstrip("0")
|
|
self.mill_count = 0
|
|
# surely there's a better way to do the next bit
|
|
mo = THREE_DIGITS_WORD.search(num)
|
|
while mo:
|
|
num = THREE_DIGITS_WORD.sub(self.hundsub, num, 1)
|
|
mo = THREE_DIGITS_WORD.search(num)
|
|
num = TWO_DIGITS_WORD.sub(self.tensub, num, 1)
|
|
num = ONE_DIGIT_WORD.sub(self.unitsub, num, 1)
|
|
return num
|
|
|
|
@staticmethod
|
|
def _sub_ord(val):
|
|
new = ordinal_suff.sub(lambda match: ordinal[match.group(1)], val)
|
|
return new + "th" * (new == val)
|
|
|
|
@classmethod
|
|
def _chunk_num(cls, num, decimal, group):
|
|
if decimal:
|
|
max_split = -1 if group != 0 else 1
|
|
chunks = num.split(".", max_split)
|
|
else:
|
|
chunks = [num]
|
|
return cls._remove_last_blank(chunks)
|
|
|
|
@staticmethod
|
|
def _remove_last_blank(chunks):
|
|
"""
|
|
Remove the last item from chunks if it's a blank string.
|
|
|
|
Return the resultant chunks and whether the last item was removed.
|
|
"""
|
|
removed = chunks[-1] == ""
|
|
result = chunks[:-1] if removed else chunks
|
|
return result, removed
|
|
|
|
@staticmethod
|
|
def _get_sign(num):
|
|
return {'+': 'plus', '-': 'minus'}.get(num.lstrip()[0], '')
|
|
|
|
@typechecked
|
|
def number_to_words( # noqa: C901
|
|
self,
|
|
num: Union[Number, Word],
|
|
wantlist: bool = False,
|
|
group: int = 0,
|
|
comma: Union[Falsish, str] = ",",
|
|
andword: str = "and",
|
|
zero: str = "zero",
|
|
one: str = "one",
|
|
decimal: Union[Falsish, str] = "point",
|
|
threshold: Optional[int] = None,
|
|
) -> Union[str, List[str]]:
|
|
"""
|
|
Return a number in words.
|
|
|
|
group = 1, 2 or 3 to group numbers before turning into words
|
|
comma: define comma
|
|
|
|
andword:
|
|
word for 'and'. Can be set to ''.
|
|
e.g. "one hundred and one" vs "one hundred one"
|
|
|
|
zero: word for '0'
|
|
one: word for '1'
|
|
decimal: word for decimal point
|
|
threshold: numbers above threshold not turned into words
|
|
|
|
parameters not remembered from last call. Departure from Perl version.
|
|
"""
|
|
self._number_args = {"andword": andword, "zero": zero, "one": one}
|
|
num = str(num)
|
|
|
|
# Handle "stylistic" conversions (up to a given threshold)...
|
|
if threshold is not None and float(num) > threshold:
|
|
spnum = num.split(".", 1)
|
|
while comma:
|
|
(spnum[0], n) = FOUR_DIGIT_COMMA.subn(r"\1,\2", spnum[0])
|
|
if n == 0:
|
|
break
|
|
try:
|
|
return f"{spnum[0]}.{spnum[1]}"
|
|
except IndexError:
|
|
return str(spnum[0])
|
|
|
|
if group < 0 or group > 3:
|
|
raise BadChunkingOptionError
|
|
|
|
sign = self._get_sign(num)
|
|
|
|
if num in nth_suff:
|
|
num = zero
|
|
|
|
myord = num[-2:] in nth_suff
|
|
if myord:
|
|
num = num[:-2]
|
|
|
|
chunks, finalpoint = self._chunk_num(num, decimal, group)
|
|
|
|
loopstart = chunks[0] == ""
|
|
first: bool | None = not loopstart
|
|
|
|
def _handle_chunk(chunk):
|
|
nonlocal first
|
|
|
|
# remove all non numeric \D
|
|
chunk = NON_DIGIT.sub("", chunk)
|
|
if chunk == "":
|
|
chunk = "0"
|
|
|
|
if group == 0 and not first:
|
|
chunk = self.enword(chunk, 1)
|
|
else:
|
|
chunk = self.enword(chunk, group)
|
|
|
|
if chunk[-2:] == ", ":
|
|
chunk = chunk[:-2]
|
|
chunk = WHITESPACES_COMMA.sub(",", chunk)
|
|
|
|
if group == 0 and first:
|
|
chunk = COMMA_WORD.sub(f" {andword} \\1", chunk)
|
|
chunk = WHITESPACES.sub(" ", chunk)
|
|
# chunk = re.sub(r"(\A\s|\s\Z)", self.blankfn, chunk)
|
|
chunk = chunk.strip()
|
|
if first:
|
|
first = None
|
|
return chunk
|
|
|
|
chunks[loopstart:] = map(_handle_chunk, chunks[loopstart:])
|
|
|
|
numchunks = []
|
|
if first != 0:
|
|
numchunks = chunks[0].split(f"{comma} ")
|
|
|
|
if myord and numchunks:
|
|
numchunks[-1] = self._sub_ord(numchunks[-1])
|
|
|
|
for chunk in chunks[1:]:
|
|
numchunks.append(decimal)
|
|
numchunks.extend(chunk.split(f"{comma} "))
|
|
|
|
if finalpoint:
|
|
numchunks.append(decimal)
|
|
|
|
if wantlist:
|
|
return [sign] * bool(sign) + numchunks
|
|
|
|
signout = f"{sign} " if sign else ""
|
|
valout = (
|
|
', '.join(numchunks)
|
|
if group
|
|
else ''.join(self._render(numchunks, decimal, comma))
|
|
)
|
|
return signout + valout
|
|
|
|
@staticmethod
|
|
def _render(chunks, decimal, comma):
|
|
first_item = chunks.pop(0)
|
|
yield first_item
|
|
first = decimal is None or not first_item.endswith(decimal)
|
|
for nc in chunks:
|
|
if nc == decimal:
|
|
first = False
|
|
elif first:
|
|
yield comma
|
|
yield f" {nc}"
|
|
|
|
@typechecked
|
|
def join(
|
|
self,
|
|
words: Optional[Sequence[Word]],
|
|
sep: Optional[str] = None,
|
|
sep_spaced: bool = True,
|
|
final_sep: Optional[str] = None,
|
|
conj: str = "and",
|
|
conj_spaced: bool = True,
|
|
) -> str:
|
|
"""
|
|
Join words into a list.
|
|
|
|
e.g. join(['ant', 'bee', 'fly']) returns 'ant, bee, and fly'
|
|
|
|
options:
|
|
conj: replacement for 'and'
|
|
sep: separator. default ',', unless ',' is in the list then ';'
|
|
final_sep: final separator. default ',', unless ',' is in the list then ';'
|
|
conj_spaced: boolean. Should conj have spaces around it
|
|
|
|
"""
|
|
if not words:
|
|
return ""
|
|
if len(words) == 1:
|
|
return words[0]
|
|
|
|
if conj_spaced:
|
|
if conj == "":
|
|
conj = " "
|
|
else:
|
|
conj = f" {conj} "
|
|
|
|
if len(words) == 2:
|
|
return f"{words[0]}{conj}{words[1]}"
|
|
|
|
if sep is None:
|
|
if "," in "".join(words):
|
|
sep = ";"
|
|
else:
|
|
sep = ","
|
|
if final_sep is None:
|
|
final_sep = sep
|
|
|
|
final_sep = f"{final_sep}{conj}"
|
|
|
|
if sep_spaced:
|
|
sep += " "
|
|
|
|
return f"{sep.join(words[0:-1])}{final_sep}{words[-1]}"
|