sdata 1.5.0__py3-none-any.whl

sdata/contrib/piexif/_insert.py

@@ -0,0 +1,60 @@
+import io
+import struct
+import sys
+
+from ._common import *
+from ._exceptions import InvalidImageDataError
+from . import _webp
+
+def insert(exif, image, new_file=None):
+    """
+    py:function:: piexif.insert(exif_bytes, filename)
+
+    Insert exif into JPEG.
+
+    :param bytes exif_bytes: Exif as bytes
+    :param str filename: JPEG
+    """
+    if exif[0:6] != b"\x45\x78\x69\x66\x00\x00":
+        raise ValueError("Given data is not exif data")
+
+    output_file = False
+    # Prevents "UnicodeWarning: Unicode equal comparison failed" warnings on Python 2
+    maybe_image = sys.version_info >= (3,0,0) or isinstance(image, str)
+
+    if maybe_image and image[0:2] == b"\xff\xd8":
+        image_data = image
+        file_type = "jpeg"
+    elif maybe_image and image[0:4] == b"RIFF" and image[8:12] == b"WEBP":
+        image_data = image
+        file_type = "webp"
+    else:
+        with open(image, 'rb') as f:
+            image_data = f.read()
+        if image_data[0:2] == b"\xff\xd8":
+            file_type = "jpeg"
+        elif image_data[0:4] == b"RIFF" and image_data[8:12] == b"WEBP":
+            file_type = "webp"
+        else:
+            raise InvalidImageDataError
+        output_file = True
+
+    if file_type == "jpeg":
+        exif = b"\xff\xe1" + struct.pack(">H", len(exif) + 2) + exif
+        segments = split_into_segments(image_data)
+        new_data = merge_segments(segments, exif)
+    elif file_type == "webp":
+        exif = exif[6:]
+        new_data = _webp.insert(image_data, exif)
+
+    if isinstance(new_file, io.BytesIO):
+        new_file.write(new_data)
+        new_file.seek(0)
+    elif new_file:
+        with open(new_file, "wb+") as f:
+            f.write(new_data)
+    elif output_file:
+        with open(image, "wb+") as f:
+            f.write(new_data)
+    else:
+        raise ValueError("Give a 3rd argument to 'insert' to output file")

sdata/contrib/piexif/_load.py

