py2docfx 0.1.11.dev1827111__py3-none-any.whl → 0.1.11.dev1859874__py3-none-any.whl

py2docfx/venv/template/Lib/site-packages/babel/messages/jslexer.py

@@ -1,203 +0,0 @@
-"""
-    babel.messages.jslexer
-    ~~~~~~~~~~~~~~~~~~~~~~
-
-    A simple JavaScript 1.5 lexer which is used for the JavaScript
-    extractor.
-
-    :copyright: (c) 2013-2024 by the Babel Team.
-    :license: BSD, see LICENSE for more details.
-"""
-from __future__ import annotations
-
-import re
-from collections.abc import Generator
-from typing import NamedTuple
-
-operators: list[str] = sorted([
-    '+', '-', '*', '%', '!=', '==', '<', '>', '<=', '>=', '=',
-    '+=', '-=', '*=', '%=', '<<', '>>', '>>>', '<<=', '>>=',
-    '>>>=', '&', '&=', '|', '|=', '&&', '||', '^', '^=', '(', ')',
-    '[', ']', '{', '}', '!', '--', '++', '~', ',', ';', '.', ':',
-], key=len, reverse=True)
-
-escapes: dict[str, str] = {'b': '\b', 'f': '\f', 'n': '\n', 'r': '\r', 't': '\t'}
-
-name_re = re.compile(r'[\w$_][\w\d$_]*', re.UNICODE)
-dotted_name_re = re.compile(r'[\w$_][\w\d$_.]*[\w\d$_.]', re.UNICODE)
-division_re = re.compile(r'/=?')
-regex_re = re.compile(r'/(?:[^/\\]*(?:\\.[^/\\]*)*)/[a-zA-Z]*', re.DOTALL)
-line_re = re.compile(r'(\r\n|\n|\r)')
-line_join_re = re.compile(r'\\' + line_re.pattern)
-uni_escape_re = re.compile(r'[a-fA-F0-9]{1,4}')
-hex_escape_re = re.compile(r'[a-fA-F0-9]{1,2}')
-
-
-class Token(NamedTuple):
-    type: str
-    value: str
-    lineno: int
-
-
-_rules: list[tuple[str | None, re.Pattern[str]]] = [
-    (None, re.compile(r'\s+', re.UNICODE)),
-    (None, re.compile(r'<!--.*')),
-    ('linecomment', re.compile(r'//.*')),
-    ('multilinecomment', re.compile(r'/\*.*?\*/', re.UNICODE | re.DOTALL)),
-    ('dotted_name', dotted_name_re),
-    ('name', name_re),
-    ('number', re.compile(r'''(
-        (?:0|[1-9]\d*)
-        (\.\d+)?
-        ([eE][-+]?\d+)? |
-        (0x[a-fA-F0-9]+)
-    )''', re.VERBOSE)),
-    ('jsx_tag', re.compile(r'(?:</?[^>\s]+|/>)', re.I)),  # May be mangled in `get_rules`
-    ('operator', re.compile(r'(%s)' % '|'.join(map(re.escape, operators)))),
-    ('template_string', re.compile(r'''`(?:[^`\\]*(?:\\.[^`\\]*)*)`''', re.UNICODE)),
-    ('string', re.compile(r'''(
-        '(?:[^'\\]*(?:\\.[^'\\]*)*)'  |
-        "(?:[^"\\]*(?:\\.[^"\\]*)*)"
-    )''', re.VERBOSE | re.DOTALL)),
-]
-
-
-def get_rules(jsx: bool, dotted: bool, template_string: bool) -> list[tuple[str | None, re.Pattern[str]]]:
-    """
-    Get a tokenization rule list given the passed syntax options.
-
-    Internal to this module.
-    """
-    rules = []
-    for token_type, rule in _rules:
-        if not jsx and token_type and 'jsx' in token_type:
-            continue
-        if not template_string and token_type == 'template_string':
-            continue
-        if token_type == 'dotted_name':
-            if not dotted:
-                continue
-            token_type = 'name'
-        rules.append((token_type, rule))
-    return rules
-
-
-def indicates_division(token: Token) -> bool:
-    """A helper function that helps the tokenizer to decide if the current
-    token may be followed by a division operator.
-    """
-    if token.type == 'operator':
-        return token.value in (')', ']', '}', '++', '--')
-    return token.type in ('name', 'number', 'string', 'regexp')
-
-
-def unquote_string(string: str) -> str:
-    """Unquote a string with JavaScript rules.  The string has to start with
-    string delimiters (``'``, ``"`` or the back-tick/grave accent (for template strings).)
-    """
-    assert string and string[0] == string[-1] and string[0] in '"\'`', \
-        'string provided is not properly delimited'
-    string = line_join_re.sub('\\1', string[1:-1])
-    result: list[str] = []
-    add = result.append
-    pos = 0
-
-    while True:
-        # scan for the next escape
-        escape_pos = string.find('\\', pos)
-        if escape_pos < 0:
-            break
-        add(string[pos:escape_pos])
-
-        # check which character is escaped
-        next_char = string[escape_pos + 1]
-        if next_char in escapes:
-            add(escapes[next_char])
-
-        # unicode escapes.  trie to consume up to four characters of
-        # hexadecimal characters and try to interpret them as unicode
-        # character point.  If there is no such character point, put
-        # all the consumed characters into the string.
-        elif next_char in 'uU':
-            escaped = uni_escape_re.match(string, escape_pos + 2)
-            if escaped is not None:
-                escaped_value = escaped.group()
-                if len(escaped_value) == 4:
-                    try:
-                        add(chr(int(escaped_value, 16)))
-                    except ValueError:
-                        pass
-                    else:
-                        pos = escape_pos + 6
-                        continue
-                add(next_char + escaped_value)
-                pos = escaped.end()
-                continue
-            else:
-                add(next_char)
-
-        # hex escapes. conversion from 2-digits hex to char is infallible
-        elif next_char in 'xX':
-            escaped = hex_escape_re.match(string, escape_pos + 2)
-            if escaped is not None:
-                escaped_value = escaped.group()
-                add(chr(int(escaped_value, 16)))
-                pos = escape_pos + 2 + len(escaped_value)
-                continue
-            else:
-                add(next_char)
-
-        # bogus escape.  Just remove the backslash.
-        else:
-            add(next_char)
-        pos = escape_pos + 2
-
-    if pos < len(string):
-        add(string[pos:])
-
-    return ''.join(result)
-
-
-def tokenize(source: str, jsx: bool = True, dotted: bool = True, template_string: bool = True, lineno: int = 1) -> Generator[Token, None, None]:
-    """
-    Tokenize JavaScript/JSX source.  Returns a generator of tokens.
-
-    :param jsx: Enable (limited) JSX parsing.
-    :param dotted: Read dotted names as single name token.
-    :param template_string: Support ES6 template strings
-    :param lineno: starting line number (optional)
-    """
-    may_divide = False
-    pos = 0
-    end = len(source)
-    rules = get_rules(jsx=jsx, dotted=dotted, template_string=template_string)
-
-    while pos < end:
-        # handle regular rules first
-        for token_type, rule in rules:  # noqa: B007
-            match = rule.match(source, pos)
-            if match is not None:
-                break
-        # if we don't have a match we don't give up yet, but check for
-        # division operators or regular expression literals, based on
-        # the status of `may_divide` which is determined by the last
-        # processed non-whitespace token using `indicates_division`.
-        else:
-            if may_divide:
-                match = division_re.match(source, pos)
-                token_type = 'operator'
-            else:
-                match = regex_re.match(source, pos)
-                token_type = 'regexp'
-            if match is None:
-                # woops. invalid syntax. jump one char ahead and try again.
-                pos += 1
-                continue
-
-        token_value = match.group()
-        if token_type is not None:
-            token = Token(token_type, token_value, lineno)
-            may_divide = indicates_division(token)
-            yield token
-        lineno += len(line_re.findall(token_value))
-        pos = match.end()

py2docfx/venv/template/Lib/site-packages/babel/messages/mofile.py

@@ -1,212 +0,0 @@
-"""
-    babel.messages.mofile
-    ~~~~~~~~~~~~~~~~~~~~~
-
-    Writing of files in the ``gettext`` MO (machine object) format.
-
-    :copyright: (c) 2013-2024 by the Babel Team.
-    :license: BSD, see LICENSE for more details.
-"""
-from __future__ import annotations
-
-import array
-import struct
-from typing import TYPE_CHECKING
-
-from babel.messages.catalog import Catalog, Message
-
-if TYPE_CHECKING:
-    from _typeshed import SupportsRead, SupportsWrite
-
-LE_MAGIC: int = 0x950412de
-BE_MAGIC: int = 0xde120495
-
-
-def read_mo(fileobj: SupportsRead[bytes]) -> Catalog:
-    """Read a binary MO file from the given file-like object and return a
-    corresponding `Catalog` object.
-
-    :param fileobj: the file-like object to read the MO file from
-
-    :note: The implementation of this function is heavily based on the
-           ``GNUTranslations._parse`` method of the ``gettext`` module in the
-           standard library.
-    """
-    catalog = Catalog()
-    headers = {}
-
-    filename = getattr(fileobj, 'name', '')
-
-    buf = fileobj.read()
-    buflen = len(buf)
-    unpack = struct.unpack
-
-    # Parse the .mo file header, which consists of 5 little endian 32
-    # bit words.
-    magic = unpack('<I', buf[:4])[0]  # Are we big endian or little endian?
-    if magic == LE_MAGIC:
-        version, msgcount, origidx, transidx = unpack('<4I', buf[4:20])
-        ii = '<II'
-    elif magic == BE_MAGIC:
-        version, msgcount, origidx, transidx = unpack('>4I', buf[4:20])
-        ii = '>II'
-    else:
-        raise OSError(0, 'Bad magic number', filename)
-
-    # Now put all messages from the .mo file buffer into the catalog
-    # dictionary
-    for _i in range(msgcount):
-        mlen, moff = unpack(ii, buf[origidx:origidx + 8])
-        mend = moff + mlen
-        tlen, toff = unpack(ii, buf[transidx:transidx + 8])
-        tend = toff + tlen
-        if mend < buflen and tend < buflen:
-            msg = buf[moff:mend]
-            tmsg = buf[toff:tend]
-        else:
-            raise OSError(0, 'File is corrupt', filename)
-
-        # See if we're looking at GNU .mo conventions for metadata
-        if mlen == 0:
-            # Catalog description
-            lastkey = key = None
-            for item in tmsg.splitlines():
-                item = item.strip()
-                if not item:
-                    continue
-                if b':' in item:
-                    key, value = item.split(b':', 1)
-                    lastkey = key = key.strip().lower()
-                    headers[key] = value.strip()
-                elif lastkey:
-                    headers[lastkey] += b'\n' + item
-
-        if b'\x04' in msg:  # context
-            ctxt, msg = msg.split(b'\x04')
-        else:
-            ctxt = None
-
-        if b'\x00' in msg:  # plural forms
-            msg = msg.split(b'\x00')
-            tmsg = tmsg.split(b'\x00')
-            if catalog.charset:
-                msg = [x.decode(catalog.charset) for x in msg]
-                tmsg = [x.decode(catalog.charset) for x in tmsg]
-        else:
-            if catalog.charset:
-                msg = msg.decode(catalog.charset)
-                tmsg = tmsg.decode(catalog.charset)
-        catalog[msg] = Message(msg, tmsg, context=ctxt)
-
-        # advance to next entry in the seek tables
-        origidx += 8
-        transidx += 8
-
-    catalog.mime_headers = headers.items()
-    return catalog
-
-
-def write_mo(fileobj: SupportsWrite[bytes], catalog: Catalog, use_fuzzy: bool = False) -> None:
-    """Write a catalog to the specified file-like object using the GNU MO file
-    format.
-
-    >>> import sys
-    >>> from babel.messages import Catalog
-    >>> from gettext import GNUTranslations
-    >>> from io import BytesIO
-
-    >>> catalog = Catalog(locale='en_US')
-    >>> catalog.add('foo', 'Voh')
-    <Message ...>
-    >>> catalog.add((u'bar', u'baz'), (u'Bahr', u'Batz'))
-    <Message ...>
-    >>> catalog.add('fuz', 'Futz', flags=['fuzzy'])
-    <Message ...>
-    >>> catalog.add('Fizz', '')
-    <Message ...>
-    >>> catalog.add(('Fuzz', 'Fuzzes'), ('', ''))
-    <Message ...>
-    >>> buf = BytesIO()
-
-    >>> write_mo(buf, catalog)
-    >>> x = buf.seek(0)
-    >>> translations = GNUTranslations(fp=buf)
-    >>> if sys.version_info[0] >= 3:
-    ...     translations.ugettext = translations.gettext
-    ...     translations.ungettext = translations.ngettext
-    >>> translations.ugettext('foo')
-    u'Voh'
-    >>> translations.ungettext('bar', 'baz', 1)
-    u'Bahr'
-    >>> translations.ungettext('bar', 'baz', 2)
-    u'Batz'
-    >>> translations.ugettext('fuz')
-    u'fuz'
-    >>> translations.ugettext('Fizz')
-    u'Fizz'
-    >>> translations.ugettext('Fuzz')
-    u'Fuzz'
-    >>> translations.ugettext('Fuzzes')
-    u'Fuzzes'
-
-    :param fileobj: the file-like object to write to
-    :param catalog: the `Catalog` instance
-    :param use_fuzzy: whether translations marked as "fuzzy" should be included
-                      in the output
-    """
-    messages = list(catalog)
-    messages[1:] = [m for m in messages[1:]
-                    if m.string and (use_fuzzy or not m.fuzzy)]
-    messages.sort()
-
-    ids = strs = b''
-    offsets = []
-
-    for message in messages:
-        # For each string, we need size and file offset.  Each string is NUL
-        # terminated; the NUL does not count into the size.
-        if message.pluralizable:
-            msgid = b'\x00'.join([
-                msgid.encode(catalog.charset) for msgid in message.id
-            ])
-            msgstrs = []
-            for idx, string in enumerate(message.string):
-                if not string:
-                    msgstrs.append(message.id[min(int(idx), 1)])
-                else:
-                    msgstrs.append(string)
-            msgstr = b'\x00'.join([
-                msgstr.encode(catalog.charset) for msgstr in msgstrs
-            ])
-        else:
-            msgid = message.id.encode(catalog.charset)
-            msgstr = message.string.encode(catalog.charset)
-        if message.context:
-            msgid = b'\x04'.join([message.context.encode(catalog.charset),
-                                  msgid])
-        offsets.append((len(ids), len(msgid), len(strs), len(msgstr)))
-        ids += msgid + b'\x00'
-        strs += msgstr + b'\x00'
-
-    # The header is 7 32-bit unsigned integers.  We don't use hash tables, so
-    # the keys start right after the index tables.
-    keystart = 7 * 4 + 16 * len(messages)
-    valuestart = keystart + len(ids)
-
-    # The string table first has the list of keys, then the list of values.
-    # Each entry has first the size of the string, then the file offset.
-    koffsets = []
-    voffsets = []
-    for o1, l1, o2, l2 in offsets:
-        koffsets += [l1, o1 + keystart]
-        voffsets += [l2, o2 + valuestart]
-    offsets = koffsets + voffsets
-
-    fileobj.write(struct.pack('Iiiiiii',
-                              LE_MAGIC,                   # magic
-                              0,                          # version
-                              len(messages),              # number of entries
-                              7 * 4,                      # start of key index
-                              7 * 4 + len(messages) * 8,  # start of value index
-                              0, 0,                       # size and offset of hash table
-                              ) + array.array.tobytes(array.array("i", offsets)) + ids + strs)

