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

stdlib/urllib/error.pyi

@@ -1,16 +1,16 @@
 from email.message import Message
-from typing import IO, Optional, Tuple, Union
+from typing import IO, Tuple
 from urllib.response import addinfourl
 
 # Stubs for urllib.error
 
 class URLError(IOError):
-    reason: Union[str, BaseException]
-    def __init__(self, reason: Union[str, BaseException], filename: Optional[str] = ...) -> None: ...
+    reason: str | BaseException
+    def __init__(self, reason: str | BaseException, filename: str | None = ...) -> None: ...
 
 class HTTPError(URLError, addinfourl):
     code: int
-    def __init__(self, url: str, code: int, msg: str, hdrs: Message, fp: Optional[IO[bytes]]) -> None: ...
+    def __init__(self, url: str, code: int, msg: str, hdrs: Message, fp: IO[bytes] | None) -> None: ...
 
 class ContentTooShortError(URLError):
     content: Tuple[str, Message]

stdlib/urllib/parse.pyi

@@ -1,5 +1,5 @@
 import sys
-from typing import Any, AnyStr, Callable, Dict, Generic, List, Mapping, NamedTuple, Optional, Sequence, Tuple, Union, overload
+from typing import Any, AnyStr, Callable, Dict, Generic, List, Mapping, NamedTuple, Sequence, Tuple, Union, overload
 
 if sys.version_info >= (3, 9):
     from types import GenericAlias
@@ -25,10 +25,10 @@ class _ResultMixinBytes(_ResultMixinBase[str]):
     def decode(self, encoding: str = ..., errors: str = ...) -> _ResultMixinStr: ...
 
 class _NetlocResultMixinBase(Generic[AnyStr]):
-    username: Optional[AnyStr]
-    password: Optional[AnyStr]
-    hostname: Optional[AnyStr]
-    port: Optional[int]
+    username: AnyStr | None
+    password: AnyStr | None
+    hostname: AnyStr | None
+    port: int | None
     if sys.version_info >= (3, 9):
         def __class_getitem__(cls, item: Any) -> GenericAlias: ...
 
@@ -80,30 +80,30 @@ class SplitResultBytes(_SplitResultBytesBase, _NetlocResultMixinBytes): ...
 class ParseResultBytes(_ParseResultBytesBase, _NetlocResultMixinBytes): ...
 
 def parse_qs(
-    qs: Optional[AnyStr],
+    qs: AnyStr | None,
     keep_blank_values: bool = ...,
     strict_parsing: bool = ...,
     encoding: str = ...,
     errors: str = ...,
-    max_num_fields: Optional[int] = ...,
+    max_num_fields: int | None = ...,
     separator: str = ...,
 ) -> Dict[AnyStr, List[AnyStr]]: ...
 def parse_qsl(
-    qs: Optional[AnyStr],
+    qs: AnyStr | None,
     keep_blank_values: bool = ...,
     strict_parsing: bool = ...,
     encoding: str = ...,
     errors: str = ...,
-    max_num_fields: Optional[int] = ...,
+    max_num_fields: int | None = ...,
     separator: str = ...,
 ) -> List[Tuple[AnyStr, AnyStr]]: ...
 @overload
-def quote(string: str, safe: _Str = ..., encoding: Optional[str] = ..., errors: Optional[str] = ...) -> str: ...
+def quote(string: str, safe: _Str = ..., encoding: str | None = ..., errors: str | None = ...) -> str: ...
 @overload
 def quote(string: bytes, safe: _Str = ...) -> str: ...
 def quote_from_bytes(bs: bytes, safe: _Str = ...) -> str: ...
 @overload
-def quote_plus(string: str, safe: _Str = ..., encoding: Optional[str] = ..., errors: Optional[str] = ...) -> str: ...
+def quote_plus(string: str, safe: _Str = ..., encoding: str | None = ..., errors: str | None = ...) -> str: ...
 @overload
 def quote_plus(string: bytes, safe: _Str = ...) -> str: ...
 def unquote(string: str, encoding: str = ..., errors: str = ...) -> str: ...
@@ -112,33 +112,31 @@ def unquote_plus(string: str, encoding: str = ..., errors: str = ...) -> str: ..
 @overload
 def urldefrag(url: str) -> DefragResult: ...
 @overload
