FM / dist-packages

/usr/lib/python3/dist-packages

Name	Size	Mode	Actions
acme/	-	0755	rm
acme-1.21.0.egg-info/	-	0755	rm
apport/	-	0755	rm
apt/	-	0755	rm
aptsources/	-	0755	rm
apt_inst-stubs/	-	0755	rm
apt_pkg-stubs/	-	0755	rm
attr/	-	0755	rm
attrs-21.2.0.egg-info/	-	0755	rm
automat/	-	0755	rm
Automat-20.2.0.egg-info/	-	0755	rm
babel/	-	0755	rm
Babel-2.8.0.egg-info/	-	0755	rm
bcrypt/	-	0755	rm
bcrypt-3.2.0.egg-info/	-	0755	rm
beautifulsoup4-4.10.0.egg-info/	-	0755	rm
blinker/	-	0755	rm
boost/	-	0755	rm
bs4/	-	0755	rm
certbot/	-	0755	rm
certbot-1.21.0.egg-info/	-	0755	rm
certbot_apache/	-	0755	rm
certbot_apache-1.21.0.egg-info/	-	0755	rm
certbot_dns_cloudflare/	-	0755	rm
certbot_dns_cloudflare-1.18.0.egg-info/	-	0755	rm
certbot_nginx/	-	0755	rm
certbot_nginx-1.21.0.egg-info/	-	0755	rm
certifi/	-	0755	rm
certifi-2020.6.20.egg-info/	-	0755	rm
chardet/	-	0755	rm
chardet-4.0.0.egg-info/	-	0755	rm
click/	-	0755	rm
click-8.0.3.egg-info/	-	0755	rm
CloudFlare/	-	0755	rm
cloudflare-2.8.14.egg-info/	-	0755	rm
cloudinit/	-	0755	rm
cloud_init-25.3.egg-info/	-	0755	rm
colorama/	-	0755	rm
colorama-0.4.4.egg-info/	-	0755	rm
CommandNotFound/	-	0755	rm
ConfigArgParse-1.5.3.egg-info/	-	0755	rm
configobj-5.0.6.egg-info/	-	0755	rm
constantly/	-	0755	rm
constantly-15.1.0.egg-info/	-	0755	rm
cryptography/	-	0755	rm
cryptography-3.4.8.egg-info/	-	0755	rm
dbus/	-	0755	rm
dbus_python-1.2.18.egg-info/	-	0755	rm
debian/	-	0755	rm
debian_bundle/	-	0755	rm
distro/	-	0755	rm
distro-1.7.0.egg-info/	-	0755	rm
distro_info-1.1+ubuntu0.2.egg-info/	-	0755	rm
DistUpgrade/	-	0755	rm
fail2ban/	-	0755	rm
fail2ban-0.11.2.egg-info/	-	0755	rm
gi/	-	0755	rm
hamcrest/	-	0755	rm
html5lib/	-	0755	rm
html5lib-1.1.egg-info/	-	0755	rm
httplib2/	-	0755	rm
httplib2-0.20.2.egg-info/	-	0755	rm
HweSupportStatus/	-	0755	rm
hyperlink/	-	0755	rm
hyperlink-21.0.0.egg-info/	-	0755	rm
icu/	-	0755	rm
idna/	-	0755	rm
idna-3.3.egg-info/	-	0755	rm
importlib_metadata/	-	0755	rm
importlib_metadata-4.6.4.egg-info/	-	0755	rm
incremental/	-	0755	rm
incremental-21.3.0.egg-info/	-	0755	rm
janitor/	-	0755	rm
jeepney/	-	0755	rm
jeepney-0.7.1.dist-info/	-	0755	rm
jinja2/	-	0755	rm
Jinja2-3.0.3.egg-info/	-	0755	rm
josepy/	-	0755	rm
josepy-1.10.0.egg-info/	-	0755	rm
jsonpatch-1.32.egg-info/	-	0755	rm
jsonpointer-2.0.egg-info/	-	0755	rm
jsonschema/	-	0755	rm
jsonschema-3.2.0.egg-info/	-	0755	rm
jwt/	-	0755	rm
keyring/	-	0755	rm
keyring-23.5.0.egg-info/	-	0755	rm
landscape/	-	0755	rm
launchpadlib/	-	0755	rm
launchpadlib-1.10.16.egg-info/	-	0755	rm
lazr/	-	0755	rm
lazr.restfulclient-0.14.4.egg-info/	-	0755	rm
lazr.uri-1.0.6.egg-info/	-	0755	rm
lxml/	-	0755	rm
lxml-4.8.0.egg-info/	-	0755	rm
magic/	-	0755	rm
markupsafe/	-	0755	rm
MarkupSafe-2.0.1.egg-info/	-	0755	rm
more_itertools/	-	0755	rm
more_itertools-8.10.0.egg-info/	-	0755	rm
nacl/	-	0755	rm
netifaces-0.11.0.egg-info/	-	0755	rm
oauthlib/	-	0755	rm
oauthlib-3.2.0.egg-info/	-	0755	rm
OpenSSL/	-	0755	rm
packaging/	-	0755	rm
packaging-21.3.egg-info/	-	0755	rm
parsedatetime/	-	0755	rm
parsedatetime-2.6.egg-info/	-	0755	rm
pexpect/	-	0755	rm
pkg_resources/	-	0755	rm
ptyprocess/	-	0755	rm
ptyprocess-0.7.0.dist-info/	-	0755	rm
pyasn1/	-	0755	rm
pyasn1-0.4.8.egg-info/	-	0755	rm
pyasn1_modules/	-	0755	rm
PyGObject-3.42.1.egg-info/	-	0755	rm
pygtkcompat/	-	0755	rm
PyHamcrest-2.0.2.egg-info/	-	0755	rm
PyICU-2.8.1.egg-info/	-	0755	rm
PyJWT-2.3.0.egg-info/	-	0755	rm
pymacaroons/	-	0755	rm
pymacaroons-0.13.0.egg-info/	-	0755	rm
PyNaCl-1.5.0.dist-info/	-	0755	rm
pyOpenSSL-21.0.0.egg-info/	-	0755	rm
pyparsing-2.4.7.egg-info/	-	0755	rm
pyrfc3339/	-	0755	rm
pyRFC3339-1.1.egg-info/	-	0755	rm
pyrsistent/	-	0755	rm
pyrsistent-0.18.1.egg-info/	-	0755	rm
pyserial-3.5.egg-info/	-	0755	rm
python_apt-2.4.0+ubuntu4.1.egg-info/	-	0755	rm
python_debian-0.1.43+ubuntu1.1.egg-info/	-	0755	rm
python_magic-0.4.24.egg-info/	-	0755	rm
pytz/	-	0755	rm
pytz-2022.1.egg-info/	-	0755	rm
PyYAML-5.4.1.egg-info/	-	0755	rm
requests/	-	0755	rm
requests-2.25.1.egg-info/	-	0755	rm
requests_toolbelt/	-	0755	rm
requests_toolbelt-0.9.1.egg-info/	-	0755	rm
secretstorage/	-	0755	rm
SecretStorage-3.3.1.egg-info/	-	0755	rm
serial/	-	0755	rm
service_identity/	-	0755	rm
service_identity-18.1.0.egg-info/	-	0755	rm
setuptools/	-	0755	rm
setuptools-59.6.0.egg-info/	-	0755	rm
six-1.16.0.egg-info/	-	0755	rm
softwareproperties/	-	0755	rm
sos/	-	0755	rm
sos-4.10.2.egg-info/	-	0755	rm
soupsieve/	-	0755	rm
soupsieve-2.3.1.egg-info/	-	0755	rm
ssh_import_id/	-	0755	rm
ssh_import_id-5.11.egg-info/	-	0755	rm
systemd/	-	0755	rm
twisted/	-	0755	rm
Twisted-22.1.0.egg-info/	-	0755	rm
uaclient/	-	0755	rm
ubuntu_pro_client-8001.egg-info/	-	0755	rm
ufw/	-	0755	rm
unattended_upgrades-0.1.egg-info/	-	0755	rm
UpdateManager/	-	0755	rm
urllib3/	-	0755	rm
urllib3-1.26.5.egg-info/	-	0755	rm
wadllib/	-	0755	rm
wadllib-1.3.6.egg-info/	-	0755	rm
webencodings/	-	0755	rm
webencodings-0.5.1.egg-info/	-	0755	rm
yaml/	-	0755	rm
zipp-1.0.0.egg-info/	-	0755	rm
zope/	-	0755	rm
zope.component-4.3.0.egg-info/	-	0755	rm
zope.event-4.4.egg-info/	-	0755	rm
zope.hookable-5.1.0.egg-info/	-	0755	rm
zope.interface-5.4.0.egg-info/	-	0755	rm
_distutils_hack/	-	0755	rm
_yaml/	-	0755	rm
__pycache__/	-	0755	rm
apport_python_hook.py	8063	0644	edit dl rm
apt_inst.cpython-310-x86_64-linux-gnu.so	60064	0644	edit dl rm
apt_pkg.cpython-310-x86_64-linux-gnu.so	347096	0644	edit dl rm
augeas.py	23555	0644	edit dl rm
blinker-1.4.egg-info	3901	0644	edit dl rm
command_not_found-0.3.egg-info	189	0644	edit dl rm
configargparse.py	49875	0644	edit dl rm
configobj.py	89613	0644	edit dl rm
deb822.py	273	0644	edit dl rm
debconf.py	6769	0644	edit dl rm
distro_info.py	12528	0644	edit dl rm
jsonpatch.py	28813	0644	edit dl rm
jsonpointer.py	9796	0644	edit dl rm
lsb_release.py	14901	0644	edit dl rm
netifaces.cpython-310-x86_64-linux-gnu.so	23232	0644	edit dl rm
pexpect-4.8.0.egg-info	2285	0644	edit dl rm
problem_report.py	26867	0644	edit dl rm
pvectorc.cpython-310-x86_64-linux-gnu.so	37552	0644	edit dl rm
pyasn1_modules-0.2.1.egg-info	1722	0644	edit dl rm
pyinotify-0.9.6.egg-info	1421	0644	edit dl rm
pyinotify.py	89010	0644	edit dl rm
pyparsing.py	273365	0644	edit dl rm
python_augeas-0.5.0.egg-info	238	0644	edit dl rm
six.py	34549	0644	edit dl rm
snack.py	31134	0644	edit dl rm
systemd_python-234.egg-info	586	0644	edit dl rm
ufw-0.36.1.egg-info	263	0644	edit dl rm
validate.py	47243	0644	edit dl rm
zipp.py	6914	0644	edit dl rm
zope.component-4.3.0-nspkg.pth	529	0644	edit dl rm
zope.event-4.4-nspkg.pth	529	0644	edit dl rm
zope.hookable-5.1.0-nspkg.pth	529	0644	edit dl rm
zope.interface-5.4.0-nspkg.pth	529	0644	edit dl rm
_cffi_backend.cpython-310-x86_64-linux-gnu.so	194472	0644	edit dl rm
_dbus_bindings.cpython-310-x86_64-linux-gnu.so	168152	0644	edit dl rm
_dbus_glib_bindings.cpython-310-x86_64-linux-gnu.so	23040	0644	edit dl rm
_pyrsistent_version.py	23	0644	edit dl rm
_snack.cpython-310-x86_64-linux-gnu.so	47888	0644	edit dl rm
_version.py	21	0644	edit dl rm

