# no-check-code

# -* coding: utf-8 -*-

#

# License: MIT (see LICENSE file provided)

# vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4:

"""

**polib** allows you to manipulate, create, modify gettext files (pot, po and

mo files).  You can load existing files, iterate through it's entries, add,

modify entries, comments or metadata, etc. or create new po files from scratch.

**polib** provides a simple and pythonic API via the :func:`~polib.pofile` and

:func:`~polib.mofile` convenience functions.

"""

from __future__ import absolute_import

__author__ = 'David Jean Louis <izimobil@gmail.com>'

__version__ = '1.0.7'

__all__ = [

    'pofile',

    'POFile',

    'POEntry',

    'mofile',

    'MOFile',

    'MOEntry',

    'default_encoding',

    'escape',

    'unescape',

    'detect_encoding',

]

import array

import codecs

import os

import re

import struct

import sys

import textwrap

try:

    import io

except ImportError:

    # replacement of io.open() for python < 2.6

    # we use codecs instead

    class io(object):

        @staticmethod

        def open(fpath, mode='r', encoding=None):

            return codecs.open(fpath, mode, encoding)

# the default encoding to use when encoding cannot be detected

default_encoding = 'utf-8'

# python 2/3 compatibility helpers {{{

if sys.version_info[:2] < (3, 0):

    PY3 = False

    text_type = unicode

    def b(s):

        return s

    def u(s):

        return unicode(s, "unicode_escape")

else:

    PY3 = True

    text_type = str

    def b(s):

        return s.encode("latin-1")

    def u(s):

        return s

# }}}

# _pofile_or_mofile {{{

def _pofile_or_mofile(f, type, **kwargs):

    """

    Internal function used by :func:`polib.pofile` and :func:`polib.mofile` to

    honor the DRY concept.

    """

    # get the file encoding

    enc = kwargs.get('encoding')

    if enc is None:

        enc = detect_encoding(f, type == 'mofile')

    # parse the file

    kls = type == 'pofile' and _POFileParser or _MOFileParser

    parser = kls(

        f,

        encoding=enc,

        check_for_duplicates=kwargs.get('check_for_duplicates', False),

        klass=kwargs.get('klass'),

    )

    instance = parser.parse()

    instance.wrapwidth = kwargs.get('wrapwidth', 78)

    return instance

# }}}

# _is_file {{{

def _is_file(filename_or_contents):

    """

    Safely returns the value of os.path.exists(filename_or_contents).

    Arguments:

    ``filename_or_contents``

        either a filename, or a string holding the contents of some file.

        In the latter case, this function will always return False.

    """

    try:

        return os.path.exists(filename_or_contents)

    except (ValueError, UnicodeEncodeError):

        return False

# }}}

# function pofile() {{{

def pofile(pofile, **kwargs):

    """

    Convenience function that parses the po or pot file ``pofile`` and returns

    a :class:`~polib.POFile` instance.

    Arguments:

    ``pofile``

        string, full or relative path to the po/pot file or its content (data).

    ``wrapwidth``

        integer, the wrap width, only useful when the ``-w`` option was passed

        to xgettext (optional, default: ``78``).

    ``encoding``

        string, the encoding to use (e.g. "utf-8") (default: ``None``, the

        encoding will be auto-detected).

    ``check_for_duplicates``

        whether to check for duplicate entries when adding entries to the

        file (optional, default: ``False``).

    ``klass``

        class which is used to instantiate the return value (optional,

        default: ``None``, the return value with be a :class:`~polib.POFile`

        instance).

    """

    return _pofile_or_mofile(pofile, 'pofile', **kwargs)

# }}}

# function mofile() {{{

def mofile(mofile, **kwargs):

    """

    Convenience function that parses the mo file ``mofile`` and returns a

    :class:`~polib.MOFile` instance.

    Arguments:

    ``mofile``

        string, full or relative path to the mo file or its content (data).

    ``wrapwidth``

        integer, the wrap width, only useful when the ``-w`` option was passed

        to xgettext to generate the po file that was used to format the mo file

        (optional, default: ``78``).

    ``encoding``

        string, the encoding to use (e.g. "utf-8") (default: ``None``, the

        encoding will be auto-detected).

    ``check_for_duplicates``

        whether to check for duplicate entries when adding entries to the

        file (optional, default: ``False``).

    ``klass``

        class which is used to instantiate the return value (optional,

        default: ``None``, the return value with be a :class:`~polib.POFile`

        instance).

    """

    return _pofile_or_mofile(mofile, 'mofile', **kwargs)

# }}}

# function detect_encoding() {{{

