Glymur 0.13.6__py3-none-any.whl → 0.13.8__py3-none-any.whl

glymur/codestream.py

@@ -14,23 +14,28 @@ import numpy as np
 
 # local imports
 from .core import (
-    LRCP, RLCP, RPCL, PCRL, CPRL,
-    WAVELET_XFORM_9X7_IRREVERSIBLE, WAVELET_XFORM_5X3_REVERSIBLE
+    LRCP,
+    RLCP,
+    RPCL,
+    PCRL,
+    CPRL,
+    WAVELET_XFORM_9X7_IRREVERSIBLE,
+    WAVELET_XFORM_5X3_REVERSIBLE,
 )
 from .lib import openjp2 as opj2
 
 
 _PROGRESSION_ORDER_DISPLAY = {
-    LRCP: 'LRCP',
-    RLCP: 'RLCP',
-    RPCL: 'RPCL',
-    PCRL: 'PCRL',
-    CPRL: 'CPRL',
+    LRCP: "LRCP",
+    RLCP: "RLCP",
+    RPCL: "RPCL",
+    PCRL: "PCRL",
+    CPRL: "CPRL",
 }
 
 _WAVELET_XFORM_DISPLAY = {
-    WAVELET_XFORM_9X7_IRREVERSIBLE: '9-7 irreversible',
-    WAVELET_XFORM_5X3_REVERSIBLE: '5-3 reversible'
+    WAVELET_XFORM_9X7_IRREVERSIBLE: "9-7 irreversible",
+    WAVELET_XFORM_5X3_REVERSIBLE: "5-3 reversible",
 }
 
 _NO_PROFILE = 0
@@ -95,24 +100,24 @@ _PROFILE_IMF_8K_R = 0x0900
 
 # How to display the codestream profile.
 _CAPABILITIES_DISPLAY = {
-    _PROFILE_NONE: 'no profile',
-    _PROFILE_0: '0',
-    _PROFILE_1: '1',
-    _PROFILE_PART2: 'at least 1 extension defined in 15444-2 (Part-2)',
-    _PROFILE_CINEMA_2K: '2K cinema',
-    _PROFILE_CINEMA_4K: '4K cinema',
-    _PROFILE_CINEMA_S2K: 'scalable 2K cinema',
-    _PROFILE_CINEMA_S4K: 'scalable 4K cinema',
-    _PROFILE_CINEMA_LTS: 'long term storage cinema',
-    _PROFILE_BC_SINGLE: 'single tile broadcast',
-    _PROFILE_BC_MULTI: 'multi tile broadcast',
-    _PROFILE_BC_MULTI_R: 'multi tile reversible broadcast',
-    _PROFILE_IMF_2K: '2K single tile lossy IMF',
-    _PROFILE_IMF_4K: '4K single tile lossy IMF',
-    _PROFILE_IMF_8K: '8K single tile lossy IMF',
-    _PROFILE_IMF_2K_R: '2K single/multi tile reversible IMF',
-    _PROFILE_IMF_4K_R: '4K single/multi tile reversible IMF',
-    _PROFILE_IMF_8K_R: '8K single/multi tile reversible IMF',
+    _PROFILE_NONE: "no profile",
+    _PROFILE_0: "0",
+    _PROFILE_1: "1",
+    _PROFILE_PART2: "at least 1 extension defined in 15444-2 (Part-2)",
+    _PROFILE_CINEMA_2K: "2K cinema",
+    _PROFILE_CINEMA_4K: "4K cinema",
+    _PROFILE_CINEMA_S2K: "scalable 2K cinema",
+    _PROFILE_CINEMA_S4K: "scalable 4K cinema",
+    _PROFILE_CINEMA_LTS: "long term storage cinema",
+    _PROFILE_BC_SINGLE: "single tile broadcast",
+    _PROFILE_BC_MULTI: "multi tile broadcast",
+    _PROFILE_BC_MULTI_R: "multi tile reversible broadcast",
+    _PROFILE_IMF_2K: "2K single tile lossy IMF",
+    _PROFILE_IMF_4K: "4K single tile lossy IMF",
+    _PROFILE_IMF_8K: "8K single tile lossy IMF",
+    _PROFILE_IMF_2K_R: "2K single/multi tile reversible IMF",
+    _PROFILE_IMF_4K_R: "4K single/multi tile reversible IMF",
+    _PROFILE_IMF_8K_R: "8K single/multi tile reversible IMF",
 }
 
 _KNOWN_PROFILES = _CAPABILITIES_DISPLAY.keys()