Edit: /usr/lib/python3/dist-packages/problem_report.py (26867B)

# vim: set encoding=UTF-8 fileencoding=UTF-8 :

'''Store, load, and handle problem reports.'''

# Copyright (C) 2006 - 2012 Canonical Ltd.
# Author: Martin Pitt <martin.pitt@ubuntu.com>
#
# This program is free software; you can redistribute it and/or modify it
# under the terms of the GNU General Public License as published by the
# Free Software Foundation; either version 2 of the License, or (at your
# option) any later version.  See http://www.gnu.org/copyleft/gpl.html for
# the full text of the license.

import locale
import zlib, base64, time, sys, gzip, struct, os
from email.encoders import encode_base64
from email.mime.multipart import MIMEMultipart
from email.mime.base import MIMEBase
from email.mime.text import MIMEText
from io import BytesIO

if sys.version[0] < '3':
    from UserDict import IterableUserDict as UserDict
    UserDict  # pyflakes
    _python2 = True
else:
    from collections import UserDict
    _python2 = False

class CompressedValue:
    '''Represent a ProblemReport value which is gzip compressed.'''

def __init__(self, value=None, name=None):
        '''Initialize an empty CompressedValue object with an optional name.'''

self.gzipvalue = None
        self.name = name
        # By default, compressed values are in gzip format. Earlier versions of
        # problem_report used zlib format (without gzip header). If you have
        # such a case, set legacy_zlib to True.
        self.legacy_zlib = False

