diff --git a/msoffcrypto/method/container/ecma376_encrypted.py b/msoffcrypto/method/container/ecma376_encrypted.py
index b363d75..a5818de 100644
--- a/msoffcrypto/method/container/ecma376_encrypted.py
+++ b/msoffcrypto/method/container/ecma376_encrypted.py
@@ -182,13 +182,28 @@ def write_header_to(self, obuf):
         Write 128 bytes header in the output buffer. The Name property needs to be converted to UTF-16; Content is _not_
         written out by this method.
         """
-        name16 = self.Name.encode("UTF-16-LE")  # Write in Little Endian; omit the BOM at the start of the output
+        name16 = self.Name.encode(
+            "UTF-16-LE"
+        )  # Write in Little Endian; omit the BOM at the start of the output
         directoryNameSize = len(name16) + 2  # Count the null terminator in the size
 
-        obuf.write(name16 + b"\0" * 2)  # Specs calls for us to store the null-terminator
-        obuf.write(b"\0" * (64 - directoryNameSize))  # Pad name to 64 bytes (thus max 31 chars + \x00\x00)
+        obuf.write(
+            name16 + b"\0" * 2
+        )  # Specs calls for us to store the null-terminator
+        obuf.write(
+            b"\0" * (64 - directoryNameSize)
+        )  # Pad name to 64 bytes (thus max 31 chars + \x00\x00)
         obuf.write(pack("<H", directoryNameSize if directoryNameSize > 2 else 0))
-        obuf.write(pack("<BBIII", self.Type, self.Color, self.LeftSiblingId, self.RightSiblingId, self.ChildId))
+        obuf.write(
+            pack(
+                "<BBIII",
+                self.Type,
+                self.Color,
+                self.LeftSiblingId,
+                self.RightSiblingId,
+                self.ChildId,
+            )
+        )
 
         if self.CLSID:
             obuf.write(self.CLSID)
@@ -294,11 +309,12 @@ def miniFatDataPos(self):
 
     @property
     def contentSectorNum(self):
-        return self.numMiniFatSectors + self.directoryEntrySectorNum + self.miniFatDataSectorNum + self.encryptionPackageSectorNum
-
-    @property
-    def miniFatDataPos(self):
-        return self.directoryEntryPos + self.directoryEntrySectorNum
+        return (
+            self.numMiniFatSectors
+            + self.directoryEntrySectorNum
+            + self.miniFatDataSectorNum
+            + self.encryptionPackageSectorNum
+        )
 
     @property
     def encryptionPackagePos(self):
@@ -370,10 +386,37 @@ def _get_directory_entries(self):
         ft = datetime2filetime(datetime.now())
 
         directories = [  # Must follow DSPos ordering
-            DirectoryEntry("Root Entry", DirectoryEntryType.ROOT_STORAGE, RedBlack.RED, ct=ft, mt=ft, childId=DSPos.iEncryptionInfo),
-            DirectoryEntry("EncryptedPackage", DirectoryEntryType.STREAM, RedBlack.RED, ct=ft, mt=ft),
-            DirectoryEntry("\x06DataSpaces", DirectoryEntryType.STORAGE, RedBlack.RED, ct=ft, mt=ft, childId=DSPos.iDataSpaceMap),
-            DirectoryEntry("Version", DirectoryEntryType.STREAM, RedBlack.BLACK, ct=ft, mt=ft, content=DefaultContent.Version),
+            DirectoryEntry(
+                "Root Entry",
+                DirectoryEntryType.ROOT_STORAGE,
+                RedBlack.RED,
+                ct=ft,
+                mt=ft,
+                childId=DSPos.iEncryptionInfo,
+            ),
+            DirectoryEntry(
+                "EncryptedPackage",
+                DirectoryEntryType.STREAM,
+                RedBlack.RED,
+                ct=ft,
+                mt=ft,
+            ),
+            DirectoryEntry(
+                "\x06DataSpaces",
+                DirectoryEntryType.STORAGE,
+                RedBlack.RED,
+                ct=ft,
+                mt=ft,
+                childId=DSPos.iDataSpaceMap,
+            ),
+            DirectoryEntry(
+                "Version",
+                DirectoryEntryType.STREAM,
+                RedBlack.BLACK,
+                ct=ft,
+                mt=ft,
+                content=DefaultContent.Version,
+            ),
             DirectoryEntry(
                 "DataSpaceMap",
                 DirectoryEntryType.STREAM,
@@ -402,10 +445,29 @@ def _get_directory_entries(self):
                 content=DefaultContent.StrongEncryptionDataSpace,
             ),
             DirectoryEntry(
-                "TransformInfo", DirectoryEntryType.STORAGE, RedBlack.RED, ct=ft, mt=ft, childId=DSPos.iStrongEncryptionTransform
+                "TransformInfo",
+                DirectoryEntryType.STORAGE,
+                RedBlack.RED,
+                ct=ft,
+                mt=ft,
+                childId=DSPos.iStrongEncryptionTransform,
+            ),
+            DirectoryEntry(
+                "StrongEncryptionTransform",
+                DirectoryEntryType.STORAGE,
+                RedBlack.BLACK,
+                ct=ft,
+                mt=ft,
+                childId=DSPos.iPrimary,
+            ),
+            DirectoryEntry(
+                "\x06Primary",
+                DirectoryEntryType.STREAM,
+                RedBlack.BLACK,
+                ct=ft,
+                mt=ft,
+                content=DefaultContent.Primary,
             ),
-            DirectoryEntry("StrongEncryptionTransform", DirectoryEntryType.STORAGE, RedBlack.BLACK, ct=ft, mt=ft, childId=DSPos.iPrimary),
-            DirectoryEntry("\x06Primary", DirectoryEntryType.STREAM, RedBlack.BLACK, ct=ft, mt=ft, content=DefaultContent.Primary),
             DirectoryEntry(
                 "EncryptionInfo",
                 DirectoryEntryType.STREAM,
@@ -431,7 +493,9 @@ def _write_to(self, obuf):
 
         self._dirs[DSPos.iRoot].StartingSectorLocation = layout.miniFatDataPos
         self._dirs[DSPos.iRoot].Content = b"\0" * (64 * layout.miniFatNum)
-        self._dirs[DSPos.iEncryptionPackage].StartingSectorLocation = layout.encryptionPackagePos
+        self._dirs[
+            DSPos.iEncryptionPackage
+        ].StartingSectorLocation = layout.encryptionPackagePos
 
         for i in range(min(layout.fatSectorNum, Header.FIRSTNUMDIFAT)):
             self._header.difat.append(layout.fatPos + i)
@@ -464,7 +528,9 @@ def _write_directory_entries(self, obuf, layout: ECMA376EncryptedLayout):
 
         if obuf.tell() != (layout.offsetDirectoryEntries + len(self._dirs) * 128):
             # TODO: Use appropriate custom exception
-            raise Exception("Buffer did not advance as expected when writing out directory entries")
+            raise Exception(
+                "Buffer did not advance as expected when writing out directory entries"
+            )
 
     def _write_Content(self, obuf, layout: ECMA376EncryptedLayout):
         for d in self._dirs:
@@ -479,15 +545,24 @@ def _write_Content(self, obuf, layout: ECMA376EncryptedLayout):
                     obuf.write(d.Content)
 
     def _write_FAT_start(self, obuf, layout: ECMA376EncryptedLayout):
-        v = ([SectorTypes.DIFSECT] * layout.difatSectorNum) + ([SectorTypes.FATSECT] * layout.fatSectorNum)
-        v += [layout.numMiniFatSectors, layout.directoryEntrySectorNum, layout.miniFatDataSectorNum, layout.encryptionPackageSectorNum]
+        v = ([SectorTypes.DIFSECT] * layout.difatSectorNum) + (
+            [SectorTypes.FATSECT] * layout.fatSectorNum
+        )
+        v += [
+            layout.numMiniFatSectors,
+            layout.directoryEntrySectorNum,
+            layout.miniFatDataSectorNum,
+            layout.encryptionPackageSectorNum,
+        ]
 
         obuf.seek(layout.offsetFat)
         self._write_FAT(obuf, v, layout.fatSectorNum * layout.sectorSize)
 
     def _write_MiniFAT(self, obuf, layout: ECMA376EncryptedLayout):
         obuf.seek(layout.offsetMiniFat)
-        self._write_FAT(obuf, layout.miniFatSectors, layout.numMiniFatSectors * layout.sectorSize)
+        self._write_FAT(
+            obuf, layout.miniFatSectors, layout.numMiniFatSectors * layout.sectorSize
+        )
 
     def _write_FAT(self, obuf, entries, blockSize):
         v = 0
@@ -556,8 +631,14 @@ def _detect_sector_num(self, layout: ECMA376EncryptedLayout):
         fatSectorNum = 0
 
         for i in range(10):
-            a = self._get_block_num(difatSectorNum + fatSectorNum + layout.contentSectorNum, numInFat)
-            b = 0 if a <= Header.FIRSTNUMDIFAT else self._get_block_num(a - Header.FIRSTNUMDIFAT, numInFat - 1)
+            a = self._get_block_num(
+                difatSectorNum + fatSectorNum + layout.contentSectorNum, numInFat
+            )
+            b = (
+                0
+                if a <= Header.FIRSTNUMDIFAT
+                else self._get_block_num(a - Header.FIRSTNUMDIFAT, numInFat - 1)
+            )
 
             if (b == difatSectorNum) and (a == fatSectorNum):
                 layout.fatSectorNum = fatSectorNum
@@ -568,11 +649,19 @@ def _detect_sector_num(self, layout: ECMA376EncryptedLayout):
             difatSectorNum = b
             fatSectorNum = a
 
-        raise IndexError("Unable to detect sector number within a reasonsable amount of loops")
+        raise IndexError(
+            "Unable to detect sector number within a reasonsable amount of loops"
+        )
 
     def _set_sector_locations_of_streams(self, layout: ECMA376EncryptedLayout):
         # Use all streams, except the encrypted package which is special (and the main reason why we're doing all this!)
-        streamsOfInterest = list(filter(lambda d: d.Type == DirectoryEntryType.STREAM and d.Name != "EncryptedPackage", self._dirs))
+        streamsOfInterest = list(
+            filter(
+                lambda d: d.Type == DirectoryEntryType.STREAM
+                and d.Name != "EncryptedPackage",
+                self._dirs,
+            )
+        )
 
         miniFatSectors = []
         miniFatNum = 0
@@ -588,7 +677,9 @@ def _set_sector_locations_of_streams(self, layout: ECMA376EncryptedLayout):
             pos += n
 
         miniFatNum = pos
-        miniFatDataSectorNum = self._get_block_num(miniFatNum, (self._header.sectorSize // 64))
+        miniFatDataSectorNum = self._get_block_num(
+            miniFatNum, (self._header.sectorSize // 64)
+        )
 
         if self._get_block_num(miniFatDataSectorNum, 128) > 1:
             raise ValueError("Unexpected layout size; too large")
@@ -598,7 +689,9 @@ def _set_sector_locations_of_streams(self, layout: ECMA376EncryptedLayout):
         layout.miniFatSectors = miniFatSectors
 
         layout.directoryEntrySectorNum = self._get_block_num(len(self._dirs), 4)
-        layout.encryptionPackageSectorNum = self._get_block_num(len(self._dirs[DSPos.iEncryptionPackage].Content), layout.sectorSize)
+        layout.encryptionPackageSectorNum = self._get_block_num(
+            len(self._dirs[DSPos.iEncryptionPackage].Content), layout.sectorSize
+        )
 
     def _get_MiniFAT_sector_number(self, size):
         return self._get_block_num(size, 64)
diff --git a/msoffcrypto/method/ecma376_agile.py b/msoffcrypto/method/ecma376_agile.py
index dcc5a3c..783b936 100644
--- a/msoffcrypto/method/ecma376_agile.py
+++ b/msoffcrypto/method/ecma376_agile.py
@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import base64
 import functools
 import hmac
@@ -26,7 +28,9 @@
 }
 
 blkKey_VerifierHashInput = bytearray([0xFE, 0xA7, 0xD2, 0x76, 0x3B, 0x4B, 0x9E, 0x79])
-blkKey_encryptedVerifierHashValue = bytearray([0xD7, 0xAA, 0x0F, 0x6D, 0x30, 0x61, 0x34, 0x4E])
+blkKey_encryptedVerifierHashValue = bytearray(
+    [0xD7, 0xAA, 0x0F, 0x6D, 0x30, 0x61, 0x34, 0x4E]
+)
 blkKey_encryptedKeyValue = bytearray([0x14, 0x6E, 0x0B, 0xE7, 0xAB, 0xAC, 0xD0, 0xD6])
 blkKey_dataIntegrity1 = bytearray([0x5F, 0xB2, 0xAD, 0x01, 0x0C, 0xB9, 0xE1, 0xF6])
 blkKey_dataIntegrity2 = bytearray([0xA0, 0x67, 0x7F, 0x02, 0xB2, 0x2C, 0x84, 0x33])
@@ -85,9 +89,11 @@ def _encrypt_aes_cbc_padded(data, key, iv, blockSize):
 
 
 def _get_salt(salt_value=None, salt_size=16):
-    if not salt_value is None:
+    if salt_value is not None:
         if len(salt_value) != salt_size:
-            raise exceptions.EncryptionError(f"Invalid salt value size, should be {salt_size}")
+            raise exceptions.EncryptionError(
+                f"Invalid salt value size, should be {salt_size}"
+            )
 
         return salt_value
 
@@ -103,7 +109,7 @@ def __init__(self):
         self.blockSize = 16
         self.keyBits = 256
         self.hashSize = 64
-        self.saltValue = None
+        self.saltValue: bytes | None = None
 
 
 def _enc64(b):
@@ -114,13 +120,13 @@ class ECMA376AgileEncryptionInfo:
     def __init__(self):
         self.spinCount = 100000
         self.keyData = ECMA376AgileCipherParams()
-        self.encryptedHmacKey = None
-        self.encryptedHmacValue = None
+        self.encryptedHmacKey: bytes | None = None
+        self.encryptedHmacValue: bytes | None = None
 
         self.encryptedKey = ECMA376AgileCipherParams()
-        self.encryptedVerifierHashInput = None
-        self.encryptedVerifierHashValue = None
-        self.encryptedKeyValue = None
+        self.encryptedVerifierHashInput: bytes | None = None
+        self.encryptedVerifierHashValue: bytes | None = None
+        self.encryptedKeyValue: bytes | None = None
 
     def getEncryptionDescriptorHeader(self):
         # https://learn.microsoft.com/en-us/openspecs/office_file_formats/ms-offcrypto/87020a34-e73f-4139-99bc-bbdf6cf6fa55
@@ -161,7 +167,9 @@ def __init__(self):
         pass
 
     @staticmethod
-    def _derive_iterated_hash_from_password(password, saltValue, hashAlgorithm, spinValue):
+    def _derive_iterated_hash_from_password(
+        password, saltValue, hashAlgorithm, spinValue
+    ):
         r"""
         Do a partial password-based hash derivation.
         Note the block key is not taken into consideration in this function.
