'find', 'translation', 'install', 'textdomain', 'bindtextdomain',

'bind_textdomain_codeset',

'dgettext', 'dngettext', 'gettext', 'lgettext', 'ldgettext',

'ldngettext', 'lngettext', 'ngettext',

'pgettext', 'dpgettext', 'npgettext', 'dnpgettext',

for mo in re.finditer(_token_pattern, plural):

kind = mo.lastgroup

if kind == 'WHITESPACES':

continue

value = mo.group(kind)

if kind == 'INVALID':

raise ValueError('invalid token in plural form: %s' % value)

yield value

if value:

return ValueError('unexpected token in plural form: %s' % value)

else:

('||',),

('&&',),

('==', '!='),

('<', '>', '<=', '>='),

('+', '-'),

('*', '/', '%'),

result = ''

nexttok = next(tokens)

while nexttok == '!':

result += 'not '

nexttok = next(tokens)

if nexttok == '(':

sub, nexttok = _parse(tokens)

result = '%s(%s)' % (result, sub)

if nexttok != ')':

raise ValueError('unbalanced parenthesis in plural form')

elif nexttok == 'n':

result = '%s%s' % (result, nexttok)

else:

try:

value = int(nexttok, 10)

except ValueError:

raise _error(nexttok) from None

result = '%s%d' % (result, value)

nexttok = next(tokens)

j = 100

while nexttok in _binary_ops:

i = _binary_ops[nexttok]

if i < priority:

break

# Break chained comparisons

if i in (3, 4) and j in (3, 4): # '==', '!=', '<', '>', '<=', '>='

result = '(%s)' % result

# Replace some C operators by their Python equivalents

op = _c2py_ops.get(nexttok, nexttok)

right, nexttok = _parse(tokens, i + 1)

result = '%s %s %s' % (result, op, right)

j = i

if j == priority == 4: # '<', '>', '<=', '>='

result = '(%s)' % result

if nexttok == '?' and priority <= 0:

if_true, nexttok = _parse(tokens, 0)

if nexttok != ':':

raise _error(nexttok)

if_false, nexttok = _parse(tokens)

result = '%s if %s else %s' % (if_true, result, if_false)

if priority == 0:

result = '(%s)' % result

try:

i = round(n)

except TypeError:

raise TypeError('Plural value must be an integer, got %s' %

(n.__class__.__name__,)) from None

import warnings

warnings.warn('Plural value must be an integer, got %s' %

(n.__class__.__name__,),

DeprecationWarning, 4)