if value:
            self.set_value(value)

def set_value(self, value):
        '''Set uncompressed value.'''

out = BytesIO()
        gzip.GzipFile(self.name, mode='wb', fileobj=out, mtime=0).write(value)
        self.gzipvalue = out.getvalue()
        self.legacy_zlib = False

def get_value(self):
        '''Return uncompressed value.'''

if not self.gzipvalue:
            return None

if self.legacy_zlib:
            return zlib.decompress(self.gzipvalue)
        return gzip.GzipFile(fileobj=BytesIO(self.gzipvalue)).read()

def write(self, file):
        '''Write uncompressed value into given file-like object.'''

assert self.gzipvalue

if self.legacy_zlib:
            file.write(zlib.decompress(self.gzipvalue))
            return

gz = gzip.GzipFile(fileobj=BytesIO(self.gzipvalue))
        while True:
            block = gz.read(1048576)
            if not block:
                break
            file.write(block)

def __len__(self):
        '''Return length of uncompressed value.'''

assert self.gzipvalue
        if self.legacy_zlib:
            return len(self.get_value())
        return int(struct.unpack('<L', self.gzipvalue[-4:])[0])

def splitlines(self):
        '''Behaves like splitlines() for a normal string.'''

return self.get_value().splitlines()

class ProblemReport(UserDict):
    def __init__(self, type='Crash', date=None):
        '''Initialize a fresh problem report.

type can be 'Crash', 'Packaging', 'KernelCrash' or 'KernelOops'.
        date is the desired date/time string; if None (default), the
        current local time is used.
        '''
        if date is None:
            date = time.asctime()
        self.data = {'ProblemType': type, 'Date': date}