@@ -140,6 +145,7 @@ class Codestream(object):
        15444-1:2004 - Information technology -- JPEG 2000 image coding system:
        Core coding system
     """
+
     # These two begin their lives as class attributes that usually become
     # instance attributes.  The reason why isn't important for users; it's only
     # important for testing purposes.
@@ -168,65 +174,62 @@ class Codestream(object):
         # We really don't know what to do with them, so they are treated as if
         # they are reserved markers.
         self.parse_marker_segment_fcn = {
-
             # The following are definitively reserved markers according to
             # table A-1 in ISO/IEC FCD15444-1.
-            0xff30: self._parse_reserved_marker,
-            0xff31: self._parse_reserved_marker,
-            0xff32: self._parse_reserved_marker,
-            0xff33: self._parse_reserved_marker,
-            0xff34: self._parse_reserved_marker,
-            0xff35: self._parse_reserved_marker,
-            0xff36: self._parse_reserved_marker,
-            0xff37: self._parse_reserved_marker,
-            0xff38: self._parse_reserved_marker,
-            0xff39: self._parse_reserved_marker,
-            0xff3a: self._parse_reserved_marker,
-            0xff3b: self._parse_reserved_marker,
-            0xff3c: self._parse_reserved_marker,
-            0xff3d: self._parse_reserved_marker,
-            0xff3e: self._parse_reserved_marker,
-            0xff3f: self._parse_reserved_marker,
-
+            0xFF30: self._parse_reserved_marker,
+            0xFF31: self._parse_reserved_marker,
+            0xFF32: self._parse_reserved_marker,
+            0xFF33: self._parse_reserved_marker,
+            0xFF34: self._parse_reserved_marker,
+            0xFF35: self._parse_reserved_marker,
+            0xFF36: self._parse_reserved_marker,
+            0xFF37: self._parse_reserved_marker,
+            0xFF38: self._parse_reserved_marker,
+            0xFF39: self._parse_reserved_marker,
+            0xFF3A: self._parse_reserved_marker,
+            0xFF3B: self._parse_reserved_marker,
+            0xFF3C: self._parse_reserved_marker,
+            0xFF3D: self._parse_reserved_marker,
+            0xFF3E: self._parse_reserved_marker,
+            0xFF3F: self._parse_reserved_marker,
             # 0xff4f:  SOC (already encountered by the time we get here)
-            0xff50: self._parse_cap_segment,
-            0xff51: self._parse_siz_segment,
-            0xff52: self._parse_cod_segment,
-            0xff53: self._parse_coc_segment,
-            0xff54: self._parse_reserved_segment,
-            0xff55: self._parse_tlm_segment,
-            0xff56: self._parse_reserved_segment,
-            0xff57: self._parse_reserved_segment,
-            0xff58: self._parse_plt_segment,
-            0xff59: self._parse_reserved_segment,
-            0xff5a: self._parse_reserved_segment,
-            0xff5b: self._parse_reserved_segment,
-            0xff5c: self._parse_qcd_segment,
-            0xff5d: self._parse_qcc_segment,
-            0xff5e: self._parse_rgn_segment,
-            0xff5f: self._parse_pod_segment,
-            0xff60: self._parse_ppm_segment,
-            0xff61: self._parse_ppt_segment,
-            0xff62: self._parse_reserved_segment,
-            0xff63: self._parse_crg_segment,
-            0xff64: self._parse_cme_segment,
-            0xff65: self._parse_reserved_segment,
-            0xff66: self._parse_reserved_segment,
-            0xff67: self._parse_reserved_segment,
-            0xff68: self._parse_reserved_segment,
-            0xff69: self._parse_reserved_segment,
-            0xff6a: self._parse_reserved_segment,
-            0xff6b: self._parse_reserved_segment,
-            0xff6c: self._parse_reserved_segment,
-            0xff6d: self._parse_reserved_segment,
-            0xff6e: self._parse_reserved_segment,
-            0xff6f: self._parse_reserved_segment,
-            0xff90: self._parse_sot_segment,
+            0xFF50: self._parse_cap_segment,
+            0xFF51: self._parse_siz_segment,
+            0xFF52: self._parse_cod_segment,
+            0xFF53: self._parse_coc_segment,
+            0xFF54: self._parse_reserved_segment,
+            0xFF55: self._parse_tlm_segment,
+            0xFF56: self._parse_reserved_segment,
+            0xFF57: self._parse_reserved_segment,
+            0xFF58: self._parse_plt_segment,
+            0xFF59: self._parse_reserved_segment,
+            0xFF5A: self._parse_reserved_segment,
+            0xFF5B: self._parse_reserved_segment,
+            0xFF5C: self._parse_qcd_segment,
+            0xFF5D: self._parse_qcc_segment,
+            0xFF5E: self._parse_rgn_segment,
+            0xFF5F: self._parse_pod_segment,
+            0xFF60: self._parse_ppm_segment,
+            0xFF61: self._parse_ppt_segment,
+            0xFF62: self._parse_reserved_segment,
+            0xFF63: self._parse_crg_segment,
+            0xFF64: self._parse_cme_segment,
+            0xFF65: self._parse_reserved_segment,
+            0xFF66: self._parse_reserved_segment,
+            0xFF67: self._parse_reserved_segment,
+            0xFF68: self._parse_reserved_segment,
+            0xFF69: self._parse_reserved_segment,
+            0xFF6A: self._parse_reserved_segment,
+            0xFF6B: self._parse_reserved_segment,
+            0xFF6C: self._parse_reserved_segment,
+            0xFF6D: self._parse_reserved_segment,
+            0xFF6E: self._parse_reserved_segment,
+            0xFF6F: self._parse_reserved_segment,
+            0xFF90: self._parse_sot_segment,
             # 0xff91:  SOP (only found in bit stream)
             # 0xff92:  EPH (only found in bit stream)
-            0xff93: self._parse_sod_marker,
-            0xffd9: self._parse_eoc_marker,
-
+            0xFF93: self._parse_sod_marker,
+            0xFFD9: self._parse_eoc_marker,
         }
 
         self.offset = fptr.tell()
@@ -254,27 +257,27 @@ class Codestream(object):
             read_buffer = fptr.read(2)
 
             try:
-                self._marker_id, = struct.unpack('>H', read_buffer)
+                (self._marker_id,) = struct.unpack(">H", read_buffer)
             except struct.error as e:
                 msg = (
                     f"Unable to read an expected marker in the codestream "
-                    f"at byte offset {fptr.tell()}.  \"{e}\"."
+                    f'at byte offset {fptr.tell()}.  "{e}".'
                 )
                 raise J2KParseError(msg)
 
-            if self._marker_id < 0xff00:
+            if self._marker_id < 0xFF00:
                 offset = fptr.tell() - 2
                 msg = (
-                    f'Invalid codestream marker at byte offset {offset}.  It '
-                    f'must be must be greater than 0xff00, but '
-                    f'found 0x{self._marker_id:04x} instead.  Codestream '
-                    f'parsing will cease.'
+                    f"Invalid codestream marker at byte offset {offset}.  It "
+                    f"must be must be greater than 0xff00, but "
+                    f"found 0x{self._marker_id:04x} instead.  Codestream "
+                    f"parsing will cease."
                 )
                 raise ValueError(msg)
 
             self._offset = fptr.tell() - 2
 
-            if self._marker_id == 0xff90 and self.header_only:
+            if self._marker_id == 0xFF90 and self.header_only:
                 # Start-of-tile (SOT) means that we are out of the main header
                 # and there is no need to go further.
                 break
@@ -286,13 +289,13 @@ class Codestream(object):
 
             self.segment.append(segment)
 
-            if self._marker_id == 0xffd9:
+            if self._marker_id == 0xFFD9:
                 # end of codestream, should break.
                 break
 
             # If the marker ID is SOD, then we need to seek past the tile part
             # bit stream.
-            if self._marker_id == 0xff93:
+            if self._marker_id == 0xFF93:
 
                 if self._parse_tpart_flag and not self.header_only:
                     # But first parse the tile part bit stream for SOP and
@@ -320,14 +323,18 @@ class Codestream(object):
         offset = fptr.tell() - 2
 
         read_buffer = fptr.read(2)
-        length, = struct.unpack('>H', read_buffer)
+        (length,) = struct.unpack(">H", read_buffer)
         if length > 0:
             data = fptr.read(length - 2)
         else:
             data = None
 
-        segment = Segment(marker_id=f'0x{self._marker_id:x}',
-                          offset=offset, length=length, data=data)
+        segment = Segment(
+            marker_id=f"0x{self._marker_id:x}",
+            offset=offset,
+            length=length,
+            data=data
+        )
         return segment
 
     def _parse_tile_part_bit_stream(self, fptr, sod_marker, tile_length):
@@ -338,14 +345,14 @@ class Codestream(object):
         count = min(tile_length, len(read_buffer))
         packet = np.frombuffer(read_buffer, dtype=np.uint8, count=count)
 
-        indices = np.where(packet == 0xff)
+        indices = np.where(packet == 0xFF)
         for idx in indices[0]:
             try:
                 if packet[idx + 1] == 0x91 and (idx < (len(packet) - 5)):
                     offset = sod_marker.offset + 2 + idx
                     length = 4
-                    nsop = packet[(idx + 4):(idx + 6)].view('uint16')[0]
-                    if sys.byteorder == 'little':
+                    nsop = packet[(idx + 4):(idx + 6)].view("uint16")[0]
+                    if sys.byteorder == "little":
                         nsop = nsop.byteswap()
                     segment = SOPsegment(nsop, length, offset)
                     self.segment.append(segment)
@@ -358,13 +365,13 @@ class Codestream(object):
                 continue
 
     def __str__(self):
-        msg = 'Codestream:\n'
+        msg = "Codestream:\n"
         for segment in self.segment:
             strs = str(segment)
 
             # Add indentation
-            strs = [('    ' + x + '\n') for x in strs.split('\n')]
-            msg += ''.join(strs)
+            strs = [("    " + x + "\n") for x in strs.split("\n")]
+            msg += "".join(strs)
         return msg.rstrip()
 
     def _parse_cme_segment(self, fptr):
@@ -383,7 +390,7 @@ class Codestream(object):
         offset = fptr.tell() - 2
 
         read_buffer = fptr.read(4)
-        data = struct.unpack('>HH', read_buffer)
+        data = struct.unpack(">HH", read_buffer)
         length = data[0]
         rcme = data[1]
         ccme = fptr.read(length - 4)
@@ -405,19 +412,19 @@ class Codestream(object):
         """
         kwargs = {}
         offset = fptr.tell() - 2
