# Compression => pil compression name

1: "raw",

2: "tiff_ccitt",

3: "group3",

4: "group4",

5: "tiff_lzw",

6: "tiff_jpeg", # obsolete

7: "jpeg",

8: "tiff_adobe_deflate",

32771: "tiff_raw_16", # 16-bit padding

32773: "packbits",

32809: "tiff_thunderscan",

32946: "tiff_deflate",

34676: "tiff_sgilog",

34677: "tiff_sgilog24",

34925: "lzma",

50000: "zstd",

50001: "webp",

# (ByteOrder, PhotoInterpretation, SampleFormat, FillOrder, BitsPerSample,

# ExtraSamples) => mode, rawmode

(II, 0, (1,), 1, (1,), ()): ("1", "1;I"),

(MM, 0, (1,), 1, (1,), ()): ("1", "1;I"),

(II, 0, (1,), 2, (1,), ()): ("1", "1;IR"),

(MM, 0, (1,), 2, (1,), ()): ("1", "1;IR"),

(II, 1, (1,), 1, (1,), ()): ("1", "1"),

(MM, 1, (1,), 1, (1,), ()): ("1", "1"),

(II, 1, (1,), 2, (1,), ()): ("1", "1;R"),

(MM, 1, (1,), 2, (1,), ()): ("1", "1;R"),

(II, 0, (1,), 1, (2,), ()): ("L", "L;2I"),

(MM, 0, (1,), 1, (2,), ()): ("L", "L;2I"),

(II, 0, (1,), 2, (2,), ()): ("L", "L;2IR"),

(MM, 0, (1,), 2, (2,), ()): ("L", "L;2IR"),

(II, 1, (1,), 1, (2,), ()): ("L", "L;2"),

(MM, 1, (1,), 1, (2,), ()): ("L", "L;2"),

(II, 1, (1,), 2, (2,), ()): ("L", "L;2R"),

(MM, 1, (1,), 2, (2,), ()): ("L", "L;2R"),

(II, 0, (1,), 1, (4,), ()): ("L", "L;4I"),

(MM, 0, (1,), 1, (4,), ()): ("L", "L;4I"),

(II, 0, (1,), 2, (4,), ()): ("L", "L;4IR"),

(MM, 0, (1,), 2, (4,), ()): ("L", "L;4IR"),

(II, 1, (1,), 1, (4,), ()): ("L", "L;4"),

(MM, 1, (1,), 1, (4,), ()): ("L", "L;4"),

(II, 1, (1,), 2, (4,), ()): ("L", "L;4R"),

(MM, 1, (1,), 2, (4,), ()): ("L", "L;4R"),

(II, 0, (1,), 1, (8,), ()): ("L", "L;I"),

(MM, 0, (1,), 1, (8,), ()): ("L", "L;I"),

(II, 0, (1,), 2, (8,), ()): ("L", "L;IR"),

(MM, 0, (1,), 2, (8,), ()): ("L", "L;IR"),

(II, 1, (1,), 1, (8,), ()): ("L", "L"),

(MM, 1, (1,), 1, (8,), ()): ("L", "L"),

(II, 1, (2,), 1, (8,), ()): ("L", "L"),

(MM, 1, (2,), 1, (8,), ()): ("L", "L"),

(II, 1, (1,), 2, (8,), ()): ("L", "L;R"),

(MM, 1, (1,), 2, (8,), ()): ("L", "L;R"),

(II, 1, (1,), 1, (12,), ()): ("I;16", "I;12"),

(II, 0, (1,), 1, (16,), ()): ("I;16", "I;16"),

(II, 1, (1,), 1, (16,), ()): ("I;16", "I;16"),

(MM, 1, (1,), 1, (16,), ()): ("I;16B", "I;16B"),

(II, 1, (1,), 2, (16,), ()): ("I;16", "I;16R"),

(II, 1, (2,), 1, (16,), ()): ("I", "I;16S"),

(MM, 1, (2,), 1, (16,), ()): ("I", "I;16BS"),

(II, 0, (3,), 1, (32,), ()): ("F", "F;32F"),

(MM, 0, (3,), 1, (32,), ()): ("F", "F;32BF"),

(II, 1, (1,), 1, (32,), ()): ("I", "I;32N"),

