Big diff: Use new "|" union syntax (#5872)

stdlib/ssl.pyi

@@ -19,7 +19,7 @@ class _Cipher(TypedDict):
     alg_bits: int
     auth: str
     description: str
-    digest: Optional[str]
+    digest: str | None
     id: int
     kea: str
     name: str
@@ -47,18 +47,18 @@ else:
 
 def wrap_socket(
     sock: socket.socket,
-    keyfile: Optional[str] = ...,
-    certfile: Optional[str] = ...,
+    keyfile: str | None = ...,
+    certfile: str | None = ...,
     server_side: bool = ...,
     cert_reqs: int = ...,
     ssl_version: int = ...,
-    ca_certs: Optional[str] = ...,
+    ca_certs: str | None = ...,
     do_handshake_on_connect: bool = ...,
     suppress_ragged_eofs: bool = ...,
-    ciphers: Optional[str] = ...,
+    ciphers: str | None = ...,
 ) -> SSLSocket: ...
 def create_default_context(
-    purpose: Any = ..., *, cafile: Optional[str] = ..., capath: Optional[str] = ..., cadata: Union[str, bytes, None] = ...
+    purpose: Any = ..., *, cafile: str | None = ..., capath: str | None = ..., cadata: str | bytes | None = ...
 ) -> SSLContext: ...
 
 if sys.version_info >= (3, 7):
@@ -68,25 +68,25 @@ if sys.version_info >= (3, 7):
         cert_reqs: int = ...,
         check_hostname: bool = ...,
         purpose: Any = ...,
-        certfile: Optional[str] = ...,
-        keyfile: Optional[str] = ...,
-        cafile: Optional[str] = ...,
-        capath: Optional[str] = ...,
-        cadata: Union[str, bytes, None] = ...,
+        certfile: str | None = ...,
+        keyfile: str | None = ...,
+        cafile: str | None = ...,
+        capath: str | None = ...,
+        cadata: str | bytes | None = ...,
     ) -> SSLContext: ...
 
 else:
     def _create_unverified_context(
         protocol: int = ...,
         *,
-        cert_reqs: Optional[int] = ...,
+        cert_reqs: int | None = ...,
         check_hostname: bool = ...,
         purpose: Any = ...,
-        certfile: Optional[str] = ...,
-        keyfile: Optional[str] = ...,
-        cafile: Optional[str] = ...,
-        capath: Optional[str] = ...,
-        cadata: Union[str, bytes, None] = ...,
+        certfile: str | None = ...,
+        keyfile: str | None = ...,
+        cafile: str | None = ...,
+        capath: str | None = ...,
+        cadata: str | bytes | None = ...,
     ) -> SSLContext: ...
 
 _create_default_https_context: Callable[..., SSLContext]
@@ -98,7 +98,7 @@ def RAND_egd(path: str) -> None: ...
 def RAND_add(__s: bytes, __entropy: float) -> None: ...
 def match_hostname(cert: _PeerCertRetType, hostname: str) -> None: ...
 def cert_time_to_seconds(cert_time: str) -> int: ...
-def get_server_certificate(addr: Tuple[str, int], ssl_version: int = ..., ca_certs: Optional[str] = ...) -> str: ...
+def get_server_certificate(addr: Tuple[str, int], ssl_version: int = ..., ca_certs: str | None = ...) -> str: ...
 def DER_cert_to_PEM_cert(der_cert_bytes: bytes) -> str: ...
 def PEM_cert_to_DER_cert(pem_cert_string: str) -> bytes: ...
 
@@ -286,68 +286,66 @@ class Purpose(_ASN1Object, enum.Enum):
 class SSLSocket(socket.socket):
     context: SSLContext
     server_side: bool
-    server_hostname: Optional[str]
-    session: Optional[SSLSession]
-    session_reused: Optional[bool]
+    server_hostname: str | None
+    session: SSLSession | None
+    session_reused: bool | None
     if sys.version_info < (3, 7):
         def __init__(
             self,
-            sock: Optional[socket.socket] = ...,
-            keyfile: Optional[str] = ...,
-            certfile: Optional[str] = ...,
+            sock: socket.socket | None = ...,
+            keyfile: str | None = ...,
+            certfile: str | None = ...,
             server_side: bool = ...,
             cert_reqs: int = ...,
             ssl_version: int = ...,
-            ca_certs: Optional[str] = ...,
+            ca_certs: str | None = ...,
             do_handshake_on_connect: bool = ...,
             family: int = ...,
             type: int = ...,
             proto: int = ...,
-            fileno: Optional[int] = ...,
+            fileno: int | None = ...,
             suppress_ragged_eofs: bool = ...,
-            npn_protocols: Optional[Iterable[str]] = ...,
-            ciphers: Optional[str] = ...,
-            server_hostname: Optional[str] = ...,
-            _context: Optional[SSLContext] = ...,
-            _session: Optional[Any] = ...,
+            npn_protocols: Iterable[str] | None = ...,
+            ciphers: str | None = ...,
+            server_hostname: str | None = ...,
+            _context: SSLContext | None = ...,
+            _session: Any | None = ...,
         ) -> None: ...
     else:
         def __init__(self, *args: Any, **kwargs: Any) -> None: ...