-def urldefrag(url: Optional[bytes]) -> DefragResultBytes: ...
+def urldefrag(url: bytes | None) -> DefragResultBytes: ...
 def urlencode(
-    query: Union[Mapping[Any, Any], Mapping[Any, Sequence[Any]], Sequence[Tuple[Any, Any]], Sequence[Tuple[Any, Sequence[Any]]]],
+    query: Mapping[Any, Any] | Mapping[Any, Sequence[Any]] | Sequence[Tuple[Any, Any]] | Sequence[Tuple[Any, Sequence[Any]]],
     doseq: bool = ...,
     safe: AnyStr = ...,
     encoding: str = ...,
     errors: str = ...,
     quote_via: Callable[[str, AnyStr, str, str], str] = ...,
 ) -> str: ...
-def urljoin(base: AnyStr, url: Optional[AnyStr], allow_fragments: bool = ...) -> AnyStr: ...
+def urljoin(base: AnyStr, url: AnyStr | None, allow_fragments: bool = ...) -> AnyStr: ...
 @overload
-def urlparse(url: str, scheme: Optional[str] = ..., allow_fragments: bool = ...) -> ParseResult: ...
+def urlparse(url: str, scheme: str | None = ..., allow_fragments: bool = ...) -> ParseResult: ...
 @overload
-def urlparse(url: Optional[bytes], scheme: Optional[bytes] = ..., allow_fragments: bool = ...) -> ParseResultBytes: ...
+def urlparse(url: bytes | None, scheme: bytes | None = ..., allow_fragments: bool = ...) -> ParseResultBytes: ...
 @overload
-def urlsplit(url: str, scheme: Optional[str] = ..., allow_fragments: bool = ...) -> SplitResult: ...
+def urlsplit(url: str, scheme: str | None = ..., allow_fragments: bool = ...) -> SplitResult: ...
 @overload
-def urlsplit(url: Optional[bytes], scheme: Optional[bytes] = ..., allow_fragments: bool = ...) -> SplitResultBytes: ...
+def urlsplit(url: bytes | None, scheme: bytes | None = ..., allow_fragments: bool = ...) -> SplitResultBytes: ...
 @overload
 def urlunparse(
-    components: Tuple[Optional[AnyStr], Optional[AnyStr], Optional[AnyStr], Optional[AnyStr], Optional[AnyStr], Optional[AnyStr]]
+    components: Tuple[AnyStr | None, AnyStr | None, AnyStr | None, AnyStr | None, AnyStr | None, AnyStr | None]
 ) -> AnyStr: ...
 @overload
-def urlunparse(components: Sequence[Optional[AnyStr]]) -> AnyStr: ...
+def urlunparse(components: Sequence[AnyStr | None]) -> AnyStr: ...
 @overload
-def urlunsplit(
-    components: Tuple[Optional[AnyStr], Optional[AnyStr], Optional[AnyStr], Optional[AnyStr], Optional[AnyStr]]
-) -> AnyStr: ...
+def urlunsplit(components: Tuple[AnyStr | None, AnyStr | None, AnyStr | None, AnyStr | None, AnyStr | None]) -> AnyStr: ...
 @overload
-def urlunsplit(components: Sequence[Optional[AnyStr]]) -> AnyStr: ...
+def urlunsplit(components: Sequence[AnyStr | None]) -> AnyStr: ...

stdlib/urllib/request.pyi

@@ -4,23 +4,7 @@ from _typeshed import StrOrBytesPath
 from email.message import Message
 from http.client import HTTPMessage, HTTPResponse, _HTTPConnectionProtocol
 from http.cookiejar import CookieJar
-from typing import (
-    IO,
-    Any,
-    Callable,
-    ClassVar,
-    Dict,
-    List,
-    Mapping,
-    NoReturn,
-    Optional,
-    Pattern,
-    Sequence,
-    Tuple,
-    TypeVar,
-    Union,
-    overload,
-)
+from typing import IO, Any, Callable, ClassVar, Dict, List, Mapping, NoReturn, Pattern, Sequence, Tuple, TypeVar, overload
 from urllib.error import HTTPError
 from urllib.response import addclosehook, addinfourl
 