-        kwargs['offset'] = offset
+        kwargs["offset"] = offset
 
         read_buffer = fptr.read(2)
-        length, = struct.unpack('>H', read_buffer)
-        kwargs['length'] = length
+        (length,) = struct.unpack(">H", read_buffer)
+        kwargs["length"] = length
 
-        fmt = '>B' if self._csiz <= 255 else '>H'
+        fmt = ">B" if self._csiz <= 255 else ">H"
         nbytes = 1 if self._csiz <= 255 else 2
         read_buffer = fptr.read(nbytes)
-        ccoc, = struct.unpack(fmt, read_buffer)
+        (ccoc,) = struct.unpack(fmt, read_buffer)
 
         read_buffer = fptr.read(1)
-        scoc, = struct.unpack('>B', read_buffer)
+        (scoc,) = struct.unpack(">B", read_buffer)
 
         numbytes = offset + 2 + length - fptr.tell()
         read_buffer = fptr.read(numbytes)
@@ -443,11 +450,11 @@ class Codestream(object):
         offset = fptr.tell() - 2
 
         read_buffer = fptr.read(2)
-        length, = struct.unpack('>H', read_buffer)
+        (length,) = struct.unpack(">H", read_buffer)
 
         read_buffer = fptr.read(length - 2)
 
-        lst = struct.unpack_from('>BBHBBBBBB', read_buffer, offset=0)
+        lst = struct.unpack_from(">BBHBBBBBB", read_buffer, offset=0)
         scod, prog, nlayers, mct, nr, xcb, ycb, cstyle, xform = lst
 
         if len(read_buffer) > 10:
@@ -463,10 +470,20 @@ class Codestream(object):
         else:
             cls._parse_tpart_flag = False
 
