Add files using upload-large-folder tool

.gitattributes

@@ -311,3 +311,10 @@ my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/Pillow.libs
 my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/Pillow.libs/liblcms2-1e643a89.so.2.0.13 filter=lfs diff=lfs merge=lfs -text
 my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/Pillow.libs/libtiff-d0580107.so.5.7.0 filter=lfs diff=lfs merge=lfs -text
 my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/psutil/_psutil_linux.abi3.so filter=lfs diff=lfs merge=lfs -text
+my_container_sandbox/workspace/anaconda3/lib/libnvvm.so filter=lfs diff=lfs merge=lfs -text
+my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/multidict/_multidict.cpython-38-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/aiohttp/_websocket.cpython-38-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/Pillow.libs/libwebp-8efe125f.so.7.1.3 filter=lfs diff=lfs merge=lfs -text
+my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/lxml/builder.cpython-38-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/Pillow.libs/libjpeg-1b553ed5.so.62.3.0 filter=lfs diff=lfs merge=lfs -text
+my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/lxml/_elementpath.cpython-38-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text

my_container_sandbox/workspace/anaconda3/lib/libnvvm.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f0c95d249f3d60d67dbd191174fe1d8b9f393b1887ae1a54b4988823c7e42a31
+size 26650200

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/PIL/BdfFontFile.py

@@ -0,0 +1,110 @@
+#
+# 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.
+#
+
+"""
+Parse X Bitmap Distribution Format (BDF)
+"""
+
+
+from . import FontFile, Image
+
+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
+
+
+class BdfFontFile(FontFile.FontFile):
+    """Font file plugin for the X11 BDF format."""
+
+    def __init__(self, fp):
+        super().__init__()
+
+        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"))
+
+        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

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/PIL/BufrStubImagePlugin.py

@@ -0,0 +1,73 @@
+#
+# 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 OSError("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")

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/PIL/ContainerIO.py

@@ -0,0 +1,120 @@
+#
+# The Python Imaging Library.
+# $Id$
+#
+# a class to read from a container file
+#
+# History:
+# 1995-06-18 fl     Created
+# 1995-09-07 fl     Added readline(), readlines()
+#
+# Copyright (c) 1997-2001 by Secret Labs AB
+# Copyright (c) 1995 by Fredrik Lundh
+#
+# See the README file for information on usage and redistribution.
+#
+
+
+import io
+
+
+class ContainerIO:
+    """
+    A file object that provides read access to a part of an existing
+    file (for example a TAR file).
+    """
+
+    def __init__(self, file, offset, length):
+        """
+        Create file object.
+
+        :param file: Existing file.
+        :param offset: Start of region, in bytes.
+        :param length: Size of region, in bytes.
+        """
+        self.fh = file
+        self.pos = 0
+        self.offset = offset
+        self.length = length
+        self.fh.seek(offset)
+
+    ##
+    # Always false.
+
+    def isatty(self):
+        return False
+
+    def seek(self, offset, mode=io.SEEK_SET):
+        """
+        Move file pointer.
+
+        :param offset: Offset in bytes.
+        :param mode: Starting position. Use 0 for beginning of region, 1
+           for current offset, and 2 for end of region.  You cannot move
+           the pointer outside the defined region.
+        """
+        if mode == 1:
+            self.pos = self.pos + offset
+        elif mode == 2:
+            self.pos = self.length + offset
+        else:
+            self.pos = offset
+        # clamp
+        self.pos = max(0, min(self.pos, self.length))
+        self.fh.seek(self.offset + self.pos)
+
+    def tell(self):
+        """
+        Get current file pointer.
+
+        :returns: Offset from start of region, in bytes.
+        """
+        return self.pos
+
+    def read(self, n=0):
+        """
+        Read data.
+
+        :param n: Number of bytes to read. If omitted or zero,
+            read until end of region.
+        :returns: An 8-bit string.
+        """
+        if n:
+            n = min(n, self.length - self.pos)
+        else:
+            n = self.length - self.pos
+        if not n:  # EOF
+            return b"" if "b" in self.fh.mode else ""
+        self.pos = self.pos + n
+        return self.fh.read(n)
+
+    def readline(self):
+        """
+        Read a line of text.
+
+        :returns: An 8-bit string.
+        """
+        s = b"" if "b" in self.fh.mode else ""
+        newline_character = b"\n" if "b" in self.fh.mode else "\n"
+        while True:
+            c = self.read(1)
+            if not c:
+                break
+            s = s + c
+            if c == newline_character:
+                break
+        return s
+
+    def readlines(self):
+        """
+        Read multiple lines of text.
+
+        :returns: A list of 8-bit strings.
+        """
+        lines = []
+        while True:
+            s = self.readline()
+            if not s:
+                break
+            lines.append(s)
+        return lines

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/PIL/CurImagePlugin.py

@@ -0,0 +1,75 @@
+#
+# The Python Imaging Library.
+# $Id$
+#
+# Windows Cursor support for PIL
+#
+# notes:
+#       uses BmpImagePlugin.py to read the bitmap data.
+#
+# history:
+#       96-05-27 fl     Created
+#
+# Copyright (c) Secret Labs AB 1997.
+# Copyright (c) Fredrik Lundh 1996.
+#
+# See the README file for information on usage and redistribution.
+#
+from . import BmpImagePlugin, Image
+from ._binary import i16le as i16
+from ._binary import i32le as i32
+
+#
+# --------------------------------------------------------------------
+
+
+def _accept(prefix):
+    return prefix[:4] == b"\0\0\2\0"
+
+
+##
+# Image plugin for Windows Cursor files.
+
+
+class CurImageFile(BmpImagePlugin.BmpImageFile):
+
+    format = "CUR"
+    format_description = "Windows Cursor"
+
+    def _open(self):
+
+        offset = self.fp.tell()
+
+        # check magic
+        s = self.fp.read(6)
+        if not _accept(s):
+            raise SyntaxError("not a CUR file")
+
+        # pick the largest cursor in the file
+        m = b""
+        for i in range(i16(s, 4)):
+            s = self.fp.read(16)
+            if not m:
+                m = s
+            elif s[0] > m[0] and s[1] > m[1]:
+                m = s
+        if not m:
+            raise TypeError("No cursors were found")
+
+        # load as bitmap
+        self._bitmap(i32(m, 12) + offset)
+
+        # patch up the bitmap height
+        self._size = self.size[0], self.size[1] // 2
+        d, e, o, a = self.tile[0]
+        self.tile[0] = d, (0, 0) + self.size, o, a
+
+        return
+
+
+#
+# --------------------------------------------------------------------
+
+Image.register_open(CurImageFile.format, CurImageFile, _accept)
+
+Image.register_extension(CurImageFile.format, ".cur")

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/PIL/DdsImagePlugin.py

@@ -0,0 +1,249 @@
+"""
+A Pillow loader for .dds files (S3TC-compressed aka DXTC)
+Jerome Leclanche <jerome@leclan.ch>
+
+Documentation:
+  https://web.archive.org/web/20170802060935/http://oss.sgi.com/projects/ogl-sample/registry/EXT/texture_compression_s3tc.txt
+
+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/
+"""
+
+import struct
+from io import BytesIO
+
+from . import Image, ImageFile
+from ._binary import o32le as o32
+
+# Magic ("DDS ")
+DDS_MAGIC = 0x20534444
+
+# DDS flags
+DDSD_CAPS = 0x1
+DDSD_HEIGHT = 0x2
+DDSD_WIDTH = 0x4
+DDSD_PITCH = 0x8
+DDSD_PIXELFORMAT = 0x1000
+DDSD_MIPMAPCOUNT = 0x20000
+DDSD_LINEARSIZE = 0x80000
+DDSD_DEPTH = 0x800000
+
+# DDS caps
+DDSCAPS_COMPLEX = 0x8
+DDSCAPS_TEXTURE = 0x1000
+DDSCAPS_MIPMAP = 0x400000
+
+DDSCAPS2_CUBEMAP = 0x200
+DDSCAPS2_CUBEMAP_POSITIVEX = 0x400
+DDSCAPS2_CUBEMAP_NEGATIVEX = 0x800
+DDSCAPS2_CUBEMAP_POSITIVEY = 0x1000
+DDSCAPS2_CUBEMAP_NEGATIVEY = 0x2000
+DDSCAPS2_CUBEMAP_POSITIVEZ = 0x4000
+DDSCAPS2_CUBEMAP_NEGATIVEZ = 0x8000
+DDSCAPS2_VOLUME = 0x200000
+
+# Pixel Format
+DDPF_ALPHAPIXELS = 0x1
+DDPF_ALPHA = 0x2
+DDPF_FOURCC = 0x4
+DDPF_PALETTEINDEXED8 = 0x20
+DDPF_RGB = 0x40
+DDPF_LUMINANCE = 0x20000
+
+
+# dds.h
+
+DDS_FOURCC = DDPF_FOURCC
+DDS_RGB = DDPF_RGB
+DDS_RGBA = DDPF_RGB | DDPF_ALPHAPIXELS
+DDS_LUMINANCE = DDPF_LUMINANCE
+DDS_LUMINANCEA = DDPF_LUMINANCE | DDPF_ALPHAPIXELS
+DDS_ALPHA = DDPF_ALPHA
+DDS_PAL8 = DDPF_PALETTEINDEXED8
+
+DDS_HEADER_FLAGS_TEXTURE = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT
+DDS_HEADER_FLAGS_MIPMAP = DDSD_MIPMAPCOUNT
+DDS_HEADER_FLAGS_VOLUME = DDSD_DEPTH
+DDS_HEADER_FLAGS_PITCH = DDSD_PITCH
+DDS_HEADER_FLAGS_LINEARSIZE = DDSD_LINEARSIZE
+
+DDS_HEIGHT = DDSD_HEIGHT
+DDS_WIDTH = DDSD_WIDTH
+
+DDS_SURFACE_FLAGS_TEXTURE = DDSCAPS_TEXTURE
+DDS_SURFACE_FLAGS_MIPMAP = DDSCAPS_COMPLEX | DDSCAPS_MIPMAP
+DDS_SURFACE_FLAGS_CUBEMAP = DDSCAPS_COMPLEX
+
+DDS_CUBEMAP_POSITIVEX = DDSCAPS2_CUBEMAP | DDSCAPS2_CUBEMAP_POSITIVEX
+DDS_CUBEMAP_NEGATIVEX = DDSCAPS2_CUBEMAP | DDSCAPS2_CUBEMAP_NEGATIVEX
+DDS_CUBEMAP_POSITIVEY = DDSCAPS2_CUBEMAP | DDSCAPS2_CUBEMAP_POSITIVEY
+DDS_CUBEMAP_NEGATIVEY = DDSCAPS2_CUBEMAP | DDSCAPS2_CUBEMAP_NEGATIVEY
+DDS_CUBEMAP_POSITIVEZ = DDSCAPS2_CUBEMAP | DDSCAPS2_CUBEMAP_POSITIVEZ
+DDS_CUBEMAP_NEGATIVEZ = DDSCAPS2_CUBEMAP | DDSCAPS2_CUBEMAP_NEGATIVEZ
+
+
+# DXT1
+DXT1_FOURCC = 0x31545844
+
+# DXT3
+DXT3_FOURCC = 0x33545844
+
+# DXT5
+DXT5_FOURCC = 0x35545844
+
+
+# dxgiformat.h
+
+DXGI_FORMAT_R8G8B8A8_TYPELESS = 27
+DXGI_FORMAT_R8G8B8A8_UNORM = 28
+DXGI_FORMAT_R8G8B8A8_UNORM_SRGB = 29
+DXGI_FORMAT_BC5_TYPELESS = 82
+DXGI_FORMAT_BC5_UNORM = 83
+DXGI_FORMAT_BC5_SNORM = 84
+DXGI_FORMAT_BC7_TYPELESS = 97
+DXGI_FORMAT_BC7_UNORM = 98
+DXGI_FORMAT_BC7_UNORM_SRGB = 99
+
+
+class DdsImageFile(ImageFile.ImageFile):
+    format = "DDS"
+    format_description = "DirectDraw Surface"
+
+    def _open(self):
+        if not _accept(self.fp.read(4)):
+            raise SyntaxError("not a DDS file")
+        (header_size,) = struct.unpack("<I", self.fp.read(4))
+        if header_size != 124:
+            raise OSError(f"Unsupported header size {repr(header_size)}")
+        header_bytes = self.fp.read(header_size - 4)
+        if len(header_bytes) != 120:
+            raise OSError(f"Incomplete header: {len(header_bytes)} bytes")
+        header = BytesIO(header_bytes)
+
+        flags, height, width = struct.unpack("<3I", header.read(12))
+        self._size = (width, height)
+        self.mode = "RGBA"
+
+        pitch, depth, mipmaps = struct.unpack("<3I", header.read(12))
+        struct.unpack("<11I", header.read(44))  # reserved
+
+        # pixel format
+        pfsize, pfflags = struct.unpack("<2I", header.read(8))
+        fourcc = header.read(4)
+        (bitcount,) = struct.unpack("<I", header.read(4))
+        masks = struct.unpack("<4I", header.read(16))
+        if pfflags & DDPF_RGB:
+            # Texture contains uncompressed RGB data
+            masks = {mask: ["R", "G", "B", "A"][i] for i, mask in enumerate(masks)}
+            rawmode = ""
+            if bitcount == 32:
+                rawmode += masks[0xFF000000]
+            else:
+                self.mode = "RGB"
+            rawmode += masks[0xFF0000] + masks[0xFF00] + masks[0xFF]
+
+            self.tile = [("raw", (0, 0) + self.size, 0, (rawmode[::-1], 0, 1))]
+        else:
+            data_start = header_size + 4
+            n = 0
+            if fourcc == b"DXT1":
+                self.pixel_format = "DXT1"
+                n = 1
+            elif fourcc == b"DXT3":
+                self.pixel_format = "DXT3"
+                n = 2
+            elif fourcc == b"DXT5":
+                self.pixel_format = "DXT5"
+                n = 3
+            elif fourcc == b"BC5S":
+                self.pixel_format = "BC5S"
+                n = 5
+                self.mode = "RGB"
+            elif fourcc == b"DX10":
+                data_start += 20
+                # ignoring flags which pertain to volume textures and cubemaps
+                (dxgi_format,) = struct.unpack("<I", self.fp.read(4))
+                self.fp.read(16)
+                if dxgi_format in (DXGI_FORMAT_BC5_TYPELESS, DXGI_FORMAT_BC5_UNORM):
+                    self.pixel_format = "BC5"
+                    n = 5
+                    self.mode = "RGB"
+                elif dxgi_format == DXGI_FORMAT_BC5_SNORM:
+                    self.pixel_format = "BC5S"
+                    n = 5
+                    self.mode = "RGB"
+                elif dxgi_format in (DXGI_FORMAT_BC7_TYPELESS, DXGI_FORMAT_BC7_UNORM):
+                    self.pixel_format = "BC7"
+                    n = 7
+                elif dxgi_format == DXGI_FORMAT_BC7_UNORM_SRGB:
+                    self.pixel_format = "BC7"
+                    self.info["gamma"] = 1 / 2.2
+                    n = 7
+                elif dxgi_format in (
+                    DXGI_FORMAT_R8G8B8A8_TYPELESS,
+                    DXGI_FORMAT_R8G8B8A8_UNORM,
+                    DXGI_FORMAT_R8G8B8A8_UNORM_SRGB,
+                ):
+                    self.tile = [("raw", (0, 0) + self.size, 0, ("RGBA", 0, 1))]
+                    if dxgi_format == DXGI_FORMAT_R8G8B8A8_UNORM_SRGB:
+                        self.info["gamma"] = 1 / 2.2
+                    return
+                else:
+                    raise NotImplementedError(
+                        f"Unimplemented DXGI format {dxgi_format}"
+                    )
+            else:
+                raise NotImplementedError(f"Unimplemented pixel format {repr(fourcc)}")
+
+            self.tile = [
+                ("bcn", (0, 0) + self.size, data_start, (n, self.pixel_format))
+            ]
+
+    def load_seek(self, pos):
+        pass
+
+
+def _save(im, fp, filename):
+    if im.mode not in ("RGB", "RGBA"):
+        raise OSError(f"cannot write mode {im.mode} as DDS")
+
+    fp.write(
+        o32(DDS_MAGIC)
+        + o32(124)  # header size
+        + o32(
+            DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_PITCH | DDSD_PIXELFORMAT
+        )  # flags
+        + o32(im.height)
+        + o32(im.width)
+        + o32((im.width * (32 if im.mode == "RGBA" else 24) + 7) // 8)  # pitch
+        + o32(0)  # depth
+        + o32(0)  # mipmaps
+        + o32(0) * 11  # reserved
+        + o32(32)  # pfsize
+        + o32(DDS_RGBA if im.mode == "RGBA" else DDPF_RGB)  # pfflags
+        + o32(0)  # fourcc
+        + o32(32 if im.mode == "RGBA" else 24)  # bitcount
+        + o32(0xFF0000)  # rbitmask
+        + o32(0xFF00)  # gbitmask
+        + o32(0xFF)  # bbitmask
+        + o32(0xFF000000 if im.mode == "RGBA" else 0)  # abitmask
+        + o32(DDSCAPS_TEXTURE)  # dwCaps
+        + o32(0)  # dwCaps2
+        + o32(0)  # dwCaps3
+        + o32(0)  # dwCaps4
+        + o32(0)  # dwReserved2
+    )
+    if im.mode == "RGBA":
+        r, g, b, a = im.split()
+        im = Image.merge("RGBA", (a, r, g, b))
+    ImageFile._save(im, fp, [("raw", (0, 0) + im.size, 0, (im.mode[::-1], 0, 1))])
+
+
+def _accept(prefix):
+    return prefix[:4] == b"DDS "
+
+
+Image.register_open(DdsImageFile.format, DdsImageFile, _accept)
+Image.register_save(DdsImageFile.format, _save)
+Image.register_extension(DdsImageFile.format, ".dds")

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/PIL/EpsImagePlugin.py

@@ -0,0 +1,411 @@
+#
+# The Python Imaging Library.
+# $Id$
+#
+# EPS file handling
+#
+# History:
+# 1995-09-01 fl   Created (0.1)
+# 1996-05-18 fl   Don't choke on "atend" fields, Ghostscript interface (0.2)
+# 1996-08-22 fl   Don't choke on floating point BoundingBox values
+# 1996-08-23 fl   Handle files from Macintosh (0.3)
+# 2001-02-17 fl   Use 're' instead of 'regex' (Python 2.1) (0.4)
+# 2003-09-07 fl   Check gs.close status (from Federico Di Gregorio) (0.5)
+# 2014-05-07 e    Handling of EPS with binary preview and fixed resolution
+#                 resizing
+#
+# 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.
+#
+
+import io
+import os
+import re
+import subprocess
+import sys
+import tempfile
+
+from . import Image, ImageFile
+from ._binary import i32le as i32
+
+#
+# --------------------------------------------------------------------
+
+split = re.compile(r"^%%([^:]*):[ \t]*(.*)[ \t]*$")
+field = re.compile(r"^%[%!\w]([^:]*)[ \t]*$")
+
+gs_windows_binary = None
+if sys.platform.startswith("win"):
+    import shutil
+
+    for binary in ("gswin32c", "gswin64c", "gs"):
+        if shutil.which(binary) is not None:
+            gs_windows_binary = binary
+            break
+    else:
+        gs_windows_binary = False
+
+
+def has_ghostscript():
+    if gs_windows_binary:
+        return True
+    if not sys.platform.startswith("win"):
+        try:
+            subprocess.check_call(["gs", "--version"], stdout=subprocess.DEVNULL)
+            return True
+        except OSError:
+            # No Ghostscript
+            pass
+    return False
+
+
+def Ghostscript(tile, size, fp, scale=1, transparency=False):
+    """Render an image using Ghostscript"""
+
+    # Unpack decoder tile
+    decoder, tile, offset, data = tile[0]
+    length, bbox = data
+
+    # Hack to support hi-res rendering
+    scale = int(scale) or 1
+    # orig_size = size
+    # orig_bbox = bbox
+    size = (size[0] * scale, size[1] * scale)
+    # resolution is dependent on bbox and size
+    res = (
+        72.0 * size[0] / (bbox[2] - bbox[0]),
+        72.0 * size[1] / (bbox[3] - bbox[1]),
+    )
+
+    out_fd, outfile = tempfile.mkstemp()
+    os.close(out_fd)
+
+    infile_temp = None
+    if hasattr(fp, "name") and os.path.exists(fp.name):
+        infile = fp.name
+    else:
+        in_fd, infile_temp = tempfile.mkstemp()
+        os.close(in_fd)
+        infile = infile_temp
+
+        # Ignore length and offset!
+        # Ghostscript can read it
+        # Copy whole file to read in Ghostscript
+        with open(infile_temp, "wb") as f:
+            # fetch length of fp
+            fp.seek(0, io.SEEK_END)
+            fsize = fp.tell()
+            # ensure start position
+            # go back
+            fp.seek(0)
+            lengthfile = fsize
+            while lengthfile > 0:
+                s = fp.read(min(lengthfile, 100 * 1024))
+                if not s:
+                    break
+                lengthfile -= len(s)
+                f.write(s)
+
+    device = "pngalpha" if transparency else "ppmraw"
+
+    # Build Ghostscript command
+    command = [
+        "gs",
+        "-q",  # quiet mode
+        "-g%dx%d" % size,  # set output geometry (pixels)
+        "-r%fx%f" % res,  # set input DPI (dots per inch)
+        "-dBATCH",  # exit after processing
+        "-dNOPAUSE",  # don't pause between pages
+        "-dSAFER",  # safe mode
+        f"-sDEVICE={device}",
+        f"-sOutputFile={outfile}",  # output file
+        # adjust for image origin
+        "-c",
+        f"{-bbox[0]} {-bbox[1]} translate",
+        "-f",
+        infile,  # input file
+        # showpage (see https://bugs.ghostscript.com/show_bug.cgi?id=698272)
+        "-c",
+        "showpage",
+    ]
+
+    if gs_windows_binary is not None:
+        if not gs_windows_binary:
+            raise OSError("Unable to locate Ghostscript on paths")
+        command[0] = gs_windows_binary
+
+    # push data through Ghostscript
+    try:
+        startupinfo = None
+        if sys.platform.startswith("win"):
+            startupinfo = subprocess.STARTUPINFO()
+            startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
+        subprocess.check_call(command, startupinfo=startupinfo)
+        out_im = Image.open(outfile)
+        out_im.load()
+    finally:
+        try:
+            os.unlink(outfile)
+            if infile_temp:
+                os.unlink(infile_temp)
+        except OSError:
+            pass
+
+    im = out_im.im.copy()
+    out_im.close()
+    return im
+
+
+class PSFile:
+    """
+    Wrapper for bytesio object that treats either CR or LF as end of line.
+    """
+
+    def __init__(self, fp):
+        self.fp = fp
+        self.char = None
+
+    def seek(self, offset, whence=io.SEEK_SET):
+        self.char = None
+        self.fp.seek(offset, whence)
+
+    def readline(self):
+        s = [self.char or b""]
+        self.char = None
+
+        c = self.fp.read(1)
+        while (c not in b"\r\n") and len(c):
+            s.append(c)
+            c = self.fp.read(1)
+
+        self.char = self.fp.read(1)
+        # line endings can be 1 or 2 of \r \n, in either order
+        if self.char in b"\r\n":
+            self.char = None
+
+        return b"".join(s).decode("latin-1")
+
+
+def _accept(prefix):
+    return prefix[:4] == b"%!PS" or (len(prefix) >= 4 and i32(prefix) == 0xC6D3D0C5)
+
+
+##
+# Image plugin for Encapsulated PostScript.  This plugin supports only
+# a few variants of this format.
+
+
+class EpsImageFile(ImageFile.ImageFile):
+    """EPS File Parser for the Python Imaging Library"""
+
+    format = "EPS"
+    format_description = "Encapsulated Postscript"
+
+    mode_map = {1: "L", 2: "LAB", 3: "RGB", 4: "CMYK"}
+
+    def _open(self):
+        (length, offset) = self._find_offset(self.fp)
+
+        # Rewrap the open file pointer in something that will
+        # convert line endings and decode to latin-1.
+        fp = PSFile(self.fp)
+
+        # go to offset - start of "%!PS"
+        fp.seek(offset)
+
+        box = None
+
+        self.mode = "RGB"
+        self._size = 1, 1  # FIXME: huh?
+
+        #
+        # Load EPS header
+
+        s_raw = fp.readline()
+        s = s_raw.strip("\r\n")
+
+        while s_raw:
+            if s:
+                if len(s) > 255:
+                    raise SyntaxError("not an EPS file")
+
+                try:
+                    m = split.match(s)
+                except re.error as e:
+                    raise SyntaxError("not an EPS file") from e
+
+                if m:
+                    k, v = m.group(1, 2)
+                    self.info[k] = v
+                    if k == "BoundingBox":
+                        try:
+                            # Note: The DSC spec says that BoundingBox
+                            # fields should be integers, but some drivers
+                            # put floating point values there anyway.
+                            box = [int(float(i)) for i in v.split()]
+                            self._size = box[2] - box[0], box[3] - box[1]
+                            self.tile = [
+                                ("eps", (0, 0) + self.size, offset, (length, box))
+                            ]
+                        except Exception:
+                            pass
+
+                else:
+                    m = field.match(s)
+                    if m:
+                        k = m.group(1)
+
+                        if k == "EndComments":
+                            break
+                        if k[:8] == "PS-Adobe":
+                            self.info[k[:8]] = k[9:]
+                        else:
+                            self.info[k] = ""
+                    elif s[0] == "%":
+                        # handle non-DSC PostScript comments that some
+                        # tools mistakenly put in the Comments section
+                        pass
+                    else:
+                        raise OSError("bad EPS header")
+
+            s_raw = fp.readline()
+            s = s_raw.strip("\r\n")
+
+            if s and s[:1] != "%":
+                break
+
+        #
+        # Scan for an "ImageData" descriptor
+
+        while s[:1] == "%":
+
+            if len(s) > 255:
+                raise SyntaxError("not an EPS file")
+
+            if s[:11] == "%ImageData:":
+                # Encoded bitmapped image.
+                x, y, bi, mo = s[11:].split(None, 7)[:4]
+
+                if int(bi) != 8:
+                    break
+                try:
+                    self.mode = self.mode_map[int(mo)]
+                except ValueError:
+                    break
+
+                self._size = int(x), int(y)
+                return
+
+            s = fp.readline().strip("\r\n")
+            if not s:
+                break
+
+        if not box:
+            raise OSError("cannot determine EPS bounding box")
+
+    def _find_offset(self, fp):
+
+        s = fp.read(160)
+
+        if s[:4] == b"%!PS":
+            # for HEAD without binary preview
+            fp.seek(0, io.SEEK_END)
+            length = fp.tell()
+            offset = 0
+        elif i32(s, 0) == 0xC6D3D0C5:
+            # FIX for: Some EPS file not handled correctly / issue #302
+            # EPS can contain binary data
+            # or start directly with latin coding
+            # more info see:
+            # https://web.archive.org/web/20160528181353/http://partners.adobe.com/public/developer/en/ps/5002.EPSF_Spec.pdf
+            offset = i32(s, 4)
+            length = i32(s, 8)
+        else:
+            raise SyntaxError("not an EPS file")
+
+        return (length, offset)
+
+    def load(self, scale=1, transparency=False):
+        # Load EPS via Ghostscript
+        if self.tile:
+            self.im = Ghostscript(self.tile, self.size, self.fp, scale, transparency)
+            self.mode = self.im.mode
+            self._size = self.im.size
+            self.tile = []
+        return Image.Image.load(self)
+
+    def load_seek(self, *args, **kwargs):
+        # we can't incrementally load, so force ImageFile.parser to
+        # use our custom load method by defining this method.
+        pass
+
+
+#
+# --------------------------------------------------------------------
+
+
+def _save(im, fp, filename, eps=1):
+    """EPS Writer for the Python Imaging Library."""
+
+    #
+    # make sure image data is available
+    im.load()
+
+    #
+    # determine PostScript image mode
+    if im.mode == "L":
+        operator = (8, 1, b"image")
+    elif im.mode == "RGB":
+        operator = (8, 3, b"false 3 colorimage")
+    elif im.mode == "CMYK":
+        operator = (8, 4, b"false 4 colorimage")
+    else:
+        raise ValueError("image mode is not supported")
+
+    if eps:
+        #
+        # write EPS header
+        fp.write(b"%!PS-Adobe-3.0 EPSF-3.0\n")
+        fp.write(b"%%Creator: PIL 0.1 EpsEncode\n")
+        # fp.write("%%CreationDate: %s"...)
+        fp.write(b"%%%%BoundingBox: 0 0 %d %d\n" % im.size)
+        fp.write(b"%%Pages: 1\n")
+        fp.write(b"%%EndComments\n")
+        fp.write(b"%%Page: 1 1\n")
+        fp.write(b"%%ImageData: %d %d " % im.size)
+        fp.write(b'%d %d 0 1 1 "%s"\n' % operator)
+
+    #
+    # image header
+    fp.write(b"gsave\n")
+    fp.write(b"10 dict begin\n")
+    fp.write(b"/buf %d string def\n" % (im.size[0] * operator[1]))
+    fp.write(b"%d %d scale\n" % im.size)
+    fp.write(b"%d %d 8\n" % im.size)  # <= bits
+    fp.write(b"[%d 0 0 -%d 0 %d]\n" % (im.size[0], im.size[1], im.size[1]))
+    fp.write(b"{ currentfile buf readhexstring pop } bind\n")
+    fp.write(operator[2] + b"\n")
+    if hasattr(fp, "flush"):
+        fp.flush()
+
+    ImageFile._save(im, fp, [("eps", (0, 0) + im.size, 0, None)])
+
+    fp.write(b"\n%%%%EndBinary\n")
+    fp.write(b"grestore end\n")
+    if hasattr(fp, "flush"):
+        fp.flush()
+
+
+#
+# --------------------------------------------------------------------
+
+
+Image.register_open(EpsImageFile.format, EpsImageFile, _accept)
+
+Image.register_save(EpsImageFile.format, _save)
+
+Image.register_extensions(EpsImageFile.format, [".ps", ".eps"])
+
+Image.register_mime(EpsImageFile.format, "application/postscript")

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/PIL/ExifTags.py

@@ -0,0 +1,331 @@
+#
+# The Python Imaging Library.
+# $Id$
+#
+# EXIF tags
+#
+# Copyright (c) 2003 by Secret Labs AB
+#
+# See the README file for information on usage and redistribution.
+#
+
+"""
+This module provides constants and clear-text names for various
+well-known EXIF tags.
+"""
+
+
+TAGS = {
+    # possibly incomplete
+    0x0001: "InteropIndex",
+    0x000B: "ProcessingSoftware",
+    0x00FE: "NewSubfileType",
+    0x00FF: "SubfileType",
+    0x0100: "ImageWidth",
+    0x0101: "ImageLength",
+    0x0102: "BitsPerSample",
+    0x0103: "Compression",
+    0x0106: "PhotometricInterpretation",
+    0x0107: "Thresholding",
+    0x0108: "CellWidth",
+    0x0109: "CellLength",
+    0x010A: "FillOrder",
+    0x010D: "DocumentName",
+    0x010E: "ImageDescription",
+    0x010F: "Make",
+    0x0110: "Model",
+    0x0111: "StripOffsets",
+    0x0112: "Orientation",
+    0x0115: "SamplesPerPixel",
+    0x0116: "RowsPerStrip",
+    0x0117: "StripByteCounts",
+    0x0118: "MinSampleValue",
+    0x0119: "MaxSampleValue",
+    0x011A: "XResolution",
+    0x011B: "YResolution",
+    0x011C: "PlanarConfiguration",
+    0x011D: "PageName",
+    0x0120: "FreeOffsets",
+    0x0121: "FreeByteCounts",
+    0x0122: "GrayResponseUnit",
+    0x0123: "GrayResponseCurve",
+    0x0124: "T4Options",
+    0x0125: "T6Options",
+    0x0128: "ResolutionUnit",
+    0x0129: "PageNumber",
+    0x012D: "TransferFunction",
+    0x0131: "Software",
+    0x0132: "DateTime",
+    0x013B: "Artist",
+    0x013C: "HostComputer",
+    0x013D: "Predictor",
+    0x013E: "WhitePoint",
+    0x013F: "PrimaryChromaticities",
+    0x0140: "ColorMap",
+    0x0141: "HalftoneHints",
+    0x0142: "TileWidth",
+    0x0143: "TileLength",
+    0x0144: "TileOffsets",
+    0x0145: "TileByteCounts",
+    0x014A: "SubIFDs",
+    0x014C: "InkSet",
+    0x014D: "InkNames",
+    0x014E: "NumberOfInks",
+    0x0150: "DotRange",
+    0x0151: "TargetPrinter",
+    0x0152: "ExtraSamples",
+    0x0153: "SampleFormat",
+    0x0154: "SMinSampleValue",
+    0x0155: "SMaxSampleValue",
+    0x0156: "TransferRange",
+    0x0157: "ClipPath",
+    0x0158: "XClipPathUnits",
+    0x0159: "YClipPathUnits",
+    0x015A: "Indexed",
+    0x015B: "JPEGTables",
+    0x015F: "OPIProxy",
+    0x0200: "JPEGProc",
+    0x0201: "JpegIFOffset",
+    0x0202: "JpegIFByteCount",
+    0x0203: "JpegRestartInterval",
+    0x0205: "JpegLosslessPredictors",
+    0x0206: "JpegPointTransforms",
+    0x0207: "JpegQTables",
+    0x0208: "JpegDCTables",
+    0x0209: "JpegACTables",
+    0x0211: "YCbCrCoefficients",
+    0x0212: "YCbCrSubSampling",
+    0x0213: "YCbCrPositioning",
+    0x0214: "ReferenceBlackWhite",
+    0x02BC: "XMLPacket",
+    0x1000: "RelatedImageFileFormat",
+    0x1001: "RelatedImageWidth",
+    0x1002: "RelatedImageLength",
+    0x4746: "Rating",
+    0x4749: "RatingPercent",
+    0x800D: "ImageID",
+    0x828D: "CFARepeatPatternDim",
+    0x828E: "CFAPattern",
+    0x828F: "BatteryLevel",
+    0x8298: "Copyright",
+    0x829A: "ExposureTime",
+    0x829D: "FNumber",
+    0x83BB: "IPTCNAA",
+    0x8649: "ImageResources",
+    0x8769: "ExifOffset",
+    0x8773: "InterColorProfile",
+    0x8822: "ExposureProgram",
+    0x8824: "SpectralSensitivity",
+    0x8825: "GPSInfo",
+    0x8827: "ISOSpeedRatings",
+    0x8828: "OECF",
+    0x8829: "Interlace",
+    0x882A: "TimeZoneOffset",
+    0x882B: "SelfTimerMode",
+    0x8830: "SensitivityType",
+    0x8831: "StandardOutputSensitivity",
+    0x8832: "RecommendedExposureIndex",
+    0x8833: "ISOSpeed",
+    0x8834: "ISOSpeedLatitudeyyy",
+    0x8835: "ISOSpeedLatitudezzz",
+    0x9000: "ExifVersion",
+    0x9003: "DateTimeOriginal",
+    0x9004: "DateTimeDigitized",
+    0x9010: "OffsetTime",
+    0x9011: "OffsetTimeOriginal",
+    0x9012: "OffsetTimeDigitized",
+    0x9101: "ComponentsConfiguration",
+    0x9102: "CompressedBitsPerPixel",
+    0x9201: "ShutterSpeedValue",
+    0x9202: "ApertureValue",
+    0x9203: "BrightnessValue",
+    0x9204: "ExposureBiasValue",
+    0x9205: "MaxApertureValue",
+    0x9206: "SubjectDistance",
+    0x9207: "MeteringMode",
+    0x9208: "LightSource",
+    0x9209: "Flash",
+    0x920A: "FocalLength",
+    0x920B: "FlashEnergy",
+    0x920C: "SpatialFrequencyResponse",
+    0x920D: "Noise",
+    0x9211: "ImageNumber",
+    0x9212: "SecurityClassification",
+    0x9213: "ImageHistory",
+    0x9214: "SubjectLocation",
+    0x9215: "ExposureIndex",
+    0x9216: "TIFF/EPStandardID",
+    0x927C: "MakerNote",
+    0x9286: "UserComment",
+    0x9290: "SubsecTime",
+    0x9291: "SubsecTimeOriginal",
+    0x9292: "SubsecTimeDigitized",
+    0x9400: "AmbientTemperature",
+    0x9401: "Humidity",
+    0x9402: "Pressure",
+    0x9403: "WaterDepth",
+    0x9404: "Acceleration",
+    0x9405: "CameraElevationAngle",
+    0x9C9B: "XPTitle",
+    0x9C9C: "XPComment",
+    0x9C9D: "XPAuthor",
+    0x9C9E: "XPKeywords",
+    0x9C9F: "XPSubject",
+    0xA000: "FlashPixVersion",
+    0xA001: "ColorSpace",
+    0xA002: "ExifImageWidth",
+    0xA003: "ExifImageHeight",
+    0xA004: "RelatedSoundFile",
+    0xA005: "ExifInteroperabilityOffset",
+    0xA20B: "FlashEnergy",
+    0xA20C: "SpatialFrequencyResponse",
+    0xA20E: "FocalPlaneXResolution",
+    0xA20F: "FocalPlaneYResolution",
+    0xA210: "FocalPlaneResolutionUnit",
+    0xA214: "SubjectLocation",
+    0xA215: "ExposureIndex",
+    0xA217: "SensingMethod",
+    0xA300: "FileSource",
+    0xA301: "SceneType",
+    0xA302: "CFAPattern",
+    0xA401: "CustomRendered",
+    0xA402: "ExposureMode",
+    0xA403: "WhiteBalance",
+    0xA404: "DigitalZoomRatio",
+    0xA405: "FocalLengthIn35mmFilm",
+    0xA406: "SceneCaptureType",
+    0xA407: "GainControl",
+    0xA408: "Contrast",
+    0xA409: "Saturation",
+    0xA40A: "Sharpness",
+    0xA40B: "DeviceSettingDescription",
+    0xA40C: "SubjectDistanceRange",
+    0xA420: "ImageUniqueID",
+    0xA430: "CameraOwnerName",
+    0xA431: "BodySerialNumber",
+    0xA432: "LensSpecification",
+    0xA433: "LensMake",
+    0xA434: "LensModel",
+    0xA435: "LensSerialNumber",
+    0xA460: "CompositeImage",
+    0xA461: "CompositeImageCount",
+    0xA462: "CompositeImageExposureTimes",
+    0xA500: "Gamma",
+    0xC4A5: "PrintImageMatching",
+    0xC612: "DNGVersion",
+    0xC613: "DNGBackwardVersion",
+    0xC614: "UniqueCameraModel",
+    0xC615: "LocalizedCameraModel",
+    0xC616: "CFAPlaneColor",
+    0xC617: "CFALayout",
+    0xC618: "LinearizationTable",
+    0xC619: "BlackLevelRepeatDim",
+    0xC61A: "BlackLevel",
+    0xC61B: "BlackLevelDeltaH",
+    0xC61C: "BlackLevelDeltaV",
+    0xC61D: "WhiteLevel",
+    0xC61E: "DefaultScale",
+    0xC61F: "DefaultCropOrigin",
+    0xC620: "DefaultCropSize",
+    0xC621: "ColorMatrix1",
+    0xC622: "ColorMatrix2",
+    0xC623: "CameraCalibration1",
+    0xC624: "CameraCalibration2",
+    0xC625: "ReductionMatrix1",
+    0xC626: "ReductionMatrix2",
+    0xC627: "AnalogBalance",
+    0xC628: "AsShotNeutral",
+    0xC629: "AsShotWhiteXY",
+    0xC62A: "BaselineExposure",
+    0xC62B: "BaselineNoise",
+    0xC62C: "BaselineSharpness",
+    0xC62D: "BayerGreenSplit",
+    0xC62E: "LinearResponseLimit",
+    0xC62F: "CameraSerialNumber",
+    0xC630: "LensInfo",
+    0xC631: "ChromaBlurRadius",
+    0xC632: "AntiAliasStrength",
+    0xC633: "ShadowScale",
+    0xC634: "DNGPrivateData",
+    0xC635: "MakerNoteSafety",
+    0xC65A: "CalibrationIlluminant1",
+    0xC65B: "CalibrationIlluminant2",
+    0xC65C: "BestQualityScale",
+    0xC65D: "RawDataUniqueID",
+    0xC68B: "OriginalRawFileName",
+    0xC68C: "OriginalRawFileData",
+    0xC68D: "ActiveArea",
+    0xC68E: "MaskedAreas",
+    0xC68F: "AsShotICCProfile",
+    0xC690: "AsShotPreProfileMatrix",
+    0xC691: "CurrentICCProfile",
+    0xC692: "CurrentPreProfileMatrix",
+    0xC6BF: "ColorimetricReference",
+    0xC6F3: "CameraCalibrationSignature",
+    0xC6F4: "ProfileCalibrationSignature",
+    0xC6F6: "AsShotProfileName",
+    0xC6F7: "NoiseReductionApplied",
+    0xC6F8: "ProfileName",
+    0xC6F9: "ProfileHueSatMapDims",
+    0xC6FA: "ProfileHueSatMapData1",
+    0xC6FB: "ProfileHueSatMapData2",
+    0xC6FC: "ProfileToneCurve",
+    0xC6FD: "ProfileEmbedPolicy",
+    0xC6FE: "ProfileCopyright",
+    0xC714: "ForwardMatrix1",
+    0xC715: "ForwardMatrix2",
+    0xC716: "PreviewApplicationName",
+    0xC717: "PreviewApplicationVersion",
+    0xC718: "PreviewSettingsName",
+    0xC719: "PreviewSettingsDigest",
+    0xC71A: "PreviewColorSpace",
+    0xC71B: "PreviewDateTime",
+    0xC71C: "RawImageDigest",
+    0xC71D: "OriginalRawFileDigest",
+    0xC71E: "SubTileBlockSize",
+    0xC71F: "RowInterleaveFactor",
+    0xC725: "ProfileLookTableDims",
+    0xC726: "ProfileLookTableData",
+    0xC740: "OpcodeList1",
+    0xC741: "OpcodeList2",
+    0xC74E: "OpcodeList3",
+    0xC761: "NoiseProfile",
+}
+"""Maps EXIF tags to tag names."""
+
+
+GPSTAGS = {
+    0: "GPSVersionID",
+    1: "GPSLatitudeRef",
+    2: "GPSLatitude",
+    3: "GPSLongitudeRef",
+    4: "GPSLongitude",
+    5: "GPSAltitudeRef",
+    6: "GPSAltitude",
+    7: "GPSTimeStamp",
+    8: "GPSSatellites",
+    9: "GPSStatus",
+    10: "GPSMeasureMode",
+    11: "GPSDOP",
+    12: "GPSSpeedRef",
+    13: "GPSSpeed",
+    14: "GPSTrackRef",
+    15: "GPSTrack",
+    16: "GPSImgDirectionRef",
+    17: "GPSImgDirection",
+    18: "GPSMapDatum",
+    19: "GPSDestLatitudeRef",
+    20: "GPSDestLatitude",
+    21: "GPSDestLongitudeRef",
+    22: "GPSDestLongitude",
+    23: "GPSDestBearingRef",
+    24: "GPSDestBearing",
+    25: "GPSDestDistanceRef",
+    26: "GPSDestDistance",
+    27: "GPSProcessingMethod",
+    28: "GPSAreaInformation",
+    29: "GPSDateStamp",
+    30: "GPSDifferential",
+    31: "GPSHPositioningError",
+}
+"""Maps EXIF GPS tags to tag names."""

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/PIL/FitsStubImagePlugin.py

@@ -0,0 +1,77 @@
+#
+# The Python Imaging Library
+# $Id$
+#
+# FITS stub adapter
+#
+# Copyright (c) 1998-2003 by Fredrik Lundh
+#
+# See the README file for information on usage and redistribution.
+#
+
+import warnings
+
+from . import FitsImagePlugin, Image, ImageFile
+
+_handler = None
+
+
+def register_handler(handler):
+    """
+    Install application-specific FITS image handler.
+
+    :param handler: Handler object.
+    """
+    global _handler
+    _handler = handler
+
+    warnings.warn(
+        "FitsStubImagePlugin is deprecated and will be removed in Pillow "
+        "10 (2023-07-01). FITS images can now be read without a handler through "
+        "FitsImagePlugin instead.",
+        DeprecationWarning,
+    )
+
+    # Override FitsImagePlugin with this handler
+    # for backwards compatibility
+    try:
+        Image.ID.remove(FITSStubImageFile.format)
+    except ValueError:
+        pass
+
+    Image.register_open(
+        FITSStubImageFile.format, FITSStubImageFile, FitsImagePlugin._accept
+    )
+
+
+class FITSStubImageFile(ImageFile.StubImageFile):
+
+    format = FitsImagePlugin.FitsImageFile.format
+    format_description = FitsImagePlugin.FitsImageFile.format_description
+
+    def _open(self):
+        offset = self.fp.tell()
+
+        im = FitsImagePlugin.FitsImageFile(self.fp)
+        self._size = im.size
+        self.mode = im.mode
+        self.tile = []
+
+        self.fp.seek(offset)
+
+        loader = self._load()
+        if loader:
+            loader.open(self)
+
+    def _load(self):
+        return _handler
+
+
+def _save(im, fp, filename):
+    raise OSError("FITS save handler not installed")
+
+
+# --------------------------------------------------------------------
+# Registry
+
+Image.register_save(FITSStubImageFile.format, _save)

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/PIL/FliImagePlugin.py

@@ -0,0 +1,171 @@
+#
+# The Python Imaging Library.
+# $Id$
+#
+# FLI/FLC file handling.
+#
+# History:
+#       95-09-01 fl     Created
+#       97-01-03 fl     Fixed parser, setup decoder tile
+#       98-07-15 fl     Renamed offset attribute to avoid name clash
+#
+# Copyright (c) Secret Labs AB 1997-98.
+# Copyright (c) Fredrik Lundh 1995-97.
+#
+# See the README file for information on usage and redistribution.
+#
+
+
+from . import Image, ImageFile, ImagePalette
+from ._binary import i16le as i16
+from ._binary import i32le as i32
+from ._binary import o8
+
+#
+# decoder
+
+
+def _accept(prefix):
+    return (
+        len(prefix) >= 6
+        and i16(prefix, 4) in [0xAF11, 0xAF12]
+        and i16(prefix, 14) in [0, 3]  # flags
+    )
+
+
+##
+# Image plugin for the FLI/FLC animation format.  Use the <b>seek</b>
+# method to load individual frames.
+
+
+class FliImageFile(ImageFile.ImageFile):
+
+    format = "FLI"
+    format_description = "Autodesk FLI/FLC Animation"
+    _close_exclusive_fp_after_loading = False
+
+    def _open(self):
+
+        # HEAD
+        s = self.fp.read(128)
+        if not (_accept(s) and s[20:22] == b"\x00\x00"):
+            raise SyntaxError("not an FLI/FLC file")
+
+        # frames
+        self.n_frames = i16(s, 6)
+        self.is_animated = self.n_frames > 1
+
+        # image characteristics
+        self.mode = "P"
+        self._size = i16(s, 8), i16(s, 10)
+
+        # animation speed
+        duration = i32(s, 16)
+        magic = i16(s, 4)
+        if magic == 0xAF11:
+            duration = (duration * 1000) // 70
+        self.info["duration"] = duration
+
+        # look for palette
+        palette = [(a, a, a) for a in range(256)]
+
+        s = self.fp.read(16)
+
+        self.__offset = 128
+
+        if i16(s, 4) == 0xF100:
+            # prefix chunk; ignore it
+            self.__offset = self.__offset + i32(s)
+            s = self.fp.read(16)
+
+        if i16(s, 4) == 0xF1FA:
+            # look for palette chunk
+            s = self.fp.read(6)
+            if i16(s, 4) == 11:
+                self._palette(palette, 2)
+            elif i16(s, 4) == 4:
+                self._palette(palette, 0)
+
+        palette = [o8(r) + o8(g) + o8(b) for (r, g, b) in palette]
+        self.palette = ImagePalette.raw("RGB", b"".join(palette))
+
+        # set things up to decode first frame
+        self.__frame = -1
+        self.__fp = self.fp
+        self.__rewind = self.fp.tell()
+        self.seek(0)
+
+    def _palette(self, palette, shift):
+        # load palette
+
+        i = 0
+        for e in range(i16(self.fp.read(2))):
+            s = self.fp.read(2)
+            i = i + s[0]
+            n = s[1]
+            if n == 0:
+                n = 256
+            s = self.fp.read(n * 3)
+            for n in range(0, len(s), 3):
+                r = s[n] << shift
+                g = s[n + 1] << shift
+                b = s[n + 2] << shift
+                palette[i] = (r, g, b)
+                i += 1
+
+    def seek(self, frame):
+        if not self._seek_check(frame):
+            return
+        if frame < self.__frame:
+            self._seek(0)
+
+        for f in range(self.__frame + 1, frame + 1):
+            self._seek(f)
+
+    def _seek(self, frame):
+        if frame == 0:
+            self.__frame = -1
+            self.__fp.seek(self.__rewind)
+            self.__offset = 128
+        else:
+            # ensure that the previous frame was loaded
+            self.load()
+
+        if frame != self.__frame + 1:
+            raise ValueError(f"cannot seek to frame {frame}")
+        self.__frame = frame
+
+        # move to next frame
+        self.fp = self.__fp
+        self.fp.seek(self.__offset)
+
+        s = self.fp.read(4)
+        if not s:
+            raise EOFError
+
+        framesize = i32(s)
+
+        self.decodermaxblock = framesize
+        self.tile = [("fli", (0, 0) + self.size, self.__offset, None)]
+
+        self.__offset += framesize
+
+    def tell(self):
+        return self.__frame
+
+    def _close__fp(self):
+        try:
+            if self.__fp != self.fp:
+                self.__fp.close()
+        except AttributeError:
+            pass
+        finally:
+            self.__fp = None
+
+
+#
+# registry
+
+Image.register_open(FliImageFile.format, FliImageFile, _accept)
+
+Image.register_extensions(FliImageFile.format, [".fli", ".flc"])

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/PIL/FontFile.py

@@ -0,0 +1,111 @@
+#
+# The Python Imaging Library
+# $Id$
+#
+# base class for raster font file parsers
+#
+# history:
+# 1997-06-05 fl   created
+# 1997-08-19 fl   restrict image width
+#
+# Copyright (c) 1997-1998 by Secret Labs AB
+# Copyright (c) 1997-1998 by Fredrik Lundh
+#
+# See the README file for information on usage and redistribution.
+#
+
+
+import os
+
+from . import Image, _binary
+
+WIDTH = 800
+
+
+def puti16(fp, values):
+    """Write network order (big-endian) 16-bit sequence"""
+    for v in values:
+        if v < 0:
+            v += 65536
+        fp.write(_binary.o16be(v))
+
+
+class FontFile:
+    """Base class for raster font file handlers."""
+
+    bitmap = None
+
+    def __init__(self):
+
+        self.info = {}
+        self.glyph = [None] * 256
+
+    def __getitem__(self, ix):
+        return self.glyph[ix]
+
+    def compile(self):
+        """Create metrics and bitmap"""
+
+        if self.bitmap:
+            return
+
+        # create bitmap large enough to hold all data
+        h = w = maxwidth = 0
+        lines = 1
+        for glyph in self:
+            if glyph:
+                d, dst, src, im = glyph
+                h = max(h, src[3] - src[1])
+                w = w + (src[2] - src[0])
+                if w > WIDTH:
+                    lines += 1
+                    w = src[2] - src[0]
+                maxwidth = max(maxwidth, w)
+
+        xsize = maxwidth
+        ysize = lines * h
+
+        if xsize == 0 and ysize == 0:
+            return ""
+
+        self.ysize = h
+
+        # paste glyphs into bitmap
+        self.bitmap = Image.new("1", (xsize, ysize))
+        self.metrics = [None] * 256
+        x = y = 0
+        for i in range(256):
+            glyph = self[i]
+            if glyph:
+                d, dst, src, im = glyph
+                xx = src[2] - src[0]
+                # yy = src[3] - src[1]
+                x0, y0 = x, y
+                x = x + xx
+                if x > WIDTH:
+                    x, y = 0, y + h
+                    x0, y0 = x, y
+                    x = xx
+                s = src[0] + x0, src[1] + y0, src[2] + x0, src[3] + y0
+                self.bitmap.paste(im.crop(src), s)
+                self.metrics[i] = d, dst, s
+
+    def save(self, filename):
+        """Save font"""
+
+        self.compile()
+
+        # font data
+        self.bitmap.save(os.path.splitext(filename)[0] + ".pbm", "PNG")
+
+        # font metrics
+        with open(os.path.splitext(filename)[0] + ".pil", "wb") as fp:
+            fp.write(b"PILfont\n")
+            fp.write(f";;;;;;{self.ysize};\n".encode("ascii"))  # HACK!!!
+            fp.write(b"DATA\n")
+            for id in range(256):
+                m = self.metrics[id]
+                if not m:
+                    puti16(fp, [0] * 10)
+                else:
+                    puti16(fp, m[0] + m[1] + m[2])

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/PIL/FpxImagePlugin.py

@@ -0,0 +1,242 @@
+#
+# THIS IS WORK IN PROGRESS
+#
+# The Python Imaging Library.
+# $Id$
+#
+# FlashPix support for PIL
+#
+# History:
+# 97-01-25 fl   Created (reads uncompressed RGB images only)
+#
+# Copyright (c) Secret Labs AB 1997.
+# Copyright (c) Fredrik Lundh 1997.
+#
+# See the README file for information on usage and redistribution.
+#
+import olefile
+
+from . import Image, ImageFile
+from ._binary import i32le as i32
+
+# we map from colour field tuples to (mode, rawmode) descriptors
+MODES = {
+    # opacity
+    (0x00007FFE): ("A", "L"),
+    # monochrome
+    (0x00010000,): ("L", "L"),
+    (0x00018000, 0x00017FFE): ("RGBA", "LA"),
+    # photo YCC
+    (0x00020000, 0x00020001, 0x00020002): ("RGB", "YCC;P"),
+    (0x00028000, 0x00028001, 0x00028002, 0x00027FFE): ("RGBA", "YCCA;P"),
+    # standard RGB (NIFRGB)
+    (0x00030000, 0x00030001, 0x00030002): ("RGB", "RGB"),
+    (0x00038000, 0x00038001, 0x00038002, 0x00037FFE): ("RGBA", "RGBA"),
+}
+
+
+#
+# --------------------------------------------------------------------
+
+
+def _accept(prefix):
+    return prefix[:8] == olefile.MAGIC
+
+
+##
+# Image plugin for the FlashPix images.
+
+
+class FpxImageFile(ImageFile.ImageFile):
+
+    format = "FPX"
+    format_description = "FlashPix"
+
+    def _open(self):
+        #
+        # read the OLE directory and see if this is a likely
+        # to be a FlashPix file
+
+        try:
+            self.ole = olefile.OleFileIO(self.fp)
+        except OSError as e:
+            raise SyntaxError("not an FPX file; invalid OLE file") from e
+
+        if self.ole.root.clsid != "56616700-C154-11CE-8553-00AA00A1F95B":
+            raise SyntaxError("not an FPX file; bad root CLSID")
+
+        self._open_index(1)
+
+    def _open_index(self, index=1):
+        #
+        # get the Image Contents Property Set
+
+        prop = self.ole.getproperties(
+            [f"Data Object Store {index:06d}", "\005Image Contents"]
+        )
+
+        # size (highest resolution)
+
+        self._size = prop[0x1000002], prop[0x1000003]
+
+        size = max(self.size)
+        i = 1
+        while size > 64:
+            size = size / 2
+            i += 1
+        self.maxid = i - 1
+
+        # mode.  instead of using a single field for this, flashpix
+        # requires you to specify the mode for each channel in each
+        # resolution subimage, and leaves it to the decoder to make
+        # sure that they all match.  for now, we'll cheat and assume
+        # that this is always the case.
+
+        id = self.maxid << 16
+
+        s = prop[0x2000002 | id]
+
+        colors = []
+        bands = i32(s, 4)
+        if bands > 4:
+            raise OSError("Invalid number of bands")
+        for i in range(bands):
+            # note: for now, we ignore the "uncalibrated" flag
+            colors.append(i32(s, 8 + i * 4) & 0x7FFFFFFF)
+
+        self.mode, self.rawmode = MODES[tuple(colors)]
+
+        # load JPEG tables, if any
+        self.jpeg = {}
+        for i in range(256):
+            id = 0x3000001 | (i << 16)
+            if id in prop:
+                self.jpeg[i] = prop[id]
+
+        self._open_subimage(1, self.maxid)
+
+    def _open_subimage(self, index=1, subimage=0):
+        #
+        # setup tile descriptors for a given subimage
+
+        stream = [
+            f"Data Object Store {index:06d}",
+            f"Resolution {subimage:04d}",
+            "Subimage 0000 Header",
+        ]
+
+        fp = self.ole.openstream(stream)
+
+        # skip prefix
+        fp.read(28)
+
+        # header stream
+        s = fp.read(36)
+
+        size = i32(s, 4), i32(s, 8)
+        # tilecount = i32(s, 12)
+        tilesize = i32(s, 16), i32(s, 20)
+        # channels = i32(s, 24)
+        offset = i32(s, 28)
+        length = i32(s, 32)
+
+        if size != self.size:
+            raise OSError("subimage mismatch")
+
+        # get tile descriptors
+        fp.seek(28 + offset)
+        s = fp.read(i32(s, 12) * length)
+
+        x = y = 0
+        xsize, ysize = size
+        xtile, ytile = tilesize
+        self.tile = []
+
+        for i in range(0, len(s), length):
+
+            compression = i32(s, i + 8)
+
+            if compression == 0:
+                self.tile.append(
+                    (
+                        "raw",
+                        (x, y, x + xtile, y + ytile),
+                        i32(s, i) + 28,
+                        (self.rawmode),
+                    )
+                )
+
+            elif compression == 1:
+
+                # FIXME: the fill decoder is not implemented
+                self.tile.append(
+                    (
+                        "fill",
+                        (x, y, x + xtile, y + ytile),
+                        i32(s, i) + 28,
+                        (self.rawmode, s[12:16]),
+                    )
+                )
+
+            elif compression == 2:
+
+                internal_color_conversion = s[14]
+                jpeg_tables = s[15]
+                rawmode = self.rawmode
+
+                if internal_color_conversion:
+                    # The image is stored as usual (usually YCbCr).
+                    if rawmode == "RGBA":
+                        # For "RGBA", data is stored as YCbCrA based on
+                        # negative RGB. The following trick works around
+                        # this problem :
+                        jpegmode, rawmode = "YCbCrK", "CMYK"
+                    else:
+                        jpegmode = None  # let the decoder decide
+
+                else:
+                    # The image is stored as defined by rawmode
+                    jpegmode = rawmode
+
+                self.tile.append(
+                    (
+                        "jpeg",
+                        (x, y, x + xtile, y + ytile),
+                        i32(s, i) + 28,
+                        (rawmode, jpegmode),
+                    )
+                )
+
+                # FIXME: jpeg tables are tile dependent; the prefix
+                # data must be placed in the tile descriptor itself!
+
+                if jpeg_tables:
+                    self.tile_prefix = self.jpeg[jpeg_tables]
+
+            else:
+                raise OSError("unknown/invalid compression")
+
+            x = x + xtile
+            if x >= xsize:
+                x, y = 0, y + ytile
+                if y >= ysize:
+                    break  # isn't really required
+
+        self.stream = stream
+        self.fp = None
+
+    def load(self):
+
+        if not self.fp:
+            self.fp = self.ole.openstream(self.stream[:2] + ["Subimage 0000 Data"])
+
+        return ImageFile.ImageFile.load(self)
+
+
+#
+# --------------------------------------------------------------------
+
+
+Image.register_open(FpxImageFile.format, FpxImageFile, _accept)
+
+Image.register_extension(FpxImageFile.format, ".fpx")

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/PIL/FtexImagePlugin.py

@@ -0,0 +1,135 @@
+"""
+A Pillow loader for .ftc and .ftu files (FTEX)
+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/
+
+Independence War 2: Edge Of Chaos - Texture File Format - 16 October 2001
+
+The textures used for 3D objects in Independence War 2: Edge Of Chaos are in a
+packed custom format called FTEX. This file format uses file extensions FTC
+and FTU.
+* FTC files are compressed textures (using standard texture compression).
+* FTU files are not compressed.
+Texture File Format
+The FTC and FTU texture files both use the same format. This
+has the following structure:
+{header}
+{format_directory}
+{data}
+Where:
+{header} = {
+    u32:magic,
+    u32:version,
+    u32:width,
+    u32:height,
+    u32:mipmap_count,
+    u32:format_count
+}
+
+* The "magic" number is "FTEX".
+* "width" and "height" are the dimensions of the texture.
+* "mipmap_count" is the number of mipmaps in the texture.
+* "format_count" is the number of texture formats (different versions of the
+same texture) in this file.
+
+{format_directory} = format_count * { u32:format, u32:where }
+
+The format value is 0 for DXT1 compressed textures and 1 for 24-bit RGB
+uncompressed textures.
+The texture data for a format starts at the position "where" in the file.
+
+Each set of texture data in the file has the following structure:
+{data} = format_count * { u32:mipmap_size, mipmap_size * { u8 } }
+* "mipmap_size" is the number of bytes in that mip level. For compressed
+textures this is the size of the texture data compressed with DXT1. For 24 bit
+uncompressed textures, this is 3 * width * height. Following this are the image
+bytes for that mipmap level.
+
+Note: All data is stored in little-Endian (Intel) byte order.
+"""
+
+import struct
+import warnings
+from enum import IntEnum
+from io import BytesIO
+
+from . import Image, ImageFile
+
+MAGIC = b"FTEX"
+
+
+class Format(IntEnum):
+    DXT1 = 0
+    UNCOMPRESSED = 1
+
+
+def __getattr__(name):
+    deprecated = "deprecated and will be removed in Pillow 10 (2023-07-01). "
+    for enum, prefix in {Format: "FORMAT_"}.items():
+        if name.startswith(prefix):
+            name = name[len(prefix) :]
+            if name in enum.__members__:
+                warnings.warn(
+                    prefix
+                    + name
+                    + " is "
+                    + deprecated
+                    + "Use "
+                    + enum.__name__
+                    + "."
+                    + name
+                    + " instead.",
+                    DeprecationWarning,
+                    stacklevel=2,
+                )
+                return enum[name]
+    raise AttributeError(f"module '{__name__}' has no attribute '{name}'")
+
+
+class FtexImageFile(ImageFile.ImageFile):
+    format = "FTEX"
+    format_description = "Texture File Format (IW2:EOC)"
+
+    def _open(self):
+        if not _accept(self.fp.read(4)):
+            raise SyntaxError("not an FTEX file")
+        struct.unpack("<i", self.fp.read(4))  # version
+        self._size = struct.unpack("<2i", self.fp.read(8))
+        mipmap_count, format_count = struct.unpack("<2i", self.fp.read(8))
+
+        self.mode = "RGB"
+
+        # Only support single-format files.
+        # I don't know of any multi-format file.
+        assert format_count == 1
+
+        format, where = struct.unpack("<2i", self.fp.read(8))
+        self.fp.seek(where)
+        (mipmap_size,) = struct.unpack("<i", self.fp.read(4))
+
+        data = self.fp.read(mipmap_size)
+
+        if format == Format.DXT1:
+            self.mode = "RGBA"
+            self.tile = [("bcn", (0, 0) + self.size, 0, (1))]
+        elif format == Format.UNCOMPRESSED:
+            self.tile = [("raw", (0, 0) + self.size, 0, ("RGB", 0, 1))]
+        else:
+            raise ValueError(f"Invalid texture compression format: {repr(format)}")
+
+        self.fp.close()
+        self.fp = BytesIO(data)
+
+    def load_seek(self, pos):
+        pass
+
+
+def _accept(prefix):
+    return prefix[:4] == MAGIC
+
+
+Image.register_open(FtexImageFile.format, FtexImageFile, _accept)
+Image.register_extensions(FtexImageFile.format, [".ftc", ".ftu"])

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/PIL/GbrImagePlugin.py

@@ -0,0 +1,98 @@
+#
+# The Python Imaging Library
+#
+# load a GIMP brush file
+#
+# History:
+#       96-03-14 fl     Created
+#       16-01-08 es     Version 2
+#
+# Copyright (c) Secret Labs AB 1997.
+# Copyright (c) Fredrik Lundh 1996.
+# Copyright (c) Eric Soroos 2016.
+#
+# See the README file for information on usage and redistribution.
+#
+#
+# See https://github.com/GNOME/gimp/blob/mainline/devel-docs/gbr.txt for
+# format documentation.
+#
+# This code Interprets version 1 and 2 .gbr files.
+# Version 1 files are obsolete, and should not be used for new
+#   brushes.
+# Version 2 files are saved by GIMP v2.8 (at least)
+# Version 3 files have a format specifier of 18 for 16bit floats in
+#   the color depth field. This is currently unsupported by Pillow.
+
+from . import Image, ImageFile
+from ._binary import i32be as i32
+
+
+def _accept(prefix):
+    return len(prefix) >= 8 and i32(prefix, 0) >= 20 and i32(prefix, 4) in (1, 2)
+
+
+##
+# Image plugin for the GIMP brush format.
+
+
+class GbrImageFile(ImageFile.ImageFile):
+
+    format = "GBR"
+    format_description = "GIMP brush file"
+
+    def _open(self):
+        header_size = i32(self.fp.read(4))
+        if header_size < 20:
+            raise SyntaxError("not a GIMP brush")
+        version = i32(self.fp.read(4))
+        if version not in (1, 2):
+            raise SyntaxError(f"Unsupported GIMP brush version: {version}")
+
+        width = i32(self.fp.read(4))
+        height = i32(self.fp.read(4))
+        color_depth = i32(self.fp.read(4))
+        if width <= 0 or height <= 0:
+            raise SyntaxError("not a GIMP brush")
+        if color_depth not in (1, 4):
+            raise SyntaxError(f"Unsupported GIMP brush color depth: {color_depth}")
+
+        if version == 1:
+            comment_length = header_size - 20
+        else:
+            comment_length = header_size - 28
+            magic_number = self.fp.read(4)
+            if magic_number != b"GIMP":
+                raise SyntaxError("not a GIMP brush, bad magic number")
+            self.info["spacing"] = i32(self.fp.read(4))
+
+        comment = self.fp.read(comment_length)[:-1]
+
+        if color_depth == 1:
+            self.mode = "L"
+        else:
+            self.mode = "RGBA"
+
+        self._size = width, height
+
+        self.info["comment"] = comment
+
+        # Image might not be small
+        Image._decompression_bomb_check(self.size)
+
+        # Data is an uncompressed block of w * h * bytes/pixel
+        self._data_size = width * height * color_depth
+
+    def load(self):
+        if not self.im:
+            self.im = Image.core.new(self.mode, self.size)
+            self.frombytes(self.fp.read(self._data_size))
+        return Image.Image.load(self)
+
+
+#
+# registry
+
+
+Image.register_open(GbrImageFile.format, GbrImageFile, _accept)
+Image.register_extension(GbrImageFile.format, ".gbr")

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/PIL/GimpGradientFile.py

@@ -0,0 +1,140 @@
+#
+# Python Imaging Library
+# $Id$
+#
+# stuff to read (and render) GIMP gradient files
+#
+# History:
+#       97-08-23 fl     Created
+#
+# Copyright (c) Secret Labs AB 1997.
+# Copyright (c) Fredrik Lundh 1997.
+#
+# See the README file for information on usage and redistribution.
+#
+
+"""
+Stuff to translate curve segments to palette values (derived from
+the corresponding code in GIMP, written by Federico Mena Quintero.
+See the GIMP distribution for more information.)
+"""
+
+
+from math import log, pi, sin, sqrt
+
+from ._binary import o8
+
+EPSILON = 1e-10
+""""""  # Enable auto-doc for data member
+
+
+def linear(middle, pos):
+    if pos <= middle:
+        if middle < EPSILON:
+            return 0.0
+        else:
+            return 0.5 * pos / middle
+    else:
+        pos = pos - middle
+        middle = 1.0 - middle
+        if middle < EPSILON:
+            return 1.0
+        else:
+            return 0.5 + 0.5 * pos / middle
+
+
+def curved(middle, pos):
+    return pos ** (log(0.5) / log(max(middle, EPSILON)))
+
+
+def sine(middle, pos):
+    return (sin((-pi / 2.0) + pi * linear(middle, pos)) + 1.0) / 2.0
+
+
+def sphere_increasing(middle, pos):
+    return sqrt(1.0 - (linear(middle, pos) - 1.0) ** 2)
+
+
+def sphere_decreasing(middle, pos):
+    return 1.0 - sqrt(1.0 - linear(middle, pos) ** 2)
+
+
+SEGMENTS = [linear, curved, sine, sphere_increasing, sphere_decreasing]
+""""""  # Enable auto-doc for data member
+
+
+class GradientFile:
+
+    gradient = None
+
+    def getpalette(self, entries=256):
+
+        palette = []
+
+        ix = 0
+        x0, x1, xm, rgb0, rgb1, segment = self.gradient[ix]
+
+        for i in range(entries):
+
+            x = i / (entries - 1)
+
+            while x1 < x:
+                ix += 1
+                x0, x1, xm, rgb0, rgb1, segment = self.gradient[ix]
+
+            w = x1 - x0
+
+            if w < EPSILON:
+                scale = segment(0.5, 0.5)
+            else:
+                scale = segment((xm - x0) / w, (x - x0) / w)
+
+            # expand to RGBA
+            r = o8(int(255 * ((rgb1[0] - rgb0[0]) * scale + rgb0[0]) + 0.5))
+            g = o8(int(255 * ((rgb1[1] - rgb0[1]) * scale + rgb0[1]) + 0.5))
+            b = o8(int(255 * ((rgb1[2] - rgb0[2]) * scale + rgb0[2]) + 0.5))
+            a = o8(int(255 * ((rgb1[3] - rgb0[3]) * scale + rgb0[3]) + 0.5))
+
+            # add to palette
+            palette.append(r + g + b + a)
+
+        return b"".join(palette), "RGBA"
+
+
+class GimpGradientFile(GradientFile):
+    """File handler for GIMP's gradient format."""
+
+    def __init__(self, fp):
+
+        if fp.readline()[:13] != b"GIMP Gradient":
+            raise SyntaxError("not a GIMP gradient file")
+
+        line = fp.readline()
+
+        # GIMP 1.2 gradient files don't contain a name, but GIMP 1.3 files do
+        if line.startswith(b"Name: "):
+            line = fp.readline().strip()
+
+        count = int(line)
+
+        gradient = []
+
+        for i in range(count):
+
+            s = fp.readline().split()
+            w = [float(x) for x in s[:11]]
+
+            x0, x1 = w[0], w[2]
+            xm = w[1]
+            rgb0 = w[3:7]
+            rgb1 = w[7:11]
+
+            segment = SEGMENTS[int(s[11])]
+            cspace = int(s[12])
+
+            if cspace != 0:
+                raise OSError("cannot handle HSV colour space")
+
+            gradient.append((x0, x1, xm, rgb0, rgb1, segment))
+
+        self.gradient = gradient

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/PIL/GimpPaletteFile.py

@@ -0,0 +1,56 @@
+#
+# Python Imaging Library
+# $Id$
+#
+# stuff to read GIMP palette files
+#
+# History:
+# 1997-08-23 fl     Created
+# 2004-09-07 fl     Support GIMP 2.0 palette files.
+#
+# Copyright (c) Secret Labs AB 1997-2004.  All rights reserved.
+# Copyright (c) Fredrik Lundh 1997-2004.
+#
+# See the README file for information on usage and redistribution.
+#
+
+import re
+
+from ._binary import o8
+
+
+class GimpPaletteFile:
+    """File handler for GIMP's palette format."""
+
+    rawmode = "RGB"
+
+    def __init__(self, fp):
+
+        self.palette = [o8(i) * 3 for i in range(256)]
+
+        if fp.readline()[:12] != b"GIMP Palette":
+            raise SyntaxError("not a GIMP palette file")
+
+        for i in range(256):
+
+            s = fp.readline()
+            if not s:
+                break
+
+            # skip fields and comment lines
+            if re.match(rb"\w+:|#", s):
+                continue
+            if len(s) > 100:
+                raise SyntaxError("bad palette file")
+
+            v = tuple(map(int, s.split()[:3]))
+            if len(v) != 3:
+                raise ValueError("bad palette entry")
+
+            self.palette[i] = o8(v[0]) + o8(v[1]) + o8(v[2])
+
+        self.palette = b"".join(self.palette)
+
+    def getpalette(self):
+
+        return self.palette, self.rawmode

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/PIL/GribStubImagePlugin.py

@@ -0,0 +1,73 @@
+#
+# The Python Imaging Library
+# $Id$
+#
+# GRIB 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 GRIB image handler.
+
+    :param handler: Handler object.
+    """
+    global _handler
+    _handler = handler
+
+
+# --------------------------------------------------------------------
+# Image adapter
+
+
+def _accept(prefix):
+    return prefix[0:4] == b"GRIB" and prefix[7] == 1
+
+
+class GribStubImageFile(ImageFile.StubImageFile):
+
+    format = "GRIB"
+    format_description = "GRIB"
+
+    def _open(self):
+
+        offset = self.fp.tell()
+
+        if not _accept(self.fp.read(8)):
+            raise SyntaxError("Not a GRIB 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 OSError("GRIB save handler not installed")
+    _handler.save(im, fp, filename)
+
+
+# --------------------------------------------------------------------
+# Registry
+
+Image.register_open(GribStubImageFile.format, GribStubImageFile, _accept)
+Image.register_save(GribStubImageFile.format, _save)
+
+Image.register_extension(GribStubImageFile.format, ".grib")

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/PIL/IcnsImagePlugin.py

@@ -0,0 +1,392 @@
+#
+# The Python Imaging Library.
+# $Id$
+#
+# macOS icns file decoder, based on icns.py by Bob Ippolito.
+#
+# history:
+# 2004-10-09 fl   Turned into a PIL plugin; removed 2.3 dependencies.
+# 2020-04-04      Allow saving on all operating systems.
+#
+# Copyright (c) 2004 by Bob Ippolito.
+# Copyright (c) 2004 by Secret Labs.
+# Copyright (c) 2004 by Fredrik Lundh.
+# Copyright (c) 2014 by Alastair Houghton.
+# Copyright (c) 2020 by Pan Jing.
+#
+# See the README file for information on usage and redistribution.
+#
+
+import io
+import os
+import struct
+import sys
+
+from PIL import Image, ImageFile, PngImagePlugin, features
+
+enable_jpeg2k = features.check_codec("jpg_2000")
+if enable_jpeg2k:
+    from PIL import Jpeg2KImagePlugin
+
+MAGIC = b"icns"
+HEADERSIZE = 8
+
+
+def nextheader(fobj):
+    return struct.unpack(">4sI", fobj.read(HEADERSIZE))
+
+
+def read_32t(fobj, start_length, size):
+    # The 128x128 icon seems to have an extra header for some reason.
+    (start, length) = start_length
+    fobj.seek(start)
+    sig = fobj.read(4)
+    if sig != b"\x00\x00\x00\x00":
+        raise SyntaxError("Unknown signature, expecting 0x00000000")
+    return read_32(fobj, (start + 4, length - 4), size)
+
+
+def read_32(fobj, start_length, size):
+    """
+    Read a 32bit RGB icon resource.  Seems to be either uncompressed or
+    an RLE packbits-like scheme.
+    """
+    (start, length) = start_length
+    fobj.seek(start)
+    pixel_size = (size[0] * size[2], size[1] * size[2])
+    sizesq = pixel_size[0] * pixel_size[1]
+    if length == sizesq * 3:
+        # uncompressed ("RGBRGBGB")
+        indata = fobj.read(length)
+        im = Image.frombuffer("RGB", pixel_size, indata, "raw", "RGB", 0, 1)
+    else:
+        # decode image
+        im = Image.new("RGB", pixel_size, None)
+        for band_ix in range(3):
+            data = []
+            bytesleft = sizesq
+            while bytesleft > 0:
+                byte = fobj.read(1)
+                if not byte:
+                    break
+                byte = byte[0]
+                if byte & 0x80:
+                    blocksize = byte - 125
+                    byte = fobj.read(1)
+                    for i in range(blocksize):
+                        data.append(byte)
+                else:
+                    blocksize = byte + 1
+                    data.append(fobj.read(blocksize))
+                bytesleft -= blocksize
+                if bytesleft <= 0:
+                    break
+            if bytesleft != 0:
+                raise SyntaxError(f"Error reading channel [{repr(bytesleft)} left]")
+            band = Image.frombuffer("L", pixel_size, b"".join(data), "raw", "L", 0, 1)
+            im.im.putband(band.im, band_ix)
+    return {"RGB": im}
+
+
+def read_mk(fobj, start_length, size):
+    # Alpha masks seem to be uncompressed
+    start = start_length[0]
+    fobj.seek(start)
+    pixel_size = (size[0] * size[2], size[1] * size[2])
+    sizesq = pixel_size[0] * pixel_size[1]
+    band = Image.frombuffer("L", pixel_size, fobj.read(sizesq), "raw", "L", 0, 1)
+    return {"A": band}
+
+
+def read_png_or_jpeg2000(fobj, start_length, size):
+    (start, length) = start_length
+    fobj.seek(start)
+    sig = fobj.read(12)
+    if sig[:8] == b"\x89PNG\x0d\x0a\x1a\x0a":
+        fobj.seek(start)
+        im = PngImagePlugin.PngImageFile(fobj)
+        Image._decompression_bomb_check(im.size)
+        return {"RGBA": im}
+    elif (
+        sig[:4] == b"\xff\x4f\xff\x51"
+        or sig[:4] == b"\x0d\x0a\x87\x0a"
+        or sig == b"\x00\x00\x00\x0cjP  \x0d\x0a\x87\x0a"
+    ):
+        if not enable_jpeg2k:
+            raise ValueError(
+                "Unsupported icon subimage format (rebuild PIL "
+                "with JPEG 2000 support to fix this)"
+            )
+        # j2k, jpc or j2c
+        fobj.seek(start)
+        jp2kstream = fobj.read(length)
+        f = io.BytesIO(jp2kstream)
+        im = Jpeg2KImagePlugin.Jpeg2KImageFile(f)
+        Image._decompression_bomb_check(im.size)
+        if im.mode != "RGBA":
+            im = im.convert("RGBA")
+        return {"RGBA": im}
+    else:
+        raise ValueError("Unsupported icon subimage format")
+
+
+class IcnsFile:
+
+    SIZES = {
+        (512, 512, 2): [(b"ic10", read_png_or_jpeg2000)],
+        (512, 512, 1): [(b"ic09", read_png_or_jpeg2000)],
+        (256, 256, 2): [(b"ic14", read_png_or_jpeg2000)],
+        (256, 256, 1): [(b"ic08", read_png_or_jpeg2000)],
+        (128, 128, 2): [(b"ic13", read_png_or_jpeg2000)],
+        (128, 128, 1): [
+            (b"ic07", read_png_or_jpeg2000),
+            (b"it32", read_32t),
+            (b"t8mk", read_mk),
+        ],
+        (64, 64, 1): [(b"icp6", read_png_or_jpeg2000)],
+        (32, 32, 2): [(b"ic12", read_png_or_jpeg2000)],
+        (48, 48, 1): [(b"ih32", read_32), (b"h8mk", read_mk)],
+        (32, 32, 1): [
+            (b"icp5", read_png_or_jpeg2000),
+            (b"il32", read_32),
+            (b"l8mk", read_mk),
+        ],
+        (16, 16, 2): [(b"ic11", read_png_or_jpeg2000)],
+        (16, 16, 1): [
+            (b"icp4", read_png_or_jpeg2000),
+            (b"is32", read_32),
+            (b"s8mk", read_mk),
+        ],
+    }
+
+    def __init__(self, fobj):
+        """
+        fobj is a file-like object as an icns resource
+        """
+        # signature : (start, length)
+        self.dct = dct = {}
+        self.fobj = fobj
+        sig, filesize = nextheader(fobj)
+        if not _accept(sig):
+            raise SyntaxError("not an icns file")
+        i = HEADERSIZE
+        while i < filesize:
+            sig, blocksize = nextheader(fobj)
+            if blocksize <= 0:
+                raise SyntaxError("invalid block header")
+            i += HEADERSIZE
+            blocksize -= HEADERSIZE
+            dct[sig] = (i, blocksize)
+            fobj.seek(blocksize, io.SEEK_CUR)
+            i += blocksize
+
+    def itersizes(self):
+        sizes = []
+        for size, fmts in self.SIZES.items():
+            for (fmt, reader) in fmts:
+                if fmt in self.dct:
+                    sizes.append(size)
+                    break
+        return sizes
+
+    def bestsize(self):
+        sizes = self.itersizes()
+        if not sizes:
+            raise SyntaxError("No 32bit icon resources found")
+        return max(sizes)
+
+    def dataforsize(self, size):
+        """
+        Get an icon resource as {channel: array}.  Note that
+        the arrays are bottom-up like windows bitmaps and will likely
+        need to be flipped or transposed in some way.
+        """
+        dct = {}
+        for code, reader in self.SIZES[size]:
+            desc = self.dct.get(code)
+            if desc is not None:
+                dct.update(reader(self.fobj, desc, size))
+        return dct
+
+    def getimage(self, size=None):
+        if size is None:
+            size = self.bestsize()
+        if len(size) == 2:
+            size = (size[0], size[1], 1)
+        channels = self.dataforsize(size)
+
+        im = channels.get("RGBA", None)
+        if im:
+            return im
+
+        im = channels.get("RGB").copy()
+        try:
+            im.putalpha(channels["A"])
+        except KeyError:
+            pass
+        return im
+
+
+##
+# Image plugin for Mac OS icons.
+
+
+class IcnsImageFile(ImageFile.ImageFile):
+    """
+    PIL image support for Mac OS .icns files.
+    Chooses the best resolution, but will possibly load
+    a different size image if you mutate the size attribute
+    before calling 'load'.
+
+    The info dictionary has a key 'sizes' that is a list
+    of sizes that the icns file has.
+    """
+
+    format = "ICNS"
+    format_description = "Mac OS icns resource"
+
+    def _open(self):
+        self.icns = IcnsFile(self.fp)
+        self.mode = "RGBA"
+        self.info["sizes"] = self.icns.itersizes()
+        self.best_size = self.icns.bestsize()
+        self.size = (
+            self.best_size[0] * self.best_size[2],
+            self.best_size[1] * self.best_size[2],
+        )
+
+    @property
+    def size(self):
+        return self._size
+
+    @size.setter
+    def size(self, value):
+        info_size = value
+        if info_size not in self.info["sizes"] and len(info_size) == 2:
+            info_size = (info_size[0], info_size[1], 1)
+        if (
+            info_size not in self.info["sizes"]
+            and len(info_size) == 3
+            and info_size[2] == 1
+        ):
+            simple_sizes = [
+                (size[0] * size[2], size[1] * size[2]) for size in self.info["sizes"]
+            ]
+            if value in simple_sizes:
+                info_size = self.info["sizes"][simple_sizes.index(value)]
+        if info_size not in self.info["sizes"]:
+            raise ValueError("This is not one of the allowed sizes of this image")
+        self._size = value
+
+    def load(self):
+        if len(self.size) == 3:
+            self.best_size = self.size
+            self.size = (
+                self.best_size[0] * self.best_size[2],
+                self.best_size[1] * self.best_size[2],
+            )
+
+        px = Image.Image.load(self)
+        if self.im is not None and self.im.size == self.size:
+            # Already loaded
+            return px
+        self.load_prepare()
+        # This is likely NOT the best way to do it, but whatever.
+        im = self.icns.getimage(self.best_size)
+
+        # If this is a PNG or JPEG 2000, it won't be loaded yet
+        px = im.load()
+
+        self.im = im.im
+        self.mode = im.mode
+        self.size = im.size
+
+        return px
+
+
+def _save(im, fp, filename):
+    """
+    Saves the image as a series of PNG files,
+    that are then combined into a .icns file.
+    """
+    if hasattr(fp, "flush"):
+        fp.flush()
+
+    sizes = {
+        b"ic07": 128,
+        b"ic08": 256,
+        b"ic09": 512,
+        b"ic10": 1024,
+        b"ic11": 32,
+        b"ic12": 64,
+        b"ic13": 256,
+        b"ic14": 512,
+    }
+    provided_images = {im.width: im for im in im.encoderinfo.get("append_images", [])}
+    size_streams = {}
+    for size in set(sizes.values()):
+        image = (
+            provided_images[size]
+            if size in provided_images
+            else im.resize((size, size))
+        )
+
+        temp = io.BytesIO()
+        image.save(temp, "png")
+        size_streams[size] = temp.getvalue()
+
+    entries = []
+    for type, size in sizes.items():
+        stream = size_streams[size]
+        entries.append(
+            {"type": type, "size": HEADERSIZE + len(stream), "stream": stream}
+        )
+
+    # Header
+    fp.write(MAGIC)
+    file_length = HEADERSIZE  # Header
+    file_length += HEADERSIZE + 8 * len(entries)  # TOC
+    file_length += sum(entry["size"] for entry in entries)
+    fp.write(struct.pack(">i", file_length))
+
+    # TOC
+    fp.write(b"TOC ")
+    fp.write(struct.pack(">i", HEADERSIZE + len(entries) * HEADERSIZE))
+    for entry in entries:
+        fp.write(entry["type"])
+        fp.write(struct.pack(">i", entry["size"]))
+
+    # Data
+    for entry in entries:
+        fp.write(entry["type"])
+        fp.write(struct.pack(">i", entry["size"]))
+        fp.write(entry["stream"])
+
+    if hasattr(fp, "flush"):
+        fp.flush()
+
+
+def _accept(prefix):
+    return prefix[:4] == MAGIC
+
+
+Image.register_open(IcnsImageFile.format, IcnsImageFile, _accept)
+Image.register_extension(IcnsImageFile.format, ".icns")
+
+Image.register_save(IcnsImageFile.format, _save)
+Image.register_mime(IcnsImageFile.format, "image/icns")
+
+if __name__ == "__main__":
+    if len(sys.argv) < 2:
+        print("Syntax: python3 IcnsImagePlugin.py [file]")
+        sys.exit()
+
+    with open(sys.argv[1], "rb") as fp:
+        imf = IcnsImageFile(fp)
+        for size in imf.info["sizes"]:
+            imf.size = size
+            imf.save("out-%s-%s-%s.png" % size)
+        with Image.open(sys.argv[1]) as im:
+            im.save("out.png")
+        if sys.platform == "windows":
+            os.startfile("out.png")

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/PIL/IcoImagePlugin.py

@@ -0,0 +1,355 @@
+#
+# The Python Imaging Library.
+# $Id$
+#
+# Windows Icon support for PIL
+#
+# History:
+#       96-05-27 fl     Created
+#
+# Copyright (c) Secret Labs AB 1997.
+# Copyright (c) Fredrik Lundh 1996.
+#
+# See the README file for information on usage and redistribution.
+#
+
+# This plugin is a refactored version of Win32IconImagePlugin by Bryan Davis
+# <casadebender@gmail.com>.
+# https://code.google.com/archive/p/casadebender/wikis/Win32IconImagePlugin.wiki
+#
+# Icon format references:
+#   * https://en.wikipedia.org/wiki/ICO_(file_format)
+#   * https://msdn.microsoft.com/en-us/library/ms997538.aspx
+
+
+import warnings
+from io import BytesIO
+from math import ceil, log
+
+from . import BmpImagePlugin, Image, ImageFile, PngImagePlugin
+from ._binary import i16le as i16
+from ._binary import i32le as i32
+from ._binary import o8
+from ._binary import o16le as o16
+from ._binary import o32le as o32
+
+#
+# --------------------------------------------------------------------
+
+_MAGIC = b"\0\0\1\0"
+
+
+def _save(im, fp, filename):
+    fp.write(_MAGIC)  # (2+2)
+    bmp = im.encoderinfo.get("bitmap_format") == "bmp"
+    sizes = im.encoderinfo.get(
+        "sizes",
+        [(16, 16), (24, 24), (32, 32), (48, 48), (64, 64), (128, 128), (256, 256)],
+    )
+    frames = []
+    provided_ims = [im] + im.encoderinfo.get("append_images", [])
+    width, height = im.size
+    for size in sorted(set(sizes)):
+        if size[0] > width or size[1] > height or size[0] > 256 or size[1] > 256:
+            continue
+
+        for provided_im in provided_ims:
+            if provided_im.size != size:
+                continue
+            frames.append(provided_im)
+            if bmp:
+                bits = BmpImagePlugin.SAVE[provided_im.mode][1]
+                bits_used = [bits]
+                for other_im in provided_ims:
+                    if other_im.size != size:
+                        continue
+                    bits = BmpImagePlugin.SAVE[other_im.mode][1]
+                    if bits not in bits_used:
+                        # Another image has been supplied for this size
+                        # with a different bit depth
+                        frames.append(other_im)
+                        bits_used.append(bits)
+            break
+        else:
+            # TODO: invent a more convenient method for proportional scalings
+            frame = provided_im.copy()
+            frame.thumbnail(size, Image.Resampling.LANCZOS, reducing_gap=None)
+            frames.append(frame)
+    fp.write(o16(len(frames)))  # idCount(2)
+    offset = fp.tell() + len(frames) * 16
+    for frame in frames:
+        width, height = frame.size
+        # 0 means 256
+        fp.write(o8(width if width < 256 else 0))  # bWidth(1)
+        fp.write(o8(height if height < 256 else 0))  # bHeight(1)
+
+        bits, colors = BmpImagePlugin.SAVE[frame.mode][1:] if bmp else (32, 0)
+        fp.write(o8(colors))  # bColorCount(1)
+        fp.write(b"\0")  # bReserved(1)
+        fp.write(b"\0\0")  # wPlanes(2)
+        fp.write(o16(bits))  # wBitCount(2)
+
+        image_io = BytesIO()
+        if bmp:
+            frame.save(image_io, "dib")
+
+            if bits != 32:
+                and_mask = Image.new("1", size)
+                ImageFile._save(
+                    and_mask, image_io, [("raw", (0, 0) + size, 0, ("1", 0, -1))]
+                )
+        else:
+            frame.save(image_io, "png")
+        image_io.seek(0)
+        image_bytes = image_io.read()
+        if bmp:
+            image_bytes = image_bytes[:8] + o32(height * 2) + image_bytes[12:]
+        bytes_len = len(image_bytes)
+        fp.write(o32(bytes_len))  # dwBytesInRes(4)
+        fp.write(o32(offset))  # dwImageOffset(4)
+        current = fp.tell()
+        fp.seek(offset)
+        fp.write(image_bytes)
+        offset = offset + bytes_len
+        fp.seek(current)
+
+
+def _accept(prefix):
+    return prefix[:4] == _MAGIC
+
+
+class IcoFile:
+    def __init__(self, buf):
+        """
+        Parse image from file-like object containing ico file data
+        """
+
+        # check magic
+        s = buf.read(6)
+        if not _accept(s):
+            raise SyntaxError("not an ICO file")
+
+        self.buf = buf
+        self.entry = []
+
+        # Number of items in file
+        self.nb_items = i16(s, 4)
+
+        # Get headers for each item
+        for i in range(self.nb_items):
+            s = buf.read(16)
+
+            icon_header = {
+                "width": s[0],
+                "height": s[1],
+                "nb_color": s[2],  # No. of colors in image (0 if >=8bpp)
+                "reserved": s[3],
+                "planes": i16(s, 4),
+                "bpp": i16(s, 6),
+                "size": i32(s, 8),
+                "offset": i32(s, 12),
+            }
+
+            # See Wikipedia
+            for j in ("width", "height"):
+                if not icon_header[j]:
+                    icon_header[j] = 256
+
+            # See Wikipedia notes about color depth.
+            # We need this just to differ images with equal sizes
+            icon_header["color_depth"] = (
+                icon_header["bpp"]
+                or (
+                    icon_header["nb_color"] != 0
+                    and ceil(log(icon_header["nb_color"], 2))
+                )
+                or 256
+            )
+
+            icon_header["dim"] = (icon_header["width"], icon_header["height"])
+            icon_header["square"] = icon_header["width"] * icon_header["height"]
+
+            self.entry.append(icon_header)
+
+        self.entry = sorted(self.entry, key=lambda x: x["color_depth"])
+        # ICO images are usually squares
+        # self.entry = sorted(self.entry, key=lambda x: x['width'])
+        self.entry = sorted(self.entry, key=lambda x: x["square"])
+        self.entry.reverse()
+
+    def sizes(self):
+        """
+        Get a list of all available icon sizes and color depths.
+        """
+        return {(h["width"], h["height"]) for h in self.entry}
+
+    def getentryindex(self, size, bpp=False):
+        for (i, h) in enumerate(self.entry):
+            if size == h["dim"] and (bpp is False or bpp == h["color_depth"]):
+                return i
+        return 0
+
+    def getimage(self, size, bpp=False):
+        """
+        Get an image from the icon
+        """
+        return self.frame(self.getentryindex(size, bpp))
+
+    def frame(self, idx):
+        """
+        Get an image from frame idx
+        """
+
+        header = self.entry[idx]
+
+        self.buf.seek(header["offset"])
+        data = self.buf.read(8)
+        self.buf.seek(header["offset"])
+
+        if data[:8] == PngImagePlugin._MAGIC:
+            # png frame
+            im = PngImagePlugin.PngImageFile(self.buf)
+            Image._decompression_bomb_check(im.size)
+        else:
+            # XOR + AND mask bmp frame
+            im = BmpImagePlugin.DibImageFile(self.buf)
+            Image._decompression_bomb_check(im.size)
+
+            # change tile dimension to only encompass XOR image
+            im._size = (im.size[0], int(im.size[1] / 2))
+            d, e, o, a = im.tile[0]
+            im.tile[0] = d, (0, 0) + im.size, o, a
+
+            # figure out where AND mask image starts
+            bpp = header["bpp"]
+            if 32 == bpp:
+                # 32-bit color depth icon image allows semitransparent areas
+                # PIL's DIB format ignores transparency bits, recover them.
+                # The DIB is packed in BGRX byte order where X is the alpha
+                # channel.
+
+                # Back up to start of bmp data
+                self.buf.seek(o)
+                # extract every 4th byte (eg. 3,7,11,15,...)
+                alpha_bytes = self.buf.read(im.size[0] * im.size[1] * 4)[3::4]
+
+                # convert to an 8bpp grayscale image
+                mask = Image.frombuffer(
+                    "L",  # 8bpp
+                    im.size,  # (w, h)
+                    alpha_bytes,  # source chars
+                    "raw",  # raw decoder
+                    ("L", 0, -1),  # 8bpp inverted, unpadded, reversed
+                )
+            else:
+                # get AND image from end of bitmap
+                w = im.size[0]
+                if (w % 32) > 0:
+                    # bitmap row data is aligned to word boundaries
+                    w += 32 - (im.size[0] % 32)
+
+                # the total mask data is
+                # padded row size * height / bits per char
+
+                total_bytes = int((w * im.size[1]) / 8)
+                and_mask_offset = header["offset"] + header["size"] - total_bytes
+
+                self.buf.seek(and_mask_offset)
+                mask_data = self.buf.read(total_bytes)
+
+                # convert raw data to image
+                mask = Image.frombuffer(
+                    "1",  # 1 bpp
+                    im.size,  # (w, h)
+                    mask_data,  # source chars
+                    "raw",  # raw decoder
+                    ("1;I", int(w / 8), -1),  # 1bpp inverted, padded, reversed
+                )
+
+                # now we have two images, im is XOR image and mask is AND image
+
+            # apply mask image as alpha channel
+            im = im.convert("RGBA")
+            im.putalpha(mask)
+
+        return im
+
+
+##
+# Image plugin for Windows Icon files.
+
+
+class IcoImageFile(ImageFile.ImageFile):
+    """
+    PIL read-only image support for Microsoft Windows .ico files.
+
+    By default the largest resolution image in the file will be loaded. This
+    can be changed by altering the 'size' attribute before calling 'load'.
+
+    The info dictionary has a key 'sizes' that is a list of the sizes available
+    in the icon file.
+
+    Handles classic, XP and Vista icon formats.
+
+    When saving, PNG compression is used. Support for this was only added in
+    Windows Vista. If you are unable to view the icon in Windows, convert the
+    image to "RGBA" mode before saving.
+
+    This plugin is a refactored version of Win32IconImagePlugin by Bryan Davis
+    <casadebender@gmail.com>.
+    https://code.google.com/archive/p/casadebender/wikis/Win32IconImagePlugin.wiki
+    """
+
+    format = "ICO"
+    format_description = "Windows Icon"
+
+    def _open(self):
+        self.ico = IcoFile(self.fp)
+        self.info["sizes"] = self.ico.sizes()
+        self.size = self.ico.entry[0]["dim"]
+        self.load()
+
+    @property
+    def size(self):
+        return self._size
+
+    @size.setter
+    def size(self, value):
+        if value not in self.info["sizes"]:
+            raise ValueError("This is not one of the allowed sizes of this image")
+        self._size = value
+
+    def load(self):
+        if self.im is not None and self.im.size == self.size:
+            # Already loaded
+            return Image.Image.load(self)
+        im = self.ico.getimage(self.size)
+        # if tile is PNG, it won't really be loaded yet
+        im.load()
+        self.im = im.im
+        self.mode = im.mode
+        if im.size != self.size:
+            warnings.warn("Image was not the expected size")
+
+            index = self.ico.getentryindex(self.size)
+            sizes = list(self.info["sizes"])
+            sizes[index] = im.size
+            self.info["sizes"] = set(sizes)
+
+            self.size = im.size
+
+    def load_seek(self):
+        # Flag the ImageFile.Parser so that it
+        # just does all the decode at the end.
+        pass
+
+
+#
+# --------------------------------------------------------------------
+
+
+Image.register_open(IcoImageFile.format, IcoImageFile, _accept)
+Image.register_save(IcoImageFile.format, _save)
+Image.register_extension(IcoImageFile.format, ".ico")
+
+Image.register_mime(IcoImageFile.format, "image/x-icon")

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/PIL/ImageChops.py

@@ -0,0 +1,328 @@
+#
+# The Python Imaging Library.
+# $Id$
+#
+# standard channel operations
+#
+# History:
+# 1996-03-24 fl   Created
+# 1996-08-13 fl   Added logical operations (for "1" images)
+# 2000-10-12 fl   Added offset method (from Image.py)
+#
+# Copyright (c) 1997-2000 by Secret Labs AB
+# Copyright (c) 1996-2000 by Fredrik Lundh
+#
+# See the README file for information on usage and redistribution.
+#
+
+from . import Image
+
+
+def constant(image, value):
+    """Fill a channel with a given grey level.
+
+    :rtype: :py:class:`~PIL.Image.Image`
+    """
+
+    return Image.new("L", image.size, value)
+
+
+def duplicate(image):
+    """Copy a channel. Alias for :py:meth:`PIL.Image.Image.copy`.
+
+    :rtype: :py:class:`~PIL.Image.Image`
+    """
+
+    return image.copy()
+
+
+def invert(image):
+    """
+    Invert an image (channel).
+
+    .. code-block:: python
+
+        out = MAX - image
+
+    :rtype: :py:class:`~PIL.Image.Image`
+    """
+
+    image.load()
+    return image._new(image.im.chop_invert())
+
+
+def lighter(image1, image2):
+    """
+    Compares the two images, pixel by pixel, and returns a new image containing
+    the lighter values.
+
+    .. code-block:: python
+
+        out = max(image1, image2)
+
+    :rtype: :py:class:`~PIL.Image.Image`
+    """
+
+    image1.load()
+    image2.load()
+    return image1._new(image1.im.chop_lighter(image2.im))
+
+
+def darker(image1, image2):
+    """
+    Compares the two images, pixel by pixel, and returns a new image containing
+    the darker values.
+
+    .. code-block:: python
+
+        out = min(image1, image2)
+
+    :rtype: :py:class:`~PIL.Image.Image`
+    """
+
+    image1.load()
+    image2.load()
+    return image1._new(image1.im.chop_darker(image2.im))
+
+
+def difference(image1, image2):
+    """
+    Returns the absolute value of the pixel-by-pixel difference between the two
+    images.
+
+    .. code-block:: python
+
+        out = abs(image1 - image2)
+
+    :rtype: :py:class:`~PIL.Image.Image`
+    """
+
+    image1.load()
+    image2.load()
+    return image1._new(image1.im.chop_difference(image2.im))
+
+
+def multiply(image1, image2):
+    """
+    Superimposes two images on top of each other.
+
+    If you multiply an image with a solid black image, the result is black. If
+    you multiply with a solid white image, the image is unaffected.
+
+    .. code-block:: python
+
+        out = image1 * image2 / MAX
+
+    :rtype: :py:class:`~PIL.Image.Image`
+    """
+
+    image1.load()
+    image2.load()
+    return image1._new(image1.im.chop_multiply(image2.im))
+
+
+def screen(image1, image2):
+    """
+    Superimposes two inverted images on top of each other.
+
+    .. code-block:: python
+
+        out = MAX - ((MAX - image1) * (MAX - image2) / MAX)
+
+    :rtype: :py:class:`~PIL.Image.Image`
+    """
+
+    image1.load()
+    image2.load()
+    return image1._new(image1.im.chop_screen(image2.im))
+
+
+def soft_light(image1, image2):
+    """
+    Superimposes two images on top of each other using the Soft Light algorithm
+
+    :rtype: :py:class:`~PIL.Image.Image`
+    """
+
+    image1.load()
+    image2.load()
+    return image1._new(image1.im.chop_soft_light(image2.im))
+
+
+def hard_light(image1, image2):
+    """
+    Superimposes two images on top of each other using the Hard Light algorithm
+
+    :rtype: :py:class:`~PIL.Image.Image`
+    """
+
+    image1.load()
+    image2.load()
+    return image1._new(image1.im.chop_hard_light(image2.im))
+
+
+def overlay(image1, image2):
+    """
+    Superimposes two images on top of each other using the Overlay algorithm
+
+    :rtype: :py:class:`~PIL.Image.Image`
+    """
+
+    image1.load()
+    image2.load()
+    return image1._new(image1.im.chop_overlay(image2.im))
+
+
+def add(image1, image2, scale=1.0, offset=0):
+    """
+    Adds two images, dividing the result by scale and adding the
+    offset. If omitted, scale defaults to 1.0, and offset to 0.0.
+
+    .. code-block:: python
+
+        out = ((image1 + image2) / scale + offset)
+
+    :rtype: :py:class:`~PIL.Image.Image`
+    """
+
+    image1.load()
+    image2.load()
+    return image1._new(image1.im.chop_add(image2.im, scale, offset))
+
+
+def subtract(image1, image2, scale=1.0, offset=0):
+    """
+    Subtracts two images, dividing the result by scale and adding the offset.
+    If omitted, scale defaults to 1.0, and offset to 0.0.
+
+    .. code-block:: python
+
+        out = ((image1 - image2) / scale + offset)
+
+    :rtype: :py:class:`~PIL.Image.Image`
+    """
+
+    image1.load()
+    image2.load()
+    return image1._new(image1.im.chop_subtract(image2.im, scale, offset))
+
+
+def add_modulo(image1, image2):
+    """Add two images, without clipping the result.
+
+    .. code-block:: python
+
+        out = ((image1 + image2) % MAX)
+
+    :rtype: :py:class:`~PIL.Image.Image`
+    """
+
+    image1.load()
+    image2.load()
+    return image1._new(image1.im.chop_add_modulo(image2.im))
+
+
+def subtract_modulo(image1, image2):
+    """Subtract two images, without clipping the result.
+
+    .. code-block:: python
+
+        out = ((image1 - image2) % MAX)
+
+    :rtype: :py:class:`~PIL.Image.Image`
+    """
+
+    image1.load()
+    image2.load()
+    return image1._new(image1.im.chop_subtract_modulo(image2.im))
+
+
+def logical_and(image1, image2):
+    """Logical AND between two images.
+
+    Both of the images must have mode "1". If you would like to perform a
+    logical AND on an image with a mode other than "1", try
+    :py:meth:`~PIL.ImageChops.multiply` instead, using a black-and-white mask
+    as the second image.
+
+    .. code-block:: python
+
+        out = ((image1 and image2) % MAX)
+
+    :rtype: :py:class:`~PIL.Image.Image`
+    """
+
+    image1.load()
+    image2.load()
+    return image1._new(image1.im.chop_and(image2.im))
+
+
+def logical_or(image1, image2):
+    """Logical OR between two images.
+
+    Both of the images must have mode "1".
+
+    .. code-block:: python
+
+        out = ((image1 or image2) % MAX)
+
+    :rtype: :py:class:`~PIL.Image.Image`
+    """
+
+    image1.load()
+    image2.load()
+    return image1._new(image1.im.chop_or(image2.im))
+
+
+def logical_xor(image1, image2):
+    """Logical XOR between two images.
+
+    Both of the images must have mode "1".
+
+    .. code-block:: python
+
+        out = ((bool(image1) != bool(image2)) % MAX)
+
+    :rtype: :py:class:`~PIL.Image.Image`
+    """
+
+    image1.load()
+    image2.load()
+    return image1._new(image1.im.chop_xor(image2.im))
+
+
+def blend(image1, image2, alpha):
+    """Blend images using constant transparency weight. Alias for
+    :py:func:`PIL.Image.blend`.
+
+    :rtype: :py:class:`~PIL.Image.Image`
+    """
+
+    return Image.blend(image1, image2, alpha)
+
+
+def composite(image1, image2, mask):
+    """Create composite using transparency mask. Alias for
+    :py:func:`PIL.Image.composite`.
+
+    :rtype: :py:class:`~PIL.Image.Image`
+    """
+
+    return Image.composite(image1, image2, mask)
+
+
+def offset(image, xoffset, yoffset=None):
+    """Returns a copy of the image where data has been offset by the given
+    distances. Data wraps around the edges. If ``yoffset`` is omitted, it
+    is assumed to be equal to ``xoffset``.
+
+    :param xoffset: The horizontal distance.
+    :param yoffset: The vertical distance.  If omitted, both
+        distances are set to the same value.
+    :rtype: :py:class:`~PIL.Image.Image`
+    """
+
+    if yoffset is None:
+        yoffset = xoffset
+    image.load()
+    return image._new(image.im.offset(xoffset, yoffset))

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/PIL/ImageColor.py

@@ -0,0 +1,302 @@
+#
+# The Python Imaging Library
+# $Id$
+#
+# map CSS3-style colour description strings to RGB
+#
+# History:
+# 2002-10-24 fl   Added support for CSS-style color strings
+# 2002-12-15 fl   Added RGBA support
+# 2004-03-27 fl   Fixed remaining int() problems for Python 1.5.2
+# 2004-07-19 fl   Fixed gray/grey spelling issues
+# 2009-03-05 fl   Fixed rounding error in grayscale calculation
+#
+# Copyright (c) 2002-2004 by Secret Labs AB
+# Copyright (c) 2002-2004 by Fredrik Lundh
+#
+# See the README file for information on usage and redistribution.
+#
+
+import re
+
+from . import Image
+
+
+def getrgb(color):
+    """
+     Convert a color string to an RGB or RGBA tuple. If the string cannot be
+     parsed, this function raises a :py:exc:`ValueError` exception.
+
+    .. versionadded:: 1.1.4
+
+    :param color: A color string
+    :return: ``(red, green, blue[, alpha])``
+    """
+    if len(color) > 100:
+        raise ValueError("color specifier is too long")
+    color = color.lower()
+
+    rgb = colormap.get(color, None)
+    if rgb:
+        if isinstance(rgb, tuple):
+            return rgb
+        colormap[color] = rgb = getrgb(rgb)
+        return rgb
+
+    # check for known string formats
+    if re.match("#[a-f0-9]{3}$", color):
+        return (int(color[1] * 2, 16), int(color[2] * 2, 16), int(color[3] * 2, 16))
+
+    if re.match("#[a-f0-9]{4}$", color):
+        return (
+            int(color[1] * 2, 16),
+            int(color[2] * 2, 16),
+            int(color[3] * 2, 16),
+            int(color[4] * 2, 16),
+        )
+
+    if re.match("#[a-f0-9]{6}$", color):
+        return (int(color[1:3], 16), int(color[3:5], 16), int(color[5:7], 16))
+
+    if re.match("#[a-f0-9]{8}$", color):
+        return (
+            int(color[1:3], 16),
+            int(color[3:5], 16),
+            int(color[5:7], 16),
+            int(color[7:9], 16),
+        )
+
+    m = re.match(r"rgb\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\)$", color)
+    if m:
+        return (int(m.group(1)), int(m.group(2)), int(m.group(3)))
+
+    m = re.match(r"rgb\(\s*(\d+)%\s*,\s*(\d+)%\s*,\s*(\d+)%\s*\)$", color)
+    if m:
+        return (
+            int((int(m.group(1)) * 255) / 100.0 + 0.5),
+            int((int(m.group(2)) * 255) / 100.0 + 0.5),
+            int((int(m.group(3)) * 255) / 100.0 + 0.5),
+        )
+
+    m = re.match(
+        r"hsl\(\s*(\d+\.?\d*)\s*,\s*(\d+\.?\d*)%\s*,\s*(\d+\.?\d*)%\s*\)$", color
+    )
+    if m:
+        from colorsys import hls_to_rgb
+
+        rgb = hls_to_rgb(
+            float(m.group(1)) / 360.0,
+            float(m.group(3)) / 100.0,
+            float(m.group(2)) / 100.0,
+        )
+        return (
+            int(rgb[0] * 255 + 0.5),
+            int(rgb[1] * 255 + 0.5),
+            int(rgb[2] * 255 + 0.5),
+        )
+
+    m = re.match(
+        r"hs[bv]\(\s*(\d+\.?\d*)\s*,\s*(\d+\.?\d*)%\s*,\s*(\d+\.?\d*)%\s*\)$", color
+    )
+    if m:
+        from colorsys import hsv_to_rgb
+
+        rgb = hsv_to_rgb(
+            float(m.group(1)) / 360.0,
+            float(m.group(2)) / 100.0,
+            float(m.group(3)) / 100.0,
+        )
+        return (
+            int(rgb[0] * 255 + 0.5),
+            int(rgb[1] * 255 + 0.5),
+            int(rgb[2] * 255 + 0.5),
+        )
+
+    m = re.match(r"rgba\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\)$", color)
+    if m:
+        return (int(m.group(1)), int(m.group(2)), int(m.group(3)), int(m.group(4)))
+    raise ValueError(f"unknown color specifier: {repr(color)}")
+
+
+def getcolor(color, mode):
+    """
+    Same as :py:func:`~PIL.ImageColor.getrgb`, but converts the RGB value to a
+    greyscale value if the mode is not color or a palette image. If the string
+    cannot be parsed, this function raises a :py:exc:`ValueError` exception.
+
+    .. versionadded:: 1.1.4
+
+    :param color: A color string
+    :return: ``(graylevel [, alpha]) or (red, green, blue[, alpha])``
+    """
+    # same as getrgb, but converts the result to the given mode
+    color, alpha = getrgb(color), 255
+    if len(color) == 4:
+        color, alpha = color[0:3], color[3]
+
+    if Image.getmodebase(mode) == "L":
+        r, g, b = color
+        # ITU-R Recommendation 601-2 for nonlinear RGB
+        # scaled to 24 bits to match the convert's implementation.
+        color = (r * 19595 + g * 38470 + b * 7471 + 0x8000) >> 16
+        if mode[-1] == "A":
+            return (color, alpha)
+    else:
+        if mode[-1] == "A":
+            return color + (alpha,)
+    return color
+
+
+colormap = {
+    # X11 colour table from https://drafts.csswg.org/css-color-4/, with
+    # gray/grey spelling issues fixed.  This is a superset of HTML 4.0
+    # colour names used in CSS 1.
+    "aliceblue": "#f0f8ff",
+    "antiquewhite": "#faebd7",
+    "aqua": "#00ffff",
+    "aquamarine": "#7fffd4",
+    "azure": "#f0ffff",
+    "beige": "#f5f5dc",
+    "bisque": "#ffe4c4",
+    "black": "#000000",
+    "blanchedalmond": "#ffebcd",
+    "blue": "#0000ff",
+    "blueviolet": "#8a2be2",
+    "brown": "#a52a2a",
+    "burlywood": "#deb887",
+    "cadetblue": "#5f9ea0",
+    "chartreuse": "#7fff00",
+    "chocolate": "#d2691e",
+    "coral": "#ff7f50",
+    "cornflowerblue": "#6495ed",
+    "cornsilk": "#fff8dc",
+    "crimson": "#dc143c",
+    "cyan": "#00ffff",
+    "darkblue": "#00008b",
+    "darkcyan": "#008b8b",
+    "darkgoldenrod": "#b8860b",
+    "darkgray": "#a9a9a9",
+    "darkgrey": "#a9a9a9",
+    "darkgreen": "#006400",
+    "darkkhaki": "#bdb76b",
+    "darkmagenta": "#8b008b",
+    "darkolivegreen": "#556b2f",
+    "darkorange": "#ff8c00",
+    "darkorchid": "#9932cc",
+    "darkred": "#8b0000",
+    "darksalmon": "#e9967a",
+    "darkseagreen": "#8fbc8f",
+    "darkslateblue": "#483d8b",
+    "darkslategray": "#2f4f4f",
+    "darkslategrey": "#2f4f4f",
+    "darkturquoise": "#00ced1",
+    "darkviolet": "#9400d3",
+    "deeppink": "#ff1493",
+    "deepskyblue": "#00bfff",
+    "dimgray": "#696969",
+    "dimgrey": "#696969",
+    "dodgerblue": "#1e90ff",
+    "firebrick": "#b22222",
+    "floralwhite": "#fffaf0",
+    "forestgreen": "#228b22",
+    "fuchsia": "#ff00ff",
+    "gainsboro": "#dcdcdc",
+    "ghostwhite": "#f8f8ff",
+    "gold": "#ffd700",
+    "goldenrod": "#daa520",
+    "gray": "#808080",
+    "grey": "#808080",
+    "green": "#008000",
+    "greenyellow": "#adff2f",
+    "honeydew": "#f0fff0",
+    "hotpink": "#ff69b4",
+    "indianred": "#cd5c5c",
+    "indigo": "#4b0082",
+    "ivory": "#fffff0",
+    "khaki": "#f0e68c",
+    "lavender": "#e6e6fa",
+    "lavenderblush": "#fff0f5",
+    "lawngreen": "#7cfc00",
+    "lemonchiffon": "#fffacd",
+    "lightblue": "#add8e6",
+    "lightcoral": "#f08080",
+    "lightcyan": "#e0ffff",
+    "lightgoldenrodyellow": "#fafad2",
+    "lightgreen": "#90ee90",
+    "lightgray": "#d3d3d3",
+    "lightgrey": "#d3d3d3",
+    "lightpink": "#ffb6c1",
+    "lightsalmon": "#ffa07a",
+    "lightseagreen": "#20b2aa",
+    "lightskyblue": "#87cefa",
+    "lightslategray": "#778899",
+    "lightslategrey": "#778899",
+    "lightsteelblue": "#b0c4de",
+    "lightyellow": "#ffffe0",
+    "lime": "#00ff00",
+    "limegreen": "#32cd32",
+    "linen": "#faf0e6",
+    "magenta": "#ff00ff",
+    "maroon": "#800000",
+    "mediumaquamarine": "#66cdaa",
+    "mediumblue": "#0000cd",
+    "mediumorchid": "#ba55d3",
+    "mediumpurple": "#9370db",
+    "mediumseagreen": "#3cb371",
+    "mediumslateblue": "#7b68ee",
+    "mediumspringgreen": "#00fa9a",
+    "mediumturquoise": "#48d1cc",
+    "mediumvioletred": "#c71585",
+    "midnightblue": "#191970",
+    "mintcream": "#f5fffa",
+    "mistyrose": "#ffe4e1",
+    "moccasin": "#ffe4b5",
+    "navajowhite": "#ffdead",
+    "navy": "#000080",
+    "oldlace": "#fdf5e6",
+    "olive": "#808000",
+    "olivedrab": "#6b8e23",
+    "orange": "#ffa500",
+    "orangered": "#ff4500",
+    "orchid": "#da70d6",
+    "palegoldenrod": "#eee8aa",
+    "palegreen": "#98fb98",
+    "paleturquoise": "#afeeee",
+    "palevioletred": "#db7093",
+    "papayawhip": "#ffefd5",
+    "peachpuff": "#ffdab9",
+    "peru": "#cd853f",
+    "pink": "#ffc0cb",
+    "plum": "#dda0dd",
+    "powderblue": "#b0e0e6",
+    "purple": "#800080",
+    "rebeccapurple": "#663399",
+    "red": "#ff0000",
+    "rosybrown": "#bc8f8f",
+    "royalblue": "#4169e1",
+    "saddlebrown": "#8b4513",
+    "salmon": "#fa8072",
+    "sandybrown": "#f4a460",
+    "seagreen": "#2e8b57",
+    "seashell": "#fff5ee",
+    "sienna": "#a0522d",
+    "silver": "#c0c0c0",
+    "skyblue": "#87ceeb",
+    "slateblue": "#6a5acd",
+    "slategray": "#708090",
+    "slategrey": "#708090",
+    "snow": "#fffafa",
+    "springgreen": "#00ff7f",
+    "steelblue": "#4682b4",
+    "tan": "#d2b48c",
+    "teal": "#008080",
+    "thistle": "#d8bfd8",
+    "tomato": "#ff6347",
+    "turquoise": "#40e0d0",
+    "violet": "#ee82ee",
+    "wheat": "#f5deb3",
+    "white": "#ffffff",
+    "whitesmoke": "#f5f5f5",
+    "yellow": "#ffff00",
+    "yellowgreen": "#9acd32",
+}

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/PIL/ImageDraw2.py

@@ -0,0 +1,179 @@
+#
+# The Python Imaging Library
+# $Id$
+#
+# WCK-style drawing interface operations
+#
+# History:
+# 2003-12-07 fl   created
+# 2005-05-15 fl   updated; added to PIL as ImageDraw2
+# 2005-05-15 fl   added text support
+# 2005-05-20 fl   added arc/chord/pieslice support
+#
+# Copyright (c) 2003-2005 by Secret Labs AB
+# Copyright (c) 2003-2005 by Fredrik Lundh
+#
+# See the README file for information on usage and redistribution.
+#
+
+
+"""
+(Experimental) WCK-style drawing interface operations
+
+.. seealso:: :py:mod:`PIL.ImageDraw`
+"""
+
+
+from . import Image, ImageColor, ImageDraw, ImageFont, ImagePath
+
+
+class Pen:
+    """Stores an outline color and width."""
+
+    def __init__(self, color, width=1, opacity=255):
+        self.color = ImageColor.getrgb(color)
+        self.width = width
+
+
+class Brush:
+    """Stores a fill color"""
+
+    def __init__(self, color, opacity=255):
+        self.color = ImageColor.getrgb(color)
+
+
+class Font:
+    """Stores a TrueType font and color"""
+
+    def __init__(self, color, file, size=12):
+        # FIXME: add support for bitmap fonts
+        self.color = ImageColor.getrgb(color)
+        self.font = ImageFont.truetype(file, size)
+
+
+class Draw:
+    """
+    (Experimental) WCK-style drawing interface
+    """
+
+    def __init__(self, image, size=None, color=None):
+        if not hasattr(image, "im"):
+            image = Image.new(image, size, color)
+        self.draw = ImageDraw.Draw(image)
+        self.image = image
+        self.transform = None
+
+    def flush(self):
+        return self.image
+
+    def render(self, op, xy, pen, brush=None):
+        # handle color arguments
+        outline = fill = None
+        width = 1
+        if isinstance(pen, Pen):
+            outline = pen.color
+            width = pen.width
+        elif isinstance(brush, Pen):
+            outline = brush.color
+            width = brush.width
+        if isinstance(brush, Brush):
+            fill = brush.color
+        elif isinstance(pen, Brush):
+            fill = pen.color
+        # handle transformation
+        if self.transform:
+            xy = ImagePath.Path(xy)
+            xy.transform(self.transform)
+        # render the item
+        if op == "line":
+            self.draw.line(xy, fill=outline, width=width)
+        else:
+            getattr(self.draw, op)(xy, fill=fill, outline=outline)
+
+    def settransform(self, offset):
+        """Sets a transformation offset."""
+        (xoffset, yoffset) = offset
+        self.transform = (1, 0, xoffset, 0, 1, yoffset)
+
+    def arc(self, xy, start, end, *options):
+        """
+        Draws an arc (a portion of a circle outline) between the start and end
+        angles, inside the given bounding box.
+
+        .. seealso:: :py:meth:`PIL.ImageDraw.ImageDraw.arc`
+        """
+        self.render("arc", xy, start, end, *options)
+
+    def chord(self, xy, start, end, *options):
+        """
+        Same as :py:meth:`~PIL.ImageDraw2.Draw.arc`, but connects the end points
+        with a straight line.
+
+        .. seealso:: :py:meth:`PIL.ImageDraw.ImageDraw.chord`
+        """
+        self.render("chord", xy, start, end, *options)
+
+    def ellipse(self, xy, *options):
+        """
+        Draws an ellipse inside the given bounding box.
+
+        .. seealso:: :py:meth:`PIL.ImageDraw.ImageDraw.ellipse`
+        """
+        self.render("ellipse", xy, *options)
+
+    def line(self, xy, *options):
+        """
+        Draws a line between the coordinates in the ``xy`` list.
+
+        .. seealso:: :py:meth:`PIL.ImageDraw.ImageDraw.line`
+        """
+        self.render("line", xy, *options)
+
+    def pieslice(self, xy, start, end, *options):
+        """
+        Same as arc, but also draws straight lines between the end points and the
+        center of the bounding box.
+
+        .. seealso:: :py:meth:`PIL.ImageDraw.ImageDraw.pieslice`
+        """
+        self.render("pieslice", xy, start, end, *options)
+
+    def polygon(self, xy, *options):
+        """
+        Draws a polygon.
+
+        The polygon outline consists of straight lines between the given
+        coordinates, plus a straight line between the last and the first
+        coordinate.
+
+
+        .. seealso:: :py:meth:`PIL.ImageDraw.ImageDraw.polygon`
+        """
+        self.render("polygon", xy, *options)
+
+    def rectangle(self, xy, *options):
+        """
+        Draws a rectangle.
+
+        .. seealso:: :py:meth:`PIL.ImageDraw.ImageDraw.rectangle`
+        """
+        self.render("rectangle", xy, *options)
+
+    def text(self, xy, text, font):
+        """
+        Draws the string at the given position.
+
+        .. seealso:: :py:meth:`PIL.ImageDraw.ImageDraw.text`
+        """
+        if self.transform:
+            xy = ImagePath.Path(xy)
+            xy.transform(self.transform)
+        self.draw.text(xy, text, font=font.font, fill=font.color)
+
+    def textsize(self, text, font):
+        """
+        Return the size of the given string, in pixels.
+
+        .. seealso:: :py:meth:`PIL.ImageDraw.ImageDraw.textsize`
+        """
+        return self.draw.textsize(text, font=font.font)

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/PIL/ImageEnhance.py

@@ -0,0 +1,103 @@
+#
+# The Python Imaging Library.
+# $Id$
+#
+# image enhancement classes
+#
+# For a background, see "Image Processing By Interpolation and
+# Extrapolation", Paul Haeberli and Douglas Voorhies.  Available
+# at http://www.graficaobscura.com/interp/index.html
+#
+# History:
+# 1996-03-23 fl  Created
+# 2009-06-16 fl  Fixed mean calculation
+#
+# Copyright (c) Secret Labs AB 1997.
+# Copyright (c) Fredrik Lundh 1996.
+#
+# See the README file for information on usage and redistribution.
+#
+
+from . import Image, ImageFilter, ImageStat
+
+
+class _Enhance:
+    def enhance(self, factor):
+        """
+        Returns an enhanced image.
+
+        :param factor: A floating point value controlling the enhancement.
+                       Factor 1.0 always returns a copy of the original image,
+                       lower factors mean less color (brightness, contrast,
+                       etc), and higher values more. There are no restrictions
+                       on this value.
+        :rtype: :py:class:`~PIL.Image.Image`
+        """
+        return Image.blend(self.degenerate, self.image, factor)
+
+
+class Color(_Enhance):
+    """Adjust image color balance.
+
+    This class can be used to adjust the colour balance of an image, in
+    a manner similar to the controls on a colour TV set. An enhancement
+    factor of 0.0 gives a black and white image. A factor of 1.0 gives
+    the original image.
+    """
+
+    def __init__(self, image):
+        self.image = image
+        self.intermediate_mode = "L"
+        if "A" in image.getbands():
+            self.intermediate_mode = "LA"
+
+        self.degenerate = image.convert(self.intermediate_mode).convert(image.mode)
+
+
+class Contrast(_Enhance):
+    """Adjust image contrast.
+
+    This class can be used to control the contrast of an image, similar
+    to the contrast control on a TV set. An enhancement factor of 0.0
+    gives a solid grey image. A factor of 1.0 gives the original image.
+    """
+
+    def __init__(self, image):
+        self.image = image
+        mean = int(ImageStat.Stat(image.convert("L")).mean[0] + 0.5)
+        self.degenerate = Image.new("L", image.size, mean).convert(image.mode)
+
+        if "A" in image.getbands():
+            self.degenerate.putalpha(image.getchannel("A"))
+
+
+class Brightness(_Enhance):
+    """Adjust image brightness.
+
+    This class can be used to control the brightness of an image.  An
+    enhancement factor of 0.0 gives a black image. A factor of 1.0 gives the
+    original image.
+    """
+
+    def __init__(self, image):
+        self.image = image
+        self.degenerate = Image.new(image.mode, image.size, 0)
+
+        if "A" in image.getbands():
+            self.degenerate.putalpha(image.getchannel("A"))
+
+
+class Sharpness(_Enhance):
+    """Adjust image sharpness.
+
+    This class can be used to adjust the sharpness of an image. An
+    enhancement factor of 0.0 gives a blurred image, a factor of 1.0 gives the
+    original image, and a factor of 2.0 gives a sharpened image.
+    """
+
+    def __init__(self, image):
+        self.image = image
+        self.degenerate = image.filter(ImageFilter.SMOOTH)
+
+        if "A" in image.getbands():
+            self.degenerate.putalpha(image.getchannel("A"))

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/PIL/ImageFile.py

@@ -0,0 +1,748 @@
+#
+# The Python Imaging Library.
+# $Id$
+#
+# base class for image file handlers
+#
+# history:
+# 1995-09-09 fl   Created
+# 1996-03-11 fl   Fixed load mechanism.
+# 1996-04-15 fl   Added pcx/xbm decoders.
+# 1996-04-30 fl   Added encoders.
+# 1996-12-14 fl   Added load helpers
+# 1997-01-11 fl   Use encode_to_file where possible
+# 1997-08-27 fl   Flush output in _save
+# 1998-03-05 fl   Use memory mapping for some modes
+# 1999-02-04 fl   Use memory mapping also for "I;16" and "I;16B"
+# 1999-05-31 fl   Added image parser
+# 2000-10-12 fl   Set readonly flag on memory-mapped images
+# 2002-03-20 fl   Use better messages for common decoder errors
+# 2003-04-21 fl   Fall back on mmap/map_buffer if map is not available
+# 2003-10-30 fl   Added StubImageFile class
+# 2004-02-25 fl   Made incremental parser more robust
+#
+# Copyright (c) 1997-2004 by Secret Labs AB
+# Copyright (c) 1995-2004 by Fredrik Lundh
+#
+# See the README file for information on usage and redistribution.
+#
+
+import io
+import itertools
+import struct
+import sys
+
+from . import Image
+from ._util import isPath
+
+MAXBLOCK = 65536
+
+SAFEBLOCK = 1024 * 1024
+
+LOAD_TRUNCATED_IMAGES = False
+"""Whether or not to load truncated image files. User code may change this."""
+
+ERRORS = {
+    -1: "image buffer overrun error",
+    -2: "decoding error",
+    -3: "unknown error",
+    -8: "bad configuration",
+    -9: "out of memory error",
+}
+"""
+Dict of known error codes returned from :meth:`.PyDecoder.decode`,
+:meth:`.PyEncoder.encode` :meth:`.PyEncoder.encode_to_pyfd` and
+:meth:`.PyEncoder.encode_to_file`.
+"""
+
+
+#
+# --------------------------------------------------------------------
+# Helpers
+
+
+def raise_oserror(error):
+    try:
+        message = Image.core.getcodecstatus(error)
+    except AttributeError:
+        message = ERRORS.get(error)
+    if not message:
+        message = f"decoder error {error}"
+    raise OSError(message + " when reading image file")
+
+
+def _tilesort(t):
+    # sort on offset
+    return t[2]
+
+
+#
+# --------------------------------------------------------------------
+# ImageFile base class
+
+
+class ImageFile(Image.Image):
+    """Base class for image file format handlers."""
+
+    def __init__(self, fp=None, filename=None):
+        super().__init__()
+
+        self._min_frame = 0
+
+        self.custom_mimetype = None
+
+        self.tile = None
+        """ A list of tile descriptors, or ``None`` """
+
+        self.readonly = 1  # until we know better
+
+        self.decoderconfig = ()
+        self.decodermaxblock = MAXBLOCK
+
+        if isPath(fp):
+            # filename
+            self.fp = open(fp, "rb")
+            self.filename = fp
+            self._exclusive_fp = True
+        else:
+            # stream
+            self.fp = fp
+            self.filename = filename
+            # can be overridden
+            self._exclusive_fp = None
+
+        try:
+            try:
+                self._open()
+            except (
+                IndexError,  # end of data
+                TypeError,  # end of data (ord)
+                KeyError,  # unsupported mode
+                EOFError,  # got header but not the first frame
+                struct.error,
+            ) as v:
+                raise SyntaxError(v) from v
+
+            if not self.mode or self.size[0] <= 0 or self.size[1] <= 0:
+                raise SyntaxError("not identified by this driver")
+        except BaseException:
+            # close the file only if we have opened it this constructor
+            if self._exclusive_fp:
+                self.fp.close()
+            raise
+
+    def get_format_mimetype(self):
+        if self.custom_mimetype:
+            return self.custom_mimetype
+        if self.format is not None:
+            return Image.MIME.get(self.format.upper())
+
+    def verify(self):
+        """Check file integrity"""
+
+        # raise exception if something's wrong.  must be called
+        # directly after open, and closes file when finished.
+        if self._exclusive_fp:
+            self.fp.close()
+        self.fp = None
+
+    def load(self):
+        """Load image data based on tile list"""
+
+        if self.tile is None:
+            raise OSError("cannot load this image")
+
+        pixel = Image.Image.load(self)
+        if not self.tile:
+            return pixel
+
+        self.map = None
+        use_mmap = self.filename and len(self.tile) == 1
+        # As of pypy 2.1.0, memory mapping was failing here.
+        use_mmap = use_mmap and not hasattr(sys, "pypy_version_info")
+
+        readonly = 0
+
+        # look for read/seek overrides
+        try:
+            read = self.load_read
+            # don't use mmap if there are custom read/seek functions
+            use_mmap = False
+        except AttributeError:
+            read = self.fp.read
+
+        try:
+            seek = self.load_seek
+            use_mmap = False
+        except AttributeError:
+            seek = self.fp.seek
+
+        if use_mmap:
+            # try memory mapping
+            decoder_name, extents, offset, args = self.tile[0]
+            if (
+                decoder_name == "raw"
+                and len(args) >= 3
+                and args[0] == self.mode
+                and args[0] in Image._MAPMODES
+            ):
+                try:
+                    # use mmap, if possible
+                    import mmap
+
+                    with open(self.filename) as fp:
+                        self.map = mmap.mmap(fp.fileno(), 0, access=mmap.ACCESS_READ)
+                    self.im = Image.core.map_buffer(
+                        self.map, self.size, decoder_name, offset, args
+                    )
+                    readonly = 1
+                    # After trashing self.im,
+                    # we might need to reload the palette data.
+                    if self.palette:
+                        self.palette.dirty = 1
+                except (AttributeError, OSError, ImportError):
+                    self.map = None
+
+        self.load_prepare()
+        err_code = -3  # initialize to unknown error
+        if not self.map:
+            # sort tiles in file order
+            self.tile.sort(key=_tilesort)
+
+            try:
+                # FIXME: This is a hack to handle TIFF's JpegTables tag.
+                prefix = self.tile_prefix
+            except AttributeError:
+                prefix = b""
+
+            # Remove consecutive duplicates that only differ by their offset
+            self.tile = [
+                list(tiles)[-1]
+                for _, tiles in itertools.groupby(
+                    self.tile, lambda tile: (tile[0], tile[1], tile[3])
+                )
+            ]
+            for decoder_name, extents, offset, args in self.tile:
+                seek(offset)
+                decoder = Image._getdecoder(
+                    self.mode, decoder_name, args, self.decoderconfig
+                )
+                try:
+                    decoder.setimage(self.im, extents)
+                    if decoder.pulls_fd:
+                        decoder.setfd(self.fp)
+                        err_code = decoder.decode(b"")[1]
+                    else:
+                        b = prefix
+                        while True:
+                            try:
+                                s = read(self.decodermaxblock)
+                            except (IndexError, struct.error) as e:
+                                # truncated png/gif
+                                if LOAD_TRUNCATED_IMAGES:
+                                    break
+                                else:
+                                    raise OSError("image file is truncated") from e
+
+                            if not s:  # truncated jpeg
+                                if LOAD_TRUNCATED_IMAGES:
+                                    break
+                                else:
+                                    raise OSError(
+                                        "image file is truncated "
+                                        f"({len(b)} bytes not processed)"
+                                    )
+
+                            b = b + s
+                            n, err_code = decoder.decode(b)
+                            if n < 0:
+                                break
+                            b = b[n:]
+                finally:
+                    # Need to cleanup here to prevent leaks
+                    decoder.cleanup()
+
+        self.tile = []
+        self.readonly = readonly
+
+        self.load_end()
+
+        if self._exclusive_fp and self._close_exclusive_fp_after_loading:
+            self.fp.close()
+        self.fp = None
+
+        if not self.map and not LOAD_TRUNCATED_IMAGES and err_code < 0:
+            # still raised if decoder fails to return anything
+            raise_oserror(err_code)
+
+        return Image.Image.load(self)
+
+    def load_prepare(self):
+        # create image memory if necessary
+        if not self.im or self.im.mode != self.mode or self.im.size != self.size:
+            self.im = Image.core.new(self.mode, self.size)
+        # create palette (optional)
+        if self.mode == "P":
+            Image.Image.load(self)
+
+    def load_end(self):
+        # may be overridden
+        pass
+
+    # may be defined for contained formats
+    # def load_seek(self, pos):
+    #     pass
+
+    # may be defined for blocked formats (e.g. PNG)
+    # def load_read(self, bytes):
+    #     pass
+
+    def _seek_check(self, frame):
+        if (
+            frame < self._min_frame
+            # Only check upper limit on frames if additional seek operations
+            # are not required to do so
+            or (
+                not (hasattr(self, "_n_frames") and self._n_frames is None)
+                and frame >= self.n_frames + self._min_frame
+            )
+        ):
+            raise EOFError("attempt to seek outside sequence")
+
+        return self.tell() != frame
+
+
+class StubImageFile(ImageFile):
+    """
+    Base class for stub image loaders.
+
+    A stub loader is an image loader that can identify files of a
+    certain format, but relies on external code to load the file.
+    """
+
+    def _open(self):
+        raise NotImplementedError("StubImageFile subclass must implement _open")
+
+    def load(self):
+        loader = self._load()
+        if loader is None:
+            raise OSError(f"cannot find loader for this {self.format} file")
+        image = loader.load(self)
+        assert image is not None
+        # become the other object (!)
+        self.__class__ = image.__class__
+        self.__dict__ = image.__dict__
+        return image.load()
+
+    def _load(self):
+        """(Hook) Find actual image loader."""
+        raise NotImplementedError("StubImageFile subclass must implement _load")
+
+
+class Parser:
+    """
+    Incremental image parser.  This class implements the standard
+    feed/close consumer interface.
+    """
+
+    incremental = None
+    image = None
+    data = None
+    decoder = None
+    offset = 0
+    finished = 0
+
+    def reset(self):
+        """
+        (Consumer) Reset the parser.  Note that you can only call this
+        method immediately after you've created a parser; parser
+        instances cannot be reused.
+        """
+        assert self.data is None, "cannot reuse parsers"
+
+    def feed(self, data):
+        """
+        (Consumer) Feed data to the parser.
+
+        :param data: A string buffer.
+        :exception OSError: If the parser failed to parse the image file.
+        """
+        # collect data
+
+        if self.finished:
+            return
+
+        if self.data is None:
+            self.data = data
+        else:
+            self.data = self.data + data
+
+        # parse what we have
+        if self.decoder:
+
+            if self.offset > 0:
+                # skip header
+                skip = min(len(self.data), self.offset)
+                self.data = self.data[skip:]
+                self.offset = self.offset - skip
+                if self.offset > 0 or not self.data:
+                    return
+
+            n, e = self.decoder.decode(self.data)
+
+            if n < 0:
+                # end of stream
+                self.data = None
+                self.finished = 1
+                if e < 0:
+                    # decoding error
+                    self.image = None
+                    raise_oserror(e)
+                else:
+                    # end of image
+                    return
+            self.data = self.data[n:]
+
+        elif self.image:
+
+            # if we end up here with no decoder, this file cannot
+            # be incrementally parsed.  wait until we've gotten all
+            # available data
+            pass
+
+        else:
+
+            # attempt to open this file
+            try:
+                with io.BytesIO(self.data) as fp:
+                    im = Image.open(fp)
+            except OSError:
+                # traceback.print_exc()
+                pass  # not enough data
+            else:
+                flag = hasattr(im, "load_seek") or hasattr(im, "load_read")
+                if flag or len(im.tile) != 1:
+                    # custom load code, or multiple tiles
+                    self.decode = None
+                else:
+                    # initialize decoder
+                    im.load_prepare()
+                    d, e, o, a = im.tile[0]
+                    im.tile = []
+                    self.decoder = Image._getdecoder(im.mode, d, a, im.decoderconfig)
+                    self.decoder.setimage(im.im, e)
+
+                    # calculate decoder offset
+                    self.offset = o
+                    if self.offset <= len(self.data):
+                        self.data = self.data[self.offset :]
+                        self.offset = 0
+
+                self.image = im
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *args):
+        self.close()
+
+    def close(self):
+        """
+        (Consumer) Close the stream.
+
+        :returns: An image object.
+        :exception OSError: If the parser failed to parse the image file either
+                            because it cannot be identified or cannot be
+                            decoded.
+        """
+        # finish decoding
+        if self.decoder:
+            # get rid of what's left in the buffers
+            self.feed(b"")
+            self.data = self.decoder = None
+            if not self.finished:
+                raise OSError("image was incomplete")
+        if not self.image:
+            raise OSError("cannot parse this image")
+        if self.data:
+            # incremental parsing not possible; reopen the file
+            # not that we have all data
+            with io.BytesIO(self.data) as fp:
+                try:
+                    self.image = Image.open(fp)
+                finally:
+                    self.image.load()
+        return self.image
+
+
+# --------------------------------------------------------------------
+
+
+def _save(im, fp, tile, bufsize=0):
+    """Helper to save image based on tile list
+
+    :param im: Image object.
+    :param fp: File object.
+    :param tile: Tile list.
+    :param bufsize: Optional buffer size
+    """
+
+    im.load()
+    if not hasattr(im, "encoderconfig"):
+        im.encoderconfig = ()
+    tile.sort(key=_tilesort)
+    # FIXME: make MAXBLOCK a configuration parameter
+    # It would be great if we could have the encoder specify what it needs
+    # But, it would need at least the image size in most cases. RawEncode is
+    # a tricky case.
+    bufsize = max(MAXBLOCK, bufsize, im.size[0] * 4)  # see RawEncode.c
+    try:
+        fh = fp.fileno()
+        fp.flush()
+        exc = None
+    except (AttributeError, io.UnsupportedOperation) as e:
+        exc = e
+    for e, b, o, a in tile:
+        if o > 0:
+            fp.seek(o)
+        encoder = Image._getencoder(im.mode, e, a, im.encoderconfig)
+        try:
+            encoder.setimage(im.im, b)
+            if encoder.pushes_fd:
+                encoder.setfd(fp)
+                l, s = encoder.encode_to_pyfd()
+            else:
+                if exc:
+                    # compress to Python file-compatible object
+                    while True:
+                        l, s, d = encoder.encode(bufsize)
+                        fp.write(d)
+                        if s:
+                            break
+                else:
+                    # slight speedup: compress to real file object
+                    s = encoder.encode_to_file(fh, bufsize)
+            if s < 0:
+                raise OSError(f"encoder error {s} when writing image file") from exc
+        finally:
+            encoder.cleanup()
+    if hasattr(fp, "flush"):
+        fp.flush()
+
+
+def _safe_read(fp, size):
+    """
+    Reads large blocks in a safe way.  Unlike fp.read(n), this function
+    doesn't trust the user.  If the requested size is larger than
+    SAFEBLOCK, the file is read block by block.
+
+    :param fp: File handle.  Must implement a <b>read</b> method.
+    :param size: Number of bytes to read.
+    :returns: A string containing <i>size</i> bytes of data.
+
+    Raises an OSError if the file is truncated and the read cannot be completed
+
+    """
+    if size <= 0:
+        return b""
+    if size <= SAFEBLOCK:
+        data = fp.read(size)
+        if len(data) < size:
+            raise OSError("Truncated File Read")
+        return data
+    data = []
+    remaining_size = size
+    while remaining_size > 0:
+        block = fp.read(min(remaining_size, SAFEBLOCK))
+        if not block:
+            break
+        data.append(block)
+        remaining_size -= len(block)
+    if sum(len(d) for d in data) < size:
+        raise OSError("Truncated File Read")
+    return b"".join(data)
+
+
+class PyCodecState:
+    def __init__(self):
+        self.xsize = 0
+        self.ysize = 0
+        self.xoff = 0
+        self.yoff = 0
+
+    def extents(self):
+        return (self.xoff, self.yoff, self.xoff + self.xsize, self.yoff + self.ysize)
+
+
+class PyCodec:
+    def __init__(self, mode, *args):
+        self.im = None
+        self.state = PyCodecState()
+        self.fd = None
+        self.mode = mode
+        self.init(args)
+
+    def init(self, args):
+        """
+        Override to perform codec specific initialization
+
+        :param args: Array of args items from the tile entry
+        :returns: None
+        """
+        self.args = args
+
+    def cleanup(self):
+        """
+        Override to perform codec specific cleanup
+
+        :returns: None
+        """
+        pass
+
+    def setfd(self, fd):
+        """
+        Called from ImageFile to set the Python file-like object
+
+        :param fd: A Python file-like object
+        :returns: None
+        """
+        self.fd = fd
+
+    def setimage(self, im, extents=None):
+        """
+        Called from ImageFile to set the core output image for the codec
+
+        :param im: A core image object
+        :param extents: a 4 tuple of (x0, y0, x1, y1) defining the rectangle
+            for this tile
+        :returns: None
+        """
+
+        # following c code
+        self.im = im
+
+        if extents:
+            (x0, y0, x1, y1) = extents
+        else:
+            (x0, y0, x1, y1) = (0, 0, 0, 0)
+
+        if x0 == 0 and x1 == 0:
+            self.state.xsize, self.state.ysize = self.im.size
+        else:
+            self.state.xoff = x0
+            self.state.yoff = y0
+            self.state.xsize = x1 - x0
+            self.state.ysize = y1 - y0
+
+        if self.state.xsize <= 0 or self.state.ysize <= 0:
+            raise ValueError("Size cannot be negative")
+
+        if (
+            self.state.xsize + self.state.xoff > self.im.size[0]
+            or self.state.ysize + self.state.yoff > self.im.size[1]
+        ):
+            raise ValueError("Tile cannot extend outside image")
+
+
+class PyDecoder(PyCodec):
+    """
+    Python implementation of a format decoder. Override this class and
+    add the decoding logic in the :meth:`decode` method.
+
+    See :ref:`Writing Your Own File Codec in Python<file-codecs-py>`
+    """
+
+    _pulls_fd = False
+
+    @property
+    def pulls_fd(self):
+        return self._pulls_fd
+
+    def decode(self, buffer):
+        """
+        Override to perform the decoding process.
+
+        :param buffer: A bytes object with the data to be decoded.
+        :returns: A tuple of ``(bytes consumed, errcode)``.
+            If finished with decoding return -1 for the bytes consumed.
+            Err codes are from :data:`.ImageFile.ERRORS`.
+        """
+        raise NotImplementedError()
+
+    def set_as_raw(self, data, rawmode=None):
+        """
+        Convenience method to set the internal image from a stream of raw data
+
+        :param data: Bytes to be set
+        :param rawmode: The rawmode to be used for the decoder.
+            If not specified, it will default to the mode of the image
+        :returns: None
+        """
+
+        if not rawmode:
+            rawmode = self.mode
+        d = Image._getdecoder(self.mode, "raw", (rawmode))
+        d.setimage(self.im, self.state.extents())
+        s = d.decode(data)
+
+        if s[0] >= 0:
+            raise ValueError("not enough image data")
+        if s[1] != 0:
+            raise ValueError("cannot decode image data")
+
+
+class PyEncoder(PyCodec):
+    """
+    Python implementation of a format encoder. Override this class and
+    add the decoding logic in the :meth:`encode` method.
+
+    See :ref:`Writing Your Own File Codec in Python<file-codecs-py>`
+    """
+
+    _pushes_fd = False
+
+    @property
+    def pushes_fd(self):
+        return self._pushes_fd
+
+    def encode(self, bufsize):
+        """
+        Override to perform the encoding process.
+
+        :param bufsize: Buffer size.
+        :returns: A tuple of ``(bytes encoded, errcode, bytes)``.
+            If finished with encoding return 1 for the error code.
+            Err codes are from :data:`.ImageFile.ERRORS`.
+        """
+        raise NotImplementedError()
+
+    def encode_to_pyfd(self):
+        """
+        If ``pushes_fd`` is ``True``, then this method will be used,
+        and ``encode()`` will only be called once.
+
+        :returns: A tuple of ``(bytes consumed, errcode)``.
+            Err codes are from :data:`.ImageFile.ERRORS`.
+        """
+        if not self.pushes_fd:
+            return 0, -8  # bad configuration
+        bytes_consumed, errcode, data = self.encode(0)
+        if data:
+            self.fd.write(data)
+        return bytes_consumed, errcode
+
+    def encode_to_file(self, fh, bufsize):
+        """
+        :param fh: File handle.
+        :param bufsize: Buffer size.
+
+        :returns: If finished successfully, return 0.
+            Otherwise, return an error code. Err codes are from
+            :data:`.ImageFile.ERRORS`.
+        """
+        errcode = 0
+        while errcode == 0:
+            status, errcode, buf = self.encode(bufsize)
+            if status > 0:
+                fh.write(buf[status:])
+        return errcode

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/PIL/ImageFont.py

@@ -0,0 +1,1083 @@
+#
+# The Python Imaging Library.
+# $Id$
+#
+# PIL raster font management
+#
+# History:
+# 1996-08-07 fl   created (experimental)
+# 1997-08-25 fl   minor adjustments to handle fonts from pilfont 0.3
+# 1999-02-06 fl   rewrote most font management stuff in C
+# 1999-03-17 fl   take pth files into account in load_path (from Richard Jones)
+# 2001-02-17 fl   added freetype support
+# 2001-05-09 fl   added TransposedFont wrapper class
+# 2002-03-04 fl   make sure we have a "L" or "1" font
+# 2002-12-04 fl   skip non-directory entries in the system path
+# 2003-04-29 fl   add embedded default font
+# 2003-09-27 fl   added support for truetype charmap encodings
+#
+# Todo:
+# Adapt to PILFONT2 format (16-bit fonts, compressed, single file)
+#
+# Copyright (c) 1997-2003 by Secret Labs AB
+# Copyright (c) 1996-2003 by Fredrik Lundh
+#
+# See the README file for information on usage and redistribution.
+#
+
+import base64
+import os
+import sys
+import warnings
+from enum import IntEnum
+from io import BytesIO
+
+from . import Image
+from ._util import isDirectory, isPath
+
+
+class Layout(IntEnum):
+    BASIC = 0
+    RAQM = 1
+
+
+def __getattr__(name):
+    deprecated = "deprecated and will be removed in Pillow 10 (2023-07-01). "
+    for enum, prefix in {Layout: "LAYOUT_"}.items():
+        if name.startswith(prefix):
+            name = name[len(prefix) :]
+            if name in enum.__members__:
+                warnings.warn(
+                    prefix
+                    + name
+                    + " is "
+                    + deprecated
+                    + "Use "
+                    + enum.__name__
+                    + "."
+                    + name
+                    + " instead.",
+                    DeprecationWarning,
+                    stacklevel=2,
+                )
+                return enum[name]
+    raise AttributeError(f"module '{__name__}' has no attribute '{name}'")
+
+
+class _imagingft_not_installed:
+    # module placeholder
+    def __getattr__(self, id):
+        raise ImportError("The _imagingft C module is not installed")
+
+
+try:
+    from . import _imagingft as core
+except ImportError:
+    core = _imagingft_not_installed()
+
+
+# FIXME: add support for pilfont2 format (see FontFile.py)
+
+# --------------------------------------------------------------------
+# Font metrics format:
+#       "PILfont" LF
+#       fontdescriptor LF
+#       (optional) key=value... LF
+#       "DATA" LF
+#       binary data: 256*10*2 bytes (dx, dy, dstbox, srcbox)
+#
+# To place a character, cut out srcbox and paste at dstbox,
+# relative to the character position.  Then move the character
+# position according to dx, dy.
+# --------------------------------------------------------------------
+
+
+class ImageFont:
+    "PIL font wrapper"
+
+    def _load_pilfont(self, filename):
+
+        with open(filename, "rb") as fp:
+            image = None
+            for ext in (".png", ".gif", ".pbm"):
+                if image:
+                    image.close()
+                try:
+                    fullname = os.path.splitext(filename)[0] + ext
+                    image = Image.open(fullname)
+                except Exception:
+                    pass
+                else:
+                    if image and image.mode in ("1", "L"):
+                        break
+            else:
+                if image:
+                    image.close()
+                raise OSError("cannot find glyph data file")
+
+            self.file = fullname
+
+            self._load_pilfont_data(fp, image)
+            image.close()
+
+    def _load_pilfont_data(self, file, image):
+
+        # read PILfont header
+        if file.readline() != b"PILfont\n":
+            raise SyntaxError("Not a PILfont file")
+        file.readline().split(b";")
+        self.info = []  # FIXME: should be a dictionary
+        while True:
+            s = file.readline()
+            if not s or s == b"DATA\n":
+                break
+            self.info.append(s)
+
+        # read PILfont metrics
+        data = file.read(256 * 20)
+
+        # check image
+        if image.mode not in ("1", "L"):
+            raise TypeError("invalid font image mode")
+
+        image.load()
+
+        self.font = Image.core.font(image.im, data)
+
+    def getsize(self, text, *args, **kwargs):
+        """
+        Returns width and height (in pixels) of given text.
+
+        :param text: Text to measure.
+
+        :return: (width, height)
+        """
+        return self.font.getsize(text)
+
+    def getmask(self, text, mode="", *args, **kwargs):
+        """
+        Create a bitmap for the text.
+
+        If the font uses antialiasing, the bitmap should have mode ``L`` and use a
+        maximum value of 255. Otherwise, it should have mode ``1``.
+
+        :param text: Text to render.
+        :param mode: Used by some graphics drivers to indicate what mode the
+                     driver prefers; if empty, the renderer may return either
+                     mode. Note that the mode is always a string, to simplify
+                     C-level implementations.
+
+                     .. versionadded:: 1.1.5
+
+        :return: An internal PIL storage memory instance as defined by the
+                 :py:mod:`PIL.Image.core` interface module.
+        """
+        return self.font.getmask(text, mode)
+
+
+##
+# Wrapper for FreeType fonts.  Application code should use the
+# <b>truetype</b> factory function to create font objects.
+
+
+class FreeTypeFont:
+    "FreeType font wrapper (requires _imagingft service)"
+
+    def __init__(self, font=None, size=10, index=0, encoding="", layout_engine=None):
+        # FIXME: use service provider instead
+
+        self.path = font
+        self.size = size
+        self.index = index
+        self.encoding = encoding
+
+        if layout_engine not in (Layout.BASIC, Layout.RAQM):
+            layout_engine = Layout.BASIC
+            if core.HAVE_RAQM:
+                layout_engine = Layout.RAQM
+        elif layout_engine == Layout.RAQM and not core.HAVE_RAQM:
+            import warnings
+
+            warnings.warn(
+                "Raqm layout was requested, but Raqm is not available. "
+                "Falling back to basic layout."
+            )
+            layout_engine = Layout.BASIC
+
+        self.layout_engine = layout_engine
+
+        def load_from_bytes(f):
+            self.font_bytes = f.read()
+            self.font = core.getfont(
+                "", size, index, encoding, self.font_bytes, layout_engine
+            )
+
+        if isPath(font):
+            if sys.platform == "win32":
+                font_bytes_path = font if isinstance(font, bytes) else font.encode()
+                try:
+                    font_bytes_path.decode("ascii")
+                except UnicodeDecodeError:
+                    # FreeType cannot load fonts with non-ASCII characters on Windows
+                    # So load it into memory first
+                    with open(font, "rb") as f:
+                        load_from_bytes(f)
+                    return
+            self.font = core.getfont(
+                font, size, index, encoding, layout_engine=layout_engine
+            )
+        else:
+            load_from_bytes(font)
+
+    def __getstate__(self):
+        return [self.path, self.size, self.index, self.encoding, self.layout_engine]
+
+    def __setstate__(self, state):
+        path, size, index, encoding, layout_engine = state
+        self.__init__(path, size, index, encoding, layout_engine)
+
+    def _multiline_split(self, text):
+        split_character = "\n" if isinstance(text, str) else b"\n"
+        return text.split(split_character)
+
+    def getname(self):
+        """
+        :return: A tuple of the font family (e.g. Helvetica) and the font style
+            (e.g. Bold)
+        """
+        return self.font.family, self.font.style
+
+    def getmetrics(self):
+        """
+        :return: A tuple of the font ascent (the distance from the baseline to
+            the highest outline point) and descent (the distance from the
+            baseline to the lowest outline point, a negative value)
+        """
+        return self.font.ascent, self.font.descent
+
+    def getlength(self, text, mode="", direction=None, features=None, language=None):
+        """
+        Returns length (in pixels with 1/64 precision) of given text when rendered
+        in font with provided direction, features, and language.
+
+        This is the amount by which following text should be offset.
+        Text bounding box may extend past the length in some fonts,
+        e.g. when using italics or accents.
+
+        The result is returned as a float; it is a whole number if using basic layout.
+
+        Note that the sum of two lengths may not equal the length of a concatenated
+        string due to kerning. If you need to adjust for kerning, include the following
+        character and subtract its length.
+
+        For example, instead of
+
+        .. code-block:: python
+
+          hello = font.getlength("Hello")
+          world = font.getlength("World")
+          hello_world = hello + world  # not adjusted for kerning
+          assert hello_world == font.getlength("HelloWorld")  # may fail
+
+        use
+
+        .. code-block:: python
+
+          hello = font.getlength("HelloW") - font.getlength("W")  # adjusted for kerning
+          world = font.getlength("World")
+          hello_world = hello + world  # adjusted for kerning
+          assert hello_world == font.getlength("HelloWorld")  # True
+
+        or disable kerning with (requires libraqm)
+
+        .. code-block:: python
+
+          hello = draw.textlength("Hello", font, features=["-kern"])
+          world = draw.textlength("World", font, features=["-kern"])
+          hello_world = hello + world  # kerning is disabled, no need to adjust
+          assert hello_world == draw.textlength("HelloWorld", font, features=["-kern"])
+
+        .. versionadded:: 8.0.0
+
+        :param text: Text to measure.
+        :param mode: Used by some graphics drivers to indicate what mode the
+                     driver prefers; if empty, the renderer may return either
+                     mode. Note that the mode is always a string, to simplify
+                     C-level implementations.
+
+        :param direction: Direction of the text. It can be 'rtl' (right to
+                          left), 'ltr' (left to right) or 'ttb' (top to bottom).
+                          Requires libraqm.
+
+        :param features: A list of OpenType font features to be used during text
+                         layout. This is usually used to turn on optional
+                         font features that are not enabled by default,
+                         for example 'dlig' or 'ss01', but can be also
+                         used to turn off default font features for
+                         example '-liga' to disable ligatures or '-kern'
+                         to disable kerning.  To get all supported
+                         features, see
+                         https://docs.microsoft.com/en-us/typography/opentype/spec/featurelist
+                         Requires libraqm.
+
+        :param language: Language of the text. Different languages may use
+                         different glyph shapes or ligatures. This parameter tells
+                         the font which language the text is in, and to apply the
+                         correct substitutions as appropriate, if available.
+                         It should be a `BCP 47 language code
+                         <https://www.w3.org/International/articles/language-tags/>`_
+                         Requires libraqm.
+
+        :return: Width for horizontal, height for vertical text.
+        """
+        return self.font.getlength(text, mode, direction, features, language) / 64
+
+    def getbbox(
+        self,
+        text,
+        mode="",
+        direction=None,
+        features=None,
+        language=None,
+        stroke_width=0,
+        anchor=None,
+    ):
+        """
+        Returns bounding box (in pixels) of given text relative to given anchor
+        when rendered in font with provided direction, features, and language.
+
+        Use :py:meth:`getlength()` to get the offset of following text with
+        1/64 pixel precision. The bounding box includes extra margins for
+        some fonts, e.g. italics or accents.
+
+        .. versionadded:: 8.0.0
+
+        :param text: Text to render.
+        :param mode: Used by some graphics drivers to indicate what mode the
+                     driver prefers; if empty, the renderer may return either
+                     mode. Note that the mode is always a string, to simplify
+                     C-level implementations.
+
+        :param direction: Direction of the text. It can be 'rtl' (right to
+                          left), 'ltr' (left to right) or 'ttb' (top to bottom).
+                          Requires libraqm.
+
+        :param features: A list of OpenType font features to be used during text
+                         layout. This is usually used to turn on optional
+                         font features that are not enabled by default,
+                         for example 'dlig' or 'ss01', but can be also
+                         used to turn off default font features for
+                         example '-liga' to disable ligatures or '-kern'
+                         to disable kerning.  To get all supported
+                         features, see
+                         https://docs.microsoft.com/en-us/typography/opentype/spec/featurelist
+                         Requires libraqm.
+
+        :param language: Language of the text. Different languages may use
+                         different glyph shapes or ligatures. This parameter tells
+                         the font which language the text is in, and to apply the
+                         correct substitutions as appropriate, if available.
+                         It should be a `BCP 47 language code
+                         <https://www.w3.org/International/articles/language-tags/>`_
+                         Requires libraqm.
+
+        :param stroke_width: The width of the text stroke.
+
+        :param anchor:  The text anchor alignment. Determines the relative location of
+                        the anchor to the text. The default alignment is top left.
+                        See :ref:`text-anchors` for valid values.
+
+        :return: ``(left, top, right, bottom)`` bounding box
+        """
+        size, offset = self.font.getsize(
+            text, mode, direction, features, language, anchor
+        )
+        left, top = offset[0] - stroke_width, offset[1] - stroke_width
+        width, height = size[0] + 2 * stroke_width, size[1] + 2 * stroke_width
+        return left, top, left + width, top + height
+
+    def getsize(
+        self, text, direction=None, features=None, language=None, stroke_width=0
+    ):
+        """
+        Returns width and height (in pixels) of given text if rendered in font with
+        provided direction, features, and language.
+
+        Use :py:meth:`getlength()` to measure the offset of following text with
+        1/64 pixel precision.
+        Use :py:meth:`getbbox()` to get the exact bounding box based on an anchor.
+
+        .. note:: For historical reasons this function measures text height from
+            the ascender line instead of the top, see :ref:`text-anchors`.
+            If you wish to measure text height from the top, it is recommended
+            to use the bottom value of :meth:`getbbox` with ``anchor='lt'`` instead.
+
+        :param text: Text to measure.
+
+        :param direction: Direction of the text. It can be 'rtl' (right to
+                          left), 'ltr' (left to right) or 'ttb' (top to bottom).
+                          Requires libraqm.
+
+                          .. versionadded:: 4.2.0
+
+        :param features: A list of OpenType font features to be used during text
+                         layout. This is usually used to turn on optional
+                         font features that are not enabled by default,
+                         for example 'dlig' or 'ss01', but can be also
+                         used to turn off default font features for
+                         example '-liga' to disable ligatures or '-kern'
+                         to disable kerning.  To get all supported
+                         features, see
+                         https://docs.microsoft.com/en-us/typography/opentype/spec/featurelist
+                         Requires libraqm.
+
+                         .. versionadded:: 4.2.0
+
+        :param language: Language of the text. Different languages may use
+                         different glyph shapes or ligatures. This parameter tells
+                         the font which language the text is in, and to apply the
+                         correct substitutions as appropriate, if available.
+                         It should be a `BCP 47 language code
+                         <https://www.w3.org/International/articles/language-tags/>`_
+                         Requires libraqm.
+
+                         .. versionadded:: 6.0.0
+
+        :param stroke_width: The width of the text stroke.
+
+                         .. versionadded:: 6.2.0
+
+        :return: (width, height)
+        """
+        # vertical offset is added for historical reasons
+        # see https://github.com/python-pillow/Pillow/pull/4910#discussion_r486682929
+        size, offset = self.font.getsize(text, "L", direction, features, language)
+        return (
+            size[0] + stroke_width * 2,
+            size[1] + stroke_width * 2 + offset[1],
+        )
+
+    def getsize_multiline(
+        self,
+        text,
+        direction=None,
+        spacing=4,
+        features=None,
+        language=None,
+        stroke_width=0,
+    ):
+        """
+        Returns width and height (in pixels) of given text if rendered in font
+        with provided direction, features, and language, while respecting
+        newline characters.
+
+        :param text: Text to measure.
+
+        :param direction: Direction of the text. It can be 'rtl' (right to
+                          left), 'ltr' (left to right) or 'ttb' (top to bottom).
+                          Requires libraqm.
+
+        :param spacing: The vertical gap between lines, defaulting to 4 pixels.
+
+        :param features: A list of OpenType font features to be used during text
+                         layout. This is usually used to turn on optional
+                         font features that are not enabled by default,
+                         for example 'dlig' or 'ss01', but can be also
+                         used to turn off default font features for
+                         example '-liga' to disable ligatures or '-kern'
+                         to disable kerning.  To get all supported
+                         features, see
+                         https://docs.microsoft.com/en-us/typography/opentype/spec/featurelist
+                         Requires libraqm.
+
+        :param language: Language of the text. Different languages may use
+                         different glyph shapes or ligatures. This parameter tells
+                         the font which language the text is in, and to apply the
+                         correct substitutions as appropriate, if available.
+                         It should be a `BCP 47 language code
+                         <https://www.w3.org/International/articles/language-tags/>`_
+                         Requires libraqm.
+
+                         .. versionadded:: 6.0.0
+
+        :param stroke_width: The width of the text stroke.
+
+                         .. versionadded:: 6.2.0
+
+        :return: (width, height)
+        """
+        max_width = 0
+        lines = self._multiline_split(text)
+        line_spacing = self.getsize("A", stroke_width=stroke_width)[1] + spacing
+        for line in lines:
+            line_width, line_height = self.getsize(
+                line, direction, features, language, stroke_width
+            )
+            max_width = max(max_width, line_width)
+
+        return max_width, len(lines) * line_spacing - spacing
+
+    def getoffset(self, text):
+        """
+        Returns the offset of given text. This is the gap between the
+        starting coordinate and the first marking. Note that this gap is
+        included in the result of :py:func:`~PIL.ImageFont.FreeTypeFont.getsize`.
+
+        :param text: Text to measure.
+
+        :return: A tuple of the x and y offset
+        """
+        return self.font.getsize(text)[1]
+
+    def getmask(
+        self,
+        text,
+        mode="",
+        direction=None,
+        features=None,
+        language=None,
+        stroke_width=0,
+        anchor=None,
+        ink=0,
+    ):
+        """
+        Create a bitmap for the text.
+
+        If the font uses antialiasing, the bitmap should have mode ``L`` and use a
+        maximum value of 255. If the font has embedded color data, the bitmap
+        should have mode ``RGBA``. Otherwise, it should have mode ``1``.
+
+        :param text: Text to render.
+        :param mode: Used by some graphics drivers to indicate what mode the
+                     driver prefers; if empty, the renderer may return either
+                     mode. Note that the mode is always a string, to simplify
+                     C-level implementations.
+
+                     .. versionadded:: 1.1.5
+
+        :param direction: Direction of the text. It can be 'rtl' (right to
+                          left), 'ltr' (left to right) or 'ttb' (top to bottom).
+                          Requires libraqm.
+
+                          .. versionadded:: 4.2.0
+
+        :param features: A list of OpenType font features to be used during text
+                         layout. This is usually used to turn on optional
+                         font features that are not enabled by default,
+                         for example 'dlig' or 'ss01', but can be also
+                         used to turn off default font features for
+                         example '-liga' to disable ligatures or '-kern'
+                         to disable kerning.  To get all supported
+                         features, see
+                         https://docs.microsoft.com/en-us/typography/opentype/spec/featurelist
+                         Requires libraqm.
+
+                         .. versionadded:: 4.2.0
+
+        :param language: Language of the text. Different languages may use
+                         different glyph shapes or ligatures. This parameter tells
+                         the font which language the text is in, and to apply the
+                         correct substitutions as appropriate, if available.
+                         It should be a `BCP 47 language code
+                         <https://www.w3.org/International/articles/language-tags/>`_
+                         Requires libraqm.
+
+                         .. versionadded:: 6.0.0
+
+        :param stroke_width: The width of the text stroke.
+
+                         .. versionadded:: 6.2.0
+
+        :param anchor:  The text anchor alignment. Determines the relative location of
+                        the anchor to the text. The default alignment is top left.
+                        See :ref:`text-anchors` for valid values.
+
+                         .. versionadded:: 8.0.0
+
+        :param ink: Foreground ink for rendering in RGBA mode.
+
+                         .. versionadded:: 8.0.0
+
+        :return: An internal PIL storage memory instance as defined by the
+                 :py:mod:`PIL.Image.core` interface module.
+        """
+        return self.getmask2(
+            text,
+            mode,
+            direction=direction,
+            features=features,
+            language=language,
+            stroke_width=stroke_width,
+            anchor=anchor,
+            ink=ink,
+        )[0]
+
+    def getmask2(
+        self,
+        text,
+        mode="",
+        fill=Image.core.fill,
+        direction=None,
+        features=None,
+        language=None,
+        stroke_width=0,
+        anchor=None,
+        ink=0,
+        *args,
+        **kwargs,
+    ):
+        """
+        Create a bitmap for the text.
+
+        If the font uses antialiasing, the bitmap should have mode ``L`` and use a
+        maximum value of 255. If the font has embedded color data, the bitmap
+        should have mode ``RGBA``. Otherwise, it should have mode ``1``.
+
+        :param text: Text to render.
+        :param mode: Used by some graphics drivers to indicate what mode the
+                     driver prefers; if empty, the renderer may return either
+                     mode. Note that the mode is always a string, to simplify
+                     C-level implementations.
+
+                     .. versionadded:: 1.1.5
+
+        :param direction: Direction of the text. It can be 'rtl' (right to
+                          left), 'ltr' (left to right) or 'ttb' (top to bottom).
+                          Requires libraqm.
+
+                          .. versionadded:: 4.2.0
+
+        :param features: A list of OpenType font features to be used during text
+                         layout. This is usually used to turn on optional
+                         font features that are not enabled by default,
+                         for example 'dlig' or 'ss01', but can be also
+                         used to turn off default font features for
+                         example '-liga' to disable ligatures or '-kern'
+                         to disable kerning.  To get all supported
+                         features, see
+                         https://docs.microsoft.com/en-us/typography/opentype/spec/featurelist
+                         Requires libraqm.
+
+                         .. versionadded:: 4.2.0
+
+        :param language: Language of the text. Different languages may use
+                         different glyph shapes or ligatures. This parameter tells
+                         the font which language the text is in, and to apply the
+                         correct substitutions as appropriate, if available.
+                         It should be a `BCP 47 language code
+                         <https://www.w3.org/International/articles/language-tags/>`_
+                         Requires libraqm.
+
+                         .. versionadded:: 6.0.0
+
+        :param stroke_width: The width of the text stroke.
+
+                         .. versionadded:: 6.2.0
+
+        :param anchor:  The text anchor alignment. Determines the relative location of
+                        the anchor to the text. The default alignment is top left.
+                        See :ref:`text-anchors` for valid values.
+
+                         .. versionadded:: 8.0.0
+
+        :param ink: Foreground ink for rendering in RGBA mode.
+
+                         .. versionadded:: 8.0.0
+
+        :return: A tuple of an internal PIL storage memory instance as defined by the
+                 :py:mod:`PIL.Image.core` interface module, and the text offset, the
+                 gap between the starting coordinate and the first marking
+        """
+        size, offset = self.font.getsize(
+            text, mode, direction, features, language, anchor
+        )
+        size = size[0] + stroke_width * 2, size[1] + stroke_width * 2
+        offset = offset[0] - stroke_width, offset[1] - stroke_width
+        Image._decompression_bomb_check(size)
+        im = fill("RGBA" if mode == "RGBA" else "L", size, 0)
+        self.font.render(
+            text, im.id, mode, direction, features, language, stroke_width, ink
+        )
+        return im, offset
+
+    def font_variant(
+        self, font=None, size=None, index=None, encoding=None, layout_engine=None
+    ):
+        """
+        Create a copy of this FreeTypeFont object,
+        using any specified arguments to override the settings.
+
+        Parameters are identical to the parameters used to initialize this
+        object.
+
+        :return: A FreeTypeFont object.
+        """
+        return FreeTypeFont(
+            font=self.path if font is None else font,
+            size=self.size if size is None else size,
+            index=self.index if index is None else index,
+            encoding=self.encoding if encoding is None else encoding,
+            layout_engine=layout_engine or self.layout_engine,
+        )
+
+    def get_variation_names(self):
+        """
+        :returns: A list of the named styles in a variation font.
+        :exception OSError: If the font is not a variation font.
+        """
+        try:
+            names = self.font.getvarnames()
+        except AttributeError as e:
+            raise NotImplementedError("FreeType 2.9.1 or greater is required") from e
+        return [name.replace(b"\x00", b"") for name in names]
+
+    def set_variation_by_name(self, name):
+        """
+        :param name: The name of the style.
+        :exception OSError: If the font is not a variation font.
+        """
+        names = self.get_variation_names()
+        if not isinstance(name, bytes):
+            name = name.encode()
+        index = names.index(name)
+
+        if index == getattr(self, "_last_variation_index", None):
+            # When the same name is set twice in a row,
+            # there is an 'unknown freetype error'
+            # https://savannah.nongnu.org/bugs/?56186
+            return
+        self._last_variation_index = index
+
+        self.font.setvarname(index)
+
+    def get_variation_axes(self):
+        """
+        :returns: A list of the axes in a variation font.
+        :exception OSError: If the font is not a variation font.
+        """
+        try:
+            axes = self.font.getvaraxes()
+        except AttributeError as e:
+            raise NotImplementedError("FreeType 2.9.1 or greater is required") from e
+        for axis in axes:
+            axis["name"] = axis["name"].replace(b"\x00", b"")
+        return axes
+
+    def set_variation_by_axes(self, axes):
+        """
+        :param axes: A list of values for each axis.
+        :exception OSError: If the font is not a variation font.
+        """
+        try:
+            self.font.setvaraxes(axes)
+        except AttributeError as e:
+            raise NotImplementedError("FreeType 2.9.1 or greater is required") from e
+
+
+class TransposedFont:
+    "Wrapper for writing rotated or mirrored text"
+
+    def __init__(self, font, orientation=None):
+        """
+        Wrapper that creates a transposed font from any existing font
+        object.
+
+        :param font: A font object.
+        :param orientation: An optional orientation.  If given, this should
+            be one of Image.Transpose.FLIP_LEFT_RIGHT, Image.Transpose.FLIP_TOP_BOTTOM,
+            Image.Transpose.ROTATE_90, Image.Transpose.ROTATE_180, or
+            Image.Transpose.ROTATE_270.
+        """
+        self.font = font
+        self.orientation = orientation  # any 'transpose' argument, or None
+
+    def getsize(self, text, *args, **kwargs):
+        w, h = self.font.getsize(text)
+        if self.orientation in (Image.Transpose.ROTATE_90, Image.Transpose.ROTATE_270):
+            return h, w
+        return w, h
+
+    def getmask(self, text, mode="", *args, **kwargs):
+        im = self.font.getmask(text, mode, *args, **kwargs)
+        if self.orientation is not None:
+            return im.transpose(self.orientation)
+        return im
+
+
+def load(filename):
+    """
+    Load a font file.  This function loads a font object from the given
+    bitmap font file, and returns the corresponding font object.
+
+    :param filename: Name of font file.
+    :return: A font object.
+    :exception OSError: If the file could not be read.
+    """
+    f = ImageFont()
+    f._load_pilfont(filename)
+    return f
+
+
+def truetype(font=None, size=10, index=0, encoding="", layout_engine=None):
+    """
+    Load a TrueType or OpenType font from a file or file-like object,
+    and create a font object.
+    This function loads a font object from the given file or file-like
+    object, and creates a font object for a font of the given size.
+
+    Pillow uses FreeType to open font files. If you are opening many fonts
+    simultaneously on Windows, be aware that Windows limits the number of files
+    that can be open in C at once to 512. If you approach that limit, an
+    ``OSError`` may be thrown, reporting that FreeType "cannot open resource".
+
+    This function requires the _imagingft service.
+
+    :param font: A filename or file-like object containing a TrueType font.
+                 If the file is not found in this filename, the loader may also
+                 search in other directories, such as the :file:`fonts/`
+                 directory on Windows or :file:`/Library/Fonts/`,
+                 :file:`/System/Library/Fonts/` and :file:`~/Library/Fonts/` on
+                 macOS.
+
+    :param size: The requested size, in pixels.
+    :param index: Which font face to load (default is first available face).
+    :param encoding: Which font encoding to use (default is Unicode). Possible
+                     encodings include (see the FreeType documentation for more
+                     information):
+
+                     * "unic" (Unicode)
+                     * "symb" (Microsoft Symbol)
+                     * "ADOB" (Adobe Standard)
+                     * "ADBE" (Adobe Expert)
+                     * "ADBC" (Adobe Custom)
+                     * "armn" (Apple Roman)
+                     * "sjis" (Shift JIS)
+                     * "gb  " (PRC)
+                     * "big5"
+                     * "wans" (Extended Wansung)
+                     * "joha" (Johab)
+                     * "lat1" (Latin-1)
+
+                     This specifies the character set to use. It does not alter the
+                     encoding of any text provided in subsequent operations.
+    :param layout_engine: Which layout engine to use, if available:
+                     :data:`.ImageFont.Layout.BASIC` or :data:`.ImageFont.Layout.RAQM`.
+
+                     You can check support for Raqm layout using
+                     :py:func:`PIL.features.check_feature` with ``feature="raqm"``.
+
+                     .. versionadded:: 4.2.0
+    :return: A font object.
+    :exception OSError: If the file could not be read.
+    """
+
+    def freetype(font):
+        return FreeTypeFont(font, size, index, encoding, layout_engine)
+
+    try:
+        return freetype(font)
+    except OSError:
+        if not isPath(font):
+            raise
+        ttf_filename = os.path.basename(font)
+
+        dirs = []
+        if sys.platform == "win32":
+            # check the windows font repository
+            # NOTE: must use uppercase WINDIR, to work around bugs in
+            # 1.5.2's os.environ.get()
+            windir = os.environ.get("WINDIR")
+            if windir:
+                dirs.append(os.path.join(windir, "fonts"))
+        elif sys.platform in ("linux", "linux2"):
+            lindirs = os.environ.get("XDG_DATA_DIRS", "")
+            if not lindirs:
+                # According to the freedesktop spec, XDG_DATA_DIRS should
+                # default to /usr/share
+                lindirs = "/usr/share"
+            dirs += [os.path.join(lindir, "fonts") for lindir in lindirs.split(":")]
+        elif sys.platform == "darwin":
+            dirs += [
+                "/Library/Fonts",
+                "/System/Library/Fonts",
+                os.path.expanduser("~/Library/Fonts"),
+            ]
+
+        ext = os.path.splitext(ttf_filename)[1]
+        first_font_with_a_different_extension = None
+        for directory in dirs:
+            for walkroot, walkdir, walkfilenames in os.walk(directory):
+                for walkfilename in walkfilenames:
+                    if ext and walkfilename == ttf_filename:
+                        return freetype(os.path.join(walkroot, walkfilename))
+                    elif not ext and os.path.splitext(walkfilename)[0] == ttf_filename:
+                        fontpath = os.path.join(walkroot, walkfilename)
+                        if os.path.splitext(fontpath)[1] == ".ttf":
+                            return freetype(fontpath)
+                        if not ext and first_font_with_a_different_extension is None:
+                            first_font_with_a_different_extension = fontpath
+        if first_font_with_a_different_extension:
+            return freetype(first_font_with_a_different_extension)
+        raise
+
+
+def load_path(filename):
+    """
+    Load font file. Same as :py:func:`~PIL.ImageFont.load`, but searches for a
+    bitmap font along the Python path.
+
+    :param filename: Name of font file.
+    :return: A font object.
+    :exception OSError: If the file could not be read.
+    """
+    for directory in sys.path:
+        if isDirectory(directory):
+            if not isinstance(filename, str):
+                filename = filename.decode("utf-8")
+            try:
+                return load(os.path.join(directory, filename))
+            except OSError:
+                pass
+    raise OSError("cannot find font file")
+
+
+def load_default():
+    """Load a "better than nothing" default font.
+
+    .. versionadded:: 1.1.4
+
+    :return: A font object.
+    """
+    f = ImageFont()
+    f._load_pilfont_data(
+        # courB08
+        BytesIO(
+            base64.b64decode(
+                b"""
+UElMZm9udAo7Ozs7OzsxMDsKREFUQQoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYAAAAA//8AAQAAAAAAAAABAAEA
+BgAAAAH/+gADAAAAAQAAAAMABgAGAAAAAf/6AAT//QADAAAABgADAAYAAAAA//kABQABAAYAAAAL
+AAgABgAAAAD/+AAFAAEACwAAABAACQAGAAAAAP/5AAUAAAAQAAAAFQAHAAYAAP////oABQAAABUA
+AAAbAAYABgAAAAH/+QAE//wAGwAAAB4AAwAGAAAAAf/5AAQAAQAeAAAAIQAIAAYAAAAB//kABAAB
+ACEAAAAkAAgABgAAAAD/+QAE//0AJAAAACgABAAGAAAAAP/6AAX//wAoAAAALQAFAAYAAAAB//8A
+BAACAC0AAAAwAAMABgAAAAD//AAF//0AMAAAADUAAQAGAAAAAf//AAMAAAA1AAAANwABAAYAAAAB
+//kABQABADcAAAA7AAgABgAAAAD/+QAFAAAAOwAAAEAABwAGAAAAAP/5AAYAAABAAAAARgAHAAYA
+AAAA//kABQAAAEYAAABLAAcABgAAAAD/+QAFAAAASwAAAFAABwAGAAAAAP/5AAYAAABQAAAAVgAH
+AAYAAAAA//kABQAAAFYAAABbAAcABgAAAAD/+QAFAAAAWwAAAGAABwAGAAAAAP/5AAUAAABgAAAA
+ZQAHAAYAAAAA//kABQAAAGUAAABqAAcABgAAAAD/+QAFAAAAagAAAG8ABwAGAAAAAf/8AAMAAABv
+AAAAcQAEAAYAAAAA//wAAwACAHEAAAB0AAYABgAAAAD/+gAE//8AdAAAAHgABQAGAAAAAP/7AAT/
+/gB4AAAAfAADAAYAAAAB//oABf//AHwAAACAAAUABgAAAAD/+gAFAAAAgAAAAIUABgAGAAAAAP/5
+AAYAAQCFAAAAiwAIAAYAAP////oABgAAAIsAAACSAAYABgAA////+gAFAAAAkgAAAJgABgAGAAAA
+AP/6AAUAAACYAAAAnQAGAAYAAP////oABQAAAJ0AAACjAAYABgAA////+gAFAAAAowAAAKkABgAG
+AAD////6AAUAAACpAAAArwAGAAYAAAAA//oABQAAAK8AAAC0AAYABgAA////+gAGAAAAtAAAALsA
+BgAGAAAAAP/6AAQAAAC7AAAAvwAGAAYAAP////oABQAAAL8AAADFAAYABgAA////+gAGAAAAxQAA
+AMwABgAGAAD////6AAUAAADMAAAA0gAGAAYAAP////oABQAAANIAAADYAAYABgAA////+gAGAAAA
+2AAAAN8ABgAGAAAAAP/6AAUAAADfAAAA5AAGAAYAAP////oABQAAAOQAAADqAAYABgAAAAD/+gAF
+AAEA6gAAAO8ABwAGAAD////6AAYAAADvAAAA9gAGAAYAAAAA//oABQAAAPYAAAD7AAYABgAA////
++gAFAAAA+wAAAQEABgAGAAD////6AAYAAAEBAAABCAAGAAYAAP////oABgAAAQgAAAEPAAYABgAA
+////+gAGAAABDwAAARYABgAGAAAAAP/6AAYAAAEWAAABHAAGAAYAAP////oABgAAARwAAAEjAAYA
+BgAAAAD/+gAFAAABIwAAASgABgAGAAAAAf/5AAQAAQEoAAABKwAIAAYAAAAA//kABAABASsAAAEv
+AAgABgAAAAH/+QAEAAEBLwAAATIACAAGAAAAAP/5AAX//AEyAAABNwADAAYAAAAAAAEABgACATcA
+AAE9AAEABgAAAAH/+QAE//wBPQAAAUAAAwAGAAAAAP/7AAYAAAFAAAABRgAFAAYAAP////kABQAA
+AUYAAAFMAAcABgAAAAD/+wAFAAABTAAAAVEABQAGAAAAAP/5AAYAAAFRAAABVwAHAAYAAAAA//sA
+BQAAAVcAAAFcAAUABgAAAAD/+QAFAAABXAAAAWEABwAGAAAAAP/7AAYAAgFhAAABZwAHAAYAAP//
+//kABQAAAWcAAAFtAAcABgAAAAD/+QAGAAABbQAAAXMABwAGAAAAAP/5AAQAAgFzAAABdwAJAAYA
+AP////kABgAAAXcAAAF+AAcABgAAAAD/+QAGAAABfgAAAYQABwAGAAD////7AAUAAAGEAAABigAF
+AAYAAP////sABQAAAYoAAAGQAAUABgAAAAD/+wAFAAABkAAAAZUABQAGAAD////7AAUAAgGVAAAB
+mwAHAAYAAAAA//sABgACAZsAAAGhAAcABgAAAAD/+wAGAAABoQAAAacABQAGAAAAAP/7AAYAAAGn
+AAABrQAFAAYAAAAA//kABgAAAa0AAAGzAAcABgAA////+wAGAAABswAAAboABQAGAAD////7AAUA
+AAG6AAABwAAFAAYAAP////sABgAAAcAAAAHHAAUABgAAAAD/+wAGAAABxwAAAc0ABQAGAAD////7
+AAYAAgHNAAAB1AAHAAYAAAAA//sABQAAAdQAAAHZAAUABgAAAAH/+QAFAAEB2QAAAd0ACAAGAAAA
+Av/6AAMAAQHdAAAB3gAHAAYAAAAA//kABAABAd4AAAHiAAgABgAAAAD/+wAF//0B4gAAAecAAgAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYAAAAB
+//sAAwACAecAAAHpAAcABgAAAAD/+QAFAAEB6QAAAe4ACAAGAAAAAP/5AAYAAAHuAAAB9AAHAAYA
+AAAA//oABf//AfQAAAH5AAUABgAAAAD/+QAGAAAB+QAAAf8ABwAGAAAAAv/5AAMAAgH/AAACAAAJ
+AAYAAAAA//kABQABAgAAAAIFAAgABgAAAAH/+gAE//sCBQAAAggAAQAGAAAAAP/5AAYAAAIIAAAC
+DgAHAAYAAAAB//kABf/+Ag4AAAISAAUABgAA////+wAGAAACEgAAAhkABQAGAAAAAP/7AAX//gIZ
+AAACHgADAAYAAAAA//wABf/9Ah4AAAIjAAEABgAAAAD/+QAHAAACIwAAAioABwAGAAAAAP/6AAT/
++wIqAAACLgABAAYAAAAA//kABP/8Ai4AAAIyAAMABgAAAAD/+gAFAAACMgAAAjcABgAGAAAAAf/5
+AAT//QI3AAACOgAEAAYAAAAB//kABP/9AjoAAAI9AAQABgAAAAL/+QAE//sCPQAAAj8AAgAGAAD/
+///7AAYAAgI/AAACRgAHAAYAAAAA//kABgABAkYAAAJMAAgABgAAAAH//AAD//0CTAAAAk4AAQAG
+AAAAAf//AAQAAgJOAAACUQADAAYAAAAB//kABP/9AlEAAAJUAAQABgAAAAH/+QAF//4CVAAAAlgA
+BQAGAAD////7AAYAAAJYAAACXwAFAAYAAP////kABgAAAl8AAAJmAAcABgAA////+QAGAAACZgAA
+Am0ABwAGAAD////5AAYAAAJtAAACdAAHAAYAAAAA//sABQACAnQAAAJ5AAcABgAA////9wAGAAAC
+eQAAAoAACQAGAAD////3AAYAAAKAAAAChwAJAAYAAP////cABgAAAocAAAKOAAkABgAA////9wAG
+AAACjgAAApUACQAGAAD////4AAYAAAKVAAACnAAIAAYAAP////cABgAAApwAAAKjAAkABgAA////
++gAGAAACowAAAqoABgAGAAAAAP/6AAUAAgKqAAACrwAIAAYAAP////cABQAAAq8AAAK1AAkABgAA
+////9wAFAAACtQAAArsACQAGAAD////3AAUAAAK7AAACwQAJAAYAAP////gABQAAAsEAAALHAAgA
+BgAAAAD/9wAEAAACxwAAAssACQAGAAAAAP/3AAQAAALLAAACzwAJAAYAAAAA//cABAAAAs8AAALT
+AAkABgAAAAD/+AAEAAAC0wAAAtcACAAGAAD////6AAUAAALXAAAC3QAGAAYAAP////cABgAAAt0A
+AALkAAkABgAAAAD/9wAFAAAC5AAAAukACQAGAAAAAP/3AAUAAALpAAAC7gAJAAYAAAAA//cABQAA
+Au4AAALzAAkABgAAAAD/9wAFAAAC8wAAAvgACQAGAAAAAP/4AAUAAAL4AAAC/QAIAAYAAAAA//oA
+Bf//Av0AAAMCAAUABgAA////+gAGAAADAgAAAwkABgAGAAD////3AAYAAAMJAAADEAAJAAYAAP//
+//cABgAAAxAAAAMXAAkABgAA////9wAGAAADFwAAAx4ACQAGAAD////4AAYAAAAAAAoABwASAAYA
+AP////cABgAAAAcACgAOABMABgAA////+gAFAAAADgAKABQAEAAGAAD////6AAYAAAAUAAoAGwAQ
+AAYAAAAA//gABgAAABsACgAhABIABgAAAAD/+AAGAAAAIQAKACcAEgAGAAAAAP/4AAYAAAAnAAoA
+LQASAAYAAAAA//gABgAAAC0ACgAzABIABgAAAAD/+QAGAAAAMwAKADkAEQAGAAAAAP/3AAYAAAA5
+AAoAPwATAAYAAP////sABQAAAD8ACgBFAA8ABgAAAAD/+wAFAAIARQAKAEoAEQAGAAAAAP/4AAUA
+AABKAAoATwASAAYAAAAA//gABQAAAE8ACgBUABIABgAAAAD/+AAFAAAAVAAKAFkAEgAGAAAAAP/5
+AAUAAABZAAoAXgARAAYAAAAA//gABgAAAF4ACgBkABIABgAAAAD/+AAGAAAAZAAKAGoAEgAGAAAA
+AP/4AAYAAABqAAoAcAASAAYAAAAA//kABgAAAHAACgB2ABEABgAAAAD/+AAFAAAAdgAKAHsAEgAG
+AAD////4AAYAAAB7AAoAggASAAYAAAAA//gABQAAAIIACgCHABIABgAAAAD/+AAFAAAAhwAKAIwA
+EgAGAAAAAP/4AAUAAACMAAoAkQASAAYAAAAA//gABQAAAJEACgCWABIABgAAAAD/+QAFAAAAlgAK
+AJsAEQAGAAAAAP/6AAX//wCbAAoAoAAPAAYAAAAA//oABQABAKAACgClABEABgAA////+AAGAAAA
+pQAKAKwAEgAGAAD////4AAYAAACsAAoAswASAAYAAP////gABgAAALMACgC6ABIABgAA////+QAG
+AAAAugAKAMEAEQAGAAD////4AAYAAgDBAAoAyAAUAAYAAP////kABQACAMgACgDOABMABgAA////
++QAGAAIAzgAKANUAEw==
+"""
+            )
+        ),
+        Image.open(
+            BytesIO(
+                base64.b64decode(
+                    b"""
+iVBORw0KGgoAAAANSUhEUgAAAx4AAAAUAQAAAAArMtZoAAAEwElEQVR4nABlAJr/AHVE4czCI/4u
+Mc4b7vuds/xzjz5/3/7u/n9vMe7vnfH/9++vPn/xyf5zhxzjt8GHw8+2d83u8x27199/nxuQ6Od9
+M43/5z2I+9n9ZtmDBwMQECDRQw/eQIQohJXxpBCNVE6QCCAAAAD//wBlAJr/AgALyj1t/wINwq0g
+LeNZUworuN1cjTPIzrTX6ofHWeo3v336qPzfEwRmBnHTtf95/fglZK5N0PDgfRTslpGBvz7LFc4F
+IUXBWQGjQ5MGCx34EDFPwXiY4YbYxavpnhHFrk14CDAAAAD//wBlAJr/AgKqRooH2gAgPeggvUAA
+Bu2WfgPoAwzRAABAAAAAAACQgLz/3Uv4Gv+gX7BJgDeeGP6AAAD1NMDzKHD7ANWr3loYbxsAD791
+NAADfcoIDyP44K/jv4Y63/Z+t98Ovt+ub4T48LAAAAD//wBlAJr/AuplMlADJAAAAGuAphWpqhMx
+in0A/fRvAYBABPgBwBUgABBQ/sYAyv9g0bCHgOLoGAAAAAAAREAAwI7nr0ArYpow7aX8//9LaP/9
+SjdavWA8ePHeBIKB//81/83ndznOaXx379wAAAD//wBlAJr/AqDxW+D3AABAAbUh/QMnbQag/gAY
+AYDAAACgtgD/gOqAAAB5IA/8AAAk+n9w0AAA8AAAmFRJuPo27ciC0cD5oeW4E7KA/wD3ECMAn2tt
+y8PgwH8AfAxFzC0JzeAMtratAsC/ffwAAAD//wBlAJr/BGKAyCAA4AAAAvgeYTAwHd1kmQF5chkG
+ABoMIHcL5xVpTfQbUqzlAAAErwAQBgAAEOClA5D9il08AEh/tUzdCBsXkbgACED+woQg8Si9VeqY
+lODCn7lmF6NhnAEYgAAA/NMIAAAAAAD//2JgjLZgVGBg5Pv/Tvpc8hwGBjYGJADjHDrAwPzAjv/H
+/Wf3PzCwtzcwHmBgYGcwbZz8wHaCAQMDOwMDQ8MCBgYOC3W7mp+f0w+wHOYxO3OG+e376hsMZjk3
+AAAAAP//YmCMY2A4wMAIN5e5gQETPD6AZisDAwMDgzSDAAPjByiHcQMDAwMDg1nOze1lByRu5/47
+c4859311AYNZzg0AAAAA//9iYGDBYihOIIMuwIjGL39/fwffA8b//xv/P2BPtzzHwCBjUQAAAAD/
+/yLFBrIBAAAA//9i1HhcwdhizX7u8NZNzyLbvT97bfrMf/QHI8evOwcSqGUJAAAA//9iYBB81iSw
+pEE170Qrg5MIYydHqwdDQRMrAwcVrQAAAAD//2J4x7j9AAMDn8Q/BgYLBoaiAwwMjPdvMDBYM1Tv
+oJodAAAAAP//Yqo/83+dxePWlxl3npsel9lvLfPcqlE9725C+acfVLMEAAAA//9i+s9gwCoaaGMR
+evta/58PTEWzr21hufPjA8N+qlnBwAAAAAD//2JiWLci5v1+HmFXDqcnULE/MxgYGBj+f6CaJQAA
+AAD//2Ji2FrkY3iYpYC5qDeGgeEMAwPDvwQBBoYvcTwOVLMEAAAA//9isDBgkP///0EOg9z35v//
+Gc/eeW7BwPj5+QGZhANUswMAAAD//2JgqGBgYGBgqEMXlvhMPUsAAAAA//8iYDd1AAAAAP//AwDR
+w7IkEbzhVQAAAABJRU5ErkJggg==
+"""
+                )
+            )
+        ),
+    )
+    return f

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/PIL/ImageGrab.py

@@ -0,0 +1,124 @@
+#
+# The Python Imaging Library
+# $Id$
+#
+# screen grabber
+#
+# History:
+# 2001-04-26 fl  created
+# 2001-09-17 fl  use builtin driver, if present
+# 2002-11-19 fl  added grabclipboard support
+#
+# Copyright (c) 2001-2002 by Secret Labs AB
+# Copyright (c) 2001-2002 by Fredrik Lundh
+#
+# See the README file for information on usage and redistribution.
+#
+
+import sys
+
+from . import Image
+
+if sys.platform == "darwin":
+    import os
+    import subprocess
+    import tempfile
+
+
+def grab(bbox=None, include_layered_windows=False, all_screens=False, xdisplay=None):
+    if xdisplay is None:
+        if sys.platform == "darwin":
+            fh, filepath = tempfile.mkstemp(".png")
+            os.close(fh)
+            args = ["screencapture"]
+            if bbox:
+                left, top, right, bottom = bbox
+                args += ["-R", f"{left},{right},{right-left},{bottom-top}"]
+            subprocess.call(args + ["-x", filepath])
+            im = Image.open(filepath)
+            im.load()
+            os.unlink(filepath)
+            if bbox:
+                im_resized = im.resize((right - left, bottom - top))
+                im.close()
+                return im_resized
+            return im
+        elif sys.platform == "win32":
+            offset, size, data = Image.core.grabscreen_win32(
+                include_layered_windows, all_screens
+            )
+            im = Image.frombytes(
+                "RGB",
+                size,
+                data,
+                # RGB, 32-bit line padding, origin lower left corner
+                "raw",
+                "BGR",
+                (size[0] * 3 + 3) & -4,
+                -1,
+            )
+            if bbox:
+                x0, y0 = offset
+                left, top, right, bottom = bbox
+                im = im.crop((left - x0, top - y0, right - x0, bottom - y0))
+            return im
+    # use xdisplay=None for default display on non-win32/macOS systems
+    if not Image.core.HAVE_XCB:
+        raise OSError("Pillow was built without XCB support")
+    size, data = Image.core.grabscreen_x11(xdisplay)
+    im = Image.frombytes("RGB", size, data, "raw", "BGRX", size[0] * 4, 1)
+    if bbox:
+        im = im.crop(bbox)
+    return im
+
+
+def grabclipboard():
+    if sys.platform == "darwin":
+        fh, filepath = tempfile.mkstemp(".jpg")
+        os.close(fh)
+        commands = [
+            'set theFile to (open for access POSIX file "'
+            + filepath
+            + '" with write permission)',
+            "try",
+            "    write (the clipboard as JPEG picture) to theFile",
+            "end try",
+            "close access theFile",
+        ]
+        script = ["osascript"]
+        for command in commands:
+            script += ["-e", command]
+        subprocess.call(script)
+
+        im = None
+        if os.stat(filepath).st_size != 0:
+            im = Image.open(filepath)
+            im.load()
+        os.unlink(filepath)
+        return im
+    elif sys.platform == "win32":
+        fmt, data = Image.core.grabclipboard_win32()
+        if fmt == "file":  # CF_HDROP
+            import struct
+
+            o = struct.unpack_from("I", data)[0]
+            if data[16] != 0:
+                files = data[o:].decode("utf-16le").split("\0")
+            else:
+                files = data[o:].decode("mbcs").split("\0")
+            return files[: files.index("")]
+        if isinstance(data, bytes):
+            import io
+
+            data = io.BytesIO(data)
+            if fmt == "png":
+                from . import PngImagePlugin
+
+                return PngImagePlugin.PngImageFile(data)
+            elif fmt == "DIB":
+                from . import BmpImagePlugin
+
+                return BmpImagePlugin.DibImageFile(data)
+        return None
+    else:
+        raise NotImplementedError("ImageGrab.grabclipboard() is macOS and Windows only")

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/PIL/ImageMode.py

@@ -0,0 +1,91 @@
+#
+# The Python Imaging Library.
+# $Id$
+#
+# standard mode descriptors
+#
+# History:
+# 2006-03-20 fl   Added
+#
+# Copyright (c) 2006 by Secret Labs AB.
+# Copyright (c) 2006 by Fredrik Lundh.
+#
+# See the README file for information on usage and redistribution.
+#
+
+import sys
+
+# mode descriptor cache
+_modes = None
+
+
+class ModeDescriptor:
+    """Wrapper for mode strings."""
+
+    def __init__(self, mode, bands, basemode, basetype, typestr):
+        self.mode = mode
+        self.bands = bands
+        self.basemode = basemode
+        self.basetype = basetype
+        self.typestr = typestr
+
+    def __str__(self):
+        return self.mode
+
+
+def getmode(mode):
+    """Gets a mode descriptor for the given mode."""
+    global _modes
+    if not _modes:
+        # initialize mode cache
+        modes = {}
+        endian = "<" if sys.byteorder == "little" else ">"
+        for m, (basemode, basetype, bands, typestr) in {
+            # core modes
+            # Bits need to be extended to bytes
+            "1": ("L", "L", ("1",), "|b1"),
+            "L": ("L", "L", ("L",), "|u1"),
+            "I": ("L", "I", ("I",), endian + "i4"),
+            "F": ("L", "F", ("F",), endian + "f4"),
+            "P": ("P", "L", ("P",), "|u1"),
+            "RGB": ("RGB", "L", ("R", "G", "B"), "|u1"),
+            "RGBX": ("RGB", "L", ("R", "G", "B", "X"), "|u1"),
+            "RGBA": ("RGB", "L", ("R", "G", "B", "A"), "|u1"),
+            "CMYK": ("RGB", "L", ("C", "M", "Y", "K"), "|u1"),
+            "YCbCr": ("RGB", "L", ("Y", "Cb", "Cr"), "|u1"),
+            # UNDONE - unsigned |u1i1i1
+            "LAB": ("RGB", "L", ("L", "A", "B"), "|u1"),
+            "HSV": ("RGB", "L", ("H", "S", "V"), "|u1"),
+            # extra experimental modes
+            "RGBa": ("RGB", "L", ("R", "G", "B", "a"), "|u1"),
+            "BGR;15": ("RGB", "L", ("B", "G", "R"), endian + "u2"),
+            "BGR;16": ("RGB", "L", ("B", "G", "R"), endian + "u2"),
+            "BGR;24": ("RGB", "L", ("B", "G", "R"), endian + "u3"),
+            "BGR;32": ("RGB", "L", ("B", "G", "R"), endian + "u4"),
+            "LA": ("L", "L", ("L", "A"), "|u1"),
+            "La": ("L", "L", ("L", "a"), "|u1"),
+            "PA": ("RGB", "L", ("P", "A"), "|u1"),
+        }.items():
+            modes[m] = ModeDescriptor(m, bands, basemode, basetype, typestr)
+        # mapping modes
+        for i16mode, typestr in {
+            # I;16 == I;16L, and I;32 == I;32L
+            "I;16": "<u2",
+            "I;16S": "<i2",
+            "I;16L": "<u2",
+            "I;16LS": "<i2",
+            "I;16B": ">u2",
+            "I;16BS": ">i2",
+            "I;16N": endian + "u2",
+            "I;16NS": endian + "i2",
+            "I;32": "<u4",
+            "I;32B": ">u4",
+            "I;32L": "<u4",
+            "I;32S": "<i4",
+            "I;32BS": ">i4",
+            "I;32LS": "<i4",
+        }.items():
+            modes[i16mode] = ModeDescriptor(i16mode, ("I",), "L", "L", typestr)
+        # set global mode cache atomically
+        _modes = modes
+    return _modes[mode]

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/PIL/ImagePalette.py

@@ -0,0 +1,261 @@
+#
+# The Python Imaging Library.
+# $Id$
+#
+# image palette object
+#
+# History:
+# 1996-03-11 fl   Rewritten.
+# 1997-01-03 fl   Up and running.
+# 1997-08-23 fl   Added load hack
+# 2001-04-16 fl   Fixed randint shadow bug in random()
+#
+# Copyright (c) 1997-2001 by Secret Labs AB
+# Copyright (c) 1996-1997 by Fredrik Lundh
+#
+# See the README file for information on usage and redistribution.
+#
+
+import array
+import warnings
+
+from . import GimpGradientFile, GimpPaletteFile, ImageColor, PaletteFile
+
+
+class ImagePalette:
+    """
+    Color palette for palette mapped images
+
+    :param mode: The mode to use for the palette. See:
+        :ref:`concept-modes`. Defaults to "RGB"
+    :param palette: An optional palette. If given, it must be a bytearray,
+        an array or a list of ints between 0-255. The list must consist of
+        all channels for one color followed by the next color (e.g. RGBRGBRGB).
+        Defaults to an empty palette.
+    :param size: An optional palette size. If given, an error is raised
+        if ``palette`` is not of equal length.
+    """
+
+    def __init__(self, mode="RGB", palette=None, size=0):
+        self.mode = mode
+        self.rawmode = None  # if set, palette contains raw data
+        self.palette = palette or bytearray()
+        self.dirty = None
+        if size != 0:
+            warnings.warn(
+                "The size parameter is deprecated and will be removed in Pillow 10 "
+                "(2023-07-01).",
+                DeprecationWarning,
+            )
+            if size != len(self.palette):
+                raise ValueError("wrong palette size")
+
+    @property
+    def palette(self):
+        return self._palette
+
+    @palette.setter
+    def palette(self, palette):
+        self._palette = palette
+
+        mode_len = len(self.mode)
+        self.colors = {}
+        for i in range(0, len(self.palette), mode_len):
+            color = tuple(self.palette[i : i + mode_len])
+            if color in self.colors:
+                continue
+            self.colors[color] = i // mode_len
+
+    def copy(self):
+        new = ImagePalette()
+
+        new.mode = self.mode
+        new.rawmode = self.rawmode
+        if self.palette is not None:
+            new.palette = self.palette[:]
+        new.dirty = self.dirty
+
+        return new
+
+    def getdata(self):
+        """
+        Get palette contents in format suitable for the low-level
+        ``im.putpalette`` primitive.
+
+        .. warning:: This method is experimental.
+        """
+        if self.rawmode:
+            return self.rawmode, self.palette
+        return self.mode, self.tobytes()
+
+    def tobytes(self):
+        """Convert palette to bytes.
+
+        .. warning:: This method is experimental.
+        """
+        if self.rawmode:
+            raise ValueError("palette contains raw palette data")
+        if isinstance(self.palette, bytes):
+            return self.palette
+        arr = array.array("B", self.palette)
+        return arr.tobytes()
+
+    # Declare tostring as an alias for tobytes
+    tostring = tobytes
+
+    def getcolor(self, color, image=None):
+        """Given an rgb tuple, allocate palette entry.
+
+        .. warning:: This method is experimental.
+        """
+        if self.rawmode:
+            raise ValueError("palette contains raw palette data")
+        if isinstance(color, tuple):
+            if self.mode == "RGB":
+                if len(color) == 4 and color[3] == 255:
+                    color = color[:3]
+            elif self.mode == "RGBA":
+                if len(color) == 3:
+                    color += (255,)
+            try:
+                return self.colors[color]
+            except KeyError as e:
+                # allocate new color slot
+                if not isinstance(self.palette, bytearray):
+                    self._palette = bytearray(self.palette)
+                index = len(self.palette) // 3
+                special_colors = ()
+                if image:
+                    special_colors = (
+                        image.info.get("background"),
+                        image.info.get("transparency"),
+                    )
+                while index in special_colors:
+                    index += 1
+                if index >= 256:
+                    if image:
+                        # Search for an unused index
+                        for i, count in reversed(list(enumerate(image.histogram()))):
+                            if count == 0 and i not in special_colors:
+                                index = i
+                                break
+                    if index >= 256:
+                        raise ValueError("cannot allocate more than 256 colors") from e
+                self.colors[color] = index
+                if index * 3 < len(self.palette):
+                    self._palette = (
+                        self.palette[: index * 3]
+                        + bytes(color)
+                        + self.palette[index * 3 + 3 :]
+                    )
+                else:
+                    self._palette += bytes(color)
+                self.dirty = 1
+                return index
+        else:
+            raise ValueError(f"unknown color specifier: {repr(color)}")
+
+    def save(self, fp):
+        """Save palette to text file.
+
+        .. warning:: This method is experimental.
+        """
+        if self.rawmode:
+            raise ValueError("palette contains raw palette data")
+        if isinstance(fp, str):
+            fp = open(fp, "w")
+        fp.write("# Palette\n")
+        fp.write(f"# Mode: {self.mode}\n")
+        for i in range(256):
+            fp.write(f"{i}")
+            for j in range(i * len(self.mode), (i + 1) * len(self.mode)):
+                try:
+                    fp.write(f" {self.palette[j]}")
+                except IndexError:
+                    fp.write(" 0")
+            fp.write("\n")
+        fp.close()
+
+
+# --------------------------------------------------------------------
+# Internal
+
+
+def raw(rawmode, data):
+    palette = ImagePalette()
+    palette.rawmode = rawmode
+    palette.palette = data
+    palette.dirty = 1
+    return palette
+
+
+# --------------------------------------------------------------------
+# Factories
+
+
+def make_linear_lut(black, white):
+    lut = []
+    if black == 0:
+        for i in range(256):
+            lut.append(white * i // 255)
+    else:
+        raise NotImplementedError  # FIXME
+    return lut
+
+
+def make_gamma_lut(exp):
+    lut = []
+    for i in range(256):
+        lut.append(int(((i / 255.0) ** exp) * 255.0 + 0.5))
+    return lut
+
+
+def negative(mode="RGB"):
+    palette = list(range(256 * len(mode)))
+    palette.reverse()
+    return ImagePalette(mode, [i // len(mode) for i in palette])
+
+
+def random(mode="RGB"):
+    from random import randint
+
+    palette = []
+    for i in range(256 * len(mode)):
+        palette.append(randint(0, 255))
+    return ImagePalette(mode, palette)
+
+
+def sepia(white="#fff0c0"):
+    bands = [make_linear_lut(0, band) for band in ImageColor.getrgb(white)]
+    return ImagePalette("RGB", [bands[i % 3][i // 3] for i in range(256 * 3)])
+
+
+def wedge(mode="RGB"):
+    palette = list(range(256 * len(mode)))
+    return ImagePalette(mode, [i // len(mode) for i in palette])
+
+
+def load(filename):
+
+    # FIXME: supports GIMP gradients only
+
+    with open(filename, "rb") as fp:
+
+        for paletteHandler in [
+            GimpPaletteFile.GimpPaletteFile,
+            GimpGradientFile.GimpGradientFile,
+            PaletteFile.PaletteFile,
+        ]:
+            try:
+                fp.seek(0)
+                lut = paletteHandler(fp).getpalette()
+                if lut:
+                    break
+            except (SyntaxError, ValueError):
+                # import traceback
+                # traceback.print_exc()
+                pass
+        else:
+            raise OSError("cannot load palette")
+
+    return lut  # data, rawmode

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/PIL/ImagePath.py

@@ -0,0 +1,19 @@
+#
+# The Python Imaging Library
+# $Id$
+#
+# path interface
+#
+# History:
+# 1996-11-04 fl   Created
+# 2002-04-14 fl   Added documentation stub class
+#
+# Copyright (c) Secret Labs AB 1997.
+# Copyright (c) Fredrik Lundh 1996.
+#
+# See the README file for information on usage and redistribution.
+#
+
+from . import Image
+
+Path = Image.core.path

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/PIL/ImageQt.py

@@ -0,0 +1,223 @@
+#
+# The Python Imaging Library.
+# $Id$
+#
+# a simple Qt image interface.
+#
+# history:
+# 2006-06-03 fl: created
+# 2006-06-04 fl: inherit from QImage instead of wrapping it
+# 2006-06-05 fl: removed toimage helper; move string support to ImageQt
+# 2013-11-13 fl: add support for Qt5 (aurelien.ballier@cyclonit.com)
+#
+# Copyright (c) 2006 by Secret Labs AB
+# Copyright (c) 2006 by Fredrik Lundh
+#
+# See the README file for information on usage and redistribution.
+#
+
+import sys
+from io import BytesIO
+
+from . import Image
+from ._util import isPath
+
+qt_versions = [
+    ["6", "PyQt6"],
+    ["side6", "PySide6"],
+    ["5", "PyQt5"],
+    ["side2", "PySide2"],
+]
+
+# If a version has already been imported, attempt it first
+qt_versions.sort(key=lambda qt_version: qt_version[1] in sys.modules, reverse=True)
+for qt_version, qt_module in qt_versions:
+    try:
+        if qt_module == "PyQt6":
+            from PyQt6.QtCore import QBuffer, QIODevice
+            from PyQt6.QtGui import QImage, QPixmap, qRgba
+        elif qt_module == "PySide6":
+            from PySide6.QtCore import QBuffer, QIODevice
+            from PySide6.QtGui import QImage, QPixmap, qRgba
+        elif qt_module == "PyQt5":
+            from PyQt5.QtCore import QBuffer, QIODevice
+            from PyQt5.QtGui import QImage, QPixmap, qRgba
+        elif qt_module == "PySide2":
+            from PySide2.QtCore import QBuffer, QIODevice
+            from PySide2.QtGui import QImage, QPixmap, qRgba
+    except (ImportError, RuntimeError):
+        continue
+    qt_is_installed = True
+    break
+else:
+    qt_is_installed = False
+    qt_version = None
+
+
+def rgb(r, g, b, a=255):
+    """(Internal) Turns an RGB color into a Qt compatible color integer."""
+    # use qRgb to pack the colors, and then turn the resulting long
+    # into a negative integer with the same bitpattern.
+    return qRgba(r, g, b, a) & 0xFFFFFFFF
+
+
+def fromqimage(im):
+    """
+    :param im: QImage or PIL ImageQt object
+    """
+    buffer = QBuffer()
+    if qt_version == "6":
+        try:
+            qt_openmode = QIODevice.OpenModeFlag
+        except AttributeError:
+            qt_openmode = QIODevice.OpenMode
+    else:
+        qt_openmode = QIODevice
+    buffer.open(qt_openmode.ReadWrite)
+    # preserve alpha channel with png
+    # otherwise ppm is more friendly with Image.open
+    if im.hasAlphaChannel():
+        im.save(buffer, "png")
+    else:
+        im.save(buffer, "ppm")
+
+    b = BytesIO()
+    b.write(buffer.data())
+    buffer.close()
+    b.seek(0)
+
+    return Image.open(b)
+
+
+def fromqpixmap(im):
+    return fromqimage(im)
+    # buffer = QBuffer()
+    # buffer.open(QIODevice.ReadWrite)
+    # # im.save(buffer)
+    # # What if png doesn't support some image features like animation?
+    # im.save(buffer, 'ppm')
+    # bytes_io = BytesIO()
+    # bytes_io.write(buffer.data())
+    # buffer.close()
+    # bytes_io.seek(0)
+    # return Image.open(bytes_io)
+
+
+def align8to32(bytes, width, mode):
+    """
+    converts each scanline of data from 8 bit to 32 bit aligned
+    """
+
+    bits_per_pixel = {"1": 1, "L": 8, "P": 8, "I;16": 16}[mode]
+
+    # calculate bytes per line and the extra padding if needed
+    bits_per_line = bits_per_pixel * width
+    full_bytes_per_line, remaining_bits_per_line = divmod(bits_per_line, 8)
+    bytes_per_line = full_bytes_per_line + (1 if remaining_bits_per_line else 0)
+
+    extra_padding = -bytes_per_line % 4
+
+    # already 32 bit aligned by luck
+    if not extra_padding:
+        return bytes
+
+    new_data = []
+    for i in range(len(bytes) // bytes_per_line):
+        new_data.append(
+            bytes[i * bytes_per_line : (i + 1) * bytes_per_line]
+            + b"\x00" * extra_padding
+        )
+
+    return b"".join(new_data)
+
+
+def _toqclass_helper(im):
+    data = None
+    colortable = None
+    exclusive_fp = False
+
+    # handle filename, if given instead of image name
+    if hasattr(im, "toUtf8"):
+        # FIXME - is this really the best way to do this?
+        im = str(im.toUtf8(), "utf-8")
+    if isPath(im):
+        im = Image.open(im)
+        exclusive_fp = True
+
+    qt_format = QImage.Format if qt_version == "6" else QImage
+    if im.mode == "1":
+        format = qt_format.Format_Mono
+    elif im.mode == "L":
+        format = qt_format.Format_Indexed8
+        colortable = []
+        for i in range(256):
+            colortable.append(rgb(i, i, i))
+    elif im.mode == "P":
+        format = qt_format.Format_Indexed8
+        colortable = []
+        palette = im.getpalette()
+        for i in range(0, len(palette), 3):
+            colortable.append(rgb(*palette[i : i + 3]))
+    elif im.mode == "RGB":
+        # Populate the 4th channel with 255
+        im = im.convert("RGBA")
+
+        data = im.tobytes("raw", "BGRA")
+        format = qt_format.Format_RGB32
+    elif im.mode == "RGBA":
+        data = im.tobytes("raw", "BGRA")
+        format = qt_format.Format_ARGB32
+    elif im.mode == "I;16" and hasattr(qt_format, "Format_Grayscale16"):  # Qt 5.13+
+        im = im.point(lambda i: i * 256)
+
+        format = qt_format.Format_Grayscale16
+    else:
+        if exclusive_fp:
+            im.close()
+        raise ValueError(f"unsupported image mode {repr(im.mode)}")
+
+    size = im.size
+    __data = data or align8to32(im.tobytes(), size[0], im.mode)
+    if exclusive_fp:
+        im.close()
+    return {"data": __data, "size": size, "format": format, "colortable": colortable}
+
+
+if qt_is_installed:
+
+    class ImageQt(QImage):
+        def __init__(self, im):
+            """
+            An PIL image wrapper for Qt.  This is a subclass of PyQt's QImage
+            class.
+
+            :param im: A PIL Image object, or a file name (given either as
+                Python string or a PyQt string object).
+            """
+            im_data = _toqclass_helper(im)
+            # must keep a reference, or Qt will crash!
+            # All QImage constructors that take data operate on an existing
+            # buffer, so this buffer has to hang on for the life of the image.
+            # Fixes https://github.com/python-pillow/Pillow/issues/1370
+            self.__data = im_data["data"]
+            super().__init__(
+                self.__data,
+                im_data["size"][0],
+                im_data["size"][1],
+                im_data["format"],
+            )
+            if im_data["colortable"]:
+                self.setColorTable(im_data["colortable"])
+
+
+def toqimage(im):
+    return ImageQt(im)
+
+
+def toqpixmap(im):
+    # # This doesn't work. For now using a dumb approach.
+    # im_data = _toqclass_helper(im)
+    # result = QPixmap(im_data["size"][0], im_data["size"][1])
+    # result.loadFromData(im_data["data"])
+    qimage = toqimage(im)
+    return QPixmap.fromImage(qimage)

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/PIL/ImageSequence.py

@@ -0,0 +1,75 @@
+#
+# The Python Imaging Library.
+# $Id$
+#
+# sequence support classes
+#
+# history:
+# 1997-02-20 fl     Created
+#
+# Copyright (c) 1997 by Secret Labs AB.
+# Copyright (c) 1997 by Fredrik Lundh.
+#
+# See the README file for information on usage and redistribution.
+#
+
+##
+
+
+class Iterator:
+    """
+    This class implements an iterator object that can be used to loop
+    over an image sequence.
+
+    You can use the ``[]`` operator to access elements by index. This operator
+    will raise an :py:exc:`IndexError` if you try to access a nonexistent
+    frame.
+
+    :param im: An image object.
+    """
+
+    def __init__(self, im):
+        if not hasattr(im, "seek"):
+            raise AttributeError("im must have seek method")
+        self.im = im
+        self.position = getattr(self.im, "_min_frame", 0)
+
+    def __getitem__(self, ix):
+        try:
+            self.im.seek(ix)
+            return self.im
+        except EOFError as e:
+            raise IndexError from e  # end of sequence
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        try:
+            self.im.seek(self.position)
+            self.position += 1
+            return self.im
+        except EOFError as e:
+            raise StopIteration from e
+
+
+def all_frames(im, func=None):
+    """
+    Applies a given function to all frames in an image or a list of images.
+    The frames are returned as a list of separate images.
+
+    :param im: An image, or a list of images.
+    :param func: The function to apply to all of the image frames.
+    :returns: A list of images.
+    """
+    if not isinstance(im, list):
+        im = [im]
+
+    ims = []
+    for imSequence in im:
+        current = imSequence.tell()
+
+        ims += [im_frame.copy() for im_frame in Iterator(imSequence)]
+
+        imSequence.seek(current)
+    return [func(im) for im in ims] if func else ims

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/PIL/ImageStat.py

@@ -0,0 +1,147 @@
+#
+# The Python Imaging Library.
+# $Id$
+#
+# global image statistics
+#
+# History:
+# 1996-04-05 fl   Created
+# 1997-05-21 fl   Added mask; added rms, var, stddev attributes
+# 1997-08-05 fl   Added median
+# 1998-07-05 hk   Fixed integer overflow error
+#
+# Notes:
+# This class shows how to implement delayed evaluation of attributes.
+# To get a certain value, simply access the corresponding attribute.
+# The __getattr__ dispatcher takes care of the rest.
+#
+# Copyright (c) Secret Labs AB 1997.
+# Copyright (c) Fredrik Lundh 1996-97.
+#
+# See the README file for information on usage and redistribution.
+#
+
+import functools
+import math
+import operator
+
+
+class Stat:
+    def __init__(self, image_or_list, mask=None):
+        try:
+            if mask:
+                self.h = image_or_list.histogram(mask)
+            else:
+                self.h = image_or_list.histogram()
+        except AttributeError:
+            self.h = image_or_list  # assume it to be a histogram list
+        if not isinstance(self.h, list):
+            raise TypeError("first argument must be image or list")
+        self.bands = list(range(len(self.h) // 256))
+
+    def __getattr__(self, id):
+        """Calculate missing attribute"""
+        if id[:4] == "_get":
+            raise AttributeError(id)
+        # calculate missing attribute
+        v = getattr(self, "_get" + id)()
+        setattr(self, id, v)
+        return v
+
+    def _getextrema(self):
+        """Get min/max values for each band in the image"""
+
+        def minmax(histogram):
+            n = 255
+            x = 0
+            for i in range(256):
+                if histogram[i]:
+                    n = min(n, i)
+                    x = max(x, i)
+            return n, x  # returns (255, 0) if there's no data in the histogram
+
+        v = []
+        for i in range(0, len(self.h), 256):
+            v.append(minmax(self.h[i:]))
+        return v
+
+    def _getcount(self):
+        """Get total number of pixels in each layer"""
+
+        v = []
+        for i in range(0, len(self.h), 256):
+            v.append(functools.reduce(operator.add, self.h[i : i + 256]))
+        return v
+
+    def _getsum(self):
+        """Get sum of all pixels in each layer"""
+
+        v = []
+        for i in range(0, len(self.h), 256):
+            layerSum = 0.0
+            for j in range(256):
+                layerSum += j * self.h[i + j]
+            v.append(layerSum)
+        return v
+
+    def _getsum2(self):
+        """Get squared sum of all pixels in each layer"""
+
+        v = []
+        for i in range(0, len(self.h), 256):
+            sum2 = 0.0
+            for j in range(256):
+                sum2 += (j**2) * float(self.h[i + j])
+            v.append(sum2)
+        return v
+
+    def _getmean(self):
+        """Get average pixel level for each layer"""
+
+        v = []
+        for i in self.bands:
+            v.append(self.sum[i] / self.count[i])
+        return v
+
+    def _getmedian(self):
+        """Get median pixel level for each layer"""
+
+        v = []
+        for i in self.bands:
+            s = 0
+            half = self.count[i] // 2
+            b = i * 256
+            for j in range(256):
+                s = s + self.h[b + j]
+                if s > half:
+                    break
+            v.append(j)
+        return v
+
+    def _getrms(self):
+        """Get RMS for each layer"""
+
+        v = []
+        for i in self.bands:
+            v.append(math.sqrt(self.sum2[i] / self.count[i]))
+        return v
+
+    def _getvar(self):
+        """Get variance for each layer"""
+
+        v = []
+        for i in self.bands:
+            n = self.count[i]
+            v.append((self.sum2[i] - (self.sum[i] ** 2.0) / n) / n)
+        return v
+
+    def _getstddev(self):
+        """Get standard deviation for each layer"""
+
+        v = []
+        for i in self.bands:
+            v.append(math.sqrt(self.var[i]))
+        return v
+
+
+Global = Stat  # compatibility

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/PIL/ImageWin.py

@@ -0,0 +1,230 @@
+#
+# The Python Imaging Library.
+# $Id$
+#
+# a Windows DIB display interface
+#
+# History:
+# 1996-05-20 fl   Created
+# 1996-09-20 fl   Fixed subregion exposure
+# 1997-09-21 fl   Added draw primitive (for tzPrint)
+# 2003-05-21 fl   Added experimental Window/ImageWindow classes
+# 2003-09-05 fl   Added fromstring/tostring methods
+#
+# Copyright (c) Secret Labs AB 1997-2003.
+# Copyright (c) Fredrik Lundh 1996-2003.
+#
+# See the README file for information on usage and redistribution.
+#
+
+from . import Image
+
+
+class HDC:
+    """
+    Wraps an HDC integer. The resulting object can be passed to the
+    :py:meth:`~PIL.ImageWin.Dib.draw` and :py:meth:`~PIL.ImageWin.Dib.expose`
+    methods.
+    """
+
+    def __init__(self, dc):
+        self.dc = dc
+
+    def __int__(self):
+        return self.dc
+
+
+class HWND:
+    """
+    Wraps an HWND integer. The resulting object can be passed to the
+    :py:meth:`~PIL.ImageWin.Dib.draw` and :py:meth:`~PIL.ImageWin.Dib.expose`
+    methods, instead of a DC.
+    """
+
+    def __init__(self, wnd):
+        self.wnd = wnd
+
+    def __int__(self):
+        return self.wnd
+
+
+class Dib:
+    """
+    A Windows bitmap with the given mode and size.  The mode can be one of "1",
+    "L", "P", or "RGB".
+
+    If the display requires a palette, this constructor creates a suitable
+    palette and associates it with the image. For an "L" image, 128 greylevels
+    are allocated. For an "RGB" image, a 6x6x6 colour cube is used, together
+    with 20 greylevels.
+
+    To make sure that palettes work properly under Windows, you must call the
+    ``palette`` method upon certain events from Windows.
+
+    :param image: Either a PIL image, or a mode string. If a mode string is
+                  used, a size must also be given.  The mode can be one of "1",
+                  "L", "P", or "RGB".
+    :param size: If the first argument is a mode string, this
+                 defines the size of the image.
+    """
+
+    def __init__(self, image, size=None):
+        if hasattr(image, "mode") and hasattr(image, "size"):
+            mode = image.mode
+            size = image.size
+        else:
+            mode = image
+            image = None
+        if mode not in ["1", "L", "P", "RGB"]:
+            mode = Image.getmodebase(mode)
+        self.image = Image.core.display(mode, size)
+        self.mode = mode
+        self.size = size
+        if image:
+            self.paste(image)
+
+    def expose(self, handle):
+        """
+        Copy the bitmap contents to a device context.
+
+        :param handle: Device context (HDC), cast to a Python integer, or an
+                       HDC or HWND instance.  In PythonWin, you can use
+                       ``CDC.GetHandleAttrib()`` to get a suitable handle.
+        """
+        if isinstance(handle, HWND):
+            dc = self.image.getdc(handle)
+            try:
+                result = self.image.expose(dc)
+            finally:
+                self.image.releasedc(handle, dc)
+        else:
+            result = self.image.expose(handle)
+        return result
+
+    def draw(self, handle, dst, src=None):
+        """
+        Same as expose, but allows you to specify where to draw the image, and
+        what part of it to draw.
+
+        The destination and source areas are given as 4-tuple rectangles. If
+        the source is omitted, the entire image is copied. If the source and
+        the destination have different sizes, the image is resized as
+        necessary.
+        """
+        if not src:
+            src = (0, 0) + self.size
+        if isinstance(handle, HWND):
+            dc = self.image.getdc(handle)
+            try:
+                result = self.image.draw(dc, dst, src)
+            finally:
+                self.image.releasedc(handle, dc)
+        else:
+            result = self.image.draw(handle, dst, src)
+        return result
+
+    def query_palette(self, handle):
+        """
+        Installs the palette associated with the image in the given device
+        context.
+
+        This method should be called upon **QUERYNEWPALETTE** and
+        **PALETTECHANGED** events from Windows. If this method returns a
+        non-zero value, one or more display palette entries were changed, and
+        the image should be redrawn.
+
+        :param handle: Device context (HDC), cast to a Python integer, or an
+                       HDC or HWND instance.
+        :return: A true value if one or more entries were changed (this
+                 indicates that the image should be redrawn).
+        """
+        if isinstance(handle, HWND):
+            handle = self.image.getdc(handle)
+            try:
+                result = self.image.query_palette(handle)
+            finally:
+                self.image.releasedc(handle, handle)
+        else:
+            result = self.image.query_palette(handle)
+        return result
+
+    def paste(self, im, box=None):
+        """
+        Paste a PIL image into the bitmap image.
+
+        :param im: A PIL image.  The size must match the target region.
+                   If the mode does not match, the image is converted to the
+                   mode of the bitmap image.
+        :param box: A 4-tuple defining the left, upper, right, and
+                    lower pixel coordinate.  See :ref:`coordinate-system`. If
+                    None is given instead of a tuple, all of the image is
+                    assumed.
+        """
+        im.load()
+        if self.mode != im.mode:
+            im = im.convert(self.mode)
+        if box:
+            self.image.paste(im.im, box)
+        else:
+            self.image.paste(im.im)
+
+    def frombytes(self, buffer):
+        """
+        Load display memory contents from byte data.
+
+        :param buffer: A buffer containing display data (usually
+                       data returned from :py:func:`~PIL.ImageWin.Dib.tobytes`)
+        """
+        return self.image.frombytes(buffer)
+
+    def tobytes(self):
+        """
+        Copy display memory contents to bytes object.
+
+        :return: A bytes object containing display data.
+        """
+        return self.image.tobytes()
+
+
+class Window:
+    """Create a Window with the given title size."""
+
+    def __init__(self, title="PIL", width=None, height=None):
+        self.hwnd = Image.core.createwindow(
+            title, self.__dispatcher, width or 0, height or 0
+        )
+
+    def __dispatcher(self, action, *args):
+        return getattr(self, "ui_handle_" + action)(*args)
+
+    def ui_handle_clear(self, dc, x0, y0, x1, y1):
+        pass
+
+    def ui_handle_damage(self, x0, y0, x1, y1):
+        pass
+
+    def ui_handle_destroy(self):
+        pass
+
+    def ui_handle_repair(self, dc, x0, y0, x1, y1):
+        pass
+
+    def ui_handle_resize(self, width, height):
+        pass
+
+    def mainloop(self):
+        Image.core.eventloop()
+
+
+class ImageWindow(Window):
+    """Create an image window which displays the given image."""
+
+    def __init__(self, image, title="PIL"):
+        if not isinstance(image, Dib):
+            image = Dib(image)
+        self.image = image
+        width, height = image.size
+        super().__init__(title, width=width, height=height)
+
+    def ui_handle_repair(self, dc, x0, y0, x1, y1):
+        self.image.draw(dc, (x0, y0, x1, y1))

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/PIL/ImtImagePlugin.py

@@ -0,0 +1,93 @@
+#
+# The Python Imaging Library.
+# $Id$
+#
+# IM Tools support for PIL
+#
+# history:
+# 1996-05-27 fl   Created (read 8-bit images only)
+# 2001-02-17 fl   Use 're' instead of 'regex' (Python 2.1) (0.2)
+#
+# Copyright (c) Secret Labs AB 1997-2001.
+# Copyright (c) Fredrik Lundh 1996-2001.
+#
+# See the README file for information on usage and redistribution.
+#
+
+
+import re
+
+from . import Image, ImageFile
+
+#
+# --------------------------------------------------------------------
+
+field = re.compile(rb"([a-z]*) ([^ \r\n]*)")
+
+
+##
+# Image plugin for IM Tools images.
+
+
+class ImtImageFile(ImageFile.ImageFile):
+
+    format = "IMT"
+    format_description = "IM Tools"
+
+    def _open(self):
+
+        # Quick rejection: if there's not a LF among the first
+        # 100 bytes, this is (probably) not a text header.
+
+        if b"\n" not in self.fp.read(100):
+            raise SyntaxError("not an IM file")
+        self.fp.seek(0)
+
+        xsize = ysize = 0
+
+        while True:
+
+            s = self.fp.read(1)
+            if not s:
+                break
+
+            if s == b"\x0C":
+
+                # image data begins
+                self.tile = [
+                    ("raw", (0, 0) + self.size, self.fp.tell(), (self.mode, 0, 1))
+                ]
+
+                break
+
+            else:
+
+                # read key/value pair
+                # FIXME: dangerous, may read whole file
+                s = s + self.fp.readline()
+                if len(s) == 1 or len(s) > 100:
+                    break
+                if s[0] == ord(b"*"):
+                    continue  # comment
+
+                m = field.match(s)
+                if not m:
+                    break
+                k, v = m.group(1, 2)
+                if k == "width":
+                    xsize = int(v)
+                    self._size = xsize, ysize
+                elif k == "height":
+                    ysize = int(v)
+                    self._size = xsize, ysize
+                elif k == "pixel" and v == "n8":
+                    self.mode = "L"
+
+
+#
+# --------------------------------------------------------------------
+
+Image.register_open(ImtImageFile.format, ImtImageFile)
+
+#
+# no extension registered (".im" is simply too common)

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/PIL/IptcImagePlugin.py

@@ -0,0 +1,230 @@
+#
+# The Python Imaging Library.
+# $Id$
+#
+# IPTC/NAA file handling
+#
+# history:
+# 1995-10-01 fl   Created
+# 1998-03-09 fl   Cleaned up and added to PIL
+# 2002-06-18 fl   Added getiptcinfo helper
+#
+# Copyright (c) Secret Labs AB 1997-2002.
+# Copyright (c) Fredrik Lundh 1995.
+#
+# See the README file for information on usage and redistribution.
+#
+import os
+import tempfile
+
+from . import Image, ImageFile
+from ._binary import i8
+from ._binary import i16be as i16
+from ._binary import i32be as i32
+from ._binary import o8
+
+COMPRESSION = {1: "raw", 5: "jpeg"}
+
+PAD = o8(0) * 4
+
+
+#
+# Helpers
+
+
+def i(c):
+    return i32((PAD + c)[-4:])
+
+
+def dump(c):
+    for i in c:
+        print("%02x" % i8(i), end=" ")
+    print()
+
+
+##
+# Image plugin for IPTC/NAA datastreams.  To read IPTC/NAA fields
+# from TIFF and JPEG files, use the <b>getiptcinfo</b> function.
+
+
+class IptcImageFile(ImageFile.ImageFile):
+
+    format = "IPTC"
+    format_description = "IPTC/NAA"
+
+    def getint(self, key):
+        return i(self.info[key])
+
+    def field(self):
+        #
+        # get a IPTC field header
+        s = self.fp.read(5)
+        if not len(s):
+            return None, 0
+
+        tag = s[1], s[2]
+
+        # syntax
+        if s[0] != 0x1C or tag[0] < 1 or tag[0] > 9:
+            raise SyntaxError("invalid IPTC/NAA file")
+
+        # field size
+        size = s[3]
+        if size > 132:
+            raise OSError("illegal field length in IPTC/NAA file")
+        elif size == 128:
+            size = 0
+        elif size > 128:
+            size = i(self.fp.read(size - 128))
+        else:
+            size = i16(s, 3)
+
+        return tag, size
+
+    def _open(self):
+
+        # load descriptive fields
+        while True:
+            offset = self.fp.tell()
+            tag, size = self.field()
+            if not tag or tag == (8, 10):
+                break
+            if size:
+                tagdata = self.fp.read(size)
+            else:
+                tagdata = None
+            if tag in self.info:
+                if isinstance(self.info[tag], list):
+                    self.info[tag].append(tagdata)
+                else:
+                    self.info[tag] = [self.info[tag], tagdata]
+            else:
+                self.info[tag] = tagdata
+
+        # mode
+        layers = i8(self.info[(3, 60)][0])
+        component = i8(self.info[(3, 60)][1])
+        if (3, 65) in self.info:
+            id = i8(self.info[(3, 65)][0]) - 1
+        else:
+            id = 0
+        if layers == 1 and not component:
+            self.mode = "L"
+        elif layers == 3 and component:
+            self.mode = "RGB"[id]
+        elif layers == 4 and component:
+            self.mode = "CMYK"[id]
+
+        # size
+        self._size = self.getint((3, 20)), self.getint((3, 30))
+
+        # compression
+        try:
+            compression = COMPRESSION[self.getint((3, 120))]
+        except KeyError as e:
+            raise OSError("Unknown IPTC image compression") from e
+
+        # tile
+        if tag == (8, 10):
+            self.tile = [
+                ("iptc", (compression, offset), (0, 0, self.size[0], self.size[1]))
+            ]
+
+    def load(self):
+
+        if len(self.tile) != 1 or self.tile[0][0] != "iptc":
+            return ImageFile.ImageFile.load(self)
+
+        type, tile, box = self.tile[0]
+
+        encoding, offset = tile
+
+        self.fp.seek(offset)
+
+        # Copy image data to temporary file
+        o_fd, outfile = tempfile.mkstemp(text=False)
+        o = os.fdopen(o_fd)
+        if encoding == "raw":
+            # To simplify access to the extracted file,
+            # prepend a PPM header
+            o.write("P5\n%d %d\n255\n" % self.size)
+        while True:
+            type, size = self.field()
+            if type != (8, 10):
+                break
+            while size > 0:
+                s = self.fp.read(min(size, 8192))
+                if not s:
+                    break
+                o.write(s)
+                size -= len(s)
+        o.close()
+
+        try:
+            with Image.open(outfile) as _im:
+                _im.load()
+                self.im = _im.im
+        finally:
+            try:
+                os.unlink(outfile)
+            except OSError:
+                pass
+
+
+Image.register_open(IptcImageFile.format, IptcImageFile)
+
+Image.register_extension(IptcImageFile.format, ".iim")
+
+
+def getiptcinfo(im):
+    """
+    Get IPTC information from TIFF, JPEG, or IPTC file.
+
+    :param im: An image containing IPTC data.
+    :returns: A dictionary containing IPTC information, or None if
+        no IPTC information block was found.
+    """
+    import io
+
+    from . import JpegImagePlugin, TiffImagePlugin
+
+    data = None
+
+    if isinstance(im, IptcImageFile):
+        # return info dictionary right away
+        return im.info
+
+    elif isinstance(im, JpegImagePlugin.JpegImageFile):
+        # extract the IPTC/NAA resource
+        photoshop = im.info.get("photoshop")
+        if photoshop:
+            data = photoshop.get(0x0404)
+
+    elif isinstance(im, TiffImagePlugin.TiffImageFile):
+        # get raw data from the IPTC/NAA tag (PhotoShop tags the data
+        # as 4-byte integers, so we cannot use the get method...)
+        try:
+            data = im.tag.tagdata[TiffImagePlugin.IPTC_NAA_CHUNK]
+        except (AttributeError, KeyError):
+            pass
+
+    if data is None:
+        return None  # no properties
+
+    # create an IptcImagePlugin object without initializing it
+    class FakeImage:
+        pass
+
+    im = FakeImage()
+    im.__class__ = IptcImageFile
+
+    # parse the IPTC information chunk
+    im.info = {}
+    im.fp = io.BytesIO(data)
+
+    try:
+        im._open()
+    except (IndexError, KeyError):
+        pass  # expected failure
+
+    return im.info

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/PIL/JpegPresets.py

@@ -0,0 +1,240 @@
+"""
+JPEG quality settings equivalent to the Photoshop settings.
+Can be used when saving JPEG files.
+
+The following presets are available by default:
+``web_low``, ``web_medium``, ``web_high``, ``web_very_high``, ``web_maximum``,
+``low``, ``medium``, ``high``, ``maximum``.
+More presets can be added to the :py:data:`presets` dict if needed.
+
+To apply the preset, specify::
+
+  quality="preset_name"
+
+To apply only the quantization table::
+
+  qtables="preset_name"
+
+To apply only the subsampling setting::
+
+  subsampling="preset_name"
+
+Example::
+
+  im.save("image_name.jpg", quality="web_high")
+
+Subsampling
+-----------
+
+Subsampling is the practice of encoding images by implementing less resolution
+for chroma information than for luma information.
+(ref.: https://en.wikipedia.org/wiki/Chroma_subsampling)
+
+Possible subsampling values are 0, 1 and 2 that correspond to 4:4:4, 4:2:2 and
+4:2:0.
+
+You can get the subsampling of a JPEG with the
+:func:`.JpegImagePlugin.get_sampling` function.
+
+In JPEG compressed data a JPEG marker is used instead of an EXIF tag.
+(ref.: https://www.exiv2.org/tags.html)
+
+
+Quantization tables
+-------------------
+
+They are values use by the DCT (Discrete cosine transform) to remove
+*unnecessary* information from the image (the lossy part of the compression).
+(ref.: https://en.wikipedia.org/wiki/Quantization_matrix#Quantization_matrices,
+https://en.wikipedia.org/wiki/JPEG#Quantization)
+
+You can get the quantization tables of a JPEG with::
+
+  im.quantization
+
+This will return a dict with a number of lists. You can pass this dict
+directly as the qtables argument when saving a JPEG.
+
+The quantization table format in presets is a list with sublists. These formats
+are interchangeable.
+
+Libjpeg ref.:
+https://web.archive.org/web/20120328125543/http://www.jpegcameras.com/libjpeg/libjpeg-3.html
+
+"""
+
+# fmt: off
+presets = {
+            'web_low':      {'subsampling':  2,  # "4:2:0"
+                             'quantization': [
+                               [20, 16, 25, 39, 50, 46, 62, 68,
+                                16, 18, 23, 38, 38, 53, 65, 68,
+                                25, 23, 31, 38, 53, 65, 68, 68,
+                                39, 38, 38, 53, 65, 68, 68, 68,
+                                50, 38, 53, 65, 68, 68, 68, 68,
+                                46, 53, 65, 68, 68, 68, 68, 68,
+                                62, 65, 68, 68, 68, 68, 68, 68,
+                                68, 68, 68, 68, 68, 68, 68, 68],
+                               [21, 25, 32, 38, 54, 68, 68, 68,
+                                25, 28, 24, 38, 54, 68, 68, 68,
+                                32, 24, 32, 43, 66, 68, 68, 68,
+                                38, 38, 43, 53, 68, 68, 68, 68,
+                                54, 54, 66, 68, 68, 68, 68, 68,
+                                68, 68, 68, 68, 68, 68, 68, 68,
+                                68, 68, 68, 68, 68, 68, 68, 68,
+                                68, 68, 68, 68, 68, 68, 68, 68]
+                              ]},
+            'web_medium':   {'subsampling':  2,  # "4:2:0"
+                             'quantization': [
+                               [16, 11, 11, 16, 23, 27, 31, 30,
+                                11, 12, 12, 15, 20, 23, 23, 30,
+                                11, 12, 13, 16, 23, 26, 35, 47,
+                                16, 15, 16, 23, 26, 37, 47, 64,
+                                23, 20, 23, 26, 39, 51, 64, 64,
+                                27, 23, 26, 37, 51, 64, 64, 64,
+                                31, 23, 35, 47, 64, 64, 64, 64,
+                                30, 30, 47, 64, 64, 64, 64, 64],
+                               [17, 15, 17, 21, 20, 26, 38, 48,
+                                15, 19, 18, 17, 20, 26, 35, 43,
+                                17, 18, 20, 22, 26, 30, 46, 53,
+                                21, 17, 22, 28, 30, 39, 53, 64,
+                                20, 20, 26, 30, 39, 48, 64, 64,
+                                26, 26, 30, 39, 48, 63, 64, 64,
+                                38, 35, 46, 53, 64, 64, 64, 64,
+                                48, 43, 53, 64, 64, 64, 64, 64]
+                             ]},
+            'web_high':     {'subsampling':  0,  # "4:4:4"
+                             'quantization': [
+                               [6,   4,  4,  6,  9, 11, 12, 16,
+                                4,   5,  5,  6,  8, 10, 12, 12,
+                                4,   5,  5,  6, 10, 12, 14, 19,
+                                6,   6,  6, 11, 12, 15, 19, 28,
+                                9,   8, 10, 12, 16, 20, 27, 31,
+                                11, 10, 12, 15, 20, 27, 31, 31,
+                                12, 12, 14, 19, 27, 31, 31, 31,
+                                16, 12, 19, 28, 31, 31, 31, 31],
+                               [7,   7, 13, 24, 26, 31, 31, 31,
+                                7,  12, 16, 21, 31, 31, 31, 31,
+                                13, 16, 17, 31, 31, 31, 31, 31,
+                                24, 21, 31, 31, 31, 31, 31, 31,
+                                26, 31, 31, 31, 31, 31, 31, 31,
+                                31, 31, 31, 31, 31, 31, 31, 31,
+                                31, 31, 31, 31, 31, 31, 31, 31,
+                                31, 31, 31, 31, 31, 31, 31, 31]
+                             ]},
+            'web_very_high': {'subsampling':  0,  # "4:4:4"
+                              'quantization': [
+                               [2,   2,  2,  2,  3,  4,  5,  6,
+                                2,   2,  2,  2,  3,  4,  5,  6,
+                                2,   2,  2,  2,  4,  5,  7,  9,
+                                2,   2,  2,  4,  5,  7,  9, 12,
+                                3,   3,  4,  5,  8, 10, 12, 12,
+                                4,   4,  5,  7, 10, 12, 12, 12,
+                                5,   5,  7,  9, 12, 12, 12, 12,
+                                6,   6,  9, 12, 12, 12, 12, 12],
+                               [3,   3,  5,  9, 13, 15, 15, 15,
+                                3,   4,  6, 11, 14, 12, 12, 12,
+                                5,   6,  9, 14, 12, 12, 12, 12,
+                                9,  11, 14, 12, 12, 12, 12, 12,
+                                13, 14, 12, 12, 12, 12, 12, 12,
+                                15, 12, 12, 12, 12, 12, 12, 12,
+                                15, 12, 12, 12, 12, 12, 12, 12,
+                                15, 12, 12, 12, 12, 12, 12, 12]
+                              ]},
+            'web_maximum':  {'subsampling':  0,  # "4:4:4"
+                             'quantization': [
+                                [1,  1,  1,  1,  1,  1,  1,  1,
+                                 1,  1,  1,  1,  1,  1,  1,  1,
+                                 1,  1,  1,  1,  1,  1,  1,  2,
+                                 1,  1,  1,  1,  1,  1,  2,  2,
+                                 1,  1,  1,  1,  1,  2,  2,  3,
+                                 1,  1,  1,  1,  2,  2,  3,  3,
+                                 1,  1,  1,  2,  2,  3,  3,  3,
+                                 1,  1,  2,  2,  3,  3,  3,  3],
+                                [1,  1,  1,  2,  2,  3,  3,  3,
+                                 1,  1,  1,  2,  3,  3,  3,  3,
+                                 1,  1,  1,  3,  3,  3,  3,  3,
+                                 2,  2,  3,  3,  3,  3,  3,  3,
+                                 2,  3,  3,  3,  3,  3,  3,  3,
+                                 3,  3,  3,  3,  3,  3,  3,  3,
+                                 3,  3,  3,  3,  3,  3,  3,  3,
+                                 3,  3,  3,  3,  3,  3,  3,  3]
+                             ]},
+            'low':          {'subsampling':  2,  # "4:2:0"
+                             'quantization': [
+                               [18, 14, 14, 21, 30, 35, 34, 17,
+                                14, 16, 16, 19, 26, 23, 12, 12,
+                                14, 16, 17, 21, 23, 12, 12, 12,
+                                21, 19, 21, 23, 12, 12, 12, 12,
+                                30, 26, 23, 12, 12, 12, 12, 12,
+                                35, 23, 12, 12, 12, 12, 12, 12,
+                                34, 12, 12, 12, 12, 12, 12, 12,
+                                17, 12, 12, 12, 12, 12, 12, 12],
+                               [20, 19, 22, 27, 20, 20, 17, 17,
+                                19, 25, 23, 14, 14, 12, 12, 12,
+                                22, 23, 14, 14, 12, 12, 12, 12,
+                                27, 14, 14, 12, 12, 12, 12, 12,
+                                20, 14, 12, 12, 12, 12, 12, 12,
+                                20, 12, 12, 12, 12, 12, 12, 12,
+                                17, 12, 12, 12, 12, 12, 12, 12,
+                                17, 12, 12, 12, 12, 12, 12, 12]
+                             ]},
+            'medium':       {'subsampling':  2,  # "4:2:0"
+                             'quantization': [
+                               [12,  8,  8, 12, 17, 21, 24, 17,
+                                8,   9,  9, 11, 15, 19, 12, 12,
+                                8,   9, 10, 12, 19, 12, 12, 12,
+                                12, 11, 12, 21, 12, 12, 12, 12,
+                                17, 15, 19, 12, 12, 12, 12, 12,
+                                21, 19, 12, 12, 12, 12, 12, 12,
+                                24, 12, 12, 12, 12, 12, 12, 12,
+                                17, 12, 12, 12, 12, 12, 12, 12],
+                               [13, 11, 13, 16, 20, 20, 17, 17,
+                                11, 14, 14, 14, 14, 12, 12, 12,
+                                13, 14, 14, 14, 12, 12, 12, 12,
+                                16, 14, 14, 12, 12, 12, 12, 12,
+                                20, 14, 12, 12, 12, 12, 12, 12,
+                                20, 12, 12, 12, 12, 12, 12, 12,
+                                17, 12, 12, 12, 12, 12, 12, 12,
+                                17, 12, 12, 12, 12, 12, 12, 12]
+                             ]},
+            'high':         {'subsampling':  0,  # "4:4:4"
+                             'quantization': [
+                               [6,   4,  4,  6,  9, 11, 12, 16,
+                                4,   5,  5,  6,  8, 10, 12, 12,
+                                4,   5,  5,  6, 10, 12, 12, 12,
+                                6,   6,  6, 11, 12, 12, 12, 12,
+                                9,   8, 10, 12, 12, 12, 12, 12,
+                                11, 10, 12, 12, 12, 12, 12, 12,
+                                12, 12, 12, 12, 12, 12, 12, 12,
+                                16, 12, 12, 12, 12, 12, 12, 12],
+                               [7,   7, 13, 24, 20, 20, 17, 17,
+                                7,  12, 16, 14, 14, 12, 12, 12,
+                                13, 16, 14, 14, 12, 12, 12, 12,
+                                24, 14, 14, 12, 12, 12, 12, 12,
+                                20, 14, 12, 12, 12, 12, 12, 12,
+                                20, 12, 12, 12, 12, 12, 12, 12,
+                                17, 12, 12, 12, 12, 12, 12, 12,
+                                17, 12, 12, 12, 12, 12, 12, 12]
+                             ]},
+            'maximum':      {'subsampling':  0,  # "4:4:4"
+                             'quantization': [
+                               [2,   2,  2,  2,  3,  4,  5,  6,
+                                2,   2,  2,  2,  3,  4,  5,  6,
+                                2,   2,  2,  2,  4,  5,  7,  9,
+                                2,   2,  2,  4,  5,  7,  9, 12,
+                                3,   3,  4,  5,  8, 10, 12, 12,
+                                4,   4,  5,  7, 10, 12, 12, 12,
+                                5,   5,  7,  9, 12, 12, 12, 12,
+                                6,   6,  9, 12, 12, 12, 12, 12],
+                               [3,   3,  5,  9, 13, 15, 15, 15,
+                                3,   4,  6, 10, 14, 12, 12, 12,
+                                5,   6,  9, 14, 12, 12, 12, 12,
+                                9,  10, 14, 12, 12, 12, 12, 12,
+                                13, 14, 12, 12, 12, 12, 12, 12,
+                                15, 12, 12, 12, 12, 12, 12, 12,
+                                15, 12, 12, 12, 12, 12, 12, 12,
+                                15, 12, 12, 12, 12, 12, 12, 12]
+                             ]},
+}
+# fmt: on

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/PIL/MicImagePlugin.py

@@ -0,0 +1,107 @@
+#
+# The Python Imaging Library.
+# $Id$
+#
+# Microsoft Image Composer support for PIL
+#
+# Notes:
+#       uses TiffImagePlugin.py to read the actual image streams
+#
+# History:
+#       97-01-20 fl     Created
+#
+# Copyright (c) Secret Labs AB 1997.
+# Copyright (c) Fredrik Lundh 1997.
+#
+# See the README file for information on usage and redistribution.
+#
+
+
+import olefile
+
+from . import Image, TiffImagePlugin
+
+#
+# --------------------------------------------------------------------
+
+
+def _accept(prefix):
+    return prefix[:8] == olefile.MAGIC
+
+
+##
+# Image plugin for Microsoft's Image Composer file format.
+
+
+class MicImageFile(TiffImagePlugin.TiffImageFile):
+
+    format = "MIC"
+    format_description = "Microsoft Image Composer"
+    _close_exclusive_fp_after_loading = False
+
+    def _open(self):
+
+        # read the OLE directory and see if this is a likely
+        # to be a Microsoft Image Composer file
+
+        try:
+            self.ole = olefile.OleFileIO(self.fp)
+        except OSError as e:
+            raise SyntaxError("not an MIC file; invalid OLE file") from e
+
+        # find ACI subfiles with Image members (maybe not the
+        # best way to identify MIC files, but what the... ;-)
+
+        self.images = []
+        for path in self.ole.listdir():
+            if path[1:] and path[0][-4:] == ".ACI" and path[1] == "Image":
+                self.images.append(path)
+
+        # if we didn't find any images, this is probably not
+        # an MIC file.
+        if not self.images:
+            raise SyntaxError("not an MIC file; no image entries")
+
+        self.__fp = self.fp
+        self.frame = None
+        self._n_frames = len(self.images)
+        self.is_animated = self._n_frames > 1
+
+        if len(self.images) > 1:
+            self._category = Image.CONTAINER
+
+        self.seek(0)
+
+    def seek(self, frame):
+        if not self._seek_check(frame):
+            return
+        try:
+            filename = self.images[frame]
+        except IndexError as e:
+            raise EOFError("no such frame") from e
+
+        self.fp = self.ole.openstream(filename)
+
+        TiffImagePlugin.TiffImageFile._open(self)
+
+        self.frame = frame
+
+    def tell(self):
+        return self.frame
+
+    def _close__fp(self):
+        try:
+            if self.__fp != self.fp:
+                self.__fp.close()
+        except AttributeError:
+            pass
+        finally:
+            self.__fp = None
+
+
+#
+# --------------------------------------------------------------------
+
+Image.register_open(MicImageFile.format, MicImageFile, _accept)
+
+Image.register_extension(MicImageFile.format, ".mic")

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/PIL/MspImagePlugin.py

@@ -0,0 +1,194 @@
+#
+# The Python Imaging Library.
+#
+# MSP file handling
+#
+# This is the format used by the Paint program in Windows 1 and 2.
+#
+# History:
+#       95-09-05 fl     Created
+#       97-01-03 fl     Read/write MSP images
+#       17-02-21 es     Fixed RLE interpretation
+#
+# Copyright (c) Secret Labs AB 1997.
+# Copyright (c) Fredrik Lundh 1995-97.
+# Copyright (c) Eric Soroos 2017.
+#
+# See the README file for information on usage and redistribution.
+#
+# More info on this format: https://archive.org/details/gg243631
+# Page 313:
+# Figure 205. Windows Paint Version 1: "DanM" Format
+# Figure 206. Windows Paint Version 2: "LinS" Format. Used in Windows V2.03
+#
+# See also: https://www.fileformat.info/format/mspaint/egff.htm
+
+import io
+import struct
+
+from . import Image, ImageFile
+from ._binary import i16le as i16
+from ._binary import o16le as o16
+
+#
+# read MSP files
+
+
+def _accept(prefix):
+    return prefix[:4] in [b"DanM", b"LinS"]
+
+
+##
+# Image plugin for Windows MSP images.  This plugin supports both
+# uncompressed (Windows 1.0).
+
+
+class MspImageFile(ImageFile.ImageFile):
+
+    format = "MSP"
+    format_description = "Windows Paint"
+
+    def _open(self):
+
+        # Header
+        s = self.fp.read(32)
+        if not _accept(s):
+            raise SyntaxError("not an MSP file")
+
+        # Header checksum
+        checksum = 0
+        for i in range(0, 32, 2):
+            checksum = checksum ^ i16(s, i)
+        if checksum != 0:
+            raise SyntaxError("bad MSP checksum")
+
+        self.mode = "1"
+        self._size = i16(s, 4), i16(s, 6)
+
+        if s[:4] == b"DanM":
+            self.tile = [("raw", (0, 0) + self.size, 32, ("1", 0, 1))]
+        else:
+            self.tile = [("MSP", (0, 0) + self.size, 32, None)]
+
+
+class MspDecoder(ImageFile.PyDecoder):
+    # The algo for the MSP decoder is from
+    # https://www.fileformat.info/format/mspaint/egff.htm
+    # cc-by-attribution -- That page references is taken from the
+    # Encyclopedia of Graphics File Formats and is licensed by
+    # O'Reilly under the Creative Common/Attribution license
+    #
+    # For RLE encoded files, the 32byte header is followed by a scan
+    # line map, encoded as one 16bit word of encoded byte length per
+    # line.
+    #
+    # NOTE: the encoded length of the line can be 0. This was not
+    # handled in the previous version of this encoder, and there's no
+    # mention of how to handle it in the documentation. From the few
+    # examples I've seen, I've assumed that it is a fill of the
+    # background color, in this case, white.
+    #
+    #
+    # Pseudocode of the decoder:
+    # Read a BYTE value as the RunType
+    #  If the RunType value is zero
+    #   Read next byte as the RunCount
+    #   Read the next byte as the RunValue
+    #   Write the RunValue byte RunCount times
+    #  If the RunType value is non-zero
+    #   Use this value as the RunCount
+    #   Read and write the next RunCount bytes literally
+    #
+    #  e.g.:
+    #  0x00 03 ff 05 00 01 02 03 04
+    #  would yield the bytes:
+    #  0xff ff ff 00 01 02 03 04
+    #
+    # which are then interpreted as a bit packed mode '1' image
+
+    _pulls_fd = True
+
+    def decode(self, buffer):
+
+        img = io.BytesIO()
+        blank_line = bytearray((0xFF,) * ((self.state.xsize + 7) // 8))
+        try:
+            self.fd.seek(32)
+            rowmap = struct.unpack_from(
+                f"<{self.state.ysize}H", self.fd.read(self.state.ysize * 2)
+            )
+        except struct.error as e:
+            raise OSError("Truncated MSP file in row map") from e
+
+        for x, rowlen in enumerate(rowmap):
+            try:
+                if rowlen == 0:
+                    img.write(blank_line)
+                    continue
+                row = self.fd.read(rowlen)
+                if len(row) != rowlen:
+                    raise OSError(
+                        "Truncated MSP file, expected %d bytes on row %s", (rowlen, x)
+                    )
+                idx = 0
+                while idx < rowlen:
+                    runtype = row[idx]
+                    idx += 1
+                    if runtype == 0:
+                        (runcount, runval) = struct.unpack_from("Bc", row, idx)
+                        img.write(runval * runcount)
+                        idx += 2
+                    else:
+                        runcount = runtype
+                        img.write(row[idx : idx + runcount])
+                        idx += runcount
+
+            except struct.error as e:
+                raise OSError(f"Corrupted MSP file in row {x}") from e
+
+        self.set_as_raw(img.getvalue(), ("1", 0, 1))
+
+        return -1, 0
+
+
+Image.register_decoder("MSP", MspDecoder)
+
+
+#
+# write MSP files (uncompressed only)
+
+
+def _save(im, fp, filename):
+
+    if im.mode != "1":
+        raise OSError(f"cannot write mode {im.mode} as MSP")
+
+    # create MSP header
+    header = [0] * 16
+
+    header[0], header[1] = i16(b"Da"), i16(b"nM")  # version 1
+    header[2], header[3] = im.size
+    header[4], header[5] = 1, 1
+    header[6], header[7] = 1, 1
+    header[8], header[9] = im.size
+
+    checksum = 0
+    for h in header:
+        checksum = checksum ^ h
+    header[12] = checksum  # FIXME: is this the right field?
+
+    # header
+    for h in header:
+        fp.write(o16(h))
+
+    # image body
+    ImageFile._save(im, fp, [("raw", (0, 0) + im.size, 32, ("1", 0, 1))])
+
+
+#
+# registry
+
+Image.register_open(MspImageFile.format, MspImageFile, _accept)
+Image.register_save(MspImageFile.format, _save)
+
+Image.register_extension(MspImageFile.format, ".msp")

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/PIL/PaletteFile.py

@@ -0,0 +1,53 @@
+#
+# Python Imaging Library
+# $Id$
+#
+# stuff to read simple, teragon-style palette files
+#
+# History:
+#       97-08-23 fl     Created
+#
+# Copyright (c) Secret Labs AB 1997.
+# Copyright (c) Fredrik Lundh 1997.
+#
+# See the README file for information on usage and redistribution.
+#
+
+from ._binary import o8
+
+
+class PaletteFile:
+    """File handler for Teragon-style palette files."""
+
+    rawmode = "RGB"
+
+    def __init__(self, fp):
+
+        self.palette = [(i, i, i) for i in range(256)]
+
+        while True:
+
+            s = fp.readline()
+
+            if not s:
+                break
+            if s[0:1] == b"#":
+                continue
+            if len(s) > 100:
+                raise SyntaxError("bad palette file")
+
+            v = [int(x) for x in s.split()]
+            try:
+                [i, r, g, b] = v
+            except ValueError:
+                [i, r] = v
+                g = b = r
+
+            if 0 <= i <= 255:
+                self.palette[i] = o8(r) + o8(g) + o8(b)
+
+        self.palette = b"".join(self.palette)
+
+    def getpalette(self):
+
+        return self.palette, self.rawmode

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/PIL/PcdImagePlugin.py

@@ -0,0 +1,63 @@
+#
+# The Python Imaging Library.
+# $Id$
+#
+# PCD file handling
+#
+# History:
+#       96-05-10 fl     Created
+#       96-05-27 fl     Added draft mode (128x192, 256x384)
+#
+# Copyright (c) Secret Labs AB 1997.
+# Copyright (c) Fredrik Lundh 1996.
+#
+# See the README file for information on usage and redistribution.
+#
+
+
+from . import Image, ImageFile
+
+##
+# Image plugin for PhotoCD images.  This plugin only reads the 768x512
+# image from the file; higher resolutions are encoded in a proprietary
+# encoding.
+
+
+class PcdImageFile(ImageFile.ImageFile):
+
+    format = "PCD"
+    format_description = "Kodak PhotoCD"
+
+    def _open(self):
+
+        # rough
+        self.fp.seek(2048)
+        s = self.fp.read(2048)
+
+        if s[:4] != b"PCD_":
+            raise SyntaxError("not a PCD file")
+
+        orientation = s[1538] & 3
+        self.tile_post_rotate = None
+        if orientation == 1:
+            self.tile_post_rotate = 90
+        elif orientation == 3:
+            self.tile_post_rotate = -90
+
+        self.mode = "RGB"
+        self._size = 768, 512  # FIXME: not correct for rotated images!
+        self.tile = [("pcd", (0, 0) + self.size, 96 * 2048, None)]
+
+    def load_end(self):
+        if self.tile_post_rotate:
+            # Handle rotated PCDs
+            self.im = self.im.rotate(self.tile_post_rotate)
+            self._size = self.im.size
+
+
+#
+# registry
+
+Image.register_open(PcdImageFile.format, PcdImageFile)
+
+Image.register_extension(PcdImageFile.format, ".pcd")

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/PIL/PcfFontFile.py

@@ -0,0 +1,248 @@
+#
+# THIS IS WORK IN PROGRESS
+#
+# The Python Imaging Library
+# $Id$
+#
+# portable compiled font file parser
+#
+# history:
+# 1997-08-19 fl   created
+# 2003-09-13 fl   fixed loading of unicode fonts
+#
+# 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.
+#
+
+import io
+
+from . import FontFile, Image
+from ._binary import i8
+from ._binary import i16be as b16
+from ._binary import i16le as l16
+from ._binary import i32be as b32
+from ._binary import i32le as l32
+
+# --------------------------------------------------------------------
+# declarations
+
+PCF_MAGIC = 0x70636601  # "\x01fcp"
+
+PCF_PROPERTIES = 1 << 0
+PCF_ACCELERATORS = 1 << 1
+PCF_METRICS = 1 << 2
+PCF_BITMAPS = 1 << 3
+PCF_INK_METRICS = 1 << 4
+PCF_BDF_ENCODINGS = 1 << 5
+PCF_SWIDTHS = 1 << 6
+PCF_GLYPH_NAMES = 1 << 7
+PCF_BDF_ACCELERATORS = 1 << 8
+
+BYTES_PER_ROW = [
+    lambda bits: ((bits + 7) >> 3),
+    lambda bits: ((bits + 15) >> 3) & ~1,
+    lambda bits: ((bits + 31) >> 3) & ~3,
+    lambda bits: ((bits + 63) >> 3) & ~7,
+]
+
+
+def sz(s, o):
+    return s[o : s.index(b"\0", o)]
+
+
+class PcfFontFile(FontFile.FontFile):
+    """Font file plugin for the X11 PCF format."""
+
+    name = "name"
+
+    def __init__(self, fp, charset_encoding="iso8859-1"):
+
+        self.charset_encoding = charset_encoding
+
+        magic = l32(fp.read(4))
+        if magic != PCF_MAGIC:
+            raise SyntaxError("not a PCF file")
+
+        super().__init__()
+
+        count = l32(fp.read(4))
+        self.toc = {}
+        for i in range(count):
+            type = l32(fp.read(4))
+            self.toc[type] = l32(fp.read(4)), l32(fp.read(4)), l32(fp.read(4))
+
+        self.fp = fp
+
+        self.info = self._load_properties()
+
+        metrics = self._load_metrics()
+        bitmaps = self._load_bitmaps(metrics)
+        encoding = self._load_encoding()
+
+        #
+        # create glyph structure
+
+        for ch in range(256):
+            ix = encoding[ch]
+            if ix is not None:
+                x, y, l, r, w, a, d, f = metrics[ix]
+                glyph = (w, 0), (l, d - y, x + l, d), (0, 0, x, y), bitmaps[ix]
+                self.glyph[ch] = glyph
+
+    def _getformat(self, tag):
+
+        format, size, offset = self.toc[tag]
+
+        fp = self.fp
+        fp.seek(offset)
+
+        format = l32(fp.read(4))
+
+        if format & 4:
+            i16, i32 = b16, b32
+        else:
+            i16, i32 = l16, l32
+
+        return fp, format, i16, i32
+
+    def _load_properties(self):
+
+        #
+        # font properties
+
+        properties = {}
+
+        fp, format, i16, i32 = self._getformat(PCF_PROPERTIES)
+
+        nprops = i32(fp.read(4))
+
+        # read property description
+        p = []
+        for i in range(nprops):
+            p.append((i32(fp.read(4)), i8(fp.read(1)), i32(fp.read(4))))
+        if nprops & 3:
+            fp.seek(4 - (nprops & 3), io.SEEK_CUR)  # pad
+
+        data = fp.read(i32(fp.read(4)))
+
+        for k, s, v in p:
+            k = sz(data, k)
+            if s:
+                v = sz(data, v)
+            properties[k] = v
+
+        return properties
+
+    def _load_metrics(self):
+
+        #
+        # font metrics
+
+        metrics = []
+
+        fp, format, i16, i32 = self._getformat(PCF_METRICS)
+
+        append = metrics.append
+
+        if (format & 0xFF00) == 0x100:
+
+            # "compressed" metrics
+            for i in range(i16(fp.read(2))):
+                left = i8(fp.read(1)) - 128
+                right = i8(fp.read(1)) - 128
+                width = i8(fp.read(1)) - 128
+                ascent = i8(fp.read(1)) - 128
+                descent = i8(fp.read(1)) - 128
+                xsize = right - left
+                ysize = ascent + descent
+                append((xsize, ysize, left, right, width, ascent, descent, 0))
+
+        else:
+
+            # "jumbo" metrics
+            for i in range(i32(fp.read(4))):
+                left = i16(fp.read(2))
+                right = i16(fp.read(2))
+                width = i16(fp.read(2))
+                ascent = i16(fp.read(2))
+                descent = i16(fp.read(2))
+                attributes = i16(fp.read(2))
+                xsize = right - left
+                ysize = ascent + descent
+                append((xsize, ysize, left, right, width, ascent, descent, attributes))
+
+        return metrics
+
+    def _load_bitmaps(self, metrics):
+
+        #
+        # bitmap data
+
+        bitmaps = []
+
+        fp, format, i16, i32 = self._getformat(PCF_BITMAPS)
+
+        nbitmaps = i32(fp.read(4))
+
+        if nbitmaps != len(metrics):
+            raise OSError("Wrong number of bitmaps")
+
+        offsets = []
+        for i in range(nbitmaps):
+            offsets.append(i32(fp.read(4)))
+
+        bitmapSizes = []
+        for i in range(4):
+            bitmapSizes.append(i32(fp.read(4)))
+
+        # byteorder = format & 4  # non-zero => MSB
+        bitorder = format & 8  # non-zero => MSB
+        padindex = format & 3
+
+        bitmapsize = bitmapSizes[padindex]
+        offsets.append(bitmapsize)
+
+        data = fp.read(bitmapsize)
+
+        pad = BYTES_PER_ROW[padindex]
+        mode = "1;R"
+        if bitorder:
+            mode = "1"
+
+        for i in range(nbitmaps):
+            x, y, l, r, w, a, d, f = metrics[i]
+            b, e = offsets[i], offsets[i + 1]
+            bitmaps.append(Image.frombytes("1", (x, y), data[b:e], "raw", mode, pad(x)))
+
+        return bitmaps
+
+    def _load_encoding(self):
+
+        # map character code to bitmap index
+        encoding = [None] * 256
+
+        fp, format, i16, i32 = self._getformat(PCF_BDF_ENCODINGS)
+
+        firstCol, lastCol = i16(fp.read(2)), i16(fp.read(2))
+        firstRow, lastRow = i16(fp.read(2)), i16(fp.read(2))
+
+        i16(fp.read(2))  # default
+
+        nencoding = (lastCol - firstCol + 1) * (lastRow - firstRow + 1)
+
+        encodingOffsets = [i16(fp.read(2)) for _ in range(nencoding)]
+
+        for i in range(firstCol, len(encoding)):
+            try:
+                encodingOffset = encodingOffsets[
+                    ord(bytearray([i]).decode(self.charset_encoding))
+                ]
+                if encodingOffset != 0xFFFF:
+                    encoding[i] = encodingOffset
+            except UnicodeDecodeError:
+                # character is not supported in selected encoding
+                pass
+
+        return encoding

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/PIL/PcxImagePlugin.py

@@ -0,0 +1,218 @@
+#
+# The Python Imaging Library.
+# $Id$
+#
+# PCX file handling
+#
+# This format was originally used by ZSoft's popular PaintBrush
+# program for the IBM PC.  It is also supported by many MS-DOS and
+# Windows applications, including the Windows PaintBrush program in
+# Windows 3.
+#
+# history:
+# 1995-09-01 fl   Created
+# 1996-05-20 fl   Fixed RGB support
+# 1997-01-03 fl   Fixed 2-bit and 4-bit support
+# 1999-02-03 fl   Fixed 8-bit support (broken in 1.0b1)
+# 1999-02-07 fl   Added write support
+# 2002-06-09 fl   Made 2-bit and 4-bit support a bit more robust
+# 2002-07-30 fl   Seek from to current position, not beginning of file
+# 2003-06-03 fl   Extract DPI settings (info["dpi"])
+#
+# 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.
+#
+
+import io
+import logging
+
+from . import Image, ImageFile, ImagePalette
+from ._binary import i16le as i16
+from ._binary import o8
+from ._binary import o16le as o16
+
+logger = logging.getLogger(__name__)
+
+
+def _accept(prefix):
+    return prefix[0] == 10 and prefix[1] in [0, 2, 3, 5]
+
+
+##
+# Image plugin for Paintbrush images.
+
+
+class PcxImageFile(ImageFile.ImageFile):
+
+    format = "PCX"
+    format_description = "Paintbrush"
+
+    def _open(self):
+
+        # header
+        s = self.fp.read(128)
+        if not _accept(s):
+            raise SyntaxError("not a PCX file")
+
+        # image
+        bbox = i16(s, 4), i16(s, 6), i16(s, 8) + 1, i16(s, 10) + 1
+        if bbox[2] <= bbox[0] or bbox[3] <= bbox[1]:
+            raise SyntaxError("bad PCX image size")
+        logger.debug("BBox: %s %s %s %s", *bbox)
+
+        # format
+        version = s[1]
+        bits = s[3]
+        planes = s[65]
+        provided_stride = i16(s, 66)
+        logger.debug(
+            "PCX version %s, bits %s, planes %s, stride %s",
+            version,
+            bits,
+            planes,
+            provided_stride,
+        )
+
+        self.info["dpi"] = i16(s, 12), i16(s, 14)
+
+        if bits == 1 and planes == 1:
+            mode = rawmode = "1"
+
+        elif bits == 1 and planes in (2, 4):
+            mode = "P"
+            rawmode = "P;%dL" % planes
+            self.palette = ImagePalette.raw("RGB", s[16:64])
+
+        elif version == 5 and bits == 8 and planes == 1:
+            mode = rawmode = "L"
+            # FIXME: hey, this doesn't work with the incremental loader !!!
+            self.fp.seek(-769, io.SEEK_END)
+            s = self.fp.read(769)
+            if len(s) == 769 and s[0] == 12:
+                # check if the palette is linear greyscale
+                for i in range(256):
+                    if s[i * 3 + 1 : i * 3 + 4] != o8(i) * 3:
+                        mode = rawmode = "P"
+                        break
+                if mode == "P":
+                    self.palette = ImagePalette.raw("RGB", s[1:])
+            self.fp.seek(128)
+
+        elif version == 5 and bits == 8 and planes == 3:
+            mode = "RGB"
+            rawmode = "RGB;L"
+
+        else:
+            raise OSError("unknown PCX mode")
+
+        self.mode = mode
+        self._size = bbox[2] - bbox[0], bbox[3] - bbox[1]
+
+        # Don't trust the passed in stride.
+        # Calculate the approximate position for ourselves.
+        # CVE-2020-35653
+        stride = (self._size[0] * bits + 7) // 8
+
+        # While the specification states that this must be even,
+        # not all images follow this
+        if provided_stride != stride:
+            stride += stride % 2
+
+        bbox = (0, 0) + self.size
+        logger.debug("size: %sx%s", *self.size)
+
+        self.tile = [("pcx", bbox, self.fp.tell(), (rawmode, planes * stride))]
+
+
+# --------------------------------------------------------------------
+# save PCX files
+
+
+SAVE = {
+    # mode: (version, bits, planes, raw mode)
+    "1": (2, 1, 1, "1"),
+    "L": (5, 8, 1, "L"),
+    "P": (5, 8, 1, "P"),
+    "RGB": (5, 8, 3, "RGB;L"),
+}
+
+
+def _save(im, fp, filename):
+
+    try:
+        version, bits, planes, rawmode = SAVE[im.mode]
+    except KeyError as e:
+        raise ValueError(f"Cannot save {im.mode} images as PCX") from e
+
+    # bytes per plane
+    stride = (im.size[0] * bits + 7) // 8
+    # stride should be even
+    stride += stride % 2
+    # Stride needs to be kept in sync with the PcxEncode.c version.
+    # Ideally it should be passed in in the state, but the bytes value
+    # gets overwritten.
+
+    logger.debug(
+        "PcxImagePlugin._save: xwidth: %d, bits: %d, stride: %d",
+        im.size[0],
+        bits,
+        stride,
+    )
+
+    # under windows, we could determine the current screen size with
+    # "Image.core.display_mode()[1]", but I think that's overkill...
+
+    screen = im.size
+
+    dpi = 100, 100
+
+    # PCX header
+    fp.write(
+        o8(10)
+        + o8(version)
+        + o8(1)
+        + o8(bits)
+        + o16(0)
+        + o16(0)
+        + o16(im.size[0] - 1)
+        + o16(im.size[1] - 1)
+        + o16(dpi[0])
+        + o16(dpi[1])
+        + b"\0" * 24
+        + b"\xFF" * 24
+        + b"\0"
+        + o8(planes)
+        + o16(stride)
+        + o16(1)
+        + o16(screen[0])
+        + o16(screen[1])
+        + b"\0" * 54
+    )
+
+    assert fp.tell() == 128
+
+    ImageFile._save(im, fp, [("pcx", (0, 0) + im.size, 0, (rawmode, bits * planes))])
+
+    if im.mode == "P":
+        # colour palette
+        fp.write(o8(12))
+        fp.write(im.im.getpalette("RGB", "RGB"))  # 768 bytes
+    elif im.mode == "L":
+        # greyscale palette
+        fp.write(o8(12))
+        for i in range(256):
+            fp.write(o8(i) * 3)
+
+
+# --------------------------------------------------------------------
+# registry
+
+
+Image.register_open(PcxImageFile.format, PcxImageFile, _accept)
+Image.register_save(PcxImageFile.format, _save)
+
+Image.register_extension(PcxImageFile.format, ".pcx")
+
+Image.register_mime(PcxImageFile.format, "image/x-pcx")

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/PIL/PdfImagePlugin.py

@@ -0,0 +1,239 @@
+#
+# The Python Imaging Library.
+# $Id$
+#
+# PDF (Acrobat) file handling
+#
+# History:
+# 1996-07-16 fl   Created
+# 1997-01-18 fl   Fixed header
+# 2004-02-21 fl   Fixes for 1/L/CMYK images, etc.
+# 2004-02-24 fl   Fixes for 1 and P images.
+#
+# Copyright (c) 1997-2004 by Secret Labs AB.  All rights reserved.
+# Copyright (c) 1996-1997 by Fredrik Lundh.
+#
+# See the README file for information on usage and redistribution.
+#
+
+##
+# Image plugin for PDF images (output only).
+##
+
+import io
+import os
+import time
+
+from . import Image, ImageFile, ImageSequence, PdfParser, __version__
+
+#
+# --------------------------------------------------------------------
+
+# object ids:
+#  1. catalogue
+#  2. pages
+#  3. image
+#  4. page
+#  5. page contents
+
+
+def _save_all(im, fp, filename):
+    _save(im, fp, filename, save_all=True)
+
+
+##
+# (Internal) Image save plugin for the PDF format.
+
+
+def _save(im, fp, filename, save_all=False):
+    is_appending = im.encoderinfo.get("append", False)
+    if is_appending:
+        existing_pdf = PdfParser.PdfParser(f=fp, filename=filename, mode="r+b")
+    else:
+        existing_pdf = PdfParser.PdfParser(f=fp, filename=filename, mode="w+b")
+
+    resolution = im.encoderinfo.get("resolution", 72.0)
+
+    info = {
+        "title": None
+        if is_appending
+        else os.path.splitext(os.path.basename(filename))[0],
+        "author": None,
+        "subject": None,
+        "keywords": None,
+        "creator": None,
+        "producer": None,
+        "creationDate": None if is_appending else time.gmtime(),
+        "modDate": None if is_appending else time.gmtime(),
+    }
+    for k, default in info.items():
+        v = im.encoderinfo.get(k) if k in im.encoderinfo else default
+        if v:
+            existing_pdf.info[k[0].upper() + k[1:]] = v
+
+    #
+    # make sure image data is available
+    im.load()
+
+    existing_pdf.start_writing()
+    existing_pdf.write_header()
+    existing_pdf.write_comment(f"created by Pillow {__version__} PDF driver")
+
+    #
+    # pages
+    ims = [im]
+    if save_all:
+        append_images = im.encoderinfo.get("append_images", [])
+        for append_im in append_images:
+            append_im.encoderinfo = im.encoderinfo.copy()
+            ims.append(append_im)
+    numberOfPages = 0
+    image_refs = []
+    page_refs = []
+    contents_refs = []
+    for im in ims:
+        im_numberOfPages = 1
+        if save_all:
+            try:
+                im_numberOfPages = im.n_frames
+            except AttributeError:
+                # Image format does not have n_frames.
+                # It is a single frame image
+                pass
+        numberOfPages += im_numberOfPages
+        for i in range(im_numberOfPages):
+            image_refs.append(existing_pdf.next_object_id(0))
+            page_refs.append(existing_pdf.next_object_id(0))
+            contents_refs.append(existing_pdf.next_object_id(0))
+            existing_pdf.pages.append(page_refs[-1])
+
+    #
+    # catalog and list of pages
+    existing_pdf.write_catalog()
+
+    pageNumber = 0
+    for imSequence in ims:
+        im_pages = ImageSequence.Iterator(imSequence) if save_all else [imSequence]
+        for im in im_pages:
+            # FIXME: Should replace ASCIIHexDecode with RunLengthDecode
+            # (packbits) or LZWDecode (tiff/lzw compression).  Note that
+            # PDF 1.2 also supports Flatedecode (zip compression).
+
+            bits = 8
+            params = None
+            decode = None
+
+            if im.mode == "1":
+                filter = "DCTDecode"
+                colorspace = PdfParser.PdfName("DeviceGray")
+                procset = "ImageB"  # grayscale
+            elif im.mode == "L":
+                filter = "DCTDecode"
+                # params = f"<< /Predictor 15 /Columns {width-2} >>"
+                colorspace = PdfParser.PdfName("DeviceGray")
+                procset = "ImageB"  # grayscale
+            elif im.mode == "P":
+                filter = "ASCIIHexDecode"
+                palette = im.getpalette()
+                colorspace = [
+                    PdfParser.PdfName("Indexed"),
+                    PdfParser.PdfName("DeviceRGB"),
+                    255,
+                    PdfParser.PdfBinary(palette),
+                ]
+                procset = "ImageI"  # indexed color
+            elif im.mode == "RGB":
+                filter = "DCTDecode"
+                colorspace = PdfParser.PdfName("DeviceRGB")
+                procset = "ImageC"  # color images
+            elif im.mode == "CMYK":
+                filter = "DCTDecode"
+                colorspace = PdfParser.PdfName("DeviceCMYK")
+                procset = "ImageC"  # color images
+                decode = [1, 0, 1, 0, 1, 0, 1, 0]
+            else:
+                raise ValueError(f"cannot save mode {im.mode}")
+
+            #
+            # image
+
+            op = io.BytesIO()
+
+            if filter == "ASCIIHexDecode":
+                ImageFile._save(im, op, [("hex", (0, 0) + im.size, 0, im.mode)])
+            elif filter == "DCTDecode":
+                Image.SAVE["JPEG"](im, op, filename)
+            elif filter == "FlateDecode":
+                ImageFile._save(im, op, [("zip", (0, 0) + im.size, 0, im.mode)])
+            elif filter == "RunLengthDecode":
+                ImageFile._save(im, op, [("packbits", (0, 0) + im.size, 0, im.mode)])
+            else:
+                raise ValueError(f"unsupported PDF filter ({filter})")
+
+            #
+            # Get image characteristics
+
+            width, height = im.size
+
+            existing_pdf.write_obj(
+                image_refs[pageNumber],
+                stream=op.getvalue(),
+                Type=PdfParser.PdfName("XObject"),
+                Subtype=PdfParser.PdfName("Image"),
+                Width=width,  # * 72.0 / resolution,
+                Height=height,  # * 72.0 / resolution,
+                Filter=PdfParser.PdfName(filter),
+                BitsPerComponent=bits,
+                Decode=decode,
+                DecodeParams=params,
+                ColorSpace=colorspace,
+            )
+
+            #
+            # page
+
+            existing_pdf.write_page(
+                page_refs[pageNumber],
+                Resources=PdfParser.PdfDict(
+                    ProcSet=[PdfParser.PdfName("PDF"), PdfParser.PdfName(procset)],
+                    XObject=PdfParser.PdfDict(image=image_refs[pageNumber]),
+                ),
+                MediaBox=[
+                    0,
+                    0,
+                    width * 72.0 / resolution,
+                    height * 72.0 / resolution,
+                ],
+                Contents=contents_refs[pageNumber],
+            )
+
+            #
+            # page contents
+
+            page_contents = b"q %f 0 0 %f 0 0 cm /image Do Q\n" % (
+                width * 72.0 / resolution,
+                height * 72.0 / resolution,
+            )
+
+            existing_pdf.write_obj(contents_refs[pageNumber], stream=page_contents)
+
+            pageNumber += 1
+
+    #
+    # trailer
+    existing_pdf.write_xref_and_trailer()
+    if hasattr(fp, "flush"):
+        fp.flush()
+    existing_pdf.close()
+
+
+#
+# --------------------------------------------------------------------
+
+
+Image.register_save("PDF", _save)
+Image.register_save_all("PDF", _save_all)
+
+Image.register_extension("PDF", ".pdf")
+
+Image.register_mime("PDF", "application/pdf")

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/PIL/PdfParser.py

@@ -0,0 +1,998 @@
+import calendar
+import codecs
+import collections
+import mmap
+import os
+import re
+import time
+import zlib
+
+
+# see 7.9.2.2 Text String Type on page 86 and D.3 PDFDocEncoding Character Set
+# on page 656
+def encode_text(s):
+    return codecs.BOM_UTF16_BE + s.encode("utf_16_be")
+
+
+PDFDocEncoding = {
+    0x16: "\u0017",
+    0x18: "\u02D8",
+    0x19: "\u02C7",
+    0x1A: "\u02C6",
+    0x1B: "\u02D9",
+    0x1C: "\u02DD",
+    0x1D: "\u02DB",
+    0x1E: "\u02DA",
+    0x1F: "\u02DC",
+    0x80: "\u2022",
+    0x81: "\u2020",
+    0x82: "\u2021",
+    0x83: "\u2026",
+    0x84: "\u2014",
+    0x85: "\u2013",
+    0x86: "\u0192",
+    0x87: "\u2044",
+    0x88: "\u2039",
+    0x89: "\u203A",
+    0x8A: "\u2212",
+    0x8B: "\u2030",
+    0x8C: "\u201E",
+    0x8D: "\u201C",
+    0x8E: "\u201D",
+    0x8F: "\u2018",
+    0x90: "\u2019",
+    0x91: "\u201A",
+    0x92: "\u2122",
+    0x93: "\uFB01",
+    0x94: "\uFB02",
+    0x95: "\u0141",
+    0x96: "\u0152",
+    0x97: "\u0160",
+    0x98: "\u0178",
+    0x99: "\u017D",
+    0x9A: "\u0131",
+    0x9B: "\u0142",
+    0x9C: "\u0153",
+    0x9D: "\u0161",
+    0x9E: "\u017E",
+    0xA0: "\u20AC",
+}
+
+
+def decode_text(b):
+    if b[: len(codecs.BOM_UTF16_BE)] == codecs.BOM_UTF16_BE:
+        return b[len(codecs.BOM_UTF16_BE) :].decode("utf_16_be")
+    else:
+        return "".join(PDFDocEncoding.get(byte, chr(byte)) for byte in b)
+
+
+class PdfFormatError(RuntimeError):
+    """An error that probably indicates a syntactic or semantic error in the
+    PDF file structure"""
+
+    pass
+
+
+def check_format_condition(condition, error_message):
+    if not condition:
+        raise PdfFormatError(error_message)
+
+
+class IndirectReference(
+    collections.namedtuple("IndirectReferenceTuple", ["object_id", "generation"])
+):
+    def __str__(self):
+        return "%s %s R" % self
+
+    def __bytes__(self):
+        return self.__str__().encode("us-ascii")
+
+    def __eq__(self, other):
+        return (
+            other.__class__ is self.__class__
+            and other.object_id == self.object_id
+            and other.generation == self.generation
+        )
+
+    def __ne__(self, other):
+        return not (self == other)
+
+    def __hash__(self):
+        return hash((self.object_id, self.generation))
+
+
+class IndirectObjectDef(IndirectReference):
+    def __str__(self):
+        return "%s %s obj" % self
+
+
+class XrefTable:
+    def __init__(self):
+        self.existing_entries = {}  # object ID => (offset, generation)
+        self.new_entries = {}  # object ID => (offset, generation)
+        self.deleted_entries = {0: 65536}  # object ID => generation
+        self.reading_finished = False
+
+    def __setitem__(self, key, value):
+        if self.reading_finished:
+            self.new_entries[key] = value
+        else:
+            self.existing_entries[key] = value
+        if key in self.deleted_entries:
+            del self.deleted_entries[key]
+
+    def __getitem__(self, key):
+        try:
+            return self.new_entries[key]
+        except KeyError:
+            return self.existing_entries[key]
+
+    def __delitem__(self, key):
+        if key in self.new_entries:
+            generation = self.new_entries[key][1] + 1
+            del self.new_entries[key]
+            self.deleted_entries[key] = generation
+        elif key in self.existing_entries:
+            generation = self.existing_entries[key][1] + 1
+            self.deleted_entries[key] = generation
+        elif key in self.deleted_entries:
+            generation = self.deleted_entries[key]
+        else:
+            raise IndexError(
+                "object ID " + str(key) + " cannot be deleted because it doesn't exist"
+            )
+
+    def __contains__(self, key):
+        return key in self.existing_entries or key in self.new_entries
+
+    def __len__(self):
+        return len(
+            set(self.existing_entries.keys())
+            | set(self.new_entries.keys())
+            | set(self.deleted_entries.keys())
+        )
+
+    def keys(self):
+        return (
+            set(self.existing_entries.keys()) - set(self.deleted_entries.keys())
+        ) | set(self.new_entries.keys())
+
+    def write(self, f):
+        keys = sorted(set(self.new_entries.keys()) | set(self.deleted_entries.keys()))
+        deleted_keys = sorted(set(self.deleted_entries.keys()))
+        startxref = f.tell()
+        f.write(b"xref\n")
+        while keys:
+            # find a contiguous sequence of object IDs
+            prev = None
+            for index, key in enumerate(keys):
+                if prev is None or prev + 1 == key:
+                    prev = key
+                else:
+                    contiguous_keys = keys[:index]
+                    keys = keys[index:]
+                    break
+            else:
+                contiguous_keys = keys
+                keys = None
+            f.write(b"%d %d\n" % (contiguous_keys[0], len(contiguous_keys)))
+            for object_id in contiguous_keys:
+                if object_id in self.new_entries:
+                    f.write(b"%010d %05d n \n" % self.new_entries[object_id])
+                else:
+                    this_deleted_object_id = deleted_keys.pop(0)
+                    check_format_condition(
+                        object_id == this_deleted_object_id,
+                        f"expected the next deleted object ID to be {object_id}, "
+                        f"instead found {this_deleted_object_id}",
+                    )
+                    try:
+                        next_in_linked_list = deleted_keys[0]
+                    except IndexError:
+                        next_in_linked_list = 0
+                    f.write(
+                        b"%010d %05d f \n"
+                        % (next_in_linked_list, self.deleted_entries[object_id])
+                    )
+        return startxref
+
+
+class PdfName:
+    def __init__(self, name):
+        if isinstance(name, PdfName):
+            self.name = name.name
+        elif isinstance(name, bytes):
+            self.name = name
+        else:
+            self.name = name.encode("us-ascii")
+
+    def name_as_str(self):
+        return self.name.decode("us-ascii")
+
+    def __eq__(self, other):
+        return (
+            isinstance(other, PdfName) and other.name == self.name
+        ) or other == self.name
+
+    def __hash__(self):
+        return hash(self.name)
+
+    def __repr__(self):
+        return f"PdfName({repr(self.name)})"
+
+    @classmethod
+    def from_pdf_stream(cls, data):
+        return cls(PdfParser.interpret_name(data))
+
+    allowed_chars = set(range(33, 127)) - {ord(c) for c in "#%/()<>[]{}"}
+
+    def __bytes__(self):
+        result = bytearray(b"/")
+        for b in self.name:
+            if b in self.allowed_chars:
+                result.append(b)
+            else:
+                result.extend(b"#%02X" % b)
+        return bytes(result)
+
+
+class PdfArray(list):
+    def __bytes__(self):
+        return b"[ " + b" ".join(pdf_repr(x) for x in self) + b" ]"
+
+
+class PdfDict(collections.UserDict):
+    def __setattr__(self, key, value):
+        if key == "data":
+            collections.UserDict.__setattr__(self, key, value)
+        else:
+            self[key.encode("us-ascii")] = value
+
+    def __getattr__(self, key):
+        try:
+            value = self[key.encode("us-ascii")]
+        except KeyError as e:
+            raise AttributeError(key) from e
+        if isinstance(value, bytes):
+            value = decode_text(value)
+        if key.endswith("Date"):
+            if value.startswith("D:"):
+                value = value[2:]
+
+            relationship = "Z"
+            if len(value) > 17:
+                relationship = value[14]
+                offset = int(value[15:17]) * 60
+                if len(value) > 20:
+                    offset += int(value[18:20])
+
+            format = "%Y%m%d%H%M%S"[: len(value) - 2]
+            value = time.strptime(value[: len(format) + 2], format)
+            if relationship in ["+", "-"]:
+                offset *= 60
+                if relationship == "+":
+                    offset *= -1
+                value = time.gmtime(calendar.timegm(value) + offset)
+        return value
+
+    def __bytes__(self):
+        out = bytearray(b"<<")
+        for key, value in self.items():
+            if value is None:
+                continue
+            value = pdf_repr(value)
+            out.extend(b"\n")
+            out.extend(bytes(PdfName(key)))
+            out.extend(b" ")
+            out.extend(value)
+        out.extend(b"\n>>")
+        return bytes(out)
+
+
+class PdfBinary:
+    def __init__(self, data):
+        self.data = data
+
+    def __bytes__(self):
+        return b"<%s>" % b"".join(b"%02X" % b for b in self.data)
+
+
+class PdfStream:
+    def __init__(self, dictionary, buf):
+        self.dictionary = dictionary
+        self.buf = buf
+
+    def decode(self):
+        try:
+            filter = self.dictionary.Filter
+        except AttributeError:
+            return self.buf
+        if filter == b"FlateDecode":
+            try:
+                expected_length = self.dictionary.DL
+            except AttributeError:
+                expected_length = self.dictionary.Length
+            return zlib.decompress(self.buf, bufsize=int(expected_length))
+        else:
+            raise NotImplementedError(
+                f"stream filter {repr(self.dictionary.Filter)} unknown/unsupported"
+            )
+
+
+def pdf_repr(x):
+    if x is True:
+        return b"true"
+    elif x is False:
+        return b"false"
+    elif x is None:
+        return b"null"
+    elif isinstance(x, (PdfName, PdfDict, PdfArray, PdfBinary)):
+        return bytes(x)
+    elif isinstance(x, int):
+        return str(x).encode("us-ascii")
+    elif isinstance(x, float):
+        return str(x).encode("us-ascii")
+    elif isinstance(x, time.struct_time):
+        return b"(D:" + time.strftime("%Y%m%d%H%M%SZ", x).encode("us-ascii") + b")"
+    elif isinstance(x, dict):
+        return bytes(PdfDict(x))
+    elif isinstance(x, list):
+        return bytes(PdfArray(x))
+    elif isinstance(x, str):
+        return pdf_repr(encode_text(x))
+    elif isinstance(x, bytes):
+        # XXX escape more chars? handle binary garbage
+        x = x.replace(b"\\", b"\\\\")
+        x = x.replace(b"(", b"\\(")
+        x = x.replace(b")", b"\\)")
+        return b"(" + x + b")"
+    else:
+        return bytes(x)
+
+
+class PdfParser:
+    """Based on
+    https://www.adobe.com/content/dam/acom/en/devnet/acrobat/pdfs/PDF32000_2008.pdf
+    Supports PDF up to 1.4
+    """
+
+    def __init__(self, filename=None, f=None, buf=None, start_offset=0, mode="rb"):
+        if buf and f:
+            raise RuntimeError("specify buf or f or filename, but not both buf and f")
+        self.filename = filename
+        self.buf = buf
+        self.f = f
+        self.start_offset = start_offset
+        self.should_close_buf = False
+        self.should_close_file = False
+        if filename is not None and f is None:
+            self.f = f = open(filename, mode)
+            self.should_close_file = True
+        if f is not None:
+            self.buf = buf = self.get_buf_from_file(f)
+            self.should_close_buf = True
+            if not filename and hasattr(f, "name"):
+                self.filename = f.name
+        self.cached_objects = {}
+        if buf:
+            self.read_pdf_info()
+        else:
+            self.file_size_total = self.file_size_this = 0
+            self.root = PdfDict()
+            self.root_ref = None
+            self.info = PdfDict()
+            self.info_ref = None
+            self.page_tree_root = {}
+            self.pages = []
+            self.orig_pages = []
+            self.pages_ref = None
+            self.last_xref_section_offset = None
+            self.trailer_dict = {}
+            self.xref_table = XrefTable()
+        self.xref_table.reading_finished = True
+        if f:
+            self.seek_end()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        self.close()
+        return False  # do not suppress exceptions
+
+    def start_writing(self):
+        self.close_buf()
+        self.seek_end()
+
+    def close_buf(self):
+        try:
+            self.buf.close()
+        except AttributeError:
+            pass
+        self.buf = None
+
+    def close(self):
+        if self.should_close_buf:
+            self.close_buf()
+        if self.f is not None and self.should_close_file:
+            self.f.close()
+            self.f = None
+
+    def seek_end(self):
+        self.f.seek(0, os.SEEK_END)
+
+    def write_header(self):
+        self.f.write(b"%PDF-1.4\n")
+
+    def write_comment(self, s):
+        self.f.write(f"% {s}\n".encode())
+
+    def write_catalog(self):
+        self.del_root()
+        self.root_ref = self.next_object_id(self.f.tell())
+        self.pages_ref = self.next_object_id(0)
+        self.rewrite_pages()
+        self.write_obj(self.root_ref, Type=PdfName(b"Catalog"), Pages=self.pages_ref)
+        self.write_obj(
+            self.pages_ref,
+            Type=PdfName(b"Pages"),
+            Count=len(self.pages),
+            Kids=self.pages,
+        )
+        return self.root_ref
+
+    def rewrite_pages(self):
+        pages_tree_nodes_to_delete = []
+        for i, page_ref in enumerate(self.orig_pages):
+            page_info = self.cached_objects[page_ref]
+            del self.xref_table[page_ref.object_id]
+            pages_tree_nodes_to_delete.append(page_info[PdfName(b"Parent")])
+            if page_ref not in self.pages:
+                # the page has been deleted
+                continue
+            # make dict keys into strings for passing to write_page
+            stringified_page_info = {}
+            for key, value in page_info.items():
+                # key should be a PdfName
+                stringified_page_info[key.name_as_str()] = value
+            stringified_page_info["Parent"] = self.pages_ref
+            new_page_ref = self.write_page(None, **stringified_page_info)
+            for j, cur_page_ref in enumerate(self.pages):
+                if cur_page_ref == page_ref:
+                    # replace the page reference with the new one
+                    self.pages[j] = new_page_ref
+        # delete redundant Pages tree nodes from xref table
+        for pages_tree_node_ref in pages_tree_nodes_to_delete:
+            while pages_tree_node_ref:
+                pages_tree_node = self.cached_objects[pages_tree_node_ref]
+                if pages_tree_node_ref.object_id in self.xref_table:
+                    del self.xref_table[pages_tree_node_ref.object_id]
+                pages_tree_node_ref = pages_tree_node.get(b"Parent", None)
+        self.orig_pages = []
+
+    def write_xref_and_trailer(self, new_root_ref=None):
+        if new_root_ref:
+            self.del_root()
+            self.root_ref = new_root_ref
+        if self.info:
+            self.info_ref = self.write_obj(None, self.info)
+        start_xref = self.xref_table.write(self.f)
+        num_entries = len(self.xref_table)
+        trailer_dict = {b"Root": self.root_ref, b"Size": num_entries}
+        if self.last_xref_section_offset is not None:
+            trailer_dict[b"Prev"] = self.last_xref_section_offset
+        if self.info:
+            trailer_dict[b"Info"] = self.info_ref
+        self.last_xref_section_offset = start_xref
+        self.f.write(
+            b"trailer\n"
+            + bytes(PdfDict(trailer_dict))
+            + b"\nstartxref\n%d\n%%%%EOF" % start_xref
+        )
+
+    def write_page(self, ref, *objs, **dict_obj):
+        if isinstance(ref, int):
+            ref = self.pages[ref]
+        if "Type" not in dict_obj:
+            dict_obj["Type"] = PdfName(b"Page")
+        if "Parent" not in dict_obj:
+            dict_obj["Parent"] = self.pages_ref
+        return self.write_obj(ref, *objs, **dict_obj)
+
+    def write_obj(self, ref, *objs, **dict_obj):
+        f = self.f
+        if ref is None:
+            ref = self.next_object_id(f.tell())
+        else:
+            self.xref_table[ref.object_id] = (f.tell(), ref.generation)
+        f.write(bytes(IndirectObjectDef(*ref)))
+        stream = dict_obj.pop("stream", None)
+        if stream is not None:
+            dict_obj["Length"] = len(stream)
+        if dict_obj:
+            f.write(pdf_repr(dict_obj))
+        for obj in objs:
+            f.write(pdf_repr(obj))
+        if stream is not None:
+            f.write(b"stream\n")
+            f.write(stream)
+            f.write(b"\nendstream\n")
+        f.write(b"endobj\n")
+        return ref
+
+    def del_root(self):
+        if self.root_ref is None:
+            return
+        del self.xref_table[self.root_ref.object_id]
+        del self.xref_table[self.root[b"Pages"].object_id]
+
+    @staticmethod
+    def get_buf_from_file(f):
+        if hasattr(f, "getbuffer"):
+            return f.getbuffer()
+        elif hasattr(f, "getvalue"):
+            return f.getvalue()
+        else:
+            try:
+                return mmap.mmap(f.fileno(), 0, access=mmap.ACCESS_READ)
+            except ValueError:  # cannot mmap an empty file
+                return b""
+
+    def read_pdf_info(self):
+        self.file_size_total = len(self.buf)
+        self.file_size_this = self.file_size_total - self.start_offset
+        self.read_trailer()
+        self.root_ref = self.trailer_dict[b"Root"]
+        self.info_ref = self.trailer_dict.get(b"Info", None)
+        self.root = PdfDict(self.read_indirect(self.root_ref))
+        if self.info_ref is None:
+            self.info = PdfDict()
+        else:
+            self.info = PdfDict(self.read_indirect(self.info_ref))
+        check_format_condition(b"Type" in self.root, "/Type missing in Root")
+        check_format_condition(
+            self.root[b"Type"] == b"Catalog", "/Type in Root is not /Catalog"
+        )
+        check_format_condition(b"Pages" in self.root, "/Pages missing in Root")
+        check_format_condition(
+            isinstance(self.root[b"Pages"], IndirectReference),
+            "/Pages in Root is not an indirect reference",
+        )
+        self.pages_ref = self.root[b"Pages"]
+        self.page_tree_root = self.read_indirect(self.pages_ref)
+        self.pages = self.linearize_page_tree(self.page_tree_root)
+        # save the original list of page references
+        # in case the user modifies, adds or deletes some pages
+        # and we need to rewrite the pages and their list
+        self.orig_pages = self.pages[:]
+
+    def next_object_id(self, offset=None):
+        try:
+            # TODO: support reuse of deleted objects
+            reference = IndirectReference(max(self.xref_table.keys()) + 1, 0)
+        except ValueError:
+            reference = IndirectReference(1, 0)
+        if offset is not None:
+            self.xref_table[reference.object_id] = (offset, 0)
+        return reference
+
+    delimiter = rb"[][()<>{}/%]"
+    delimiter_or_ws = rb"[][()<>{}/%\000\011\012\014\015\040]"
+    whitespace = rb"[\000\011\012\014\015\040]"
+    whitespace_or_hex = rb"[\000\011\012\014\015\0400-9a-fA-F]"
+    whitespace_optional = whitespace + b"*"
+    whitespace_mandatory = whitespace + b"+"
+    # No "\012" aka "\n" or "\015" aka "\r":
+    whitespace_optional_no_nl = rb"[\000\011\014\040]*"
+    newline_only = rb"[\r\n]+"
+    newline = whitespace_optional_no_nl + newline_only + whitespace_optional_no_nl
+    re_trailer_end = re.compile(
+        whitespace_mandatory
+        + rb"trailer"
+        + whitespace_optional
+        + rb"\<\<(.*\>\>)"
+        + newline
+        + rb"startxref"
+        + newline
+        + rb"([0-9]+)"
+        + newline
+        + rb"%%EOF"
+        + whitespace_optional
+        + rb"$",
+        re.DOTALL,
+    )
+    re_trailer_prev = re.compile(
+        whitespace_optional
+        + rb"trailer"
+        + whitespace_optional
+        + rb"\<\<(.*?\>\>)"
+        + newline
+        + rb"startxref"
+        + newline
+        + rb"([0-9]+)"
+        + newline
+        + rb"%%EOF"
+        + whitespace_optional,
+        re.DOTALL,
+    )
+
+    def read_trailer(self):
+        search_start_offset = len(self.buf) - 16384
+        if search_start_offset < self.start_offset:
+            search_start_offset = self.start_offset
+        m = self.re_trailer_end.search(self.buf, search_start_offset)
+        check_format_condition(m, "trailer end not found")
+        # make sure we found the LAST trailer
+        last_match = m
+        while m:
+            last_match = m
+            m = self.re_trailer_end.search(self.buf, m.start() + 16)
+        if not m:
+            m = last_match
+        trailer_data = m.group(1)
+        self.last_xref_section_offset = int(m.group(2))
+        self.trailer_dict = self.interpret_trailer(trailer_data)
+        self.xref_table = XrefTable()
+        self.read_xref_table(xref_section_offset=self.last_xref_section_offset)
+        if b"Prev" in self.trailer_dict:
+            self.read_prev_trailer(self.trailer_dict[b"Prev"])
+
+    def read_prev_trailer(self, xref_section_offset):
+        trailer_offset = self.read_xref_table(xref_section_offset=xref_section_offset)
+        m = self.re_trailer_prev.search(
+            self.buf[trailer_offset : trailer_offset + 16384]
+        )
+        check_format_condition(m, "previous trailer not found")
+        trailer_data = m.group(1)
+        check_format_condition(
+            int(m.group(2)) == xref_section_offset,
+            "xref section offset in previous trailer doesn't match what was expected",
+        )
+        trailer_dict = self.interpret_trailer(trailer_data)
+        if b"Prev" in trailer_dict:
+            self.read_prev_trailer(trailer_dict[b"Prev"])
+
+    re_whitespace_optional = re.compile(whitespace_optional)
+    re_name = re.compile(
+        whitespace_optional
+        + rb"/([!-$&'*-.0-;=?-Z\\^-z|~]+)(?="
+        + delimiter_or_ws
+        + rb")"
+    )
+    re_dict_start = re.compile(whitespace_optional + rb"\<\<")
+    re_dict_end = re.compile(whitespace_optional + rb"\>\>" + whitespace_optional)
+
+    @classmethod
+    def interpret_trailer(cls, trailer_data):
+        trailer = {}
+        offset = 0
+        while True:
+            m = cls.re_name.match(trailer_data, offset)
+            if not m:
+                m = cls.re_dict_end.match(trailer_data, offset)
+                check_format_condition(
+                    m and m.end() == len(trailer_data),
+                    "name not found in trailer, remaining data: "
+                    + repr(trailer_data[offset:]),
+                )
+                break
+            key = cls.interpret_name(m.group(1))
+            value, offset = cls.get_value(trailer_data, m.end())
+            trailer[key] = value
+        check_format_condition(
+            b"Size" in trailer and isinstance(trailer[b"Size"], int),
+            "/Size not in trailer or not an integer",
+        )
+        check_format_condition(
+            b"Root" in trailer and isinstance(trailer[b"Root"], IndirectReference),
+            "/Root not in trailer or not an indirect reference",
+        )
+        return trailer
+
+    re_hashes_in_name = re.compile(rb"([^#]*)(#([0-9a-fA-F]{2}))?")
+
+    @classmethod
+    def interpret_name(cls, raw, as_text=False):
+        name = b""
+        for m in cls.re_hashes_in_name.finditer(raw):
+            if m.group(3):
+                name += m.group(1) + bytearray.fromhex(m.group(3).decode("us-ascii"))
+            else:
+                name += m.group(1)
+        if as_text:
+            return name.decode("utf-8")
+        else:
+            return bytes(name)
+
+    re_null = re.compile(whitespace_optional + rb"null(?=" + delimiter_or_ws + rb")")
+    re_true = re.compile(whitespace_optional + rb"true(?=" + delimiter_or_ws + rb")")
+    re_false = re.compile(whitespace_optional + rb"false(?=" + delimiter_or_ws + rb")")
+    re_int = re.compile(
+        whitespace_optional + rb"([-+]?[0-9]+)(?=" + delimiter_or_ws + rb")"
+    )
+    re_real = re.compile(
+        whitespace_optional
+        + rb"([-+]?([0-9]+\.[0-9]*|[0-9]*\.[0-9]+))(?="
+        + delimiter_or_ws
+        + rb")"
+    )
+    re_array_start = re.compile(whitespace_optional + rb"\[")
+    re_array_end = re.compile(whitespace_optional + rb"]")
+    re_string_hex = re.compile(
+        whitespace_optional + rb"\<(" + whitespace_or_hex + rb"*)\>"
+    )
+    re_string_lit = re.compile(whitespace_optional + rb"\(")
+    re_indirect_reference = re.compile(
+        whitespace_optional
+        + rb"([-+]?[0-9]+)"
+        + whitespace_mandatory
+        + rb"([-+]?[0-9]+)"
+        + whitespace_mandatory
+        + rb"R(?="
+        + delimiter_or_ws
+        + rb")"
+    )
+    re_indirect_def_start = re.compile(
+        whitespace_optional
+        + rb"([-+]?[0-9]+)"
+        + whitespace_mandatory
+        + rb"([-+]?[0-9]+)"
+        + whitespace_mandatory
+        + rb"obj(?="
+        + delimiter_or_ws
+        + rb")"
+    )
+    re_indirect_def_end = re.compile(
+        whitespace_optional + rb"endobj(?=" + delimiter_or_ws + rb")"
+    )
+    re_comment = re.compile(
+        rb"(" + whitespace_optional + rb"%[^\r\n]*" + newline + rb")*"
+    )
+    re_stream_start = re.compile(whitespace_optional + rb"stream\r?\n")
+    re_stream_end = re.compile(
+        whitespace_optional + rb"endstream(?=" + delimiter_or_ws + rb")"
+    )
+
+    @classmethod
+    def get_value(cls, data, offset, expect_indirect=None, max_nesting=-1):
+        if max_nesting == 0:
+            return None, None
+        m = cls.re_comment.match(data, offset)
+        if m:
+            offset = m.end()
+        m = cls.re_indirect_def_start.match(data, offset)
+        if m:
+            check_format_condition(
+                int(m.group(1)) > 0,
+                "indirect object definition: object ID must be greater than 0",
+            )
+            check_format_condition(
+                int(m.group(2)) >= 0,
+                "indirect object definition: generation must be non-negative",
+            )
+            check_format_condition(
+                expect_indirect is None
+                or expect_indirect
+                == IndirectReference(int(m.group(1)), int(m.group(2))),
+                "indirect object definition different than expected",
+            )
+            object, offset = cls.get_value(data, m.end(), max_nesting=max_nesting - 1)
+            if offset is None:
+                return object, None
+            m = cls.re_indirect_def_end.match(data, offset)
+            check_format_condition(m, "indirect object definition end not found")
+            return object, m.end()
+        check_format_condition(
+            not expect_indirect, "indirect object definition not found"
+        )
+        m = cls.re_indirect_reference.match(data, offset)
+        if m:
+            check_format_condition(
+                int(m.group(1)) > 0,
+                "indirect object reference: object ID must be greater than 0",
+            )
+            check_format_condition(
+                int(m.group(2)) >= 0,
+                "indirect object reference: generation must be non-negative",
+            )
+            return IndirectReference(int(m.group(1)), int(m.group(2))), m.end()
+        m = cls.re_dict_start.match(data, offset)
+        if m:
+            offset = m.end()
+            result = {}
+            m = cls.re_dict_end.match(data, offset)
+            while not m:
+                key, offset = cls.get_value(data, offset, max_nesting=max_nesting - 1)
+                if offset is None:
+                    return result, None
+                value, offset = cls.get_value(data, offset, max_nesting=max_nesting - 1)
+                result[key] = value
+                if offset is None:
+                    return result, None
+                m = cls.re_dict_end.match(data, offset)
+            offset = m.end()
+            m = cls.re_stream_start.match(data, offset)
+            if m:
+                try:
+                    stream_len = int(result[b"Length"])
+                except (TypeError, KeyError, ValueError) as e:
+                    raise PdfFormatError(
+                        "bad or missing Length in stream dict (%r)"
+                        % result.get(b"Length", None)
+                    ) from e
+                stream_data = data[m.end() : m.end() + stream_len]
+                m = cls.re_stream_end.match(data, m.end() + stream_len)
+                check_format_condition(m, "stream end not found")
+                offset = m.end()
+                result = PdfStream(PdfDict(result), stream_data)
+            else:
+                result = PdfDict(result)
+            return result, offset
+        m = cls.re_array_start.match(data, offset)
+        if m:
+            offset = m.end()
+            result = []
+            m = cls.re_array_end.match(data, offset)
+            while not m:
+                value, offset = cls.get_value(data, offset, max_nesting=max_nesting - 1)
+                result.append(value)
+                if offset is None:
+                    return result, None
+                m = cls.re_array_end.match(data, offset)
+            return result, m.end()
+        m = cls.re_null.match(data, offset)
+        if m:
+            return None, m.end()
+        m = cls.re_true.match(data, offset)
+        if m:
+            return True, m.end()
+        m = cls.re_false.match(data, offset)
+        if m:
+            return False, m.end()
+        m = cls.re_name.match(data, offset)
+        if m:
+            return PdfName(cls.interpret_name(m.group(1))), m.end()
+        m = cls.re_int.match(data, offset)
+        if m:
+            return int(m.group(1)), m.end()
+        m = cls.re_real.match(data, offset)
+        if m:
+            # XXX Decimal instead of float???
+            return float(m.group(1)), m.end()
+        m = cls.re_string_hex.match(data, offset)
+        if m:
+            # filter out whitespace
+            hex_string = bytearray(
+                b for b in m.group(1) if b in b"0123456789abcdefABCDEF"
+            )
+            if len(hex_string) % 2 == 1:
+                # append a 0 if the length is not even - yes, at the end
+                hex_string.append(ord(b"0"))
+            return bytearray.fromhex(hex_string.decode("us-ascii")), m.end()
+        m = cls.re_string_lit.match(data, offset)
+        if m:
+            return cls.get_literal_string(data, m.end())
+        # return None, offset  # fallback (only for debugging)
+        raise PdfFormatError("unrecognized object: " + repr(data[offset : offset + 32]))
+
+    re_lit_str_token = re.compile(
+        rb"(\\[nrtbf()\\])|(\\[0-9]{1,3})|(\\(\r\n|\r|\n))|(\r\n|\r|\n)|(\()|(\))"
+    )
+    escaped_chars = {
+        b"n": b"\n",
+        b"r": b"\r",
+        b"t": b"\t",
+        b"b": b"\b",
+        b"f": b"\f",
+        b"(": b"(",
+        b")": b")",
+        b"\\": b"\\",
+        ord(b"n"): b"\n",
+        ord(b"r"): b"\r",
+        ord(b"t"): b"\t",
+        ord(b"b"): b"\b",
+        ord(b"f"): b"\f",
+        ord(b"("): b"(",
+        ord(b")"): b")",
+        ord(b"\\"): b"\\",
+    }
+
+    @classmethod
+    def get_literal_string(cls, data, offset):
+        nesting_depth = 0
+        result = bytearray()
+        for m in cls.re_lit_str_token.finditer(data, offset):
+            result.extend(data[offset : m.start()])
+            if m.group(1):
+                result.extend(cls.escaped_chars[m.group(1)[1]])
+            elif m.group(2):
+                result.append(int(m.group(2)[1:], 8))
+            elif m.group(3):
+                pass
+            elif m.group(5):
+                result.extend(b"\n")
+            elif m.group(6):
+                result.extend(b"(")
+                nesting_depth += 1
+            elif m.group(7):
+                if nesting_depth == 0:
+                    return bytes(result), m.end()
+                result.extend(b")")
+                nesting_depth -= 1
+            offset = m.end()
+        raise PdfFormatError("unfinished literal string")
+
+    re_xref_section_start = re.compile(whitespace_optional + rb"xref" + newline)
+    re_xref_subsection_start = re.compile(
+        whitespace_optional
+        + rb"([0-9]+)"
+        + whitespace_mandatory
+        + rb"([0-9]+)"
+        + whitespace_optional
+        + newline_only
+    )
+    re_xref_entry = re.compile(rb"([0-9]{10}) ([0-9]{5}) ([fn])( \r| \n|\r\n)")
+
+    def read_xref_table(self, xref_section_offset):
+        subsection_found = False
+        m = self.re_xref_section_start.match(
+            self.buf, xref_section_offset + self.start_offset
+        )
+        check_format_condition(m, "xref section start not found")
+        offset = m.end()
+        while True:
+            m = self.re_xref_subsection_start.match(self.buf, offset)
+            if not m:
+                check_format_condition(
+                    subsection_found, "xref subsection start not found"
+                )
+                break
+            subsection_found = True
+            offset = m.end()
+            first_object = int(m.group(1))
+            num_objects = int(m.group(2))
+            for i in range(first_object, first_object + num_objects):
+                m = self.re_xref_entry.match(self.buf, offset)
+                check_format_condition(m, "xref entry not found")
+                offset = m.end()
+                is_free = m.group(3) == b"f"
+                generation = int(m.group(2))
+                if not is_free:
+                    new_entry = (int(m.group(1)), generation)
+                    check_format_condition(
+                        i not in self.xref_table or self.xref_table[i] == new_entry,
+                        "xref entry duplicated (and not identical)",
+                    )
+                    self.xref_table[i] = new_entry
+        return offset
+
+    def read_indirect(self, ref, max_nesting=-1):
+        offset, generation = self.xref_table[ref[0]]
+        check_format_condition(
+            generation == ref[1],
+            f"expected to find generation {ref[1]} for object ID {ref[0]} in xref "
+            f"table, instead found generation {generation} at offset {offset}",
+        )
+        value = self.get_value(
+            self.buf,
+            offset + self.start_offset,
+            expect_indirect=IndirectReference(*ref),
+            max_nesting=max_nesting,
+        )[0]
+        self.cached_objects[ref] = value
+        return value
+
+    def linearize_page_tree(self, node=None):
+        if node is None:
+            node = self.page_tree_root
+        check_format_condition(
+            node[b"Type"] == b"Pages", "/Type of page tree node is not /Pages"
+        )
+        pages = []
+        for kid in node[b"Kids"]:
+            kid_object = self.read_indirect(kid)
+            if kid_object[b"Type"] == b"Page":
+                pages.append(kid)
+            else:
+                pages.extend(self.linearize_page_tree(node=kid_object))
+        return pages

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/PIL/PixarImagePlugin.py

@@ -0,0 +1,70 @@
+#
+# The Python Imaging Library.
+# $Id$
+#
+# PIXAR raster support for PIL
+#
+# history:
+#       97-01-29 fl     Created
+#
+# notes:
+#       This is incomplete; it is based on a few samples created with
+#       Photoshop 2.5 and 3.0, and a summary description provided by
+#       Greg Coats <gcoats@labiris.er.usgs.gov>.  Hopefully, "L" and
+#       "RGBA" support will be added in future versions.
+#
+# Copyright (c) Secret Labs AB 1997.
+# Copyright (c) Fredrik Lundh 1997.
+#
+# See the README file for information on usage and redistribution.
+#
+
+from . import Image, ImageFile
+from ._binary import i16le as i16
+
+#
+# helpers
+
+
+def _accept(prefix):
+    return prefix[:4] == b"\200\350\000\000"
+
+
+##
+# Image plugin for PIXAR raster images.
+
+
+class PixarImageFile(ImageFile.ImageFile):
+
+    format = "PIXAR"
+    format_description = "PIXAR raster image"
+
+    def _open(self):
+
+        # assuming a 4-byte magic label
+        s = self.fp.read(4)
+        if not _accept(s):
+            raise SyntaxError("not a PIXAR file")
+
+        # read rest of header
+        s = s + self.fp.read(508)
+
+        self._size = i16(s, 418), i16(s, 416)
+
+        # get channel/depth descriptions
+        mode = i16(s, 424), i16(s, 426)
+
+        if mode == (14, 2):
+            self.mode = "RGB"
+        # FIXME: to be continued...
+
+        # create tile descriptor (assuming "dumped")
+        self.tile = [("raw", (0, 0) + self.size, 1024, (self.mode, 0, 1))]
+
+
+#
+# --------------------------------------------------------------------
+
+Image.register_open(PixarImageFile.format, PixarImageFile, _accept)
+
+Image.register_extension(PixarImageFile.format, ".pxr")

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/PIL/PngImagePlugin.py

@@ -0,0 +1,1432 @@
+#
+# The Python Imaging Library.
+# $Id$
+#
+# PNG support code
+#
+# See "PNG (Portable Network Graphics) Specification, version 1.0;
+# W3C Recommendation", 1996-10-01, Thomas Boutell (ed.).
+#
+# history:
+# 1996-05-06 fl   Created (couldn't resist it)
+# 1996-12-14 fl   Upgraded, added read and verify support (0.2)
+# 1996-12-15 fl   Separate PNG stream parser
+# 1996-12-29 fl   Added write support, added getchunks
+# 1996-12-30 fl   Eliminated circular references in decoder (0.3)
+# 1998-07-12 fl   Read/write 16-bit images as mode I (0.4)
+# 2001-02-08 fl   Added transparency support (from Zircon) (0.5)
+# 2001-04-16 fl   Don't close data source in "open" method (0.6)
+# 2004-02-24 fl   Don't even pretend to support interlaced files (0.7)
+# 2004-08-31 fl   Do basic sanity check on chunk identifiers (0.8)
+# 2004-09-20 fl   Added PngInfo chunk container
+# 2004-12-18 fl   Added DPI read support (based on code by Niki Spahiev)
+# 2008-08-13 fl   Added tRNS support for RGB images
+# 2009-03-06 fl   Support for preserving ICC profiles (by Florian Hoech)
+# 2009-03-08 fl   Added zTXT support (from Lowell Alleman)
+# 2009-03-29 fl   Read interlaced PNG files (from Conrado Porto Lopes Gouvua)
+#
+# Copyright (c) 1997-2009 by Secret Labs AB
+# Copyright (c) 1996 by Fredrik Lundh
+#
+# See the README file for information on usage and redistribution.
+#
+
+import itertools
+import logging
+import re
+import struct
+import warnings
+import zlib
+from enum import IntEnum
+
+from . import Image, ImageChops, ImageFile, ImagePalette, ImageSequence
+from ._binary import i16be as i16
+from ._binary import i32be as i32
+from ._binary import o8
+from ._binary import o16be as o16
+from ._binary import o32be as o32
+
+logger = logging.getLogger(__name__)
+
+is_cid = re.compile(rb"\w\w\w\w").match
+
+
+_MAGIC = b"\211PNG\r\n\032\n"
+
+
+_MODES = {
+    # supported bits/color combinations, and corresponding modes/rawmodes
+    # Greyscale
+    (1, 0): ("1", "1"),
+    (2, 0): ("L", "L;2"),
+    (4, 0): ("L", "L;4"),
+    (8, 0): ("L", "L"),
+    (16, 0): ("I", "I;16B"),
+    # Truecolour
+    (8, 2): ("RGB", "RGB"),
+    (16, 2): ("RGB", "RGB;16B"),
+    # Indexed-colour
+    (1, 3): ("P", "P;1"),
+    (2, 3): ("P", "P;2"),
+    (4, 3): ("P", "P;4"),
+    (8, 3): ("P", "P"),
+    # Greyscale with alpha
+    (8, 4): ("LA", "LA"),
+    (16, 4): ("RGBA", "LA;16B"),  # LA;16B->LA not yet available
+    # Truecolour with alpha
+    (8, 6): ("RGBA", "RGBA"),
+    (16, 6): ("RGBA", "RGBA;16B"),
+}
+
+
+_simple_palette = re.compile(b"^\xff*\x00\xff*$")
+
+MAX_TEXT_CHUNK = ImageFile.SAFEBLOCK
+"""
+Maximum decompressed size for a iTXt or zTXt chunk.
+Eliminates decompression bombs where compressed chunks can expand 1000x.
+See :ref:`Text in PNG File Format<png-text>`.
+"""
+MAX_TEXT_MEMORY = 64 * MAX_TEXT_CHUNK
+"""
+Set the maximum total text chunk size.
+See :ref:`Text in PNG File Format<png-text>`.
+"""
+
+
+# APNG frame disposal modes
+class Disposal(IntEnum):
+    OP_NONE = 0
+    """
+    No disposal is done on this frame before rendering the next frame.
+    See :ref:`Saving APNG sequences<apng-saving>`.
+    """
+    OP_BACKGROUND = 1
+    """
+    This frame’s modified region is cleared to fully transparent black before rendering
+    the next frame.
+    See :ref:`Saving APNG sequences<apng-saving>`.
+    """
+    OP_PREVIOUS = 2
+    """
+    This frame’s modified region is reverted to the previous frame’s contents before
+    rendering the next frame.
+    See :ref:`Saving APNG sequences<apng-saving>`.
+    """
+
+
+# APNG frame blend modes
+class Blend(IntEnum):
+    OP_SOURCE = 0
+    """
+    All color components of this frame, including alpha, overwrite the previous output
+    image contents.
+    See :ref:`Saving APNG sequences<apng-saving>`.
+    """
+    OP_OVER = 1
+    """
+    This frame should be alpha composited with the previous output image contents.
+    See :ref:`Saving APNG sequences<apng-saving>`.
+    """
+
+
+def __getattr__(name):
+    deprecated = "deprecated and will be removed in Pillow 10 (2023-07-01). "
+    for enum, prefix in {Disposal: "APNG_DISPOSE_", Blend: "APNG_BLEND_"}.items():
+        if name.startswith(prefix):
+            name = name[len(prefix) :]
+            if name in enum.__members__:
+                warnings.warn(
+                    prefix
+                    + name
+                    + " is "
+                    + deprecated
+                    + "Use "
+                    + enum.__name__
+                    + "."
+                    + name
+                    + " instead.",
+                    DeprecationWarning,
+                    stacklevel=2,
+                )
+                return enum[name]
+    raise AttributeError(f"module '{__name__}' has no attribute '{name}'")
+
+
+def _safe_zlib_decompress(s):
+    dobj = zlib.decompressobj()
+    plaintext = dobj.decompress(s, MAX_TEXT_CHUNK)
+    if dobj.unconsumed_tail:
+        raise ValueError("Decompressed Data Too Large")
+    return plaintext
+
+
+def _crc32(data, seed=0):
+    return zlib.crc32(data, seed) & 0xFFFFFFFF
+
+
+# --------------------------------------------------------------------
+# Support classes.  Suitable for PNG and related formats like MNG etc.
+
+
+class ChunkStream:
+    def __init__(self, fp):
+
+        self.fp = fp
+        self.queue = []
+
+    def read(self):
+        """Fetch a new chunk. Returns header information."""
+        cid = None
+
+        if self.queue:
+            cid, pos, length = self.queue.pop()
+            self.fp.seek(pos)
+        else:
+            s = self.fp.read(8)
+            cid = s[4:]
+            pos = self.fp.tell()
+            length = i32(s)
+
+        if not is_cid(cid):
+            if not ImageFile.LOAD_TRUNCATED_IMAGES:
+                raise SyntaxError(f"broken PNG file (chunk {repr(cid)})")
+
+        return cid, pos, length
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *args):
+        self.close()
+
+    def close(self):
+        self.queue = self.crc = self.fp = None
+
+    def push(self, cid, pos, length):
+
+        self.queue.append((cid, pos, length))
+
+    def call(self, cid, pos, length):
+        """Call the appropriate chunk handler"""
+
+        logger.debug("STREAM %r %s %s", cid, pos, length)
+        return getattr(self, "chunk_" + cid.decode("ascii"))(pos, length)
+
+    def crc(self, cid, data):
+        """Read and verify checksum"""
+
+        # Skip CRC checks for ancillary chunks if allowed to load truncated
+        # images
+        # 5th byte of first char is 1 [specs, section 5.4]
+        if ImageFile.LOAD_TRUNCATED_IMAGES and (cid[0] >> 5 & 1):
+            self.crc_skip(cid, data)
+            return
+
+        try:
+            crc1 = _crc32(data, _crc32(cid))
+            crc2 = i32(self.fp.read(4))
+            if crc1 != crc2:
+                raise SyntaxError(
+                    f"broken PNG file (bad header checksum in {repr(cid)})"
+                )
+        except struct.error as e:
+            raise SyntaxError(
+                f"broken PNG file (incomplete checksum in {repr(cid)})"
+            ) from e
+
+    def crc_skip(self, cid, data):
+        """Read checksum.  Used if the C module is not present"""
+
+        self.fp.read(4)
+
+    def verify(self, endchunk=b"IEND"):
+
+        # Simple approach; just calculate checksum for all remaining
+        # blocks.  Must be called directly after open.
+
+        cids = []
+
+        while True:
+            try:
+                cid, pos, length = self.read()
+            except struct.error as e:
+                raise OSError("truncated PNG file") from e
+
+            if cid == endchunk:
+                break
+            self.crc(cid, ImageFile._safe_read(self.fp, length))
+            cids.append(cid)
+
+        return cids
+
+
+class iTXt(str):
+    """
+    Subclass of string to allow iTXt chunks to look like strings while
+    keeping their extra information
+
+    """
+
+    @staticmethod
+    def __new__(cls, text, lang=None, tkey=None):
+        """
+        :param cls: the class to use when creating the instance
+        :param text: value for this key
+        :param lang: language code
+        :param tkey: UTF-8 version of the key name
+        """
+
+        self = str.__new__(cls, text)
+        self.lang = lang
+        self.tkey = tkey
+        return self
+
+
+class PngInfo:
+    """
+    PNG chunk container (for use with save(pnginfo=))
+
+    """
+
+    def __init__(self):
+        self.chunks = []
+
+    def add(self, cid, data, after_idat=False):
+        """Appends an arbitrary chunk. Use with caution.
+
+        :param cid: a byte string, 4 bytes long.
+        :param data: a byte string of the encoded data
+        :param after_idat: for use with private chunks. Whether the chunk
+                           should be written after IDAT
+
+        """
+
+        chunk = [cid, data]
+        if after_idat:
+            chunk.append(True)
+        self.chunks.append(tuple(chunk))
+
+    def add_itxt(self, key, value, lang="", tkey="", zip=False):
+        """Appends an iTXt chunk.
+
+        :param key: latin-1 encodable text key name
+        :param value: value for this key
+        :param lang: language code
+        :param tkey: UTF-8 version of the key name
+        :param zip: compression flag
+
+        """
+
+        if not isinstance(key, bytes):
+            key = key.encode("latin-1", "strict")
+        if not isinstance(value, bytes):
+            value = value.encode("utf-8", "strict")
+        if not isinstance(lang, bytes):
+            lang = lang.encode("utf-8", "strict")
+        if not isinstance(tkey, bytes):
+            tkey = tkey.encode("utf-8", "strict")
+
+        if zip:
+            self.add(
+                b"iTXt",
+                key + b"\0\x01\0" + lang + b"\0" + tkey + b"\0" + zlib.compress(value),
+            )
+        else:
+            self.add(b"iTXt", key + b"\0\0\0" + lang + b"\0" + tkey + b"\0" + value)
+
+    def add_text(self, key, value, zip=False):
+        """Appends a text chunk.
+
+        :param key: latin-1 encodable text key name
+        :param value: value for this key, text or an
+           :py:class:`PIL.PngImagePlugin.iTXt` instance
+        :param zip: compression flag
+
+        """
+        if isinstance(value, iTXt):
+            return self.add_itxt(key, value, value.lang, value.tkey, zip=zip)
+
+        # The tEXt chunk stores latin-1 text
+        if not isinstance(value, bytes):
+            try:
+                value = value.encode("latin-1", "strict")
+            except UnicodeError:
+                return self.add_itxt(key, value, zip=zip)
+
+        if not isinstance(key, bytes):
+            key = key.encode("latin-1", "strict")
+
+        if zip:
+            self.add(b"zTXt", key + b"\0\0" + zlib.compress(value))
+        else:
+            self.add(b"tEXt", key + b"\0" + value)
+
+
+# --------------------------------------------------------------------
+# PNG image stream (IHDR/IEND)
+
+
+class PngStream(ChunkStream):
+    def __init__(self, fp):
+        super().__init__(fp)
+
+        # local copies of Image attributes
+        self.im_info = {}
+        self.im_text = {}
+        self.im_size = (0, 0)
+        self.im_mode = None
+        self.im_tile = None
+        self.im_palette = None
+        self.im_custom_mimetype = None
+        self.im_n_frames = None
+        self._seq_num = None
+        self.rewind_state = None
+
+        self.text_memory = 0
+
+    def check_text_memory(self, chunklen):
+        self.text_memory += chunklen
+        if self.text_memory > MAX_TEXT_MEMORY:
+            raise ValueError(
+                "Too much memory used in text chunks: "
+                f"{self.text_memory}>MAX_TEXT_MEMORY"
+            )
+
+    def save_rewind(self):
+        self.rewind_state = {
+            "info": self.im_info.copy(),
+            "tile": self.im_tile,
+            "seq_num": self._seq_num,
+        }
+
+    def rewind(self):
+        self.im_info = self.rewind_state["info"]
+        self.im_tile = self.rewind_state["tile"]
+        self._seq_num = self.rewind_state["seq_num"]
+
+    def chunk_iCCP(self, pos, length):
+
+        # ICC profile
+        s = ImageFile._safe_read(self.fp, length)
+        # according to PNG spec, the iCCP chunk contains:
+        # Profile name  1-79 bytes (character string)
+        # Null separator        1 byte (null character)
+        # Compression method    1 byte (0)
+        # Compressed profile    n bytes (zlib with deflate compression)
+        i = s.find(b"\0")
+        logger.debug("iCCP profile name %r", s[:i])
+        logger.debug("Compression method %s", s[i])
+        comp_method = s[i]
+        if comp_method != 0:
+            raise SyntaxError(f"Unknown compression method {comp_method} in iCCP chunk")
+        try:
+            icc_profile = _safe_zlib_decompress(s[i + 2 :])
+        except ValueError:
+            if ImageFile.LOAD_TRUNCATED_IMAGES:
+                icc_profile = None
+            else:
+                raise
+        except zlib.error:
+            icc_profile = None  # FIXME
+        self.im_info["icc_profile"] = icc_profile
+        return s
+
+    def chunk_IHDR(self, pos, length):
+
+        # image header
+        s = ImageFile._safe_read(self.fp, length)
+        self.im_size = i32(s, 0), i32(s, 4)
+        try:
+            self.im_mode, self.im_rawmode = _MODES[(s[8], s[9])]
+        except Exception:
+            pass
+        if s[12]:
+            self.im_info["interlace"] = 1
+        if s[11]:
+            raise SyntaxError("unknown filter category")
+        return s
+
+    def chunk_IDAT(self, pos, length):
+
+        # image data
+        if "bbox" in self.im_info:
+            tile = [("zip", self.im_info["bbox"], pos, self.im_rawmode)]
+        else:
+            if self.im_n_frames is not None:
+                self.im_info["default_image"] = True
+            tile = [("zip", (0, 0) + self.im_size, pos, self.im_rawmode)]
+        self.im_tile = tile
+        self.im_idat = length
+        raise EOFError
+
+    def chunk_IEND(self, pos, length):
+
+        # end of PNG image
+        raise EOFError
+
+    def chunk_PLTE(self, pos, length):
+
+        # palette
+        s = ImageFile._safe_read(self.fp, length)
+        if self.im_mode == "P":
+            self.im_palette = "RGB", s
+        return s
+
+    def chunk_tRNS(self, pos, length):
+
+        # transparency
+        s = ImageFile._safe_read(self.fp, length)
+        if self.im_mode == "P":
+            if _simple_palette.match(s):
+                # tRNS contains only one full-transparent entry,
+                # other entries are full opaque
+                i = s.find(b"\0")
+                if i >= 0:
+                    self.im_info["transparency"] = i
+            else:
+                # otherwise, we have a byte string with one alpha value
+                # for each palette entry
+                self.im_info["transparency"] = s
+        elif self.im_mode in ("1", "L", "I"):
+            self.im_info["transparency"] = i16(s)
+        elif self.im_mode == "RGB":
+            self.im_info["transparency"] = i16(s), i16(s, 2), i16(s, 4)
+        return s
+
+    def chunk_gAMA(self, pos, length):
+        # gamma setting
+        s = ImageFile._safe_read(self.fp, length)
+        self.im_info["gamma"] = i32(s) / 100000.0
+        return s
+
+    def chunk_cHRM(self, pos, length):
+        # chromaticity, 8 unsigned ints, actual value is scaled by 100,000
+        # WP x,y, Red x,y, Green x,y Blue x,y
+
+        s = ImageFile._safe_read(self.fp, length)
+        raw_vals = struct.unpack(">%dI" % (len(s) // 4), s)
+        self.im_info["chromaticity"] = tuple(elt / 100000.0 for elt in raw_vals)
+        return s
+
+    def chunk_sRGB(self, pos, length):
+        # srgb rendering intent, 1 byte
+        # 0 perceptual
+        # 1 relative colorimetric
+        # 2 saturation
+        # 3 absolute colorimetric
+
+        s = ImageFile._safe_read(self.fp, length)
+        self.im_info["srgb"] = s[0]
+        return s
+
+    def chunk_pHYs(self, pos, length):
+
+        # pixels per unit
+        s = ImageFile._safe_read(self.fp, length)
+        px, py = i32(s, 0), i32(s, 4)
+        unit = s[8]
+        if unit == 1:  # meter
+            dpi = px * 0.0254, py * 0.0254
+            self.im_info["dpi"] = dpi
+        elif unit == 0:
+            self.im_info["aspect"] = px, py
+        return s
+
+    def chunk_tEXt(self, pos, length):
+
+        # text
+        s = ImageFile._safe_read(self.fp, length)
+        try:
+            k, v = s.split(b"\0", 1)
+        except ValueError:
+            # fallback for broken tEXt tags
+            k = s
+            v = b""
+        if k:
+            k = k.decode("latin-1", "strict")
+            v_str = v.decode("latin-1", "replace")
+
+            self.im_info[k] = v if k == "exif" else v_str
+            self.im_text[k] = v_str
+            self.check_text_memory(len(v_str))
+
+        return s
+
+    def chunk_zTXt(self, pos, length):
+
+        # compressed text
+        s = ImageFile._safe_read(self.fp, length)
+        try:
+            k, v = s.split(b"\0", 1)
+        except ValueError:
+            k = s
+            v = b""
+        if v:
+            comp_method = v[0]
+        else:
+            comp_method = 0
+        if comp_method != 0:
+            raise SyntaxError(f"Unknown compression method {comp_method} in zTXt chunk")
+        try:
+            v = _safe_zlib_decompress(v[1:])
+        except ValueError:
+            if ImageFile.LOAD_TRUNCATED_IMAGES:
+                v = b""
+            else:
+                raise
+        except zlib.error:
+            v = b""
+
+        if k:
+            k = k.decode("latin-1", "strict")
+            v = v.decode("latin-1", "replace")
+
+            self.im_info[k] = self.im_text[k] = v
+            self.check_text_memory(len(v))
+
+        return s
+
+    def chunk_iTXt(self, pos, length):
+
+        # international text
+        r = s = ImageFile._safe_read(self.fp, length)
+        try:
+            k, r = r.split(b"\0", 1)
+        except ValueError:
+            return s
+        if len(r) < 2:
+            return s
+        cf, cm, r = r[0], r[1], r[2:]
+        try:
+            lang, tk, v = r.split(b"\0", 2)
+        except ValueError:
+            return s
+        if cf != 0:
+            if cm == 0:
+                try:
+                    v = _safe_zlib_decompress(v)
+                except ValueError:
+                    if ImageFile.LOAD_TRUNCATED_IMAGES:
+                        return s
+                    else:
+                        raise
+                except zlib.error:
+                    return s
+            else:
+                return s
+        try:
+            k = k.decode("latin-1", "strict")
+            lang = lang.decode("utf-8", "strict")
+            tk = tk.decode("utf-8", "strict")
+            v = v.decode("utf-8", "strict")
+        except UnicodeError:
+            return s
+
+        self.im_info[k] = self.im_text[k] = iTXt(v, lang, tk)
+        self.check_text_memory(len(v))
+
+        return s
+
+    def chunk_eXIf(self, pos, length):
+        s = ImageFile._safe_read(self.fp, length)
+        self.im_info["exif"] = b"Exif\x00\x00" + s
+        return s
+
+    # APNG chunks
+    def chunk_acTL(self, pos, length):
+        s = ImageFile._safe_read(self.fp, length)
+        if self.im_n_frames is not None:
+            self.im_n_frames = None
+            warnings.warn("Invalid APNG, will use default PNG image if possible")
+            return s
+        n_frames = i32(s)
+        if n_frames == 0 or n_frames > 0x80000000:
+            warnings.warn("Invalid APNG, will use default PNG image if possible")
+            return s
+        self.im_n_frames = n_frames
+        self.im_info["loop"] = i32(s, 4)
+        self.im_custom_mimetype = "image/apng"
+        return s
+
+    def chunk_fcTL(self, pos, length):
+        s = ImageFile._safe_read(self.fp, length)
+        seq = i32(s)
+        if (self._seq_num is None and seq != 0) or (
+            self._seq_num is not None and self._seq_num != seq - 1
+        ):
+            raise SyntaxError("APNG contains frame sequence errors")
+        self._seq_num = seq
+        width, height = i32(s, 4), i32(s, 8)
+        px, py = i32(s, 12), i32(s, 16)
+        im_w, im_h = self.im_size
+        if px + width > im_w or py + height > im_h:
+            raise SyntaxError("APNG contains invalid frames")
+        self.im_info["bbox"] = (px, py, px + width, py + height)
+        delay_num, delay_den = i16(s, 20), i16(s, 22)
+        if delay_den == 0:
+            delay_den = 100
+        self.im_info["duration"] = float(delay_num) / float(delay_den) * 1000
+        self.im_info["disposal"] = s[24]
+        self.im_info["blend"] = s[25]
+        return s
+
+    def chunk_fdAT(self, pos, length):
+        s = ImageFile._safe_read(self.fp, 4)
+        seq = i32(s)
+        if self._seq_num != seq - 1:
+            raise SyntaxError("APNG contains frame sequence errors")
+        self._seq_num = seq
+        return self.chunk_IDAT(pos + 4, length - 4)
+
+
+# --------------------------------------------------------------------
+# PNG reader
+
+
+def _accept(prefix):
+    return prefix[:8] == _MAGIC
+
+
+##
+# Image plugin for PNG images.
+
+
+class PngImageFile(ImageFile.ImageFile):
+
+    format = "PNG"
+    format_description = "Portable network graphics"
+
+    def _open(self):
+
+        if not _accept(self.fp.read(8)):
+            raise SyntaxError("not a PNG file")
+        self.__fp = self.fp
+        self.__frame = 0
+
+        #
+        # Parse headers up to the first IDAT or fDAT chunk
+
+        self.private_chunks = []
+        self.png = PngStream(self.fp)
+
+        while True:
+
+            #
+            # get next chunk
+
+            cid, pos, length = self.png.read()
+
+            try:
+                s = self.png.call(cid, pos, length)
+            except EOFError:
+                break
+            except AttributeError:
+                logger.debug("%r %s %s (unknown)", cid, pos, length)
+                s = ImageFile._safe_read(self.fp, length)
+                if cid[1:2].islower():
+                    self.private_chunks.append((cid, s))
+
+            self.png.crc(cid, s)
+
+        #
+        # Copy relevant attributes from the PngStream.  An alternative
+        # would be to let the PngStream class modify these attributes
+        # directly, but that introduces circular references which are
+        # difficult to break if things go wrong in the decoder...
+        # (believe me, I've tried ;-)
+
+        self.mode = self.png.im_mode
+        self._size = self.png.im_size
+        self.info = self.png.im_info
+        self._text = None
+        self.tile = self.png.im_tile
+        self.custom_mimetype = self.png.im_custom_mimetype
+        self.n_frames = self.png.im_n_frames or 1
+        self.default_image = self.info.get("default_image", False)
+
+        if self.png.im_palette:
+            rawmode, data = self.png.im_palette
+            self.palette = ImagePalette.raw(rawmode, data)
+
+        if cid == b"fdAT":
+            self.__prepare_idat = length - 4
+        else:
+            self.__prepare_idat = length  # used by load_prepare()
+
+        if self.png.im_n_frames is not None:
+            self._close_exclusive_fp_after_loading = False
+            self.png.save_rewind()
+            self.__rewind_idat = self.__prepare_idat
+            self.__rewind = self.__fp.tell()
+            if self.default_image:
+                # IDAT chunk contains default image and not first animation frame
+                self.n_frames += 1
+            self._seek(0)
+        self.is_animated = self.n_frames > 1
+
+    @property
+    def text(self):
+        # experimental
+        if self._text is None:
+            # iTxt, tEXt and zTXt chunks may appear at the end of the file
+            # So load the file to ensure that they are read
+            if self.is_animated:
+                frame = self.__frame
+                # for APNG, seek to the final frame before loading
+                self.seek(self.n_frames - 1)
+            self.load()
+            if self.is_animated:
+                self.seek(frame)
+        return self._text
+
+    def verify(self):
+        """Verify PNG file"""
+
+        if self.fp is None:
+            raise RuntimeError("verify must be called directly after open")
+
+        # back up to beginning of IDAT block
+        self.fp.seek(self.tile[0][2] - 8)
+
+        self.png.verify()
+        self.png.close()
+
+        if self._exclusive_fp:
+            self.fp.close()
+        self.fp = None
+
+    def seek(self, frame):
+        if not self._seek_check(frame):
+            return
+        if frame < self.__frame:
+            self._seek(0, True)
+
+        last_frame = self.__frame
+        for f in range(self.__frame + 1, frame + 1):
+            try:
+                self._seek(f)
+            except EOFError as e:
+                self.seek(last_frame)
+                raise EOFError("no more images in APNG file") from e
+
+    def _seek(self, frame, rewind=False):
+        if frame == 0:
+            if rewind:
+                self.__fp.seek(self.__rewind)
+                self.png.rewind()
+                self.__prepare_idat = self.__rewind_idat
+                self.im = None
+                if self.pyaccess:
+                    self.pyaccess = None
+                self.info = self.png.im_info
+                self.tile = self.png.im_tile
+                self.fp = self.__fp
+            self._prev_im = None
+            self.dispose = None
+            self.default_image = self.info.get("default_image", False)
+            self.dispose_op = self.info.get("disposal")
+            self.blend_op = self.info.get("blend")
+            self.dispose_extent = self.info.get("bbox")
+            self.__frame = 0
+        else:
+            if frame != self.__frame + 1:
+                raise ValueError(f"cannot seek to frame {frame}")
+
+            # ensure previous frame was loaded
+            self.load()
+
+            if self.dispose:
+                self.im.paste(self.dispose, self.dispose_extent)
+            self._prev_im = self.im.copy()
+
+            self.fp = self.__fp
+
+            # advance to the next frame
+            if self.__prepare_idat:
+                ImageFile._safe_read(self.fp, self.__prepare_idat)
+                self.__prepare_idat = 0
+            frame_start = False
+            while True:
+                self.fp.read(4)  # CRC
+
+                try:
+                    cid, pos, length = self.png.read()
+                except (struct.error, SyntaxError):
+                    break
+
+                if cid == b"IEND":
+                    raise EOFError("No more images in APNG file")
+                if cid == b"fcTL":
+                    if frame_start:
+                        # there must be at least one fdAT chunk between fcTL chunks
+                        raise SyntaxError("APNG missing frame data")
+                    frame_start = True
+
+                try:
+                    self.png.call(cid, pos, length)
+                except UnicodeDecodeError:
+                    break
+                except EOFError:
+                    if cid == b"fdAT":
+                        length -= 4
+                        if frame_start:
+                            self.__prepare_idat = length
+                            break
+                    ImageFile._safe_read(self.fp, length)
+                except AttributeError:
+                    logger.debug("%r %s %s (unknown)", cid, pos, length)
+                    ImageFile._safe_read(self.fp, length)
+
+            self.__frame = frame
+            self.tile = self.png.im_tile
+            self.dispose_op = self.info.get("disposal")
+            self.blend_op = self.info.get("blend")
+            self.dispose_extent = self.info.get("bbox")
+
+            if not self.tile:
+                raise EOFError
+
+        # setup frame disposal (actual disposal done when needed in the next _seek())
+        if self._prev_im is None and self.dispose_op == Disposal.OP_PREVIOUS:
+            self.dispose_op = Disposal.OP_BACKGROUND
+
+        if self.dispose_op == Disposal.OP_PREVIOUS:
+            self.dispose = self._prev_im.copy()
+            self.dispose = self._crop(self.dispose, self.dispose_extent)
+        elif self.dispose_op == Disposal.OP_BACKGROUND:
+            self.dispose = Image.core.fill(self.mode, self.size)
+            self.dispose = self._crop(self.dispose, self.dispose_extent)
+        else:
+            self.dispose = None
+
+    def tell(self):
+        return self.__frame
+
+    def load_prepare(self):
+        """internal: prepare to read PNG file"""
+
+        if self.info.get("interlace"):
+            self.decoderconfig = self.decoderconfig + (1,)
+
+        self.__idat = self.__prepare_idat  # used by load_read()
+        ImageFile.ImageFile.load_prepare(self)
+
+    def load_read(self, read_bytes):
+        """internal: read more image data"""
+
+        while self.__idat == 0:
+            # end of chunk, skip forward to next one
+
+            self.fp.read(4)  # CRC
+
+            cid, pos, length = self.png.read()
+
+            if cid not in [b"IDAT", b"DDAT", b"fdAT"]:
+                self.png.push(cid, pos, length)
+                return b""
+
+            if cid == b"fdAT":
+                try:
+                    self.png.call(cid, pos, length)
+                except EOFError:
+                    pass
+                self.__idat = length - 4  # sequence_num has already been read
+            else:
+                self.__idat = length  # empty chunks are allowed
+
+        # read more data from this chunk
+        if read_bytes <= 0:
+            read_bytes = self.__idat
+        else:
+            read_bytes = min(read_bytes, self.__idat)
+
+        self.__idat = self.__idat - read_bytes
+
+        return self.fp.read(read_bytes)
+
+    def load_end(self):
+        """internal: finished reading image data"""
+        if self.__idat != 0:
+            self.fp.read(self.__idat)
+        while True:
+            self.fp.read(4)  # CRC
+
+            try:
+                cid, pos, length = self.png.read()
+            except (struct.error, SyntaxError):
+                break
+
+            if cid == b"IEND":
+                break
+            elif cid == b"fcTL" and self.is_animated:
+                # start of the next frame, stop reading
+                self.__prepare_idat = 0
+                self.png.push(cid, pos, length)
+                break
+
+            try:
+                self.png.call(cid, pos, length)
+            except UnicodeDecodeError:
+                break
+            except EOFError:
+                if cid == b"fdAT":
+                    length -= 4
+                ImageFile._safe_read(self.fp, length)
+            except AttributeError:
+                logger.debug("%r %s %s (unknown)", cid, pos, length)
+                s = ImageFile._safe_read(self.fp, length)
+                if cid[1:2].islower():
+                    self.private_chunks.append((cid, s, True))
+        self._text = self.png.im_text
+        if not self.is_animated:
+            self.png.close()
+            self.png = None
+        else:
+            if self._prev_im and self.blend_op == Blend.OP_OVER:
+                updated = self._crop(self.im, self.dispose_extent)
+                self._prev_im.paste(
+                    updated, self.dispose_extent, updated.convert("RGBA")
+                )
+                self.im = self._prev_im
+                if self.pyaccess:
+                    self.pyaccess = None
+
+    def _getexif(self):
+        if "exif" not in self.info:
+            self.load()
+        if "exif" not in self.info and "Raw profile type exif" not in self.info:
+            return None
+        return self.getexif()._get_merged_dict()
+
+    def getexif(self):
+        if "exif" not in self.info:
+            self.load()
+
+        return super().getexif()
+
+    def getxmp(self):
+        """
+        Returns a dictionary containing the XMP tags.
+        Requires defusedxml to be installed.
+
+        :returns: XMP tags in a dictionary.
+        """
+        return (
+            self._getxmp(self.info["XML:com.adobe.xmp"])
+            if "XML:com.adobe.xmp" in self.info
+            else {}
+        )
+
+    def _close__fp(self):
+        try:
+            if self.__fp != self.fp:
+                self.__fp.close()
+        except AttributeError:
+            pass
+        finally:
+            self.__fp = None
+
+
+# --------------------------------------------------------------------
+# PNG writer
+
+_OUTMODES = {
+    # supported PIL modes, and corresponding rawmodes/bits/color combinations
+    "1": ("1", b"\x01\x00"),
+    "L;1": ("L;1", b"\x01\x00"),
+    "L;2": ("L;2", b"\x02\x00"),
+    "L;4": ("L;4", b"\x04\x00"),
+    "L": ("L", b"\x08\x00"),
+    "LA": ("LA", b"\x08\x04"),
+    "I": ("I;16B", b"\x10\x00"),
+    "I;16": ("I;16B", b"\x10\x00"),
+    "P;1": ("P;1", b"\x01\x03"),
+    "P;2": ("P;2", b"\x02\x03"),
+    "P;4": ("P;4", b"\x04\x03"),
+    "P": ("P", b"\x08\x03"),
+    "RGB": ("RGB", b"\x08\x02"),
+    "RGBA": ("RGBA", b"\x08\x06"),
+}
+
+
+def putchunk(fp, cid, *data):
+    """Write a PNG chunk (including CRC field)"""
+
+    data = b"".join(data)
+
+    fp.write(o32(len(data)) + cid)
+    fp.write(data)
+    crc = _crc32(data, _crc32(cid))
+    fp.write(o32(crc))
+
+
+class _idat:
+    # wrap output from the encoder in IDAT chunks
+
+    def __init__(self, fp, chunk):
+        self.fp = fp
+        self.chunk = chunk
+
+    def write(self, data):
+        self.chunk(self.fp, b"IDAT", data)
+
+
+class _fdat:
+    # wrap encoder output in fdAT chunks
+
+    def __init__(self, fp, chunk, seq_num):
+        self.fp = fp
+        self.chunk = chunk
+        self.seq_num = seq_num
+
+    def write(self, data):
+        self.chunk(self.fp, b"fdAT", o32(self.seq_num), data)
+        self.seq_num += 1
+
+
+def _write_multiple_frames(im, fp, chunk, rawmode):
+    default_image = im.encoderinfo.get("default_image", im.info.get("default_image"))
+    duration = im.encoderinfo.get("duration", im.info.get("duration", 0))
+    loop = im.encoderinfo.get("loop", im.info.get("loop", 0))
+    disposal = im.encoderinfo.get("disposal", im.info.get("disposal", Disposal.OP_NONE))
+    blend = im.encoderinfo.get("blend", im.info.get("blend", Blend.OP_SOURCE))
+
+    if default_image:
+        chain = itertools.chain(im.encoderinfo.get("append_images", []))
+    else:
+        chain = itertools.chain([im], im.encoderinfo.get("append_images", []))
+
+    im_frames = []
+    frame_count = 0
+    for im_seq in chain:
+        for im_frame in ImageSequence.Iterator(im_seq):
+            im_frame = im_frame.copy()
+            if im_frame.mode != im.mode:
+                if im.mode == "P":
+                    im_frame = im_frame.convert(im.mode, palette=im.palette)
+                else:
+                    im_frame = im_frame.convert(im.mode)
+            encoderinfo = im.encoderinfo.copy()
+            if isinstance(duration, (list, tuple)):
+                encoderinfo["duration"] = duration[frame_count]
+            if isinstance(disposal, (list, tuple)):
+                encoderinfo["disposal"] = disposal[frame_count]
+            if isinstance(blend, (list, tuple)):
+                encoderinfo["blend"] = blend[frame_count]
+            frame_count += 1
+
+            if im_frames:
+                previous = im_frames[-1]
+                prev_disposal = previous["encoderinfo"].get("disposal")
+                prev_blend = previous["encoderinfo"].get("blend")
+                if prev_disposal == Disposal.OP_PREVIOUS and len(im_frames) < 2:
+                    prev_disposal = Disposal.OP_BACKGROUND
+
+                if prev_disposal == Disposal.OP_BACKGROUND:
+                    base_im = previous["im"]
+                    dispose = Image.core.fill("RGBA", im.size, (0, 0, 0, 0))
+                    bbox = previous["bbox"]
+                    if bbox:
+                        dispose = dispose.crop(bbox)
+                    else:
+                        bbox = (0, 0) + im.size
+                    base_im.paste(dispose, bbox)
+                elif prev_disposal == Disposal.OP_PREVIOUS:
+                    base_im = im_frames[-2]["im"]
+                else:
+                    base_im = previous["im"]
+                delta = ImageChops.subtract_modulo(
+                    im_frame.convert("RGB"), base_im.convert("RGB")
+                )
+                bbox = delta.getbbox()
+                if (
+                    not bbox
+                    and prev_disposal == encoderinfo.get("disposal")
+                    and prev_blend == encoderinfo.get("blend")
+                ):
+                    if isinstance(duration, (list, tuple)):
+                        previous["encoderinfo"]["duration"] += encoderinfo["duration"]
+                    continue
+            else:
+                bbox = None
+            im_frames.append({"im": im_frame, "bbox": bbox, "encoderinfo": encoderinfo})
+
+    # animation control
+    chunk(
+        fp,
+        b"acTL",
+        o32(len(im_frames)),  # 0: num_frames
+        o32(loop),  # 4: num_plays
+    )
+
+    # default image IDAT (if it exists)
+    if default_image:
+        ImageFile._save(im, _idat(fp, chunk), [("zip", (0, 0) + im.size, 0, rawmode)])
+
+    seq_num = 0
+    for frame, frame_data in enumerate(im_frames):
+        im_frame = frame_data["im"]
+        if not frame_data["bbox"]:
+            bbox = (0, 0) + im_frame.size
+        else:
+            bbox = frame_data["bbox"]
+            im_frame = im_frame.crop(bbox)
+        size = im_frame.size
+        encoderinfo = frame_data["encoderinfo"]
+        frame_duration = int(round(encoderinfo.get("duration", duration)))
+        frame_disposal = encoderinfo.get("disposal", disposal)
+        frame_blend = encoderinfo.get("blend", blend)
+        # frame control
+        chunk(
+            fp,
+            b"fcTL",
+            o32(seq_num),  # sequence_number
+            o32(size[0]),  # width
+            o32(size[1]),  # height
+            o32(bbox[0]),  # x_offset
+            o32(bbox[1]),  # y_offset
+            o16(frame_duration),  # delay_numerator
+            o16(1000),  # delay_denominator
+            o8(frame_disposal),  # dispose_op
+            o8(frame_blend),  # blend_op
+        )
+        seq_num += 1
+        # frame data
+        if frame == 0 and not default_image:
+            # first frame must be in IDAT chunks for backwards compatibility
+            ImageFile._save(
+                im_frame,
+                _idat(fp, chunk),
+                [("zip", (0, 0) + im_frame.size, 0, rawmode)],
+            )
+        else:
+            fdat_chunks = _fdat(fp, chunk, seq_num)
+            ImageFile._save(
+                im_frame,
+                fdat_chunks,
+                [("zip", (0, 0) + im_frame.size, 0, rawmode)],
+            )
+            seq_num = fdat_chunks.seq_num
+
+
+def _save_all(im, fp, filename):
+    _save(im, fp, filename, save_all=True)
+
+
+def _save(im, fp, filename, chunk=putchunk, save_all=False):
+    # save an image to disk (called by the save method)
+
+    mode = im.mode
+
+    if mode == "P":
+
+        #
+        # attempt to minimize storage requirements for palette images
+        if "bits" in im.encoderinfo:
+            # number of bits specified by user
+            colors = min(1 << im.encoderinfo["bits"], 256)
+        else:
+            # check palette contents
+            if im.palette:
+                colors = max(min(len(im.palette.getdata()[1]) // 3, 256), 1)
+            else:
+                colors = 256
+
+        if colors <= 16:
+            if colors <= 2:
+                bits = 1
+            elif colors <= 4:
+                bits = 2
+            else:
+                bits = 4
+            mode = f"{mode};{bits}"
+
+    # encoder options
+    im.encoderconfig = (
+        im.encoderinfo.get("optimize", False),
+        im.encoderinfo.get("compress_level", -1),
+        im.encoderinfo.get("compress_type", -1),
+        im.encoderinfo.get("dictionary", b""),
+    )
+
+    # get the corresponding PNG mode
+    try:
+        rawmode, mode = _OUTMODES[mode]
+    except KeyError as e:
+        raise OSError(f"cannot write mode {mode} as PNG") from e
+
+    #
+    # write minimal PNG file
+
+    fp.write(_MAGIC)
+
+    chunk(
+        fp,
+        b"IHDR",
+        o32(im.size[0]),  # 0: size
+        o32(im.size[1]),
+        mode,  # 8: depth/type
+        b"\0",  # 10: compression
+        b"\0",  # 11: filter category
+        b"\0",  # 12: interlace flag
+    )
+
+    chunks = [b"cHRM", b"gAMA", b"sBIT", b"sRGB", b"tIME"]
+
+    icc = im.encoderinfo.get("icc_profile", im.info.get("icc_profile"))
+    if icc:
+        # ICC profile
+        # according to PNG spec, the iCCP chunk contains:
+        # Profile name  1-79 bytes (character string)
+        # Null separator        1 byte (null character)
+        # Compression method    1 byte (0)
+        # Compressed profile    n bytes (zlib with deflate compression)
+        name = b"ICC Profile"
+        data = name + b"\0\0" + zlib.compress(icc)
+        chunk(fp, b"iCCP", data)
+
+        # You must either have sRGB or iCCP.
+        # Disallow sRGB chunks when an iCCP-chunk has been emitted.
+        chunks.remove(b"sRGB")
+
+    info = im.encoderinfo.get("pnginfo")
+    if info:
+        chunks_multiple_allowed = [b"sPLT", b"iTXt", b"tEXt", b"zTXt"]
+        for info_chunk in info.chunks:
+            cid, data = info_chunk[:2]
+            if cid in chunks:
+                chunks.remove(cid)
+                chunk(fp, cid, data)
+            elif cid in chunks_multiple_allowed:
+                chunk(fp, cid, data)
+            elif cid[1:2].islower():
+                # Private chunk
+                after_idat = info_chunk[2:3]
+                if not after_idat:
+                    chunk(fp, cid, data)
+
+    if im.mode == "P":
+        palette_byte_number = colors * 3
+        palette_bytes = im.im.getpalette("RGB")[:palette_byte_number]
+        while len(palette_bytes) < palette_byte_number:
+            palette_bytes += b"\0"
+        chunk(fp, b"PLTE", palette_bytes)
+
+    transparency = im.encoderinfo.get("transparency", im.info.get("transparency", None))
+
+    if transparency or transparency == 0:
+        if im.mode == "P":
+            # limit to actual palette size
+            alpha_bytes = colors
+            if isinstance(transparency, bytes):
+                chunk(fp, b"tRNS", transparency[:alpha_bytes])
+            else:
+                transparency = max(0, min(255, transparency))
+                alpha = b"\xFF" * transparency + b"\0"
+                chunk(fp, b"tRNS", alpha[:alpha_bytes])
+        elif im.mode in ("1", "L", "I"):
+            transparency = max(0, min(65535, transparency))
+            chunk(fp, b"tRNS", o16(transparency))
+        elif im.mode == "RGB":
+            red, green, blue = transparency
+            chunk(fp, b"tRNS", o16(red) + o16(green) + o16(blue))
+        else:
+            if "transparency" in im.encoderinfo:
+                # don't bother with transparency if it's an RGBA
+                # and it's in the info dict. It's probably just stale.
+                raise OSError("cannot use transparency for this mode")
+    else:
+        if im.mode == "P" and im.im.getpalettemode() == "RGBA":
+            alpha = im.im.getpalette("RGBA", "A")
+            alpha_bytes = colors
+            chunk(fp, b"tRNS", alpha[:alpha_bytes])
+
+    dpi = im.encoderinfo.get("dpi")
+    if dpi:
+        chunk(
+            fp,
+            b"pHYs",
+            o32(int(dpi[0] / 0.0254 + 0.5)),
+            o32(int(dpi[1] / 0.0254 + 0.5)),
+            b"\x01",
+        )
+
+    if info:
+        chunks = [b"bKGD", b"hIST"]
+        for info_chunk in info.chunks:
+            cid, data = info_chunk[:2]
+            if cid in chunks:
+                chunks.remove(cid)
+                chunk(fp, cid, data)
+
+    exif = im.encoderinfo.get("exif", im.info.get("exif"))
+    if exif:
+        if isinstance(exif, Image.Exif):
+            exif = exif.tobytes(8)
+        if exif.startswith(b"Exif\x00\x00"):
+            exif = exif[6:]
+        chunk(fp, b"eXIf", exif)
+
+    if save_all:
+        _write_multiple_frames(im, fp, chunk, rawmode)
+    else:
+        ImageFile._save(im, _idat(fp, chunk), [("zip", (0, 0) + im.size, 0, rawmode)])
+
+    if info:
+        for info_chunk in info.chunks:
+            cid, data = info_chunk[:2]
+            if cid[1:2].islower():
+                # Private chunk
+                after_idat = info_chunk[2:3]
+                if after_idat:
+                    chunk(fp, cid, data)
+
+    chunk(fp, b"IEND", b"")
+
+    if hasattr(fp, "flush"):
+        fp.flush()
+
+
+# --------------------------------------------------------------------
+# PNG chunk converter
+
+
+def getchunks(im, **params):
+    """Return a list of PNG chunks representing this image."""
+
+    class collector:
+        data = []
+
+        def write(self, data):
+            pass
+
+        def append(self, chunk):
+            self.data.append(chunk)
+
+    def append(fp, cid, *data):
+        data = b"".join(data)
+        crc = o32(_crc32(data, _crc32(cid)))
+        fp.append((cid, data, crc))
+
+    fp = collector()
+
+    try:
+        im.encoderinfo = params
+        _save(im, fp, None, append)
+    finally:
+        del im.encoderinfo
+
+    return fp.data
+
+
+# --------------------------------------------------------------------
+# Registry
+
+Image.register_open(PngImageFile.format, PngImageFile, _accept)
+Image.register_save(PngImageFile.format, _save)
+Image.register_save_all(PngImageFile.format, _save_all)
+
+Image.register_extensions(PngImageFile.format, [".png", ".apng"])
+
+Image.register_mime(PngImageFile.format, "image/png")

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/PIL/PpmImagePlugin.py

@@ -0,0 +1,199 @@
+#
+# The Python Imaging Library.
+# $Id$
+#
+# PPM support for PIL
+#
+# History:
+#       96-03-24 fl     Created
+#       98-03-06 fl     Write RGBA images (as RGB, that is)
+#
+# Copyright (c) Secret Labs AB 1997-98.
+# Copyright (c) Fredrik Lundh 1996.
+#
+# See the README file for information on usage and redistribution.
+#
+
+
+from . import Image, ImageFile
+from ._binary import i16be as i16
+from ._binary import o8
+from ._binary import o32le as o32
+
+#
+# --------------------------------------------------------------------
+
+b_whitespace = b"\x20\x09\x0a\x0b\x0c\x0d"
+
+MODES = {
+    # standard
+    b"P4": "1",
+    b"P5": "L",
+    b"P6": "RGB",
+    # extensions
+    b"P0CMYK": "CMYK",
+    # PIL extensions (for test purposes only)
+    b"PyP": "P",
+    b"PyRGBA": "RGBA",
+    b"PyCMYK": "CMYK",
+}
+
+
+def _accept(prefix):
+    return prefix[0:1] == b"P" and prefix[1] in b"0456y"
+
+
+##
+# Image plugin for PBM, PGM, and PPM images.
+
+
+class PpmImageFile(ImageFile.ImageFile):
+
+    format = "PPM"
+    format_description = "Pbmplus image"
+
+    def _read_magic(self):
+        magic = b""
+        # read until whitespace or longest available magic number
+        for _ in range(6):
+            c = self.fp.read(1)
+            if not c or c in b_whitespace:
+                break
+            magic += c
+        return magic
+
+    def _read_token(self):
+        token = b""
+        while len(token) <= 10:  # read until next whitespace or limit of 10 characters
+            c = self.fp.read(1)
+            if not c:
+                break
+            elif c in b_whitespace:  # token ended
+                if not token:
+                    # skip whitespace at start
+                    continue
+                break
+            elif c == b"#":
+                # ignores rest of the line; stops at CR, LF or EOF
+                while self.fp.read(1) not in b"\r\n":
+                    pass
+                continue
+            token += c
+        if not token:
+            # Token was not even 1 byte
+            raise ValueError("Reached EOF while reading header")
+        elif len(token) > 10:
+            raise ValueError(f"Token too long in file header: {token}")
+        return token
+
+    def _open(self):
+        magic_number = self._read_magic()
+        try:
+            mode = MODES[magic_number]
+        except KeyError:
+            raise SyntaxError("not a PPM file")
+
+        self.custom_mimetype = {
+            b"P4": "image/x-portable-bitmap",
+            b"P5": "image/x-portable-graymap",
+            b"P6": "image/x-portable-pixmap",
+        }.get(magic_number)
+
+        if mode == "1":
+            self.mode = "1"
+            rawmode = "1;I"
+        else:
+            self.mode = rawmode = mode
+
+        decoder_name = "raw"
+        for ix in range(3):
+            token = int(self._read_token())
+            if ix == 0:  # token is the x size
+                xsize = token
+            elif ix == 1:  # token is the y size
+                ysize = token
+                if mode == "1":
+                    break
+            elif ix == 2:  # token is maxval
+                maxval = token
+                if maxval > 255 and mode == "L":
+                    self.mode = "I"
+
+                # If maxval matches a bit depth, use the raw decoder directly
+                if maxval == 65535 and mode == "L":
+                    rawmode = "I;16B"
+                elif maxval != 255:
+                    decoder_name = "ppm"
+        args = (rawmode, 0, 1) if decoder_name == "raw" else (rawmode, maxval)
+
+        self._size = xsize, ysize
+        self.tile = [(decoder_name, (0, 0, xsize, ysize), self.fp.tell(), args)]
+
+
+class PpmDecoder(ImageFile.PyDecoder):
+    _pulls_fd = True
+
+    def decode(self, buffer):
+        data = bytearray()
+        maxval = min(self.args[-1], 65535)
+        in_byte_count = 1 if maxval < 256 else 2
+        out_byte_count = 4 if self.mode == "I" else 1
+        out_max = 65535 if self.mode == "I" else 255
+        bands = Image.getmodebands(self.mode)
+        while len(data) < self.state.xsize * self.state.ysize * bands * out_byte_count:
+            pixels = self.fd.read(in_byte_count * bands)
+            if len(pixels) < in_byte_count * bands:
+                # eof
+                break
+            for b in range(bands):
+                value = (
+                    pixels[b] if in_byte_count == 1 else i16(pixels, b * in_byte_count)
+                )
+                value = min(out_max, round(value / maxval * out_max))
+                data += o32(value) if self.mode == "I" else o8(value)
+        rawmode = "I;32" if self.mode == "I" else self.mode
+        self.set_as_raw(bytes(data), (rawmode, 0, 1))
+        return -1, 0
+
+
+#
+# --------------------------------------------------------------------
+
+
+def _save(im, fp, filename):
+    if im.mode == "1":
+        rawmode, head = "1;I", b"P4"
+    elif im.mode == "L":
+        rawmode, head = "L", b"P5"
+    elif im.mode == "I":
+        rawmode, head = "I;16B", b"P5"
+    elif im.mode in ("RGB", "RGBA"):
+        rawmode, head = "RGB", b"P6"
+    else:
+        raise OSError(f"cannot write mode {im.mode} as PPM")
+    fp.write(head + b"\n%d %d\n" % im.size)
+    if head == b"P6":
+        fp.write(b"255\n")
+    elif head == b"P5":
+        if rawmode == "L":
+            fp.write(b"255\n")
+        else:
+            fp.write(b"65535\n")
+    ImageFile._save(im, fp, [("raw", (0, 0) + im.size, 0, (rawmode, 0, 1))])
+
+    # ALTERNATIVE: save via builtin debug function
+    # im._dump(filename)
+
+
+#
+# --------------------------------------------------------------------
+
+
+Image.register_open(PpmImageFile.format, PpmImageFile, _accept)
+Image.register_save(PpmImageFile.format, _save)
+
+Image.register_decoder("ppm", PpmDecoder)
+
+Image.register_extensions(PpmImageFile.format, [".pbm", ".pgm", ".ppm", ".pnm"])
+
+Image.register_mime(PpmImageFile.format, "image/x-portable-anymap")

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/PIL/PsdImagePlugin.py

@@ -0,0 +1,311 @@
+#
+# The Python Imaging Library
+# $Id$
+#
+# Adobe PSD 2.5/3.0 file handling
+#
+# History:
+# 1995-09-01 fl   Created
+# 1997-01-03 fl   Read most PSD images
+# 1997-01-18 fl   Fixed P and CMYK support
+# 2001-10-21 fl   Added seek/tell support (for layers)
+#
+# Copyright (c) 1997-2001 by Secret Labs AB.
+# Copyright (c) 1995-2001 by Fredrik Lundh
+#
+# See the README file for information on usage and redistribution.
+#
+
+import io
+
+from . import Image, ImageFile, ImagePalette
+from ._binary import i8
+from ._binary import i16be as i16
+from ._binary import i32be as i32
+from ._binary import si16be as si16
+
+MODES = {
+    # (photoshop mode, bits) -> (pil mode, required channels)
+    (0, 1): ("1", 1),
+    (0, 8): ("L", 1),
+    (1, 8): ("L", 1),
+    (2, 8): ("P", 1),
+    (3, 8): ("RGB", 3),
+    (4, 8): ("CMYK", 4),
+    (7, 8): ("L", 1),  # FIXME: multilayer
+    (8, 8): ("L", 1),  # duotone
+    (9, 8): ("LAB", 3),
+}
+
+
+# --------------------------------------------------------------------.
+# read PSD images
+
+
+def _accept(prefix):
+    return prefix[:4] == b"8BPS"
+
+
+##
+# Image plugin for Photoshop images.
+
+
+class PsdImageFile(ImageFile.ImageFile):
+
+    format = "PSD"
+    format_description = "Adobe Photoshop"
+    _close_exclusive_fp_after_loading = False
+
+    def _open(self):
+
+        read = self.fp.read
+
+        #
+        # header
+
+        s = read(26)
+        if not _accept(s) or i16(s, 4) != 1:
+            raise SyntaxError("not a PSD file")
+
+        psd_bits = i16(s, 22)
+        psd_channels = i16(s, 12)
+        psd_mode = i16(s, 24)
+
+        mode, channels = MODES[(psd_mode, psd_bits)]
+
+        if channels > psd_channels:
+            raise OSError("not enough channels")
+
+        self.mode = mode
+        self._size = i32(s, 18), i32(s, 14)
+
+        #
+        # color mode data
+
+        size = i32(read(4))
+        if size:
+            data = read(size)
+            if mode == "P" and size == 768:
+                self.palette = ImagePalette.raw("RGB;L", data)
+
+        #
+        # image resources
+
+        self.resources = []
+
+        size = i32(read(4))
+        if size:
+            # load resources
+            end = self.fp.tell() + size
+            while self.fp.tell() < end:
+                read(4)  # signature
+                id = i16(read(2))
+                name = read(i8(read(1)))
+                if not (len(name) & 1):
+                    read(1)  # padding
+                data = read(i32(read(4)))
+                if len(data) & 1:
+                    read(1)  # padding
+                self.resources.append((id, name, data))
+                if id == 1039:  # ICC profile
+                    self.info["icc_profile"] = data
+
+        #
+        # layer and mask information
+
+        self.layers = []
+
+        size = i32(read(4))
+        if size:
+            end = self.fp.tell() + size
+            size = i32(read(4))
+            if size:
+                _layer_data = io.BytesIO(ImageFile._safe_read(self.fp, size))
+                self.layers = _layerinfo(_layer_data, size)
+            self.fp.seek(end)
+        self.n_frames = len(self.layers)
+        self.is_animated = self.n_frames > 1
+
+        #
+        # image descriptor
+
+        self.tile = _maketile(self.fp, mode, (0, 0) + self.size, channels)
+
+        # keep the file open
+        self.__fp = self.fp
+        self.frame = 1
+        self._min_frame = 1
+
+    def seek(self, layer):
+        if not self._seek_check(layer):
+            return
+
+        # seek to given layer (1..max)
+        try:
+            name, mode, bbox, tile = self.layers[layer - 1]
+            self.mode = mode
+            self.tile = tile
+            self.frame = layer
+            self.fp = self.__fp
+            return name, bbox
+        except IndexError as e:
+            raise EOFError("no such layer") from e
+
+    def tell(self):
+        # return layer number (0=image, 1..max=layers)
+        return self.frame
+
+    def _close__fp(self):
+        try:
+            if self.__fp != self.fp:
+                self.__fp.close()
+        except AttributeError:
+            pass
+        finally:
+            self.__fp = None
+
+
+def _layerinfo(fp, ct_bytes):
+    # read layerinfo block
+    layers = []
+
+    def read(size):
+        return ImageFile._safe_read(fp, size)
+
+    ct = si16(read(2))
+
+    # sanity check
+    if ct_bytes < (abs(ct) * 20):
+        raise SyntaxError("Layer block too short for number of layers requested")
+
+    for i in range(abs(ct)):
+
+        # bounding box
+        y0 = i32(read(4))
+        x0 = i32(read(4))
+        y1 = i32(read(4))
+        x1 = i32(read(4))
+
+        # image info
+        mode = []
+        ct_types = i16(read(2))
+        types = list(range(ct_types))
+        if len(types) > 4:
+            continue
+
+        for i in types:
+            type = i16(read(2))
+
+            if type == 65535:
+                m = "A"
+            else:
+                m = "RGBA"[type]
+
+            mode.append(m)
+            read(4)  # size
+
+        # figure out the image mode
+        mode.sort()
+        if mode == ["R"]:
+            mode = "L"
+        elif mode == ["B", "G", "R"]:
+            mode = "RGB"
+        elif mode == ["A", "B", "G", "R"]:
+            mode = "RGBA"
+        else:
+            mode = None  # unknown
+
+        # skip over blend flags and extra information
+        read(12)  # filler
+        name = ""
+        size = i32(read(4))  # length of the extra data field
+        if size:
+            data_end = fp.tell() + size
+
+            length = i32(read(4))
+            if length:
+                fp.seek(length - 16, io.SEEK_CUR)
+
+            length = i32(read(4))
+            if length:
+                fp.seek(length, io.SEEK_CUR)
+
+            length = i8(read(1))
+            if length:
+                # Don't know the proper encoding,
+                # Latin-1 should be a good guess
+                name = read(length).decode("latin-1", "replace")
+
+            fp.seek(data_end)
+        layers.append((name, mode, (x0, y0, x1, y1)))
+
+    # get tiles
+    i = 0
+    for name, mode, bbox in layers:
+        tile = []
+        for m in mode:
+            t = _maketile(fp, m, bbox, 1)
+            if t:
+                tile.extend(t)
+        layers[i] = name, mode, bbox, tile
+        i += 1
+
+    return layers
+
+
+def _maketile(file, mode, bbox, channels):
+
+    tile = None
+    read = file.read
+
+    compression = i16(read(2))
+
+    xsize = bbox[2] - bbox[0]
+    ysize = bbox[3] - bbox[1]
+
+    offset = file.tell()
+
+    if compression == 0:
+        #
+        # raw compression
+        tile = []
+        for channel in range(channels):
+            layer = mode[channel]
+            if mode == "CMYK":
+                layer += ";I"
+            tile.append(("raw", bbox, offset, layer))
+            offset = offset + xsize * ysize
+
+    elif compression == 1:
+        #
+        # packbits compression
+        i = 0
+        tile = []
+        bytecount = read(channels * ysize * 2)
+        offset = file.tell()
+        for channel in range(channels):
+            layer = mode[channel]
+            if mode == "CMYK":
+                layer += ";I"
+            tile.append(("packbits", bbox, offset, layer))
+            for y in range(ysize):
+                offset = offset + i16(bytecount, i)
+                i += 2
+
+    file.seek(offset)
+
+    if offset & 1:
+        read(1)  # padding
+
+    return tile
+
+
+# --------------------------------------------------------------------
+# registry
+
+
+Image.register_open(PsdImageFile.format, PsdImageFile, _accept)
+
+Image.register_extension(PsdImageFile.format, ".psd")
+
+Image.register_mime(PsdImageFile.format, "image/vnd.adobe.photoshop")