# keeps track of keys which were added since the last ctor or load()
        self.old_keys = set()

def load(self, file, binary=True, key_filter=None):
        '''Initialize problem report from a file-like object.

If binary is False, binary data is not loaded; the dictionary key is
        created, but its value will be an empty string. If it is True, it is
        transparently uncompressed and available as dictionary byte array values.
        If binary is 'compressed', the compressed value is retained, and the
        dictionary value will be a CompressedValue object. This is useful if
        the compressed value is still useful (to avoid recompression if the
        file needs to be written back).

file needs to be opened in binary mode.

If key_filter is given, only those keys will be loaded.

Files are in RFC822 format, but with case sensitive keys.
        '''
        self._assert_bin_mode(file)
        self.data.clear()
        key = None
        value = None
        b64_block = False
        bd = None
        if key_filter:
            remaining_keys = set(key_filter)
        else:
            remaining_keys = None
        for line in file:
            # continuation line
            if line.startswith(b' '):
                if b64_block and not binary:
                    value = None
                    continue
                assert (key is not None and value is not None)
                if b64_block:
                    block = base64.b64decode(line)
                    if bd:
                        value += bd.decompress(block)
                    else:
                        if binary == 'compressed':
                            # check gzip header; if absent, we have legacy zlib
                            # data
                            if value.gzipvalue == b'' and not block.startswith(b'\037\213\010'):
                                value.legacy_zlib = True
                            value.gzipvalue += block
                        else:
                            # lazy initialization of bd
                            # skip gzip header, if present
                            if block.startswith(b'\037\213\010'):
                                bd = zlib.decompressobj(-zlib.MAX_WBITS)
                                value = bd.decompress(self._strip_gzip_header(block))
                            else:
                                # legacy zlib-only format used default block
                                # size
                                bd = zlib.decompressobj()
                                value += bd.decompress(block)
                else:
                    if len(value) > 0:
                        value += b'\n'
                    if line.endswith(b'\n'):
                        value += line[1:-1]
                    else:
                        value += line[1:]
            else:
                if b64_block:
                    if bd:
                        value += bd.flush()
                    b64_block = False
                    bd = None
                if key:
                    if remaining_keys is not None:
                        try:
                            remaining_keys.remove(key)
                            self.data[key] = self._try_unicode(value)
                            if not remaining_keys:
                                key = None
                                break
                        except KeyError:
                            pass
                    else:
                        self.data[key] = self._try_unicode(value)

(key, value) = line.split(b':', 1)
                if not _python2:
                    key = key.decode('ASCII')
                value = value.strip()
                if value == b'base64':
                    if binary == 'compressed':
                        value = CompressedValue(key.encode())
                        value.gzipvalue = b''
                    else:
                        value = b''
                    b64_block = True

if key is not None:
            self.data[key] = self._try_unicode(value)

self.old_keys = set(self.data.keys())

def extract_keys(self, file, bin_keys, dir):
        '''Extract only one binary element from the problem_report

Binary elements like kernel crash dumps can be very big. This method
        extracts directly files without loading the report into memory.
        '''
        self._assert_bin_mode(file)
        # support singe key and collection of keys
        if isinstance(bin_keys, str):
            bin_keys = [bin_keys]
        key = None
        value = None
        missing_keys = list(bin_keys)
        b64_block = {}
        bd = None
        out = None
        for line in file:
            # Identify the bin_keys we're looking for
            while not line.startswith(b' '):
                (key, value) = line.split(b':', 1)
                if not _python2:
                    key = key.decode('ASCII')
                if key not in missing_keys:
                    break
                b64_block[key] = False
                missing_keys.remove(key)
                value = value.strip()
                if value == b'base64':
                    value = b''
                    b64_block[key] = True
                    try:
                        bd = None
                        with open(os.path.join(dir, key), 'wb') as out:
                            for line in file:
                                # continuation line
                                if line.startswith(b' '):
                                    assert (key is not None and value is not None)
                                    if b64_block[key]:
                                        block = base64.b64decode(line)
                                        if bd:
                                            out.write(bd.decompress(block))
                                        else:
                                            # lazy initialization of bd
                                            # skip gzip header, if present
                                            if block.startswith(b'\037\213\010'):
                                                bd = zlib.decompressobj(-zlib.MAX_WBITS)
                                                out.write(bd.decompress(self._strip_gzip_header(block)))
                                            else:
                                                # legacy zlib-only format used default block
                                                # size
                                                bd = zlib.decompressobj()
                                                out.write(bd.decompress(block))
                                else:
                                    break
                    except IOError:
                        raise IOError('unable to open %s' % (os.path.join(dir, key)))
                else:
                    break
        if missing_keys:
            raise KeyError('Cannot find %s in report' % ', '.join(missing_keys))
        if False in b64_block.values():
            raise ValueError('%s has no binary content' %
                             [item for item, element in b64_block.items() if element is False])

def get_timestamp(self) -> int:
        '''Get timestamp (seconds since epoch) from Date field

Return None if it is not present.
        '''
        # report time is from asctime(), not in locale representation
        orig_ctime = locale.getlocale(locale.LC_TIME)
        try:
            try:
                locale.setlocale(locale.LC_TIME, 'C')
                return int(time.mktime(time.strptime(self['Date'])))
            except KeyError:
                return None
            finally:
                locale.setlocale(locale.LC_TIME, orig_ctime)
        except locale.Error:
            return None

def has_removed_fields(self):
        '''Check if the report has any keys which were not loaded.

This could happen when using binary=False in load().
        '''
        return None in self.values()

@classmethod
    def _is_binary(klass, string):
        '''Check if the given strings contains binary data.'''

if type(string) == bytes:
            for c in string:
                if c < 32 and not chr(c).isspace():
                    return True
        return False

@classmethod
    def _try_unicode(klass, value):
        '''Try to convert bytearray value to unicode'''

if type(value) == bytes and not klass._is_binary(value):
            try:
                return value.decode('UTF-8')
            except UnicodeDecodeError:
                return value
        return value

def write(self, file, only_new=False):
        '''Write information into the given file-like object.

If only_new is True, only keys which have been added since the last
        load() are written (i. e. those returned by new_keys()).

If a value is a string, it is written directly. Otherwise it must be a
        tuple of the form (file, encode=True, limit=None, fail_on_empty=False).
        The first argument can be a file name or a file-like object,
        which will be read and its content will become the value of this key.
        'encode' specifies whether the contents will be
        gzip compressed and base64-encoded (this defaults to True). If limit is
        set to a positive integer, the file is not attached if it's larger
        than the given limit, and the entire key will be removed. If
        fail_on_empty is True, reading zero bytes will cause an IOError.

file needs to be opened in binary mode.

Files are written in RFC822 format.
        '''
        self._assert_bin_mode(file)

# sort keys into ASCII non-ASCII/binary attachment ones, so that
        # the base64 ones appear last in the report
        asckeys = []
        binkeys = []
        for k in self.data.keys():
            if only_new and k in self.old_keys:
                continue
            v = self.data[k]
            if hasattr(v, 'find'):
                if self._is_binary(v):
                    binkeys.append(k)
                else:
                    asckeys.append(k)
            else:
                if not isinstance(v, CompressedValue) and len(v) >= 2 and not v[1]:
                    # force uncompressed
                    asckeys.append(k)
                else:
                    binkeys.append(k)

asckeys.sort()
        if 'ProblemType' in asckeys:
            asckeys.remove('ProblemType')
            asckeys.insert(0, 'ProblemType')
        binkeys.sort()

# write the ASCII keys first
        for k in asckeys:
            v = self.data[k]

# if it's a tuple, we have a file reference; read the contents
            if not hasattr(v, 'find'):
                if len(v) >= 3 and v[2] is not None:
                    limit = v[2]
                else:
                    limit = None

fail_on_empty = len(v) >= 4 and v[3]

if hasattr(v[0], 'read'):
                    v = v[0].read()  # file-like object
                else:
                    with open(v[0], 'rb') as f:  # file name
                        v = f.read()

if fail_on_empty and len(v) == 0:
                    raise IOError('did not get any data for field ' + k)

if limit is not None and len(v) > limit:
                    del self.data[k]
                    continue

if isinstance(v, str):
                # unicode → str
                v = v.encode('UTF-8')

file.write(k.encode('ASCII'))
            if b'\n' in v:
                # multiline value
                file.write(b':\n ')
                file.write(v.replace(b'\n', b'\n '))
            else:
                file.write(b': ')
                file.write(v)
            file.write(b'\n')

# now write the binary keys with gzip compression and base64 encoding
        for k in binkeys:
            v = self.data[k]
            limit = None
            size = 0

curr_pos = file.tell()
            file.write(k.encode('ASCII'))
            file.write(b': base64\n ')

# CompressedValue
            if isinstance(v, CompressedValue):
                file.write(base64.b64encode(v.gzipvalue))
                file.write(b'\n')
                continue

# write gzip header
            gzip_header = b'\037\213\010\010\000\000\000\000\002\377' + k.encode('UTF-8') + b'\000'
            file.write(base64.b64encode(gzip_header))
            file.write(b'\n ')
            crc = zlib.crc32(b'')

bc = zlib.compressobj(6, zlib.DEFLATED, -zlib.MAX_WBITS,
                                  zlib.DEF_MEM_LEVEL, 0)
            # direct value
            if hasattr(v, 'find'):
                size += len(v)
                crc = zlib.crc32(v, crc)
                outblock = bc.compress(v)
                if outblock:
                    file.write(base64.b64encode(outblock))
                    file.write(b'\n ')
            # file reference
            else:
                if len(v) >= 3 and v[2] is not None:
                    limit = v[2]