@@ -0,0 +1,270 @@
+import struct
+import sys
+
+from ._common import *
+from ._exceptions import InvalidImageDataError
+from ._exif import *
+from . import _webp
+
+LITTLE_ENDIAN = b"\x49\x49"
+
+
+def load(input_data, key_is_name=False):
+    """
+    py:function:: piexif.load(filename)
+
+    Return exif data as dict. Keys(IFD name), be contained, are "0th", "Exif", "GPS", "Interop", "1st", and "thumbnail". Without "thumbnail", the value is dict(tag name/tag value). "thumbnail" value is JPEG as bytes.
+
+    :param str filename: JPEG or TIFF
+    :return: Exif data({"0th":dict, "Exif":dict, "GPS":dict, "Interop":dict, "1st":dict, "thumbnail":bytes})
+    :rtype: dict
+    """
+    exif_dict = {"0th":{},
+                 "Exif":{},
+                 "GPS":{},
+                 "Interop":{},
+                 "1st":{},
+                 "thumbnail":None}
+    exifReader = _ExifReader(input_data)
+    if exifReader.tiftag is None:
+        return exif_dict
+
+    if exifReader.tiftag[0:2] == LITTLE_ENDIAN:
+        exifReader.endian_mark = "<"
+    else:
+        exifReader.endian_mark = ">"
+
+    pointer = struct.unpack(exifReader.endian_mark + "L",
+                            exifReader.tiftag[4:8])[0]
+    exif_dict["0th"] = exifReader.get_ifd_dict(pointer, "0th")
+    first_ifd_pointer = exif_dict["0th"].pop("first_ifd_pointer")
+    if ImageIFD.ExifTag in exif_dict["0th"]:
+        pointer = exif_dict["0th"][ImageIFD.ExifTag]
+        exif_dict["Exif"] = exifReader.get_ifd_dict(pointer, "Exif")
+    if ImageIFD.GPSTag in exif_dict["0th"]:
+        pointer = exif_dict["0th"][ImageIFD.GPSTag]
+        exif_dict["GPS"] = exifReader.get_ifd_dict(pointer, "GPS")
+    if ExifIFD.InteroperabilityTag in exif_dict["Exif"]:
+        pointer = exif_dict["Exif"][ExifIFD.InteroperabilityTag]
+        exif_dict["Interop"] = exifReader.get_ifd_dict(pointer, "Interop")
+    if first_ifd_pointer != b"\x00\x00\x00\x00":
+        pointer = struct.unpack(exifReader.endian_mark + "L",
+                                first_ifd_pointer)[0]
+        exif_dict["1st"] = exifReader.get_ifd_dict(pointer, "1st")
+        if (ImageIFD.JPEGInterchangeFormat in exif_dict["1st"] and
+            ImageIFD.JPEGInterchangeFormatLength in exif_dict["1st"]):
+            end = (exif_dict["1st"][ImageIFD.JPEGInterchangeFormat] +
+                   exif_dict["1st"][ImageIFD.JPEGInterchangeFormatLength])
+            thumb = exifReader.tiftag[exif_dict["1st"][ImageIFD.JPEGInterchangeFormat]:end]
+            exif_dict["thumbnail"] = thumb
+
+    if key_is_name:
+        exif_dict = _get_key_name_dict(exif_dict)
+    return exif_dict
+
+
+class _ExifReader(object):
+    def __init__(self, data):
+        # Prevents "UnicodeWarning: Unicode equal comparison failed" warnings on Python 2
+        maybe_image = sys.version_info >= (3,0,0) or isinstance(data, str)
+
+        if maybe_image and data[0:2] == b"\xff\xd8":  # JPEG
+            segments = split_into_segments(data)
+            app1 = get_exif_seg(segments)
+            if app1:
+                self.tiftag = app1[10:]
+            else:
+                self.tiftag = None
+        elif maybe_image and data[0:2] in (b"\x49\x49", b"\x4d\x4d"):  # TIFF
+            self.tiftag = data
+        elif maybe_image and data[0:4] == b"RIFF" and data[8:12] == b"WEBP":
+            self.tiftag = _webp.get_exif(data)
+        elif maybe_image and data[0:4] == b"Exif":  # Exif
+            self.tiftag = data[6:]
+        else:
+            with open(data, 'rb') as f:
+                magic_number = f.read(2)
+            if magic_number == b"\xff\xd8":  # JPEG
+                app1 = read_exif_from_file(data)
+                if app1:
+                    self.tiftag = app1[10:]
+                else:
+                    self.tiftag = None
+            elif magic_number in (b"\x49\x49", b"\x4d\x4d"):  # TIFF
+                with open(data, 'rb') as f:
+                    self.tiftag = f.read()
+            else:
+                with open(data, 'rb') as f:
+                    header = f.read(12)
+                if header[0:4] == b"RIFF"and header[8:12] == b"WEBP":
+                    with open(data, 'rb') as f:
+                        file_data = f.read()
+                    self.tiftag = _webp.get_exif(file_data)
+                else:
+                    raise InvalidImageDataError("Given file is neither JPEG nor TIFF.")
+
+    def get_ifd_dict(self, pointer, ifd_name, read_unknown=False):
+        ifd_dict = {}
+        tag_count = struct.unpack(self.endian_mark + "H",
+                                  self.tiftag[pointer: pointer+2])[0]
+        offset = pointer + 2
+        if ifd_name in ["0th", "1st"]:
+            t = "Image"
+        else:
+            t = ifd_name
+        p_and_value = []
+        for x in range(tag_count):
+            pointer = offset + 12 * x
+            tag = struct.unpack(self.endian_mark + "H",
+                       self.tiftag[pointer: pointer+2])[0]
+            value_type = struct.unpack(self.endian_mark + "H",
+                         self.tiftag[pointer + 2: pointer + 4])[0]
+            value_num = struct.unpack(self.endian_mark + "L",
+                                      self.tiftag[pointer + 4: pointer + 8]
+                                      )[0]
+            value = self.tiftag[pointer+8: pointer+12]
+            p_and_value.append((pointer, value_type, value_num, value))
+            v_set = (value_type, value_num, value, tag)
+            if tag in TAGS[t]:
+                ifd_dict[tag] = self.convert_value(v_set)
+            elif read_unknown:
+                ifd_dict[tag] = (v_set[0], v_set[1], v_set[2], self.tiftag)
+            #else:
+            #    pass
+
+        if ifd_name == "0th":
+            pointer = offset + 12 * tag_count
+            ifd_dict["first_ifd_pointer"] = self.tiftag[pointer:pointer + 4]
+        return ifd_dict
+
+    def convert_value(self, val):
+        data = None
+        t = val[0]
+        length = val[1]
+        value = val[2]
+
+        if t == TYPES.Byte: # BYTE
+            if length > 4:
+                pointer = struct.unpack(self.endian_mark + "L", value)[0]
+                data = struct.unpack("B" * length,
+                                     self.tiftag[pointer: pointer + length])
+            else:
+                data = struct.unpack("B" * length, value[0:length])
+        elif t == TYPES.Ascii: # ASCII
+            if length > 4:
+                pointer = struct.unpack(self.endian_mark + "L", value)[0]
+                data = self.tiftag[pointer: pointer+length - 1]
+            else:
+                data = value[0: length - 1]
+        elif t == TYPES.Short: # SHORT
+            if length > 2:
+                pointer = struct.unpack(self.endian_mark + "L", value)[0]
+                data = struct.unpack(self.endian_mark + "H" * length,
+                                     self.tiftag[pointer: pointer+length*2])
+            else:
+                data = struct.unpack(self.endian_mark + "H" * length,
+                                     value[0:length * 2])
+        elif t == TYPES.Long: # LONG
+            if length > 1:
+                pointer = struct.unpack(self.endian_mark + "L", value)[0]
+                data = struct.unpack(self.endian_mark + "L" * length,
+                                     self.tiftag[pointer: pointer+length*4])
+            else:
+                data = struct.unpack(self.endian_mark + "L" * length,
+                                     value)
+        elif t == TYPES.Rational: # RATIONAL
+            pointer = struct.unpack(self.endian_mark + "L", value)[0]
+            if length > 1:
+                data = tuple(
+                    (struct.unpack(self.endian_mark + "L",
+                                   self.tiftag[pointer + x * 8:
+                                       pointer + 4 + x * 8])[0],
+                     struct.unpack(self.endian_mark + "L",
+                                   self.tiftag[pointer + 4 + x * 8:
+                                       pointer + 8 + x * 8])[0])
+                    for x in range(length)
+                )
+            else:
+                data = (struct.unpack(self.endian_mark + "L",
+                                      self.tiftag[pointer: pointer + 4])[0],
+                        struct.unpack(self.endian_mark + "L",
+                                      self.tiftag[pointer + 4: pointer + 8]
+                                      )[0])
+        elif t == TYPES.SByte: # SIGNED BYTES
+            if length > 4:
+                pointer = struct.unpack(self.endian_mark + "L", value)[0]
+                data = struct.unpack("b" * length,
+                                     self.tiftag[pointer: pointer + length])
+            else:
+                data = struct.unpack("b" * length, value[0:length])
+        elif t == TYPES.Undefined: # UNDEFINED BYTES
+            if length > 4:
+                pointer = struct.unpack(self.endian_mark + "L", value)[0]
+                data = self.tiftag[pointer: pointer+length]
+            else:
+                data = value[0:length]
+        elif t == TYPES.SShort: # SIGNED SHORT
+            if length > 2:
+                pointer = struct.unpack(self.endian_mark + "L", value)[0]
+                data = struct.unpack(self.endian_mark + "h" * length,
+                                     self.tiftag[pointer: pointer+length*2])
+            else:
+                data = struct.unpack(self.endian_mark + "h" * length,
+                                     value[0:length * 2])
+        elif t == TYPES.SLong: # SLONG
+            if length > 1:
+                pointer = struct.unpack(self.endian_mark + "L", value)[0]
+                data = struct.unpack(self.endian_mark + "l" * length,
+                                     self.tiftag[pointer: pointer+length*4])
+            else:
+                data = struct.unpack(self.endian_mark + "l" * length,
+                                     value)
+        elif t == TYPES.SRational: # SRATIONAL
+            pointer = struct.unpack(self.endian_mark + "L", value)[0]
+            if length > 1:
+                data = tuple(
+                  (struct.unpack(self.endian_mark + "l",
+                   self.tiftag[pointer + x * 8: pointer + 4 + x * 8])[0],
+                   struct.unpack(self.endian_mark + "l",
+                   self.tiftag[pointer + 4 + x * 8: pointer + 8 + x * 8])[0])
+                  for x in range(length)
+                )
+            else:
+                data = (struct.unpack(self.endian_mark + "l",
+                                      self.tiftag[pointer: pointer + 4])[0],
+                        struct.unpack(self.endian_mark + "l",
+                                      self.tiftag[pointer + 4: pointer + 8]
+                                      )[0])
+        elif t == TYPES.Float: # FLOAT
+            if length > 1:
+                pointer = struct.unpack(self.endian_mark + "L", value)[0]
+                data = struct.unpack(self.endian_mark + "f" * length,
+                                     self.tiftag[pointer: pointer+length*4])
+            else:
+                data = struct.unpack(self.endian_mark + "f" * length,
+                                     value)
+        elif t == TYPES.DFloat: # DOUBLE
+            pointer = struct.unpack(self.endian_mark + "L", value)[0]
+            data = struct.unpack(self.endian_mark + "d" * length,
+                                    self.tiftag[pointer: pointer+length*8])
+        else:
+            raise ValueError("Exif might be wrong. Got incorrect value " +
+                             "type to decode.\n" +
+                             "tag: " + str(val[3]) + "\ntype: " + str(t))
+
+        if isinstance(data, tuple) and (len(data) == 1):
+            return data[0]
+        else:
+            return data
+
+
+def _get_key_name_dict(exif_dict):
+    new_dict = {
+        "0th":{TAGS["Image"][n]["name"]:value for n, value in exif_dict["0th"].items()},
+        "Exif":{TAGS["Exif"][n]["name"]:value for n, value in exif_dict["Exif"].items()},
+        "1st":{TAGS["Image"][n]["name"]:value for n, value in exif_dict["1st"].items()},
+        "GPS":{TAGS["GPS"][n]["name"]:value for n, value in exif_dict["GPS"].items()},
+        "Interop":{TAGS["Interop"][n]["name"]:value for n, value in exif_dict["Interop"].items()},
+        "thumbnail":exif_dict["thumbnail"],
+    }
+    return new_dict

sdata/contrib/piexif/_remove.py

@@ -0,0 +1,56 @@
+import io
+
+from ._common import *
+from . import _webp
+
+def remove(src, new_file=None):
+    """
+    py:function:: piexif.remove(filename)
+
+    Remove exif from JPEG.
+
+    :param str filename: JPEG
+    """
+    output_is_file = False
+    if src[0:2] == b"\xff\xd8":
+        src_data = src
+        file_type = "jpeg"
+    elif src[0:4] == b"RIFF" and src[8:12] == b"WEBP":
+        src_data = src
+        file_type = "webp"
+    else:
+        with open(src, 'rb') as f:
+            src_data = f.read()
+        output_is_file = True
+        if src_data[0:2] == b"\xff\xd8":
+            file_type = "jpeg"
+        elif src_data[0:4] == b"RIFF" and src_data[8:12] == b"WEBP":
+            file_type = "webp"
+
+    if file_type == "jpeg":
+        segments = split_into_segments(src_data)
+        exif = get_exif_seg(segments)
+        if exif:
+            new_data = src_data.replace(exif, b"")
+        else:
+            new_data = src_data
+    elif file_type == "webp":
+        try:
+            new_data = _webp.remove(src_data)
+        except ValueError:
+            new_data = src_data
+        except e:
+            print(e.args)
+            raise ValueError("Error occurred.")
+
+    if isinstance(new_file, io.BytesIO):
+        new_file.write(new_data)
+        new_file.seek(0)
+    elif new_file:
+        with open(new_file, "wb+") as f:
+            f.write(new_data)
+    elif output_is_file:
+        with open(src, "wb+") as f:
+            f.write(new_data)
+    else:
+        raise ValueError("Give a second argument to 'remove' to output file")