-    def connect(self, addr: Union[socket._Address, bytes]) -> None: ...
-    def connect_ex(self, addr: Union[socket._Address, bytes]) -> int: ...
+    def connect(self, addr: socket._Address | bytes) -> None: ...
+    def connect_ex(self, addr: socket._Address | bytes) -> int: ...
     def recv(self, buflen: int = ..., flags: int = ...) -> bytes: ...
-    def recv_into(self, buffer: WriteableBuffer, nbytes: Optional[int] = ..., flags: int = ...) -> int: ...
+    def recv_into(self, buffer: WriteableBuffer, nbytes: int | None = ..., flags: int = ...) -> int: ...
     def recvfrom(self, buflen: int = ..., flags: int = ...) -> tuple[bytes, socket._RetAddress]: ...
     def recvfrom_into(
-        self, buffer: WriteableBuffer, nbytes: Optional[int] = ..., flags: int = ...
+        self, buffer: WriteableBuffer, nbytes: int | None = ..., flags: int = ...
     ) -> tuple[int, socket._RetAddress]: ...
     def send(self, data: ReadableBuffer, flags: int = ...) -> int: ...
     def sendall(self, data: ReadableBuffer, flags: int = ...) -> None: ...
     @overload
     def sendto(self, data: ReadableBuffer, flags_or_addr: socket._Address) -> int: ...
     @overload
-    def sendto(
-        self, data: ReadableBuffer, flags_or_addr: Union[int, socket._Address], addr: Optional[socket._Address] = ...
-    ) -> int: ...
+    def sendto(self, data: ReadableBuffer, flags_or_addr: int | socket._Address, addr: socket._Address | None = ...) -> int: ...
     def shutdown(self, how: int) -> None: ...
-    def read(self, len: int = ..., buffer: Optional[bytearray] = ...) -> bytes: ...
+    def read(self, len: int = ..., buffer: bytearray | None = ...) -> bytes: ...
     def write(self, data: bytes) -> int: ...
     def do_handshake(self, block: bool = ...) -> None: ...  # block is undocumented
     @overload
-    def getpeercert(self, binary_form: Literal[False] = ...) -> Optional[_PeerCertRetDictType]: ...
+    def getpeercert(self, binary_form: Literal[False] = ...) -> _PeerCertRetDictType | None: ...
     @overload
-    def getpeercert(self, binary_form: Literal[True]) -> Optional[bytes]: ...
+    def getpeercert(self, binary_form: Literal[True]) -> bytes | None: ...
     @overload
     def getpeercert(self, binary_form: bool) -> _PeerCertRetType: ...
-    def cipher(self) -> Optional[Tuple[str, str, int]]: ...
-    def shared_ciphers(self) -> Optional[List[Tuple[str, str, int]]]: ...
-    def compression(self) -> Optional[str]: ...
-    def get_channel_binding(self, cb_type: str = ...) -> Optional[bytes]: ...
-    def selected_alpn_protocol(self) -> Optional[str]: ...
-    def selected_npn_protocol(self) -> Optional[str]: ...
+    def cipher(self) -> Tuple[str, str, int] | None: ...
+    def shared_ciphers(self) -> List[Tuple[str, str, int]] | None: ...
+    def compression(self) -> str | None: ...
+    def get_channel_binding(self, cb_type: str = ...) -> bytes | None: ...
+    def selected_alpn_protocol(self) -> str | None: ...
+    def selected_npn_protocol(self) -> str | None: ...
     def accept(self) -> Tuple[SSLSocket, socket._RetAddress]: ...
     def unwrap(self) -> socket.socket: ...
-    def version(self) -> Optional[str]: ...
+    def version(self) -> str | None: ...
     def pending(self) -> int: ...
     if sys.version_info >= (3, 8):
         def verify_client_post_handshake(self) -> None: ...
@@ -373,7 +371,7 @@ class SSLContext:
         hostname_checks_common_name: bool
         maximum_version: TLSVersion
         minimum_version: TLSVersion
-        sni_callback: Optional[Callable[[SSLObject, str, SSLContext], Union[None, int]]]
+        sni_callback: Callable[[SSLObject, str, SSLContext], None | int] | None
         sslobject_class: ClassVar[Type[SSLObject]]
         sslsocket_class: ClassVar[Type[SSLSocket]]
     if sys.version_info >= (3, 8):
@@ -382,23 +380,21 @@ class SSLContext:
     def __new__(cls, protocol: int = ..., *args: Any, **kwargs: Any) -> SSLContext: ...
     def __init__(self, protocol: int = ...) -> None: ...
     def cert_store_stats(self) -> Dict[str, int]: ...
-    def load_cert_chain(
-        self, certfile: StrPath, keyfile: Optional[StrPath] = ..., password: Optional[_PasswordType] = ...
-    ) -> None: ...
+    def load_cert_chain(self, certfile: StrPath, keyfile: StrPath | None = ..., password: _PasswordType | None = ...) -> None: ...
     def load_default_certs(self, purpose: Purpose = ...) -> None: ...
     def load_verify_locations(
-        self, cafile: Optional[StrPath] = ..., capath: Optional[StrPath] = ..., cadata: Union[str, bytes, None] = ...
+        self, cafile: StrPath | None = ..., capath: StrPath | None = ..., cadata: str | bytes | None = ...
     ) -> None: ...
-    def get_ca_certs(self, binary_form: bool = ...) -> Union[List[_PeerCertRetDictType], List[bytes]]: ...
+    def get_ca_certs(self, binary_form: bool = ...) -> List[_PeerCertRetDictType] | List[bytes]: ...
     def get_ciphers(self) -> list[_Cipher]: ...
     def set_default_verify_paths(self) -> None: ...
     def set_ciphers(self, __cipherlist: str) -> None: ...
     def set_alpn_protocols(self, alpn_protocols: Iterable[str]) -> None: ...
     def set_npn_protocols(self, npn_protocols: Iterable[str]) -> None: ...
     if sys.version_info >= (3, 7):
-        def set_servername_callback(self, server_name_callback: Optional[_SrvnmeCbType]) -> None: ...
+        def set_servername_callback(self, server_name_callback: _SrvnmeCbType | None) -> None: ...
     else:
-        def set_servername_callback(self, __method: Optional[_SrvnmeCbType]) -> None: ...
+        def set_servername_callback(self, __method: _SrvnmeCbType | None) -> None: ...
     def load_dh_params(self, __path: str) -> None: ...
     def set_ecdh_curve(self, __name: str) -> None: ...
     def wrap_socket(
@@ -407,49 +403,47 @@ class SSLContext:
         server_side: bool = ...,
         do_handshake_on_connect: bool = ...,
         suppress_ragged_eofs: bool = ...,
-        server_hostname: Optional[str] = ...,
-        session: Optional[SSLSession] = ...,
+        server_hostname: str | None = ...,
+        session: SSLSession | None = ...,
     ) -> SSLSocket: ...
     def wrap_bio(
         self,
         incoming: MemoryBIO,
         outgoing: MemoryBIO,
         server_side: bool = ...,
-        server_hostname: Optional[str] = ...,
-        session: Optional[SSLSession] = ...,
+        server_hostname: str | None = ...,
+        session: SSLSession | None = ...,
     ) -> SSLObject: ...
     def session_stats(self) -> Dict[str, int]: ...
 
 class SSLObject:
     context: SSLContext
     server_side: bool
-    server_hostname: Optional[str]
-    session: Optional[SSLSession]
+    server_hostname: str | None
+    session: SSLSession | None
     session_reused: bool
     if sys.version_info >= (3, 7):
         def __init__(self, *args: Any, **kwargs: Any) -> None: ...
     else:
-        def __init__(
-            self, sslobj: Any, owner: Optional[Union[SSLSocket, SSLObject]] = ..., session: Optional[Any] = ...
-        ) -> None: ...
-    def read(self, len: int = ..., buffer: Optional[bytearray] = ...) -> bytes: ...
+        def __init__(self, sslobj: Any, owner: SSLSocket | SSLObject | None = ..., session: Any | None = ...) -> None: ...
+    def read(self, len: int = ..., buffer: bytearray | None = ...) -> bytes: ...
     def write(self, data: bytes) -> int: ...
     @overload
-    def getpeercert(self, binary_form: Literal[False] = ...) -> Optional[_PeerCertRetDictType]: ...
+    def getpeercert(self, binary_form: Literal[False] = ...) -> _PeerCertRetDictType | None: ...
     @overload
-    def getpeercert(self, binary_form: Literal[True]) -> Optional[bytes]: ...
+    def getpeercert(self, binary_form: Literal[True]) -> bytes | None: ...
     @overload
     def getpeercert(self, binary_form: bool) -> _PeerCertRetType: ...
-    def selected_alpn_protocol(self) -> Optional[str]: ...
-    def selected_npn_protocol(self) -> Optional[str]: ...
-    def cipher(self) -> Optional[Tuple[str, str, int]]: ...
-    def shared_ciphers(self) -> Optional[List[Tuple[str, str, int]]]: ...
-    def compression(self) -> Optional[str]: ...
+    def selected_alpn_protocol(self) -> str | None: ...
+    def selected_npn_protocol(self) -> str | None: ...
+    def cipher(self) -> Tuple[str, str, int] | None: ...
+    def shared_ciphers(self) -> List[Tuple[str, str, int]] | None: ...
+    def compression(self) -> str | None: ...
     def pending(self) -> int: ...
     def do_handshake(self) -> None: ...
     def unwrap(self) -> None: ...
-    def version(self) -> Optional[str]: ...
-    def get_channel_binding(self, cb_type: str = ...) -> Optional[bytes]: ...
+    def version(self) -> str | None: ...
+    def get_channel_binding(self, cb_type: str = ...) -> bytes | None: ...
     if sys.version_info >= (3, 8):
         def verify_client_post_handshake(self) -> None: ...