if hasattr(v[0], 'read'):
                    f = v[0]  # file-like object
                else:
                    f = open(v[0], 'rb')  # file name
                while True:
                    block = f.read(1048576)
                    size += len(block)
                    crc = zlib.crc32(block, crc)
                    if limit is not None:
                        if size > limit:
                            # roll back
                            file.seek(curr_pos)
                            file.truncate(curr_pos)
                            del self.data[k]
                            crc = None
                            break
                    if block:
                        outblock = bc.compress(block)
                        if outblock:
                            file.write(base64.b64encode(outblock))
                            file.write(b'\n ')
                    else:
                        break
                if not hasattr(v[0], 'read'):
                    f.close()

if len(v) >= 4 and v[3]:
                    if size == 0:
                        raise IOError('did not get any data for field %s from %s' % (k, str(v[0])))

# flush compressor and write the rest
            if not limit or size <= limit:
                block = bc.flush()
                # append gzip trailer: crc (32 bit) and size (32 bit)
                if crc:
                    block += struct.pack('<L', crc & 0xFFFFFFFF)
                    block += struct.pack('<L', size & 0xFFFFFFFF)

file.write(base64.b64encode(block))
                file.write(b'\n')

def add_to_existing(self, reportfile, keep_times=False):
        '''Add this report's data to an already existing report file.

The file will be temporarily chmod'ed to 000 to prevent frontends
        from picking up a hal-updated report file. If keep_times
        is True, then the file's atime and mtime restored after updating.
        '''
        st = os.stat(reportfile)
        try:
            f = open(reportfile, 'ab')
            os.chmod(reportfile, 0)
            self.write(f)
            f.close()
        finally:
            if keep_times:
                os.utime(reportfile, (st.st_atime, st.st_mtime))
            os.chmod(reportfile, st.st_mode)

def write_mime(self, file, attach_treshold=5, extra_headers={},
                   skip_keys=None, priority_fields=None):
        '''Write MIME/Multipart RFC 2822 formatted data into file.

file must be a file-like object, not a path.  It needs to be opened in
        binary mode.

If a value is a string or a CompressedValue, it is written directly.
        Otherwise it must be a tuple containing the source file and an optional
        boolean value (in that order); the first argument can be a file name or
        a file-like object, which will be read and its content will become the
        value of this key.  The file will be gzip compressed, unless the key
        already ends in .gz.

attach_treshold specifies the maximum number of lines for a value to be
        included into the first inline text part. All bigger values (as well as
        all non-ASCII ones) will become an attachment, as well as text
        values bigger than 1 kB.

Extra MIME preamble headers can be specified, too, as a dictionary.

skip_keys is a set/list specifying keys which are filtered out and not
        written to the destination file.

priority_fields is a set/list specifying the order in which keys should
        appear in the destination file.
        '''
        self._assert_bin_mode(file)

keys = sorted(self.data.keys())

text = ''
        attachments = []

if 'ProblemType' in keys:
            keys.remove('ProblemType')
            keys.insert(0, 'ProblemType')

if priority_fields:
            counter = 0
            for priority_field in priority_fields:
                if priority_field in keys:
                    keys.remove(priority_field)
                    keys.insert(counter, priority_field)
                    counter += 1

for k in keys:
            if skip_keys and k in skip_keys:
                continue
            v = self.data[k]
            attach_value = None

# compressed values are ready for attaching in gzip form
            if isinstance(v, CompressedValue):
                attach_value = v.gzipvalue

# if it's a tuple, we have a file reference; read the contents
            # and gzip it
            elif not hasattr(v, 'find'):
                attach_value = ''
                if hasattr(v[0], 'read'):
                    f = v[0]  # file-like object
                else:
                    f = open(v[0], 'rb')  # file name
                if k.endswith('.gz'):
                    attach_value = f.read()
                else:
                    io = BytesIO()
                    gf = gzip.GzipFile(k, mode='wb', fileobj=io, mtime=0)
                    while True:
                        block = f.read(1048576)
                        if block:
                            gf.write(block)
                        else:
                            gf.close()
                            break
                    attach_value = io.getvalue()
                f.close()

# binary value
            elif self._is_binary(v):
                if k.endswith('.gz'):
                    attach_value = v
                else:
                    attach_value = CompressedValue(v, k).gzipvalue