sdata/contrib/piexif/_transplant.py

@@ -0,0 +1,45 @@
+import io
+
+from ._common import *
+
+
+def transplant(exif_src, image, new_file=None):
+    """
+    py:function:: piexif.transplant(filename1, filename2)
+
+    Transplant exif from filename1 to filename2.
+
+    :param str filename1: JPEG
+    :param str filename2: JPEG
+    """
+    if exif_src[0:2] == b"\xff\xd8":
+        src_data = exif_src
+    else:
+        with open(exif_src, 'rb') as f:
+            src_data = f.read()
+    segments = split_into_segments(src_data)
+    exif = get_exif_seg(segments)
+    if exif is None:
+        raise ValueError("not found exif in input")
+
+    output_file = False
+    if image[0:2] == b"\xff\xd8":
+        image_data = image
+    else:
+        with open(image, 'rb') as f:
+            image_data = f.read()
+        output_file = True
+    segments = split_into_segments(image_data)
+    new_data = merge_segments(segments, exif)
+
+    if isinstance(new_file, io.BytesIO):
+        new_file.write(new_data)
+        new_file.seek(0)
+    elif new_file:
+        with open(new_file, "wb+") as f:
+            f.write(new_data)
+    elif output_file:
+        with open(image, "wb+") as f:
+            f.write(new_data)
+    else:
+        raise ValueError("Give a 3rd argument to 'transplant' to output file")