@@ -28,17 +12,17 @@ _T = TypeVar("_T")
 _UrlopenRet = Any
 
 def urlopen(
-    url: Union[str, Request],
-    data: Optional[bytes] = ...,
-    timeout: Optional[float] = ...,
+    url: str | Request,
+    data: bytes | None = ...,
+    timeout: float | None = ...,
     *,
-    cafile: Optional[str] = ...,
-    capath: Optional[str] = ...,
+    cafile: str | None = ...,
+    capath: str | None = ...,
     cadefault: bool = ...,
-    context: Optional[ssl.SSLContext] = ...,
+    context: ssl.SSLContext | None = ...,
 ) -> _UrlopenRet: ...
 def install_opener(opener: OpenerDirector) -> None: ...
-def build_opener(*handlers: Union[BaseHandler, Callable[[], BaseHandler]]) -> OpenerDirector: ...
+def build_opener(*handlers: BaseHandler | Callable[[], BaseHandler]) -> OpenerDirector: ...
 
 if sys.platform == "win32":
     from nturl2path import pathname2url as pathname2url, url2pathname as url2pathname
@@ -54,7 +38,7 @@ if sys.platform == "win32" or sys.platform == "darwin":
     def proxy_bypass(host: str) -> Any: ...  # undocumented
 
 else:
-    def proxy_bypass(host: str, proxies: Optional[Mapping[str, str]] = ...) -> Any: ...  # undocumented
+    def proxy_bypass(host: str, proxies: Mapping[str, str] | None = ...) -> Any: ...  # undocumented
 
 class Request:
     @property
@@ -67,20 +51,20 @@ class Request:
     host: str
     origin_req_host: str
     selector: str
-    data: Optional[bytes]
+    data: bytes | None
     headers: Dict[str, str]
     unredirected_hdrs: Dict[str, str]
     unverifiable: bool
-    method: Optional[str]
-    timeout: Optional[float]  # Undocumented, only set after __init__() by OpenerDirector.open()
+    method: str | None
+    timeout: float | None  # Undocumented, only set after __init__() by OpenerDirector.open()
     def __init__(
         self,
         url: str,
-        data: Optional[bytes] = ...,
+        data: bytes | None = ...,
         headers: Dict[str, str] = ...,
-        origin_req_host: Optional[str] = ...,
+        origin_req_host: str | None = ...,
         unverifiable: bool = ...,
-        method: Optional[str] = ...,
+        method: str | None = ...,
     ) -> None: ...
     def get_method(self) -> str: ...
     def add_header(self, key: str, val: str) -> None: ...
@@ -90,16 +74,16 @@ class Request:
     def get_full_url(self) -> str: ...
     def set_proxy(self, host: str, type: str) -> None: ...
     @overload
-    def get_header(self, header_name: str) -> Optional[str]: ...
+    def get_header(self, header_name: str) -> str | None: ...
     @overload
-    def get_header(self, header_name: str, default: _T) -> Union[str, _T]: ...
+    def get_header(self, header_name: str, default: _T) -> str | _T: ...
     def header_items(self) -> List[Tuple[str, str]]: ...
     def has_proxy(self) -> bool: ...
 
 class OpenerDirector:
     addheaders: List[Tuple[str, str]]
     def add_handler(self, handler: BaseHandler) -> None: ...
-    def open(self, fullurl: Union[str, Request], data: Optional[bytes] = ..., timeout: Optional[float] = ...) -> _UrlopenRet: ...
+    def open(self, fullurl: str | Request, data: bytes | None = ..., timeout: float | None = ...) -> _UrlopenRet: ...
     def error(self, proto: str, *args: Any) -> _UrlopenRet: ...
     def close(self) -> None: ...
 