"""Gets a C expression as used in PO files for plural forms and returns a

if len(plural) > 1000:

raise ValueError('plural form expression is too long')

try:

result, nexttok = _parse(_tokenize(plural))

if nexttok:

raise _error(nexttok)

depth = 0

for c in result:

if c == '(':

depth += 1

if depth > 20:

# Python compiler limit is about 90.

# The most complex example has 2.

raise ValueError('plural form expression is too complex')

elif c == ')':

depth -= 1

ns = {'_as_int': _as_int}

exec('''if True:

''' % result, ns)

return ns['func']

except RecursionError:

# Recursion error can be raised in _parse() or exec().

loc = locale.normalize(loc)

COMPONENT_CODESET = 1 << 0

COMPONENT_TERRITORY = 1 << 1

COMPONENT_MODIFIER = 1 << 2

# split up the locale into its base components

mask = 0

pos = loc.find('@')

if pos >= 0:

modifier = loc[pos:]

loc = loc[:pos]

mask |= COMPONENT_MODIFIER

else:

modifier = ''

pos = loc.find('.')

if pos >= 0:

codeset = loc[pos:]

loc = loc[:pos]

mask |= COMPONENT_CODESET

else:

codeset = ''

pos = loc.find('_')

if pos >= 0:

territory = loc[pos:]

loc = loc[:pos]

mask |= COMPONENT_TERRITORY

else:

territory = ''

language = loc

ret = []

for i in range(mask+1):

if not (i & ~mask): # if all components for this combo exist ...

val = language

if i & COMPONENT_TERRITORY: val += territory

if i & COMPONENT_CODESET: val += codeset

if i & COMPONENT_MODIFIER: val += modifier

ret.append(val)

ret.reverse()

def __init__(self, fp=None):

self._info = {}

self._charset = None

self._output_charset = None

self._fallback = None

if fp is not None:

self._parse(fp)

def _parse(self, fp):

pass

def add_fallback(self, fallback):

if self._fallback:

self._fallback.add_fallback(fallback)

else:

self._fallback = fallback

def gettext(self, message):

if self._fallback:

return self._fallback.gettext(message)

return message

def lgettext(self, message):

import warnings

warnings.warn('lgettext() is deprecated, use gettext() instead',

DeprecationWarning, 2)

if self._fallback:

with warnings.catch_warnings():

warnings.filterwarnings('ignore', r'.*\blgettext\b.*',

DeprecationWarning)

return self._fallback.lgettext(message)

if self._output_charset:

return message.encode(self._output_charset)

return message.encode(locale.getpreferredencoding())

def ngettext(self, msgid1, msgid2, n):

if self._fallback:

return self._fallback.ngettext(msgid1, msgid2, n)

if n == 1:

return msgid1

else:

return msgid2

def lngettext(self, msgid1, msgid2, n):

import warnings

warnings.warn('lngettext() is deprecated, use ngettext() instead',

DeprecationWarning, 2)

if self._fallback:

with warnings.catch_warnings():

warnings.filterwarnings('ignore', r'.*\blngettext\b.*',

DeprecationWarning)

return self._fallback.lngettext(msgid1, msgid2, n)

if n == 1:

tmsg = msgid1

else:

tmsg = msgid2

if self._output_charset:

return tmsg.encode(self._output_charset)

return tmsg.encode(locale.getpreferredencoding())

def pgettext(self, context, message):

if self._fallback:

return self._fallback.pgettext(context, message)

return message

def npgettext(self, context, msgid1, msgid2, n):

if self._fallback:

return self._fallback.npgettext(context, msgid1, msgid2, n)

if n == 1:

return msgid1

else:

return msgid2

def info(self):

return self._info

def charset(self):

return self._charset

def output_charset(self):

import warnings

warnings.warn('output_charset() is deprecated',

DeprecationWarning, 2)

return self._output_charset

def set_output_charset(self, charset):

import warnings

warnings.warn('set_output_charset() is deprecated',

DeprecationWarning, 2)

self._output_charset = charset

def install(self, names=None):

import builtins

builtins.__dict__['_'] = self.gettext

if names is not None:

allowed = {'gettext', 'lgettext', 'lngettext',

'ngettext', 'npgettext', 'pgettext'}

for name in allowed & set(names):

# Magic number of .mo files

LE_MAGIC = 0x950412de

BE_MAGIC = 0xde120495

# The encoding of a msgctxt and a msgid in a .mo file is

# msgctxt + "\x04" + msgid (gettext version >= 0.15)

CONTEXT = "%s\x04%s"

# Acceptable .mo versions

VERSIONS = (0, 1)

def _get_versions(self, version):

"""Returns a tuple of major version, minor version"""

return (version >> 16, version & 0xffff)

def _parse(self, fp):

"""Override this method to support alternative .mo formats."""

# Delay struct import for speeding up gettext import when .mo files

# are not used.

from struct import unpack

filename = getattr(fp, 'name', '')

# Parse the .mo file header, which consists of 5 little endian 32

# bit words.

self._catalog = catalog = {}

self.plural = lambda n: int(n != 1) # germanic plural by default

buf = fp.read()

buflen = len(buf)

# Are we big endian or little endian?

magic = unpack('<I', buf[:4])[0]

if magic == self.LE_MAGIC:

version, msgcount, masteridx, transidx = unpack('<4I', buf[4:20])

ii = '<II'

elif magic == self.BE_MAGIC:

version, msgcount, masteridx, transidx = unpack('>4I', buf[4:20])

ii = '>II'

else:

raise OSError(0, 'Bad magic number', filename)

major_version, minor_version = self._get_versions(version)

if major_version not in self.VERSIONS:

raise OSError(0, 'Bad version number ' + str(major_version), filename)

# Now put all messages from the .mo file buffer into the catalog

# dictionary.

for i in range(0, msgcount):

mlen, moff = unpack(ii, buf[masteridx:masteridx+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

lastk = None

for b_item in tmsg.split(b'\n'):

item = b_item.decode().strip()

if not item:

continue

# Skip over comment lines:

if item.startswith('#-#-#-#-#') and item.endswith('#-#-#-#-#'):

continue

k = v = None

if ':' in item:

k, v = item.split(':', 1)

k = k.strip().lower()

v = v.strip()

self._info[k] = v

lastk = k

elif lastk:

self._info[lastk] += '\n' + item

if k == 'content-type':

self._charset = v.split('charset=')[1]

elif k == 'plural-forms':

v = v.split(';')

plural = v[1].split('plural=')[1]

self.plural = c2py(plural)

# Note: we unconditionally convert both msgids and msgstrs to

# Unicode using the character encoding specified in the charset

# parameter of the Content-Type header. The gettext documentation

# strongly encourages msgids to be us-ascii, but some applications

# require alternative encodings (e.g. Zope's ZCML and ZPT). For

# traditional gettext applications, the msgid conversion will

# cause no problems since us-ascii should always be a subset of

# the charset encoding. We may want to fall back to 8-bit msgids

# if the Unicode conversion fails.

charset = self._charset or 'ascii'

if b'\x00' in msg:

# Plural forms

msgid1, msgid2 = msg.split(b'\x00')

tmsg = tmsg.split(b'\x00')

msgid1 = str(msgid1, charset)

for i, x in enumerate(tmsg):

catalog[(msgid1, i)] = str(x, charset)

else:

catalog[str(msg, charset)] = str(tmsg, charset)

# advance to next entry in the seek tables

masteridx += 8

transidx += 8

def lgettext(self, message):

import warnings

warnings.warn('lgettext() is deprecated, use gettext() instead',

DeprecationWarning, 2)

missing = object()

tmsg = self._catalog.get(message, missing)

if tmsg is missing:

if self._fallback:

return self._fallback.lgettext(message)

tmsg = message

if self._output_charset:

return tmsg.encode(self._output_charset)

return tmsg.encode(locale.getpreferredencoding())

def lngettext(self, msgid1, msgid2, n):

import warnings

warnings.warn('lngettext() is deprecated, use ngettext() instead',

DeprecationWarning, 2)

try:

tmsg = self._catalog[(msgid1, self.plural(n))]

except KeyError:

if self._fallback:

return self._fallback.lngettext(msgid1, msgid2, n)

if n == 1:

tmsg = msgid1

else:

tmsg = msgid2

if self._output_charset:

return tmsg.encode(self._output_charset)

return tmsg.encode(locale.getpreferredencoding())

def gettext(self, message):

missing = object()

tmsg = self._catalog.get(message, missing)

if tmsg is missing:

if self._fallback:

return self._fallback.gettext(message)

return message

return tmsg

def ngettext(self, msgid1, msgid2, n):

try:

tmsg = self._catalog[(msgid1, self.plural(n))]

except KeyError:

if self._fallback:

return self._fallback.ngettext(msgid1, msgid2, n)

if n == 1:

tmsg = msgid1

else:

tmsg = msgid2

return tmsg

def pgettext(self, context, message):

ctxt_msg_id = self.CONTEXT % (context, message)

missing = object()

tmsg = self._catalog.get(ctxt_msg_id, missing)

if tmsg is missing:

if self._fallback:

return self._fallback.pgettext(context, message)

return message

return tmsg

def npgettext(self, context, msgid1, msgid2, n):

ctxt_msg_id = self.CONTEXT % (context, msgid1)

try:

tmsg = self._catalog[ctxt_msg_id, self.plural(n)]

except KeyError:

if self._fallback:

return self._fallback.npgettext(context, msgid1, msgid2, n)

if n == 1:

tmsg = msgid1

else:

tmsg = msgid2

# Get some reasonable defaults for arguments that were not supplied

if localedir is None:

localedir = _default_localedir

if languages is None:

languages = []

for envar in ('LANGUAGE', 'LC_ALL', 'LC_MESSAGES', 'LANG'):

val = os.environ.get(envar)

if val:

languages = val.split(':')

break

if 'C' not in languages:

languages.append('C')

# now normalize and expand the languages

nelangs = []

for lang in languages:

for nelang in _expand_lang(lang):

if nelang not in nelangs:

nelangs.append(nelang)

# select a language

if all:

result = []

else:

result = None

for lang in nelangs:

if lang == 'C':

break

mofile = os.path.join(localedir, lang, 'LC_MESSAGES', '%s.mo' % domain)

if os.path.exists(mofile):

if all:

result.append(mofile)

else:

return mofile

class_=None, fallback=False, codeset=_unspecified):

if class_ is None:

class_ = GNUTranslations

mofiles = find(domain, localedir, languages, all=True)

if not mofiles:

if fallback:

return NullTranslations()

from errno import ENOENT

raise FileNotFoundError(ENOENT,

'No translation file found for domain', domain)

# Avoid opening, reading, and parsing the .mo file after it's been done

# once.

result = None

for mofile in mofiles:

key = (class_, os.path.abspath(mofile))

t = _translations.get(key)

if t is None:

with open(mofile, 'rb') as fp:

t = _translations.setdefault(key, class_(fp))

# Copy the translation object to allow setting fallbacks and

# output charset. All other instance data is shared with the

# cached object.

# Delay copy import for speeding up gettext import when .mo files

# are not used.

import copy

t = copy.copy(t)

if codeset is not _unspecified:

import warnings

warnings.warn('parameter codeset is deprecated',

DeprecationWarning, 2)

if codeset:

with warnings.catch_warnings():

warnings.filterwarnings('ignore', r'.*\bset_output_charset\b.*',

DeprecationWarning)

t.set_output_charset(codeset)

if result is None:

result = t

else:

result.add_fallback(t)

global _current_domain

if domain is not None:

_current_domain = domain

global _localedirs

if localedir is not None:

_localedirs[domain] = localedir

import warnings

warnings.warn('bind_textdomain_codeset() is deprecated',

DeprecationWarning, 2)

global _localecodesets

if codeset is not None:

_localecodesets[domain] = codeset

try:

t = translation(domain, _localedirs.get(domain, None))

except OSError:

return message

import warnings

warnings.warn('ldgettext() is deprecated, use dgettext() instead',

DeprecationWarning, 2)

codeset = _localecodesets.get(domain)

try:

with warnings.catch_warnings():

warnings.filterwarnings('ignore', r'.*\bparameter codeset\b.*',

DeprecationWarning)

t = translation(domain, _localedirs.get(domain, None), codeset=codeset)

except OSError:

return message.encode(codeset or locale.getpreferredencoding())

with warnings.catch_warnings():

warnings.filterwarnings('ignore', r'.*\blgettext\b.*',

DeprecationWarning)

try:

t = translation(domain, _localedirs.get(domain, None))

except OSError:

if n == 1:

return msgid1

else:

return msgid2

import warnings

warnings.warn('ldngettext() is deprecated, use dngettext() instead',

DeprecationWarning, 2)

codeset = _localecodesets.get(domain)

try:

with warnings.catch_warnings():

warnings.filterwarnings('ignore', r'.*\bparameter codeset\b.*',

DeprecationWarning)

t = translation(domain, _localedirs.get(domain, None), codeset=codeset)

except OSError:

if n == 1:

tmsg = msgid1

else:

tmsg = msgid2

return tmsg.encode(codeset or locale.getpreferredencoding())

with warnings.catch_warnings():

warnings.filterwarnings('ignore', r'.*\blngettext\b.*',

DeprecationWarning)

try:

t = translation(domain, _localedirs.get(domain, None))

except OSError:

return message

try:

t = translation(domain, _localedirs.get(domain, None))

except OSError:

if n == 1:

return msgid1

else:

return msgid2

import warnings

warnings.warn('lgettext() is deprecated, use gettext() instead',

DeprecationWarning, 2)

with warnings.catch_warnings():

warnings.filterwarnings('ignore', r'.*\bldgettext\b.*',

DeprecationWarning)

import warnings

warnings.warn('lngettext() is deprecated, use ngettext() instead',

DeprecationWarning, 2)

with warnings.catch_warnings():

warnings.filterwarnings('ignore', r'.*\bldngettext\b.*',

DeprecationWarning)