(II, 1, (2,), 1, (32,), ()): ("I", "I;32S"),

(MM, 1, (2,), 1, (32,), ()): ("I", "I;32BS"),

(II, 1, (3,), 1, (32,), ()): ("F", "F;32F"),

(MM, 1, (3,), 1, (32,), ()): ("F", "F;32BF"),

(II, 1, (1,), 1, (8, 8), (2,)): ("LA", "LA"),

(MM, 1, (1,), 1, (8, 8), (2,)): ("LA", "LA"),

(II, 2, (1,), 1, (8, 8, 8), ()): ("RGB", "RGB"),

(MM, 2, (1,), 1, (8, 8, 8), ()): ("RGB", "RGB"),

(II, 2, (1,), 2, (8, 8, 8), ()): ("RGB", "RGB;R"),

(MM, 2, (1,), 2, (8, 8, 8), ()): ("RGB", "RGB;R"),

(II, 2, (1,), 1, (8, 8, 8, 8), ()): ("RGBA", "RGBA"), # missing ExtraSamples

(MM, 2, (1,), 1, (8, 8, 8, 8), ()): ("RGBA", "RGBA"), # missing ExtraSamples

(II, 2, (1,), 1, (8, 8, 8, 8), (0,)): ("RGB", "RGBX"),

(MM, 2, (1,), 1, (8, 8, 8, 8), (0,)): ("RGB", "RGBX"),

(II, 2, (1,), 1, (8, 8, 8, 8, 8), (0, 0)): ("RGB", "RGBXX"),

(MM, 2, (1,), 1, (8, 8, 8, 8, 8), (0, 0)): ("RGB", "RGBXX"),

(II, 2, (1,), 1, (8, 8, 8, 8, 8, 8), (0, 0, 0)): ("RGB", "RGBXXX"),

(MM, 2, (1,), 1, (8, 8, 8, 8, 8, 8), (0, 0, 0)): ("RGB", "RGBXXX"),

(II, 2, (1,), 1, (8, 8, 8, 8), (1,)): ("RGBA", "RGBa"),

(MM, 2, (1,), 1, (8, 8, 8, 8), (1,)): ("RGBA", "RGBa"),

(II, 2, (1,), 1, (8, 8, 8, 8, 8), (1, 0)): ("RGBA", "RGBaX"),

(MM, 2, (1,), 1, (8, 8, 8, 8, 8), (1, 0)): ("RGBA", "RGBaX"),

(II, 2, (1,), 1, (8, 8, 8, 8, 8, 8), (1, 0, 0)): ("RGBA", "RGBaXX"),

(MM, 2, (1,), 1, (8, 8, 8, 8, 8, 8), (1, 0, 0)): ("RGBA", "RGBaXX"),

(II, 2, (1,), 1, (8, 8, 8, 8), (2,)): ("RGBA", "RGBA"),

(MM, 2, (1,), 1, (8, 8, 8, 8), (2,)): ("RGBA", "RGBA"),

(II, 2, (1,), 1, (8, 8, 8, 8, 8), (2, 0)): ("RGBA", "RGBAX"),

(MM, 2, (1,), 1, (8, 8, 8, 8, 8), (2, 0)): ("RGBA", "RGBAX"),

(II, 2, (1,), 1, (8, 8, 8, 8, 8, 8), (2, 0, 0)): ("RGBA", "RGBAXX"),

(MM, 2, (1,), 1, (8, 8, 8, 8, 8, 8), (2, 0, 0)): ("RGBA", "RGBAXX"),

(II, 2, (1,), 1, (8, 8, 8, 8), (999,)): ("RGBA", "RGBA"), # Corel Draw 10

(MM, 2, (1,), 1, (8, 8, 8, 8), (999,)): ("RGBA", "RGBA"), # Corel Draw 10

(II, 2, (1,), 1, (16, 16, 16), ()): ("RGB", "RGB;16L"),

(MM, 2, (1,), 1, (16, 16, 16), ()): ("RGB", "RGB;16B"),

(II, 2, (1,), 1, (16, 16, 16, 16), ()): ("RGBA", "RGBA;16L"),

(MM, 2, (1,), 1, (16, 16, 16, 16), ()): ("RGBA", "RGBA;16B"),

(II, 2, (1,), 1, (16, 16, 16, 16), (0,)): ("RGB", "RGBX;16L"),

