style: fix non-pep604-annotation-union (UP007)

Author: spaceone

httoop/authentication/__init__.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 import re
-from typing import Any, Dict, List, Tuple, Union
+from typing import Any, Dict, List, Tuple
 
 from httoop.authentication.basic import BasicAuthRequestScheme, BasicAuthResponseScheme
 from httoop.authentication.digest import DigestAuthRequestScheme, DigestAuthResponseScheme
@@ -22,7 +22,7 @@ def sanitize(self) -> None:
                 self.params[key] = type(value)(x.encode('UTF-8') if not isinstance(x, bytes) and isinstance(x, str) else x for x in value)
 
     @classmethod
-    def parseparams(cls, elementstr: bytes) -> Union[Tuple[bytes, Dict[bytes, str]], Tuple[bytes, Dict[str, bytes]], Tuple[bytes, Dict[str, Union[bytes, List[bytes], bool]]], Tuple[bytes, Dict[str, Union[bytes, List[bytes]]]], Tuple[bytes, Dict[bytes, Union[str, bytes]]]]:
+    def parseparams(cls, elementstr: bytes) -> Tuple[bytes, Dict[bytes, str]] | Tuple[bytes, Dict[str, bytes]] | Tuple[bytes, Dict[str, bytes | List[bytes] | bool]] | Tuple[bytes, Dict[str, bytes | List[bytes]]] | Tuple[bytes, Dict[bytes, str | bytes]]:
         try:
             scheme, authinfo = elementstr.split(b' ', 1)
         except ValueError:
@@ -53,7 +53,7 @@ def compose(self) -> bytes:
         return b'%s %s' % (self.value.encode('ASCII').title(), authinfo)
 
     @classmethod
-    def split(cls, value: bytes) -> List[Union[bytes, Any]]:
+    def split(cls, value: bytes) -> List[bytes | Any]:
         value = cls.RE_SPACE_SPLIT.split(value)
         indexes = [i for i, val in enumerate(value) if val != b',' and b'=' not in val]
         return [b' '.join(value[a:b]) for a, b in zip(indexes, indexes[1:] + [None])]
@@ -99,7 +99,7 @@ class AuthResponseElement(AuthElement):
     }
 
     @classmethod
-    def sorted(cls, elements: List[Union[WWWAuthenticate, Any]]) -> List[Union[WWWAuthenticate, Any]]:
+    def sorted(cls, elements: List[WWWAuthenticate | Any]) -> List[WWWAuthenticate | Any]:
         return list(sorted(elements, key=lambda e: {'basic': '\xff'}.get(e.value.lower(), e.value)))
 
     @classmethod

httoop/authentication/basic.py

@@ -1,7 +1,7 @@
 
 from __future__ import annotations
 from binascii import Error as Base64Error
-from typing import Dict, Union
+from typing import Dict
 
 from httoop.exceptions import InvalidHeader
 from httoop.header.element import HeaderElement
@@ -44,7 +44,7 @@ def compose(authinfo: ByteUnicodeDict) -> bytes:
 class BasicAuthResponseScheme:
 
     @staticmethod
-    def parse(authinfo: bytes) -> Dict[bytes, Union[str, bytes]]:
+    def parse(authinfo: bytes) -> Dict[bytes, str | bytes]:
         params = HeaderElement.parseparams(b'X;%s' % authinfo)[1]
         params.setdefault(b'realm', b'')
         return params

httoop/authentication/digest.py

@@ -1,7 +1,7 @@
 
 from __future__ import annotations
 from hashlib import md5, sha256
-from typing import Callable, Dict, List, Tuple, Union
+from typing import Callable, Dict, List, Tuple
 
 from httoop.exceptions import InvalidHeader
 from httoop.header.element import HeaderElement
@@ -21,7 +21,7 @@ class DigestAuthScheme:
     qops = (b'auth', b'auth-int')  # quality of protection
 
     @classmethod
-    def get_algorithm(cls, algorithm: Union[bytes, str]) -> Callable:
+    def get_algorithm(cls, algorithm: bytes | str) -> Callable:
         try:
             return cls.algorithms[algorithm.decode('ASCII', 'ignore') if isinstance(algorithm, bytes) else algorithm]
         except KeyError:
@@ -85,7 +85,7 @@ def _compose(cls, authinfo: ByteUnicodeDict) -> List[Tuple[str, bytes]]:
         return [(k, v) for k, v in params if v is not None]
 
     @classmethod
-    def parse(cls, authinfo: bytes) -> Dict[str, Union[bytes, List[bytes], bool]]:
+    def parse(cls, authinfo: bytes) -> Dict[str, bytes | List[bytes] | bool]:
         params = super(cls, cls).parse(authinfo)
         if b'"' in params['nonce']:
             raise InvalidHeader(_('Nonce must not contain double quote'))