@@ -120,79 +104,79 @@ class HTTPRedirectHandler(BaseHandler):
     inf_msg: ClassVar[str]  # undocumented
     def redirect_request(
         self, req: Request, fp: IO[bytes], code: int, msg: str, headers: HTTPMessage, newurl: str
-    ) -> Optional[Request]: ...
-    def http_error_301(self, req: Request, fp: IO[bytes], code: int, msg: str, headers: HTTPMessage) -> Optional[_UrlopenRet]: ...
-    def http_error_302(self, req: Request, fp: IO[bytes], code: int, msg: str, headers: HTTPMessage) -> Optional[_UrlopenRet]: ...
-    def http_error_303(self, req: Request, fp: IO[bytes], code: int, msg: str, headers: HTTPMessage) -> Optional[_UrlopenRet]: ...
-    def http_error_307(self, req: Request, fp: IO[bytes], code: int, msg: str, headers: HTTPMessage) -> Optional[_UrlopenRet]: ...
+    ) -> Request | None: ...
+    def http_error_301(self, req: Request, fp: IO[bytes], code: int, msg: str, headers: HTTPMessage) -> _UrlopenRet | None: ...
+    def http_error_302(self, req: Request, fp: IO[bytes], code: int, msg: str, headers: HTTPMessage) -> _UrlopenRet | None: ...
+    def http_error_303(self, req: Request, fp: IO[bytes], code: int, msg: str, headers: HTTPMessage) -> _UrlopenRet | None: ...
+    def http_error_307(self, req: Request, fp: IO[bytes], code: int, msg: str, headers: HTTPMessage) -> _UrlopenRet | None: ...
 
 class HTTPCookieProcessor(BaseHandler):
     cookiejar: CookieJar
-    def __init__(self, cookiejar: Optional[CookieJar] = ...) -> None: ...
+    def __init__(self, cookiejar: CookieJar | None = ...) -> None: ...
     def http_request(self, request: Request) -> Request: ...  # undocumented
     def http_response(self, request: Request, response: HTTPResponse) -> HTTPResponse: ...  # undocumented
     def https_request(self, request: Request) -> Request: ...  # undocumented
     def https_response(self, request: Request, response: HTTPResponse) -> HTTPResponse: ...  # undocumented
 
 class ProxyHandler(BaseHandler):
-    def __init__(self, proxies: Optional[Dict[str, str]] = ...) -> None: ...
-    def proxy_open(self, req: Request, proxy: str, type: str) -> Optional[_UrlopenRet]: ...  # undocumented
+    def __init__(self, proxies: Dict[str, str] | None = ...) -> None: ...
+    def proxy_open(self, req: Request, proxy: str, type: str) -> _UrlopenRet | None: ...  # undocumented
     # TODO add a method for every (common) proxy protocol
 
 class HTTPPasswordMgr:
-    def add_password(self, realm: str, uri: Union[str, Sequence[str]], user: str, passwd: str) -> None: ...
-    def find_user_password(self, realm: str, authuri: str) -> Tuple[Optional[str], Optional[str]]: ...
+    def add_password(self, realm: str, uri: str | Sequence[str], user: str, passwd: str) -> None: ...
+    def find_user_password(self, realm: str, authuri: str) -> Tuple[str | None, str | None]: ...
     def is_suburi(self, base: str, test: str) -> bool: ...  # undocumented
     def reduce_uri(self, uri: str, default_port: bool = ...) -> str: ...  # undocumented
 
 class HTTPPasswordMgrWithDefaultRealm(HTTPPasswordMgr):
-    def add_password(self, realm: Optional[str], uri: Union[str, Sequence[str]], user: str, passwd: str) -> None: ...
-    def find_user_password(self, realm: Optional[str], authuri: str) -> Tuple[Optional[str], Optional[str]]: ...
+    def add_password(self, realm: str | None, uri: str | Sequence[str], user: str, passwd: str) -> None: ...
+    def find_user_password(self, realm: str | None, authuri: str) -> Tuple[str | None, str | None]: ...
 
 class HTTPPasswordMgrWithPriorAuth(HTTPPasswordMgrWithDefaultRealm):
     def add_password(
-        self, realm: Optional[str], uri: Union[str, Sequence[str]], user: str, passwd: str, is_authenticated: bool = ...
+        self, realm: str | None, uri: str | Sequence[str], user: str, passwd: str, is_authenticated: bool = ...
     ) -> None: ...
-    def update_authenticated(self, uri: Union[str, Sequence[str]], is_authenticated: bool = ...) -> None: ...
+    def update_authenticated(self, uri: str | Sequence[str], is_authenticated: bool = ...) -> None: ...
     def is_authenticated(self, authuri: str) -> bool: ...
 
 class AbstractBasicAuthHandler:
     rx: ClassVar[Pattern[str]]  # undocumented
     passwd: HTTPPasswordMgr
