first commit

projecten1/lib/python3.6/__future__.py

@@ -0,0 +1 @@
+/usr/lib/python3.6/__future__.py

projecten1/lib/python3.6/_bootlocale.py

@@ -0,0 +1 @@
+/usr/lib/python3.6/_bootlocale.py

projecten1/lib/python3.6/_collections_abc.py

@@ -0,0 +1 @@
+/usr/lib/python3.6/_collections_abc.py

projecten1/lib/python3.6/_dummy_thread.py

@@ -0,0 +1 @@
+/usr/lib/python3.6/_dummy_thread.py

projecten1/lib/python3.6/_weakrefset.py

@@ -0,0 +1 @@
+/usr/lib/python3.6/_weakrefset.py

projecten1/lib/python3.6/abc.py

@@ -0,0 +1 @@
+/usr/lib/python3.6/abc.py

projecten1/lib/python3.6/base64.py

@@ -0,0 +1 @@
+/usr/lib/python3.6/base64.py

projecten1/lib/python3.6/bisect.py

@@ -0,0 +1 @@
+/usr/lib/python3.6/bisect.py

projecten1/lib/python3.6/codecs.py

@@ -0,0 +1 @@
+/usr/lib/python3.6/codecs.py

projecten1/lib/python3.6/collections

@@ -0,0 +1 @@
+/usr/lib/python3.6/collections

projecten1/lib/python3.6/config-3.6m-x86_64-linux-gnu

@@ -0,0 +1 @@
+/usr/lib/python3.6/config-3.6m-x86_64-linux-gnu

projecten1/lib/python3.6/copy.py

@@ -0,0 +1 @@
+/usr/lib/python3.6/copy.py

projecten1/lib/python3.6/copyreg.py

@@ -0,0 +1 @@
+/usr/lib/python3.6/copyreg.py

projecten1/lib/python3.6/distutils/__init__.py

@@ -0,0 +1,101 @@
+import os
+import sys
+import warnings 
+import imp
+import opcode # opcode is not a virtualenv module, so we can use it to find the stdlib
+              # Important! To work on pypy, this must be a module that resides in the
+              # lib-python/modified-x.y.z directory
+
+dirname = os.path.dirname
+
+distutils_path = os.path.join(os.path.dirname(opcode.__file__), 'distutils')
+if os.path.normpath(distutils_path) == os.path.dirname(os.path.normpath(__file__)):
+    warnings.warn(
+        "The virtualenv distutils package at %s appears to be in the same location as the system distutils?")
+else:
+    __path__.insert(0, distutils_path)
+    real_distutils = imp.load_module("_virtualenv_distutils", None, distutils_path, ('', '', imp.PKG_DIRECTORY))
+    # Copy the relevant attributes
+    try:
+        __revision__ = real_distutils.__revision__
+    except AttributeError:
+        pass
+    __version__ = real_distutils.__version__
+
+from distutils import dist, sysconfig
+
+try:
+    basestring
+except NameError:
+    basestring = str
+
+## patch build_ext (distutils doesn't know how to get the libs directory
+## path on windows - it hardcodes the paths around the patched sys.prefix)
+
+if sys.platform == 'win32':
+    from distutils.command.build_ext import build_ext as old_build_ext
+    class build_ext(old_build_ext):
+        def finalize_options (self):
+            if self.library_dirs is None:
+                self.library_dirs = []
+            elif isinstance(self.library_dirs, basestring):
+                self.library_dirs = self.library_dirs.split(os.pathsep)
+            
+            self.library_dirs.insert(0, os.path.join(sys.real_prefix, "Libs"))
+            old_build_ext.finalize_options(self)
+            
+    from distutils.command import build_ext as build_ext_module 
+    build_ext_module.build_ext = build_ext
+
+## distutils.dist patches:
+
+old_find_config_files = dist.Distribution.find_config_files
+def find_config_files(self):
+    found = old_find_config_files(self)
+    system_distutils = os.path.join(distutils_path, 'distutils.cfg')
+    #if os.path.exists(system_distutils):
+    #    found.insert(0, system_distutils)
+        # What to call the per-user config file
+    if os.name == 'posix':
+        user_filename = ".pydistutils.cfg"
+    else:
+        user_filename = "pydistutils.cfg"
+    user_filename = os.path.join(sys.prefix, user_filename)
+    if os.path.isfile(user_filename):
+        for item in list(found):
+            if item.endswith('pydistutils.cfg'):
+                found.remove(item)
+        found.append(user_filename)
+    return found
+dist.Distribution.find_config_files = find_config_files
+
+## distutils.sysconfig patches:
+
+old_get_python_inc = sysconfig.get_python_inc
+def sysconfig_get_python_inc(plat_specific=0, prefix=None):
+    if prefix is None:
+        prefix = sys.real_prefix
+    return old_get_python_inc(plat_specific, prefix)
+sysconfig_get_python_inc.__doc__ = old_get_python_inc.__doc__
+sysconfig.get_python_inc = sysconfig_get_python_inc
+
+old_get_python_lib = sysconfig.get_python_lib
+def sysconfig_get_python_lib(plat_specific=0, standard_lib=0, prefix=None):
+    if standard_lib and prefix is None:
+        prefix = sys.real_prefix
+    return old_get_python_lib(plat_specific, standard_lib, prefix)
+sysconfig_get_python_lib.__doc__ = old_get_python_lib.__doc__
+sysconfig.get_python_lib = sysconfig_get_python_lib
+
+old_get_config_vars = sysconfig.get_config_vars
+def sysconfig_get_config_vars(*args):
+    real_vars = old_get_config_vars(*args)
+    if sys.platform == 'win32':
+        lib_dir = os.path.join(sys.real_prefix, "libs")
+        if isinstance(real_vars, dict) and 'LIBDIR' not in real_vars:
+            real_vars['LIBDIR'] = lib_dir # asked for all
+        elif isinstance(real_vars, list) and 'LIBDIR' in args:
+            real_vars = real_vars + [lib_dir] # asked for list
+    return real_vars
+sysconfig_get_config_vars.__doc__ = old_get_config_vars.__doc__
+sysconfig.get_config_vars = sysconfig_get_config_vars

projecten1/lib/python3.6/distutils/distutils.cfg

@@ -0,0 +1,6 @@
+# This is a config file local to this virtualenv installation
+# You may include options that will be used by all distutils commands,
+# and by easy_install.  For instance:
+#
+#   [easy_install]
+#   find_links = http://mylocalsite

projecten1/lib/python3.6/encodings

@@ -0,0 +1 @@
+/usr/lib/python3.6/encodings

projecten1/lib/python3.6/enum.py

@@ -0,0 +1 @@
+/usr/lib/python3.6/enum.py

projecten1/lib/python3.6/fnmatch.py

@@ -0,0 +1 @@
+/usr/lib/python3.6/fnmatch.py

projecten1/lib/python3.6/functools.py

@@ -0,0 +1 @@
+/usr/lib/python3.6/functools.py

projecten1/lib/python3.6/genericpath.py

@@ -0,0 +1 @@
+/usr/lib/python3.6/genericpath.py

projecten1/lib/python3.6/hashlib.py

@@ -0,0 +1 @@
+/usr/lib/python3.6/hashlib.py

projecten1/lib/python3.6/heapq.py

@@ -0,0 +1 @@
+/usr/lib/python3.6/heapq.py

projecten1/lib/python3.6/hmac.py

@@ -0,0 +1 @@
+/usr/lib/python3.6/hmac.py

projecten1/lib/python3.6/imp.py

@@ -0,0 +1 @@
+/usr/lib/python3.6/imp.py

projecten1/lib/python3.6/importlib

@@ -0,0 +1 @@
+/usr/lib/python3.6/importlib

projecten1/lib/python3.6/io.py

@@ -0,0 +1 @@
+/usr/lib/python3.6/io.py

projecten1/lib/python3.6/keyword.py

@@ -0,0 +1 @@
+/usr/lib/python3.6/keyword.py

projecten1/lib/python3.6/lib-dynload

@@ -0,0 +1 @@
+/usr/lib/python3.6/lib-dynload

projecten1/lib/python3.6/linecache.py

@@ -0,0 +1 @@
+/usr/lib/python3.6/linecache.py

projecten1/lib/python3.6/locale.py

@@ -0,0 +1 @@
+/usr/lib/python3.6/locale.py

projecten1/lib/python3.6/ntpath.py

@@ -0,0 +1 @@
+/usr/lib/python3.6/ntpath.py

projecten1/lib/python3.6/operator.py

@@ -0,0 +1 @@
+/usr/lib/python3.6/operator.py

projecten1/lib/python3.6/orig-prefix.txt

@@ -0,0 +1 @@
+/usr

projecten1/lib/python3.6/os.py

@@ -0,0 +1 @@
+/usr/lib/python3.6/os.py

projecten1/lib/python3.6/posixpath.py

@@ -0,0 +1 @@
+/usr/lib/python3.6/posixpath.py

projecten1/lib/python3.6/random.py

@@ -0,0 +1 @@
+/usr/lib/python3.6/random.py

projecten1/lib/python3.6/re.py

@@ -0,0 +1 @@
+/usr/lib/python3.6/re.py

projecten1/lib/python3.6/reprlib.py

@@ -0,0 +1 @@
+/usr/lib/python3.6/reprlib.py

projecten1/lib/python3.6/rlcompleter.py

@@ -0,0 +1 @@
+/usr/lib/python3.6/rlcompleter.py

projecten1/lib/python3.6/shutil.py

@@ -0,0 +1 @@
+/usr/lib/python3.6/shutil.py

projecten1/lib/python3.6/site-packages/PIL/BdfFontFile.py

