dmg-builder 26.0.17 → 26.0.18

package/vendor/ds_store/store.py

@@ -1,48 +1,36 @@
-# -*- coding: utf-8 -*-
-from __future__ import unicode_literals
-from __future__ import print_function
-from __future__ import division
-
-import binascii
+import plistlib
 import struct
-import biplist
-import mac_alias
 
-try:
-    next
-except NameError:
-    next = lambda x: x.next()
-try:
-    unicode
-except NameError:
-    unicode = str
+import mac_alias
 
 from . import buddy
 
-class ILocCodec(object):
+
+class ILocCodec:
     @staticmethod
     def encode(point):
-        return struct.pack(b'>IIII', point[0], point[1],
-                           0xffffffff, 0xffff0000)
+        return struct.pack(b">IIII", point[0], point[1], 0xFFFFFFFF, 0xFFFF0000)
 
     @staticmethod
     def decode(bytesData):
         if isinstance(bytesData, bytearray):
-            x, y = struct.unpack_from(b'>II', bytes(bytesData[:8]))
+            x, y = struct.unpack_from(b">II", bytes(bytesData[:8]))
         else:
-            x, y = struct.unpack(b'>II', bytesData[:8])
+            x, y = struct.unpack(b">II", bytesData[:8])
         return (x, y)
 
-class PlistCodec(object):
+
+class PlistCodec:
     @staticmethod
     def encode(plist):
-        return biplist.writePlistToString(plist)
+        return plistlib.dumps(plist, fmt=plistlib.FMT_BINARY)
 
     @staticmethod
     def decode(bytes):
-        return biplist.readPlistFromString(bytes)
+        return plistlib.loads(bytes)
 
-class BookmarkCodec(object):
+
+class BookmarkCodec:
     @staticmethod
     def encode(bmk):
         return bmk.to_bytes()
@@ -51,70 +39,73 @@ class BookmarkCodec(object):
     def decode(bytes):
         return mac_alias.Bookmark.from_bytes(bytes)
 
+
 # This list tells the code how to decode particular kinds of entry in the
 # .DS_Store file.  This is really a convenience, and we currently only
 # support a tiny subset of the possible entry types.
 codecs = {
-    b'Iloc': ILocCodec,
-    b'bwsp': PlistCodec,
-    b'lsvp': PlistCodec,
-    b'lsvP': PlistCodec,
-    b'icvp': PlistCodec,
-    b'pBBk': BookmarkCodec
-    }
-
-class DSStoreEntry(object):
+    b"Iloc": ILocCodec,
+    b"bwsp": PlistCodec,
+    b"lsvp": PlistCodec,
+    b"lsvP": PlistCodec,
+    b"icvp": PlistCodec,
+    b"pBBk": BookmarkCodec,
+}
+
+
+class DSStoreEntry:
     """Holds the data from an entry in a ``.DS_Store`` file.  Note that this is
-    not meant to represent the entry itself---i.e. if you change the type
-    or value, your changes will *not* be reflected in the underlying file.
+    not meant to represent the entry itself---i.e. if you change the type or
+    value, your changes will *not* be reflected in the underlying file.
 
-    If you want to make a change, you should either use the :class:`DSStore`
-    object's :meth:`DSStore.insert` method (which will replace a key if it
-    already exists), or the mapping access mode for :class:`DSStore` (often
-    simpler anyway).
+    If you want to make a change, you should either use the
+    :class:`DSStore` object's :meth:`DSStore.insert` method (which will
+    replace a key if it already exists), or the mapping access mode for
+    :class:`DSStore` (often simpler anyway).
     """
+
     def __init__(self, filename, code, typecode, value=None):
         if str != bytes and type(filename) == bytes:
-            filename = filename.decode('utf-8')
+            filename = filename.decode("utf-8")
 
         if not isinstance(code, bytes):
-            code = code.encode('latin_1')
+            code = code.encode("latin_1")
 
         self.filename = filename
         self.code = code
         self.type = typecode
         self.value = value
-        
+
     @classmethod
     def read(cls, block):
-        """Read a ``.DS_Store`` entry from the containing Block"""
+        """Read a ``.DS_Store`` entry from the containing Block."""
         # First read the filename
-        nlen = block.read(b'>I')[0]
-        filename = block.read(2 * nlen).decode('utf-16be')
+        nlen = block.read(b">I")[0]
+        filename = block.read(2 * nlen).decode("utf-16be")
 
         # Next, read the code and type
-        code, typecode = block.read(b'>4s4s')
+        code, typecode = block.read(b">4s4s")
 
         # Finally, read the data
-        if typecode == b'bool':
-            value = block.read(b'>?')[0]
-        elif typecode == b'long' or typecode == b'shor':
-            value = block.read(b'>I')[0]
-        elif typecode == b'blob':
-            vlen = block.read(b'>I')[0]
+        if typecode == b"bool":
+            value = block.read(b">?")[0]
+        elif typecode == b"long" or typecode == b"shor":
+            value = block.read(b">I")[0]
+        elif typecode == b"blob":
+            vlen = block.read(b">I")[0]
             value = block.read(vlen)
 
             codec = codecs.get(code, None)
             if codec:
                 value = codec.decode(value)
                 typecode = codec