-    add_password: Callable[[str, Union[str, Sequence[str]], str, str], None]
-    def __init__(self, password_mgr: Optional[HTTPPasswordMgr] = ...) -> None: ...
+    add_password: Callable[[str, str | Sequence[str], str, str], None]
+    def __init__(self, password_mgr: HTTPPasswordMgr | None = ...) -> None: ...
     def http_error_auth_reqed(self, authreq: str, host: str, req: Request, headers: HTTPMessage) -> None: ...
     def http_request(self, req: Request) -> Request: ...  # undocumented
     def http_response(self, req: Request, response: HTTPResponse) -> HTTPResponse: ...  # undocumented
     def https_request(self, req: Request) -> Request: ...  # undocumented
     def https_response(self, req: Request, response: HTTPResponse) -> HTTPResponse: ...  # undocumented
-    def retry_http_basic_auth(self, host: str, req: Request, realm: str) -> Optional[_UrlopenRet]: ...  # undocumented
+    def retry_http_basic_auth(self, host: str, req: Request, realm: str) -> _UrlopenRet | None: ...  # undocumented
 
 class HTTPBasicAuthHandler(AbstractBasicAuthHandler, BaseHandler):
     auth_header: ClassVar[str]  # undocumented
-    def http_error_401(self, req: Request, fp: IO[bytes], code: int, msg: str, headers: HTTPMessage) -> Optional[_UrlopenRet]: ...
+    def http_error_401(self, req: Request, fp: IO[bytes], code: int, msg: str, headers: HTTPMessage) -> _UrlopenRet | None: ...
 
 class ProxyBasicAuthHandler(AbstractBasicAuthHandler, BaseHandler):
     auth_header: ClassVar[str]
-    def http_error_407(self, req: Request, fp: IO[bytes], code: int, msg: str, headers: HTTPMessage) -> Optional[_UrlopenRet]: ...
+    def http_error_407(self, req: Request, fp: IO[bytes], code: int, msg: str, headers: HTTPMessage) -> _UrlopenRet | None: ...
 
 class AbstractDigestAuthHandler:
-    def __init__(self, passwd: Optional[HTTPPasswordMgr] = ...) -> None: ...
+    def __init__(self, passwd: HTTPPasswordMgr | None = ...) -> None: ...
     def reset_retry_count(self) -> None: ...
     def http_error_auth_reqed(self, auth_header: str, host: str, req: Request, headers: HTTPMessage) -> None: ...
-    def retry_http_digest_auth(self, req: Request, auth: str) -> Optional[_UrlopenRet]: ...
+    def retry_http_digest_auth(self, req: Request, auth: str) -> _UrlopenRet | None: ...
     def get_cnonce(self, nonce: str) -> str: ...
     def get_authorization(self, req: Request, chal: Mapping[str, str]) -> str: ...
     def get_algorithm_impls(self, algorithm: str) -> Tuple[Callable[[str], str], Callable[[str, str], str]]: ...
-    def get_entity_digest(self, data: Optional[bytes], chal: Mapping[str, str]) -> Optional[str]: ...
+    def get_entity_digest(self, data: bytes | None, chal: Mapping[str, str]) -> str | None: ...
 
 class HTTPDigestAuthHandler(BaseHandler, AbstractDigestAuthHandler):
     auth_header: ClassVar[str]  # undocumented
-    def http_error_401(self, req: Request, fp: IO[bytes], code: int, msg: str, headers: HTTPMessage) -> Optional[_UrlopenRet]: ...
+    def http_error_401(self, req: Request, fp: IO[bytes], code: int, msg: str, headers: HTTPMessage) -> _UrlopenRet | None: ...
 
 class ProxyDigestAuthHandler(BaseHandler, AbstractDigestAuthHandler):
     auth_header: ClassVar[str]  # undocumented
-    def http_error_407(self, req: Request, fp: IO[bytes], code: int, msg: str, headers: HTTPMessage) -> Optional[_UrlopenRet]: ...
+    def http_error_407(self, req: Request, fp: IO[bytes], code: int, msg: str, headers: HTTPMessage) -> _UrlopenRet | None: ...
 
 class AbstractHTTPHandler(BaseHandler):  # undocumented
     def __init__(self, debuglevel: int = ...) -> None: ...
@@ -206,13 +190,13 @@ class HTTPHandler(AbstractHTTPHandler):
 
 class HTTPSHandler(AbstractHTTPHandler):
     def __init__(
-        self, debuglevel: int = ..., context: Optional[ssl.SSLContext] = ..., check_hostname: Optional[bool] = ...
+        self, debuglevel: int = ..., context: ssl.SSLContext | None = ..., check_hostname: bool | None = ...
     ) -> None: ...
     def https_open(self, req: Request) -> HTTPResponse: ...
     def https_request(self, request: Request) -> Request: ...  # undocumented
 
 class FileHandler(BaseHandler):
-    names: ClassVar[Optional[Tuple[str, ...]]]  # undocumented
+    names: ClassVar[Tuple[str, ...] | None]  # undocumented
     def file_open(self, req: Request) -> addinfourl: ...
     def get_names(self) -> Tuple[str, ...]: ...  # undocumented
     def open_local_file(self, req: Request) -> addinfourl: ...  # undocumented
@@ -222,7 +206,7 @@ class DataHandler(BaseHandler):
 
 class ftpwrapper:  # undocumented
     def __init__(
-        self, user: str, passwd: str, host: str, port: int, dirs: str, timeout: Optional[float] = ..., persistent: bool = ...
+        self, user: str, passwd: str, host: str, port: int, dirs: str, timeout: float | None = ..., persistent: bool = ...
     ) -> None: ...
     def close(self) -> None: ...
     def endtransfer(self) -> None: ...
@@ -255,56 +239,56 @@ class HTTPErrorProcessor(BaseHandler):
 
 def urlretrieve(
     url: str,
-    filename: Optional[StrOrBytesPath] = ...,
-    reporthook: Optional[Callable[[int, int, int], None]] = ...,
-    data: Optional[bytes] = ...,
+    filename: StrOrBytesPath | None = ...,
+    reporthook: Callable[[int, int, int], None] | None = ...,
+    data: bytes | None = ...,
 ) -> Tuple[str, HTTPMessage]: ...
 def urlcleanup() -> None: ...
 
 class URLopener:
     version: ClassVar[str]
-    def __init__(self, proxies: Optional[Dict[str, str]] = ..., **x509: str) -> None: ...
-    def open(self, fullurl: str, data: Optional[bytes] = ...) -> _UrlopenRet: ...
-    def open_unknown(self, fullurl: str, data: Optional[bytes] = ...) -> _UrlopenRet: ...
+    def __init__(self, proxies: Dict[str, str] | None = ..., **x509: str) -> None: ...
+    def open(self, fullurl: str, data: bytes | None = ...) -> _UrlopenRet: ...
+    def open_unknown(self, fullurl: str, data: bytes | None = ...) -> _UrlopenRet: ...
     def retrieve(
         self,
         url: str,
-        filename: Optional[str] = ...,
-        reporthook: Optional[Callable[[int, int, int], None]] = ...,
-        data: Optional[bytes] = ...,
-    ) -> Tuple[str, Optional[Message]]: ...
+        filename: str | None = ...,
+        reporthook: Callable[[int, int, int], None] | None = ...,
+        data: bytes | None = ...,
+    ) -> Tuple[str, Message | None]: ...
     def addheader(self, *args: Tuple[str, str]) -> None: ...  # undocumented
     def cleanup(self) -> None: ...  # undocumented
     def close(self) -> None: ...  # undocumented
     def http_error(
-        self, url: str, fp: IO[bytes], errcode: int, errmsg: str, headers: HTTPMessage, data: Optional[bytes] = ...
+        self, url: str, fp: IO[bytes], errcode: int, errmsg: str, headers: HTTPMessage, data: bytes | None = ...
     ) -> _UrlopenRet: ...  # undocumented
     def http_error_default(
         self, url: str, fp: IO[bytes], errcode: int, errmsg: str, headers: HTTPMessage
     ) -> _UrlopenRet: ...  # undocumented
-    def open_data(self, url: str, data: Optional[bytes] = ...) -> addinfourl: ...  # undocumented
+    def open_data(self, url: str, data: bytes | None = ...) -> addinfourl: ...  # undocumented
     def open_file(self, url: str) -> addinfourl: ...  # undocumented
     def open_ftp(self, url: str) -> addinfourl: ...  # undocumented