httoop/codecs/application/hal_json.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from typing import Any, Dict, Iterator, List, Optional, Union
+from typing import Any, Dict, Iterator, List, Optional
 
 
 try:
@@ -36,7 +36,7 @@ def __init__(self, *args, **kwargs) -> None:
     def self(self) -> str:
         return self.expand(self.get_link('self')['href'])
 
-    def get_links(self, relation: str, name: None = None) -> Iterator[Dict[str, Union[None, bool, str]]]:
+    def get_links(self, relation: str, name: None = None) -> Iterator[Dict[str, None | bool | str]]:
         links = self['_links'].get(relation)
         if links is None:
             return
@@ -66,7 +66,7 @@ def get_links(self, relation: str, name: None = None) -> Iterator[Dict[str, Unio
                 link['deprecation'] = False
             yield link
 
-    def get_link(self, relation: str, name: Optional[str] = None) -> Optional[Dict[str, Optional[Union[bool, str]]]]:
+    def get_link(self, relation: str, name: Optional[str] = None) -> Optional[Dict[str, Optional[bool | str]]]:
         try:
             return next(self.get_links(relation, name))
         except StopIteration:
@@ -128,7 +128,7 @@ def decode(cls, data: bytes, charset: Optional[str] = None, mimetype: Optional[C
         return Resource(data)
 
     @classmethod
-    def encode(cls, data: Union[Dict[str, None], Resource], charset: Optional[str] = None, mimetype: Optional[ContentType] = None) -> bytes:
+    def encode(cls, data: Dict[str, None] | Resource, charset: Optional[str] = None, mimetype: Optional[ContentType] = None) -> bytes:
         if not isinstance(data, dict):
             raise EncodeError('HAL documents must be JSON objects.')
 

httoop/codecs/application/json.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from json import dumps as json_encode, loads as json_decode
-from typing import Any, Dict, Optional, Union
+from typing import Any, Dict, Optional
 
 from httoop.codecs.codec import Codec
 
@@ -10,7 +10,7 @@ class JSON(Codec):
     mimetype = 'application/json'
 
     @classmethod
-    def encode(cls, data: Union[Dict[str, str], Resource], charset: Optional[str] = None, mimetype: Optional[ContentType] = None) -> bytes:
+    def encode(cls, data: Dict[str, str] | Resource, charset: Optional[str] = None, mimetype: Optional[ContentType] = None) -> bytes:
         data = json_encode(data)
         if not isinstance(data, bytes):  # python3
             data = data.encode(charset or 'UTF-8')

httoop/codecs/application/x_www_form_urlencoded.py

@@ -14,7 +14,7 @@ class FormURLEncoded(Codec):
     UNQUOTED = Percent.UNRESERVED
 
     @classmethod
-    def decode(cls, data: bytes, charset: Optional[str] = None, mimetype: Optional[ContentType] = None) -> Union[Tuple[Tuple[str, str], Tuple[str, str]], Tuple[Tuple[str, str]], Tuple[Tuple[str, str], Tuple[str, str], Tuple[str, str]], Tuple[Tuple[str, str], Tuple[str, str], Tuple[str, str], Tuple[str, str]], Tuple[()]]:
+    def decode(cls, data: bytes, charset: Optional[str] = None, mimetype: Optional[ContentType] = None) -> Tuple[Tuple[str, str], Tuple[str, str]] | Tuple[Tuple[str, str]] | Tuple[Tuple[str, str], Tuple[str, str], Tuple[str, str]] | Tuple[Tuple[str, str], Tuple[str, str], Tuple[str, str], Tuple[str, str]] | Tuple[()]:
         if not data:
             return ()
         data = data.replace(b'+', b' ').strip(b'&').split(b'&')
@@ -36,6 +36,6 @@ def unquote(cls, data: bytes, charset: Optional[str] = None) -> str:
         return Percent.unquote(data).decode(charset or 'ISO8859-1')
 
     @classmethod
-    def quote(cls, data: Union[str, List[int]], charset: Optional[str] = None) -> bytes:
+    def quote(cls, data: str | List[int], charset: Optional[str] = None) -> bytes:
         data = data.encode(charset or 'ISO8859-1')
         return Percent.quote(data, cls.UNQUOTED)

httoop/codecs/message/http.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Optional, Union
+from typing import Optional
 
 from httoop.codecs.codec import Codec
 
@@ -10,11 +10,11 @@ class HTTP(Codec):
     mimetype = 'message/http'
 
     @classmethod
-    def encode(cls, data: Union[Request, Response], charset: Optional[str] = None, mimetype: Optional[ContentType] = None) -> bytes:
+    def encode(cls, data: Request | Response, charset: Optional[str] = None, mimetype: Optional[ContentType] = None) -> bytes:
         return bytes(data) + bytes(data.headers) + bytes(data.body)
 
     @classmethod
-    def decode(cls, data: bytes, charset: Optional[str] = None, mimetype: Optional[ContentType] = None) -> Union[Request, Response]:
+    def decode(cls, data: bytes, charset: Optional[str] = None, mimetype: Optional[ContentType] = None) -> Request | Response:
         from httoop.messages import Request, Response
         line, data = data.split(b'\r\n', 1)
         message = Request()

httoop/date.py

@@ -11,7 +11,7 @@
 
 # import calendar
 from datetime import datetime
-from typing import Any, Optional, Union
+from typing import Any, Optional
 
 from httoop.exceptions import InvalidDate
 from httoop.meta import HTTPSemantic
@@ -155,13 +155,13 @@ def __eq__(self, other: Any) -> bool:
         except NotImplementedError:  # pragma: no cover
             return NotImplemented
 
-    def __gt__(self, other: Optional[Union[Date, str]]) -> bool:
+    def __gt__(self, other: Optional[Date | str]) -> bool:
         try:
             return int(self) > int(self.__other(other))
         except NotImplementedError:  # pragma: no cover
             return NotImplemented
 
-    def __lt__(self, other: Optional[Union[Date, str]]) -> bool:
+    def __lt__(self, other: Optional[Date | str]) -> bool:
         try:
             return int(self) < int(self.__other(other))
         except NotImplementedError:  # pragma: no cover

httoop/gateway/wsgi.py

@@ -5,7 +5,7 @@
 """
 from __future__ import annotations
 
-from typing import Any, Callable, Dict, Iterator, Optional, Tuple, Union
+from typing import Any, Callable, Dict, Iterator, Optional, Tuple
 
 from httoop.messages import Body
 from httoop.six import PY2, reraise
@@ -119,7 +119,7 @@ def buffered(data):
         self.response.body = buffered(data)
         return raw_result
 
-    def get_environ(self) -> Dict[str, Optional[Union[str, Tuple[int, int], WSGIBody, bool]]]:
+    def get_environ(self) -> Dict[str, Optional[str | Tuple[int, int] | WSGIBody | bool]]:
         environ = {}
         environ.update(dict(self.environ.items()))
         environ.update(dict([

httoop/header/element.py

@@ -12,7 +12,7 @@
 import re
 from binascii import b2a_base64
 from email.errors import HeaderParseError
-from typing import Any, Dict, Iterator, List, Optional, Tuple, Type, Union
+from typing import Any, Dict, Iterator, List, Optional, Tuple, Type
 
 from httoop.exceptions import InvalidHeader
 from httoop.six import with_metaclass
@@ -57,10 +57,10 @@ def __init__(self, value: str, params: Optional[Any] = None) -> None:
     def sanitize(self) -> None:
         pass
 
-    def __lt__(self, other: Union[str]) -> bool:
+    def __lt__(self, other: str) -> bool:
         return self.value < getattr(other, 'value', other)
 
-    def __gt__(self, other: Union[str]) -> bool:
+    def __gt__(self, other: str) -> bool:
         return self.value > getattr(other, 'value', other)
 
     def __eq__(self, other: Any) -> bool:
@@ -86,7 +86,7 @@ def compose(self) -> bytes:
         return b'%s%s' % (self.encode_rfc2047(self.value), b''.join(params))
 
     @classmethod
-    def parseparams(cls, elementstr: bytes) -> Union[Tuple[bytes, Dict[bytes, str]], Tuple[bytes, Dict[Any, Any]]]:
+    def parseparams(cls, elementstr: bytes) -> Tuple[bytes, Dict[bytes, str]] | Tuple[bytes, Dict[Any, Any]]:
         """Transform 'token;key=val' to ('token', {'key': 'val'})."""
         # Split the element into a value and parameters. The 'value' may
         # be of the form, "token=token", but we don't split that here.
@@ -200,7 +200,7 @@ def merge(cls, elements: List, others: List) -> bytes:
         return cls.join([bytes(x) for x in cls.sorted(elements + others)])
 
     @classmethod
-    def formatparam(cls, param: bytes, value: Optional[Union[bytes, str]] = None, quote: bool = False) -> bytes:
+    def formatparam(cls, param: bytes, value: Optional[bytes | str] = None, quote: bool = False) -> bytes:
         """
         Convenience function to format and return a key=value pair.
 
@@ -367,7 +367,7 @@ def __eq__(self, other: str) -> bool:
             other = _AcceptElement(other)
         return other.value == self.value and other.quality == self.quality
 
-    def __lt__(self, other: Union[str]) -> bool:
+    def __lt__(self, other: str) -> bool:
         if not isinstance(other, _AcceptElement):
             other = _AcceptElement(other)
         if self.quality == other.quality: