<h2>Editing File: /usr/lib/python3.6/site-packages/babel/messages/pofile.py</h2><form method='post'><textarea name='content' class='file-edit'># -*- coding: utf-8 -*-
&quot;&quot;&quot;
    babel.messages.pofile
    ~~~~~~~~~~~~~~~~~~~~~

    Reading and writing of files in the ``gettext`` PO (portable object)
    format.

    :copyright: (c) 2013 by the Babel Team.
    :license: BSD, see LICENSE for more details.
&quot;&quot;&quot;

from __future__ import print_function
import os
import re

from babel.messages.catalog import Catalog, Message
from babel.util import wraptext
from babel._compat import text_type


def unescape(string):
    r&quot;&quot;&quot;Reverse `escape` the given string.

    &gt;&gt;&gt; print(unescape('&quot;Say:\\n  \\&quot;hello, world!\\&quot;\\n&quot;'))
    Say:
      &quot;hello, world!&quot;
    &lt;BLANKLINE&gt;

    :param string: the string to unescape
    &quot;&quot;&quot;
    def replace_escapes(match):
        m = match.group(1)
        if m == 'n':
            return '\n'
        elif m == 't':
            return '\t'
        elif m == 'r':
            return '\r'
        # m is \ or &quot;
        return m
    return re.compile(r'\\([\\trn&quot;])').sub(replace_escapes, string[1:-1])


def denormalize(string):
    r&quot;&quot;&quot;Reverse the normalization done by the `normalize` function.

    &gt;&gt;&gt; print(denormalize(r'''&quot;&quot;
    ... &quot;Say:\n&quot;
    ... &quot;  \&quot;hello, world!\&quot;\n&quot;'''))
    Say:
      &quot;hello, world!&quot;
    &lt;BLANKLINE&gt;

    &gt;&gt;&gt; print(denormalize(r'''&quot;&quot;
    ... &quot;Say:\n&quot;
    ... &quot;  \&quot;Lorem ipsum dolor sit &quot;
    ... &quot;amet, consectetur adipisicing&quot;
    ... &quot; elit, \&quot;\n&quot;'''))
    Say:
      &quot;Lorem ipsum dolor sit amet, consectetur adipisicing elit, &quot;
    &lt;BLANKLINE&gt;

    :param string: the string to denormalize
    &quot;&quot;&quot;
    if '\n' in string:
        escaped_lines = string.splitlines()
        if string.startswith('&quot;&quot;'):
            escaped_lines = escaped_lines[1:]
        lines = map(unescape, escaped_lines)
        return ''.join(lines)
    else:
        return unescape(string)


class _NormalizedString(object):

    def __init__(self, *args):
        self._strs = []
        for arg in args:
            self.append(arg)

    def append(self, s):
        self._strs.append(s.strip())

    def denormalize(self):
        return ''.join(map(unescape, self._strs))

    def __nonzero__(self):
        return bool(self._strs)