(MM, 2, (1,), 1, (16, 16, 16, 16), (0,)): ("RGB", "RGBX;16B"),

(II, 2, (1,), 1, (16, 16, 16, 16), (1,)): ("RGBA", "RGBa;16L"),

(MM, 2, (1,), 1, (16, 16, 16, 16), (1,)): ("RGBA", "RGBa;16B"),

(II, 2, (1,), 1, (16, 16, 16, 16), (2,)): ("RGBA", "RGBA;16L"),

(MM, 2, (1,), 1, (16, 16, 16, 16), (2,)): ("RGBA", "RGBA;16B"),

(II, 3, (1,), 1, (1,), ()): ("P", "P;1"),

(MM, 3, (1,), 1, (1,), ()): ("P", "P;1"),

(II, 3, (1,), 2, (1,), ()): ("P", "P;1R"),

(MM, 3, (1,), 2, (1,), ()): ("P", "P;1R"),

(II, 3, (1,), 1, (2,), ()): ("P", "P;2"),

(MM, 3, (1,), 1, (2,), ()): ("P", "P;2"),

(II, 3, (1,), 2, (2,), ()): ("P", "P;2R"),

(MM, 3, (1,), 2, (2,), ()): ("P", "P;2R"),

(II, 3, (1,), 1, (4,), ()): ("P", "P;4"),

(MM, 3, (1,), 1, (4,), ()): ("P", "P;4"),

(II, 3, (1,), 2, (4,), ()): ("P", "P;4R"),

(MM, 3, (1,), 2, (4,), ()): ("P", "P;4R"),

(II, 3, (1,), 1, (8,), ()): ("P", "P"),

(MM, 3, (1,), 1, (8,), ()): ("P", "P"),

(II, 3, (1,), 1, (8, 8), (0,)): ("P", "PX"),

(II, 3, (1,), 1, (8, 8), (2,)): ("PA", "PA"),

(MM, 3, (1,), 1, (8, 8), (2,)): ("PA", "PA"),

(II, 3, (1,), 2, (8,), ()): ("P", "P;R"),

(MM, 3, (1,), 2, (8,), ()): ("P", "P;R"),

(II, 5, (1,), 1, (8, 8, 8, 8), ()): ("CMYK", "CMYK"),

(MM, 5, (1,), 1, (8, 8, 8, 8), ()): ("CMYK", "CMYK"),

(II, 5, (1,), 1, (8, 8, 8, 8, 8), (0,)): ("CMYK", "CMYKX"),

(MM, 5, (1,), 1, (8, 8, 8, 8, 8), (0,)): ("CMYK", "CMYKX"),

(II, 5, (1,), 1, (8, 8, 8, 8, 8, 8), (0, 0)): ("CMYK", "CMYKXX"),

(MM, 5, (1,), 1, (8, 8, 8, 8, 8, 8), (0, 0)): ("CMYK", "CMYKXX"),

(II, 5, (1,), 1, (16, 16, 16, 16), ()): ("CMYK", "CMYK;16L"),

(MM, 5, (1,), 1, (16, 16, 16, 16), ()): ("CMYK", "CMYK;16B"),

(II, 6, (1,), 1, (8,), ()): ("L", "L"),

(MM, 6, (1,), 1, (8,), ()): ("L", "L"),

# JPEG compressed images handled by LibTiff and auto-converted to RGBX

# Minimal Baseline TIFF requires YCbCr images to have 3 SamplesPerPixel

(II, 6, (1,), 1, (8, 8, 8), ()): ("RGB", "RGBX"),

(MM, 6, (1,), 1, (8, 8, 8), ()): ("RGB", "RGBX"),

(II, 8, (1,), 1, (8, 8, 8), ()): ("LAB", "LAB"),

(MM, 8, (1,), 1, (8, 8, 8), ()): ("LAB", "LAB"),

b"MM\x00\x2A", # Valid TIFF header with big-endian byte order

b"II\x2A\x00", # Valid TIFF header with little-endian byte order

b"MM\x2A\x00", # Invalid TIFF header, assume big-endian

b"II\x00\x2A", # Invalid TIFF header, assume little-endian

b"MM\x00\x2B", # BigTIFF with big-endian byte order

