ruff: type annotations fixes

csernazs · csernazs · commit 9367682beeb0 · 2024-02-17T17:23:30.000+01:00
diff --git a/pytest_httpserver/blocking_httpserver.py b/pytest_httpserver/blocking_httpserver.py
@@ -4,11 +4,8 @@
 from queue import Queue
 from typing import TYPE_CHECKING
 from typing import Any
-from typing import Dict
 from typing import Mapping
-from typing import Optional
 from typing import Pattern
-from typing import Union
 
 from pytest_httpserver.httpserver import METHOD_ALL
 from pytest_httpserver.httpserver import UNDEFINED
@@ -64,23 +61,23 @@ def __init__(
         self,
         host=DEFAULT_LISTEN_HOST,
         port=DEFAULT_LISTEN_PORT,
-        ssl_context: Optional[SSLContext] = None,
+        ssl_context: SSLContext | None = None,
         timeout: int = 30,
     ):
         super().__init__(host, port, ssl_context)
         self.timeout = timeout
         self.request_queue: Queue[Request] = Queue()
-        self.request_handlers: Dict[Request, Queue[BlockingRequestHandler]] = {}
+        self.request_handlers: dict[Request, Queue[BlockingRequestHandler]] = {}
 
     def assert_request(
         self,
-        uri: Union[str, URIPattern, Pattern[str]],
+        uri: str | URIPattern | Pattern[str],
         method: str = METHOD_ALL,
-        data: Union[str, bytes, None] = None,
+        data: str | bytes | None = None,
         data_encoding: str = "utf-8",
-        headers: Optional[Mapping[str, str]] = None,
-        query_string: Union[None, QueryMatcher, str, bytes, Mapping] = None,
-        header_value_matcher: Optional[HeaderValueMatcher] = None,
+        headers: Mapping[str, str] | None = None,
+        query_string: None | QueryMatcher | str | bytes | Mapping = None,
+        header_value_matcher: HeaderValueMatcher | None = None,
         json: Any = UNDEFINED,
         timeout: int = 30,
     ) -> BlockingRequestHandler:
diff --git a/pytest_httpserver/httpserver.py b/pytest_httpserver/httpserver.py
@@ -16,8 +16,8 @@
 from typing import TYPE_CHECKING
 from typing import Any
 from typing import Callable
+from typing import ClassVar
 from typing import Iterable
-from typing import List
 from typing import Mapping
 from typing import MutableMapping
 from typing import Optional
@@ -137,23 +137,23 @@ class HeaderValueMatcher:
         and return whether they are equal as bool.
     """
 
-    DEFAULT_MATCHERS: MutableMapping[str, Callable[[Optional[str], str], bool]] = {}
+    DEFAULT_MATCHERS: ClassVar[MutableMapping[str, Callable[[str | None, str], bool]]] = {}
 
-    def __init__(self, matchers: Optional[Mapping[str, Callable[[Optional[str], str], bool]]] = None):
+    def __init__(self, matchers: Mapping[str, Callable[[str | None, str], bool]] | None = None):
         self.matchers = self.DEFAULT_MATCHERS if matchers is None else matchers
 
     @staticmethod
-    def authorization_header_value_matcher(actual: Optional[str], expected: str) -> bool:
+    def authorization_header_value_matcher(actual: str | None, expected: str) -> bool:
         callable = getattr(Authorization, "from_header", None)
         if callable is None:  # Werkzeug < 2.3.0
             callable = werkzeug.http.parse_authorization_header  # type: ignore[attr-defined]
         return callable(actual) == callable(expected)
 
     @staticmethod
-    def default_header_value_matcher(actual: Optional[str], expected: str) -> bool:
+    def default_header_value_matcher(actual: str | None, expected: str) -> bool:
         return actual == expected
 
-    def __call__(self, header_name: str, actual: Optional[str], expected: str) -> bool:
+    def __call__(self, header_name: str, actual: str | None, expected: str) -> bool:
         try:
             matcher = self.matchers[header_name]
         except KeyError:
@@ -191,7 +191,7 @@ class StringQueryMatcher(QueryMatcher):
     Matches a query for a string or bytes specified
     """
 
-    def __init__(self, query_string: Union[bytes, str]):
+    def __init__(self, query_string: bytes | str):
         """
         :param query_string: the query string will be compared to this string or bytes.
             If string is specified, it will be encoded by the encode() method.
@@ -219,7 +219,7 @@ class MappingQueryMatcher(QueryMatcher):
     Matches a query string to a dictionary or MultiDict specified
     """
 