-        elif typecode == b'ustr':
-            vlen = block.read(b'>I')[0]
-            value = block.read(2 * vlen).decode('utf-16be')
-        elif typecode == b'type':
-            value = block.read(b'>4s')[0]
-        elif typecode == b'comp' or typecode == b'dutc':
-            value = block.read(b'>Q')[0]
+        elif typecode == b"ustr":
+            vlen = block.read(b">I")[0]
+            value = block.read(2 * vlen).decode("utf-16be")
+        elif typecode == b"type":
+            value = block.read(b">4s")[0]
+        elif typecode == b"comp" or typecode == b"dutc":
+            value = block.read(b">Q")[0]
         else:
             raise ValueError('Unknown type code "%s"' % typecode)
 
@@ -122,152 +113,138 @@ class DSStoreEntry(object):
 
     def __lt__(self, other):
         if not isinstance(other, DSStoreEntry):
-            raise TypeError('Can only compare against other DSStoreEntry objects')
+            raise TypeError("Can only compare against other DSStoreEntry objects")
         sfl = self.filename.lower()
         ofl = other.filename.lower()
-        return (sfl < ofl
-                or (self.filename == other.filename
-                    and self.code < other.code))
+        return sfl < ofl or (self.filename == other.filename and self.code < other.code)
 
     def __le__(self, other):
         if not isinstance(other, DSStoreEntry):
-            raise TypeError('Can only compare against other DSStoreEntry objects')
+            raise TypeError("Can only compare against other DSStoreEntry objects")
         sfl = self.filename.lower()
         ofl = other.filename.lower()
-        return (sfl < ofl
-                or (sfl == ofl
-                    and self.code <= other.code))
+        return sfl < ofl or (sfl == ofl and self.code <= other.code)
 
     def __eq__(self, other):
         if not isinstance(other, DSStoreEntry):
-            raise TypeError('Can only compare against other DSStoreEntry objects')
+            raise TypeError("Can only compare against other DSStoreEntry objects")
         sfl = self.filename.lower()
         ofl = other.filename.lower()
-        return (sfl == ofl
-                and self.code == other.code)
+        return sfl == ofl and self.code == other.code
 
     def __ne__(self, other):
         if not isinstance(other, DSStoreEntry):
-            raise TypeError('Can only compare against other DSStoreEntry objects')
+            raise TypeError("Can only compare against other DSStoreEntry objects")
         sfl = self.filename.lower()
         ofl = other.filename.lower()
-        return (sfl != ofl
-                or self.code != other.code)
+        return sfl != ofl or self.code != other.code
 
     def __gt__(self, other):
         if not isinstance(other, DSStoreEntry):
-            raise TypeError('Can only compare against other DSStoreEntry objects')
+            raise TypeError("Can only compare against other DSStoreEntry objects")
         sfl = self.filename.lower()
         ofl = other.filename.lower()
-        
+
         selfCode = self.code
         if str != bytes and type(selfCode) is bytes:
-            selfCode = selfCode.decode('utf-8')
+            selfCode = selfCode.decode("utf-8")
         otherCode = other.code
         if str != bytes and type(otherCode) is bytes:
-            otherCode = otherCode.decode('utf-8')
-        
-        return (sfl > ofl or (sfl == ofl and selfCode > otherCode))
+            otherCode = otherCode.decode("utf-8")
+
+        return sfl > ofl or (sfl == ofl and selfCode > otherCode)
 
     def __ge__(self, other):
         if not isinstance(other, DSStoreEntry):
-            raise TypeError('Can only compare against other DSStoreEntry objects')
+            raise TypeError("Can only compare against other DSStoreEntry objects")
         sfl = self.filename.lower()
         ofl = other.filename.lower()
-        return (sfl > ofl
-                or (sfl == ofl
-                    and self.code >= other.code))
+        return sfl > ofl or (sfl == ofl and self.code >= other.code)
 
-    def __cmp__(self, other):
-        if not isinstance(other, DSStoreEntry):
-            raise TypeError('Can only compare against other DSStoreEntry objects')
-        r = cmp(self.filename.lower(), other.filename.lower())
-        if r:
-            return r
-        return cmp(self.code, other.code)
-    
     def byte_length(self):
-        """Compute the length of this entry, in bytes"""
-        utf16 = self.filename.encode('utf-16be')
-        l = 4 + len(utf16) + 8
+        """Compute the length of this entry, in bytes."""
+        utf16 = self.filename.encode("utf-16be")
+        length = 4 + len(utf16) + 8
 
-        if isinstance(self.type, unicode):
-            entry_type = self.type.encode('latin_1')
+        if isinstance(self.type, str):
+            entry_type = self.type.encode("latin_1")
             value = self.value
         elif isinstance(self.type, (bytes, str)):
             entry_type = self.type
             value = self.value
         else:
-            entry_type = b'blob'
+            entry_type = b"blob"
             value = self.type.encode(self.value)
-            
-        if entry_type == b'bool':
-            l += 1
-        elif entry_type == b'long' or entry_type == b'shor':
-            l += 4
-        elif entry_type == b'blob':
-            l += 4 + len(value)
-        elif entry_type == b'ustr':
-            utf16 = value.encode('utf-16be')
-            l += 4 + len(utf16)
-        elif entry_type == b'type':
-            l += 4
-        elif entry_type == b'comp' or entry_type == b'dutc':
-            l += 8
+
+        if entry_type == b"bool":
+            length += 1
+        elif entry_type == b"long" or entry_type == b"shor":
+            length += 4
+        elif entry_type == b"blob":
+            length += 4 + len(value)
+        elif entry_type == b"ustr":
+            utf16 = value.encode("utf-16be")
+            length += 4 + len(utf16)
+        elif entry_type == b"type":
+            length += 4
+        elif entry_type == b"comp" or entry_type == b"dutc":
+            length += 8
         else:
             raise ValueError('Unknown type code "%s"' % entry_type)
 
-        return l
-    
+        return length
+
     def write(self, block, insert=False):
-        """Write this entry to the specified Block"""
+        """Write this entry to the specified Block."""
         if insert:
             w = block.insert
         else:
             w = block.write
 
-        if isinstance(self.type, unicode):
-            entry_type = self.type.encode('latin_1')
+        if isinstance(self.type, str):
+            entry_type = self.type.encode("latin_1")
             value = self.value
         elif isinstance(self.type, (bytes, str)):
             entry_type = self.type
             value = self.value
         else:
-            entry_type = b'blob'
+            entry_type = b"blob"
             value = self.type.encode(self.value)
 
-        utf16 = self.filename.encode('utf-16be')
-        w(b'>I', len(utf16) // 2)
+        utf16 = self.filename.encode("utf-16be")
+        w(b">I", len(utf16) // 2)
         w(utf16)
-        w(b'>4s4s', self.code, entry_type)
-
-        if entry_type == b'bool':
-            w(b'>?', value)
-        elif entry_type == b'long' or entry_type == b'shor':
-            w(b'>I', value)
-        elif entry_type == b'blob':
-            w(b'>I', len(value))
+        w(b">4s4s", self.code, entry_type)
+
+        if entry_type == b"bool":
+            w(b">?", value)
+        elif entry_type == b"long" or entry_type == b"shor":
+            w(b">I", value)
+        elif entry_type == b"blob":
+            w(b">I", len(value))
             w(value)
-        elif entry_type == b'ustr':
-            utf16 = value.encode('utf-16be')
-            w(b'>I', len(utf16) // 2)
+        elif entry_type == b"ustr":
+            utf16 = value.encode("utf-16be")
+            w(b">I", len(utf16) // 2)
             w(utf16)
-        elif entry_type == b'type':
-            if isinstance(value, unicode):
-                value = value.encode('latin_1')
-            w(b'>4s', value)
-        elif entry_type == b'comp' or entry_type == b'dutc':
-            w(b'>Q', value)
+        elif entry_type == b"type":
+            if isinstance(value, str):
+                value = value.encode("latin_1")
+            w(b">4s", value)
+        elif entry_type == b"comp" or entry_type == b"dutc":
+            w(b">Q", value)
         else:
             raise ValueError('Unknown type code "%s"' % entry_type)
-    
+
     def __repr__(self):
-        return '<%s %s>' % (self.filename, self.code)
+        return f"<{self.filename} {self.code}>"
+
+
+class DSStore:
+    """Python interface to a ``.DS_Store`` file.  Works by manipulating the
+    file on the disk---so this code will work with ``.DS_Store`` files for.
 
-class DSStore(object):
-    """Python interface to a ``.DS_Store`` file.  Works by manipulating the file
-    on the disk---so this code will work with ``.DS_Store`` files for *very*
-    large directories.
+    *very* large directories.
 
     A :class:`DSStore` object can be used as if it was a mapping, e.g.::
 
@@ -280,7 +257,7 @@ class DSStore(object):
 
     Currently, we know how to decode "Iloc", "bwsp", "lsvp", "lsvP" and "icvp"
     blobs.  "Iloc" decodes to an (x, y) tuple, while the others are all decoded
-    using ``biplist``.
+    using ``biplist`` or ``plistlib`` depending on Python version.
 
     Assignment also works, e.g.::
 
@@ -292,38 +269,48 @@ class DSStore(object):
 
     This is usually going to be the most convenient interface, though
     occasionally (for instance when creating a new ``.DS_Store`` file) you
-    may wish to drop down to using :class:`DSStoreEntry` objects directly."""
+    may wish to drop down to using :class:`DSStoreEntry` objects directly.
+    """
+
     def __init__(self, store):
         self._store = store
-        self._superblk = self._store['DSDB']
+        self._superblk = self._store["DSDB"]
         with self._get_block(self._superblk) as s:
-            self._rootnode, self._levels, self._records, \
-            self._nodes, self._page_size = s.read(b'>IIIII')
+            (
+                self._rootnode,
+                self._levels,
+                self._records,
+                self._nodes,
+                self._page_size,
+            ) = s.read(b">IIIII")
         self._min_usage = 2 * self._page_size // 3
         self._dirty = False
-        
+
     @classmethod
-    def open(cls, file_or_name, mode='r+', initial_entries=None):
+    def open(cls, file_or_name, mode="r+", initial_entries=None):
         """Open a ``.DS_Store`` file; pass either a Python file object, or a
-        filename in the ``file_or_name`` argument and a file access mode in
-        the ``mode`` argument.  If you are creating a new file using the "w"
-        or "w+" modes, you may also specify a list of entries with which
-        to initialise the file."""
+        filename in the ``file_or_name`` argument and a file access mode in the
+        ``mode`` argument.
+
+        If you are creating a new file using the "w" or "w+" modes, you
+        may also specify a list of entries with which to initialise the
+        file.
+        """
         store = buddy.Allocator.open(file_or_name, mode)
-        
-        if mode == 'w' or mode == 'w+':
+
+        if mode == "w" or mode == "w+":
             superblk = store.allocate(20)
-            store['DSDB'] = superblk
+            store["DSDB"] = superblk
             page_size = 4096
-            
+
             if not initial_entries:
                 root = store.allocate(page_size)
-                
+
                 with store.get_block(root) as rootblk:
                     rootblk.zero_fill()
 
                 with store.get_block(superblk) as s:
-                    s.write(b'>IIIII', root, 0, 0, 1, page_size)
+                    s.write(b">IIIII", root, 0, 0, 1, page_size)
             else:
                 # Make sure they're in sorted order
                 initial_entries = list(initial_entries)
@@ -357,48 +344,54 @@ class DSStore(object):
 
                     if len(nodes) == 1:
                         break
-                    
+
                     current_level = next_level
                     next_level = []
                     ptr_size = 4
 
                 # Allocate nodes
                 ptrs = [store.allocate(page_size) for n in range(node_count)]
-                
+
                 # Generate nodes
                 pointers = []
                 prev_pointers = None
                 for level in levels:
                     ppndx = 0
-                    lptrs = ptrs[-len(level):]
-                    del ptrs[-len(level):]
+                    lptrs = ptrs[-len(level) :]
+                    del ptrs[-len(level) :]
                     for node in level:
                         ndx = lptrs.pop(0)
                         if prev_pointers is None:
                             with store.get_block(ndx) as block:
-                                block.write(b'>II', 0, len(node))
+                                block.write(b">II", 0, len(node))
                                 for e in node:
                                     e.write(block)
                         else:
                             next_node = prev_pointers[ppndx + len(node)]
-                            node_ptrs = prev_pointers[ppndx:ppndx+len(node)]
-                            
+                            node_ptrs = prev_pointers[ppndx : ppndx + len(node)]
+
                             with store.get_block(ndx) as block:
-                                block.write(b'>II', next_node, len(node))
+                                block.write(b">II", next_node, len(node))
                                 for ptr, e in zip(node_ptrs, node):
-                                    block.write(b'>I', ptr)
+                                    block.write(b">I", ptr)
                                     e.write(block)
-                            
+
                         pointers.append(ndx)
                     prev_pointers = pointers
                     pointers = []
-                
+
                 root = prev_pointers[0]
 
                 with store.get_block(superblk) as s:
-                    s.write(b'>IIIII', root, len(levels), len(initial_entries),
-                            node_count, page_size)
-                    
+                    s.write(
+                        b">IIIII",
+                        root,
+                        len(levels),
+                        len(initial_entries),
+                        node_count,
+                        page_size,
+                    )
+
         return DSStore(store)
 
     def _get_block(self, number):
@@ -410,25 +403,31 @@ class DSStore(object):
             self._dirty = False
 
             with self._get_block(self._superblk) as s:
-                s.write(b'>IIIII', self._rootnode, self._levels, self._records,
-                        self._nodes, self._page_size)
+                s.write(
+                    b">IIIII",
+                    self._rootnode,
+                    self._levels,
+                    self._records,
+                    self._nodes,
+                    self._page_size,
+                )
         self._store.flush()
 
     def close(self):
         """Flush dirty data and close the underlying file."""
         self.flush()
         self._store.close()
-        
+
     def __enter__(self):
         return self
 
     def __exit__(self, exc_type, exc_value, traceback):
         self.close()
-        
+
     # Internal B-Tree nodes look like this:
     #
     # [ next | count | (ptr0 | rec0) | (ptr1 | rec1) ... (ptrN | recN) ]
-    
+
     # Leaf nodes look like this:
     #
     # [ 0 | count | rec0 | rec1 ... recN ]
@@ -438,10 +437,10 @@ class DSStore(object):
         if node is None:
             node = self._rootnode
         with self._get_block(node) as block:
-            next_node, count = block.read(b'>II')
+            next_node, count = block.read(b">II")
             if next_node:
                 for n in range(count):
-                    ptr = block.read(b'>I')[0]
+                    ptr = block.read(b">I")[0]
                     for e in self._traverse(ptr):
                         yield e
                     e = DSStoreEntry.read(block)
@@ -456,23 +455,30 @@ class DSStore(object):
     # Display the data in `node'
     def _dump_node(self, node):
         with self._get_block(node) as block:
-            next_node, count = block.read(b'>II')
-            print('next: %u\ncount: %u\n' % (next_node, count))
+            next_node, count = block.read(b">II")
+            print("next: %u\ncount: %u\n" % (next_node, count))
             for n in range(count):
                 if next_node:
-                    ptr = block.read(b'>I')[0]
-                    print('%8u ' % ptr, end=' ')
+                    ptr = block.read(b">I")[0]
+                    print("%8u " % ptr, end=" ")
                 else:
-                    print('         ', end=' ')
+                    print("         ", end=" ")
                 e = DSStoreEntry.read(block)
-                print(e, ' (%u)' % e.byte_length())
-            print('used: %u' % block.tell())
+                print(e, " (%u)" % e.byte_length())
+            print("used: %u" % block.tell())
 
     # Display the data in the super block
     def _dump_super(self):
-        print('root: %u\nlevels: %u\nrecords: %u\nnodes: %u\npage-size: %u' \
-          % (self._rootnode, self._levels, self._records,
-             self._nodes, self._page_size))
+        print(
+            "root: %u\nlevels: %u\nrecords: %u\nnodes: %u\npage-size: %u"
+            % (
+                self._rootnode,
+                self._levels,
+                self._records,
+                self._nodes,
+                self._page_size,
+            )
+        )
 
     # Splits entries across two blocks, returning one pivot
     #
@@ -480,9 +486,9 @@ class DSStore(object):
     def _split2(self, blocks, entries, pointers, before, internal):
         left_block = blocks[0]
         right_block = blocks[1]
-        
+
         count = len(entries)
-        
+
         # Find the feasible splits
         best_split = None
         best_diff = None
@@ -492,7 +498,7 @@ class DSStore(object):
             # We can use a *single* node for this
             best_split = count
         else:
-            # Split into two nodes  
+            # Split into two nodes
             for n in range(1, count - 1):
                 left_size = 8 + before[n]
                 right_size = 8 + total - before[n + 1]
@@ -501,7 +507,7 @@ class DSStore(object):
                     break
                 if right_size > self._page_size:
                     continue
-                
+
                 diff = abs(left_size - right_size)
 
                 if best_split is None or diff < best_diff:
@@ -510,54 +516,53 @@ class DSStore(object):
 
         if best_split is None:
             return None
-        
+
         # Write the nodes
         left_block.seek(0)
         if internal:
             next_node = pointers[best_split]
         else:
             next_node = 0
-        left_block.write(b'>II', next_node, best_split)
+        left_block.write(b">II", next_node, best_split)
 
         for n in range(best_split):
             if internal:
-                left_block.write(b'>I', pointers[n])
+                left_block.write(b">I", pointers[n])
             entries[n].write(left_block)
 
         left_block.zero_fill()
 
         if best_split == count:
             return []
-        
+
         right_block.seek(0)
         if internal:
             next_node = pointers[count]
         else:
             next_node = 0
-        right_block.write(b'>II', next_node, count - best_split - 1)
+        right_block.write(b">II", next_node, count - best_split - 1)
 
         for n in range(best_split + 1, count):
             if internal:
-                right_block.write(b'>I', pointers[n])
+                right_block.write(b">I", pointers[n])
             entries[n].write(right_block)
 
         right_block.zero_fill()
-            
+
         pivot = entries[best_split]
 
         return [pivot]
-    
+
     def _split(self, node, entry, right_ptr=0):
         self._nodes += 1
         self._dirty = True
         new_right = self._store.allocate(self._page_size)
-        with self._get_block(node) as block, \
-            self._get_block(new_right) as right_block:
+        with self._get_block(node) as block, self._get_block(new_right) as right_block:
 
             # First, measure and extract all the elements
             entry_size = entry.byte_length()
-            entry_pos = None
-            next_node, count = block.read(b'>II')
+            # ?? entry_pos = None
+            next_node, count = block.read(b">II")
             if next_node:
                 entry_size += 4
             pointers = []
@@ -567,11 +572,11 @@ class DSStore(object):
             for n in range(count):
                 pos = block.tell()
                 if next_node:
-                    ptr = block.read(b'>I')[0]
+                    ptr = block.read(b">I")[0]
                     pointers.append(ptr)
                 e = DSStoreEntry.read(block)
                 if e > entry:
-                    entry_pos = n
+                    # ?? entry_pos = n
                     entries.append(entry)
                     pointers.append(right_ptr)
                     before.append(total)
@@ -583,10 +588,10 @@ class DSStore(object):
             if next_node:
                 pointers.append(next_node)
 
-            pivot = self._split2([block, right_block],
-                                 entries, pointers, before,
-                                 bool(next_node))[0]
-            
+            pivot = self._split2(
+                [block, right_block], entries, pointers, before, bool(next_node)
+            )[0]
+
             self._records += 1
             self._nodes += 1
             self._dirty = True
@@ -598,7 +603,7 @@ class DSStore(object):
     def _new_root(self, left, pivot, right):
         new_root = self._store.allocate(self._page_size)
         with self._get_block(new_root) as block:
-            block.write(b'>III', right, 1, left)
+            block.write(b">III", right, 1, left)
             pivot.write(block)
         self._rootnode = new_root
         self._levels += 1
@@ -610,21 +615,21 @@ class DSStore(object):
     # pointer (inserted to the RIGHT of `entry')
     def _insert_inner(self, path, node, entry, right_ptr):
         with self._get_block(node) as block:
-            next_node, count = block.read(b'>II')
+            next_node, count = block.read(b">II")
             insert_pos = None
             insert_ndx = None
             n = 0
             while n < count:
                 pos = block.tell()
-                ptr = block.read(b'>I')[0]
+                ptr = block.read(b">I")[0]
                 e = DSStoreEntry.read(block)
                 if e == entry:
                     if n == count - 1:
                         right_ptr = next_node
                         next_node = ptr
-                        block_seek(pos)
+                        block.seek(pos)
                     else:
-                        right_ptr = block.read(b'>I')[0]
+                        right_ptr = block.read(b">I")[0]
                         block.seek(pos + 4)
                     insert_pos = pos
                     insert_ndx = n
@@ -651,32 +656,32 @@ class DSStore(object):
             else:
                 if insert_ndx == count:
                     block.seek(insert_pos)
-                    block.write(b'>I', next_node)
+                    block.write(b">I", next_node)
                     entry.write(block)
                     next_node = right_ptr
                 else:
                     block.seek(insert_pos + 4)
                     entry.write(block, True)
-                    block.insert('>I', right_ptr)
+                    block.insert(">I", right_ptr)
                 block.seek(0)
                 count += 1
-                block.write(b'>II', next_node, count)
+                block.write(b">II", next_node, count)
                 self._records += 1
                 self._dirty = True
 
     # Insert `entry' into the leaf node `node'
     def _insert_leaf(self, path, node, entry):
         with self._get_block(node) as block:
-            next_node, count = block.read(b'>II')
+            next_node, count = block.read(b">II")
             insert_pos = None
-            insert_ndx = None
+            # ?? insert_ndx = None
             n = 0
             while n < count:
                 pos = block.tell()
                 e = DSStoreEntry.read(block)
                 if e == entry:
                     insert_pos = pos
-                    insert_ndx = n
+                    # ?? insert_ndx = n
                     block.seek(pos)
                     block.delete(e.byte_length())
                     count -= 1
@@ -685,11 +690,11 @@ class DSStore(object):
                     continue
                 elif insert_pos is None and e > entry:
                     insert_pos = pos
-                    insert_ndx = n
+                    # ?? insert_ndx = n
                 n += 1
             if insert_pos is None:
                 insert_pos = block.tell()
-                insert_ndx = count
+                # ?? insert_ndx = count
             remaining = self._page_size - block.tell()
 
             if remaining < entry.byte_length():
@@ -703,21 +708,21 @@ class DSStore(object):
                 entry.write(block, True)
                 block.seek(0)
                 count += 1
-                block.write(b'>II', next_node, count)
+                block.write(b">II", next_node, count)
                 self._records += 1
                 self._dirty = True
 
     def insert(self, entry):
-        """Insert ``entry`` (which should be a :class:`DSStoreEntry`)
-        into the B-Tree."""
+        """Insert ``entry`` (which should be a :class:`DSStoreEntry`) into the
+        B-Tree."""
         path = []
         node = self._rootnode
         while True:
             with self._get_block(node) as block:
-                next_node, count = block.read(b'>II')
+                next_node, count = block.read(b">II")
                 if next_node:
                     for n in range(count):
-                        ptr = block.read(b'>I')[0]
+                        ptr = block.read(b">I")[0]
                         e = DSStoreEntry.read(block)
                         if entry < e:
                             next_node = ptr
@@ -735,12 +740,12 @@ class DSStore(object):
     # Return usage information for the specified `node'
     def _block_usage(self, node):
         with self._get_block(node) as block:
-            next_node, count = block.read(b'>II')
+            next_node, count = block.read(b">II")
 
             for n in range(count):
                 if next_node:
-                    ptr = block.read(b'>I')[0]
-                e = DSStoreEntry.read(block)
+                    block.read(b">I")[0]
+                DSStoreEntry.read(block)
 
             used = block.tell()
 
@@ -773,14 +778,14 @@ class DSStore(object):
                     continue
 
                 diff = abs(left_size - mid_size) * abs(right_size - mid_size)
-                
+
                 if best_split is None or diff < best_diff:
                     best_split = (n, m, count)
                     best_diff = diff
 
         if best_split is None:
             return None
-        
+
         # Write the nodes
         prev_split = -1
         for block, split in zip(blocks, best_split):
@@ -789,15 +794,15 @@ class DSStore(object):
                 next_node = pointers[split]
             else:
                 next_node = 0
-            block.write(b'>II', next_node, split)
+            block.write(b">II", next_node, split)
 
             for n in range(prev_split + 1, split):
                 if internal:
-                    block.write(b'>I', pointers[n])
+                    block.write(b">I", pointers[n])
                 entries[n].write(block)
 
             block.zero_fill()
-            
+
             prev_split = split
 
         return (entries[best_split[0]], entries[best_split[1]])
@@ -811,13 +816,13 @@ class DSStore(object):
         before = []
         total = 0
         ppivots = pivots + [None]
-        for b,p in zip(blocks, ppivots):
+        for b, p in zip(blocks, ppivots):
             b.seek(0)
-            next_node, count = b.read(b'>II')
+            next_node, count = b.read(b">II")
             for n in range(count):
                 pos = b.tell()
                 if next_node:
-                    ptr = b.read(b'>I')[0]
+                    ptr = b.read(b">I")[0]
                     pointers.append(ptr)
                 e = DSStoreEntry.read(b)
                 entries.append(e)
@@ -842,11 +847,11 @@ class DSStore(object):
             return
 
         with self._get_block(node) as block:
-            next_node, count = block.read(b'>II')
-            
+            next_node, count = block.read(b">II")
+
             with self._get_block(path[-1]) as parent:
                 # Find the left and right siblings and respective pivots
-                parent_next, parent_count = parent.read(b'>II')
+                parent_next, parent_count = parent.read(b">II")
                 left_pos = None
                 left_node = None
                 left_pivot = None
@@ -857,7 +862,7 @@ class DSStore(object):
                 prev_e = prev_ptr = prev_pos = None
                 for n in range(parent_count):
                     pos = parent.tell()
-                    ptr = parent.read(b'>I')[0]
+                    ptr = parent.read(b">I")[0]
                     e = DSStoreEntry.read(parent)
 
                     if ptr == node:
@@ -870,7 +875,7 @@ class DSStore(object):
                         right_node = ptr
                         right_pos = pos
                         break
-                
+
                     prev_e = e
                     prev_ptr = ptr
                     prev_pos = pos
@@ -884,24 +889,27 @@ class DSStore(object):
                     right_node = parent_next
                     right_pos = parent.tell()
 
-                parent_used = parent.tell()
-            
+                _ = parent.tell()
+
             if left_node and right_node:
-                with self._get_block(left_node) as left, \
-                    self._get_block(right_node) as right:
+                with self._get_block(left_node) as left, self._get_block(
+                    right_node
+                ) as right:
                     blocks = [left, block, right]
                     pivots = [left_pivot, right_pivot]
-                    
+
                     entries, pointers, before = self._extract(blocks, pivots)
 
                     # If there's a chance that we could use two pages instead
                     # of three, go for it
-                    pivots = self._split2(blocks, entries, pointers,
-                                           before, bool(next_node))
+                    pivots = self._split2(
+                        blocks, entries, pointers, before, bool(next_node)
+                    )
                     if pivots is None:
                         ptrs = [left_node, node, right_node]
-                        pivots = self._split3(blocks, entries, pointers,
-                                               before, bool(next_node))
+                        pivots = self._split3(
+                            blocks, entries, pointers, before, bool(next_node)
+                        )
                     else:
                         if pivots:
                             ptrs = [left_node, node]
@@ -913,7 +921,7 @@ class DSStore(object):
                         self._store.release(right_node)
                         self._nodes -= 1
                         self._dirty = True
-                        
+
                     # Remove the pivots from the parent
                     with self._get_block(path[-1]) as parent:
                         if right_node == parent_next:
@@ -925,11 +933,11 @@ class DSStore(object):
                             parent.delete(right_pos - left_pos)
                         parent.seek(0)
                         parent_count -= 2
-                        parent.write(b'>II', parent_next, parent_count)
+                        parent.write(b">II", parent_next, parent_count)
                         self._records -= 2
-                        
+
                     # Replace with those in pivots
-                    for e,rp in zip(pivots, ptrs[1:]):
+                    for e, rp in zip(pivots, ptrs[1:]):
                         self._insert_inner(path[:-1], path[-1], e, rp)
             elif left_node:
                 with self._get_block(left_node) as left:
@@ -938,8 +946,9 @@ class DSStore(object):
 
                     entries, pointers, before = self._extract(blocks, pivots)
 
-                    pivots = self._split2(blocks, entries, pointers,
-                                           before, bool(next_node))
+                    pivots = self._split2(
+                        blocks, entries, pointers, before, bool(next_node)
+                    )
 
                     # Remove the pivot from the parent
                     with self._get_block(path[-1]) as parent:
@@ -952,7 +961,7 @@ class DSStore(object):
                             parent.delete(node_pos - left_pos)
                         parent.seek(0)
                         parent_count -= 1
-                        parent.write(b'>II', parent_next, parent_count)
+                        parent.write(b">II", parent_next, parent_count)
                         self._records -= 1
 
                     # Replace the pivot
@@ -965,8 +974,9 @@ class DSStore(object):
 
                     entries, pointers, before = self._extract(blocks, pivots)
 
-                    pivots = self._split2(blocks, entries, pointers,
-                                           before, bool(next_node))
+                    pivots = self._split2(
+                        blocks, entries, pointers, before, bool(next_node)
+                    )
 
                     # Remove the pivot from the parent
                     with self._get_block(path[-1]) as parent:
@@ -979,13 +989,12 @@ class DSStore(object):
                             parent.delete(right_pos - node_pos)
                         parent.seek(0)
                         parent_count -= 1
-                        parent.write(b'>II', parent_next, parent_count)
+                        parent.write(b">II", parent_next, parent_count)
                         self._records -= 1
 
                     # Replace the pivot
                     if pivots:
-                        self._insert_inner(path[:-1], path[-1], pivots[0],
-                                           right_node)
+                        self._insert_inner(path[:-1], path[-1], pivots[0], right_node)
 
         if not path and not parent_count:
             self._store.release(path[-1])
@@ -994,7 +1003,7 @@ class DSStore(object):
             self._rootnode = node
         else:
             count, used = self._block_usage(path[-1])
-    
+
             if used < self._page_size // 2:
                 self._rebalance(path[:-1], path[-1])
 
@@ -1002,31 +1011,32 @@ class DSStore(object):
     # lower-cased.
     def _delete_leaf(self, node, filename_lc, code):
         found = False
-        
+
         with self._get_block(node) as block:
-            next_node, count = block.read(b'>II')
+            next_node, count = block.read(b">II")
 
             for n in range(count):
                 pos = block.tell()
                 e = DSStoreEntry.read(block)
-                if e.filename.lower() == filename_lc \
-                  and (code is None or e.code == code):
+                if e.filename.lower() == filename_lc and (
+                    code is None or e.code == code
+                ):
                     block.seek(pos)
                     block.delete(e.byte_length())
                     found = True
-                    
+
                     # This does not affect the loop; THIS IS NOT A BUG
                     count -= 1
 
                     self._records -= 1
                     self._dirty = True
-                    
+
             if found:
                 used = block.tell()
-                
+
                 block.seek(0)
-                block.write(b'>II', next_node, count)
-            
+                block.write(b">II", next_node, count)
+
                 return used < self._page_size // 2
             else:
                 return False
@@ -1040,7 +1050,7 @@ class DSStore(object):
         rebalance = None
         while True:
             with self._get_block(node) as block:
-                next_node, count = block.read(b'>II')
+                next_node, count = block.read(b">II")
 
                 if next_node:
                     path.append(node)
@@ -1053,7 +1063,7 @@ class DSStore(object):
 
                 count -= 1
                 block.seek(0)
-                block.write(b'>II', next_node, count)
+                block.write(b">II", next_node, count)
 
                 if pos < self._page_size // 2:
                     rebalance = (path, node)
@@ -1064,16 +1074,17 @@ class DSStore(object):
     # Delete an entry from an inner node, `node'
     def _delete_inner(self, path, node, filename_lc, code):
         rebalance = False
-        
+
         with self._get_block(node) as block:
-            next_node, count = block.read(b'>II')
+            next_node, count = block.read(b">II")
 
             for n in range(count):
                 pos = block.tell()
-                ptr = block.read(b'>I')[0]
+                ptr = block.read(b">I")[0]
                 e = DSStoreEntry.read(block)
-                if e.filename.lower() == filename_lc \
-                  and (code is None or e.code == code):
+                if e.filename.lower() == filename_lc and (
+                    code is None or e.code == code
+                ):
                     # Take the largest from the left subtree
                     rebalance, largest = self._take_largest(path, ptr)
 
@@ -1083,20 +1094,20 @@ class DSStore(object):
                         next_node = ptr
                         block.seek(pos)
                     else:
-                        right_ptr = block.read(b'>I')[0]
+                        right_ptr = block.read(b">I")[0]
                         block.seek(pos + 4)
-                        
+
                     block.delete(e.byte_length() + 4)
 
                     count -= 1
                     block.seek(0)
-                    block.write(b'>II', next_node, count)
+                    block.write(b">II", next_node, count)
 
                     self._records -= 1
                     self._dirty = True
-                    
+
                     break
-                    
+
         # Replace the pivot value
         self._insert_inner(path, node, largest, right_ptr)
 
@@ -1107,16 +1118,16 @@ class DSStore(object):
         return False
 
     def delete(self, filename, code):
-        """Delete an item, identified by ``filename`` and ``code``
-        from the B-Tree."""
+        """Delete an item, identified by ``filename`` and ``code`` from the
+        B-Tree."""
         if isinstance(filename, DSStoreEntry):
             code = filename.code
             filename = filename.filename
 
         # If we're deleting *every* node for "filename", we must recurse
         if code is None:
-            ###TODO: Fix this so we can do bulk deletes
-            raise ValueError('You must delete items individually.  Sorry')
+            # TODO: Fix this so we can do bulk deletes
+            raise ValueError("You must delete items individually.  Sorry")
 
         # Otherwise, we're deleting *one* specific node
         filename_lc = filename.lower()
@@ -1124,14 +1135,15 @@ class DSStore(object):
         node = self._rootnode
         while True:
             with self._get_block(node) as block:
-                next_node, count = block.read(b'>II')
+                next_node, count = block.read(b">II")
                 if next_node:
                     for n in range(count):
-                        ptr = block.read(b'>I')[0]
+                        ptr = block.read(b">I")[0]
                         e = DSStoreEntry.read(block)
                         e_lc = e.filename.lower()
-                        if filename_lc < e_lc \
-                            or (filename_lc == e_lc and code < e.code):
+                        if filename_lc < e_lc or (
+                            filename_lc == e_lc and code < e.code
+                        ):
                             next_node = ptr
                             break
                         elif filename_lc == e_lc and code == e.code:
@@ -1147,12 +1159,12 @@ class DSStore(object):
     # Find implementation
     def _find(self, node, filename_lc, code=None):
         if code is not None and not isinstance(code, bytes):
-            code = code.encode('latin_1')
+            code = code.encode("latin_1")
         with self._get_block(node) as block:
-            next_node, count = block.read(b'>II')
+            next_node, count = block.read(b">II")
             if next_node:
                 for n in range(count):
-                    ptr = block.read(b'>I')[0]
+                    ptr = block.read(b">I")[0]
                     e = DSStoreEntry.read(block)
                     if filename_lc < e.filename.lower():
                         for e in self._find(ptr, filename_lc, code):
@@ -1176,16 +1188,16 @@ class DSStore(object):
                             yield e
                         elif code < e.code:
                             return
-                        
+
     def find(self, filename, code=None):
-        """Returns a generator that will iterate over matching entries in
-        the B-Tree."""
+        """Returns a generator that will iterate over matching entries in the
+        B-Tree."""
         if isinstance(filename, DSStoreEntry):
             code = filename.code
             filename = filename.filename
 
         filename_lc = filename.lower()
-        
+
         return self._find(self._rootnode, filename_lc, code)
 
     def __len__(self):
@@ -1194,36 +1206,36 @@ class DSStore(object):
     def __iter__(self):
         return self._traverse(self._rootnode)
 
-    class Partial(object):
+    class Partial:
         """This is used to implement indexing."""
+
         def __init__(self, store, filename):
             self._store = store
             self._filename = filename
 
         def __getitem__(self, code):
             if code is None:
-                raise KeyError('no such key - [%s][None]' % self._filename)
+                raise KeyError("no such key - [%s][None]" % self._filename)
 
             if not isinstance(code, bytes):
-                code = code.encode('latin_1')
+                code = code.encode("latin_1")
 
             try:
                 item = next(self._store.find(self._filename, code))
             except StopIteration:
-                raise KeyError('no such key - [%s][%s]' % (self._filename,
-                               code))
+                raise KeyError(f"no such key - [{self._filename}][{code}]")
 
-            if not isinstance(item.type, (bytes, str, unicode)):
+            if not isinstance(item.type, (bytes, str)):
                 return item.value
-            
+
             return (item.type, item.value)
-            
+
         def __setitem__(self, code, value):
             if code is None:
-                raise KeyError('bad key - [%s][None]' % self._filename)
+                raise KeyError("bad key - [%s][None]" % self._filename)
 
             if not isinstance(code, bytes):
-                code = code.encode('latin_1')
+                code = code.encode("latin_1")
 
             codec = codecs.get(code, None)
             if codec:
@@ -1232,20 +1244,19 @@ class DSStore(object):
             else:
                 entry_type = value[0]
                 entry_value = value[1]
-            
-            self._store.insert(DSStoreEntry(self._filename, code,
-                                             entry_type, entry_value))
+
+            self._store.insert(
+                DSStoreEntry(self._filename, code, entry_type, entry_value)
+            )
 
         def __delitem__(self, code):
             if code is None:
-                raise KeyError('no such key - [%s][None]' % self._filename)
+                raise KeyError("no such key - [%s][None]" % self._filename)
 
             self._store.delete(self._filename, code)
 
         def __iter__(self):
-            for item in self._store.find(self._filename):
-                yield item
+            yield from self._store.find(self._filename)
 
     def __getitem__(self, filename):
         return self.Partial(self, filename)
-