-    def open_http(self, url: str, data: Optional[bytes] = ...) -> _UrlopenRet: ...  # undocumented
-    def open_https(self, url: str, data: Optional[bytes] = ...) -> _UrlopenRet: ...  # undocumented
+    def open_http(self, url: str, data: bytes | None = ...) -> _UrlopenRet: ...  # undocumented
+    def open_https(self, url: str, data: bytes | None = ...) -> _UrlopenRet: ...  # undocumented
     def open_local_file(self, url: str) -> addinfourl: ...  # undocumented
-    def open_unknown_proxy(self, proxy: str, fullurl: str, data: Optional[bytes] = ...) -> None: ...  # undocumented
+    def open_unknown_proxy(self, proxy: str, fullurl: str, data: bytes | None = ...) -> None: ...  # undocumented
 
 class FancyURLopener(URLopener):
     def prompt_user_passwd(self, host: str, realm: str) -> Tuple[str, str]: ...
     def get_user_passwd(self, host: str, realm: str, clear_cache: int = ...) -> Tuple[str, str]: ...  # undocumented
     def http_error_301(
-        self, url: str, fp: IO[bytes], errcode: int, errmsg: str, headers: HTTPMessage, data: Optional[bytes] = ...
-    ) -> Optional[Union[_UrlopenRet, addinfourl]]: ...  # undocumented
+        self, url: str, fp: IO[bytes], errcode: int, errmsg: str, headers: HTTPMessage, data: bytes | None = ...
+    ) -> _UrlopenRet | addinfourl | None: ...  # undocumented
     def http_error_302(
-        self, url: str, fp: IO[bytes], errcode: int, errmsg: str, headers: HTTPMessage, data: Optional[bytes] = ...
-    ) -> Optional[Union[_UrlopenRet, addinfourl]]: ...  # undocumented
+        self, url: str, fp: IO[bytes], errcode: int, errmsg: str, headers: HTTPMessage, data: bytes | None = ...
+    ) -> _UrlopenRet | addinfourl | None: ...  # undocumented
     def http_error_303(
-        self, url: str, fp: IO[bytes], errcode: int, errmsg: str, headers: HTTPMessage, data: Optional[bytes] = ...
-    ) -> Optional[Union[_UrlopenRet, addinfourl]]: ...  # undocumented
+        self, url: str, fp: IO[bytes], errcode: int, errmsg: str, headers: HTTPMessage, data: bytes | None = ...
+    ) -> _UrlopenRet | addinfourl | None: ...  # undocumented
     def http_error_307(
-        self, url: str, fp: IO[bytes], errcode: int, errmsg: str, headers: HTTPMessage, data: Optional[bytes] = ...
-    ) -> Optional[Union[_UrlopenRet, addinfourl]]: ...  # undocumented
+        self, url: str, fp: IO[bytes], errcode: int, errmsg: str, headers: HTTPMessage, data: bytes | None = ...
+    ) -> _UrlopenRet | addinfourl | None: ...  # undocumented
     def http_error_401(
         self,
         url: str,
@@ -312,9 +296,9 @@ class FancyURLopener(URLopener):
         errcode: int,
         errmsg: str,
         headers: HTTPMessage,
-        data: Optional[bytes] = ...,
+        data: bytes | None = ...,
         retry: bool = ...,
-    ) -> Optional[_UrlopenRet]: ...  # undocumented
+    ) -> _UrlopenRet | None: ...  # undocumented
     def http_error_407(
         self,
         url: str,
@@ -322,24 +306,20 @@ class FancyURLopener(URLopener):
         errcode: int,
         errmsg: str,
         headers: HTTPMessage,
-        data: Optional[bytes] = ...,
+        data: bytes | None = ...,
         retry: bool = ...,
-    ) -> Optional[_UrlopenRet]: ...  # undocumented
+    ) -> _UrlopenRet | None: ...  # undocumented
     def http_error_default(
         self, url: str, fp: IO[bytes], errcode: int, errmsg: str, headers: HTTPMessage
     ) -> addinfourl: ...  # undocumented
     def redirect_internal(
-        self, url: str, fp: IO[bytes], errcode: int, errmsg: str, headers: HTTPMessage, data: Optional[bytes]
-    ) -> Optional[_UrlopenRet]: ...  # undocumented
-    def retry_http_basic_auth(
-        self, url: str, realm: str, data: Optional[bytes] = ...
-    ) -> Optional[_UrlopenRet]: ...  # undocumented
-    def retry_https_basic_auth(
-        self, url: str, realm: str, data: Optional[bytes] = ...
-    ) -> Optional[_UrlopenRet]: ...  # undocumented
+        self, url: str, fp: IO[bytes], errcode: int, errmsg: str, headers: HTTPMessage, data: bytes | None
+    ) -> _UrlopenRet | None: ...  # undocumented
+    def retry_http_basic_auth(self, url: str, realm: str, data: bytes | None = ...) -> _UrlopenRet | None: ...  # undocumented
+    def retry_https_basic_auth(self, url: str, realm: str, data: bytes | None = ...) -> _UrlopenRet | None: ...  # undocumented
     def retry_proxy_http_basic_auth(
-        self, url: str, realm: str, data: Optional[bytes] = ...
-    ) -> Optional[_UrlopenRet]: ...  # undocumented
+        self, url: str, realm: str, data: bytes | None = ...
+    ) -> _UrlopenRet | None: ...  # undocumented
     def retry_proxy_https_basic_auth(
-        self, url: str, realm: str, data: Optional[bytes] = ...
-    ) -> Optional[_UrlopenRet]: ...  # undocumented
+        self, url: str, realm: str, data: bytes | None = ...
+    ) -> _UrlopenRet | None: ...  # undocumented