-        pargs = (scod, prog, nlayers, mct, nr, xcb, ycb, cstyle, xform,
-                 precinct_size)
-
-        return CODsegment(*pargs, length=length, offset=offset)
+        return CODsegment(
+            scod,
+            prog,
+            nlayers,
+            mct,
+            nr,
+            xcb,
+            ycb,
+            cstyle,
+            xform,
+            precinct_size,
+            length=length,
+            offset=offset
+        )
 
     def _parse_crg_segment(self, fptr):
         """Parse the CRG marker segment.
@@ -484,10 +501,10 @@ class Codestream(object):
         offset = fptr.tell() - 2
 
         read_buffer = fptr.read(2)
-        length, = struct.unpack('>H', read_buffer)
+        (length,) = struct.unpack(">H", read_buffer)
 
         read_buffer = fptr.read(4 * self._csiz)
-        data = struct.unpack('>' + 'HH' * self._csiz, read_buffer)
+        data = struct.unpack(">" + "HH" * self._csiz, read_buffer)
         xcrg = data[0::2]
         ycrg = data[1::2]
 
@@ -530,7 +547,7 @@ class Codestream(object):
         offset = fptr.tell() - 2
 
         read_buffer = fptr.read(3)
-        length, zplt = struct.unpack('>HB', read_buffer)
+        length, zplt = struct.unpack(">HB", read_buffer)
 
         numbytes = length - 3
         read_buffer = fptr.read(numbytes)
@@ -539,7 +556,7 @@ class Codestream(object):
         packet_len = []
         plen = 0
         for byte in iplt:
-            plen |= (byte & 0x7f)
+            plen |= byte & 0x7F
             if byte & 0x80:
                 # Continue by or-ing in the next byte.
                 plen <<= 7
@@ -567,13 +584,13 @@ class Codestream(object):
         offset = fptr.tell() - 2
 
         read_buffer = fptr.read(2)
-        length, = struct.unpack('>H', read_buffer)
+        (length,) = struct.unpack(">H", read_buffer)
 
         n = ((length - 2) / 7) if self._csiz < 257 else ((length - 2) / 9)
         n = int(n)
         nbytes = n * 7 if self._csiz < 257 else n * 9
         read_buffer = fptr.read(nbytes)
-        fmt = '>' + 'BBHBBB' * n if self._csiz < 257 else '>' + 'BHHBHB' * n
+        fmt = ">" + "BBHBBB" * n if self._csiz < 257 else ">" + "BHHBHB" * n
         pod_params = struct.unpack(fmt, read_buffer)
 
         return PODsegment(pod_params, length, offset)
@@ -594,7 +611,7 @@ class Codestream(object):
         offset = fptr.tell() - 2
 
         read_buffer = fptr.read(3)
-        length, zppm = struct.unpack('>HB', read_buffer)
+        length, zppm = struct.unpack(">HB", read_buffer)
 
         numbytes = length - 3
         read_buffer = fptr.read(numbytes)
@@ -620,7 +637,7 @@ class Codestream(object):
         offset = fptr.tell() - 2
 
         read_buffer = fptr.read(3)
-        length, zppt = struct.unpack('>HB', read_buffer)
+        length, zppt = struct.unpack(">HB", read_buffer)
         length = length
         zppt = zppt
 
@@ -646,15 +663,17 @@ class Codestream(object):
         offset = fptr.tell() - 2
 
         read_buffer = fptr.read(2)
-        length, = struct.unpack('>H', read_buffer)
+        (length,) = struct.unpack(">H", read_buffer)
 
         read_buffer = fptr.read(length - 2)
-        fmt = '>HB' if cls._csiz > 256 else '>BB'
+        fmt = ">HB" if cls._csiz > 256 else ">BB"
         mantissa_exponent_offset = 3 if cls._csiz > 256 else 2
         cqcc, sqcc = struct.unpack_from(fmt, read_buffer)
         if cqcc >= cls._csiz:
-            msg = ("Invalid QCC component number ({cqcc}), "
-                   "the actual number of components is only {cls._csiz}.")
+            msg = (
+                "Invalid QCC component number ({cqcc}), "
+                "the actual number of components is only {cls._csiz}."
+            )
             warnings.warn(msg, UserWarning)
 
         spqcc = read_buffer[mantissa_exponent_offset:]
@@ -677,7 +696,7 @@ class Codestream(object):
         offset = fptr.tell() - 2
 
         read_buffer = fptr.read(3)
-        length, sqcd = struct.unpack('>HB', read_buffer)
+        length, sqcd = struct.unpack(">HB", read_buffer)
         spqcd = fptr.read(length - 3)
 
         return QCDsegment(sqcd, spqcd, length, offset)
@@ -699,10 +718,10 @@ class Codestream(object):
         offset = fptr.tell() - 2
 
         read_buffer = fptr.read(2)
-        length, = struct.unpack('>H', read_buffer)
+        (length,) = struct.unpack(">H", read_buffer)
 
         nbytes = 3 if cls._csiz < 257 else 4
-        fmt = '>BBB' if cls._csiz < 257 else '>HBB'
+        fmt = ">BBB" if cls._csiz < 257 else ">HBB"
         read_buffer = fptr.read(nbytes)
         data = struct.unpack(fmt, read_buffer)
 
@@ -730,16 +749,19 @@ class Codestream(object):
         offset = fptr.tell() - 2
 
         read_buffer = fptr.read(2)
-        length, = struct.unpack('>H', read_buffer)
+        (length,) = struct.unpack(">H", read_buffer)
         read_buffer = fptr.read(length - 2)
 
-        pcap, = struct.unpack('>I', read_buffer[:4])
+        (pcap,) = struct.unpack(">I", read_buffer[:4])
 
         n = (length - 6) // 2
-        ccap = struct.unpack('>' + 'H' * n, read_buffer[4:])
+        ccap = struct.unpack(">" + "H" * n, read_buffer[4:])
 
         segment = CAPsegment(
-            pcap=pcap, ccap=ccap, length=length, offset=offset,
+            pcap=pcap,
+            ccap=ccap,
+            length=length,
+            offset=offset,
         )
 
         return segment
@@ -761,10 +783,10 @@ class Codestream(object):
         offset = fptr.tell() - 2
 
         read_buffer = fptr.read(2)
-        length, = struct.unpack('>H', read_buffer)
+        (length,) = struct.unpack(">H", read_buffer)
 
         read_buffer = fptr.read(length - 2)
-        data = struct.unpack_from('>HIIIIIIIIH', read_buffer)
+        data = struct.unpack_from(">HIIIIIIIIH", read_buffer)
 
         rsiz = data[0]
 
@@ -781,18 +803,20 @@ class Codestream(object):
         # Csiz is the number of components
         Csiz = data[9]
 
-        data = struct.unpack_from('>' + 'B' * (length - 36 - 2),
-                                  read_buffer, offset=36)
+        format = ">" + "B" * (length - 36 - 2)
+        data = struct.unpack_from(format, read_buffer, offset=36)
 
-        bitdepth = tuple(((x & 0x7f) + 1) for x in data[0::3])
+        bitdepth = tuple(((x & 0x7F) + 1) for x in data[0::3])
         signed = tuple(((x & 0x80) > 0) for x in data[0::3])
         xrsiz = data[1::3]
         yrsiz = data[2::3]
 
         for j, subsampling in enumerate(zip(xrsiz, yrsiz)):
             if 0 in subsampling:
-                msg = (f"Invalid subsampling value for component {j}: "
-                       f"dx={subsampling[0]}, dy={subsampling[1]}.")
+                msg = (
+                    f"Invalid subsampling value for component {j}: "
+                    f"dx={subsampling[0]}, dy={subsampling[1]}."
+                )
                 warnings.warn(msg, UserWarning)
 
         try:
@@ -811,17 +835,17 @@ class Codestream(object):
                 warnings.warn(msg, UserWarning)
 
         kwargs = {
-            'rsiz': rsiz,
-            'xysiz': xysiz,
-            'xyosiz': xyosiz,
-            'xytsiz': xytsiz,
-            'xytosiz': xytosiz,
-            'Csiz': Csiz,
-            'bitdepth': bitdepth,
-            'signed': signed,
-            'xyrsiz': (xrsiz, yrsiz),
-            'length': length,
-            'offset': offset
+            "rsiz": rsiz,
+            "xysiz": xysiz,
+            "xyosiz": xyosiz,
+            "xytsiz": xytsiz,
+            "xytosiz": xytosiz,
+            "Csiz": Csiz,
+            "bitdepth": bitdepth,
+            "signed": signed,
+            "xyrsiz": (xrsiz, yrsiz),
+            "length": length,
+            "offset": offset,
         }
         segment = SIZsegment(**kwargs)
 
@@ -865,7 +889,7 @@ class Codestream(object):
         offset = fptr.tell() - 2
 
         read_buffer = fptr.read(10)
-        data = struct.unpack('>HHIBB', read_buffer)
+        data = struct.unpack(">HHIBB", read_buffer)
 
         length = data[0]
         isot = data[1]
@@ -905,21 +929,22 @@ class Codestream(object):
         offset = fptr.tell() - 2
 
         read_buffer = fptr.read(2)
-        length, = struct.unpack('>H', read_buffer)
+        (length,) = struct.unpack(">H", read_buffer)
 
         read_buffer = fptr.read(length - 2)
-        ztlm, stlm = struct.unpack_from('>BB', read_buffer)
+        ztlm, stlm = struct.unpack_from(">BB", read_buffer)
         st = (stlm >> 4) & 0x3
         sp = (stlm >> 6) & 0x1
 
         nbytes = length - 4
         ntiles = nbytes / (st + (sp + 1) * 2)
 
-        fmt = {0: '', 1: 'B', 2: 'H'}[st]
-        fmt += {0: 'H', 1: 'I'}[sp]
+        fmt = {0: "", 1: "B", 2: "H"}[st]
+        fmt += {0: "H", 1: "I"}[sp]
+
+        format = ">" + fmt * int(ntiles)
+        data = struct.unpack_from(format, read_buffer, offset=2)
 
-        data = struct.unpack_from('>' + fmt * int(ntiles), read_buffer,
-                                  offset=2)
         if st == 0:
             ttlm = None
             ptlm = data
@@ -930,9 +955,8 @@ class Codestream(object):
         return TLMsegment(ztlm, ttlm, ptlm, length, offset)
 
     def _parse_reserved_marker(self, fptr):
-        """Marker range between 0xff30 and 0xff39.
-        """
-        the_id = f'0x{self._marker_id:x}'
+        """Marker range between 0xff30 and 0xff39."""
+        the_id = f"0x{self._marker_id:x}"
         segment = Segment(marker_id=the_id, offset=self._offset, length=0)
         return segment
 
@@ -953,15 +977,18 @@ class Segment(object):
         Uninterpreted buffer of raw bytes, only used where a segment is not
         well understood.
     """
-    def __init__(self, marker_id='', offset=-1, length=-1, data=None):
+
+    def __init__(self, marker_id="", offset=-1, length=-1, data=None):
         self.marker_id = marker_id
         self.offset = offset
         self.length = length
         self.data = data
 
     def __str__(self):
-        msg = (f'{self.marker_id} marker segment @ '
-               f'({self.offset}, {self.length})')
+        msg = (
+           f"{self.marker_id} marker segment @ "
+           f"({self.offset}, {self.length})"
+        )
         return msg
 
 