sdata/contrib/piexif/_webp.py

@@ -0,0 +1,240 @@
+
+import struct
+
+
+def split(data):
+    if data[0:4] != b"RIFF" or data[8:12] != b"WEBP":
+        raise ValueError("Not WebP")
+
+    webp_length_bytes = data[4:8]
+    webp_length = struct.unpack("<L", webp_length_bytes)[0]
+    RIFF_HEADER_SIZE = 8
+    file_size = RIFF_HEADER_SIZE + webp_length
+
+    start = 12
+    pointer = start
+    CHUNK_FOURCC_LENGTH = 4
+    LENGTH_BYTES_LENGTH = 4
+
+    chunks = []
+    while pointer + CHUNK_FOURCC_LENGTH + LENGTH_BYTES_LENGTH < file_size:
+        fourcc = data[pointer:pointer + CHUNK_FOURCC_LENGTH]
+        pointer += CHUNK_FOURCC_LENGTH
+        chunk_length_bytes = data[pointer:pointer + LENGTH_BYTES_LENGTH]
+        chunk_length = struct.unpack("<L", chunk_length_bytes)[0]
+        pointer += LENGTH_BYTES_LENGTH
+
+        chunk_data = data[pointer:pointer + chunk_length]
+        chunks.append({"fourcc":fourcc, "length_bytes":chunk_length_bytes, "data":chunk_data})
+
+        padding = 1 if chunk_length % 2 else 0
+
+        pointer += chunk_length + padding
+    return chunks
+
+def merge_chunks(chunks):
+    merged = b"".join([chunk["fourcc"] 
+                       + chunk["length_bytes"]
+                       + chunk["data"]
+                       + (len(chunk["data"]) % 2) * b"\x00"
+                        for chunk in chunks])
+    return merged
+
+
+def _get_size_from_vp8x(chunk):
+    width_minus_one_bytes = chunk["data"][-6:-3] + b"\x00"
+    width_minus_one = struct.unpack("<L", width_minus_one_bytes)[0]
+    width = width_minus_one + 1
+    height_minus_one_bytes = chunk["data"][-3:] + b"\x00"
+    height_minus_one = struct.unpack("<L", height_minus_one_bytes)[0]
+    height = height_minus_one + 1
+    return (width, height)
+
+def _get_size_from_vp8(chunk):
+    BEGIN_CODE = b"\x9d\x01\x2a"
+    begin_index = chunk["data"].find(BEGIN_CODE)
+    if begin_index == -1:
+        ValueError("wrong VP8")
+    else:
+        BEGIN_CODE_LENGTH = len(BEGIN_CODE)
+        LENGTH_BYTES_LENGTH = 2
+        length_start = begin_index + BEGIN_CODE_LENGTH
+        width_bytes = chunk["data"][length_start:length_start + LENGTH_BYTES_LENGTH]
+        width = struct.unpack("<H", width_bytes)[0]
+        height_bytes = chunk["data"][length_start + LENGTH_BYTES_LENGTH:length_start + 2 * LENGTH_BYTES_LENGTH]
+        height = struct.unpack("<H", height_bytes)[0]
+        return (width, height)
+
+def _vp8L_contains_alpha(chunk_data):
+    flag = ord(chunk_data[4:5]) >> 5-1 & ord(b"\x01")
+    contains = 1 * flag
+    return contains
+
+def _get_size_from_vp8L(chunk):
+    b1 = chunk["data"][1:2]
+    b2 = chunk["data"][2:3]
+    b3 = chunk["data"][3:4]
+    b4 = chunk["data"][4:5]
+
+    width_minus_one = (ord(b2) & ord(b"\x3F")) << 8 | ord(b1)
+    width = width_minus_one + 1
+
+    height_minus_one = (ord(b4) & ord(b"\x0F")) << 10 | ord(b3) << 2 | (ord(b2) & ord(b"\xC0")) >> 6
+    height = height_minus_one + 1
+
+    return (width, height)
+
+def _get_size_from_anmf(chunk):
+    width_minus_one_bytes = chunk["data"][6:9] + b"\x00"
+    width_minus_one = struct.unpack("<L", width_minus_one_bytes)[0]
+    width = width_minus_one + 1
+    height_minus_one_bytes = chunk["data"][9:12] + b"\x00"
+    height_minus_one = struct.unpack("<L", height_minus_one_bytes)[0]
+    height = height_minus_one + 1
+    return (width, height)
+    
+def set_vp8x(chunks):
+
+    width = None
+    height = None
+    flags = [b"0", b"0", b"0", b"0", b"0", b"0", b"0", b"0"]  # [0, 0, ICC, Alpha, EXIF, XMP, Anim, 0]
+
+    for chunk in chunks:
+        if chunk["fourcc"] == b"VP8X":
+            width, height = _get_size_from_vp8x(chunk)
+        elif chunk["fourcc"] == b"VP8 ":
+            width, height = _get_size_from_vp8(chunk)
+        elif chunk["fourcc"] == b"VP8L":
+            is_rgba = _vp8L_contains_alpha(chunk["data"])
+            if is_rgba:
+                flags[3] = b"1"
+            width, height = _get_size_from_vp8L(chunk)
+        elif chunk["fourcc"] == b"ANMF":
+            width, height = _get_size_from_anmf(chunk)
+        elif chunk["fourcc"] == b"ICCP":
+            flags[2] = b"1"
+        elif chunk["fourcc"] == b"ALPH":
+            flags[3] = b"1"
+        elif chunk["fourcc"] == b"EXIF":
+            flags[4] = b"1"
+        elif chunk["fourcc"] == b"XMP ":
+            flags[5] = b"1"
+        elif chunk["fourcc"] == b"ANIM":
+            flags[6] = b"1"
+    width_minus_one = width - 1
+    height_minus_one = height - 1
+
+    if chunks[0]["fourcc"] == b"VP8X":
+        chunks.pop(0)
+
+    header_bytes = b"VP8X"
+    length_bytes = b"\x0a\x00\x00\x00"
+    flags_bytes = struct.pack("B", int(b"".join(flags), 2))
+    padding_bytes = b"\x00\x00\x00"
+    width_bytes = struct.pack("<L", width_minus_one)[:3]
+    height_bytes = struct.pack("<L", height_minus_one)[:3]
+
+    data_bytes = flags_bytes + padding_bytes + width_bytes + height_bytes
+
+    vp8x_chunk = {"fourcc":header_bytes, "length_bytes":length_bytes, "data":data_bytes}
+    chunks.insert(0, vp8x_chunk)
+
+    return chunks
+
+def get_file_header(chunks):
+    WEBP_HEADER_LENGTH = 4
+    FOURCC_LENGTH = 4
+    LENGTH_BYTES_LENGTH = 4
+
+    length = WEBP_HEADER_LENGTH
+    for chunk in chunks:
+        data_length = struct.unpack("<L", chunk["length_bytes"])[0]
+        data_length += 1 if data_length % 2 else 0
+        length += FOURCC_LENGTH + LENGTH_BYTES_LENGTH + data_length
+    length_bytes = struct.pack("<L", length)
+    riff = b"RIFF"
+    webp_header = b"WEBP"
+    file_header = riff + length_bytes + webp_header
+    return file_header
+
+
+
+def get_exif(data):
+    if data[0:4] != b"RIFF" or data[8:12] != b"WEBP":
+        raise ValueError("Not WebP")
+
+    if data[12:16] != b"VP8X":
+        raise ValueError("doesnot have exif")
+
+    webp_length_bytes = data[4:8]
+    webp_length = struct.unpack("<L", webp_length_bytes)[0]
+    RIFF_HEADER_SIZE = 8
+    file_size = RIFF_HEADER_SIZE + webp_length
+
+    start = 12
+    pointer = start
+    CHUNK_FOURCC_LENGTH = 4
+    LENGTH_BYTES_LENGTH = 4
+
+    chunks = []
+    exif = b""
+    while pointer < file_size:
+        fourcc = data[pointer:pointer + CHUNK_FOURCC_LENGTH]
+        pointer += CHUNK_FOURCC_LENGTH
+        chunk_length_bytes = data[pointer:pointer + LENGTH_BYTES_LENGTH]
+        chunk_length = struct.unpack("<L", chunk_length_bytes)[0]
+        if chunk_length % 2:
+            chunk_length += 1
+        pointer += LENGTH_BYTES_LENGTH
+        if fourcc == b"EXIF":
+            return data[pointer:pointer + chunk_length]
+        pointer += chunk_length
+    return None  # if there isn't exif, return None.
+
+
+def insert_exif_into_chunks(chunks, exif_bytes):
+    EXIF_HEADER = b"EXIF"
+    exif_length_bytes = struct.pack("<L", len(exif_bytes))
+    exif_chunk = {"fourcc":EXIF_HEADER, "length_bytes":exif_length_bytes, "data":exif_bytes}
+
+    xmp_index = None
+    animation_index = None
+
+    for index, chunk in enumerate(chunks):
+        if chunk["fourcc"] == b"EXIF":
+            chunks.pop(index)
+
+    for index, chunk in enumerate(chunks):
+        if chunk["fourcc"] == b"XMP ":
+            xmp_index = index
+        elif chunk["fourcc"] == b"ANIM":
+            animation_index = index
+    if xmp_index is not None:
+        chunks.insert(xmp_index, exif_chunk)
+    elif animation_index is not None:
+        chunks.insert(animation_index, exif_chunk)
+    else:
+        chunks.append(exif_chunk)
+    return chunks
+
+
+def insert(webp_bytes, exif_bytes):
+    chunks = split(webp_bytes)
+    chunks = insert_exif_into_chunks(chunks, exif_bytes)
+    chunks = set_vp8x(chunks)
+    file_header = get_file_header(chunks)
+    merged = merge_chunks(chunks)
+    new_webp_bytes = file_header + merged
+    return new_webp_bytes
+
+
+def remove(webp_bytes):
+    chunks = split(webp_bytes)
+    for index, chunk in enumerate(chunks):
+        if chunk["fourcc"] == b"EXIF":
+            chunks.pop(index)
+    chunks = set_vp8x(chunks)
+    file_header = get_file_header(chunks)
+    merged = merge_chunks(chunks)
+    new_webp_bytes = file_header + merged
+    return new_webp_bytes