b"II\x2B\x00", # BigTIFF with little-endian byte order

val: float | Fraction | IFDRational, max_val: int

) -> tuple[IntegralLike, IntegralLike]:

inv = abs(val) > 1

n_d = IFDRational(1 / val if inv else val).limit_rational(max_val)

val: IFDRational, max_val: int, min_val: int

) -> tuple[IntegralLike, IntegralLike]:

frac = Fraction(val)

n_d: tuple[IntegralLike, IntegralLike] = frac.numerator, frac.denominator

if min(float(i) for i in n_d) < min_val:

n_d = _limit_rational(val, abs(min_val))

n_d_float = tuple(float(i) for i in n_d)

if max(n_d_float) > max_val:

n_d = _limit_rational(n_d_float[0] / n_d_float[1], max_val)

def delegate(

self: IFDRational, *args: tuple[float, ...]

) -> bool | float | Fraction:

return getattr(self._val, op)(*args)

"""Implements a rational class where 0/0 is a legal value to match

""" If the denominator is 0, store this as a float('nan'), otherwise store

__slots__ = ("_numerator", "_denominator", "_val")

def __init__(

self, value: float | Fraction | IFDRational, denominator: int = 1

) -> None:

"""

self._val: Fraction | float

if isinstance(value, IFDRational):

self._numerator = value.numerator

self._denominator = value.denominator

self._val = value._val

return

if isinstance(value, Fraction):

self._numerator = value.numerator

self._denominator = value.denominator

else:

if TYPE_CHECKING:

self._numerator = cast(IntegralLike, value)

else:

self._numerator = value

self._denominator = denominator

if denominator == 0:

self._val = float("nan")

elif denominator == 1:

self._val = Fraction(value)

elif int(value) == value:

self._val = Fraction(int(value), denominator)

else:

self._val = Fraction(value / denominator)

@property

def numerator(self) -> IntegralLike:

return self._numerator

@property

def denominator(self) -> int:

return self._denominator

def limit_rational(self, max_denominator: int) -> tuple[IntegralLike, int]:

"""

if self.denominator == 0:

return self.numerator, self.denominator

assert isinstance(self._val, Fraction)

f = self._val.limit_denominator(max_denominator)

return f.numerator, f.denominator

def __repr__(self) -> str:

return str(float(self._val))

def __hash__(self) -> int:

return self._val.__hash__()

def __eq__(self, other: object) -> bool:

val = self._val

if isinstance(other, IFDRational):

other = other._val

if isinstance(other, float):

val = float(val)

return val == other

def __getstate__(self) -> list[float | Fraction | IntegralLike]:

return [self._val, self._numerator, self._denominator]

def __setstate__(self, state: list[float | Fraction | IntegralLike]) -> None:

IFDRational.__init__(self, 0)

_val, _numerator, _denominator = state

assert isinstance(_val, (float, Fraction))

self._val = _val

if TYPE_CHECKING:

self._numerator = cast(IntegralLike, _numerator)

else:

self._numerator = _numerator

assert isinstance(_denominator, int)

self._denominator = _denominator

""" a = ['add','radd', 'sub', 'rsub', 'mul', 'rmul',

__add__ = _delegate("__add__")

__radd__ = _delegate("__radd__")

__sub__ = _delegate("__sub__")

__rsub__ = _delegate("__rsub__")

__mul__ = _delegate("__mul__")

__rmul__ = _delegate("__rmul__")

__truediv__ = _delegate("__truediv__")

__rtruediv__ = _delegate("__rtruediv__")

__floordiv__ = _delegate("__floordiv__")

__rfloordiv__ = _delegate("__rfloordiv__")

__mod__ = _delegate("__mod__")

__rmod__ = _delegate("__rmod__")

__pow__ = _delegate("__pow__")

__rpow__ = _delegate("__rpow__")

__pos__ = _delegate("__pos__")

__neg__ = _delegate("__neg__")

__abs__ = _delegate("__abs__")

__trunc__ = _delegate("__trunc__")

__lt__ = _delegate("__lt__")

__gt__ = _delegate("__gt__")

__le__ = _delegate("__le__")

__ge__ = _delegate("__ge__")

__bool__ = _delegate("__bool__")

__ceil__ = _delegate("__ceil__")

__floor__ = _delegate("__floor__")

__round__ = _delegate("__round__")

# Python >= 3.11

if hasattr(Fraction, "__int__"):

def decorator(func: _LoaderFunc) -> _LoaderFunc:

from .TiffTags import TYPES

if func.__name__.startswith("load_"):

TYPES[idx] = func.__name__[5:].replace("_", " ")

_load_dispatch[idx] = size, func # noqa: F821

return func

def decorator(func: Callable[..., Any]) -> Callable[..., Any]:

_write_dispatch[idx] = func # noqa: F821

return func

from .TiffTags import TYPES

idx, fmt, name = idx_fmt_name

TYPES[idx] = name

size = struct.calcsize(f"={fmt}")

def basic_handler(

self: ImageFileDirectory_v2, data: bytes, legacy_api: bool = True

) -> tuple[Any, ...]:

return self._unpack(f"{len(data) // size}{fmt}", data)

_load_dispatch[idx] = size, basic_handler # noqa: F821

_write_dispatch[idx] = lambda self, *values: ( # noqa: F821

b"".join(self._pack(fmt, value) for value in values)

"""This class represents a TIFF tag directory. To speed things up, we