@@ -983,8 +1010,9 @@ class CAPsegment(Segment):
     ccap : 16-bit unsigned int
         The precise meaning depends on the related parts of ISO/IEC 15444-k.
     """
+
     def __init__(self, pcap, ccap, length, offset):
-        super().__init__(marker_id='CAP')
+        super().__init__(marker_id="CAP")
         self.pcap = pcap
         self.ccap = ccap
         self.length = length
@@ -993,17 +1021,18 @@ class CAPsegment(Segment):
     def __str__(self):
         msg = Segment.__str__(self)
 
-        msg += '\n'
+        msg += "\n"
 
         # have to cast to uint64 because, you know, stupid windows
         parts = [
-            k for k in range(32)
+            k
+            for k in range(32)
             if np.bitwise_and(np.uint64(self.pcap), np.uint64(1 << (32 - k)))
         ]
 
         for b in parts:
-            msg += f'    Pcap:  Part {b} (ISO/IEC 15444-{b})\n'
-        msg += f'    Ccap:  {self.ccap}'
+            msg += f"    Pcap:  Part {b} (ISO/IEC 15444-{b})\n"
+        msg += f"    Ccap:  {self.ccap}"
 
         return msg
 
@@ -1035,8 +1064,9 @@ class COCsegment(Segment):
        15444-1:2004 - Information technology -- JPEG 2000 image coding system:
        Core coding system
     """
+
     def __init__(self, ccoc, scoc, spcoc, length, offset):
-        super().__init__(marker_id='COC')
+        super().__init__(marker_id="COC")
         self.ccoc = ccoc
         self.scoc = scoc
         self.spcoc = spcoc
@@ -1054,22 +1084,22 @@ class COCsegment(Segment):
     def __str__(self):
         msg = Segment.__str__(self)
 
-        msg += '\n'
+        msg += "\n"
 
         partition = 0 if self.scoc == 0 else 1
         width = int(self.code_block_size[0])
         height = int(self.code_block_size[1])
         xform = _WAVELET_XFORM_DISPLAY[self.spcoc[4]]
         msg += (
-            f'    Associated component:  {self.ccoc}\n'
-            f'    Coding style for this component:  '
-            f'Entropy coder, PARTITION = {partition}\n'
-            f'    Coding style parameters:\n'
-            f'        Number of decomposition levels:  {self.spcoc[0]}\n'
-            f'        Code block height, width:  ({width} x {height})\n'
-            f'        Wavelet transform:  {xform}\n'
-            f'        Precinct size:  {self.precinct_size.tolist()}\n'
-            f'        {_context_string(self.spcoc[3])}'
+            f"    Associated component:  {self.ccoc}\n"
+            f"    Coding style for this component:  "
+            f"Entropy coder, PARTITION = {partition}\n"
+            f"    Coding style parameters:\n"
+            f"        Number of decomposition levels:  {self.spcoc[0]}\n"
+            f"        Code block height, width:  ({width} x {height})\n"
+            f"        Wavelet transform:  {xform}\n"
+            f"        Precinct size:  {self.precinct_size.tolist()}\n"
+            f"        {_context_string(self.spcoc[3])}"
         )
 
         return msg
@@ -1115,9 +1145,23 @@ class CODsegment(Segment):
         pargs = (scod, prog, nlayers, mct, nr, xcb, ycb, cstyle, xform,
                  precinct_size)
     """
-    def __init__(self, scod, prog_order, num_layers, mct, nr, xcb, ycb,
-                 cstyle, xform, precinct_size, length=0, offset=0):
-        super().__init__(marker_id='COD')
+
+    def __init__(
+        self,
+        scod,
+        prog_order,
+        num_layers,
+        mct,
+        nr,
+        xcb,
+        ycb,
+        cstyle,
+        xform,
+        precinct_size,
+        length=0,
+        offset=0,
+    ):
+        super().__init__(marker_id="COD")
         self.scod = scod
         self.length = length
         self.offset = offset
@@ -1138,57 +1182,58 @@ class CODsegment(Segment):
             warnings.warn(msg, UserWarning)
         self.prog_order = prog_order
 
-        if xform not in [WAVELET_XFORM_9X7_IRREVERSIBLE,
-                         WAVELET_XFORM_5X3_REVERSIBLE]:
+        if xform not in [
+            WAVELET_XFORM_9X7_IRREVERSIBLE, WAVELET_XFORM_5X3_REVERSIBLE
+        ]:
             msg = f"Invalid wavelet transform in COD segment: {xform}."
             warnings.warn(msg, UserWarning)
 
-        self.code_block_size = 4 * 2 ** ycb, 4 * 2 ** xcb
+        self.code_block_size = 4 * 2**ycb, 4 * 2**xcb
 
         if precinct_size is None:
-            self.precinct_size = np.array(((2 ** 15, 2 ** 15)))
+            self.precinct_size = np.array(((2**15, 2**15)))
         else:
             self.precinct_size = np.array(precinct_size)
 
     def __str__(self):
         msg = Segment.__str__(self)
 
-        msg += '\n'
+        msg += "\n"
         msg += (
-            '    Coding style:\n'
-            '        Entropy coder, {with_without} partitions\n'
-            '        SOP marker segments:  {sop}\n'
-            '        EPH marker segments:  {eph}\n'
-            '    Coding style parameters:\n'
-            '        Progression order:  {prog}\n'
-            '        Number of layers:  {num_layers}\n'
-            '        Multiple component transformation usage:  {mct}\n'
-            '        Number of decomposition levels:  {num_dlevels}\n'
-            '        Code block height, width:  ({cbh} x {cbw})\n'
-            '        Wavelet transform:  {xform}\n'
-            '        Precinct size:  {precinct_size}\n'
-            '        {code_block_context}'
+            "    Coding style:\n"
+            "        Entropy coder, {with_without} partitions\n"
+            "        SOP marker segments:  {sop}\n"
+            "        EPH marker segments:  {eph}\n"
+            "    Coding style parameters:\n"
+            "        Progression order:  {prog}\n"
+            "        Number of layers:  {num_layers}\n"
+            "        Multiple component transformation usage:  {mct}\n"
+            "        Number of decomposition levels:  {num_dlevels}\n"
+            "        Code block height, width:  ({cbh} x {cbw})\n"
+            "        Wavelet transform:  {xform}\n"
+            "        Precinct size:  {precinct_size}\n"
+            "        {code_block_context}"
         )
 
         if self.mct == 0:
-            mct_str = 'no transform specified'
+            mct_str = "no transform specified"
         elif self.mct & 0x01:
-            mct_str = 'reversible'
+            mct_str = "reversible"
         elif self.mct & 0x02:
-            mct_str = 'irreversible'
+            mct_str = "irreversible"
         else:
-            mct_str = 'unknown'
+            mct_str = "unknown"
 
         try:
             progression_order = _PROGRESSION_ORDER_DISPLAY[self.prog_order]
         except KeyError:
-            progression_order = f'{self.prog_order} (invalid)'
+            progression_order = f"{self.prog_order} (invalid)"
         try:
             xform = _WAVELET_XFORM_DISPLAY[self.xform]
         except KeyError:
-            xform = f'{self.xform} (invalid)'
+            xform = f"{self.xform} (invalid)"
         msg = msg.format(
-            with_without='with' if (self.scod & 1) else 'without',
+            with_without="with" if (self.scod & 1) else "without",
             sop=((self.scod & 2) > 0),
             eph=((self.scod & 4) > 0),
             prog=progression_order,
@@ -1199,7 +1244,7 @@ class CODsegment(Segment):
             cbw=int(self.code_block_size[1]),
             xform=xform,
             precinct_size=self.precinct_size.tolist(),
-            code_block_context=_context_string(self.cstyle)
+            code_block_context=_context_string(self.cstyle),
         )
 
         return msg
@@ -1229,18 +1274,19 @@ class CMEsegment(Segment):
        15444-1:2004 - Information technology -- JPEG 2000 image coding system:
        Core coding system
     """
