sdata 1.5.0__py3-none-any.whl

sdata/contrib/piexif/_common.py

@@ -0,0 +1,94 @@
+import struct
+
+from ._exceptions import InvalidImageDataError
+
+
+def split_into_segments(data):
+    """Slices JPEG meta data into a list from JPEG binary data.
+    """
+    if data[0:2] != b"\xff\xd8":
+        raise InvalidImageDataError("Given data isn't JPEG.")
+
+    head = 2
+    segments = [b"\xff\xd8"]
+    while 1:
+        if data[head: head + 2] == b"\xff\xda":
+            segments.append(data[head:])
+            break
+        else:
+            length = struct.unpack(">H", data[head + 2: head + 4])[0]
+            endPoint = head + length + 2
+            seg = data[head: endPoint]
+            segments.append(seg)
+            head = endPoint
+
+        if (head >= len(data)):
+            raise InvalidImageDataError("Wrong JPEG data.")
+    return segments
+
+def read_exif_from_file(filename):
+    """Slices JPEG meta data into a list from JPEG binary data.
+    """
+    f = open(filename, "rb")
+    data = f.read(6)
+
+    if data[0:2] != b"\xff\xd8":
+        raise InvalidImageDataError("Given data isn't JPEG.")
+
+    head = data[2:6]
+    HEAD_LENGTH = 4
+    exif = None
+    while len(head) == HEAD_LENGTH:
+        length = struct.unpack(">H", head[2: 4])[0]
+
+        if head[:2] == b"\xff\xe1":
+            segment_data = f.read(length - 2)
+            if segment_data[:4] != b'Exif':
+                head = f.read(HEAD_LENGTH)
+                continue
+            exif = head + segment_data
+            break
+        elif head[0:1] == b"\xff":
+            f.read(length - 2)
+            head = f.read(HEAD_LENGTH)
+        else:
+            break
+
+    f.close()
+    return exif
+
+def get_exif_seg(segments):
+    """Returns Exif from JPEG meta data list
+    """
+    for seg in segments:
+        if seg[0:2] == b"\xff\xe1" and seg[4:10] == b"Exif\x00\x00":
+            return seg
+    return None
+
+
+def merge_segments(segments, exif=b""):
+    """Merges Exif with APP0 and APP1 manipulations.
+    """
+    if segments[1][0:2] == b"\xff\xe0" and \
+       segments[2][0:2] == b"\xff\xe1" and \
+       segments[2][4:10] == b"Exif\x00\x00":
+        if exif:
+            segments[2] = exif
+            segments.pop(1)
+        elif exif is None:
+            segments.pop(2)
+        else:
+            segments.pop(1)
+    elif segments[1][0:2] == b"\xff\xe0":
+        if exif:
+            segments[1] = exif
+    elif segments[1][0:2] == b"\xff\xe1" and \
+         segments[1][4:10] == b"Exif\x00\x00":
+        if exif:
+            segments[1] = exif
+        elif exif is None:
+            segments.pop(1)
+    else:
+        if exif:
+            segments.insert(1, exif)
+    return b"".join(segments)

sdata/contrib/piexif/_dump.py