@@ -215,7 +223,9 @@ def decrypt(key, keyDataSalt, hashAlgorithm, ibuf):
         totalSize = totalSize[0]
         logger.debug("totalSize: {}".format(totalSize))
         remaining = totalSize
-        for i, buf in enumerate(iter(functools.partial(ibuf.read, SEGMENT_LENGTH), b"")):
+        for i, buf in enumerate(
+            iter(functools.partial(ibuf.read, SEGMENT_LENGTH), b"")
+        ):
             saltWithBlockKey = keyDataSalt + pack("<I", i)
             iv = hashCalc(saltWithBlockKey).digest()
             iv = iv[:16]
@@ -242,9 +252,15 @@ def encrypt(key, ibuf, salt_value=None, spin_count=100000):
 
         # Encryption ported from C++ (https://github.com/herumi/msoffice, BSD-3)
 
-        info, secret_key = ECMA376Agile.generate_encryption_parameters(key, salt_value, spin_count)
-        encrypted_data = ECMA376Agile.encrypt_payload(ibuf, info.encryptedKey, secret_key, info.keyData.saltValue)
-        encryption_info = ECMA376Agile.get_encryption_information(info, encrypted_data, secret_key)
+        info, secret_key = ECMA376Agile.generate_encryption_parameters(
+            key, salt_value, spin_count
+        )
+        encrypted_data = ECMA376Agile.encrypt_payload(
+            ibuf, info.encryptedKey, secret_key, info.keyData.saltValue
+        )
+        encryption_info = ECMA376Agile.get_encryption_information(
+            info, encrypted_data, secret_key
+        )
 
         obuf = io.BytesIO()
         ECMA376Encrypted(encrypted_data, encryption_info).write_to(obuf)