+
     def __init__(self, rcme, ccme, length=-1, offset=-1):
-        super().__init__(marker_id='CME')
+        super().__init__(marker_id="CME")
         self.rcme = rcme
         self.ccme = ccme
         self.length = length
         self.offset = offset
 
     def __str__(self):
-        msg = Segment.__str__(self) + '\n'
+        msg = Segment.__str__(self) + "\n"
         if self.rcme == 1:
             # latin-1 string
-            msg += '    "{ccme}"'.format(ccme=self.ccme.decode('latin-1'))
+            msg += '    "{ccme}"'.format(ccme=self.ccme.decode("latin-1"))
         else:
             msg += "    binary data (rcme = {rcme}):  {nbytes} bytes"
             msg = msg.format(rcme=self.rcme, nbytes=len(self.ccme))
@@ -1262,8 +1308,9 @@ class CRGsegment(Segment):
     xcrg, ycrg : int sequences
         Horizontal, vertical offset for each component
     """
+
     def __init__(self, xcrg, ycrg, length, offset):
-        super().__init__(marker_id='CRG')
+        super().__init__(marker_id="CRG")
         self.xcrg = xcrg
         self.ycrg = ycrg
         self.length = length
@@ -1271,9 +1318,9 @@ class CRGsegment(Segment):
 
     def __str__(self):
         msg = Segment.__str__(self)
-        msg += '\n    Vertical, Horizontal offset: '
+        msg += "\n    Vertical, Horizontal offset: "
         for j in range(len(self.xcrg)):
-            msg += ' ({0:.2f}, {1:.2f})'.format(
+            msg += " ({0:.2f}, {1:.2f})".format(
                 self.ycrg[j] / 65535.0, self.xcrg[j] / 65535.0
             )
         return msg
@@ -1299,8 +1346,9 @@ class EOCsegment(Segment):
        15444-1:2004 - Information technology -- JPEG 2000 image coding system:
        Core coding system
     """
+
     def __init__(self, length, offset):
-        super().__init__(marker_id='EOC')
+        super().__init__(marker_id="EOC")
         self.length = length
         self.offset = offset
 
@@ -1336,8 +1384,9 @@ class PODsegment(Segment):
        15444-1:2004 - Information technology -- JPEG 2000 image coding system:
        Core coding system
     """
+
     def __init__(self, pod_params, length, offset):
-        super().__init__(marker_id='POD')
+        super().__init__(marker_id="POD")
 
         self.rspod = pod_params[0::6]
         self.cspod = pod_params[1::6]
@@ -1350,21 +1399,23 @@ class PODsegment(Segment):
 
     def __str__(self):
         msg = Segment.__str__(self)
-        msg += '\n'
-
-        submsg = ('    Progression change {0}:\n'
-                  '        Resolution index start:  {1}\n'
-                  '        Component index start:  {2}\n'
-                  '        Layer index end:  {3}\n'
-                  '        Resolution index end:  {4}\n'
-                  '        Component index end:  {5}\n'
-                  '        Progression order:  {6}\n')
+        msg += "\n"
+
+        submsg = (
+            "    Progression change {0}:\n"
+            "        Resolution index start:  {1}\n"
+            "        Component index start:  {2}\n"
+            "        Layer index end:  {3}\n"
+            "        Resolution index end:  {4}\n"
+            "        Component index end:  {5}\n"
+            "        Progression order:  {6}\n"
+        )
         for j in range(len(self.rspod)):
 
             try:
                 progorder = _PROGRESSION_ORDER_DISPLAY[self.ppod[j]]
             except KeyError:
-                progorder = f'invalid value: {self.ppod[j]}'
+                progorder = f"invalid value: {self.ppod[j]}"
 
             msg += submsg.format(
                 j,
@@ -1373,7 +1424,7 @@ class PODsegment(Segment):
                 self.lyepod[j],
                 self.repod[j],
                 self.cdpod[j],
-                progorder
+                progorder,
             )
 
         return msg.rstrip()
@@ -1402,8 +1453,9 @@ class PLTsegment(Segment):
        15444-1:2004 - Information technology -- JPEG 2000 image coding system:
        Core coding system
     """
+
     def __init__(self, zplt, iplt, length, offset):
-        super().__init__(marker_id='PLT')
+        super().__init__(marker_id="PLT")
         self.zplt = zplt
         self.iplt = iplt
         self.length = length
@@ -1411,10 +1463,7 @@ class PLTsegment(Segment):
 
     def __str__(self):
         msg = Segment.__str__(self)
-        msg += (
-            f"\n    Index:  {self.zplt}"
-            f"\n    Iplt:  {self.iplt}"
-        )
+        msg += f"\n    Index:  {self.zplt}" f"\n    Iplt:  {self.iplt}"
 
         return msg
 
@@ -1440,8 +1489,9 @@ class PPMsegment(Segment):
        15444-1:2004 - Information technology -- JPEG 2000 image coding system:
        Core coding system
     """
+
     def __init__(self, zppm, data, length, offset):
-        super().__init__(marker_id='PPM')
+        super().__init__(marker_id="PPM")
         self.zppm = zppm
 
         # both Nppm and Ippms information stored in data
@@ -1453,8 +1503,8 @@ class PPMsegment(Segment):
     def __str__(self):
         msg = Segment.__str__(self)
         msg += (
-            f'\n    Index:  {self.zppm}'
-            f'\n    Data:  {len(self.data)} uninterpreted bytes'
+            f"\n    Index:  {self.zppm}"
+            f"\n    Data:  {len(self.data)} uninterpreted bytes"
         )
         return msg
 
@@ -1482,8 +1532,9 @@ class PPTsegment(Segment):
        15444-1:2004 - Information technology -- JPEG 2000 image coding system:
        Core coding system
     """
+
     def __init__(self, zppt, ippt, length, offset):
-        super().__init__(marker_id='PPT')
+        super().__init__(marker_id="PPT")
         self.zppt = zppt
         self.ippt = ippt
         self.length = length
@@ -1492,8 +1543,8 @@ class PPTsegment(Segment):
     def __str__(self):
         msg = Segment.__str__(self)
         msg += (
-            f'\n    Index:  {self.zppt}'
-            f'\n    Packet headers:  {len(self.ippt)} uninterpreted bytes'
+            f"\n    Index:  {self.zppt}"
+            f"\n    Packet headers:  {len(self.ippt)} uninterpreted bytes"
         )
         return msg
 
