style: fix non-pep604-annotation-optional (UP045)

spaceone · spaceone · commit a06befd98b2c · 2026-04-27T03:01:30.000+02:00
diff --git a/httoop/codecs/application/hal_json.py b/httoop/codecs/application/hal_json.py
@@ -66,7 +66,7 @@ def get_links(self, relation: str, name: None = None) -> Iterator[Dict[str, None
                 link['deprecation'] = False
             yield link
 
-    def get_link(self, relation: str, name: Optional[str] = None) -> Optional[Dict[str, Optional[bool | str]]]:
+    def get_link(self, relation: str, name: str | None = None) -> Dict[str, bool | str | None] | None:
         try:
             return next(self.get_links(relation, name))
         except StopIteration:
@@ -86,7 +86,7 @@ def get_resources(self, relation: str) -> None:
                 raise DecodeError('HAL resources must be objects')
             yield Resource(resource.copy())
 
-    def get_resource(self, relation: str) -> Optional[Resource]:
+    def get_resource(self, relation: str) -> Resource | None:
         try:
             return next(self.get_resources(relation))
         except StopIteration:
@@ -121,14 +121,14 @@ class HAL(JSON):
     mimetype = 'application/hal+json'
 
     @classmethod
-    def decode(cls, data: bytes, charset: Optional[str] = None, mimetype: Optional[ContentType] = None) -> Resource:
+    def decode(cls, data: bytes, charset: str | None = None, mimetype: ContentType | None = None) -> Resource:
         data = super().decode(data)
         if not isinstance(data, dict):
             raise DecodeError('HAL documents must be JSON objects.')
         return Resource(data)
 
     @classmethod
-    def encode(cls, data: Dict[str, None] | Resource, charset: Optional[str] = None, mimetype: Optional[ContentType] = None) -> bytes:
+    def encode(cls, data: Dict[str, None] | Resource, charset: str | None = None, mimetype: ContentType | None = None) -> bytes:
         if not isinstance(data, dict):
             raise EncodeError('HAL documents must be JSON objects.')
 
diff --git a/httoop/codecs/application/json.py b/httoop/codecs/application/json.py
@@ -10,12 +10,12 @@ class JSON(Codec):
     mimetype = 'application/json'
 
     @classmethod
-    def encode(cls, data: Dict[str, str] | Resource, charset: Optional[str] = None, mimetype: Optional[ContentType] = None) -> bytes:
+    def encode(cls, data: Dict[str, str] | Resource, charset: str | None = None, mimetype: ContentType | None = None) -> bytes:
         data = json_encode(data)
         if not isinstance(data, bytes):  # python3
             data = data.encode(charset or 'UTF-8')
         return data
 
     @classmethod
-    def decode(cls, data: bytes, charset: Optional[str] = None, mimetype: Optional[ContentType] = None) -> Dict[str, Any]:
+    def decode(cls, data: bytes, charset: str | None = None, mimetype: ContentType | None = None) -> Dict[str, Any]:
         return json_decode(data.decode(charset or 'ASCII'))
diff --git a/httoop/codecs/application/x_www_form_urlencoded.py b/httoop/codecs/application/x_www_form_urlencoded.py
@@ -14,15 +14,15 @@ class FormURLEncoded(Codec):
     UNQUOTED = Percent.UNRESERVED
 
     @classmethod
-    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[()]:
+    def decode(cls, data: bytes, charset: str | None = None, mimetype: ContentType | None = 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'&')
         fields = (field.partition(b'=')[::2] for field in data if field)
         return tuple((cls.unquote(name, charset), cls.unquote(value, charset)) for name, value in fields)
 
     @classmethod
-    def encode(cls, data: Any, charset: Optional[str] = None, mimetype: None = None) -> bytes:
+    def encode(cls, data: Any, charset: str | None = None, mimetype: None = None) -> bytes:
         # if isinstance(data, (Unicode, bytes)):
         #    data = cls.decode(data, charset)
         if isinstance(data, dict):
@@ -32,10 +32,10 @@ def encode(cls, data: Any, charset: Optional[str] = None, mimetype: None = None)
         return data.replace(b'%20', b'+')
 
     @classmethod
-    def unquote(cls, data: bytes, charset: Optional[str] = None) -> str:
+    def unquote(cls, data: bytes, charset: str | None = None) -> str:
         return Percent.unquote(data).decode(charset or 'ISO8859-1')
 
     @classmethod
-    def quote(cls, data: str | List[int], charset: Optional[str] = None) -> bytes:
+    def quote(cls, data: str | List[int], charset: str | None = None) -> bytes:
         data = data.encode(charset or 'ISO8859-1')
         return Percent.quote(data, cls.UNQUOTED)
diff --git a/httoop/codecs/application/xml.py b/httoop/codecs/application/xml.py
@@ -29,12 +29,12 @@ class XML(Codec):
     mimetype = 'application/xml'
 
     @classmethod
-    def decode(cls, data: bytes, charset: Optional[str] = None, mimetype: Optional[ContentType] = None) -> Element:
+    def decode(cls, data: bytes, charset: str | None = None, mimetype: ContentType | None = None) -> Element:
         try:
             return fromstring(data)
         except ParseError as exc:
             raise DecodeError('Could not decode as %s: %s' % (mimetype, exc,))
 
     @classmethod
-    def encode(cls, root: Element, charset: Optional[str] = None, mimetype: Optional[ContentType] = None) -> bytes:
+    def encode(cls, root: Element, charset: str | None = None, mimetype: ContentType | None = None) -> bytes:
         return tostring(root, charset)
diff --git a/httoop/codecs/application/zlib.py b/httoop/codecs/application/zlib.py
@@ -20,7 +20,7 @@ def encode(cls, data: bytes, charset: None = None, mimetype: None = None) -> byt
             raise EncodeError(_('Invalid zlib/deflate data.'))
 
     @classmethod
-    def decode(cls, data: bytes, charset: Optional[str] = None, mimetype: None = None) -> str:
+    def decode(cls, data: bytes, charset: str | None = None, mimetype: None = None) -> str:
         try:
             data = zlib.decompress(data)
         except zlib.error:
diff --git a/httoop/codecs/codec.py b/httoop/codecs/codec.py
@@ -8,7 +8,7 @@
 class Codec:
 
     @classmethod
-    def decode(cls, data: bytes, charset: Optional[str] = None, mimetype: None = None) -> str:  # pragma: no cover
+    def decode(cls, data: bytes, charset: str | None = None, mimetype: None = None) -> str:  # pragma: no cover
         if isinstance(data, bytes):
             data = data.decode(charset or 'ascii')
         return data
diff --git a/httoop/codecs/message/http.py b/httoop/codecs/message/http.py
@@ -10,11 +10,11 @@ class HTTP(Codec):
     mimetype = 'message/http'
 
     @classmethod
-    def encode(cls, data: Request | Response, charset: Optional[str] = None, mimetype: Optional[ContentType] = None) -> bytes:
+    def encode(cls, data: Request | Response, charset: str | None = None, mimetype: ContentType | None = 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) -> Request | Response:
+    def decode(cls, data: bytes, charset: str | None = None, mimetype: ContentType | None = None) -> Request | Response:
         from httoop.messages import Request, Response
         line, data = data.split(b'\r\n', 1)
         message = Request()
diff --git a/httoop/codecs/multipart/multipart.py b/httoop/codecs/multipart/multipart.py
@@ -13,7 +13,7 @@ class Multipart(Codec):
     default_content_type = 'text/plain; charset=US-ASCII'
 
     @classmethod
-    def encode(cls, data: List[Body], charset: Optional[str] = None, mimetype: Optional[ContentType] = None) -> bytes:
+    def encode(cls, data: List[Body], charset: str | None = None, mimetype: ContentType | None = None) -> bytes:
         boundary = mimetype.boundary.encode('ISO8859-1')
         multipart = b''
         for body in data:
@@ -22,7 +22,7 @@ def encode(cls, data: List[Body], charset: Optional[str] = None, mimetype: Optio
         return multipart
 
     @classmethod
-    def decode(cls, data: bytes, charset: Optional[str] = None, mimetype: Optional[ContentType] = None) -> List[Body]:
+    def decode(cls, data: bytes, charset: str | None = None, mimetype: ContentType | None = None) -> List[Body]:
         boundary = mimetype.boundary.encode('ISO8859-1')
         parts = data.split(b'--%s' % (boundary, ))
         part = parts.pop(0)
diff --git a/httoop/codecs/text/plain.py b/httoop/codecs/text/plain.py
@@ -10,15 +10,15 @@ class PlainText(Codec):
     mimetype = 'text/plain'
 
     @classmethod
-    def decode(cls, data: bytes, charset: Optional[str] = None, mimetype: Optional[ContentType] = None) -> str:
+    def decode(cls, data: bytes, charset: str | None = None, mimetype: ContentType | None = None) -> str:
         try:
             assert isinstance(data, bytes)
             return data.decode(charset or 'UTF-8')
         except UnicodeDecodeError:
             raise DecodeError('Wrong encoding.')
 
     @classmethod
-    def encode(cls, data: str, charset: Optional[str] = None, mimetype: Optional[ContentType] = None) -> bytes:
+    def encode(cls, data: str, charset: str | None = None, mimetype: ContentType | None = None) -> bytes:
         try:
             assert not isinstance(data, bytes)
             return data.encode(charset or 'UTF-8')
diff --git a/httoop/date.py b/httoop/date.py
@@ -42,7 +42,7 @@ class Date(with_metaclass(HTTPSemantic)):
 
     __slots__ = ('__composed', '__timestamp', '__datetime', '__time_struct')
 
-    def __init__(self, timeval: Optional[Any] = None) -> None:
+    def __init__(self, timeval: Any | None = None) -> None:
         """
         :param timeval:
         :type  timeval:
@@ -102,7 +102,7 @@ def __compose(self):
         )
 
     @classmethod
-    def parse(cls, timestr: Optional[bytes] = None) -> Date:
+    def parse(cls, timestr: bytes | None = None) -> Date:
         """
         parses a HTTP date string and returns a :class:`Date` object.
 
@@ -155,13 +155,13 @@ def __eq__(self, other: Any) -> bool:
         except NotImplementedError:  # pragma: no cover
             return NotImplemented
 
-    def __gt__(self, other: Optional[Date | str]) -> bool:
+    def __gt__(self, other: Date | str | None) -> bool:
         try:
             return int(self) > int(self.__other(other))
         except NotImplementedError:  # pragma: no cover
             return NotImplemented
 
-    def __lt__(self, other: Optional[Date | str]) -> bool:
+    def __lt__(self, other: Date | str | None) -> bool:
         try:
             return int(self) < int(self.__other(other))
         except NotImplementedError:  # pragma: no cover
diff --git a/httoop/gateway/wsgi.py b/httoop/gateway/wsgi.py
@@ -32,7 +32,7 @@ def read(self, *size):
 class WSGI:
     """A mixin class which implements the WSGI interface."""
 
-    def __init__(self, environ: Optional[Dict[str, str]] = None, use_path_info: bool = False, *args, **kwargs) -> None:
+    def __init__(self, environ: Dict[str, str] | None = None, use_path_info: bool = False, *args, **kwargs) -> None:
         self.use_path_info = use_path_info
         super().__init__()
         self.exc_info = None
@@ -119,7 +119,7 @@ def buffered(data):
         self.response.body = buffered(data)
         return raw_result
 
-    def get_environ(self) -> Dict[str, Optional[str | Tuple[int, int] | WSGIBody | bool]]:
+    def get_environ(self) -> Dict[str, str | Tuple[int, int] | WSGIBody | bool | None]:
         environ = {}
         environ.update(dict(self.environ.items()))
         environ.update(dict([
diff --git a/httoop/header/element.py b/httoop/header/element.py
@@ -49,7 +49,7 @@ class HeaderElement(with_metaclass(HeaderType)):
     RE_SPLIT = re.compile(b',(?=(?:[^"]*"[^"]*")*[^"]*$)')
     RE_PARAMS = re.compile(b';(?=(?:[^"]*"[^"]*")*[^"]*$)')
 
-    def __init__(self, value: str, params: Optional[Any] = None) -> None:
+    def __init__(self, value: str, params: Any | None = None) -> None:
         self.value = value
         self.params = ByteUnicodeDict(params or {})
         self.sanitize()
@@ -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[bytes | str] = None, quote: bool = False) -> bytes:
+    def formatparam(cls, param: bytes, value: bytes | str | None = None, quote: bool = False) -> bytes:
         """
         Convenience function to format and return a key=value pair.
 
@@ -381,7 +381,7 @@ class _CookieElement(HeaderElement):
     # RE_TSPECIALS = re.compile(br'[ \(\)<>@,;:\\"\[\]\?=]')
     RE_TSPECIALS = re.compile(b'(?!)')
 
-    def __init__(self, cookie_name: str, cookie_value: str, params: Optional[Dict[bytes, str]] = None) -> None:
+    def __init__(self, cookie_name: str, cookie_value: str, params: Dict[bytes, str] | None = None) -> None:
         self.cookie_name = cookie_name
         self.cookie_value = cookie_value
         super().__init__(self.value, params)
diff --git a/httoop/header/headers.py b/httoop/header/headers.py
@@ -26,14 +26,14 @@ def __getitem__(self, key: str) -> str:
         Element = HEADER.get(key, HeaderElement)
         return Element.decode_rfc2047(super().__getitem__(key))
 
-    def get(self, key: str, default: Optional[bytes | str] = None) -> Optional[bytes | str]:
+    def get(self, key: str, default: bytes | str | None = None) -> bytes | str | None:
         Element = HEADER.get(key, HeaderElement)
         try:
             return Element.decode_rfc2047(super().__getitem__(key))
         except KeyError:
             return default
 
-    def getbytes(self, key: bytes | str, default: None = None) -> Optional[bytes]:
+    def getbytes(self, key: bytes | str, default: None = None) -> bytes | None:
         try:
             return super().__getitem__(key)
         except KeyError:
@@ -68,7 +68,7 @@ def element(self, fieldname: bytes | str, default: None = None) -> Any:
             return Element.parse(super().__getitem__(fieldname))
         return default
 
-    def get_element(self, fieldname: str, which: Optional[str] = None, default: Optional[object] = None) -> Any:
+    def get_element(self, fieldname: str, which: str | None = None, default: object | None = None) -> Any:
         for element in self.elements(fieldname):
             if which is None or element == which:
                 return element
diff --git a/httoop/header/messaging.py b/httoop/header/messaging.py
@@ -100,7 +100,7 @@ class ContentDisposition(HeaderElement):
     from httoop.date import Date
 
     @property
-    def filename(self) -> Optional[str]:
+    def filename(self) -> str | None:
         return self.params.get('filename')
 
     @property
@@ -116,12 +116,12 @@ def inline(self) -> bool:
         return self.value == 'inline'
 
     @property
-    def creation_date(self) -> Optional[Date]:
+    def creation_date(self) -> Date | None:
         if 'creation-date' in self.params:
             return self.Date(self.params['creation-date'])
 
     @property
-    def modification_date(self) -> Optional[Date]:
+    def modification_date(self) -> Date | None:
         if 'modification-date' in self.params:
             return self.Date(self.params['modification-date'])
 
@@ -258,15 +258,15 @@ def for_(self) -> str:
         return self.params.get('for')
 
     @property
-    def by(self) -> Optional[str]:
+    def by(self) -> str | None:
         return self.params.get('by')
 
     @property
-    def host(self) -> Optional[str]:
+    def host(self) -> str | None:
         return self.params.get('host')
 
     @property
-    def proto(self) -> Optional[str]:
+    def proto(self) -> str | None:
         return self.params.get('proto')
 
     @classmethod
@@ -306,21 +306,21 @@ def is_fqdn(self) -> bool:
         return not self.is_ip4 and not self.is_ip6 and self.RE_HOSTNAME.match(self.host) is not None
 
     @property
-    def fqdn(self) -> Optional[str]:
+    def fqdn(self) -> str | None:
         if self.is_fqdn:
             return self.host
 
     @property
-    def hostname(self) -> Optional[str]:
+    def hostname(self) -> str | None:
         return self.ip6address or self.ip4address or self.fqdn
 
     @property
-    def ip6address(self) -> Optional[str]:
+    def ip6address(self) -> str | None:
         if self.is_ip6:
             return self.host
 
     @property
-    def ip4address(self) -> Optional[str]:
+    def ip4address(self) -> str | None:
         if self.is_ip4:
             return self.host
 
diff --git a/httoop/header/range.py b/httoop/header/range.py
@@ -18,7 +18,7 @@ class ContentRange(HeaderElement):
     __name__ = 'Content-Range'
     is_response_header = True
 
-    def __init__(self, value: str, range_: Optional[Tuple[int, None] | Tuple[int, int]], length: Optional[int | str]) -> None:
+    def __init__(self, value: str, range_: Tuple[int, None] | Tuple[int, int] | None, length: int | str | None) -> None:
         self.range = range_
         if self.range:
             start, end = self.range
diff --git a/httoop/messages/body.py b/httoop/messages/body.py
@@ -103,7 +103,7 @@ def chunked(self):
     def chunked(self, chunked):
         self.transfer_encoding = 'chunked' if chunked else None
 
-    def __init__(self, content: Optional[bytes | List[bytes] | str] = None, mimetype: Optional[str] = None) -> None:
+    def __init__(self, content: bytes | List[bytes] | str | None = None, mimetype: str | None = None) -> None:
         self.data = None
         self.__iter = None
         self.fd = BytesIO()
diff --git a/httoop/messages/method.py b/httoop/messages/method.py
@@ -34,7 +34,7 @@ def idempotent(self) -> bool:
     idempotent_methods = ('GET', 'HEAD', 'PUT', 'DELETE', 'OPTIONS', 'TRACE', 'SEARCH')
     METHOD_RE = re.compile(br'^[A-Z0-9$-_.]{1,20}\Z', re.IGNORECASE)
 
-    def __init__(self, method: Optional[str] = None) -> None:
+    def __init__(self, method: str | None = None) -> None:
         self.set(method or 'GET')
 
     def __hash__(self) -> int:
diff --git a/httoop/parser.py b/httoop/parser.py
diff --git a/httoop/server/__init__.py b/httoop/server/__init__.py
diff --git a/httoop/status/redirect.py b/httoop/status/redirect.py
diff --git a/httoop/status/status.py b/httoop/status/status.py
diff --git a/httoop/status/types.py b/httoop/status/types.py
diff --git a/httoop/uri/query_string.py b/httoop/uri/query_string.py
diff --git a/httoop/uri/uri.py b/httoop/uri/uri.py
diff --git a/httoop/util.py b/httoop/util.py