-    def __init__(self, query_dict: Union[Mapping, MultiDict]):
+    def __init__(self, query_dict: Mapping | MultiDict):
         """
         :param query_dict: if dictionary (Mapping) is specified, it will be used as a
             key-value mapping where both key and value should be string. If there are multiple
@@ -256,7 +256,7 @@ def get_comparing_values(self, request_query_string):
             return (True, False)
 
 
-def _create_query_matcher(query_string: Union[None, QueryMatcher, str, bytes, Mapping]) -> QueryMatcher:
+def _create_query_matcher(query_string: None | QueryMatcher | str | bytes | Mapping) -> QueryMatcher:
     if isinstance(query_string, QueryMatcher):
         return query_string
 
@@ -316,13 +316,13 @@ class RequestMatcher:
 
     def __init__(
         self,
-        uri: Union[str, URIPattern, Pattern[str]],
+        uri: str | URIPattern | Pattern[str],
         method: str = METHOD_ALL,
-        data: Union[str, bytes, None] = None,
+        data: str | bytes | None = None,
         data_encoding: str = "utf-8",
-        headers: Optional[Mapping[str, str]] = None,
-        query_string: Union[None, QueryMatcher, str, bytes, Mapping] = None,
-        header_value_matcher: Optional[HVMATCHER_T] = None,
+        headers: Mapping[str, str] | None = None,
+        query_string: None | QueryMatcher | str | bytes | Mapping = None,
+        header_value_matcher: HVMATCHER_T | None = None,
         json: Any = UNDEFINED,
     ):
         if json is not UNDEFINED and data is not None:
@@ -419,7 +419,7 @@ def match_json(self, request: Request) -> bool:
 
         return json_received == self.json
 
-    def difference(self, request: Request) -> List[Tuple]:
+    def difference(self, request: Request) -> list[tuple]:
         """
         Calculates the difference between the matcher and the request.
 
@@ -431,7 +431,7 @@ def difference(self, request: Request) -> List[Tuple]:
         matches the fields set in the matcher object.
         """
 
-        retval: List[Tuple] = []
+        retval: list[tuple] = []
 
         if not self.match_uri(request):
             retval.append(("uri", request.path, self.uri))
@@ -478,7 +478,7 @@ def respond_with_json(
         self,
         response_json,
         status: int = 200,
-        headers: Optional[Mapping[str, str]] = None,
+        headers: Mapping[str, str] | None = None,
         content_type: str = "application/json",
     ):
         """