py2docfx/venv/template/Lib/site-packages/babel/messages/plurals.py

@@ -1,257 +0,0 @@
-"""
-    babel.messages.plurals
-    ~~~~~~~~~~~~~~~~~~~~~~
-
-    Plural form definitions.
-
-    :copyright: (c) 2013-2024 by the Babel Team.
-    :license: BSD, see LICENSE for more details.
-"""
-from __future__ import annotations
-
-from operator import itemgetter
-
-from babel.core import Locale, default_locale
-
-# XXX: remove this file, duplication with babel.plural
-
-
-LC_CTYPE: str | None = default_locale('LC_CTYPE')
-
-
-PLURALS: dict[str, tuple[int, str]] = {
-    # Afar
-    # 'aa': (),
-    # Abkhazian
-    # 'ab': (),
-    # Avestan
-    # 'ae': (),
-    # Afrikaans - From Pootle's PO's
-    'af': (2, '(n != 1)'),
-    # Akan
-    # 'ak': (),
-    # Amharic
-    # 'am': (),
-    # Aragonese
-    # 'an': (),
-    # Arabic - From Pootle's PO's
-    'ar': (6, '(n==0 ? 0 : n==1 ? 1 : n==2 ? 2 : n%100>=3 && n%100<=10 ? 3 : n%100>=0 && n%100<=2 ? 4 : 5)'),
-    # Assamese
-    # 'as': (),
-    # Avaric
-    # 'av': (),
-    # Aymara
-    # 'ay': (),
-    # Azerbaijani
-    # 'az': (),
-    # Bashkir
-    # 'ba': (),
-    # Belarusian
-    'be': (3, '(n%10==1 && n%100!=11 ? 0 : n%10>=2 && n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2)'),
-    # Bulgarian - From Pootle's PO's
-    'bg': (2, '(n != 1)'),
-    # Bihari
-    # 'bh': (),
-    # Bislama
-    # 'bi': (),
-    # Bambara
-    # 'bm': (),
-    # Bengali - From Pootle's PO's
-    'bn': (2, '(n != 1)'),
-    # Tibetan - as discussed in private with Andrew West
-    'bo': (1, '0'),
-    # Breton
-    'br': (
-        6,
-        '(n==1 ? 0 : n%10==1 && n%100!=11 && n%100!=71 && n%100!=91 ? 1 : n%10==2 && n%100!=12 && n%100!=72 && '
-        'n%100!=92 ? 2 : (n%10==3 || n%10==4 || n%10==9) && n%100!=13 && n%100!=14 && n%100!=19 && n%100!=73 && '
-        'n%100!=74 && n%100!=79 && n%100!=93 && n%100!=94 && n%100!=99 ? 3 : n%1000000==0 ? 4 : 5)',
-    ),
-    # Bosnian
-    'bs': (3, '(n%10==1 && n%100!=11 ? 0 : n%10>=2 && n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2)'),
-    # Catalan - From Pootle's PO's
-    'ca': (2, '(n != 1)'),
-    # Chechen
-    # 'ce': (),
-    # Chamorro
-    # 'ch': (),
-    # Corsican
-    # 'co': (),
-    # Cree
-    # 'cr': (),
-    # Czech
-    'cs': (3, '((n==1) ? 0 : (n>=2 && n<=4) ? 1 : 2)'),
-    # Church Slavic
-    # 'cu': (),
-    # Chuvash
-    'cv': (1, '0'),
-    # Welsh
-    'cy': (5, '(n==1 ? 1 : n==2 ? 2 : n==3 ? 3 : n==6 ? 4 : 0)'),
-    # Danish
-    'da': (2, '(n != 1)'),
-    # German
-    'de': (2, '(n != 1)'),
-    # Divehi
-    # 'dv': (),
-    # Dzongkha
-    'dz': (1, '0'),
-    # Greek
-    'el': (2, '(n != 1)'),
-    # English
-    'en': (2, '(n != 1)'),
-    # Esperanto
-    'eo': (2, '(n != 1)'),
-    # Spanish
-    'es': (2, '(n != 1)'),
-    # Estonian
-    'et': (2, '(n != 1)'),
-    # Basque - From Pootle's PO's
-    'eu': (2, '(n != 1)'),
-    # Persian - From Pootle's PO's
-    'fa': (1, '0'),
-    # Finnish
-    'fi': (2, '(n != 1)'),
-    # French
-    'fr': (2, '(n > 1)'),
-    # Friulian - From Pootle's PO's
-    'fur': (2, '(n > 1)'),
-    # Irish
-    'ga': (5, '(n==1 ? 0 : n==2 ? 1 : n>=3 && n<=6 ? 2 : n>=7 && n<=10 ? 3 : 4)'),
-    # Galician - From Pootle's PO's
-    'gl': (2, '(n != 1)'),
-    # Hausa - From Pootle's PO's
-    'ha': (2, '(n != 1)'),
-    # Hebrew
-    'he': (2, '(n != 1)'),
-    # Hindi - From Pootle's PO's
-    'hi': (2, '(n != 1)'),
-    # Croatian
-    'hr': (3, '(n%10==1 && n%100!=11 ? 0 : n%10>=2 && n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2)'),
-    # Hungarian
-    'hu': (1, '0'),
-    # Armenian - From Pootle's PO's
-    'hy': (1, '0'),
-    # Icelandic - From Pootle's PO's
-    'is': (2, '(n%10==1 && n%100!=11 ? 0 : 1)'),
-    # Italian
-    'it': (2, '(n != 1)'),
-    # Japanese
-    'ja': (1, '0'),
-    # Georgian - From Pootle's PO's
-    'ka': (1, '0'),
-    # Kongo - From Pootle's PO's
-    'kg': (2, '(n != 1)'),
-    # Khmer - From Pootle's PO's
-    'km': (1, '0'),
-    # Korean
-    'ko': (1, '0'),
-    # Kurdish - From Pootle's PO's
-    'ku': (2, '(n != 1)'),
-    # Lao - Another member of the Tai language family, like Thai.
-    'lo': (1, '0'),
-    # Lithuanian
-    'lt': (3, '(n%10==1 && n%100!=11 ? 0 : n%10>=2 && (n%100<10 || n%100>=20) ? 1 : 2)'),
-    # Latvian
-    'lv': (3, '(n%10==1 && n%100!=11 ? 0 : n != 0 ? 1 : 2)'),
-    # Maltese - From Pootle's PO's
-    'mt': (4, '(n==1 ? 0 : n==0 || ( n%100>=1 && n%100<=10) ? 1 : (n%100>10 && n%100<20 ) ? 2 : 3)'),
-    # Norwegian Bokmål
-    'nb': (2, '(n != 1)'),
-    # Dutch
-    'nl': (2, '(n != 1)'),
-    # Norwegian Nynorsk
-    'nn': (2, '(n != 1)'),
-    # Norwegian
-    'no': (2, '(n != 1)'),
-    # Punjabi - From Pootle's PO's
-    'pa': (2, '(n != 1)'),
-    # Polish
-    'pl': (3, '(n==1 ? 0 : n%10>=2 && n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2)'),
-    # Portuguese
-    'pt': (2, '(n != 1)'),
-    # Brazilian
-    'pt_BR': (2, '(n > 1)'),
-    # Romanian - From Pootle's PO's
-    'ro': (3, '(n==1 ? 0 : (n==0 || (n%100 > 0 && n%100 < 20)) ? 1 : 2)'),
-    # Russian
-    'ru': (3, '(n%10==1 && n%100!=11 ? 0 : n%10>=2 && n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2)'),
-    # Slovak
-    'sk': (3, '((n==1) ? 0 : (n>=2 && n<=4) ? 1 : 2)'),
-    # Slovenian
-    'sl': (4, '(n%100==1 ? 0 : n%100==2 ? 1 : n%100==3 || n%100==4 ? 2 : 3)'),
-    # Serbian - From Pootle's PO's
-    'sr': (3, '(n%10==1 && n%100!=11 ? 0 : n%10>=2 && n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2)'),
-    # Southern Sotho - From Pootle's PO's
-    'st': (2, '(n != 1)'),
-    # Swedish
-    'sv': (2, '(n != 1)'),
-    # Thai
-    'th': (1, '0'),
-    # Turkish
-    'tr': (1, '0'),
-    # Ukrainian
-    'uk': (3, '(n%10==1 && n%100!=11 ? 0 : n%10>=2 && n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2)'),
-    # Venda - From Pootle's PO's
-    've': (2, '(n != 1)'),
-    # Vietnamese - From Pootle's PO's
-    'vi': (1, '0'),
-    # Xhosa - From Pootle's PO's
-    'xh': (2, '(n != 1)'),
-    # Chinese - From Pootle's PO's (modified)
-    'zh': (1, '0'),
-}
-
-
-DEFAULT_PLURAL: tuple[int, str] = (2, '(n != 1)')
-
-
-class _PluralTuple(tuple):
-    """A tuple with plural information."""
-
-    __slots__ = ()
-    num_plurals = property(itemgetter(0), doc="""
-    The number of plurals used by the locale.""")
-    plural_expr = property(itemgetter(1), doc="""
-    The plural expression used by the locale.""")
-    plural_forms = property(lambda x: 'nplurals={}; plural={};'.format(*x), doc="""
-    The plural expression used by the catalog or locale.""")
-
-    def __str__(self) -> str:
-        return self.plural_forms
-
-
-def get_plural(locale: str | None = LC_CTYPE) -> _PluralTuple:
-    """A tuple with the information catalogs need to perform proper
-    pluralization.  The first item of the tuple is the number of plural
-    forms, the second the plural expression.
-
-    >>> get_plural(locale='en')
-    (2, '(n != 1)')
-    >>> get_plural(locale='ga')
-    (5, '(n==1 ? 0 : n==2 ? 1 : n>=3 && n<=6 ? 2 : n>=7 && n<=10 ? 3 : 4)')
-
-    The object returned is a special tuple with additional members:
-
-    >>> tup = get_plural("ja")
-    >>> tup.num_plurals
-    1
-    >>> tup.plural_expr
-    '0'
-    >>> tup.plural_forms
-    'nplurals=1; plural=0;'
-
-    Converting the tuple into a string prints the plural forms for a
-    gettext catalog:
-
-    >>> str(tup)
-    'nplurals=1; plural=0;'
-    """
-    locale = Locale.parse(locale)
-    try:
-        tup = PLURALS[str(locale)]
-    except KeyError:
-        try:
-            tup = PLURALS[locale.language]
-        except KeyError:
-            tup = DEFAULT_PLURAL
-    return _PluralTuple(tup)