@@ -252,13 +268,17 @@ def encrypt(key, ibuf, salt_value=None, spin_count=100000):
         return obuf.getvalue()
 
     @staticmethod
-    def get_encryption_information(info: ECMA376AgileEncryptionInfo, encrypted_data, secretKey):
+    def get_encryption_information(
+        info: ECMA376AgileEncryptionInfo, encrypted_data, secretKey
+    ):
         """
         Return the content of an EncryptionInfo Stream, including the short header, per the specifications at
 
         https://learn.microsoft.com/en-us/openspecs/office_file_formats/ms-offcrypto/87020a34-e73f-4139-99bc-bbdf6cf6fa55
         """
-        hmacKey, hmacValue = ECMA376Agile.generate_integrity_parameter(encrypted_data, info.keyData, secretKey, info.keyData.saltValue)
+        hmacKey, hmacValue = ECMA376Agile.generate_integrity_parameter(
+            encrypted_data, info.keyData, secretKey, info.keyData.saltValue
+        )
 
         info.encryptedHmacKey = hmacKey
         info.encryptedHmacValue = hmacValue
@@ -284,26 +304,52 @@ def generate_encryption_parameters(key, salt_value=None, spin_count=100000):
             key, info.encryptedKey.saltValue, info.encryptedKey.hashName, info.spinCount
         ).digest()
 