# if we have an attachment value, create an attachment
            if attach_value:
                att = MIMEBase('application', 'x-gzip')
                if k.endswith('.gz'):
                    att.add_header('Content-Disposition', 'attachment', filename=k)
                else:
                    att.add_header('Content-Disposition', 'attachment', filename=k + '.gz')
                att.set_payload(attach_value)
                encode_base64(att)
                attachments.append(att)
            else:
                # plain text value
                size = len(v)

# ensure that byte arrays are valid UTF-8
                if type(v) == bytes:
                    v = v.decode('UTF-8', 'replace')
                # convert unicode to UTF-8 str
                assert isinstance(v, str)

lines = len(v.splitlines())
                if size <= 1000 and lines == 1:
                    v = v.rstrip()
                    text += k + ': ' + v + '\n'
                elif size <= 1000 and lines <= attach_treshold:
                    text += k + ':\n '
                    if not v.endswith('\n'):
                        v += '\n'
                    text += v.strip().replace('\n', '\n ') + '\n'
                else:
                    # too large, separate attachment
                    att = MIMEText(v, _charset='UTF-8')
                    att.add_header('Content-Disposition', 'attachment', filename=k + '.txt')
                    attachments.append(att)

# create initial text attachment
        att = MIMEText(text, _charset='UTF-8')
        att.add_header('Content-Disposition', 'inline')
        attachments.insert(0, att)

msg = MIMEMultipart()
        for k, v in extra_headers.items():
            msg.add_header(k, v)
        for a in attachments:
            msg.attach(a)

file.write(msg.as_string().encode('UTF-8'))
        file.write(b'\n')

def __setitem__(self, k, v):
        assert hasattr(k, 'isalnum')
        if not k.replace('.', '').replace('-', '').replace('_', '').isalnum():
            raise ValueError("key '%s' contains invalid characters (only numbers, letters, '.', '_', and '-' are allowed)" % k)
        # value must be a string or a CompressedValue or a file reference
        # (tuple (string|file [, bool, [, max_size [, fail_on_empty]]]))
        if not (isinstance(v, CompressedValue) or hasattr(v, 'isalnum') or
                (isinstance(v, tuple) and (
                    len(v) == 1 or (len(v) >= 2 and len(v) <= 4 and v[1] in (True, False))) and
                    (hasattr(v[0], 'isalnum') or hasattr(v[0], 'read')))):
            raise TypeError("value for key %s must be a string, CompressedValue, or a file reference" % k)

return self.data.__setitem__(k, v)

def new_keys(self):
        '''Return newly added keys.

Return the set of keys which have been added to the report since it
        was constructed or loaded.
        '''
        return set(self.data.keys()) - self.old_keys

@classmethod
    def _strip_gzip_header(klass, line):
        '''Strip gzip header from line and return the rest.'''

if _python2:
            return klass._strip_gzip_header_py2(line)

flags = line[3]
        offset = 10
        if flags & 4:  # FLG.FEXTRA
            offset += line[offset] + 1
        if flags & 8:  # FLG.FNAME
            while line[offset] != 0:
                offset += 1
            offset += 1
        if flags & 16:  # FLG.FCOMMENT
            while line[offset] != 0:
                offset += 1
            offset += 1
        if flags & 2:  # FLG.FHCRC
            offset += 2

return line[offset:]

@classmethod
    def _strip_gzip_header_py2(klass, line):
        '''Strip gzip header from line and return the rest. (Python 2)'''

flags = ord(line[3])
        offset = 10
        if flags & 4:  # FLG.FEXTRA
            offset += line[offset] + 1
        if flags & 8:  # FLG.FNAME
            while ord(line[offset]) != 0:
                offset += 1
            offset += 1
        if flags & 16:  # FLG.FCOMMENT
            while ord(line[offset]) != 0:
                offset += 1
            offset += 1
        if flags & 2:  # FLG.FHCRC
            offset += 2

return line[offset:]

@classmethod
    def _assert_bin_mode(klass, file):
        '''Assert that given file object is in binary mode'''

if _python2:
            assert (type(file) == BytesIO or 'b' in file.mode), 'file stream must be in binary mode'
        else:
            assert not hasattr(file, 'encoding'), 'file stream must be in binary mode'

cmd: