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

# Security check, allow only the "n" identifier

import token, tokenize

tokens = tokenize.generate_tokens(io.StringIO(plural).readline)

try:

danger = [x for x in tokens if x[0] == token.NAME and x[1] != 'n']

except tokenize.TokenError:

raise ValueError('plural forms expression error, maybe unbalanced parenthesis')

else:

if danger:

raise ValueError('plural forms expression could be dangerous')

# Replace some C operators by their Python equivalents

plural = plural.replace('&&', ' and ')

plural = plural.replace('||', ' or ')

expr = re.compile(r'\!([^=])')

plural = expr.sub(' not \\1', plural)

# Regular expression and replacement function used to transform

# "a?b:c" to "b if a else c".

expr = re.compile(r'(.*?)\?(.*?):(.*)')

def repl(x):

return "(%s if %s else %s)" % (x.group(2), x.group(1),

expr.sub(repl, x.group(3)))

# Code to transform the plural expression, taking care of parentheses

stack = ['']

for c in plural:

if c == '(':

stack.append('')

elif c == ')':

if len(stack) == 1:

# Actually, we never reach this code, because unbalanced

# parentheses get caught in the security check at the

# beginning.

raise ValueError('unbalanced parenthesis in plural form')

s = expr.sub(repl, stack.pop())

stack[-1] += '(%s)' % s

else:

stack[-1] += c

plural = expr.sub(repl, stack.pop())

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):

if self._fallback:

return self._fallback.lgettext(message)

return message

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):

if self._fallback:

return self._fallback.lngettext(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):

return self._output_charset

def set_output_charset(self, charset):

self._output_charset = charset

def install(self, names=None):

import builtins

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

if hasattr(names, "__contains__"):

if "gettext" in names:

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

if "ngettext" in names:

builtins.__dict__['ngettext'] = self.ngettext

if "lgettext" in names:

builtins.__dict__['lgettext'] = self.lgettext

if "lngettext" in names:

# Magic number of .mo files

LE_MAGIC = 0x950412de

BE_MAGIC = 0xde120495

def _parse(self, fp):

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

unpack = struct.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)

# 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 = k = None

for b_item in tmsg.split('\n'.encode("ascii")):

item = b_item.decode().strip()

if not item:

continue

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):

missing = object()

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

if tmsg is missing:

if self._fallback:

return self._fallback.lgettext(message)

return message

if self._output_charset:

return tmsg.encode(self._output_charset)

return tmsg.encode(locale.getpreferredencoding())

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

try:

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

if self._output_charset:

return tmsg.encode(self._output_charset)

return tmsg.encode(locale.getpreferredencoding())

except KeyError:

if self._fallback:

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

if n == 1:

return msgid1

else:

return msgid2

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

# 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=None):

if class_ is None:

class_ = GNUTranslations

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

if not mofiles:

if fallback:

return NullTranslations()

raise OSError(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.

t = copy.copy(t)

if codeset:

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

global _localecodesets

if codeset is not None:

_localecodesets[domain] = codeset

try:

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

codeset=_localecodesets.get(domain))

except OSError:

return message

try:

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

codeset=_localecodesets.get(domain))

except OSError:

return message

try:

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

codeset=_localecodesets.get(domain))

except OSError:

if n == 1:

return msgid1

else:

return msgid2

try:

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

codeset=_localecodesets.get(domain))

except OSError:

if n == 1:

return msgid1

else:

return msgid2