-        key1 = ECMA376Agile._derive_encryption_key(h, blkKey_VerifierHashInput, info.encryptedKey.hashName, info.encryptedKey.keyBits)
+        key1 = ECMA376Agile._derive_encryption_key(
+            h,
+            blkKey_VerifierHashInput,
+            info.encryptedKey.hashName,
+            info.encryptedKey.keyBits,
+        )
         key2 = ECMA376Agile._derive_encryption_key(
-            h, blkKey_encryptedVerifierHashValue, info.encryptedKey.hashName, info.encryptedKey.keyBits
+            h,
+            blkKey_encryptedVerifierHashValue,
+            info.encryptedKey.hashName,
+            info.encryptedKey.keyBits,
+        )
+        key3 = ECMA376Agile._derive_encryption_key(
+            h,
+            blkKey_encryptedKeyValue,
+            info.encryptedKey.hashName,
+            info.encryptedKey.keyBits,
         )
-        key3 = ECMA376Agile._derive_encryption_key(h, blkKey_encryptedKeyValue, info.encryptedKey.hashName, info.encryptedKey.keyBits)
 
         verifierHashInput = _random_buffer(info.encryptedKey.saltSize)
-        verifierHashInput = _resize_buffer(verifierHashInput, _round_up(len(verifierHashInput), info.encryptedKey.blockSize))
+        verifierHashInput = _resize_buffer(
+            verifierHashInput,
+            _round_up(len(verifierHashInput), info.encryptedKey.blockSize),
+        )
 