@@ -0,0 +1,346 @@
+import copy
+import numbers
+import struct
+
+from ._common import *
+from ._exif import *
+
+
+TIFF_HEADER_LENGTH = 8
+
+
+def dump(exif_dict_original):
+    """
+    py:function:: piexif.load(data)
+
+    Return exif as bytes.
+
+    :param dict exif: Exif data({"0th":dict, "Exif":dict, "GPS":dict, "Interop":dict, "1st":dict, "thumbnail":bytes})
+    :return: Exif
+    :rtype: bytes
+    """
+    exif_dict = copy.deepcopy(exif_dict_original)
+    header = b"Exif\x00\x00\x4d\x4d\x00\x2a\x00\x00\x00\x08"
+    exif_is = False
+    gps_is = False
+    interop_is = False
+    first_is = False
+
+    if "0th" in exif_dict:
+        zeroth_ifd = exif_dict["0th"]
+    else:
+        zeroth_ifd = {}
+
+    if (("Exif" in exif_dict) and len(exif_dict["Exif"]) or
+          ("Interop" in exif_dict) and len(exif_dict["Interop"]) ):
+        zeroth_ifd[ImageIFD.ExifTag] = 1
+        exif_is = True
+        exif_ifd = exif_dict["Exif"]
+        if ("Interop" in exif_dict) and len(exif_dict["Interop"]):
+            exif_ifd[ExifIFD. InteroperabilityTag] = 1
+            interop_is = True
+            interop_ifd = exif_dict["Interop"]
+        elif ExifIFD. InteroperabilityTag in exif_ifd:
+            exif_ifd.pop(ExifIFD.InteroperabilityTag)
+    elif ImageIFD.ExifTag in zeroth_ifd:
+        zeroth_ifd.pop(ImageIFD.ExifTag)
+
+    if ("GPS" in exif_dict) and len(exif_dict["GPS"]):
+        zeroth_ifd[ImageIFD.GPSTag] = 1
+        gps_is = True
+        gps_ifd = exif_dict["GPS"]
+    elif ImageIFD.GPSTag in zeroth_ifd:
+        zeroth_ifd.pop(ImageIFD.GPSTag)
+
+    if (("1st" in exif_dict) and
+            ("thumbnail" in exif_dict) and
+            (exif_dict["thumbnail"] is not None)):
+        first_is = True
+        exif_dict["1st"][ImageIFD.JPEGInterchangeFormat] = 1
+        exif_dict["1st"][ImageIFD.JPEGInterchangeFormatLength] = 1
+        first_ifd = exif_dict["1st"]
+
+    zeroth_set = _dict_to_bytes(zeroth_ifd, "0th", 0)
+    zeroth_length = (len(zeroth_set[0]) + exif_is * 12 + gps_is * 12 + 4 +
+                     len(zeroth_set[1]))
+
+    if exif_is:
+        exif_set = _dict_to_bytes(exif_ifd, "Exif", zeroth_length)
+        exif_length = len(exif_set[0]) + interop_is * 12 + len(exif_set[1])
+    else:
+        exif_bytes = b""
+        exif_length = 0
+    if gps_is:
+        gps_set = _dict_to_bytes(gps_ifd, "GPS", zeroth_length + exif_length)
+        gps_bytes = b"".join(gps_set)
+        gps_length = len(gps_bytes)
+    else:
+        gps_bytes = b""
+        gps_length = 0
+    if interop_is:
+        offset = zeroth_length + exif_length + gps_length
+        interop_set = _dict_to_bytes(interop_ifd, "Interop", offset)
+        interop_bytes = b"".join(interop_set)
+        interop_length = len(interop_bytes)
+    else:
+        interop_bytes = b""
+        interop_length = 0
+    if first_is:
+        offset = zeroth_length + exif_length + gps_length + interop_length
+        first_set = _dict_to_bytes(first_ifd, "1st", offset)
+        thumbnail = _get_thumbnail(exif_dict["thumbnail"])
+        thumbnail_max_size = 64000
+        if len(thumbnail) > thumbnail_max_size:
+            raise ValueError("Given thumbnail is too large. max 64kB")
+    else:
+        first_bytes = b""
+    if exif_is:
+        pointer_value = TIFF_HEADER_LENGTH + zeroth_length
+        pointer_str = struct.pack(">I", pointer_value)
+        key = ImageIFD.ExifTag
+        key_str = struct.pack(">H", key)
+        type_str = struct.pack(">H", TYPES.Long)
+        length_str = struct.pack(">I", 1)
+        exif_pointer = key_str + type_str + length_str + pointer_str
+    else:
+        exif_pointer = b""
+    if gps_is:
+        pointer_value = TIFF_HEADER_LENGTH + zeroth_length + exif_length
+        pointer_str = struct.pack(">I", pointer_value)
+        key = ImageIFD.GPSTag
+        key_str = struct.pack(">H", key)
+        type_str = struct.pack(">H", TYPES.Long)
+        length_str = struct.pack(">I", 1)
+        gps_pointer = key_str + type_str + length_str + pointer_str
+    else:
+        gps_pointer = b""
+    if interop_is:
+        pointer_value = (TIFF_HEADER_LENGTH +
+                         zeroth_length + exif_length + gps_length)
+        pointer_str = struct.pack(">I", pointer_value)
+        key = ExifIFD.InteroperabilityTag
+        key_str = struct.pack(">H", key)
+        type_str = struct.pack(">H", TYPES.Long)
+        length_str = struct.pack(">I", 1)
+        interop_pointer = key_str + type_str + length_str + pointer_str
+    else:
+        interop_pointer = b""
+    if first_is:
+        pointer_value = (TIFF_HEADER_LENGTH + zeroth_length +
+                         exif_length + gps_length + interop_length)
+        first_ifd_pointer = struct.pack(">L", pointer_value)
+        thumbnail_pointer = (pointer_value + len(first_set[0]) + 24 +
+                             4 + len(first_set[1]))
+        thumbnail_p_bytes = (b"\x02\x01\x00\x04\x00\x00\x00\x01" +
+                             struct.pack(">L", thumbnail_pointer))
+        thumbnail_length_bytes = (b"\x02\x02\x00\x04\x00\x00\x00\x01" +
+                                  struct.pack(">L", len(thumbnail)))
+        first_bytes = (first_set[0] + thumbnail_p_bytes +
+                       thumbnail_length_bytes + b"\x00\x00\x00\x00" +
+                       first_set[1] + thumbnail)
+    else:
+        first_ifd_pointer = b"\x00\x00\x00\x00"
+
+    zeroth_bytes = (zeroth_set[0] + exif_pointer + gps_pointer +
+                    first_ifd_pointer + zeroth_set[1])
+    if exif_is:
+        exif_bytes = exif_set[0] + interop_pointer + exif_set[1]
+
+    return (header + zeroth_bytes + exif_bytes + gps_bytes +
+            interop_bytes + first_bytes)
+
+
+def _get_thumbnail(jpeg):
+    segments = split_into_segments(jpeg)
+    while (b"\xff\xe0" <= segments[1][0:2] <= b"\xff\xef"):
+        segments.pop(1)
+    thumbnail = b"".join(segments)
+    return thumbnail
+
+
+def _pack_byte(*args):
+    return struct.pack("B" * len(args), *args)
+
+def _pack_signed_byte(*args):
+    return struct.pack("b" * len(args), *args)
+
+def _pack_short(*args):
+    return struct.pack(">" + "H" * len(args), *args)
+
+def _pack_signed_short(*args):
+    return struct.pack(">" + "h" * len(args), *args)
+
+def _pack_long(*args):
+    return struct.pack(">" + "L" * len(args), *args)
+
+def _pack_slong(*args):
+    return struct.pack(">" + "l" * len(args), *args)
+
+def _pack_float(*args):
+    return struct.pack(">" + "f" * len(args), *args)
+
+def _pack_double(*args):
+    return struct.pack(">" + "d" * len(args), *args)
+
+
+def _value_to_bytes(raw_value, value_type, offset):
+    four_bytes_over = b""
+    value_str = b""
+
+    if value_type == TYPES.Byte:
+        length = len(raw_value)
+        if length <= 4:
+            value_str = (_pack_byte(*raw_value) +
+                            b"\x00" * (4 - length))
+        else:
+            value_str = struct.pack(">I", offset)
+            four_bytes_over = _pack_byte(*raw_value)
+    elif value_type == TYPES.Short:
+        length = len(raw_value)
+        if length <= 2:
+            value_str = (_pack_short(*raw_value) +
+                            b"\x00\x00" * (2 - length))
+        else:
+            value_str = struct.pack(">I", offset)
+            four_bytes_over = _pack_short(*raw_value)
+    elif value_type == TYPES.Long:
+        length = len(raw_value)
+        if length <= 1:
+            value_str = _pack_long(*raw_value)
+        else:
+            value_str = struct.pack(">I", offset)
+            four_bytes_over = _pack_long(*raw_value)
+    elif value_type == TYPES.SLong:
+        length = len(raw_value)
+        if length <= 1:
+            value_str = _pack_slong(*raw_value)
+        else:
+            value_str = struct.pack(">I", offset)
+            four_bytes_over = _pack_slong(*raw_value)
+    elif value_type == TYPES.Ascii:
+        try:
+            new_value = raw_value.encode("latin1") + b"\x00"
+        except:
+            try:
+                new_value = raw_value + b"\x00"
+            except TypeError:
+                raise ValueError("Got invalid type to convert.")
+        length = len(new_value)
+        if length > 4:
+            value_str = struct.pack(">I", offset)
+            four_bytes_over = new_value
+        else:
+            value_str = new_value + b"\x00" * (4 - length)
+    elif value_type == TYPES.Rational:
+        if isinstance(raw_value[0], numbers.Integral):
+            length = 1
+            num, den = raw_value
+            new_value = struct.pack(">L", num) + struct.pack(">L", den)
+        elif isinstance(raw_value[0], tuple):
+            length = len(raw_value)
+            new_value = b""
+            for n, val in enumerate(raw_value):
+                num, den = val
+                new_value += (struct.pack(">L", num) +
+                                struct.pack(">L", den))
+        value_str = struct.pack(">I", offset)
+        four_bytes_over = new_value
+    elif value_type == TYPES.SRational:
+        if isinstance(raw_value[0], numbers.Integral):
+            length = 1
+            num, den = raw_value
+            new_value = struct.pack(">l", num) + struct.pack(">l", den)
+        elif isinstance(raw_value[0], tuple):
+            length = len(raw_value)
+            new_value = b""
+            for n, val in enumerate(raw_value):
+                num, den = val
+                new_value += (struct.pack(">l", num) +
+                                struct.pack(">l", den))
+        value_str = struct.pack(">I", offset)
+        four_bytes_over = new_value
+    elif value_type == TYPES.Undefined:
+        length = len(raw_value)
+        if length > 4:
+            value_str = struct.pack(">I", offset)
+            try:
+                four_bytes_over = b"" + raw_value
+            except TypeError:
+                raise ValueError("Got invalid type to convert.")
+        else:
+            try:
+                value_str = raw_value + b"\x00" * (4 - length)
+            except TypeError:
+                raise ValueError("Got invalid type to convert.")
+    elif value_type == TYPES.SByte: # Signed Byte
+        length = len(raw_value)
+        if length <= 4:
+            value_str = (_pack_signed_byte(*raw_value) +
+                            b"\x00" * (4 - length))
+        else:
+            value_str = struct.pack(">I", offset)
+            four_bytes_over = _pack_signed_byte(*raw_value)
+    elif value_type == TYPES.SShort: # Signed Short
+        length = len(raw_value)
+        if length <= 2:
+            value_str = (_pack_signed_short(*raw_value) +
+                            b"\x00\x00" * (2 - length))
+        else:
+            value_str = struct.pack(">I", offset)
+            four_bytes_over = _pack_signed_short(*raw_value)
+    elif value_type == TYPES.Float:
+        length = len(raw_value)
+        if length <= 1:
+            value_str = _pack_float(*raw_value)
+        else:
+            value_str = struct.pack(">I", offset)
+            four_bytes_over = _pack_float(*raw_value)
+    elif value_type == TYPES.DFloat: # Double
+        length = len(raw_value)
+        value_str = struct.pack(">I", offset)
+        four_bytes_over = _pack_double(*raw_value)
+
+    length_str = struct.pack(">I", length)
+    return length_str, value_str, four_bytes_over
+
+def _dict_to_bytes(ifd_dict, ifd, ifd_offset):
+    tag_count = len(ifd_dict)
+    entry_header = struct.pack(">H", tag_count)
+    if ifd in ("0th", "1st"):
+        entries_length = 2 + tag_count * 12 + 4
+    else:
+        entries_length = 2 + tag_count * 12
+    entries = b""
+    values = b""
+
+    for n, key in enumerate(sorted(ifd_dict)):
+        if (ifd == "0th") and (key in (ImageIFD.ExifTag, ImageIFD.GPSTag)):
+            continue
+        elif (ifd == "Exif") and (key == ExifIFD.InteroperabilityTag):
+            continue
+        elif (ifd == "1st") and (key in (ImageIFD.JPEGInterchangeFormat, ImageIFD.JPEGInterchangeFormatLength)):
+            continue
+
+        raw_value = ifd_dict[key]
+        key_str = struct.pack(">H", key)
+        value_type = TAGS[ifd][key]["type"]
+        type_str = struct.pack(">H", value_type)
+        four_bytes_over = b""
+
+        if isinstance(raw_value, numbers.Integral) or isinstance(raw_value, float):
+            raw_value = (raw_value,)
+        offset = TIFF_HEADER_LENGTH + entries_length + ifd_offset + len(values)
+
+        try:
+            length_str, value_str, four_bytes_over = _value_to_bytes(raw_value,
+                                                                     value_type,
+                                                                     offset)
+        except ValueError:
+            raise ValueError(
+                '"dump" got wrong type of exif value.\n' +
+                '{} in {} IFD. Got as {}.'.format(key, ifd, type(ifd_dict[key]))
+            )
+
+        entries += key_str + type_str + length_str + value_str
+        values += four_bytes_over
+    return (entry_header + entries, values)

sdata/contrib/piexif/_exceptions.py

@@ -0,0 +1,2 @@
+class InvalidImageDataError(ValueError):
+    pass