@@ -1527,27 +1578,27 @@ class QCCsegment(Segment):
        15444-1:2004 - Information technology -- JPEG 2000 image coding system:
        Core coding system
     """
+
     def __init__(self, cqcc, sqcc, spqcc, length, offset):
-        super().__init__(marker_id='QCC')
+        super().__init__(marker_id="QCC")
         self.cqcc = cqcc
         self.sqcc = sqcc
         self.spqcc = spqcc
         self.length = length
         self.offset = offset
 
-        self.mantissa, self.exponent = parse_quantization(self.spqcc,
-                                                          self.sqcc)
-        self.guard_bits = (self.sqcc & 0xe0) >> 5
+        self.mantissa, self.exponent = parse_quantization(self.spqcc, self.sqcc)
+        self.guard_bits = (self.sqcc & 0xE0) >> 5
 
     def __str__(self):
         msg = Segment.__str__(self)
 
-        msg += f'\n    Associated Component:  {self.cqcc}'
+        msg += f"\n    Associated Component:  {self.cqcc}"
         msg += _print_quantization_style(self.sqcc)
-        msg += f'{self.guard_bits} guard bits'
+        msg += f"{self.guard_bits} guard bits"
 
         step_size = zip(self.mantissa, self.exponent)
-        msg += '\n    Step size:  ' + str(list(step_size))
+        msg += "\n    Step size:  " + str(list(step_size))
         return msg
 
 
@@ -1578,8 +1629,9 @@ class QCDsegment(Segment):
        15444-1:2004 - Information technology -- JPEG 2000 image coding system:
        Core coding system
     """
+
     def __init__(self, sqcd, spqcd, length, offset):
-        super().__init__(marker_id='QCD')
+        super().__init__(marker_id="QCD")
 
         self.sqcd = sqcd
         self.spqcd = spqcd
@@ -1589,17 +1641,17 @@ class QCDsegment(Segment):
         mantissa, exponent = parse_quantization(self.spqcd, self.sqcd)
         self.mantissa = mantissa
         self.exponent = exponent
-        self.guard_bits = (self.sqcd & 0xe0) >> 5
+        self.guard_bits = (self.sqcd & 0xE0) >> 5
 
     def __str__(self):
         msg = Segment.__str__(self)
 
         msg += _print_quantization_style(self.sqcd)
 
-        msg += f'{self.guard_bits} guard bits'
+        msg += f"{self.guard_bits} guard bits"
 
         step_size = zip(self.mantissa, self.exponent)
-        msg += '\n    Step size:  ' + str(list(step_size))
+        msg += "\n    Step size:  " + str(list(step_size))
         return msg
 
 
@@ -1628,8 +1680,9 @@ class RGNsegment(Segment):
        15444-1:2004 - Information technology -- JPEG 2000 image coding system:
        Core coding system
     """
+
     def __init__(self, crgn, srgn, sprgn, length=-1, offset=-1):
-        super().__init__(marker_id='RGN')
+        super().__init__(marker_id="RGN")
         self.length = length
         self.offset = offset
         self.crgn = crgn
@@ -1640,9 +1693,9 @@ class RGNsegment(Segment):
         msg = Segment.__str__(self)
 
         msg += (
-            f'\n    Associated component:  {self.crgn}'
-            f'\n    ROI style:  {self.srgn}'
-            f'\n    Parameter:  {self.sprgn}'
+            f"\n    Associated component:  {self.crgn}"
+            f"\n    ROI style:  {self.srgn}"
+            f"\n    Parameter:  {self.sprgn}"
         )
 
         return msg
@@ -1686,10 +1739,22 @@ class SIZsegment(Segment):
        15444-1:2004 - Information technology -- JPEG 2000 image coding system:
        Core coding system
     """
-    def __init__(self, rsiz=-1, xysiz=None, xyosiz=-1, xytsiz=-1, xytosiz=-1,
-                 Csiz=-1, bitdepth=None, signed=None, xyrsiz=-1, length=-1,
-                 offset=-1):
-        super().__init__(marker_id='SIZ', length=length, offset=offset)
+
+    def __init__(
+        self,
+        rsiz=-1,
+        xysiz=None,
+        xyosiz=-1,
+        xytsiz=-1,
+        xytosiz=-1,
+        Csiz=-1,
+        bitdepth=None,
+        signed=None,
+        xyrsiz=-1,
+        length=-1,
+        offset=-1,
+    ):
+        super().__init__(marker_id="SIZ", length=length, offset=offset)
 
         self.rsiz = rsiz
         self.xsiz, self.ysiz = xysiz
@@ -1727,36 +1792,40 @@ class SIZsegment(Segment):
 
     def __str__(self):
         msg = Segment.__str__(self)
-        msg += '\n'
+        msg += "\n"
 
         msg += (
-            '    Profile:  {profile}\n'
-            '    Reference Grid Height, Width:  ({height} x {width})\n'
-            '    Vertical, Horizontal Reference Grid Offset:  ({goy} x {gox})\n'  # noqa : E501
-            '    Reference Tile Height, Width:  ({tileh} x {tilew})\n'
-            '    Vertical, Horizontal Reference Tile Offset:  ({toy} x {tox})\n'  # noqa : E501
-            '    Bitdepth:  {bitdepth}\n'
-            '    Signed:  {signed}\n'
-            '    Vertical, Horizontal Subsampling:  {subsampling}'
+            "    Profile:  {profile}\n"
+            "    Reference Grid Height, Width:  ({height} x {width})\n"
+            "    Vertical, Horizontal Reference Grid Offset:  ({goy} x {gox})\n"  # noqa : E501
+            "    Reference Tile Height, Width:  ({tileh} x {tilew})\n"
+            "    Vertical, Horizontal Reference Tile Offset:  ({toy} x {tox})\n"  # noqa : E501
+            "    Bitdepth:  {bitdepth}\n"
+            "    Signed:  {signed}\n"
+            "    Vertical, Horizontal Subsampling:  {subsampling}"
         )
         try:
             profile = _CAPABILITIES_DISPLAY[self.rsiz]
         except KeyError:
             if np.bitwise_and(self.rsiz, 16384):
                 # HTJ2K profile that is uninterpreted
-                profile = f'{self.rsiz}'
+                profile = f"{self.rsiz}"
             else:
                 # profile unknown
-                profile = f'{self.rsiz} (invalid)'
+                profile = f"{self.rsiz} (invalid)"
         msg = msg.format(
             profile=profile,
-            height=self.ysiz, width=self.xsiz,
-            goy=self.yosiz, gox=self.xosiz,
-            tileh=self.ytsiz, tilew=self.xtsiz,
-            toy=self.ytosiz, tox=self.xtosiz,
+            height=self.ysiz,
+            width=self.xsiz,
+            goy=self.yosiz,
+            gox=self.xosiz,
+            tileh=self.ytsiz,
+            tilew=self.xtsiz,
+            toy=self.ytosiz,
+            tox=self.xtosiz,
             bitdepth=self.bitdepth,
             signed=self.signed,
-            subsampling=tuple(zip(self.yrsiz, self.xrsiz))
+            subsampling=tuple(zip(self.yrsiz, self.xrsiz)),
         )
 
         return msg