@@ -0,0 +1,133 @@
+#
+# The Python Imaging Library
+# $Id$
+#
+# bitmap distribution font (bdf) file parser
+#
+# history:
+# 1996-05-16 fl   created (as bdf2pil)
+# 1997-08-25 fl   converted to FontFile driver
+# 2001-05-25 fl   removed bogus __init__ call
+# 2002-11-20 fl   robustification (from Kevin Cazabon, Dmitry Vasiliev)
+# 2003-04-22 fl   more robustification (from Graham Dumpleton)
+#
+# Copyright (c) 1997-2003 by Secret Labs AB.
+# Copyright (c) 1997-2003 by Fredrik Lundh.
+#
+# See the README file for information on usage and redistribution.
+#
+
+from __future__ import print_function
+
+from . import Image, FontFile
+
+
+# --------------------------------------------------------------------
+# parse X Bitmap Distribution Format (BDF)
+# --------------------------------------------------------------------
+
+bdf_slant = {
+    "R": "Roman",
+    "I": "Italic",
+    "O": "Oblique",
+    "RI": "Reverse Italic",
+    "RO": "Reverse Oblique",
+    "OT": "Other"
+}
+
+bdf_spacing = {
+    "P": "Proportional",
+    "M": "Monospaced",
+    "C": "Cell"
+}
+
+
+def bdf_char(f):
+    # skip to STARTCHAR
+    while True:
+        s = f.readline()
+        if not s:
+            return None
+        if s[:9] == b"STARTCHAR":
+            break
+    id = s[9:].strip().decode('ascii')
+
+    # load symbol properties
+    props = {}
+    while True:
+        s = f.readline()
+        if not s or s[:6] == b"BITMAP":
+            break
+        i = s.find(b" ")
+        props[s[:i].decode('ascii')] = s[i+1:-1].decode('ascii')
+
+    # load bitmap
+    bitmap = []
+    while True:
+        s = f.readline()
+        if not s or s[:7] == b"ENDCHAR":
+            break
+        bitmap.append(s[:-1])
+    bitmap = b"".join(bitmap)
+
+    [x, y, l, d] = [int(p) for p in props["BBX"].split()]
+    [dx, dy] = [int(p) for p in props["DWIDTH"].split()]
+
+    bbox = (dx, dy), (l, -d-y, x+l, -d), (0, 0, x, y)
+
+    try:
+        im = Image.frombytes("1", (x, y), bitmap, "hex", "1")
+    except ValueError:
+        # deal with zero-width characters
+        im = Image.new("1", (x, y))
+
+    return id, int(props["ENCODING"]), bbox, im
+
+
+##
+# Font file plugin for the X11 BDF format.
+
+class BdfFontFile(FontFile.FontFile):
+
+    def __init__(self, fp):
+
+        FontFile.FontFile.__init__(self)
+
+        s = fp.readline()
+        if s[:13] != b"STARTFONT 2.1":
+            raise SyntaxError("not a valid BDF file")
+
+        props = {}
+        comments = []
+
+        while True:
+            s = fp.readline()
+            if not s or s[:13] == b"ENDPROPERTIES":
+                break
+            i = s.find(b" ")
+            props[s[:i].decode('ascii')] = s[i+1:-1].decode('ascii')
+            if s[:i] in [b"COMMENT", b"COPYRIGHT"]:
+                if s.find(b"LogicalFontDescription") < 0:
+                    comments.append(s[i+1:-1].decode('ascii'))
+
+        # font = props["FONT"].split("-")
+
+        # font[4] = bdf_slant[font[4].upper()]
+        # font[11] = bdf_spacing[font[11].upper()]
+
+        # ascent = int(props["FONT_ASCENT"])
+        # descent = int(props["FONT_DESCENT"])
+
+        # fontname = ";".join(font[1:])
+
+        # print("#", fontname)
+        # for i in comments:
+        #       print("#", i)
+
+        while True:
+            c = bdf_char(fp)
+            if not c:
+                break
+            id, ch, (xy, dst, src), im = c
+            if 0 <= ch < len(self.glyph):
+                self.glyph[ch] = xy, dst, src, im

projecten1/lib/python3.6/site-packages/PIL/BlpImagePlugin.py

@@ -0,0 +1,435 @@
+"""
+Blizzard Mipmap Format (.blp)
+Jerome Leclanche <jerome@leclan.ch>
+
+The contents of this file are hereby released in the public domain (CC0)
+Full text of the CC0 license:
+  https://creativecommons.org/publicdomain/zero/1.0/
+
+BLP1 files, used mostly in Warcraft III, are not fully supported.
+All types of BLP2 files used in World of Warcraft are supported.
+
+The BLP file structure consists of a header, up to 16 mipmaps of the
+texture
+
+Texture sizes must be powers of two, though the two dimensions do
+not have to be equal; 512x256 is valid, but 512x200 is not.
+The first mipmap (mipmap #0) is the full size image; each subsequent
+mipmap halves both dimensions. The final mipmap should be 1x1.
+
+BLP files come in many different flavours:
+* JPEG-compressed (type == 0) - only supported for BLP1.
+* RAW images (type == 1, encoding == 1). Each mipmap is stored as an
+  array of 8-bit values, one per pixel, left to right, top to bottom.
+  Each value is an index to the palette.
+* DXT-compressed (type == 1, encoding == 2):
+- DXT1 compression is used if alpha_encoding == 0.
+  - An additional alpha bit is used if alpha_depth == 1.
+  - DXT3 compression is used if alpha_encoding == 1.
+  - DXT5 compression is used if alpha_encoding == 7.
+"""
+
+import struct
+from io import BytesIO
+
+from . import Image, ImageFile
+
+
+BLP_FORMAT_JPEG = 0
+
+BLP_ENCODING_UNCOMPRESSED = 1
+BLP_ENCODING_DXT = 2
+BLP_ENCODING_UNCOMPRESSED_RAW_BGRA = 3
+
+BLP_ALPHA_ENCODING_DXT1 = 0
+BLP_ALPHA_ENCODING_DXT3 = 1
+BLP_ALPHA_ENCODING_DXT5 = 7
+
+
+def unpack_565(i):
+    return (
+        ((i >> 11) & 0x1f) << 3,
+        ((i >> 5) & 0x3f) << 2,
+        (i & 0x1f) << 3
+    )
+
+
+def decode_dxt1(data, alpha=False):
+    """
+    input: one "row" of data (i.e. will produce 4*width pixels)
+    """
+
+    blocks = len(data) // 8  # number of blocks in row
+    ret = (bytearray(), bytearray(), bytearray(), bytearray())
+
+    for block in range(blocks):
+        # Decode next 8-byte block.
+        idx = block * 8
+        color0, color1, bits = struct.unpack_from("<HHI", data, idx)
+
+        r0, g0, b0 = unpack_565(color0)
+        r1, g1, b1 = unpack_565(color1)
+
+        # Decode this block into 4x4 pixels
+        # Accumulate the results onto our 4 row accumulators
+        for j in range(4):
+            for i in range(4):
+                # get next control op and generate a pixel
+
+                control = bits & 3
+                bits = bits >> 2
+
+                a = 0xFF
+                if control == 0:
+                    r, g, b = r0, g0, b0
+                elif control == 1:
+                    r, g, b = r1, g1, b1
+                elif control == 2:
+                    if color0 > color1:
+                        r = (2 * r0 + r1) // 3
+                        g = (2 * g0 + g1) // 3
+                        b = (2 * b0 + b1) // 3
+                    else:
+                        r = (r0 + r1) // 2
+                        g = (g0 + g1) // 2
+                        b = (b0 + b1) // 2
+                elif control == 3:
+                    if color0 > color1:
+                        r = (2 * r1 + r0) // 3
+                        g = (2 * g1 + g0) // 3
+                        b = (2 * b1 + b0) // 3
+                    else:
+                        r, g, b, a = 0, 0, 0, 0
+
+                if alpha:
+                    ret[j].extend([r, g, b, a])
+                else:
+                    ret[j].extend([r, g, b])
+
+    return ret
+
+
+def decode_dxt3(data):
+    """
+    input: one "row" of data (i.e. will produce 4*width pixels)
+    """
+
+    blocks = len(data) // 16  # number of blocks in row
+    ret = (bytearray(), bytearray(), bytearray(), bytearray())
+
+    for block in range(blocks):
+        idx = block * 16
+        block = data[idx:idx + 16]
+        # Decode next 16-byte block.
+        bits = struct.unpack_from("<8B", block)
+        color0, color1 = struct.unpack_from("<HH", block, 8)
+
+        code, = struct.unpack_from("<I", block, 12)
+
+        r0, g0, b0 = unpack_565(color0)
+        r1, g1, b1 = unpack_565(color1)
+
+        for j in range(4):
+            high = False  # Do we want the higher bits?
+            for i in range(4):
+                alphacode_index = (4 * j + i) // 2
+                a = bits[alphacode_index]
+                if high:
+                    high = False
+                    a >>= 4
+                else:
+                    high = True
+                    a &= 0xf
+                a *= 17  # We get a value between 0 and 15
+
+                color_code = (code >> 2 * (4 * j + i)) & 0x03
+
+                if color_code == 0:
+                    r, g, b = r0, g0, b0
+                elif color_code == 1:
+                    r, g, b = r1, g1, b1
+                elif color_code == 2:
+                    r = (2 * r0 + r1) // 3
+                    g = (2 * g0 + g1) // 3
+                    b = (2 * b0 + b1) // 3
+                elif color_code == 3:
+                    r = (2 * r1 + r0) // 3
+                    g = (2 * g1 + g0) // 3
+                    b = (2 * b1 + b0) // 3
+
+                ret[j].extend([r, g, b, a])
+
+    return ret
+
+
+def decode_dxt5(data):
+    """
+    input: one "row" of data (i.e. will produce 4 * width pixels)
+    """
+
+    blocks = len(data) // 16  # number of blocks in row
+    ret = (bytearray(), bytearray(), bytearray(), bytearray())
+
+    for block in range(blocks):
+        idx = block * 16
+        block = data[idx:idx + 16]
+        # Decode next 16-byte block.
+        a0, a1 = struct.unpack_from("<BB", block)
+
+        bits = struct.unpack_from("<6B", block, 2)
+        alphacode1 = (
+            bits[2] | (bits[3] << 8) | (bits[4] << 16) | (bits[5] << 24)
+        )
+        alphacode2 = bits[0] | (bits[1] << 8)
+
+        color0, color1 = struct.unpack_from("<HH", block, 8)
+
+        code, = struct.unpack_from("<I", block, 12)
+
+        r0, g0, b0 = unpack_565(color0)
+        r1, g1, b1 = unpack_565(color1)
+
+        for j in range(4):
+            for i in range(4):
+                # get next control op and generate a pixel
+                alphacode_index = 3 * (4 * j + i)
+
+                if alphacode_index <= 12:
+                    alphacode = (alphacode2 >> alphacode_index) & 0x07
+                elif alphacode_index == 15:
+                    alphacode = (alphacode2 >> 15) | ((alphacode1 << 1) & 0x06)
+                else:  # alphacode_index >= 18 and alphacode_index <= 45
+                    alphacode = (alphacode1 >> (alphacode_index - 16)) & 0x07
+
+                if alphacode == 0:
+                    a = a0
+                elif alphacode == 1:
+                    a = a1
+                elif a0 > a1:
+                    a = ((8 - alphacode) * a0 + (alphacode - 1) * a1) // 7
+                elif alphacode == 6:
+                    a = 0
+                elif alphacode == 7:
+                    a = 255
+                else:
+                    a = ((6 - alphacode) * a0 + (alphacode - 1) * a1) // 5
+
+                color_code = (code >> 2 * (4 * j + i)) & 0x03
+
+                if color_code == 0:
+                    r, g, b = r0, g0, b0
+                elif color_code == 1:
+                    r, g, b = r1, g1, b1
+                elif color_code == 2:
+                    r = (2 * r0 + r1) // 3
+                    g = (2 * g0 + g1) // 3
+                    b = (2 * b0 + b1) // 3
+                elif color_code == 3:
+                    r = (2 * r1 + r0) // 3
+                    g = (2 * g1 + g0) // 3
+                    b = (2 * b1 + b0) // 3
+
+                ret[j].extend([r, g, b, a])
+
+    return ret
+
+
+class BLPFormatError(NotImplementedError):
+    pass
+
+
+class BlpImageFile(ImageFile.ImageFile):
+    """
+    Blizzard Mipmap Format
+    """
+    format = "BLP"
+    format_description = "Blizzard Mipmap Format"
+
+    def _open(self):
+        self.magic = self.fp.read(4)
+        self._read_blp_header()
+
+        if self.magic == b"BLP1":
+            decoder = "BLP1"
+            self.mode = "RGB"
+        elif self.magic == b"BLP2":
+            decoder = "BLP2"
+            self.mode = "RGBA" if self._blp_alpha_depth else "RGB"
+        else:
+            raise BLPFormatError("Bad BLP magic %r" % (self.magic))
+
+        self.tile = [
+            (decoder, (0, 0) + self.size, 0, (self.mode, 0, 1))
+        ]
+
+    def _read_blp_header(self):
+        self._blp_compression, = struct.unpack("<i", self.fp.read(4))
+
+        self._blp_encoding, = struct.unpack("<b", self.fp.read(1))
+        self._blp_alpha_depth, = struct.unpack("<b", self.fp.read(1))
+        self._blp_alpha_encoding, = struct.unpack("<b", self.fp.read(1))
+        self._blp_mips, = struct.unpack("<b", self.fp.read(1))
+
+        self.size = struct.unpack("<II", self.fp.read(8))
+
+        if self.magic == b"BLP1":
+            # Only present for BLP1
+            self._blp_encoding, = struct.unpack("<i", self.fp.read(4))
+            self._blp_subtype, = struct.unpack("<i", self.fp.read(4))
+
+        self._blp_offsets = struct.unpack("<16I", self.fp.read(16 * 4))
+        self._blp_lengths = struct.unpack("<16I", self.fp.read(16 * 4))
+
+
+class _BLPBaseDecoder(ImageFile.PyDecoder):
+    _pulls_fd = True
+
+    def decode(self, buffer):
+        try:
+            self.fd.seek(0)
+            self.magic = self.fd.read(4)
+            self._read_blp_header()
+            self._load()
+        except struct.error:
+            raise IOError("Truncated Blp file")
+        return 0, 0
+
+    def _read_palette(self):
+        ret = []
+        for i in range(256):
+            try:
+                b, g, r, a = struct.unpack("<4B", self.fd.read(4))
+            except struct.error:
+                break
+            ret.append((b, g, r, a))
+        return ret
+
+    def _read_blp_header(self):
+        self._blp_compression, = struct.unpack("<i", self.fd.read(4))
+
+        self._blp_encoding, = struct.unpack("<b", self.fd.read(1))
+        self._blp_alpha_depth, = struct.unpack("<b", self.fd.read(1))
+        self._blp_alpha_encoding, = struct.unpack("<b", self.fd.read(1))
+        self._blp_mips, = struct.unpack("<b", self.fd.read(1))
+
+        self.size = struct.unpack("<II", self.fd.read(8))
+
+        if self.magic == b"BLP1":
+            # Only present for BLP1
+            self._blp_encoding, = struct.unpack("<i", self.fd.read(4))
+            self._blp_subtype, = struct.unpack("<i", self.fd.read(4))
+
+        self._blp_offsets = struct.unpack("<16I", self.fd.read(16 * 4))
+        self._blp_lengths = struct.unpack("<16I", self.fd.read(16 * 4))
+
+
+class BLP1Decoder(_BLPBaseDecoder):
+
+    def _load(self):
+        if self._blp_compression == BLP_FORMAT_JPEG:
+            self._decode_jpeg_stream()
+
+        elif self._blp_compression == 1:
+            if self._blp_encoding in (4, 5):
+                data = bytearray()
+                palette = self._read_palette()
+                _data = BytesIO(self.fd.read(self._blp_lengths[0]))
+                while True:
+                    try:
+                        offset, = struct.unpack("<B", _data.read(1))
+                    except struct.error:
+                        break
+                    b, g, r, a = palette[offset]
+                    data.extend([r, g, b])
+
+                self.set_as_raw(bytes(data))
+            else:
+                raise BLPFormatError(
+                    "Unsupported BLP encoding %r" % (self._blp_encoding)
+                )
+        else:
+            raise BLPFormatError(
+                "Unsupported BLP compression %r" % (self._blp_encoding)
+            )
+
+    def _decode_jpeg_stream(self):
+        from PIL.JpegImagePlugin import JpegImageFile
+
+        jpeg_header_size, = struct.unpack("<I", self.fd.read(4))
+        jpeg_header = self.fd.read(jpeg_header_size)
+        self.fd.read(self._blp_offsets[0] - self.fd.tell())  # What IS this?
+        data = self.fd.read(self._blp_lengths[0])
+        data = jpeg_header + data
+        data = BytesIO(data)
+        image = JpegImageFile(data)
+        self.tile = image.tile  # :/
+        self.fd = image.fp
+        self.mode = image.mode
+
+
+class BLP2Decoder(_BLPBaseDecoder):
+
+    def _load(self):
+        palette = self._read_palette()
+
+        data = bytearray()
+        self.fd.seek(self._blp_offsets[0])
+
+        if self._blp_compression == 1:
+            # Uncompressed or DirectX compression
+
+            if self._blp_encoding == BLP_ENCODING_UNCOMPRESSED:
+                _data = BytesIO(self.fd.read(self._blp_lengths[0]))
+                while True:
+                    try:
+                        offset, = struct.unpack("<B", _data.read(1))
+                    except struct.error:
+                        break
+                    b, g, r, a = palette[offset]
+                    data.extend((r, g, b))
+
+            elif self._blp_encoding == BLP_ENCODING_DXT:
+                if self._blp_alpha_encoding == BLP_ALPHA_ENCODING_DXT1:
+                    linesize = (self.size[0] + 3) // 4 * 8
+                    for yb in range((self.size[1] + 3) // 4):
+                        for d in decode_dxt1(
+                            self.fd.read(linesize),
+                            alpha=bool(self._blp_alpha_depth)
+                        ):
+                            data += d
+
+                elif self._blp_alpha_encoding == BLP_ALPHA_ENCODING_DXT3:
+                    linesize = (self.size[0] + 3) // 4 * 16
+                    for yb in range((self.size[1] + 3) // 4):
+                        for d in decode_dxt3(self.fd.read(linesize)):
+                            data += d
+
+                elif self._blp_alpha_encoding == BLP_ALPHA_ENCODING_DXT5:
+                    linesize = (self.size[0] + 3) // 4 * 16
+                    for yb in range((self.size[1] + 3) // 4):
+                        for d in decode_dxt5(self.fd.read(linesize)):
+                            data += d
+                else:
+                    raise BLPFormatError("Unsupported alpha encoding %r" % (
+                        self._blp_alpha_encoding
+                    ))
+            else:
+                raise BLPFormatError(
+                    "Unknown BLP encoding %r" % (self._blp_encoding)
+                )
+
+        else:
+            raise BLPFormatError(
+                "Unknown BLP compression %r" % (self._blp_compression)
+            )
+
+        self.set_as_raw(bytes(data))
+
+
+Image.register_open(
+    BlpImageFile.format, BlpImageFile, lambda p: p[:4] in (b"BLP1", b"BLP2")
+)
+Image.register_extension(BlpImageFile.format, ".blp")
+
+Image.register_decoder("BLP1", BLP1Decoder)
+Image.register_decoder("BLP2", BLP2Decoder)

projecten1/lib/python3.6/site-packages/PIL/BmpImagePlugin.py

@@ -0,0 +1,289 @@
+#
+# The Python Imaging Library.
+# $Id$
+#
+# BMP file handler
+#
+# Windows (and OS/2) native bitmap storage format.
+#
+# history:
+# 1995-09-01 fl   Created
+# 1996-04-30 fl   Added save
+# 1997-08-27 fl   Fixed save of 1-bit images
+# 1998-03-06 fl   Load P images as L where possible
+# 1998-07-03 fl   Load P images as 1 where possible
+# 1998-12-29 fl   Handle small palettes
+# 2002-12-30 fl   Fixed load of 1-bit palette images
+# 2003-04-21 fl   Fixed load of 1-bit monochrome images
+# 2003-04-23 fl   Added limited support for BI_BITFIELDS compression
+#
+# Copyright (c) 1997-2003 by Secret Labs AB
+# Copyright (c) 1995-2003 by Fredrik Lundh
+#
+# See the README file for information on usage and redistribution.
+#
+
+
+from . import Image, ImageFile, ImagePalette
+from ._binary import i8, i16le as i16, i32le as i32, \
+                     o8, o16le as o16, o32le as o32
+import math
+
+__version__ = "0.7"
+
+#
+# --------------------------------------------------------------------
+# Read BMP file
+
+BIT2MODE = {
+    # bits => mode, rawmode
+    1: ("P", "P;1"),
+    4: ("P", "P;4"),
+    8: ("P", "P"),
+    16: ("RGB", "BGR;15"),
+    24: ("RGB", "BGR"),
+    32: ("RGB", "BGRX"),
+}
+
+
+def _accept(prefix):
+    return prefix[:2] == b"BM"
+
+
+# ==============================================================================
+# Image plugin for the Windows BMP format.
+# ==============================================================================
+class BmpImageFile(ImageFile.ImageFile):
+    """ Image plugin for the Windows Bitmap format (BMP) """
+
+    # -------------------------------------------------------------- Description
+    format_description = "Windows Bitmap"
+    format = "BMP"
+    # --------------------------------------------------- BMP Compression values
+    COMPRESSIONS = {'RAW': 0, 'RLE8': 1, 'RLE4': 2, 'BITFIELDS': 3, 'JPEG': 4, 'PNG': 5}
+    RAW, RLE8, RLE4, BITFIELDS, JPEG, PNG = 0, 1, 2, 3, 4, 5
+
+    def _bitmap(self, header=0, offset=0):
+        """ Read relevant info about the BMP """
+        read, seek = self.fp.read, self.fp.seek
+        if header:
+            seek(header)
+        file_info = {}
+        file_info['header_size'] = i32(read(4))  # read bmp header size @offset 14 (this is part of the header size)
+        file_info['direction'] = -1
+        # --------------------- If requested, read header at a specific position
+        header_data = ImageFile._safe_read(self.fp, file_info['header_size'] - 4)  # read the rest of the bmp header, without its size
+        # --------------------------------------------------- IBM OS/2 Bitmap v1
+        # ------ This format has different offsets because of width/height types
+        if file_info['header_size'] == 12:
+            file_info['width'] = i16(header_data[0:2])
+            file_info['height'] = i16(header_data[2:4])
+            file_info['planes'] = i16(header_data[4:6])
+            file_info['bits'] = i16(header_data[6:8])
+            file_info['compression'] = self.RAW
+            file_info['palette_padding'] = 3
+        # ---------------------------------------------- Windows Bitmap v2 to v5
+        elif file_info['header_size'] in (40, 64, 108, 124):  # v3, OS/2 v2, v4, v5
+            if file_info['header_size'] >= 40:  # v3 and OS/2
+                file_info['y_flip'] = i8(header_data[7]) == 0xff
+                file_info['direction'] = 1 if file_info['y_flip'] else -1
+                file_info['width'] = i32(header_data[0:4])
+                file_info['height'] = i32(header_data[4:8]) if not file_info['y_flip'] else 2**32 - i32(header_data[4:8])
+                file_info['planes'] = i16(header_data[8:10])
+                file_info['bits'] = i16(header_data[10:12])
+                file_info['compression'] = i32(header_data[12:16])
+                file_info['data_size'] = i32(header_data[16:20])  # byte size of pixel data
+                file_info['pixels_per_meter'] = (i32(header_data[20:24]), i32(header_data[24:28]))
+                file_info['colors'] = i32(header_data[28:32])
+                file_info['palette_padding'] = 4
+                self.info["dpi"] = tuple(
+                    map(lambda x: int(math.ceil(x / 39.3701)),
+                        file_info['pixels_per_meter']))
+                if file_info['compression'] == self.BITFIELDS:
+                    if len(header_data) >= 52:
+                        for idx, mask in enumerate(['r_mask', 'g_mask', 'b_mask', 'a_mask']):
+                            file_info[mask] = i32(header_data[36+idx*4:40+idx*4])
+                    else:
+                        # 40 byte headers only have the three components in the bitfields masks,
+                        # ref: https://msdn.microsoft.com/en-us/library/windows/desktop/dd183376(v=vs.85).aspx
+                        # See also https://github.com/python-pillow/Pillow/issues/1293
+                        # There is a 4th component in the RGBQuad, in the alpha location, but it
+                        # is listed as a reserved component, and it is not generally an alpha channel
+                        file_info['a_mask'] = 0x0
+                        for mask in ['r_mask', 'g_mask', 'b_mask']:
+                            file_info[mask] = i32(read(4))
+                    file_info['rgb_mask'] = (file_info['r_mask'], file_info['g_mask'], file_info['b_mask'])
+                    file_info['rgba_mask'] = (file_info['r_mask'], file_info['g_mask'], file_info['b_mask'], file_info['a_mask'])
+        else:
+            raise IOError("Unsupported BMP header type (%d)" % file_info['header_size'])
+        # ------------------ Special case : header is reported 40, which
+        # ---------------------- is shorter than real size for bpp >= 16
+        self.size = file_info['width'], file_info['height']
+        # -------- If color count was not found in the header, compute from bits
+        file_info['colors'] = file_info['colors'] if file_info.get('colors', 0) else (1 << file_info['bits'])
+        # -------------------------------- Check abnormal values for DOS attacks
+        if file_info['width'] * file_info['height'] > 2**31:
+            raise IOError("Unsupported BMP Size: (%dx%d)" % self.size)
+        # ----------------------- Check bit depth for unusual unsupported values
+        self.mode, raw_mode = BIT2MODE.get(file_info['bits'], (None, None))
+        if self.mode is None:
+            raise IOError("Unsupported BMP pixel depth (%d)" % file_info['bits'])
+        # ----------------- Process BMP with Bitfields compression (not palette)
+        if file_info['compression'] == self.BITFIELDS:
+            SUPPORTED = {
+                32: [(0xff0000, 0xff00, 0xff, 0x0), (0xff0000, 0xff00, 0xff, 0xff000000), (0x0, 0x0, 0x0, 0x0), (0xff000000, 0xff0000, 0xff00, 0x0)],
+                24: [(0xff0000, 0xff00, 0xff)],
+                16: [(0xf800, 0x7e0, 0x1f), (0x7c00, 0x3e0, 0x1f)]
+            }
+            MASK_MODES = {
+                (32, (0xff0000, 0xff00, 0xff, 0x0)): "BGRX",
+                (32, (0xff000000, 0xff0000, 0xff00, 0x0)): "XBGR",
+                (32, (0xff0000, 0xff00, 0xff, 0xff000000)): "BGRA",
+                (32, (0x0, 0x0, 0x0, 0x0)): "BGRA",
+                (24, (0xff0000, 0xff00, 0xff)): "BGR",
+                (16, (0xf800, 0x7e0, 0x1f)): "BGR;16",
+                (16, (0x7c00, 0x3e0, 0x1f)): "BGR;15"
+            }
+            if file_info['bits'] in SUPPORTED:
+                if file_info['bits'] == 32 and file_info['rgba_mask'] in SUPPORTED[file_info['bits']]:
+                    raw_mode = MASK_MODES[(file_info['bits'], file_info['rgba_mask'])]
+                    self.mode = "RGBA" if raw_mode in ("BGRA",) else self.mode
+                elif file_info['bits'] in (24, 16) and file_info['rgb_mask'] in SUPPORTED[file_info['bits']]:
+                    raw_mode = MASK_MODES[(file_info['bits'], file_info['rgb_mask'])]
+                else:
+                    raise IOError("Unsupported BMP bitfields layout")
+            else:
+                raise IOError("Unsupported BMP bitfields layout")
+        elif file_info['compression'] == self.RAW:
+            if file_info['bits'] == 32 and header == 22:  # 32-bit .cur offset
+                raw_mode, self.mode = "BGRA", "RGBA"
+        else:
+            raise IOError("Unsupported BMP compression (%d)" % file_info['compression'])
+        # ---------------- Once the header is processed, process the palette/LUT
+        if self.mode == "P":  # Paletted for 1, 4 and 8 bit images
+            # ----------------------------------------------------- 1-bit images
+            if not (0 < file_info['colors'] <= 65536):
+                raise IOError("Unsupported BMP Palette size (%d)" % file_info['colors'])
+            else:
+                padding = file_info['palette_padding']
+                palette = read(padding * file_info['colors'])
+                greyscale = True
+                indices = (0, 255) if file_info['colors'] == 2 else list(range(file_info['colors']))
+                # ------------------ Check if greyscale and ignore palette if so
+                for ind, val in enumerate(indices):
+                    rgb = palette[ind*padding:ind*padding + 3]
+                    if rgb != o8(val) * 3:
+                        greyscale = False
+                # -------- If all colors are grey, white or black, ditch palette
+                if greyscale:
+                    self.mode = "1" if file_info['colors'] == 2 else "L"
+                    raw_mode = self.mode
+                else:
+                    self.mode = "P"
+                    self.palette = ImagePalette.raw("BGRX" if padding == 4 else "BGR", palette)
+
+        # ----------------------------- Finally set the tile data for the plugin
+        self.info['compression'] = file_info['compression']
+        self.tile = [('raw', (0, 0, file_info['width'], file_info['height']), offset or self.fp.tell(),
+                      (raw_mode, ((file_info['width'] * file_info['bits'] + 31) >> 3) & (~3), file_info['direction'])
+                      )]
+
+    def _open(self):
+        """ Open file, check magic number and read header """
+        # read 14 bytes: magic number, filesize, reserved, header final offset
+        head_data = self.fp.read(14)
+        # choke if the file does not have the required magic bytes
+        if head_data[0:2] != b"BM":
+            raise SyntaxError("Not a BMP file")
+        # read the start position of the BMP image data (u32)
+        offset = i32(head_data[10:14])
+        # load bitmap information (offset=raster info)
+        self._bitmap(offset=offset)
+
+
+# ==============================================================================
+# Image plugin for the DIB format (BMP alias)
+# ==============================================================================
+class DibImageFile(BmpImageFile):
+
+    format = "DIB"
+    format_description = "Windows Bitmap"
+
+    def _open(self):
+        self._bitmap()
+
+#
+# --------------------------------------------------------------------
+# Write BMP file
+
+
+SAVE = {
+    "1": ("1", 1, 2),
+    "L": ("L", 8, 256),
+    "P": ("P", 8, 256),
+    "RGB": ("BGR", 24, 0),
+    "RGBA": ("BGRA", 32, 0),
+}
+
+
+def _save(im, fp, filename):
+    try:
+        rawmode, bits, colors = SAVE[im.mode]
+    except KeyError:
+        raise IOError("cannot write mode %s as BMP" % im.mode)
+
+    info = im.encoderinfo
+
+    dpi = info.get("dpi", (96, 96))
+
+    # 1 meter == 39.3701 inches
+    ppm = tuple(map(lambda x: int(x * 39.3701), dpi))
+
+    stride = ((im.size[0]*bits+7)//8+3) & (~3)
+    header = 40  # or 64 for OS/2 version 2
+    offset = 14 + header + colors * 4
+    image = stride * im.size[1]
+
+    # bitmap header
+    fp.write(b"BM" +                      # file type (magic)
+             o32(offset+image) +          # file size
+             o32(0) +                     # reserved
+             o32(offset))                 # image data offset
+
+    # bitmap info header
+    fp.write(o32(header) +                # info header size
+             o32(im.size[0]) +            # width
+             o32(im.size[1]) +            # height
+             o16(1) +                     # planes
+             o16(bits) +                  # depth
+             o32(0) +                     # compression (0=uncompressed)
+             o32(image) +                 # size of bitmap
+             o32(ppm[0]) + o32(ppm[1]) +  # resolution
+             o32(colors) +                # colors used
+             o32(colors))                 # colors important
+
+    fp.write(b"\0" * (header - 40))       # padding (for OS/2 format)
+
+    if im.mode == "1":
+        for i in (0, 255):
+            fp.write(o8(i) * 4)
+    elif im.mode == "L":
+        for i in range(256):
+            fp.write(o8(i) * 4)
+    elif im.mode == "P":
+        fp.write(im.im.getpalette("RGB", "BGRX"))
+
+    ImageFile._save(im, fp, [("raw", (0, 0)+im.size, 0,
+                    (rawmode, stride, -1))])
+
+#
+# --------------------------------------------------------------------
+# Registry
+
+
+Image.register_open(BmpImageFile.format, BmpImageFile, _accept)
+Image.register_save(BmpImageFile.format, _save)
+
+Image.register_extension(BmpImageFile.format, ".bmp")
+
+Image.register_mime(BmpImageFile.format, "image/bmp")

projecten1/lib/python3.6/site-packages/PIL/BufrStubImagePlugin.py

@@ -0,0 +1,72 @@
+#
+# The Python Imaging Library
+# $Id$
+#
+# BUFR stub adapter
+#
+# Copyright (c) 1996-2003 by Fredrik Lundh
+#
+# See the README file for information on usage and redistribution.
+#
+
+from . import Image, ImageFile
+
+_handler = None
+
+
+def register_handler(handler):
+    """
+    Install application-specific BUFR image handler.
+
+    :param handler: Handler object.
+    """
+    global _handler
+    _handler = handler
+
+
+# --------------------------------------------------------------------
+# Image adapter
+
+def _accept(prefix):
+    return prefix[:4] == b"BUFR" or prefix[:4] == b"ZCZC"
+
+
+class BufrStubImageFile(ImageFile.StubImageFile):
+
+    format = "BUFR"
+    format_description = "BUFR"
+
+    def _open(self):
+
+        offset = self.fp.tell()
+
+        if not _accept(self.fp.read(4)):
+            raise SyntaxError("Not a BUFR file")
+
+        self.fp.seek(offset)
+
+        # make something up
+        self.mode = "F"
+        self.size = 1, 1
+
+        loader = self._load()
+        if loader:
+            loader.open(self)
+
+    def _load(self):
+        return _handler
+
+
+def _save(im, fp, filename):
+    if _handler is None or not hasattr("_handler", "save"):
+        raise IOError("BUFR save handler not installed")
+    _handler.save(im, fp, filename)
+
+
+# --------------------------------------------------------------------
+# Registry
+
+Image.register_open(BufrStubImageFile.format, BufrStubImageFile, _accept)
+Image.register_save(BufrStubImageFile.format, _save)
+
+Image.register_extension(BufrStubImageFile.format, ".bufr")