py2docfx 0.1.16.dev2064350__py3-none-any.whl → 0.1.17__py3-none-any.whl

py2docfx/venv/venv1/Lib/site-packages/cryptography/hazmat/primitives/padding.py

@@ -5,20 +5,19 @@
 from __future__ import annotations
 
 import abc
-import typing
 
 from cryptography import utils
-from cryptography.exceptions import AlreadyFinalized
 from cryptography.hazmat.bindings._rust import (
+    ANSIX923PaddingContext,
+    ANSIX923UnpaddingContext,
     PKCS7PaddingContext,
     PKCS7UnpaddingContext,
-    check_ansix923_padding,
 )
 
 
 class PaddingContext(metaclass=abc.ABCMeta):
     @abc.abstractmethod
-    def update(self, data: bytes) -> bytes:
+    def update(self, data: utils.Buffer) -> bytes:
         """
         Pads the provided bytes and returns any available data as bytes.
         """
@@ -38,74 +37,6 @@ def _byte_padding_check(block_size: int) -> None:
         raise ValueError("block_size must be a multiple of 8.")
 
 
-def _byte_padding_update(
-    buffer_: bytes | None, data: bytes, block_size: int
-) -> tuple[bytes, bytes]:
-    if buffer_ is None:
-        raise AlreadyFinalized("Context was already finalized.")
-
-    utils._check_byteslike("data", data)
-
-    buffer_ += bytes(data)
-
-    finished_blocks = len(buffer_) // (block_size // 8)
-
-    result = buffer_[: finished_blocks * (block_size // 8)]
-    buffer_ = buffer_[finished_blocks * (block_size // 8) :]
-
-    return buffer_, result
-
-
-def _byte_padding_pad(
-    buffer_: bytes | None,
-    block_size: int,
-    paddingfn: typing.Callable[[int], bytes],
-) -> bytes:
-    if buffer_ is None:
-        raise AlreadyFinalized("Context was already finalized.")
-
-    pad_size = block_size // 8 - len(buffer_)
-    return buffer_ + paddingfn(pad_size)
-
-
-def _byte_unpadding_update(
-    buffer_: bytes | None, data: bytes, block_size: int
-) -> tuple[bytes, bytes]:
-    if buffer_ is None:
-        raise AlreadyFinalized("Context was already finalized.")
-
-    utils._check_byteslike("data", data)
-
-    buffer_ += bytes(data)
-
-    finished_blocks = max(len(buffer_) // (block_size // 8) - 1, 0)
-
-    result = buffer_[: finished_blocks * (block_size // 8)]
-    buffer_ = buffer_[finished_blocks * (block_size // 8) :]
-
-    return buffer_, result
-
-
-def _byte_unpadding_check(
-    buffer_: bytes | None,
-    block_size: int,
-    checkfn: typing.Callable[[bytes], int],
-) -> bytes:
-    if buffer_ is None:
-        raise AlreadyFinalized("Context was already finalized.")
-
-    if len(buffer_) != block_size // 8:
-        raise ValueError("Invalid padding bytes.")
-
-    valid = checkfn(buffer_)
-
-    if not valid:
-        raise ValueError("Invalid padding bytes.")
-
-    pad_size = buffer_[-1]
-    return buffer_[:-pad_size]
-
-
 class PKCS7:
     def __init__(self, block_size: int):
         _byte_padding_check(block_size)
@@ -128,56 +59,11 @@ class ANSIX923:
         self.block_size = block_size
 
     def padder(self) -> PaddingContext:
-        return _ANSIX923PaddingContext(self.block_size)
+        return ANSIX923PaddingContext(self.block_size)
 
     def unpadder(self) -> PaddingContext:
-        return _ANSIX923UnpaddingContext(self.block_size)
-
-
-class _ANSIX923PaddingContext(PaddingContext):
-    _buffer: bytes | None
-
-    def __init__(self, block_size: int):
-        self.block_size = block_size
-        # TODO: more copies than necessary, we should use zero-buffer (#193)
-        self._buffer = b""
-
-    def update(self, data: bytes) -> bytes:
-        self._buffer, result = _byte_padding_update(
-            self._buffer, data, self.block_size
-        )
-        return result
+        return ANSIX923UnpaddingContext(self.block_size)
 
-    def _padding(self, size: int) -> bytes:
-        return bytes([0]) * (size - 1) + bytes([size])
 
-    def finalize(self) -> bytes:
-        result = _byte_padding_pad(
-            self._buffer, self.block_size, self._padding
-        )
-        self._buffer = None
-        return result
-
-
-class _ANSIX923UnpaddingContext(PaddingContext):
-    _buffer: bytes | None
-
-    def __init__(self, block_size: int):
-        self.block_size = block_size
-        # TODO: more copies than necessary, we should use zero-buffer (#193)
-        self._buffer = b""
-
-    def update(self, data: bytes) -> bytes:
-        self._buffer, result = _byte_unpadding_update(
-            self._buffer, data, self.block_size
-        )
-        return result
-
-    def finalize(self) -> bytes:
-        result = _byte_unpadding_check(
-            self._buffer,
-            self.block_size,
-            check_ansix923_padding,
-        )
-        self._buffer = None
-        return result
+PaddingContext.register(ANSIX923PaddingContext)
+PaddingContext.register(ANSIX923UnpaddingContext)

py2docfx/venv/venv1/Lib/site-packages/cryptography/hazmat/primitives/serialization/__init__.py

@@ -33,6 +33,7 @@ from cryptography.hazmat.primitives.serialization.ssh import (
     load_ssh_private_key,
     load_ssh_public_identity,
     load_ssh_public_key,
+    ssh_key_fingerprint,
 )
 
 __all__ = [
@@ -60,4 +61,5 @@ __all__ = [
     "load_ssh_private_key",
     "load_ssh_public_identity",
     "load_ssh_public_key",
+    "ssh_key_fingerprint",
 ]

py2docfx/venv/venv1/Lib/site-packages/cryptography/hazmat/primitives/serialization/pkcs12.py

@@ -5,6 +5,7 @@
 from __future__ import annotations
 
 import typing
+from collections.abc import Iterable
 
 from cryptography import x509
 from cryptography.hazmat.bindings._rust import pkcs12 as rust_pkcs12
@@ -26,6 +27,7 @@ __all__ = [
     "PKCS12PrivateKeyTypes",
     "load_key_and_certificates",
     "load_pkcs12",
+    "serialize_java_truststore",
     "serialize_key_and_certificates",
 ]
 
@@ -118,11 +120,29 @@ _PKCS12CATypes = typing.Union[
 ]
 
 
+def serialize_java_truststore(
+    certs: Iterable[PKCS12Certificate],
+    encryption_algorithm: serialization.KeySerializationEncryption,
+) -> bytes:
+    if not certs:
+        raise ValueError("You must supply at least one cert")
+
+    if not isinstance(
+        encryption_algorithm, serialization.KeySerializationEncryption
+    ):
+        raise TypeError(
+            "Key encryption algorithm must be a "
+            "KeySerializationEncryption instance"
+        )
+
+    return rust_pkcs12.serialize_java_truststore(certs, encryption_algorithm)
+
+
 def serialize_key_and_certificates(
     name: bytes | None,
     key: PKCS12PrivateKeyTypes | None,
     cert: x509.Certificate | None,
-    cas: typing.Iterable[_PKCS12CATypes] | None,
+    cas: Iterable[_PKCS12CATypes] | None,
     encryption_algorithm: serialization.KeySerializationEncryption,
 ) -> bytes:
     if key is not None and not isinstance(

py2docfx/venv/venv1/Lib/site-packages/cryptography/hazmat/primitives/serialization/pkcs7.py

@@ -10,12 +10,16 @@ import email.message
 import email.policy
 import io
 import typing
+from collections.abc import Iterable
 
 from cryptography import utils, x509
 from cryptography.exceptions import UnsupportedAlgorithm, _Reasons
 from cryptography.hazmat.bindings._rust import pkcs7 as rust_pkcs7
 from cryptography.hazmat.primitives import hashes, serialization
 from cryptography.hazmat.primitives.asymmetric import ec, padding, rsa
+from cryptography.hazmat.primitives.ciphers import (
+    algorithms,
+)
 from cryptography.utils import _check_byteslike
 
 load_pem_pkcs7_certificates = rust_pkcs7.load_pem_pkcs7_certificates
@@ -35,6 +39,10 @@ PKCS7PrivateKeyTypes = typing.Union[
     rsa.RSAPrivateKey, ec.EllipticCurvePrivateKey
 ]
 
+ContentEncryptionAlgorithm = typing.Union[
+    typing.Type[algorithms.AES128], typing.Type[algorithms.AES256]
+]
+
 
 class PKCS7Options(utils.Enum):
     Text = "Add text/plain MIME type"
@@ -48,7 +56,7 @@ class PKCS7Options(utils.Enum):
 class PKCS7SignatureBuilder:
     def __init__(
         self,
-        data: bytes | None = None,
+        data: utils.Buffer | None = None,
         signers: list[
             tuple[
                 x509.Certificate,
@@ -63,7 +71,7 @@ class PKCS7SignatureBuilder:
         self._signers = signers
         self._additional_certs = additional_certs
 
-    def set_data(self, data: bytes) -> PKCS7SignatureBuilder:
+    def set_data(self, data: utils.Buffer) -> PKCS7SignatureBuilder:
         _check_byteslike("data", data)
         if self._data is not None:
             raise ValueError("data may only be set once")
@@ -126,7 +134,7 @@ class PKCS7SignatureBuilder:
     def sign(
         self,
         encoding: serialization.Encoding,
-        options: typing.Iterable[PKCS7Options],
+        options: Iterable[PKCS7Options],
         backend: typing.Any = None,
     ) -> bytes:
         if len(self._signers) == 0:
@@ -184,6 +192,8 @@ class PKCS7EnvelopeBuilder:
         *,
         _data: bytes | None = None,
         _recipients: list[x509.Certificate] | None = None,
+        _content_encryption_algorithm: ContentEncryptionAlgorithm
+        | None = None,
     ):
         from cryptography.hazmat.backends.openssl.backend import (
             backend as ossl,
@@ -197,13 +207,18 @@ class PKCS7EnvelopeBuilder:
             )
         self._data = _data
         self._recipients = _recipients if _recipients is not None else []
+        self._content_encryption_algorithm = _content_encryption_algorithm
 
     def set_data(self, data: bytes) -> PKCS7EnvelopeBuilder:
         _check_byteslike("data", data)
         if self._data is not None:
             raise ValueError("data may only be set once")
 
-        return PKCS7EnvelopeBuilder(_data=data, _recipients=self._recipients)
+        return PKCS7EnvelopeBuilder(
+            _data=data,
+            _recipients=self._recipients,
+            _content_encryption_algorithm=self._content_encryption_algorithm,
+        )
 
     def add_recipient(
         self,
@@ -221,17 +236,42 @@ class PKCS7EnvelopeBuilder:
                 *self._recipients,
                 certificate,
             ],
+            _content_encryption_algorithm=self._content_encryption_algorithm,
+        )
+
+    def set_content_encryption_algorithm(
+        self, content_encryption_algorithm: ContentEncryptionAlgorithm
+    ) -> PKCS7EnvelopeBuilder:
+        if self._content_encryption_algorithm is not None:
+            raise ValueError("Content encryption algo may only be set once")
+        if content_encryption_algorithm not in {
+            algorithms.AES128,
+            algorithms.AES256,
+        }:
+            raise TypeError("Only AES128 and AES256 are supported")
+
+        return PKCS7EnvelopeBuilder(
+            _data=self._data,
+            _recipients=self._recipients,
+            _content_encryption_algorithm=content_encryption_algorithm,
         )
 
     def encrypt(
         self,
         encoding: serialization.Encoding,
-        options: typing.Iterable[PKCS7Options],
+        options: Iterable[PKCS7Options],
     ) -> bytes:
         if len(self._recipients) == 0:
             raise ValueError("Must have at least one recipient")
         if self._data is None:
             raise ValueError("You must add data to encrypt")
+
+        # The default content encryption algorithm is AES-128, which the S/MIME
+        # v3.2 RFC specifies as MUST support (https://datatracker.ietf.org/doc/html/rfc5751#section-2.7)
+        content_encryption_algorithm = (
+            self._content_encryption_algorithm or algorithms.AES128
+        )
+
         options = list(options)
         if not all(isinstance(x, PKCS7Options) for x in options):
             raise ValueError("options must be from the PKCS7Options enum")
@@ -260,7 +300,9 @@ class PKCS7EnvelopeBuilder:
                 "Cannot use Binary and Text options at the same time"
             )
 
-        return rust_pkcs7.encrypt_and_serialize(self, encoding, options)
+        return rust_pkcs7.encrypt_and_serialize(
+            self, content_encryption_algorithm, encoding, options
+        )
 
 
 pkcs7_decrypt_der = rust_pkcs7.decrypt_der

py2docfx/venv/venv1/Lib/site-packages/cryptography/hazmat/primitives/serialization/ssh.py

@@ -169,20 +169,20 @@ def _ecdsa_key_type(public_key: ec.EllipticCurvePublicKey) -> bytes:
 
 
 def _ssh_pem_encode(
-    data: bytes,
+    data: utils.Buffer,
     prefix: bytes = _SK_START + b"\n",
     suffix: bytes = _SK_END + b"\n",
 ) -> bytes:
     return b"".join([prefix, _base64_encode(data), suffix])
 
 
-def _check_block_size(data: bytes, block_len: int) -> None:
+def _check_block_size(data: utils.Buffer, block_len: int) -> None:
     """Require data to be full blocks"""
     if not data or len(data) % block_len != 0:
         raise ValueError("Corrupt data: missing padding")
 
 
-def _check_empty(data: bytes) -> None:
+def _check_empty(data: utils.Buffer) -> None:
     """All data should have been parsed."""
     if data:
         raise ValueError("Corrupt data: unparsed data")
@@ -196,7 +196,9 @@ def _init_cipher(
 ) -> Cipher[modes.CBC | modes.CTR | modes.GCM]:
     """Generate key + iv and return cipher."""
     if not password:
-        raise ValueError("Key is password-protected.")
+        raise TypeError(
+            "Key is password-protected, but password was not provided."
+        )
 
     ciph = _SSH_CIPHERS[ciphername]
     seed = _bcrypt_kdf(
@@ -251,14 +253,14 @@ def _to_mpint(val: int) -> bytes:
 class _FragList:
     """Build recursive structure without data copy."""
 
-    flist: list[bytes]
+    flist: list[utils.Buffer]
 
-    def __init__(self, init: list[bytes] | None = None) -> None:
+    def __init__(self, init: list[utils.Buffer] | None = None) -> None:
         self.flist = []
         if init:
             self.flist.extend(init)
 
-    def put_raw(self, val: bytes) -> None:
+    def put_raw(self, val: utils.Buffer) -> None:
         """Add plain bytes"""
         self.flist.append(val)
 
@@ -329,7 +331,7 @@ class _SSHFormatRSA:
         return public_key, data
 
     def load_private(
-        self, data: memoryview, pubfields
+        self, data: memoryview, pubfields, unsafe_skip_rsa_key_validation: bool
     ) -> tuple[rsa.RSAPrivateKey, memoryview]:
         """Make RSA private key from data."""
         n, data = _get_mpint(data)
@@ -347,7 +349,9 @@ class _SSHFormatRSA:
         private_numbers = rsa.RSAPrivateNumbers(
             p, q, d, dmp1, dmq1, iqmp, public_numbers
         )
-        private_key = private_numbers.private_key()
+        private_key = private_numbers.private_key(
+            unsafe_skip_rsa_key_validation=unsafe_skip_rsa_key_validation
+        )
         return private_key, data
 
     def encode_public(
@@ -403,7 +407,7 @@ class _SSHFormatDSA:
         return public_key, data
 
     def load_private(
-        self, data: memoryview, pubfields
+        self, data: memoryview, pubfields, unsafe_skip_rsa_key_validation: bool
     ) -> tuple[dsa.DSAPrivateKey, memoryview]:
         """Make DSA private key from data."""
         (p, q, g, y), data = self.get_public(data)
@@ -483,7 +487,7 @@ class _SSHFormatECDSA:
         return public_key, data
 
     def load_private(
-        self, data: memoryview, pubfields
+        self, data: memoryview, pubfields, unsafe_skip_rsa_key_validation: bool
     ) -> tuple[ec.EllipticCurvePrivateKey, memoryview]:
         """Make ECDSA private key from data."""
         (curve_name, point), data = self.get_public(data)
@@ -543,7 +547,7 @@ class _SSHFormatEd25519:
         return public_key, data
 
     def load_private(
-        self, data: memoryview, pubfields
+        self, data: memoryview, pubfields, unsafe_skip_rsa_key_validation: bool
     ) -> tuple[ed25519.Ed25519PrivateKey, memoryview]:
         """Make Ed25519 private key from data."""
         (point,), data = self.get_public(data)
@@ -612,6 +616,13 @@ class _SSHFormatSKEd25519:
         _, data = load_application(data)
         return public_key, data
 
+    def get_public(self, data: memoryview) -> typing.NoReturn:
+        # Confusingly `get_public` is an entry point used by private key
+        # loading.
+        raise UnsupportedAlgorithm(
+            "sk-ssh-ed25519 private keys cannot be loaded"
+        )
+
 
 class _SSHFormatSKECDSA:
     """
@@ -631,6 +642,13 @@ class _SSHFormatSKECDSA:
         _, data = load_application(data)
         return public_key, data
 
+    def get_public(self, data: memoryview) -> typing.NoReturn:
+        # Confusingly `get_public` is an entry point used by private key
+        # loading.
+        raise UnsupportedAlgorithm(
+            "sk-ecdsa-sha2-nistp256 private keys cannot be loaded"
+        )
+
 
 _KEY_FORMATS = {
     _SSH_RSA: _SSHFormatRSA(),
@@ -644,7 +662,7 @@ _KEY_FORMATS = {
 }
 
 
-def _lookup_kformat(key_type: bytes):
+def _lookup_kformat(key_type: utils.Buffer):
     """Return valid format or throw error"""
     if not isinstance(key_type, bytes):
         key_type = memoryview(key_type).tobytes()
@@ -662,9 +680,11 @@ SSHPrivateKeyTypes = typing.Union[
 
 
 def load_ssh_private_key(
-    data: bytes,
+    data: utils.Buffer,
     password: bytes | None,
     backend: typing.Any = None,
+    *,
+    unsafe_skip_rsa_key_validation: bool = False,
 ) -> SSHPrivateKeyTypes:
     """Load private key from OpenSSH custom encoding."""
     utils._check_byteslike("data", data)
@@ -696,7 +716,7 @@ def load_ssh_private_key(
     pubfields, pubdata = kformat.get_public(pubdata)
     _check_empty(pubdata)
 
-    if (ciphername, kdfname) != (_NONE, _NONE):
+    if ciphername != _NONE or kdfname != _NONE:
         ciphername_bytes = ciphername.tobytes()
         if ciphername_bytes not in _SSH_CIPHERS:
             raise UnsupportedAlgorithm(
@@ -731,6 +751,10 @@ def load_ssh_private_key(
             # should be no output from finalize
             _check_empty(dec.finalize())
     else:
+        if password:
+            raise TypeError(
+                "Password was given but private key is not encrypted."
+            )
         # load secret data
         edata, data = _get_sshstr(data)
         _check_empty(data)
@@ -745,7 +769,11 @@ def load_ssh_private_key(
     key_type, edata = _get_sshstr(edata)
     if key_type != pub_key_type:
         raise ValueError("Corrupt data: key type mismatch")
-    private_key, edata = kformat.load_private(edata, pubfields)
+    private_key, edata = kformat.load_private(
+        edata,
+        pubfields,
+        unsafe_skip_rsa_key_validation=unsafe_skip_rsa_key_validation,
+    )
     # We don't use the comment
     _, edata = _get_sshstr(edata)
 
@@ -1001,7 +1029,7 @@ def _get_ec_hash_alg(curve: ec.EllipticCurve) -> hashes.HashAlgorithm:
 
 
 def _load_ssh_public_identity(
-    data: bytes,
+    data: utils.Buffer,
     _legacy_dsa_allowed=False,
 ) -> SSHCertificate | SSHPublicKeyTypes:
     utils._check_byteslike("data", data)
@@ -1121,8 +1149,30 @@ def _parse_exts_opts(exts_opts: memoryview) -> dict[bytes, bytes]:
     return result
 
 
+def ssh_key_fingerprint(
+    key: SSHPublicKeyTypes,
+    hash_algorithm: hashes.MD5 | hashes.SHA256,
+) -> bytes:
+    if not isinstance(hash_algorithm, (hashes.MD5, hashes.SHA256)):
+        raise TypeError("hash_algorithm must be either MD5 or SHA256")
+
+    key_type = _get_ssh_key_type(key)
+    kformat = _lookup_kformat(key_type)
+
+    f_pub = _FragList()
+    f_pub.put_sshstr(key_type)
+    kformat.encode_public(key, f_pub)
+
+    ssh_binary_data = f_pub.tobytes()
+
+    # Hash the binary data
+    hash_obj = hashes.Hash(hash_algorithm)
+    hash_obj.update(ssh_binary_data)
+    return hash_obj.finalize()
+
+
 def load_ssh_public_key(
-    data: bytes, backend: typing.Any = None
+    data: utils.Buffer, backend: typing.Any = None
 ) -> SSHPublicKeyTypes:
     cert_or_key = _load_ssh_public_identity(data, _legacy_dsa_allowed=True)
     public_key: SSHPublicKeyTypes

py2docfx/venv/venv1/Lib/site-packages/cryptography/hazmat/primitives/twofactor/hotp.py

@@ -11,6 +11,7 @@ from urllib.parse import quote, urlencode
 from cryptography.hazmat.primitives import constant_time, hmac
 from cryptography.hazmat.primitives.hashes import SHA1, SHA256, SHA512
 from cryptography.hazmat.primitives.twofactor import InvalidToken
+from cryptography.utils import Buffer
 
 HOTPHashTypes = typing.Union[SHA1, SHA256, SHA512]
 
@@ -44,7 +45,7 @@ def _generate_uri(
 class HOTP:
     def __init__(
         self,
-        key: bytes,
+        key: Buffer,
         length: int,
         algorithm: HOTPHashTypes,
         backend: typing.Any = None,
@@ -84,7 +85,7 @@ class HOTP:
         try:
             ctx.update(counter.to_bytes(length=8, byteorder="big"))
         except OverflowError:
-            raise ValueError(f"Counter must be between 0 and {2 ** 64 - 1}.")
+            raise ValueError(f"Counter must be between 0 and {2**64 - 1}.")
 
         hmac_value = ctx.finalize()
 

py2docfx/venv/venv1/Lib/site-packages/cryptography/hazmat/primitives/twofactor/totp.py

@@ -13,12 +13,13 @@ from cryptography.hazmat.primitives.twofactor.hotp import (
     HOTPHashTypes,
     _generate_uri,
 )
+from cryptography.utils import Buffer
 
 
 class TOTP:
     def __init__(
         self,
-        key: bytes,
+        key: Buffer,
         length: int,
         algorithm: HOTPHashTypes,
         time_step: int,

py2docfx/venv/venv1/Lib/site-packages/cryptography/utils.py

@@ -9,6 +9,7 @@ import sys
 import types
 import typing
 import warnings
+from collections.abc import Callable, Sequence
 
 
 # We use a UserWarning subclass, instead of DeprecationWarning, because CPython
@@ -26,6 +27,17 @@ DeprecatedIn40 = CryptographyDeprecationWarning
 DeprecatedIn41 = CryptographyDeprecationWarning
 DeprecatedIn42 = CryptographyDeprecationWarning
 DeprecatedIn43 = CryptographyDeprecationWarning
+DeprecatedIn45 = CryptographyDeprecationWarning
+
+
+# If you're wondering why we don't use `Buffer`, it's because `Buffer` would
+# be more accurately named: Bufferable. It means something which has an
+# `__buffer__`. Which means you can't actually treat the result as a buffer
+# (and do things like take a `len()`).
+if sys.version_info >= (3, 9):
+    Buffer = typing.Union[bytes, bytearray, memoryview]
+else:
+    Buffer = typing.ByteString
 
 
 def _check_bytes(name: str, value: bytes) -> None:
@@ -33,7 +45,7 @@ def _check_bytes(name: str, value: bytes) -> None:
         raise TypeError(f"{name} must be bytes")
 
 
-def _check_byteslike(name: str, value: bytes) -> None:
+def _check_byteslike(name: str, value: Buffer) -> None:
     try:
         memoryview(value)
     except TypeError:
@@ -81,7 +93,7 @@ class _ModuleWithDeprecations(types.ModuleType):
 
         delattr(self._module, attr)
 
-    def __dir__(self) -> typing.Sequence[str]:
+    def __dir__(self) -> Sequence[str]:
         return ["_module", *dir(self._module)]
 
 
@@ -102,7 +114,7 @@ def deprecated(
     return dv
 
 
-def cached_property(func: typing.Callable) -> property:
+def cached_property(func: Callable) -> property:
     cached_name = f"_cached_{func}"
     sentinel = object()
 

py2docfx/venv/venv1/Lib/site-packages/cryptography/x509/__init__.py

@@ -66,6 +66,7 @@ from cryptography.x509.extensions import (
     PolicyInformation,
     PrecertificateSignedCertificateTimestamps,
     PrecertPoison,
+    PrivateKeyUsagePeriod,
     ProfessionInfo,
     ReasonFlags,
     SignedCertificateTimestamps,
@@ -115,6 +116,7 @@ OID_FRESHEST_CRL = ExtensionOID.FRESHEST_CRL
 OID_INHIBIT_ANY_POLICY = ExtensionOID.INHIBIT_ANY_POLICY
 OID_ISSUER_ALTERNATIVE_NAME = ExtensionOID.ISSUER_ALTERNATIVE_NAME
 OID_KEY_USAGE = ExtensionOID.KEY_USAGE
+OID_PRIVATE_KEY_USAGE_PERIOD = ExtensionOID.PRIVATE_KEY_USAGE_PERIOD
 OID_NAME_CONSTRAINTS = ExtensionOID.NAME_CONSTRAINTS
 OID_OCSP_NO_CHECK = ExtensionOID.OCSP_NO_CHECK
 OID_POLICY_CONSTRAINTS = ExtensionOID.POLICY_CONSTRAINTS
@@ -233,6 +235,7 @@ __all__ = [
     "PolicyInformation",
     "PrecertPoison",
     "PrecertificateSignedCertificateTimestamps",
+    "PrivateKeyUsagePeriod",
     "ProfessionInfo",
     "PublicKeyAlgorithmOID",
     "RFC822Name",