@@ -495,11 +495,11 @@ def respond_with_json(
 
     def respond_with_data(
         self,
-        response_data: Union[str, bytes] = "",
+        response_data: str | bytes = "",
         status: int = 200,
-        headers: Optional[HEADERS_T] = None,
-        mimetype: Optional[str] = None,
-        content_type: Optional[str] = None,
+        headers: HEADERS_T | None = None,
+        mimetype: str | None = None,
+        content_type: str | None = None,
     ):
         """
         Prepares a response with raw data.
@@ -539,7 +539,7 @@ class RequestHandler(RequestHandlerBase):
 
     def __init__(self, matcher: RequestMatcher):
         self.matcher = matcher
-        self.request_handler: Optional[Callable[[Request], Response]] = None
+        self.request_handler: Callable[[Request], Response] | None = None
 
     def respond(self, request: Request) -> Response:
         """
@@ -586,7 +586,7 @@ class RequestHandlerList(list):
 
     """
 
-    def match(self, request: Request) -> Optional[RequestHandler]:
+    def match(self, request: Request) -> RequestHandler | None:
         """
         Returns the first request handler which matches the specified request. Otherwise, it returns `None`.
         """
@@ -629,7 +629,7 @@ def __init__(
         self,
         host: str,
         port: int,
-        ssl_context: Optional[SSLContext] = None,
+        ssl_context: SSLContext | None = None,
     ):
         """
         Initializes the instance.
@@ -639,9 +639,9 @@ def __init__(
         self.port = port
         self.server = None
         self.server_thread = None
-        self.assertions: List[str] = []
-        self.handler_errors: List[Exception] = []
-        self.log: List[Tuple[Request, Response]] = []
+        self.assertions: list[str] = []
+        self.handler_errors: list[Exception] = []
+        self.log: list[tuple[Request, Response]] = []
         self.ssl_context = ssl_context
         self.no_handler_status_code = 500
 
@@ -926,15 +926,15 @@ def __init__(
         self,
         host=DEFAULT_LISTEN_HOST,
         port=DEFAULT_LISTEN_PORT,
-        ssl_context: Optional[SSLContext] = None,
-        default_waiting_settings: Optional[WaitingSettings] = None,
+        ssl_context: SSLContext | None = None,
+        default_waiting_settings: WaitingSettings | None = None,
     ):
         """
         Initializes the instance.
         """
         super().__init__(host, port, ssl_context)
 
-        self.ordered_handlers: List[RequestHandler] = []
+        self.ordered_handlers: list[RequestHandler] = []
         self.oneshot_handlers = RequestHandlerList()
         self.handlers = RequestHandlerList()
         self.permanently_failed = False
@@ -967,13 +967,13 @@ def clear_all_handlers(self):
 
     def expect_request(
         self,
-        uri: Union[str, URIPattern, Pattern[str]],
+        uri: str | URIPattern | Pattern[str],
         method: str = METHOD_ALL,
-        data: Union[str, bytes, None] = None,
+        data: str | bytes | None = None,
         data_encoding: str = "utf-8",
-        headers: Optional[Mapping[str, str]] = None,
-        query_string: Union[None, QueryMatcher, str, bytes, Mapping] = None,
-        header_value_matcher: Optional[HVMATCHER_T] = None,
+        headers: Mapping[str, str] | None = None,
+        query_string: None | QueryMatcher | str | bytes | Mapping = None,
+        header_value_matcher: HVMATCHER_T | None = None,
         handler_type: HandlerType = HandlerType.PERMANENT,
         json: Any = UNDEFINED,
     ) -> RequestHandler:
@@ -1050,13 +1050,13 @@ def expect_request(
 
     def expect_oneshot_request(
         self,
-        uri: Union[str, URIPattern, Pattern[str]],
+        uri: str | URIPattern | Pattern[str],
         method: str = METHOD_ALL,
-        data: Union[str, bytes, None] = None,
+        data: str | bytes | None = None,
         data_encoding: str = "utf-8",
-        headers: Optional[Mapping[str, str]] = None,
-        query_string: Union[None, QueryMatcher, str, bytes, Mapping] = None,
-        header_value_matcher: Optional[HVMATCHER_T] = None,
+        headers: Mapping[str, str] | None = None,
+        query_string: None | QueryMatcher | str | bytes | Mapping = None,
+        header_value_matcher: HVMATCHER_T | None = None,
         json: Any = UNDEFINED,
     ) -> RequestHandler:
         """
@@ -1105,13 +1105,13 @@ def expect_oneshot_request(
 
     def expect_ordered_request(
         self,
-        uri: Union[str, URIPattern, Pattern[str]],
+        uri: str | URIPattern | Pattern[str],
         method: str = METHOD_ALL,
-        data: Union[str, bytes, None] = None,
+        data: str | bytes | None = None,
         data_encoding: str = "utf-8",
-        headers: Optional[Mapping[str, str]] = None,
-        query_string: Union[None, QueryMatcher, str, bytes, Mapping] = None,
-        header_value_matcher: Optional[HVMATCHER_T] = None,
+        headers: Mapping[str, str] | None = None,
+        query_string: None | QueryMatcher | str | bytes | Mapping = None,
+        header_value_matcher: HVMATCHER_T | None = None,
         json: Any = UNDEFINED,
     ) -> RequestHandler:
         """
@@ -1289,9 +1289,9 @@ def _update_waiting_result(self) -> None:
     @contextmanager
     def wait(
         self,
-        raise_assertions: Optional[bool] = None,
-        stop_on_nohandler: Optional[bool] = None,
-        timeout: Optional[float] = None,
+        raise_assertions: bool | None = None,
+        stop_on_nohandler: bool | None = None,
+        timeout: float | None = None,
     ):
         """Context manager to wait until the first of following event occurs: all ordered and oneshot handlers were
         executed, unexpected request was received (if `stop_on_nohandler` is set to `True`), or time was out
diff --git a/tests/test_parse_qs.py b/tests/test_parse_qs.py
@@ -1,8 +1,6 @@
 from __future__ import annotations
 
 import urllib.parse
-from typing import List
-from typing import Tuple
 
 import pytest
 
@@ -20,5 +18,5 @@
 
 
 @pytest.mark.parametrize("qs,expected", parse_qsl_semicolon_cases)
-def test_qsl(qs: str, expected: List[Tuple[bytes, bytes]]):
+def test_qsl(qs: str, expected: list[tuple[bytes, bytes]]):
     assert urllib.parse.parse_qsl(qs, keep_blank_values=True) == expected
diff --git a/tests/test_release.py b/tests/test_release.py
@@ -9,7 +9,6 @@
 from dataclasses import dataclass
 from pathlib import Path
 from typing import Iterable
-from typing import Tuple
 
 import pytest
 import toml
@@ -106,7 +105,7 @@ def version(pyproject) -> str:
     return pyproject["tool"]["poetry"]["version"]
 
 
-def version_to_tuple(version: str) -> Tuple:
+def version_to_tuple(version: str) -> tuple:
     return tuple([int(x) for x in version.split(".")])
 
 