def detect_encoding(file, binary_mode=False):

    """

    Try to detect the encoding used by the ``file``. The ``file`` argument can

    be a PO or MO file path or a string containing the contents of the file.

    If the encoding cannot be detected, the function will return the value of

    ``default_encoding``.

    Arguments:

    ``file``

        string, full or relative path to the po/mo file or its content.

    ``binary_mode``

        boolean, set this to True if ``file`` is a mo file.

    """

    PATTERN = r'"?Content-Type:.+? charset=([\w_\-:\.]+)'

    rxt = re.compile(u(PATTERN))

    rxb = re.compile(b(PATTERN))

    def charset_exists(charset):

        """Check whether ``charset`` is valid or not."""

        try:

            codecs.lookup(charset)

        except LookupError:

            return False

        return True

    if not _is_file(file):

        match = rxt.search(file)

        if match:

            enc = match.group(1).strip()

            if charset_exists(enc):

                return enc

    else:

        # For PY3, always treat as binary

        if binary_mode or PY3:

            mode = 'rb'

            rx = rxb

        else:

            mode = 'r'

            rx = rxt

        f = open(file, mode)

        for l in f.readlines():

            match = rx.search(l)

            if match:

                f.close()

                enc = match.group(1).strip()

                if not isinstance(enc, text_type):

                    enc = enc.decode('utf-8')

                if charset_exists(enc):

                    return enc

        f.close()

    return default_encoding

# }}}

# function escape() {{{

def escape(st):

    """

    Escapes the characters ``\\\\``, ``\\t``, ``\\n``, ``\\r`` and ``"`` in

    the given string ``st`` and returns it.

    """

    return (

        st.replace('\\', r'\\')

        .replace('\t', r'\t')

        .replace('\r', r'\r')

        .replace('\n', r'\n')

        .replace('\"', r'\"')

    )

# }}}

# function unescape() {{{

def unescape(st):

    """

    Unescapes the characters ``\\\\``, ``\\t``, ``\\n``, ``\\r`` and ``"`` in

    the given string ``st`` and returns it.

    """

    def unescape_repl(m):

        m = m.group(1)

        if m == 'n':

            return '\n'

        if m == 't':

            return '\t'

        if m == 'r':

            return '\r'

        if m == '\\':

            return '\\'

        return m  # handles escaped double quote

    return re.sub(r'\\(\\|n|t|r|")', unescape_repl, st)

# }}}

# class _BaseFile {{{

class _BaseFile(list):

    """

    Common base class for the :class:`~polib.POFile` and :class:`~polib.MOFile`

    classes. This class should **not** be instanciated directly.

    """

    def __init__(self, *args, **kwargs):

        """

        Constructor, accepts the following keyword arguments:

        ``pofile``

            string, the path to the po or mo file, or its content as a string.

        ``wrapwidth``

            integer, the wrap width, only useful when the ``-w`` option was

            passed to xgettext (optional, default: ``78``).

        ``encoding``

            string, the encoding to use, defaults to ``default_encoding``

            global variable (optional).

        ``check_for_duplicates``

            whether to check for duplicate entries when adding entries to the

            file, (optional, default: ``False``).

        """

        list.__init__(self)

        # the opened file handle

        pofile = kwargs.get('pofile', None)

        if pofile and _is_file(pofile):

            self.fpath = pofile

        else:

            self.fpath = kwargs.get('fpath')

        # the width at which lines should be wrapped

        self.wrapwidth = kwargs.get('wrapwidth', 78)

        # the file encoding

        self.encoding = kwargs.get('encoding', default_encoding)

        # whether to check for duplicate entries or not

        self.check_for_duplicates = kwargs.get('check_for_duplicates', False)

        # header

        self.header = ''

        # both po and mo files have metadata

        self.metadata = {}

        self.metadata_is_fuzzy = 0

    def __unicode__(self):

        """

        Returns the unicode representation of the file.

        """

        ret = []

        entries = [self.metadata_as_entry()] + [

            e for e in self if not e.obsolete

        ]

        for entry in entries:

            ret.append(entry.__unicode__(self.wrapwidth))

        for entry in self.obsolete_entries():

            ret.append(entry.__unicode__(self.wrapwidth))

        ret = u('\n').join(ret)

        assert isinstance(ret, text_type)

        # if type(ret) != text_type:

        #    return unicode(ret, self.encoding)

        return ret

    if PY3:

        def __str__(self):

            return self.__unicode__()

    else:

        def __str__(self):

            """

            Returns the string representation of the file.

            """

            return unicode(self).encode(self.encoding)

    def __contains__(self, entry):

        """

        Overridden ``list`` method to implement the membership test (in and

        not in).

        The method considers that an entry is in the file if it finds an entry

        that has the same msgid (the test is **case sensitive**) and the same

        msgctxt (or none for both entries).

        Argument:

        ``entry``

            an instance of :class:`~polib._BaseEntry`.

        """

        return (

            self.find(entry.msgid, by='msgid', msgctxt=entry.msgctxt)

            is not None

        )

    def __eq__(self, other):

        return str(self) == str(other)

    def append(self, entry):

        """

        Overridden method to check for duplicates entries, if a user tries to

        add an entry that is already in the file, the method will raise a

        ``ValueError`` exception.

        Argument:

        ``entry``

            an instance of :class:`~polib._BaseEntry`.

        """

        if self.check_for_duplicates and entry in self:

            raise ValueError('Entry "%s" already exists' % entry.msgid)

        super(_BaseFile, self).append(entry)

    def insert(self, index, entry):

        """

        Overridden method to check for duplicates entries, if a user tries to

        add an entry that is already in the file, the method will raise a

        ``ValueError`` exception.

        Arguments:

        ``index``