@@ -1782,8 +1851,9 @@ class SOCsegment(Segment):
        15444-1:2004 - Information technology -- JPEG 2000 image coding system:
        Core coding system
     """
+
     def __init__(self, **kwargs):
-        super().__init__(marker_id='SOC')
+        super().__init__(marker_id="SOC")
         self.__dict__.update(**kwargs)
 
     def __repr__(self):
@@ -1811,8 +1881,9 @@ class SODsegment(Segment):
        15444-1:2004 - Information technology -- JPEG 2000 image coding system:
        Core coding system
     """
+
     def __init__(self, length, offset):
-        super().__init__(marker_id='SOD')
+        super().__init__(marker_id="SOD")
         self.length = length
         self.offset = offset
 
@@ -1837,8 +1908,9 @@ class EPHsegment(Segment):
        15444-1:2004 - Information technology -- JPEG 2000 image coding system:
        Core coding system
     """
+
     def __init__(self, length, offset):
-        super().__init__(marker_id='EPH')
+        super().__init__(marker_id="EPH")
         self.length = length
         self.offset = offset
 
@@ -1864,15 +1936,16 @@ class SOPsegment(Segment):
        15444-1:2004 - Information technology -- JPEG 2000 image coding system:
        Core coding system
     """
+
     def __init__(self, nsop, length, offset):
-        super().__init__(marker_id='SOP')
+        super().__init__(marker_id="SOP")
         self.nsop = nsop
         self.length = length
         self.offset = offset
 
     def __str__(self):
         msg = Segment.__str__(self)
-        msg += f'\n    Nsop:  {self.nsop}'
+        msg += f"\n    Nsop:  {self.nsop}"
         return msg
 
 
@@ -1904,8 +1977,9 @@ class SOTsegment(Segment):
        15444-1:2004 - Information technology -- JPEG 2000 image coding system:
        Core coding system
     """
+
     def __init__(self, isot, psot, tpsot, tnsot, length=-1, offset=-1):
-        super().__init__(marker_id='SOT')
+        super().__init__(marker_id="SOT")
         self.isot = isot
         self.psot = psot
         self.tpsot = tpsot
@@ -1916,10 +1990,10 @@ class SOTsegment(Segment):
     def __str__(self):
         msg = Segment.__str__(self)
         msg += (
-            f'\n    Tile part index:  {self.isot}'
-            f'\n    Tile part length:  {self.psot}'
-            f'\n    Tile part instance:  {self.tpsot}'
-            f'\n    Number of tile parts:  {self.tnsot}'
+            f"\n    Tile part index:  {self.isot}"
+            f"\n    Tile part length:  {self.psot}"
+            f"\n    Tile part instance:  {self.tpsot}"
+            f"\n    Number of tile parts:  {self.tnsot}"
         )
         return msg
 
@@ -1950,8 +2024,9 @@ class TLMsegment(Segment):
        15444-1:2004 - Information technology -- JPEG 2000 image coding system:
        Core coding system
     """
+
     def __init__(self, ztlm, ttlm, ptlm, length, offset):
-        super().__init__(marker_id='TLM')
+        super().__init__(marker_id="TLM")
         self.length = length
         self.offset = offset
         self.ztlm = ztlm
@@ -1962,9 +2037,9 @@ class TLMsegment(Segment):
         msg = Segment.__str__(self)
         with np.printoptions(threshold=4):
             msg += (
-                f'\n    Index:  {self.ztlm}'
-                f'\n    Tile number:  {self.ttlm}'
-                f'\n    Length:  {self.ptlm}'
+                f"\n    Index:  {self.ztlm}"
+                f"\n    Tile number:  {self.ttlm}"
+                f"\n    Length:  {self.ptlm}"
             )
 
         return msg
@@ -1977,27 +2052,29 @@ def _parse_precinct_size(spcod):
     for item in spcod:
         ep2 = (item & 0xF0) >> 4
         ep1 = item & 0x0F
-        precinct_size.append((2 ** ep1, 2 ** ep2))
+        precinct_size.append((2**ep1, 2**ep2))
     return np.array(precinct_size)
 
 
 def _context_string(context):
     """Produce a string to represent the code block context"""
-    msg = 'Code block context:\n            '
-    lines = ['Selective arithmetic coding bypass:  {0}',
-             'Reset context probabilities on coding pass boundaries:  {1}',
-             'Termination on each coding pass:  {2}',
-             'Vertically stripe causal context:  {3}',
-             'Predictable termination:  {4}',
-             'Segmentation symbols:  {5}']
-    msg += '\n            '.join(lines)
+    msg = "Code block context:\n            "
+    lines = [
+        "Selective arithmetic coding bypass:  {0}",
+        "Reset context probabilities on coding pass boundaries:  {1}",
+        "Termination on each coding pass:  {2}",
+        "Vertically stripe causal context:  {3}",
+        "Predictable termination:  {4}",
+        "Segmentation symbols:  {5}",
+    ]
+    msg += "\n            ".join(lines)
     msg = msg.format(
         ((context & 0x01) > 0),
         ((context & 0x02) > 0),
         ((context & 0x04) > 0),
         ((context & 0x08) > 0),
         ((context & 0x10) > 0),
-        ((context & 0x20) > 0)
+        ((context & 0x20) > 0),
     )
     return msg
 
@@ -2019,17 +2096,17 @@ def parse_quantization(read_buffer, sqcd):
     exponent = []
     mantissa = []
 
-    if sqcd & 0x1f == 0:  # no quantization
-        data = struct.unpack('>' + 'B' * numbytes, read_buffer)
+    if sqcd & 0x1F == 0:  # no quantization
+        data = struct.unpack(">" + "B" * numbytes, read_buffer)
         for j in range(len(data)):
             exponent.append(data[j] >> 3)
             mantissa.append(0)
     else:
-        fmt = '>' + 'H' * int(numbytes / 2)
+        fmt = ">" + "H" * int(numbytes / 2)
         data = struct.unpack(fmt, read_buffer)
         for j in range(len(data)):
             exponent.append(data[j] >> 11)
-            mantissa.append(data[j] & 0x07ff)
+            mantissa.append(data[j] & 0x07FF)
 
     return mantissa, exponent
 
@@ -2037,11 +2114,11 @@ def parse_quantization(read_buffer, sqcd):
 def _print_quantization_style(sqcc):
     """Only to be used with QCC and QCD segments."""
 
-    msg = '\n    Quantization style:  '
-    if sqcc & 0x1f == 0:
-        msg += 'no quantization, '
-    elif sqcc & 0x1f == 1:
-        msg += 'scalar implicit, '
-    elif sqcc & 0x1f == 2:
-        msg += 'scalar explicit, '
+    msg = "\n    Quantization style:  "
+    if sqcc & 0x1F == 0:
+        msg += "no quantization, "
+    elif sqcc & 0x1F == 1:
+        msg += "scalar implicit, "
+    elif sqcc & 0x1F == 2:
+        msg += "scalar explicit, "
     return msg