class PoFileParser(object):
    &quot;&quot;&quot;Support class to  read messages from a ``gettext`` PO (portable object) file
    and add them to a `Catalog`

    See `read_po` for simple cases.
    &quot;&quot;&quot;

    _keywords = [
        'msgid',
        'msgstr',
        'msgctxt',
        'msgid_plural',
    ]

    def __init__(self, catalog, ignore_obsolete=False):
        self.catalog = catalog
        self.ignore_obsolete = ignore_obsolete
        self.counter = 0
        self.offset = 0
        self._reset_message_state()

    def _reset_message_state(self):
        self.messages = []
        self.translations = []
        self.locations = []
        self.flags = []
        self.user_comments = []
        self.auto_comments = []
        self.context = None
        self.obsolete = False
        self.in_msgid = False
        self.in_msgstr = False
        self.in_msgctxt = False

    def _add_message(self):
        &quot;&quot;&quot;
        Add a message to the catalog based on the current parser state and
        clear the state ready to process the next message.
        &quot;&quot;&quot;
        self.translations.sort()
        if len(self.messages) &gt; 1:
            msgid = tuple([m.denormalize() for m in self.messages])
        else:
            msgid = self.messages[0].denormalize()
        if isinstance(msgid, (list, tuple)):
            string = ['' for _ in range(self.catalog.num_plurals)]
            for idx, translation in self.translations:
                if idx &gt;= self.catalog.num_plurals:
                    self._invalid_pofile(&quot;&quot;, self.offset, &quot;msg has more translations than num_plurals of catalog&quot;)
                    continue
                string[idx] = translation.denormalize()
            string = tuple(string)
        else:
            string = self.translations[0][1].denormalize()
        if self.context:
            msgctxt = self.context.denormalize()
        else:
            msgctxt = None
        message = Message(msgid, string, list(self.locations), set(self.flags),
                          self.auto_comments, self.user_comments, lineno=self.offset + 1,
                          context=msgctxt)
        if self.obsolete:
            if not self.ignore_obsolete:
                self.catalog.obsolete[msgid] = message
        else:
            self.catalog[msgid] = message
        self.counter += 1
        self._reset_message_state()

    def _finish_current_message(self):
        if self.messages:
            self._add_message()

    def _process_message_line(self, lineno, line, obsolete=False):
        if line.startswith('&quot;'):
            self._process_string_continuation_line(line, lineno)
        else:
            self._process_keyword_line(lineno, line, obsolete)

    def _process_keyword_line(self, lineno, line, obsolete=False):

        for keyword in self._keywords:
            if line.startswith(keyword) and line[len(keyword)] in [' ', '[']:
                arg = line[len(keyword):]
                break
        else:
            self._invalid_pofile(line, lineno, &quot;Start of line didn't match any expected keyword.&quot;)
            return

        if keyword in ['msgid', 'msgctxt']:
            self._finish_current_message()

        self.obsolete = obsolete

        # The line that has the msgid is stored as the offset of the msg
        # should this be the msgctxt if it has one?
        if keyword == 'msgid':
            self.offset = lineno

        if keyword in ['msgid', 'msgid_plural']:
            self.in_msgctxt = False
            self.in_msgid = True
            self.messages.append(_NormalizedString(arg))

        elif keyword == 'msgstr':
            self.in_msgid = False
            self.in_msgstr = True
            if arg.startswith('['):
                idx, msg = arg[1:].split(']', 1)
                self.translations.append([int(idx), _NormalizedString(msg)])
            else:
                self.translations.append([0, _NormalizedString(arg)])

        elif keyword == 'msgctxt':
            self.in_msgctxt = True
            self.context = _NormalizedString(arg)

    def _process_string_continuation_line(self, line, lineno):
        if self.in_msgid:
            s = self.messages[-1]
        elif self.in_msgstr:
            s = self.translations[-1][1]
        elif self.in_msgctxt:
            s = self.context
        else:
            self._invalid_pofile(line, lineno, &quot;Got line starting with \&quot; but not in msgid, msgstr or msgctxt&quot;)
            return
        s.append(line)

    def _process_comment(self, line):

        self._finish_current_message()

        if line[1:].startswith(':'):
            for location in line[2:].lstrip().split():
                pos = location.rfind(':')
                if pos &gt;= 0:
                    try:
                        lineno = int(location[pos + 1:])
                    except ValueError:
                        continue
                    self.locations.append((location[:pos], lineno))
                else:
                    self.locations.append((location, None))
        elif line[1:].startswith(','):
            for flag in line[2:].lstrip().split(','):
                self.flags.append(flag.strip())
        elif line[1:].startswith('.'):
            # These are called auto-comments
            comment = line[2:].strip()
            if comment:  # Just check that we're not adding empty comments
                self.auto_comments.append(comment)
        else:
            # These are called user comments
            self.user_comments.append(line[1:].strip())

    def parse(self, fileobj):
        &quot;&quot;&quot;
        Reads from the file-like object `fileobj` and adds any po file
        units found in it to the `Catalog` supplied to the constructor.
        &quot;&quot;&quot;

        for lineno, line in enumerate(fileobj):
            line = line.strip()
            if not isinstance(line, text_type):
                line = line.decode(self.catalog.charset)
            if not line:
                continue
            if line.startswith('#'):
                if line[1:].startswith('~'):
                    self._process_message_line(lineno, line[2:].lstrip(), obsolete=True)
                else:
                    self._process_comment(line)
            else:
                self._process_message_line(lineno, line)

        self._finish_current_message()

        # No actual messages found, but there was some info in comments, from which
        # we'll construct an empty header message
        if not self.counter and (self.flags or self.user_comments or self.auto_comments):
            self.messages.append(_NormalizedString(u'&quot;&quot;'))
            self.translations.append([0, _NormalizedString(u'&quot;&quot;')])
            self._add_message()

    def _invalid_pofile(self, line, lineno, msg):
        print(&quot;WARNING:&quot;, msg)
        print(&quot;WARNING: Problem on line {0}: {1}&quot;.format(lineno + 1, line))


def read_po(fileobj, locale=None, domain=None, ignore_obsolete=False, charset=None):
    &quot;&quot;&quot;Read messages from a ``gettext`` PO (portable object) file from the given
    file-like object and return a `Catalog`.

    &gt;&gt;&gt; from datetime import datetime
    &gt;&gt;&gt; from babel._compat import StringIO
    &gt;&gt;&gt; buf = StringIO('''
    ... #: main.py:1
    ... #, fuzzy, python-format
    ... msgid &quot;foo %(name)s&quot;
    ... msgstr &quot;quux %(name)s&quot;
    ...
    ... # A user comment
    ... #. An auto comment
    ... #: main.py:3
    ... msgid &quot;bar&quot;
    ... msgid_plural &quot;baz&quot;
    ... msgstr[0] &quot;bar&quot;
    ... msgstr[1] &quot;baaz&quot;
    ... ''')
    &gt;&gt;&gt; catalog = read_po(buf)
    &gt;&gt;&gt; catalog.revision_date = datetime(2007, 4, 1)

    &gt;&gt;&gt; for message in catalog:
    ...     if message.id:
    ...         print((message.id, message.string))
    ...         print(' ', (message.locations, sorted(list(message.flags))))
    ...         print(' ', (message.user_comments, message.auto_comments))
    (u'foo %(name)s', u'quux %(name)s')
      ([(u'main.py', 1)], [u'fuzzy', u'python-format'])
      ([], [])
    ((u'bar', u'baz'), (u'bar', u'baaz'))
      ([(u'main.py', 3)], [])
      ([u'A user comment'], [u'An auto comment'])

    .. versionadded:: 1.0
       Added support for explicit charset argument.

    :param fileobj: the file-like object to read the PO file from
    :param locale: the locale identifier or `Locale` object, or `None`
                   if the catalog is not bound to a locale (which basically
                   means it's a template)
    :param domain: the message domain
    :param ignore_obsolete: whether to ignore obsolete messages in the input
    :param charset: the character set of the catalog.
    &quot;&quot;&quot;
    catalog = Catalog(locale=locale, domain=domain, charset=charset)
    parser = PoFileParser(catalog, ignore_obsolete)
    parser.parse(fileobj)
    return catalog


WORD_SEP = re.compile('('
                      r'\s+|'                                 # any whitespace
                      r'[^\s\w]*\w+[a-zA-Z]-(?=\w+[a-zA-Z])|'  # hyphenated words
                      r'(?&lt;=[\w\!\&quot;\'\&amp;\.\,\?])-{2,}(?=\w)'   # em-dash
                      ')')


def escape(string):
    r&quot;&quot;&quot;Escape the given string so that it can be included in double-quoted
    strings in ``PO`` files.

    &gt;&gt;&gt; escape('''Say:
    ...   &quot;hello, world!&quot;
    ... ''')
    '&quot;Say:\\n  \\&quot;hello, world!\\&quot;\\n&quot;'

    :param string: the string to escape
    &quot;&quot;&quot;
    return '&quot;%s&quot;' % string.replace('\\', '\\\\') \
                          .replace('\t', '\\t') \
                          .replace('\r', '\\r') \
                          .replace('\n', '\\n') \
                          .replace('\&quot;', '\\&quot;')


def normalize(string, prefix='', width=76):
    r&quot;&quot;&quot;Convert a string into a format that is appropriate for .po files.

    &gt;&gt;&gt; print(normalize('''Say:
    ...   &quot;hello, world!&quot;
    ... ''', width=None))
    &quot;&quot;
    &quot;Say:\n&quot;
    &quot;  \&quot;hello, world!\&quot;\n&quot;

    &gt;&gt;&gt; print(normalize('''Say:
    ...   &quot;Lorem ipsum dolor sit amet, consectetur adipisicing elit, &quot;
    ... ''', width=32))
    &quot;&quot;
    &quot;Say:\n&quot;
    &quot;  \&quot;Lorem ipsum dolor sit &quot;
    &quot;amet, consectetur adipisicing&quot;
    &quot; elit, \&quot;\n&quot;

    :param string: the string to normalize
    :param prefix: a string that should be prepended to every line
    :param width: the maximum line width; use `None`, 0, or a negative number
                  to completely disable line wrapping
    &quot;&quot;&quot;
    if width and width &gt; 0:
        prefixlen = len(prefix)
        lines = []
        for line in string.splitlines(True):
            if len(escape(line)) + prefixlen &gt; width:
                chunks = WORD_SEP.split(line)
                chunks.reverse()
                while chunks:
                    buf = []
                    size = 2
                    while chunks:
                        l = len(escape(chunks[-1])) - 2 + prefixlen
                        if size + l &lt; width:
                            buf.append(chunks.pop())
                            size += l
                        else:
                            if not buf:
                                # handle long chunks by putting them on a
                                # separate line
                                buf.append(chunks.pop())
                            break
                    lines.append(u''.join(buf))
            else:
                lines.append(line)
    else:
        lines = string.splitlines(True)

    if len(lines) &lt;= 1:
        return escape(string)

    # Remove empty trailing line
    if lines and not lines[-1]:
        del lines[-1]
        lines[-1] += '\n'
    return u'&quot;&quot;\n' + u'\n'.join([(prefix + escape(line)) for line in lines])


def write_po(fileobj, catalog, width=76, no_location=False, omit_header=False,
             sort_output=False, sort_by_file=False, ignore_obsolete=False,
             include_previous=False, include_lineno=True):
    r&quot;&quot;&quot;Write a ``gettext`` PO (portable object) template file for a given
    message catalog to the provided file-like object.

    &gt;&gt;&gt; catalog = Catalog()
    &gt;&gt;&gt; catalog.add(u'foo %(name)s', locations=[('main.py', 1)],
    ...             flags=('fuzzy',))
    &lt;Message...&gt;
    &gt;&gt;&gt; catalog.add((u'bar', u'baz'), locations=[('main.py', 3)])
    &lt;Message...&gt;
    &gt;&gt;&gt; from babel._compat import BytesIO
    &gt;&gt;&gt; buf = BytesIO()
    &gt;&gt;&gt; write_po(buf, catalog, omit_header=True)
    &gt;&gt;&gt; print(buf.getvalue().decode(&quot;utf8&quot;))
    #: main.py:1
    #, fuzzy, python-format
    msgid &quot;foo %(name)s&quot;
    msgstr &quot;&quot;
    &lt;BLANKLINE&gt;
    #: main.py:3
    msgid &quot;bar&quot;
    msgid_plural &quot;baz&quot;
    msgstr[0] &quot;&quot;
    msgstr[1] &quot;&quot;
    &lt;BLANKLINE&gt;
    &lt;BLANKLINE&gt;

    :param fileobj: the file-like object to write to
    :param catalog: the `Catalog` instance
    :param width: the maximum line width for the generated output; use `None`,
                  0, or a negative number to completely disable line wrapping
    :param no_location: do not emit a location comment for every message
    :param omit_header: do not include the ``msgid &quot;&quot;`` entry at the top of the
                        output
    :param sort_output: whether to sort the messages in the output by msgid
    :param sort_by_file: whether to sort the messages in the output by their
                         locations
    :param ignore_obsolete: whether to ignore obsolete messages and not include
                            them in the output; by default they are included as
                            comments
    :param include_previous: include the old msgid as a comment when
                             updating the catalog
    :param include_lineno: include line number in the location comment
    &quot;&quot;&quot;
    def _normalize(key, prefix=''):
        return normalize(key, prefix=prefix, width=width)

    def _write(text):
        if isinstance(text, text_type):
            text = text.encode(catalog.charset, 'backslashreplace')
        fileobj.write(text)

    def _write_comment(comment, prefix=''):
        # xgettext always wraps comments even if --no-wrap is passed;
        # provide the same behaviour
        if width and width &gt; 0:
            _width = width
        else:
            _width = 76
        for line in wraptext(comment, _width):
            _write('#%s %s\n' % (prefix, line.strip()))

    def _write_message(message, prefix=''):
        if isinstance(message.id, (list, tuple)):
            if message.context:
                _write('%smsgctxt %s\n' % (prefix,
                                           _normalize(message.context, prefix)))
            _write('%smsgid %s\n' % (prefix, _normalize(message.id[0], prefix)))
            _write('%smsgid_plural %s\n' % (
                prefix, _normalize(message.id[1], prefix)
            ))

            for idx in range(catalog.num_plurals):
                try:
                    string = message.string[idx]
                except IndexError:
                    string = ''
                _write('%smsgstr[%d] %s\n' % (
                    prefix, idx, _normalize(string, prefix)
                ))
        else:
            if message.context:
                _write('%smsgctxt %s\n' % (prefix,
                                           _normalize(message.context, prefix)))
            _write('%smsgid %s\n' % (prefix, _normalize(message.id, prefix)))
            _write('%smsgstr %s\n' % (
                prefix, _normalize(message.string or '', prefix)
            ))

    sort_by = None
    if sort_output:
        sort_by = &quot;message&quot;
    elif sort_by_file:
        sort_by = &quot;location&quot;

    for message in _sort_messages(catalog, sort_by=sort_by):
        if not message.id:  # This is the header &quot;message&quot;
            if omit_header:
                continue
            comment_header = catalog.header_comment
            if width and width &gt; 0:
                lines = []
                for line in comment_header.splitlines():
                    lines += wraptext(line, width=width,
                                      subsequent_indent='# ')
                comment_header = u'\n'.join(lines)
            _write(comment_header + u'\n')

        for comment in message.user_comments:
            _write_comment(comment)
        for comment in message.auto_comments:
            _write_comment(comment, prefix='.')

        if not no_location:
            locs = []
            for filename, lineno in sorted(message.locations):
                if lineno and include_lineno:
                    locs.append(u'%s:%d' % (filename.replace(os.sep, '/'), lineno))
                else:
                    locs.append(u'%s' % filename.replace(os.sep, '/'))
            _write_comment(' '.join(locs), prefix=':')
        if message.flags:
            _write('#%s\n' % ', '.join([''] + sorted(message.flags)))

        if message.previous_id and include_previous:
            _write_comment('msgid %s' % _normalize(message.previous_id[0]),
                           prefix='|')
            if len(message.previous_id) &gt; 1:
                _write_comment('msgid_plural %s' % _normalize(
                    message.previous_id[1]
                ), prefix='|')

        _write_message(message)
        _write('\n')

    if not ignore_obsolete:
        for message in _sort_messages(
            catalog.obsolete.values(),
            sort_by=sort_by
        ):
            for comment in message.user_comments:
                _write_comment(comment)
            _write_message(message, prefix='#~ ')
            _write('\n')


def _sort_messages(messages, sort_by):
    &quot;&quot;&quot;
    Sort the given message iterable by the given criteria.

    Always returns a list.

    :param messages: An iterable of Messages.
    :param sort_by: Sort by which criteria? Options are `message` and `location`.
    :return: list[Message]
    &quot;&quot;&quot;
    messages = list(messages)
    if sort_by == &quot;message&quot;:
        messages.sort()
    elif sort_by == &quot;location&quot;:
        messages.sort(key=lambda m: m.locations)
    return messages
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fusr%2Flib%2Fpython3.6%2Fsite-packages%2Fbabel%2Fmessages'>Back to Directory</a>