stdlib/urllib/response.pyi

@@ -1,7 +1,7 @@
 from _typeshed import Self
 from email.message import Message
 from types import TracebackType
-from typing import IO, Any, BinaryIO, Callable, Iterable, List, Optional, Tuple, Type, TypeVar
+from typing import IO, Any, BinaryIO, Callable, Iterable, List, Tuple, Type, TypeVar
 
 _AIUT = TypeVar("_AIUT", bound=addbase)
 
@@ -10,7 +10,7 @@ class addbase(BinaryIO):
     def __init__(self, fp: IO[bytes]) -> None: ...
     def __enter__(self: Self) -> Self: ...
     def __exit__(
-        self, type: Optional[Type[BaseException]], value: Optional[BaseException], traceback: Optional[TracebackType]
+        self, type: Type[BaseException] | None, value: BaseException | None, traceback: TracebackType | None
     ) -> None: ...
     def __iter__(self: _AIUT) -> _AIUT: ...
     def __next__(self) -> bytes: ...
@@ -29,7 +29,7 @@ class addbase(BinaryIO):
     def seek(self, offset: int, whence: int = ...) -> int: ...
     def seekable(self) -> bool: ...
     def tell(self) -> int: ...
-    def truncate(self, size: Optional[int] = ...) -> int: ...
+    def truncate(self, size: int | None = ...) -> int: ...
     def writable(self) -> bool: ...
     def write(self, s: bytes) -> int: ...
     def writelines(self, lines: Iterable[bytes]) -> None: ...
@@ -47,6 +47,6 @@ class addinfo(addbase):
 class addinfourl(addinfo):
     url: str
     code: int
-    def __init__(self, fp: IO[bytes], headers: Message, url: str, code: Optional[int] = ...) -> None: ...
+    def __init__(self, fp: IO[bytes], headers: Message, url: str, code: int | None = ...) -> None: ...
     def geturl(self) -> str: ...
     def getcode(self) -> int: ...

stdlib/urllib/robotparser.pyi

@@ -1,5 +1,5 @@
 import sys
-from typing import Iterable, List, NamedTuple, Optional
+from typing import Iterable, List, NamedTuple
 
 class _RequestRate(NamedTuple):
     requests: int
@@ -13,7 +13,7 @@ class RobotFileParser:
     def can_fetch(self, useragent: str, url: str) -> bool: ...
     def mtime(self) -> int: ...
     def modified(self) -> None: ...
-    def crawl_delay(self, useragent: str) -> Optional[str]: ...
-    def request_rate(self, useragent: str) -> Optional[_RequestRate]: ...
+    def crawl_delay(self, useragent: str) -> str | None: ...
+    def request_rate(self, useragent: str) -> _RequestRate | None: ...
     if sys.version_info >= (3, 8):
-        def site_maps(self) -> Optional[List[str]]: ...
+        def site_maps(self) -> List[str] | None: ...