-        info.encryptedVerifierHashInput = _encrypt_aes_cbc(verifierHashInput, key1, info.encryptedKey.saltValue)
+        info.encryptedVerifierHashInput = _encrypt_aes_cbc(
+            verifierHashInput, key1, info.encryptedKey.saltValue
+        )
 
-        hashedVerifier = _get_hash_func(info.encryptedKey.hashName)(verifierHashInput).digest()
-        hashedVerifier = _resize_buffer(hashedVerifier, _round_up(len(hashedVerifier), info.encryptedKey.blockSize))
+        hashedVerifier = _get_hash_func(info.encryptedKey.hashName)(
+            verifierHashInput
+        ).digest()
+        hashedVerifier = _resize_buffer(
+            hashedVerifier, _round_up(len(hashedVerifier), info.encryptedKey.blockSize)
+        )
 
-        info.encryptedVerifierHashValue = _encrypt_aes_cbc(hashedVerifier, key2, info.encryptedKey.saltValue)
+        info.encryptedVerifierHashValue = _encrypt_aes_cbc(
+            hashedVerifier, key2, info.encryptedKey.saltValue
+        )
 
         secret_key = _random_buffer(info.encryptedKey.saltSize)
         secret_key = _normalize_key(secret_key, info.encryptedKey.keyBits // 8)
 
-        info.encryptedKeyValue = _encrypt_aes_cbc(secret_key, key3, info.encryptedKey.saltValue)
+        info.encryptedKeyValue = _encrypt_aes_cbc(
+            secret_key, key3, info.encryptedKey.saltValue
+        )
 
         info.keyData.saltValue = _get_salt(salt_size=info.keyData.saltSize)
 
@@ -333,7 +379,9 @@ def encrypt_payload(ibuf, params: ECMA376AgileCipherParams, secret_key, salt_val
             if not buf:
                 break
 
-            iv = _normalize_key(hashCalc(salt_value + pack("<I", i)).digest(), params.saltSize)
+            iv = _normalize_key(
+                hashCalc(salt_value + pack("<I", i)).digest(), params.saltSize
+            )
 
             # Per the specifications, we need to make sure the last chunk is padded to our
             # block size
@@ -351,7 +399,9 @@ def encrypt_payload(ibuf, params: ECMA376AgileCipherParams, secret_key, salt_val
         return obuf.getvalue()
 
     @staticmethod
-    def generate_integrity_parameter(encrypted_data, params: ECMA376AgileCipherParams, secret_key, salt_value):
+    def generate_integrity_parameter(
+        encrypted_data, params: ECMA376AgileCipherParams, secret_key, salt_value
+    ):
         """
         Returns the encrypted HmacKey and HmacValue.
         """
@@ -370,7 +420,15 @@ def generate_integrity_parameter(encrypted_data, params: ECMA376AgileCipherParam
         return encryptedHmacKey, encryptedHmacValue
 
     @staticmethod
-    def verify_password(password, saltValue, hashAlgorithm, encryptedVerifierHashInput, encryptedVerifierHashValue, spinValue, keyBits):
+    def verify_password(
+        password,
+        saltValue,
+        hashAlgorithm,
+        encryptedVerifierHashInput,
+        encryptedVerifierHashValue,
+        spinValue,
+        keyBits,
+    ):
         r"""
         Return True if the given password is valid.
 
@@ -387,10 +445,16 @@ def verify_password(password, saltValue, hashAlgorithm, encryptedVerifierHashInp
         """
         # NOTE: See https://docs.microsoft.com/en-us/openspecs/office_file_formats/ms-offcrypto/a57cb947-554f-4e5e-b150-3f2978225e92
 
-        h = ECMA376Agile._derive_iterated_hash_from_password(password, saltValue, hashAlgorithm, spinValue)
+        h = ECMA376Agile._derive_iterated_hash_from_password(
+            password, saltValue, hashAlgorithm, spinValue
+        )
 
-        key1 = ECMA376Agile._derive_encryption_key(h.digest(), blkKey_VerifierHashInput, hashAlgorithm, keyBits)
-        key2 = ECMA376Agile._derive_encryption_key(h.digest(), blkKey_encryptedVerifierHashValue, hashAlgorithm, keyBits)
+        key1 = ECMA376Agile._derive_encryption_key(
+            h.digest(), blkKey_VerifierHashInput, hashAlgorithm, keyBits
+        )
+        key2 = ECMA376Agile._derive_encryption_key(
+            h.digest(), blkKey_encryptedVerifierHashValue, hashAlgorithm, keyBits
+        )
 
         hash_input = _decrypt_aes_cbc(encryptedVerifierHashInput, key1, saltValue)
         hashCalc = _get_hash_func(hashAlgorithm)
@@ -402,7 +466,15 @@ def verify_password(password, saltValue, hashAlgorithm, encryptedVerifierHashInp
         return acutal_hash == expected_hash
 
     @staticmethod
-    def verify_integrity(secretKey, keyDataSalt, keyDataHashAlgorithm, keyDataBlockSize, encryptedHmacKey, encryptedHmacValue, stream):
+    def verify_integrity(
+        secretKey,
+        keyDataSalt,
+        keyDataHashAlgorithm,
+        keyDataBlockSize,
+        encryptedHmacKey,
+        encryptedHmacValue,
+        stream,
+    ):
         r"""
         Return True if the HMAC of the data payload is valid.
         """
@@ -426,12 +498,16 @@ def verify_integrity(secretKey, keyDataSalt, keyDataHashAlgorithm, keyDataBlockS
 
     @staticmethod
     def makekey_from_privkey(privkey, encryptedKeyValue):
-        privkey = serialization.load_pem_private_key(privkey.read(), password=None, backend=default_backend())
+        privkey = serialization.load_pem_private_key(
+            privkey.read(), password=None, backend=default_backend()
+        )
         skey = privkey.decrypt(encryptedKeyValue, padding.PKCS1v15())
         return skey
 
     @staticmethod
-    def makekey_from_password(password, saltValue, hashAlgorithm, encryptedKeyValue, spinValue, keyBits):
+    def makekey_from_password(
+        password, saltValue, hashAlgorithm, encryptedKeyValue, spinValue, keyBits
+    ):
         r"""
         Generate intermediate key from given password.
 
@@ -446,8 +522,12 @@ def makekey_from_password(password, saltValue, hashAlgorithm, encryptedKeyValue,
             True
         """
 
-        h = ECMA376Agile._derive_iterated_hash_from_password(password, saltValue, hashAlgorithm, spinValue)
-        encryption_key = ECMA376Agile._derive_encryption_key(h.digest(), blkKey_encryptedKeyValue, hashAlgorithm, keyBits)
+        h = ECMA376Agile._derive_iterated_hash_from_password(
+            password, saltValue, hashAlgorithm, spinValue
+        )
+        encryption_key = ECMA376Agile._derive_encryption_key(
+            h.digest(), blkKey_encryptedKeyValue, hashAlgorithm, keyBits
+        )
 
         skey = _decrypt_aes_cbc(encryptedKeyValue, encryption_key, saltValue)
 
diff --git a/msoffcrypto/method/ecma376_standard.py b/msoffcrypto/method/ecma376_standard.py
index 0be0d76..eea5477 100644
--- a/msoffcrypto/method/ecma376_standard.py
+++ b/msoffcrypto/method/ecma376_standard.py
@@ -54,7 +54,9 @@ def verifykey(key, encryptedVerifier, encryptedVerifierHash):
         return expected_hash == verifierHash
 
     @staticmethod
-    def makekey_from_password(password, algId, algIdHash, providerType, keySize, saltSize, salt):
+    def makekey_from_password(
+        password, algId, algIdHash, providerType, keySize, saltSize, salt
+    ):
         r"""
         Generate intermediate key from given password.
 
@@ -69,8 +71,20 @@ def makekey_from_password(password, algId, algIdHash, providerType, keySize, sal
             >>> ECMA376Standard.makekey_from_password(password, algId, algIdHash, providerType, keySize, saltSize, salt) == expected
             True
         """
-        logger.debug([password, hex(algId), hex(algIdHash), hex(providerType), keySize, saltSize, salt])
-        xor_bytes = lambda a, b: bytearray([p ^ q for p, q in zip(bytearray(a), bytearray(b))])  # bytearray() for Python 2 compat.
+        logger.debug(
+            [
+                password,
+                hex(algId),
+                hex(algIdHash),
+                hex(providerType),
+                keySize,
+                saltSize,
+                salt,
+            ]
+        )
+        xor_bytes = lambda a, b: bytearray(
+            [p ^ q for p, q in zip(bytearray(a), bytearray(b))]
+        )  # bytearray() for Python 2 compat.
 
         # https://msdn.microsoft.com/en-us/library/dd925430(v=office.12).aspx
         ITER_COUNT = 50000
diff --git a/msoffcrypto/method/rc4_cryptoapi.py b/msoffcrypto/method/rc4_cryptoapi.py
index 184a5ae..1666a20 100644
--- a/msoffcrypto/method/rc4_cryptoapi.py
+++ b/msoffcrypto/method/rc4_cryptoapi.py
@@ -32,7 +32,15 @@ def __init__(self):
         pass
 
     @staticmethod
-    def verifypw(password, salt, keySize, encryptedVerifier, encryptedVerifierHash, algId=0x00006801, block=0):
+    def verifypw(
+        password,
+        salt,
+        keySize,
+        encryptedVerifier,
+        encryptedVerifierHash,
+        algId=0x00006801,
+        block=0,
+    ):
         r"""
         Return True if the given password is valid.
         """