_load_dispatch: dict[int, tuple[int, _LoaderFunc]] = {}

_write_dispatch: dict[int, Callable[..., Any]] = {}

def __init__(

self,

ifh: bytes = b"II\x2A\x00\x00\x00\x00\x00",

prefix: bytes | None = None,

group: int | None = None,

) -> None:

"""Initialize an ImageFileDirectory.

if not _accept(ifh):

msg = f"not a TIFF file (header {repr(ifh)} not valid)"

raise SyntaxError(msg)

self._prefix = prefix if prefix is not None else ifh[:2]

if self._prefix == MM:

self._endian = ">"

elif self._prefix == II:

self._endian = "<"

else:

msg = "not a TIFF IFD"

raise SyntaxError(msg)

self._bigtiff = ifh[2] == 43

self.group = group

self.tagtype: dict[int, int] = {}

""" Dictionary of tag types """

self.reset()

self.next = (

self._unpack("Q", ifh[8:])[0]

if self._bigtiff

else self._unpack("L", ifh[4:])[0]

)

self._legacy_api = False

prefix = property(lambda self: self._prefix)

offset = property(lambda self: self._offset)

@property

def legacy_api(self) -> bool:

return self._legacy_api

@legacy_api.setter

def legacy_api(self, value: bool) -> NoReturn:

msg = "Not allowing setting of legacy api"

raise Exception(msg)

def reset(self) -> None:

self._tags_v1: dict[int, Any] = {} # will remain empty if legacy_api is false

self._tags_v2: dict[int, Any] = {} # main tag storage

self._tagdata: dict[int, bytes] = {}

self.tagtype = {} # added 2008-06-05 by Florian Hoech

self._next = None

self._offset: int | None = None

def __str__(self) -> str:

return str(dict(self))

def named(self) -> dict[str, Any]:

"""

return {

TiffTags.lookup(code, self.group).name: value

for code, value in self.items()

}

def __len__(self) -> int:

return len(set(self._tagdata) | set(self._tags_v2))

def __getitem__(self, tag: int) -> Any:

if tag not in self._tags_v2: # unpack on the fly

data = self._tagdata[tag]

typ = self.tagtype[tag]

size, handler = self._load_dispatch[typ]

self[tag] = handler(self, data, self.legacy_api) # check type

val = self._tags_v2[tag]

if self.legacy_api and not isinstance(val, (tuple, bytes)):

val = (val,)

return val

def __contains__(self, tag: object) -> bool:

return tag in self._tags_v2 or tag in self._tagdata

def __setitem__(self, tag: int, value: Any) -> None:

self._setitem(tag, value, self.legacy_api)

def _setitem(self, tag: int, value: Any, legacy_api: bool) -> None:

basetypes = (Number, bytes, str)

info = TiffTags.lookup(tag, self.group)

values = [value] if isinstance(value, basetypes) else value

if tag not in self.tagtype:

if info.type:

self.tagtype[tag] = info.type

else:

self.tagtype[tag] = TiffTags.UNDEFINED

if all(isinstance(v, IFDRational) for v in values):

for v in values:

assert isinstance(v, IFDRational)

if v < 0:

self.tagtype[tag] = TiffTags.SIGNED_RATIONAL

break

else:

self.tagtype[tag] = TiffTags.RATIONAL

elif all(isinstance(v, int) for v in values):

short = True

signed_short = True

long = True

for v in values:

assert isinstance(v, int)

if short and not (0 <= v < 2**16):

short = False

if signed_short and not (-(2**15) < v < 2**15):

signed_short = False

if long and v < 0:

long = False

if short:

self.tagtype[tag] = TiffTags.SHORT

elif signed_short:

self.tagtype[tag] = TiffTags.SIGNED_SHORT

elif long:

self.tagtype[tag] = TiffTags.LONG

else:

self.tagtype[tag] = TiffTags.SIGNED_LONG

elif all(isinstance(v, float) for v in values):

self.tagtype[tag] = TiffTags.DOUBLE

elif all(isinstance(v, str) for v in values):

self.tagtype[tag] = TiffTags.ASCII

elif all(isinstance(v, bytes) for v in values):

self.tagtype[tag] = TiffTags.BYTE

if self.tagtype[tag] == TiffTags.UNDEFINED:

values = [

v.encode("ascii", "replace") if isinstance(v, str) else v

for v in values

]

elif self.tagtype[tag] == TiffTags.RATIONAL:

values = [float(v) if isinstance(v, int) else v for v in values]

is_ifd = self.tagtype[tag] == TiffTags.LONG and isinstance(values, dict)

if not is_ifd:

values = tuple(

info.cvt_enum(value) if isinstance(value, str) else value

for value in values

)

dest = self._tags_v1 if legacy_api else self._tags_v2

# Three branches:

# Spec'd length == 1, Actual length 1, store as element

# Spec'd length == 1, Actual > 1, Warn and truncate. Formerly barfed.

# No Spec, Actual length 1, Formerly (<4.2) returned a 1 element tuple.

# Don't mess with the legacy api, since it's frozen.

if not is_ifd and (

(info.length == 1)

or self.tagtype[tag] == TiffTags.BYTE

or (info.length is None and len(values) == 1 and not legacy_api)

):

# Don't mess with the legacy api, since it's frozen.

if legacy_api and self.tagtype[tag] in [

TiffTags.RATIONAL,

TiffTags.SIGNED_RATIONAL,

]: # rationals

values = (values,)

try:

(dest[tag],) = values

except ValueError:

# We've got a builtin tag with 1 expected entry

warnings.warn(

f"Metadata Warning, tag {tag} had too many entries: "

f"{len(values)}, expected 1"

)

dest[tag] = values[0]

else:

# Spec'd length > 1 or undefined

# Unspec'd, and length > 1

dest[tag] = values

def __delitem__(self, tag: int) -> None:

self._tags_v2.pop(tag, None)

self._tags_v1.pop(tag, None)

self._tagdata.pop(tag, None)

def __iter__(self) -> Iterator[int]:

return iter(set(self._tagdata) | set(self._tags_v2))

def _unpack(self, fmt: str, data: bytes) -> tuple[Any, ...]:

return struct.unpack(self._endian + fmt, data)

def _pack(self, fmt: str, *values: Any) -> bytes:

return struct.pack(self._endian + fmt, *values)

list(

map(

_register_basic,

[

(TiffTags.SHORT, "H", "short"),

(TiffTags.LONG, "L", "long"),

(TiffTags.SIGNED_BYTE, "b", "signed byte"),

(TiffTags.SIGNED_SHORT, "h", "signed short"),

(TiffTags.SIGNED_LONG, "l", "signed long"),

(TiffTags.FLOAT, "f", "float"),

(TiffTags.DOUBLE, "d", "double"),

(TiffTags.IFD, "L", "long"),

(TiffTags.LONG8, "Q", "long8"),

],

)

)

@_register_loader(1, 1) # Basic type, except for the legacy API.

def load_byte(self, data: bytes, legacy_api: bool = True) -> bytes:

return data

@_register_writer(1) # Basic type, except for the legacy API.

def write_byte(self, data: bytes | int | IFDRational) -> bytes:

if isinstance(data, IFDRational):

data = int(data)

if isinstance(data, int):

data = bytes((data,))

return data

@_register_loader(2, 1)

def load_string(self, data: bytes, legacy_api: bool = True) -> str:

if data.endswith(b"\0"):

data = data[:-1]

return data.decode("latin-1", "replace")

@_register_writer(2)

def write_string(self, value: str | bytes | int) -> bytes:

# remerge of https://github.com/python-pillow/Pillow/pull/1416

if isinstance(value, int):

value = str(value)

if not isinstance(value, bytes):

value = value.encode("ascii", "replace")

return value + b"\0"

@_register_loader(5, 8)

def load_rational(

self, data: bytes, legacy_api: bool = True

) -> tuple[tuple[int, int] | IFDRational, ...]:

vals = self._unpack(f"{len(data) // 4}L", data)

def combine(a: int, b: int) -> tuple[int, int] | IFDRational:

return (a, b) if legacy_api else IFDRational(a, b)

return tuple(combine(num, denom) for num, denom in zip(vals[::2], vals[1::2]))

@_register_writer(5)

def write_rational(self, *values: IFDRational) -> bytes:

return b"".join(

self._pack("2L", *_limit_rational(frac, 2**32 - 1)) for frac in values

)

@_register_loader(7, 1)

def load_undefined(self, data: bytes, legacy_api: bool = True) -> bytes:

return data

@_register_writer(7)

def write_undefined(self, value: bytes | int | IFDRational) -> bytes:

if isinstance(value, IFDRational):

value = int(value)

if isinstance(value, int):

value = str(value).encode("ascii", "replace")

return value

@_register_loader(10, 8)

def load_signed_rational(

self, data: bytes, legacy_api: bool = True

) -> tuple[tuple[int, int] | IFDRational, ...]:

vals = self._unpack(f"{len(data) // 4}l", data)

def combine(a: int, b: int) -> tuple[int, int] | IFDRational:

return (a, b) if legacy_api else IFDRational(a, b)

return tuple(combine(num, denom) for num, denom in zip(vals[::2], vals[1::2]))

@_register_writer(10)

def write_signed_rational(self, *values: IFDRational) -> bytes:

return b"".join(

self._pack("2l", *_limit_signed_rational(frac, 2**31 - 1, -(2**31)))

for frac in values

)

def _ensure_read(self, fp: IO[bytes], size: int) -> bytes:

ret = fp.read(size)

if len(ret) != size:

msg = (

"Corrupt EXIF data. "

f"Expecting to read {size} bytes but only got {len(ret)}. "

)

raise OSError(msg)

return ret

def load(self, fp: IO[bytes]) -> None:

self.reset()

self._offset = fp.tell()

try:

tag_count = (

self._unpack("Q", self._ensure_read(fp, 8))

if self._bigtiff

else self._unpack("H", self._ensure_read(fp, 2))

)[0]

for i in range(tag_count):

tag, typ, count, data = (

self._unpack("HHQ8s", self._ensure_read(fp, 20))

if self._bigtiff

else self._unpack("HHL4s", self._ensure_read(fp, 12))

)

tagname = TiffTags.lookup(tag, self.group).name

typname = TYPES.get(typ, "unknown")

msg = f"tag: {tagname} ({tag}) - type: {typname} ({typ})"

try:

unit_size, handler = self._load_dispatch[typ]

except KeyError:

logger.debug("%s - unsupported type %s", msg, typ)

continue # ignore unsupported type

size = count * unit_size

if size > (8 if self._bigtiff else 4):

here = fp.tell()

(offset,) = self._unpack("Q" if self._bigtiff else "L", data)

msg += f" Tag Location: {here} - Data Location: {offset}"

fp.seek(offset)

data = ImageFile._safe_read(fp, size)

fp.seek(here)

else:

data = data[:size]

if len(data) != size:

warnings.warn(

"Possibly corrupt EXIF data. "

f"Expecting to read {size} bytes but only got {len(data)}."

f" Skipping tag {tag}"

)

logger.debug(msg)

continue

if not data:

logger.debug(msg)

continue

self._tagdata[tag] = data

self.tagtype[tag] = typ

msg += " - value: "

msg += f"<table: {size} bytes>" if size > 32 else repr(data)

logger.debug(msg)

(self.next,) = (

self._unpack("Q", self._ensure_read(fp, 8))

if self._bigtiff

else self._unpack("L", self._ensure_read(fp, 4))