From 3dda51b5338d202b29501e0ed2ed964b6b7b1655 Mon Sep 17 00:00:00 2001
From: sdb9696 <steven.beth@gmail.com>
Date: Tue, 26 Mar 2024 13:22:55 +0000
Subject: [PATCH] Make checkin async

---
 .pre-commit-config.yaml                  |   3 +
 firebase_messaging/fcm.py                |  75 ----
 firebase_messaging/fcmpushclient.py      | 287 +++++++-------
 firebase_messaging/fcmregister.py        | 362 +++++++++++++++++
 firebase_messaging/gcm.py                | 178 ---------
 firebase_messaging/proto/checkin_pb2.pyi |   2 +-
 poetry.lock                              | 485 +++++++++++++++++++++--
 pyproject.toml                           |  15 +-
 tests/conftest.py                        |  18 +-
 tests/test_fcmpushclient.py              |   4 +-
 10 files changed, 987 insertions(+), 442 deletions(-)
 delete mode 100644 firebase_messaging/fcm.py
 create mode 100644 firebase_messaging/fcmregister.py
 delete mode 100644 firebase_messaging/gcm.py

diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 87910ee..3d1d4b9 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -17,8 +17,11 @@ repos:
     - id: mypy
       args: ["--install-types", "--non-interactive", "--ignore-missing-imports"]
       additional_dependencies: [types-protobuf]
+      # Exclude the proto/*.py so when files are passed as parameters
+      # they do not cause duplicate module errors
       exclude: |
         (?x)^(
+            tests/.*|
             docs/.*|
             firebase_messaging/proto/.*py$
         )$
diff --git a/firebase_messaging/fcm.py b/firebase_messaging/fcm.py
deleted file mode 100644
index 612950e..0000000
--- a/firebase_messaging/fcm.py
+++ /dev/null
@@ -1,75 +0,0 @@
-import logging
-import os
-import time
-from base64 import urlsafe_b64encode
-
-import requests
-from cryptography.hazmat.primitives import serialization
-from cryptography.hazmat.primitives.asymmetric import ec
-
-from .const import FCM_SEND_URL, FCM_SUBSCRIBE_URL
-
-_logger = logging.getLogger(__name__)
-
-
-def fcm_register(sender_id, token, retries=5, log_debug_verbose=False):
-    """
-    generates key pair and obtains a fcm token
-
-    sender_id: sender id as an integer
-    token: the subscription token in the dict returned by gcm_register
-
-    returns {"keys": keys, "fcm": {...}}
-    """
-    # I used this analyzer to figure out how to slice the asn1 structs
-    # https://lapo.it/asn1js
-    # first byte of public key is skipped for some reason
-    # maybe it's always zero
-
-    private_key = ec.generate_private_key(ec.SECP256R1())
-    public_key = private_key.public_key()
-
-    serialized_private = private_key.private_bytes(
-        encoding=serialization.Encoding.DER,  # asn1
-        format=serialization.PrivateFormat.PKCS8,
-        encryption_algorithm=serialization.NoEncryption(),
-    )
-    serialized_public = public_key.public_bytes(
-        encoding=serialization.Encoding.DER,
-        format=serialization.PublicFormat.SubjectPublicKeyInfo,
-    )
-
-    keys = {
-        "public": urlsafe_b64encode(serialized_public[26:]).decode(
-            "ascii"
-        ),  # urlsafe_base64(serialized_public[26:]),
-        "private": urlsafe_b64encode(serialized_private).decode("ascii"),
-        "secret": urlsafe_b64encode(os.urandom(16)).decode("ascii"),
-    }
-    data = {
-        "authorized_entity": sender_id,
-        "endpoint": f"{FCM_SEND_URL}/{token}",
-        "encryption_key": keys["public"],
-        "encryption_auth": keys["secret"],
-    }
-    if log_debug_verbose:
-        _logger.debug("FCM registration data: %s", data)
-
-    for try_num in range(retries):
-        try:
-            resp = requests.post(
-                url=FCM_SUBSCRIBE_URL,
-                data=data,
-                timeout=2,
-            )
-            fcm = resp.json()
-            return {"keys": keys, "fcm": fcm}
-        except Exception as e:
-            _logger.error(  # pylint: disable=duplicate-code
-                "Error during fmc register request attempt %s out of %s",
-                try_num + 1,
-                retries,
-                exc_info=e,
-            )
-            time.sleep(1)
-    return None
diff --git a/firebase_messaging/fcmpushclient.py b/firebase_messaging/fcmpushclient.py
index 735be95..2ea1f68 100644
--- a/firebase_messaging/fcmpushclient.py
+++ b/firebase_messaging/fcmpushclient.py
@@ -11,12 +11,14 @@
 from enum import Enum
 from ssl import SSLError
 from threading import Thread
-from typing import Any, Callable, Dict, List, Optional
+from typing import Any, Callable, Dict, List, Optional, Tuple
 
+from aiohttp import ClientSession
 from cryptography.hazmat.backends import default_backend
 from cryptography.hazmat.primitives.serialization import load_der_private_key
 from google.protobuf.json_format import MessageToJson
-from http_ece import decrypt as http_decrypt
+from google.protobuf.message import Message
+from http_ece import decrypt as http_decrypt  # type: ignore[import-untyped]
 
 from .const import (
     MCS_HOST,
@@ -25,8 +27,7 @@
     MCS_SELECTIVE_ACK_ID,
     MCS_VERSION,
 )
-from .fcm import fcm_register
-from .gcm import gcm_check_in, gcm_register
+from .fcmregister import FcmRegister
 from .proto.mcs_pb2 import (  # pylint: disable=no-name-in-module
     Close,
     DataMessageStanza,
@@ -40,6 +41,9 @@
 
 _logger = logging.getLogger(__name__)
 
+OnNotificationCallable = Callable[[Dict[str, Dict[str, str]], str, Any], None]
+CredentialsUpdatedCallable = Callable[[Dict[str, Any]], None]
+
 
 class ErrorType(Enum):
     CONNECTION = 1
@@ -118,20 +122,22 @@ def __init__(
         self,
         *,
         credentials: Optional[dict] = None,
-        credentials_updated_callback: Optional[Callable[[Dict[str, Any]], None]] = None,
+        credentials_updated_callback: Optional[CredentialsUpdatedCallable] = None,
         received_persistent_ids: Optional[List[str]] = None,
         config: Optional[FcmPushClientConfig] = None,
+        http_client_session: Optional[ClientSession] = None,
     ):
         """Initializes the receiver."""
-        self.credentials = credentials
+        self.credentials: Optional[Dict[str, Dict[str, str]]] = credentials
         self.credentials_updated_callback = credentials_updated_callback
         self.persistent_ids = received_persistent_ids if received_persistent_ids else []
         self.config = config if config else FcmPushClientConfig()
         if self.config.log_debug_verbose:
             _logger.setLevel(logging.DEBUG)
+        self._http_client_session = http_client_session
 
-        self.reader = None
-        self.writer = None
+        self.reader: Optional[asyncio.StreamReader] = None
+        self.writer: Optional[asyncio.StreamWriter] = None
         self.do_listen = False
         self.sequential_error_counters: Dict[ErrorType, int] = {}
         self.log_warn_counters: Dict[str, int] = {}
@@ -140,11 +146,11 @@ def __init__(
         self.input_stream_id = 0
         self.last_input_stream_id_reported = -1
         self.first_message = True
-        self.last_login_time = None
-        self.last_message_time = None
+        self.last_login_time: Optional[float] = None
+        self.last_message_time: Optional[float] = None
 
         self.run_state: FcmPushClientRunState = FcmPushClientRunState.CREATED
-        self.tasks = None
+        self.tasks: List[asyncio.Task] = []
 
         self.listen_event_loop: Optional[asyncio.AbstractEventLoop] = None
         self.callback_event_loop: Optional[asyncio.AbstractEventLoop] = None
@@ -153,19 +159,19 @@ def __init__(
         self.app_id: Optional[str] = None
         self.sender_id: Optional[int] = None
 
-        self.reset_lock = None
-        self.stopping_lock = None
+        self.reset_lock: Optional[asyncio.Lock] = None
+        self.stopping_lock: Optional[asyncio.Lock] = None
 
-    def _msg_str(self, msg):
+    def _msg_str(self, msg: Message) -> str:
         if self.config.log_debug_verbose:
             return type(msg).__name__ + "\n" + MessageToJson(msg, indent=4)
         return type(msg).__name__
 
-    def _log_verbose(self, msg: str, *args):
+    def _log_verbose(self, msg: str, *args: object) -> None:
         if self.config.log_debug_verbose:
             _logger.debug(msg, *args)
 
-    def _log_warn_with_limit(self, msg: str, *args):
+    def _log_warn_with_limit(self, msg: str, *args: object) -> None:
         if msg not in self.log_warn_counters:
             self.log_warn_counters[msg] = 0
         if (
@@ -175,7 +181,7 @@ def _log_warn_with_limit(self, msg: str, *args):
             self.log_warn_counters[msg] += 1
             _logger.warning(msg, *args)
 
-    async def _do_writer_close(self):
+    async def _do_writer_close(self) -> None:
         try:
             if (
                 self.listen_event_loop
@@ -187,20 +193,20 @@ async def _do_writer_close(self):
         except OSError as e:
             _logger.debug("%s Error while trying to close writer", type(e).__name__)
 
-    async def _reset(self):
+    async def _reset(self) -> None:
         if (
-            self.reset_lock.locked()
-            or self.stopping_lock.locked()
+            (self.reset_lock and self.reset_lock.locked())
+            or (self.stopping_lock and self.stopping_lock.locked())
             or not self.do_listen
         ):
             return
 
-        async with self.reset_lock:
+        async with self.reset_lock:  # type: ignore[union-attr]
             _logger.debug("Resetting connection")
 
             self.run_state = FcmPushClientRunState.RESETTING
             now = time.time()
-            time_since_last_login = now - self.last_login_time
+            time_since_last_login = now - self.last_login_time  # type: ignore[operator]
             if time_since_last_login < self.config.reset_interval:
                 _logger.debug("%ss since last reset attempt.", time_since_last_login)
                 await asyncio.sleep(self.config.reset_interval - time_since_last_login)
@@ -222,11 +228,11 @@ async def _reset(self):
     # protobuf variable length integers are encoded in base 128
     # each byte contains 7 bits of the integer and the msb is set if there's
     # more. pretty simple to implement
-    async def _read_varint32(self):
+    async def _read_varint32(self) -> int:
         res = 0
         shift = 0
         while True:
-            r = await self.reader.readexactly(1)
+            r = await self.reader.readexactly(1)  # type: ignore[union-attr]
             (b,) = struct.unpack("B", r)
             res |= (b & 0x7F) << shift
             if (b & 0x80) == 0:
@@ -235,7 +241,7 @@ async def _read_varint32(self):
         return res
 
     @staticmethod
-    def _encode_varint32(x):
+    def _encode_varint32(x: int) -> bytes:
         if x == 0:
             return bytes(bytearray([0]))
 
@@ -249,7 +255,7 @@ def _encode_varint32(x):
         return bytes(res)
 
     @staticmethod
-    def _make_packet(msg, include_version):
+    def _make_packet(msg: Message, include_version: bool) -> bytes:
         tag = MCS_MESSAGE_TAG[type(msg)]
 
         header = bytearray([MCS_VERSION, tag]) if include_version else bytearray([tag])
@@ -258,22 +264,22 @@ def _make_packet(msg, include_version):
         buf = bytes(header) + FcmPushClient._encode_varint32(len(payload)) + payload
         return buf
 
-    async def _send_msg(self, msg):
+    async def _send_msg(self, msg: Message) -> None:
         self._log_verbose("Sending packet to server: %s", self._msg_str(msg))
 
         buf = FcmPushClient._make_packet(msg, self.first_message)
-        self.writer.write(buf)
-        await self.writer.drain()
+        self.writer.write(buf)  # type: ignore[union-attr]
+        await self.writer.drain()  # type: ignore[union-attr]
 
-    async def _receive_msg(self):
+    async def _receive_msg(self) -> Optional[Message]:
         if self.first_message:
-            r = await self.reader.readexactly(2)
+            r = await self.reader.readexactly(2)  # type: ignore[union-attr]
             version, tag = struct.unpack("BB", r)
             if version < MCS_VERSION and version != 38:
                 raise RuntimeError(f"protocol version {version} unsupported")
             self.first_message = False
         else:
-            r = await self.reader.readexactly(1)
+            r = await self.reader.readexactly(1)  # type: ignore[union-attr]
             (tag,) = struct.unpack("B", r)
         size = await self._read_varint32()
 
@@ -287,7 +293,7 @@ async def _receive_msg(self):
             self._log_warn_with_limit("Unexpected message size %s", size)
             return None
 
-        buf = await self.reader.readexactly(size)
+        buf = await self.reader.readexactly(size)  # type: ignore[union-attr]
 
         msg_class = next(iter([c for c, t in MCS_MESSAGE_TAG.items() if t == tag]))
         if not msg_class:
@@ -297,13 +303,13 @@ async def _receive_msg(self):
             self._log_warn_with_limit("Unconfigured message class %s", msg_class)
             return None
 
-        payload = msg_class()
+        payload = msg_class()  # type: ignore[operator]
         payload.ParseFromString(buf)
         self._log_verbose("Received payload: %s", self._msg_str(payload))
 
         return payload
 
-    async def _login(self):
+    async def _login(self) -> None:
         self.run_state = FcmPushClientRunState.STARTING_LOGIN
 
         now = time.time()
@@ -313,11 +319,11 @@ async def _login(self):
         self.last_login_time = now
 
         try:
-            android_id = self.credentials["gcm"]["androidId"]
+            android_id = self.credentials["gcm"]["androidId"]  # type: ignore[index]
             req = LoginRequest()
             req.adaptive_heartbeat = False
-            req.auth_service = 2
-            req.auth_token = self.credentials["gcm"]["securityToken"]
+            req.auth_service = LoginRequest.ANDROID_ID  # 2
+            req.auth_token = self.credentials["gcm"]["securityToken"]  # type: ignore[index]
             req.id = "chrome-63.0.3234.0"
             req.domain = "mcs.android.com"
             req.device_id = "android-%x" % int(android_id)
@@ -345,13 +351,18 @@ async def _login(self):
                 await self._reset()
 
     @staticmethod
-    def _decrypt_raw_data(credentials, crypto_key, salt, raw_data):
-        crypto_key = urlsafe_b64decode(crypto_key.encode("ascii"))
-        salt = urlsafe_b64decode(salt.encode("ascii"))
-        der_data = credentials["keys"]["private"]
-        der_data = urlsafe_b64decode(der_data.encode("ascii") + b"========")
-        secret = credentials["keys"]["secret"]
-        secret = urlsafe_b64decode(secret.encode("ascii") + b"========")
+    def _decrypt_raw_data(
+        credentials: Dict[str, Dict[str, str]],
+        crypto_key_str: str,
+        salt_str: str,
+        raw_data: bytes,
+    ) -> bytes:
+        crypto_key = urlsafe_b64decode(crypto_key_str.encode("ascii"))
+        salt = urlsafe_b64decode(salt_str.encode("ascii"))
+        der_data_str = credentials["keys"]["private"]
+        der_data = urlsafe_b64decode(der_data_str.encode("ascii") + b"========")
+        secret_str = credentials["keys"]["secret"]
+        secret = urlsafe_b64decode(secret_str.encode("ascii") + b"========")
         privkey = load_der_private_key(
             der_data, password=None, backend=default_backend()
         )
@@ -365,14 +376,19 @@ def _decrypt_raw_data(credentials, crypto_key, salt, raw_data):
         )
         return decrypted
 
-    def _app_data_by_key(self, p, key):
+    def _app_data_by_key(self, p: DataMessageStanza, key: str) -> str:
         for x in p.app_data:
             if x.key == key:
                 return x.value
 
         raise RuntimeError(f"couldn't find in app_data {key}")
 
-    def _handle_data_message(self, callback, msg, obj):
+    def _handle_data_message(
+        self,
+        callback: Optional[OnNotificationCallable],
+        msg: DataMessageStanza,
+        obj: Any,
+    ) -> None:
         _logger.debug(
             "Received data message Stream ID: %s, Last: %s, Status: %s",
             msg.stream_id,
@@ -390,10 +406,12 @@ def _handle_data_message(self, callback, msg, obj):
                 subtype,
                 self.app_id,
             )
+        if not self.credentials:
+            return
         decrypted = self._decrypt_raw_data(
             self.credentials, crypto_key, salt, msg.raw_data
         )
-        with contextlib_suppress((json.JSONDecodeError, ValueError)):
+        with contextlib_suppress(json.JSONDecodeError, ValueError):
             decrypted_json = json.loads(decrypted.decode("utf-8"))
 
         ret_val = decrypted_json if decrypted_json else decrypted
@@ -401,7 +419,11 @@ def _handle_data_message(self, callback, msg, obj):
             "Decrypted data for message %s is: %s", msg.persistent_id, ret_val
         )
         if callback and self.listen_event_loop != self.callback_event_loop:
-            if callback and self.callback_event_loop.is_running():
+            if (
+                callback is not None
+                and self.callback_event_loop
+                and self.callback_event_loop.is_running()
+            ):
                 on_error = functools.partial(
                     self._try_increment_error_count, ErrorType.NOTIFY
                 )
@@ -430,14 +452,14 @@ def _handle_data_message(self, callback, msg, obj):
                 )
                 self._try_increment_error_count(ErrorType.NOTIFY)
 
-    def _new_input_stream_id_available(self):
+    def _new_input_stream_id_available(self) -> bool:
         return self.last_input_stream_id_reported != self.input_stream_id
 
-    def _get_input_stream_id(self):
+    def _get_input_stream_id(self) -> int:
         self.last_input_stream_id_reported = self.input_stream_id
         return self.input_stream_id
 
-    async def _handle_ping(self, p):
+    async def _handle_ping(self, p: HeartbeatPing) -> None:
         _logger.debug(
             "Received heartbeat ping, sending ack: Stream ID: %s, Last: %s, Status: %s",
             p.stream_id,
@@ -451,7 +473,7 @@ async def _handle_ping(self, p):
 
         await self._send_msg(req)
 
-    async def _handle_iq(self, p):
+    async def _handle_iq(self, p: IqStanza) -> None:
         if not p.extension:
             self._log_warn_with_limit(
                 "Unexpected IqStanza id received with no extension", str(p)
@@ -463,7 +485,7 @@ async def _handle_iq(self, p):
             )
             return
 
-    async def _send_selective_ack(self, persistent_id):
+    async def _send_selective_ack(self, persistent_id: str) -> None:
         iqs = IqStanza()
         iqs.type = IqStanza.IqType.SET
         iqs.id = ""
@@ -475,7 +497,7 @@ async def _send_selective_ack(self, persistent_id):
         _logger.debug("Sending selective ack for message id %s", persistent_id)
         await self._send_msg(iqs)
 
-    async def _send_heartbeat(self):
+    async def _send_heartbeat(self) -> None:
         req = HeartbeatPing()
 
         if self._new_input_stream_id_available():
@@ -484,7 +506,7 @@ async def _send_heartbeat(self):
         await self._send_msg(req)
         _logger.debug("Sent heartbeat ping")
 
-    def _terminate(self):
+    def _terminate(self) -> None:
         self.run_state = FcmPushClientRunState.STOPPING
 
         self.do_listen = False
@@ -495,11 +517,14 @@ def _terminate(self):
             ):  # cancel return if task is done so no need to check
                 task.cancel()
 
-    async def _do_monitor(self, callback):
+    async def _do_monitor(self, callback: Optional[OnNotificationCallable]) -> None:
         while self.do_listen:
             await asyncio.sleep(self.config.monitor_interval)
 
-            if callback and not self.callback_event_loop.is_running():
+            if callback and (
+                not self.callback_event_loop
+                or not self.callback_event_loop.is_running()
+            ):
                 _logger.debug("Callback loop no longer running, terminating FcmClient")
                 self._terminate()
                 return
@@ -511,14 +536,14 @@ async def _do_monitor(self, callback):
                 if self.config.client_heartbeat_interval:
                     now = time.time()
                     if (
-                        self.last_message_time + self.config.client_heartbeat_interval
+                        self.last_message_time + self.config.client_heartbeat_interval  # type: ignore[operator]
                         < now
                     ):
                         await self._send_heartbeat()
                         await asyncio.sleep(self.config.heartbeat_ack_timeout)
                         now = time.time()
                         if (  # Check state hasn't changed during sleep
-                            self.last_message_time
+                            self.last_message_time  # type: ignore[operator]
                             + self.config.client_heartbeat_interval
                             < now
                             and self.do_listen
@@ -528,15 +553,15 @@ async def _do_monitor(self, callback):
                 elif self.config.server_heartbeat_interval:
                     now = time.time()
                     if (  # We give the server 2 extra seconds
-                        self.last_message_time + self.config.server_heartbeat_interval
+                        self.last_message_time + self.config.server_heartbeat_interval  # type: ignore[operator]
                         < now - 2
                     ):
                         await self._reset()
 
-    def _reset_error_count(self, error_type: ErrorType):
+    def _reset_error_count(self, error_type: ErrorType) -> None:
         self.sequential_error_counters[error_type] = 0
 
-    def _try_increment_error_count(self, error_type: ErrorType):
+    def _try_increment_error_count(self, error_type: ErrorType) -> bool:
         if error_type not in self.sequential_error_counters:
             self.sequential_error_counters[error_type] = 0
 
@@ -556,7 +581,9 @@ def _try_increment_error_count(self, error_type: ErrorType):
             return False
         return True
 
-    async def _handle_message(self, msg, callback, obj):
+    async def _handle_message(
+        self, msg: Message, callback: Optional[OnNotificationCallable], obj: Any
+    ) -> None:
         self.last_message_time = time.time()
         self.input_stream_id += 1
 
@@ -596,10 +623,12 @@ async def _handle_message(self, msg, callback, obj):
         self._reset_error_count(ErrorType.CONNECTION)
 
     @staticmethod
-    async def _open_connection(host, port, ssl):
+    async def _open_connection(
+        host: str, port: int, ssl: bool
+    ) -> Tuple[asyncio.StreamReader, asyncio.StreamWriter]:
         return await asyncio.open_connection(host=host, port=port, ssl=ssl)
 
-    async def _connect(self):
+    async def _connect(self) -> bool:
         try:
             self.reader, self.writer = await self._open_connection(
                 host=MCS_HOST, port=MCS_PORT, ssl=True
@@ -615,7 +644,7 @@ async def _connect(self):
             )
             return False
 
-    async def _connect_with_retry(self):
+    async def _connect_with_retry(self) -> bool:
         self.run_state = FcmPushClientRunState.STARTING_CONNECTION
 
         trycount = 0
@@ -644,7 +673,9 @@ async def _connect_with_retry(self):
             )
         return connected
 
-    async def _listen(self, callback, obj=None):  # pylint: disable=too-many-branches
+    async def _listen(
+        self, callback: Optional[OnNotificationCallable], obj: Any = None
+    ) -> None:
         """
         listens for push notifications
 
@@ -658,8 +689,15 @@ async def _listen(self, callback, obj=None):  # pylint: disable=too-many-branche
         try:
             await self._login()
 
-            while self.do_listen and self.listen_event_loop.is_running():
-                if callback and not self.callback_event_loop.is_running():
+            while (
+                self.do_listen
+                and self.listen_event_loop
+                and self.listen_event_loop.is_running()
+            ):
+                if callback and (
+                    not self.callback_event_loop
+                    or not self.callback_event_loop.is_running()
+                ):
                     _logger.debug(
                         "Callback loop no longer running, terminating FcmClient"
                     )
@@ -714,7 +752,9 @@ async def _listen(self, callback, obj=None):  # pylint: disable=too-many-branche
         finally:
             await self._do_writer_close()
 
-    async def _run_tasks(self, callback, obj):
+    async def _run_tasks(
+        self, callback: Optional[OnNotificationCallable], obj: Any
+    ) -> None:
         self.reset_lock = asyncio.Lock()
         self.stopping_lock = asyncio.Lock()
         self.do_listen = True
@@ -729,7 +769,9 @@ async def _run_tasks(self, callback, obj):
         except Exception as ex:
             _logger.error("Unexpected error running FcmPushClient: %s", ex)
 
-    def _start_on_new_loop(self, callback, obj):
+    def _start_on_new_loop(
+        self, callback: Optional[OnNotificationCallable], obj: Any
+    ) -> None:
         self.listen_event_loop = asyncio.new_event_loop()
         if not self.callback_event_loop:
             self.callback_event_loop = self.listen_event_loop
@@ -737,19 +779,21 @@ def _start_on_new_loop(self, callback, obj):
         asyncio.set_event_loop(self.listen_event_loop)
         self.listen_event_loop.run_until_complete(self._run_tasks(callback, obj))
 
-    def _start_on_existing_loop(self, callback, obj):
-        self.listen_event_loop.create_task(self._run_tasks(callback, obj))
+    def _start_on_existing_loop(
+        self, callback: Optional[OnNotificationCallable], obj: Any
+    ) -> None:
+        self.listen_event_loop.create_task(self._run_tasks(callback, obj))  # type: ignore[union-attr]
 
     @staticmethod
     def _wrapped_callback(
-        fcm_client_loop,
-        on_error,
-        on_success,
-        callback,
-        notification,
-        persistent_id,
-        obj,
-    ):  # pylint: disable=too-many-arguments
+        fcm_client_loop: asyncio.AbstractEventLoop,
+        on_error: functools.partial,
+        on_success: functools.partial,
+        callback: OnNotificationCallable,
+        notification: Dict[str, Dict[str, str]],
+        persistent_id: str,
+        obj: Any,
+    ) -> None:  # pylint: disable=too-many-arguments
         # Should be running on callback loop
 
         try:
@@ -759,7 +803,7 @@ def _wrapped_callback(
             _logger.exception("Unexpected exception calling notification callback\n")
             fcm_client_loop.call_soon_threadsafe(on_error)
 
-    def checkin(self, sender_id: int, app_id: str) -> str:
+    async def checkin(self, sender_id: int, app_id: str) -> str:
         """Check in if you have credentials otherwise register as a new client.
 
         :param sender_id: sender id identifying push service you are connecting to.
@@ -767,21 +811,15 @@ def checkin(self, sender_id: int, app_id: str) -> str:
         :return: The FCM token which is used to identify you with the push end
             point application.
         """
-        self.sender_id = sender_id
         self.app_id = app_id
-        if self.credentials:
-            gcm_response = gcm_check_in(
-                self.credentials["gcm"]["androidId"],
-                self.credentials["gcm"]["securityToken"],
-                log_debug_verbose=self.config.log_debug_verbose,
-            )
-            if gcm_response:
-                return self.credentials["fcm"]["token"]
-
-        self.credentials = self.register(sender_id, app_id)
-        if self.credentials_updated_callback:
-            self.credentials_updated_callback(self.credentials)
-
+        self.sender_id = sender_id
+        register = FcmRegister(
+            self.credentials,
+            self.credentials_updated_callback,
+            http_client_session=self._http_client_session,
+        )
+        self.credentials = await register.checkin(sender_id, app_id)
+        await register.close()
         return self.credentials["fcm"]["token"]
 
     def start(
@@ -835,14 +873,19 @@ def start(
             )
             self.fcm_thread.start()
 
-    async def _stop_connection(self):
-        if self.stopping_lock.locked() or self.run_state in (
-            FcmPushClientRunState.STOPPING,
-            FcmPushClientRunState.STOPPED,
+    async def _stop_connection(self) -> None:
+        if (
+            self.stopping_lock
+            and self.stopping_lock.locked()
+            or self.run_state
+            in (
+                FcmPushClientRunState.STOPPING,
+                FcmPushClientRunState.STOPPED,
+            )
         ):
             return
 
-        async with self.stopping_lock:
+        async with self.stopping_lock:  # type: ignore[union-attr]
             try:
                 self.run_state = FcmPushClientRunState.STOPPING
 
@@ -876,45 +919,13 @@ def stop(self) -> None:
         elif self.listen_event_loop and self.listen_event_loop.is_running():
             self.listen_event_loop.create_task(self._stop_connection())
 
-    def register(self, sender_id: int, app_id: str) -> dict:
-        """Register gcm and fcm tokens for sender_id.
-            Typically you would
-            call checkin instead of register which does not do a full registration
-            if credentials are present
-
-        :param sender_id: sender id identifying push service you are connecting to.
-        :param app_id: identifier for your application.
-        :return: The dict containing all credentials.
-        """
-        self.sender_id = sender_id
-        self.app_id = app_id
-        subscription = gcm_register(
-            app_id=app_id, log_debug_verbose=self.config.log_debug_verbose
-        )
-        if subscription is None:
-            raise RuntimeError(
-                "Unable to establish subscription with Google Cloud Messaging."
-            )
-        self._log_verbose("GCM subscription: %s", subscription)
-        fcm = fcm_register(
-            sender_id=sender_id,
-            token=subscription["token"],
-            log_debug_verbose=self.config.log_debug_verbose,
-        )
-        self._log_verbose("FCM registration: %s", fcm)
-        res = {"gcm": subscription}
-        res.update(fcm)
-        self._log_verbose("Credential: %s", res)
-        _logger.info("Registered with FCM")
-        return res
-
-    async def _send_data_message(self, raw_data, persistent_id):
+    async def _send_data_message(self, raw_data_: bytes, persistent_id: str) -> None:
         dms = DataMessageStanza()
         dms.persistent_id = persistent_id
-        dms.data = raw_data
+
         # Not supported yet
 
-    def send_message(self, raw_data, persistent_id) -> None:
+    def send_message(self, raw_data: bytes, persistent_id: str) -> None:
         """Not implemented, does nothing atm."""
         if self.fcm_thread:
             asyncio.run_coroutine_threadsafe(
@@ -926,6 +937,6 @@ def send_message(self, raw_data, persistent_id) -> None:
                 self._send_data_message(raw_data, persistent_id)
             )
 
-    def __del__(self):
+    def __del__(self) -> None:
         if self.listen_event_loop and self.listen_event_loop.is_running():
             self.stop()
diff --git a/firebase_messaging/fcmregister.py b/firebase_messaging/fcmregister.py
new file mode 100644
index 0000000..7495a5d
--- /dev/null
+++ b/firebase_messaging/fcmregister.py
@@ -0,0 +1,362 @@
+import asyncio
+import logging
+import os
+from base64 import urlsafe_b64encode
+from typing import Any, Callable, Dict, Optional, Union
+
+from aiohttp import ClientSession
+from cryptography.hazmat.primitives import serialization
+from cryptography.hazmat.primitives.asymmetric import ec
+from google.protobuf.json_format import MessageToDict, MessageToJson
+
+from .const import (
+    FCM_SEND_URL,
+    FCM_SUBSCRIBE_URL,
+    GCM_CHECKIN_URL,
+    GCM_REGISTER_URL,
+    GCM_SERVER_KEY_B64,
+)
+from .proto.android_checkin_pb2 import (
+    DEVICE_CHROME_BROWSER,
+    AndroidCheckinProto,
+    ChromeBuildProto,
+)
+from .proto.checkin_pb2 import (
+    AndroidCheckinRequest,
+    AndroidCheckinResponse,
+)
+
+_logger = logging.getLogger(__name__)
+
+
+class FcmRegister:
+    def __init__(
+        self,
+        credentials: Optional[dict] = None,
+        credentials_updated_callback: Optional[Callable[[Dict[str, Any]], None]] = None,
+        *,
+        http_client_session: Optional[ClientSession] = None,
+        log_debug_verbose: bool = False,
+    ):
+        self.credentials = credentials
+        self.credentials_updated_callback = credentials_updated_callback
+
+        self._log_debug_verbose = log_debug_verbose
+
+        self._http_client_session = http_client_session
+        self._local_session: Optional[ClientSession] = None
+
+        self.app_id: Optional[str] = None
+        self.sender_id: Optional[int] = None
+
+    def _get_checkin_payload(
+        self, android_id: Optional[int] = None, security_token: Optional[int] = None
+    ) -> AndroidCheckinRequest:
+        chrome = ChromeBuildProto()
+        chrome.platform = ChromeBuildProto.Platform.PLATFORM_LINUX  # 3
+        chrome.chrome_version = "63.0.3234.0"
+        chrome.channel = ChromeBuildProto.Channel.CHANNEL_STABLE  # 1
+
+        checkin = AndroidCheckinProto()
+        checkin.type = DEVICE_CHROME_BROWSER  # 3
+        checkin.chrome_build.CopyFrom(chrome)
+
+        payload = AndroidCheckinRequest()
+        payload.user_serial_number = 0
+        payload.checkin.CopyFrom(checkin)
+        payload.version = 3
+        if android_id and security_token:
+            payload.id = int(android_id)
+            payload.security_token = int(security_token)
+
+        return payload
+
+    async def gcm_check_in(
+        self,
+        android_id: Optional[int] = None,
+        security_token: Optional[int] = None,
+        log_debug_verbose: bool = False,
+    ) -> Optional[Dict[str, Any]]:
+        """
+        perform check-in request
+
+        android_id, security_token can be provided if we already did the initial
+        check-in
+
+        returns dict with android_id, security_token and more
+        """
+
+        payload = self._get_checkin_payload(android_id, security_token)
+
+        if log_debug_verbose:
+            _logger.debug("GCM check in payload:\n%s", payload)
+
+        retries = 3
+        acir = None
+        content = None
+        for try_num in range(retries):
+            try:
+                async with self._session.post(
+                    url=GCM_CHECKIN_URL,
+                    headers={"Content-Type": "application/x-protobuf"},
+                    data=payload.SerializeToString(),
+                    timeout=2,
+                ) as resp:
+                    if resp.status == 200:
+                        acir = AndroidCheckinResponse()
+                        content = await resp.read()
+                        break
+                    else:
+                        text = await resp.text()
+                if acir and content:
+                    break
+                else:
+                    _logger.warning(
+                        "GCM checkin failed on attempt %s out "
+                        + "of %s with status: %s, %s",
+                        try_num + 1,
+                        retries,
+                        resp.status,
+                        text,
+                    )
+                # retry without android id and security_token
+                payload = self._get_checkin_payload()
+                await asyncio.sleep(1)
+            except Exception as e:
+                _logger.warning(
+                    "Error during gcm checkin post attempt %s out of %s",
+                    try_num + 1,
+                    retries,
+                    exc_info=e,
+                )
+                await asyncio.sleep(1)
+
+        if not acir or not content:
+            _logger.error("Unable to checkin to gcm after %s retries", retries)
+            return None
+        acir.ParseFromString(content)
+
+        if log_debug_verbose:
+            msg = MessageToJson(acir, indent=4)
+            _logger.debug("GCM check in response (raw):\n%s", msg)
+
+        return MessageToDict(acir)
+
+    async def gcm_register(
+        self, app_id: str, retries: int = 5, log_debug_verbose: bool = False
+    ) -> Optional[Dict[str, str]]:
+        """
+        obtains a gcm token
+
+        app_id: app id as an integer
+        retries: number of failed requests before giving up
+
+        returns {"token": "...", "appId": 123123, "androidId":123123,
+                        "securityToken": 123123}
+        """
+        # contains android_id, security_token and more
+        chk = await self.gcm_check_in(log_debug_verbose=log_debug_verbose)
+        if not chk:
+            raise RuntimeError("Unable to register and check in to gcm")
+        if log_debug_verbose:
+            _logger.debug("GCM check in response %s", chk)
+        body = {
+            "app": "org.chromium.linux",
+            "X-subtype": app_id,
+            "device": chk["androidId"],
+            # "sender": urlsafe_base64(GCM_SERVER_KEY),
+            "sender": GCM_SERVER_KEY_B64,
+        }
+        if log_debug_verbose:
+            _logger.debug("GCM Registration request: %s", body)
+
+        auth = "AidLogin {}:{}".format(chk["androidId"], chk["securityToken"])
+        last_error: Optional[Union[str, Exception]] = None
+        for try_num in range(retries):
+            try:
+                async with self._session.post(
+                    url=GCM_REGISTER_URL,
+                    headers={"Authorization": auth},
+                    data=body,
+                    timeout=2,
+                ) as resp:
+                    response_text = await resp.text()
+                if "Error" in response_text:
+                    _logger.warning(
+                        "GCM register request attempt %s out of %s has failed with %s",
+                        try_num + 1,
+                        retries,
+                        response_text,
+                    )
+                    last_error = response_text
+                    await asyncio.sleep(1)
+                    continue
+                token = response_text.split("=")[1]
+                # get only the fields we need from the check in response
+                chkfields = {k: chk[k] for k in ["androidId", "securityToken"]}
+                res = {"token": token, "appId": app_id}
+                res.update(chkfields)
+                return res
+            except Exception as e:
+                last_error = e
+                _logger.warning(
+                    "Error during gcm auth request attempt %s out of %s",
+                    try_num + 1,
+                    retries,
+                    exc_info=e,
+                )
+                await asyncio.sleep(1)
+
+        errorstr = f"Unable to complete gcm auth request after {retries} tries"
+        if isinstance(last_error, Exception):
+            _logger.error(errorstr, exc_info=last_error)
+        else:
+            errorstr += f", last error was {last_error}"
+            _logger.error(errorstr)
+        return None
+
+    async def fcm_register(
+        self,
+        sender_id: int,
+        token: str,
+        retries: int = 5,
+        log_debug_verbose: bool = False,
+    ) -> Optional[Dict[str, Any]]:
+        """
+        generates key pair and obtains a fcm token
+
+        sender_id: sender id as an integer
+        token: the subscription token in the dict returned by gcm_register
+
+        returns {"keys": keys, "fcm": {...}}
+        """
+        # I used this analyzer to figure out how to slice the asn1 structs
+        # https://lapo.it/asn1js
+        # first byte of public key is skipped for some reason
+        # maybe it's always zero
+
+        private_key = ec.generate_private_key(ec.SECP256R1())
+        public_key = private_key.public_key()
+
+        serialized_private = private_key.private_bytes(
+            encoding=serialization.Encoding.DER,  # asn1
+            format=serialization.PrivateFormat.PKCS8,
+            encryption_algorithm=serialization.NoEncryption(),
+        )
+        serialized_public = public_key.public_bytes(
+            encoding=serialization.Encoding.DER,
+            format=serialization.PublicFormat.SubjectPublicKeyInfo,
+        )
+
+        keys = {
+            "public": urlsafe_b64encode(serialized_public[26:]).decode(
+                "ascii"
+            ),  # urlsafe_base64(serialized_public[26:]),
+            "private": urlsafe_b64encode(serialized_private).decode("ascii"),
+            "secret": urlsafe_b64encode(os.urandom(16)).decode("ascii"),
+        }
+        data = {
+            "authorized_entity": sender_id,
+            "endpoint": f"{FCM_SEND_URL}/{token}",
+            "encryption_key": keys["public"],
+            "encryption_auth": keys["secret"],
+        }
+        if log_debug_verbose:
+            _logger.debug("FCM registration data: %s", data)
+
+        for try_num in range(retries):
+            try:
+                async with self._session.post(
+                    url=FCM_SUBSCRIBE_URL,
+                    data=data,
+                    timeout=2,
+                ) as resp:
+                    fcm = await resp.json()
+                return {"keys": keys, "fcm": fcm}
+            except Exception as e:
+                _logger.error(  # pylint: disable=duplicate-code
+                    "Error during fmc register request attempt %s out of %s",
+                    try_num + 1,
+                    retries,
+                    exc_info=e,
+                )
+                await asyncio.sleep(1)
+        return None
+
+    async def checkin(self, sender_id: int, app_id: str) -> Dict[str, Any]:
+        """Check in if you have credentials otherwise register as a new client.
+
+        :param sender_id: sender id identifying push service you are connecting to.
+        :param app_id: identifier for your application.
+        :return: The FCM token which is used to identify you with the push end
+            point application.
+        """
+        self.sender_id = sender_id
+        self.app_id = app_id
+        if self.credentials:
+            gcm_response = await self.gcm_check_in(
+                self.credentials["gcm"]["androidId"],
+                self.credentials["gcm"]["securityToken"],
+                log_debug_verbose=self._log_debug_verbose,
+            )
+            if gcm_response:
+                return self.credentials
+
+        self.credentials = await self.register(sender_id, app_id)
+        if self.credentials_updated_callback:
+            self.credentials_updated_callback(self.credentials)
+
+        return self.credentials
+
+    async def register(self, sender_id: int, app_id: str) -> Dict:
+        """Register gcm and fcm tokens for sender_id.
+            Typically you would
+            call checkin instead of register which does not do a full registration
+            if credentials are present
+
+        :param sender_id: sender id identifying push service you are connecting to.
+        :param app_id: identifier for your application.
+        :return: The dict containing all credentials.
+        """
+        self.sender_id = sender_id
+        self.app_id = app_id
+        subscription = await self.gcm_register(
+            app_id=app_id, log_debug_verbose=self._log_debug_verbose
+        )
+        if subscription is None:
+            raise RuntimeError(
+                "Unable to establish subscription with Google Cloud Messaging."
+            )
+        self._log_verbose("GCM subscription: %s", subscription)
+        fcm = await self.fcm_register(
+            sender_id=sender_id,
+            token=subscription["token"],
+            log_debug_verbose=self._log_debug_verbose,
+        )
+        if not fcm:
+            raise RuntimeError("Unable to register with fcm")
+        self._log_verbose("FCM registration: %s", fcm)
+        res: Dict[str, Any] = {"gcm": subscription}
+        res.update(fcm)
+        self._log_verbose("Credential: %s", res)
+        _logger.info("Registered with FCM")
+        return res
+
+    def _log_verbose(self, msg: str, *args: object) -> None:
+        if self._log_debug_verbose:
+            _logger.debug(msg, *args)
+
+    @property
+    def _session(self) -> ClientSession:
+        if self._http_client_session:
+            return self._http_client_session
+        if self._local_session is None:
+            self._local_session = ClientSession()
+        return self._local_session
+
+    async def close(self) -> None:
+        """Close aiohttp session."""
+        session = self._local_session
+        self._local_session = None
+        if session:
+            await session.close()
diff --git a/firebase_messaging/gcm.py b/firebase_messaging/gcm.py
deleted file mode 100644
index d62c378..0000000
--- a/firebase_messaging/gcm.py
+++ /dev/null
@@ -1,178 +0,0 @@
-import logging
-import time
-from typing import Optional, Union
-
-import requests
-from google.protobuf.json_format import MessageToDict, MessageToJson
-
-from .const import GCM_CHECKIN_URL, GCM_REGISTER_URL, GCM_SERVER_KEY_B64
-from .proto.android_checkin_pb2 import (
-    DEVICE_CHROME_BROWSER,
-    AndroidCheckinProto,
-    ChromeBuildProto,
-)
-from .proto.checkin_pb2 import (
-    AndroidCheckinRequest,
-    AndroidCheckinResponse,
-)
-
-_logger = logging.getLogger(__name__)
-
-
-def _get_checkin_payload(
-    android_id: Optional[int] = None, security_token: Optional[int] = None
-):
-    chrome = ChromeBuildProto()
-    chrome.platform = ChromeBuildProto.Platform.PLATFORM_LINUX  # 3
-    chrome.chrome_version = "63.0.3234.0"
-    chrome.channel = ChromeBuildProto.Channel.CHANNEL_STABLE  # 1
-
-    checkin = AndroidCheckinProto()
-    checkin.type = DEVICE_CHROME_BROWSER  # 3
-    checkin.chrome_build.CopyFrom(chrome)
-
-    payload = AndroidCheckinRequest()
-    payload.user_serial_number = 0
-    payload.checkin.CopyFrom(checkin)
-    payload.version = 3
-    if android_id and security_token:
-        payload.id = int(android_id)
-        payload.security_token = int(security_token)
-
-    return payload
-
-
-def gcm_check_in(
-    android_id: Optional[int] = None,
-    security_token: Optional[int] = None,
-    log_debug_verbose=False,
-):
-    """
-    perform check-in request
-
-    android_id, security_token can be provided if we already did the initial
-    check-in
-
-    returns dict with android_id, security_token and more
-    """
-
-    payload = _get_checkin_payload(android_id, security_token)
-
-    if log_debug_verbose:
-        _logger.debug("GCM check in payload:\n%s", payload)
-
-    retries = 3
-    acir = None
-    for try_num in range(retries):
-        try:
-            resp = requests.post(
-                url=GCM_CHECKIN_URL,
-                headers={"Content-Type": "application/x-protobuf"},
-                data=payload.SerializeToString(),
-                timeout=2,
-            )
-            if resp.status_code == 200:
-                acir = AndroidCheckinResponse()
-                break
-            else:
-                _logger.warning(
-                    "GCM checkin failed on attempt %s out of %s with status: %s, %s",
-                    try_num + 1,
-                    retries,
-                    resp.status_code,
-                    resp.text,
-                )
-                # retry without android id and security_token
-                payload = _get_checkin_payload()
-                time.sleep(1)
-        except Exception as e:
-            _logger.warning(
-                "Error during gcm checkin post attempt %s out of %s",
-                try_num + 1,
-                retries,
-                exc_info=e,
-            )
-            time.sleep(1)
-
-    if not acir:
-        _logger.error("Unable to checkin to gcm after %s retries", retries)
-        return None
-
-    acir.ParseFromString(resp.content)
-
-    if log_debug_verbose:
-        msg = MessageToJson(acir, indent=4)
-        _logger.debug("GCM check in response (raw):\n%s", msg)
-
-    return MessageToDict(acir)
-
-
-def gcm_register(app_id: str, retries=5, log_debug_verbose=False):
-    """
-    obtains a gcm token
-
-    app_id: app id as an integer
-    retries: number of failed requests before giving up
-
-    returns {"token": "...", "appId": 123123, "androidId":123123,
-                     "securityToken": 123123}
-    """
-    # contains android_id, security_token and more
-    chk = gcm_check_in(log_debug_verbose=log_debug_verbose)
-
-    if log_debug_verbose:
-        _logger.debug("GCM check in response %s", chk)
-    body = {
-        "app": "org.chromium.linux",
-        "X-subtype": app_id,
-        "device": chk["androidId"],
-        # "sender": urlsafe_base64(GCM_SERVER_KEY),
-        "sender": GCM_SERVER_KEY_B64,
-    }
-    if log_debug_verbose:
-        _logger.debug("GCM Registration request: %s", body)
-
-    auth = "AidLogin {}:{}".format(chk["androidId"], chk["securityToken"])
-    last_error: Optional[Union[str, Exception]] = None
-    for try_num in range(retries):
-        try:
-            resp = requests.post(
-                url=GCM_REGISTER_URL,
-                headers={"Authorization": auth},
-                data=body,
-                timeout=2,
-            )
-            resp_data = resp.text
-            if "Error" in resp_data:
-                _logger.warning(
-                    "GCM register request attempt %s out of %s has failed with %s",
-                    try_num + 1,
-                    retries,
-                    resp_data,
-                )
-                last_error = resp_data
-                time.sleep(1)
-                continue
-            token = resp_data.split("=")[1]
-            # get only the fields we need from the check in response
-            chkfields = {k: chk[k] for k in ["androidId", "securityToken"]}
-            res = {"token": token, "appId": app_id}
-            res.update(chkfields)
-            return res
-        except Exception as e:
-            last_error = e
-            _logger.warning(
-                "Error during gcm auth request attempt %s out of %s",
-                try_num + 1,
-                retries,
-                exc_info=e,
-            )
-            time.sleep(1)
-
-    errorstr = f"Unable to complete gcm auth request after {retries} tries"
-    if isinstance(last_error, Exception):
-        _logger.error(errorstr, exc_info=last_error)
-    else:
-        errorstr += f", last error was {last_error}"
-        _logger.error(errorstr)
-    return None
diff --git a/firebase_messaging/proto/checkin_pb2.pyi b/firebase_messaging/proto/checkin_pb2.pyi
index 45879df..855a264 100644
--- a/firebase_messaging/proto/checkin_pb2.pyi
+++ b/firebase_messaging/proto/checkin_pb2.pyi
@@ -7,7 +7,7 @@ found in the LICENSE file.
 
 Request and reply to the "checkin server" devices poll every few hours.
 """
-import android_checkin_pb2
+from . import android_checkin_pb2
 import builtins
 import collections.abc
 import google.protobuf.descriptor
diff --git a/poetry.lock b/poetry.lock
index 97c21a9..b68b966 100644
--- a/poetry.lock
+++ b/poetry.lock
@@ -1,5 +1,129 @@
 # This file is automatically @generated by Poetry 1.7.1 and should not be changed by hand.
 
+[[package]]
+name = "aiohttp"
+version = "3.9.3"
+description = "Async http client/server framework (asyncio)"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "aiohttp-3.9.3-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:939677b61f9d72a4fa2a042a5eee2a99a24001a67c13da113b2e30396567db54"},
+    {file = "aiohttp-3.9.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:1f5cd333fcf7590a18334c90f8c9147c837a6ec8a178e88d90a9b96ea03194cc"},
+    {file = "aiohttp-3.9.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:82e6aa28dd46374f72093eda8bcd142f7771ee1eb9d1e223ff0fa7177a96b4a5"},
+    {file = "aiohttp-3.9.3-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f56455b0c2c7cc3b0c584815264461d07b177f903a04481dfc33e08a89f0c26b"},
+    {file = "aiohttp-3.9.3-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:bca77a198bb6e69795ef2f09a5f4c12758487f83f33d63acde5f0d4919815768"},
+    {file = "aiohttp-3.9.3-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e083c285857b78ee21a96ba1eb1b5339733c3563f72980728ca2b08b53826ca5"},
+    {file = "aiohttp-3.9.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ab40e6251c3873d86ea9b30a1ac6d7478c09277b32e14745d0d3c6e76e3c7e29"},
+    {file = "aiohttp-3.9.3-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:df822ee7feaaeffb99c1a9e5e608800bd8eda6e5f18f5cfb0dc7eeb2eaa6bbec"},
+    {file = "aiohttp-3.9.3-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:acef0899fea7492145d2bbaaaec7b345c87753168589cc7faf0afec9afe9b747"},
+    {file = "aiohttp-3.9.3-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:cd73265a9e5ea618014802ab01babf1940cecb90c9762d8b9e7d2cc1e1969ec6"},
+    {file = "aiohttp-3.9.3-cp310-cp310-musllinux_1_1_ppc64le.whl", hash = "sha256:a78ed8a53a1221393d9637c01870248a6f4ea5b214a59a92a36f18151739452c"},
+    {file = "aiohttp-3.9.3-cp310-cp310-musllinux_1_1_s390x.whl", hash = "sha256:6b0e029353361f1746bac2e4cc19b32f972ec03f0f943b390c4ab3371840aabf"},
+    {file = "aiohttp-3.9.3-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:7cf5c9458e1e90e3c390c2639f1017a0379a99a94fdfad3a1fd966a2874bba52"},
+    {file = "aiohttp-3.9.3-cp310-cp310-win32.whl", hash = "sha256:3e59c23c52765951b69ec45ddbbc9403a8761ee6f57253250c6e1536cacc758b"},
+    {file = "aiohttp-3.9.3-cp310-cp310-win_amd64.whl", hash = "sha256:055ce4f74b82551678291473f66dc9fb9048a50d8324278751926ff0ae7715e5"},
+    {file = "aiohttp-3.9.3-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:6b88f9386ff1ad91ace19d2a1c0225896e28815ee09fc6a8932fded8cda97c3d"},
+    {file = "aiohttp-3.9.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:c46956ed82961e31557b6857a5ca153c67e5476972e5f7190015018760938da2"},
+    {file = "aiohttp-3.9.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:07b837ef0d2f252f96009e9b8435ec1fef68ef8b1461933253d318748ec1acdc"},
+    {file = "aiohttp-3.9.3-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:dad46e6f620574b3b4801c68255492e0159d1712271cc99d8bdf35f2043ec266"},
+    {file = "aiohttp-3.9.3-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5ed3e046ea7b14938112ccd53d91c1539af3e6679b222f9469981e3dac7ba1ce"},
+    {file = "aiohttp-3.9.3-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:039df344b45ae0b34ac885ab5b53940b174530d4dd8a14ed8b0e2155b9dddccb"},
+    {file = "aiohttp-3.9.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7943c414d3a8d9235f5f15c22ace69787c140c80b718dcd57caaade95f7cd93b"},
+    {file = "aiohttp-3.9.3-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:84871a243359bb42c12728f04d181a389718710129b36b6aad0fc4655a7647d4"},
+    {file = "aiohttp-3.9.3-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:5eafe2c065df5401ba06821b9a054d9cb2848867f3c59801b5d07a0be3a380ae"},
+    {file = "aiohttp-3.9.3-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:9d3c9b50f19704552f23b4eaea1fc082fdd82c63429a6506446cbd8737823da3"},
+    {file = "aiohttp-3.9.3-cp311-cp311-musllinux_1_1_ppc64le.whl", hash = "sha256:f033d80bc6283092613882dfe40419c6a6a1527e04fc69350e87a9df02bbc283"},
+    {file = "aiohttp-3.9.3-cp311-cp311-musllinux_1_1_s390x.whl", hash = "sha256:2c895a656dd7e061b2fd6bb77d971cc38f2afc277229ce7dd3552de8313a483e"},
+    {file = "aiohttp-3.9.3-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:1f5a71d25cd8106eab05f8704cd9167b6e5187bcdf8f090a66c6d88b634802b4"},
+    {file = "aiohttp-3.9.3-cp311-cp311-win32.whl", hash = "sha256:50fca156d718f8ced687a373f9e140c1bb765ca16e3d6f4fe116e3df7c05b2c5"},
+    {file = "aiohttp-3.9.3-cp311-cp311-win_amd64.whl", hash = "sha256:5fe9ce6c09668063b8447f85d43b8d1c4e5d3d7e92c63173e6180b2ac5d46dd8"},
+    {file = "aiohttp-3.9.3-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:38a19bc3b686ad55804ae931012f78f7a534cce165d089a2059f658f6c91fa60"},
+    {file = "aiohttp-3.9.3-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:770d015888c2a598b377bd2f663adfd947d78c0124cfe7b959e1ef39f5b13869"},
+    {file = "aiohttp-3.9.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ee43080e75fc92bf36219926c8e6de497f9b247301bbf88c5c7593d931426679"},
+    {file = "aiohttp-3.9.3-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:52df73f14ed99cee84865b95a3d9e044f226320a87af208f068ecc33e0c35b96"},
+    {file = "aiohttp-3.9.3-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:dc9b311743a78043b26ffaeeb9715dc360335e5517832f5a8e339f8a43581e4d"},
+    {file = "aiohttp-3.9.3-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b955ed993491f1a5da7f92e98d5dad3c1e14dc175f74517c4e610b1f2456fb11"},
+    {file = "aiohttp-3.9.3-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:504b6981675ace64c28bf4a05a508af5cde526e36492c98916127f5a02354d53"},
+    {file = "aiohttp-3.9.3-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a6fe5571784af92b6bc2fda8d1925cccdf24642d49546d3144948a6a1ed58ca5"},
+    {file = "aiohttp-3.9.3-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:ba39e9c8627edc56544c8628cc180d88605df3892beeb2b94c9bc857774848ca"},
+    {file = "aiohttp-3.9.3-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:e5e46b578c0e9db71d04c4b506a2121c0cb371dd89af17a0586ff6769d4c58c1"},
+    {file = "aiohttp-3.9.3-cp312-cp312-musllinux_1_1_ppc64le.whl", hash = "sha256:938a9653e1e0c592053f815f7028e41a3062e902095e5a7dc84617c87267ebd5"},
+    {file = "aiohttp-3.9.3-cp312-cp312-musllinux_1_1_s390x.whl", hash = "sha256:c3452ea726c76e92f3b9fae4b34a151981a9ec0a4847a627c43d71a15ac32aa6"},
+    {file = "aiohttp-3.9.3-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:ff30218887e62209942f91ac1be902cc80cddb86bf00fbc6783b7a43b2bea26f"},
+    {file = "aiohttp-3.9.3-cp312-cp312-win32.whl", hash = "sha256:38f307b41e0bea3294a9a2a87833191e4bcf89bb0365e83a8be3a58b31fb7f38"},
+    {file = "aiohttp-3.9.3-cp312-cp312-win_amd64.whl", hash = "sha256:b791a3143681a520c0a17e26ae7465f1b6f99461a28019d1a2f425236e6eedb5"},
+    {file = "aiohttp-3.9.3-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:0ed621426d961df79aa3b963ac7af0d40392956ffa9be022024cd16297b30c8c"},
+    {file = "aiohttp-3.9.3-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:7f46acd6a194287b7e41e87957bfe2ad1ad88318d447caf5b090012f2c5bb528"},
+    {file = "aiohttp-3.9.3-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:feeb18a801aacb098220e2c3eea59a512362eb408d4afd0c242044c33ad6d542"},
+    {file = "aiohttp-3.9.3-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f734e38fd8666f53da904c52a23ce517f1b07722118d750405af7e4123933511"},
+    {file = "aiohttp-3.9.3-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b40670ec7e2156d8e57f70aec34a7216407848dfe6c693ef131ddf6e76feb672"},
+    {file = "aiohttp-3.9.3-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:fdd215b7b7fd4a53994f238d0f46b7ba4ac4c0adb12452beee724ddd0743ae5d"},
+    {file = "aiohttp-3.9.3-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:017a21b0df49039c8f46ca0971b3a7fdc1f56741ab1240cb90ca408049766168"},
+    {file = "aiohttp-3.9.3-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e99abf0bba688259a496f966211c49a514e65afa9b3073a1fcee08856e04425b"},
+    {file = "aiohttp-3.9.3-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:648056db9a9fa565d3fa851880f99f45e3f9a771dd3ff3bb0c048ea83fb28194"},
+    {file = "aiohttp-3.9.3-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:8aacb477dc26797ee089721536a292a664846489c49d3ef9725f992449eda5a8"},
+    {file = "aiohttp-3.9.3-cp38-cp38-musllinux_1_1_ppc64le.whl", hash = "sha256:522a11c934ea660ff8953eda090dcd2154d367dec1ae3c540aff9f8a5c109ab4"},
+    {file = "aiohttp-3.9.3-cp38-cp38-musllinux_1_1_s390x.whl", hash = "sha256:5bce0dc147ca85caa5d33debc4f4d65e8e8b5c97c7f9f660f215fa74fc49a321"},
+    {file = "aiohttp-3.9.3-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:4b4af9f25b49a7be47c0972139e59ec0e8285c371049df1a63b6ca81fdd216a2"},
+    {file = "aiohttp-3.9.3-cp38-cp38-win32.whl", hash = "sha256:298abd678033b8571995650ccee753d9458dfa0377be4dba91e4491da3f2be63"},
+    {file = "aiohttp-3.9.3-cp38-cp38-win_amd64.whl", hash = "sha256:69361bfdca5468c0488d7017b9b1e5ce769d40b46a9f4a2eed26b78619e9396c"},
+    {file = "aiohttp-3.9.3-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:0fa43c32d1643f518491d9d3a730f85f5bbaedcbd7fbcae27435bb8b7a061b29"},
+    {file = "aiohttp-3.9.3-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:835a55b7ca49468aaaac0b217092dfdff370e6c215c9224c52f30daaa735c1c1"},
+    {file = "aiohttp-3.9.3-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:06a9b2c8837d9a94fae16c6223acc14b4dfdff216ab9b7202e07a9a09541168f"},
+    {file = "aiohttp-3.9.3-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:abf151955990d23f84205286938796c55ff11bbfb4ccfada8c9c83ae6b3c89a3"},
+    {file = "aiohttp-3.9.3-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:59c26c95975f26e662ca78fdf543d4eeaef70e533a672b4113dd888bd2423caa"},
+    {file = "aiohttp-3.9.3-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f95511dd5d0e05fd9728bac4096319f80615aaef4acbecb35a990afebe953b0e"},
+    {file = "aiohttp-3.9.3-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:595f105710293e76b9dc09f52e0dd896bd064a79346234b521f6b968ffdd8e58"},
+    {file = "aiohttp-3.9.3-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c7c8b816c2b5af5c8a436df44ca08258fc1a13b449393a91484225fcb7545533"},
+    {file = "aiohttp-3.9.3-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:f1088fa100bf46e7b398ffd9904f4808a0612e1d966b4aa43baa535d1b6341eb"},
+    {file = "aiohttp-3.9.3-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:f59dfe57bb1ec82ac0698ebfcdb7bcd0e99c255bd637ff613760d5f33e7c81b3"},
+    {file = "aiohttp-3.9.3-cp39-cp39-musllinux_1_1_ppc64le.whl", hash = "sha256:361a1026c9dd4aba0109e4040e2aecf9884f5cfe1b1b1bd3d09419c205e2e53d"},
+    {file = "aiohttp-3.9.3-cp39-cp39-musllinux_1_1_s390x.whl", hash = "sha256:363afe77cfcbe3a36353d8ea133e904b108feea505aa4792dad6585a8192c55a"},
+    {file = "aiohttp-3.9.3-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:8e2c45c208c62e955e8256949eb225bd8b66a4c9b6865729a786f2aa79b72e9d"},
+    {file = "aiohttp-3.9.3-cp39-cp39-win32.whl", hash = "sha256:f7217af2e14da0856e082e96ff637f14ae45c10a5714b63c77f26d8884cf1051"},
+    {file = "aiohttp-3.9.3-cp39-cp39-win_amd64.whl", hash = "sha256:27468897f628c627230dba07ec65dc8d0db566923c48f29e084ce382119802bc"},
+    {file = "aiohttp-3.9.3.tar.gz", hash = "sha256:90842933e5d1ff760fae6caca4b2b3edba53ba8f4b71e95dacf2818a2aca06f7"},
+]
+
+[package.dependencies]
+aiosignal = ">=1.1.2"
+async-timeout = {version = ">=4.0,<5.0", markers = "python_version < \"3.11\""}
+attrs = ">=17.3.0"
+frozenlist = ">=1.1.1"
+multidict = ">=4.5,<7.0"
+yarl = ">=1.0,<2.0"
+
+[package.extras]
+speedups = ["Brotli", "aiodns", "brotlicffi"]
+
+[[package]]
+name = "aioresponses"
+version = "0.7.6"
+description = "Mock out requests made by ClientSession from aiohttp package"
+optional = false
+python-versions = "*"
+files = [
+    {file = "aioresponses-0.7.6-py2.py3-none-any.whl", hash = "sha256:d2c26defbb9b440ea2685ec132e90700907fd10bcca3e85ec2f157219f0d26f7"},
+    {file = "aioresponses-0.7.6.tar.gz", hash = "sha256:f795d9dbda2d61774840e7e32f5366f45752d1adc1b74c9362afd017296c7ee1"},
+]
+
+[package.dependencies]
+aiohttp = ">=3.3.0,<4.0.0"
+
+[[package]]
+name = "aiosignal"
+version = "1.3.1"
+description = "aiosignal: a list of registered asynchronous callbacks"
+optional = false
+python-versions = ">=3.7"
+files = [
+    {file = "aiosignal-1.3.1-py3-none-any.whl", hash = "sha256:f8376fb07dd1e86a584e4fcdec80b36b7f81aac666ebc724e2c090300dd83b17"},
+    {file = "aiosignal-1.3.1.tar.gz", hash = "sha256:54cd96e15e1649b75d6c87526a6ff0b6c1b0dd3459f43d9ca11d48c339b68cfc"},
+]
+
+[package.dependencies]
+frozenlist = ">=1.1.0"
+
 [[package]]
 name = "alabaster"
 version = "0.7.13"
@@ -22,6 +146,25 @@ files = [
     {file = "async_timeout-4.0.3-py3-none-any.whl", hash = "sha256:7405140ff1230c310e51dc27b3145b9092d659ce68ff733fb0cefe3ee42be028"},
 ]
 
+[[package]]
+name = "attrs"
+version = "23.2.0"
+description = "Classes Without Boilerplate"
+optional = false
+python-versions = ">=3.7"
+files = [
+    {file = "attrs-23.2.0-py3-none-any.whl", hash = "sha256:99b87a485a5820b23b879f04c2305b44b951b502fd64be915879d77a7e8fc6f1"},
+    {file = "attrs-23.2.0.tar.gz", hash = "sha256:935dc3b529c262f6cf76e50877d35a4bd3c1de194fd41f47a2b7ae8f19971f30"},
+]
+
+[package.extras]
+cov = ["attrs[tests]", "coverage[toml] (>=5.3)"]
+dev = ["attrs[tests]", "pre-commit"]
+docs = ["furo", "myst-parser", "sphinx", "sphinx-notfound-page", "sphinxcontrib-towncrier", "towncrier", "zope-interface"]
+tests = ["attrs[tests-no-zope]", "zope-interface"]
+tests-mypy = ["mypy (>=1.6)", "pytest-mypy-plugins"]
+tests-no-zope = ["attrs[tests-mypy]", "cloudpickle", "hypothesis", "pympler", "pytest (>=4.3.0)", "pytest-xdist[psutil]"]
+
 [[package]]
 name = "babel"
 version = "2.13.1"
@@ -55,7 +198,7 @@ files = [
 name = "certifi"
 version = "2023.7.22"
 description = "Python package for providing Mozilla's CA Bundle."
-optional = false
+optional = true
 python-versions = ">=3.6"
 files = [
     {file = "certifi-2023.7.22-py3-none-any.whl", hash = "sha256:92d6037539857d8206b8f6ae472e8b77db8058fec5937a1ef3f54304089edbb9"},
@@ -152,7 +295,7 @@ files = [
 name = "charset-normalizer"
 version = "3.3.1"
 description = "The Real First Universal Charset Detector. Open, modern and actively maintained alternative to Chardet."
-optional = false
+optional = true
 python-versions = ">=3.7.0"
 files = [
     {file = "charset-normalizer-3.3.1.tar.gz", hash = "sha256:d9137a876020661972ca6eec0766d81aef8a5627df628b664b234b73396e727e"},
@@ -422,6 +565,92 @@ docs = ["furo (>=2023.7.26)", "sphinx (>=7.1.2)", "sphinx-autodoc-typehints (>=1
 testing = ["covdefaults (>=2.3)", "coverage (>=7.3)", "diff-cover (>=7.7)", "pytest (>=7.4)", "pytest-cov (>=4.1)", "pytest-mock (>=3.11.1)", "pytest-timeout (>=2.1)"]
 typing = ["typing-extensions (>=4.7.1)"]
 
+[[package]]
+name = "frozenlist"
+version = "1.4.1"
+description = "A list-like structure which implements collections.abc.MutableSequence"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "frozenlist-1.4.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:f9aa1878d1083b276b0196f2dfbe00c9b7e752475ed3b682025ff20c1c1f51ac"},
+    {file = "frozenlist-1.4.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:29acab3f66f0f24674b7dc4736477bcd4bc3ad4b896f5f45379a67bce8b96868"},
+    {file = "frozenlist-1.4.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:74fb4bee6880b529a0c6560885fce4dc95936920f9f20f53d99a213f7bf66776"},
+    {file = "frozenlist-1.4.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:590344787a90ae57d62511dd7c736ed56b428f04cd8c161fcc5e7232c130c69a"},
+    {file = "frozenlist-1.4.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:068b63f23b17df8569b7fdca5517edef76171cf3897eb68beb01341131fbd2ad"},
+    {file = "frozenlist-1.4.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5c849d495bf5154cd8da18a9eb15db127d4dba2968d88831aff6f0331ea9bd4c"},
+    {file = "frozenlist-1.4.1-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:9750cc7fe1ae3b1611bb8cfc3f9ec11d532244235d75901fb6b8e42ce9229dfe"},
+    {file = "frozenlist-1.4.1-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a9b2de4cf0cdd5bd2dee4c4f63a653c61d2408055ab77b151c1957f221cabf2a"},
+    {file = "frozenlist-1.4.1-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:0633c8d5337cb5c77acbccc6357ac49a1770b8c487e5b3505c57b949b4b82e98"},
+    {file = "frozenlist-1.4.1-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:27657df69e8801be6c3638054e202a135c7f299267f1a55ed3a598934f6c0d75"},
+    {file = "frozenlist-1.4.1-cp310-cp310-musllinux_1_1_ppc64le.whl", hash = "sha256:f9a3ea26252bd92f570600098783d1371354d89d5f6b7dfd87359d669f2109b5"},
+    {file = "frozenlist-1.4.1-cp310-cp310-musllinux_1_1_s390x.whl", hash = "sha256:4f57dab5fe3407b6c0c1cc907ac98e8a189f9e418f3b6e54d65a718aaafe3950"},
+    {file = "frozenlist-1.4.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:e02a0e11cf6597299b9f3bbd3f93d79217cb90cfd1411aec33848b13f5c656cc"},
+    {file = "frozenlist-1.4.1-cp310-cp310-win32.whl", hash = "sha256:a828c57f00f729620a442881cc60e57cfcec6842ba38e1b19fd3e47ac0ff8dc1"},
+    {file = "frozenlist-1.4.1-cp310-cp310-win_amd64.whl", hash = "sha256:f56e2333dda1fe0f909e7cc59f021eba0d2307bc6f012a1ccf2beca6ba362439"},
+    {file = "frozenlist-1.4.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:a0cb6f11204443f27a1628b0e460f37fb30f624be6051d490fa7d7e26d4af3d0"},
+    {file = "frozenlist-1.4.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:b46c8ae3a8f1f41a0d2ef350c0b6e65822d80772fe46b653ab6b6274f61d4a49"},
+    {file = "frozenlist-1.4.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:fde5bd59ab5357e3853313127f4d3565fc7dad314a74d7b5d43c22c6a5ed2ced"},
+    {file = "frozenlist-1.4.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:722e1124aec435320ae01ee3ac7bec11a5d47f25d0ed6328f2273d287bc3abb0"},
+    {file = "frozenlist-1.4.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:2471c201b70d58a0f0c1f91261542a03d9a5e088ed3dc6c160d614c01649c106"},
+    {file = "frozenlist-1.4.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c757a9dd70d72b076d6f68efdbb9bc943665ae954dad2801b874c8c69e185068"},
+    {file = "frozenlist-1.4.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f146e0911cb2f1da549fc58fc7bcd2b836a44b79ef871980d605ec392ff6b0d2"},
+    {file = "frozenlist-1.4.1-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4f9c515e7914626b2a2e1e311794b4c35720a0be87af52b79ff8e1429fc25f19"},
+    {file = "frozenlist-1.4.1-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:c302220494f5c1ebeb0912ea782bcd5e2f8308037b3c7553fad0e48ebad6ad82"},
+    {file = "frozenlist-1.4.1-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:442acde1e068288a4ba7acfe05f5f343e19fac87bfc96d89eb886b0363e977ec"},
+    {file = "frozenlist-1.4.1-cp311-cp311-musllinux_1_1_ppc64le.whl", hash = "sha256:1b280e6507ea8a4fa0c0a7150b4e526a8d113989e28eaaef946cc77ffd7efc0a"},
+    {file = "frozenlist-1.4.1-cp311-cp311-musllinux_1_1_s390x.whl", hash = "sha256:fe1a06da377e3a1062ae5fe0926e12b84eceb8a50b350ddca72dc85015873f74"},
+    {file = "frozenlist-1.4.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:db9e724bebd621d9beca794f2a4ff1d26eed5965b004a97f1f1685a173b869c2"},
+    {file = "frozenlist-1.4.1-cp311-cp311-win32.whl", hash = "sha256:e774d53b1a477a67838a904131c4b0eef6b3d8a651f8b138b04f748fccfefe17"},
+    {file = "frozenlist-1.4.1-cp311-cp311-win_amd64.whl", hash = "sha256:fb3c2db03683b5767dedb5769b8a40ebb47d6f7f45b1b3e3b4b51ec8ad9d9825"},
+    {file = "frozenlist-1.4.1-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:1979bc0aeb89b33b588c51c54ab0161791149f2461ea7c7c946d95d5f93b56ae"},
+    {file = "frozenlist-1.4.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:cc7b01b3754ea68a62bd77ce6020afaffb44a590c2289089289363472d13aedb"},
+    {file = "frozenlist-1.4.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:c9c92be9fd329ac801cc420e08452b70e7aeab94ea4233a4804f0915c14eba9b"},
+    {file = "frozenlist-1.4.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5c3894db91f5a489fc8fa6a9991820f368f0b3cbdb9cd8849547ccfab3392d86"},
+    {file = "frozenlist-1.4.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ba60bb19387e13597fb059f32cd4d59445d7b18b69a745b8f8e5db0346f33480"},
+    {file = "frozenlist-1.4.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8aefbba5f69d42246543407ed2461db31006b0f76c4e32dfd6f42215a2c41d09"},
+    {file = "frozenlist-1.4.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:780d3a35680ced9ce682fbcf4cb9c2bad3136eeff760ab33707b71db84664e3a"},
+    {file = "frozenlist-1.4.1-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9acbb16f06fe7f52f441bb6f413ebae6c37baa6ef9edd49cdd567216da8600cd"},
+    {file = "frozenlist-1.4.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:23b701e65c7b36e4bf15546a89279bd4d8675faabc287d06bbcfac7d3c33e1e6"},
+    {file = "frozenlist-1.4.1-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:3e0153a805a98f5ada7e09826255ba99fb4f7524bb81bf6b47fb702666484ae1"},
+    {file = "frozenlist-1.4.1-cp312-cp312-musllinux_1_1_ppc64le.whl", hash = "sha256:dd9b1baec094d91bf36ec729445f7769d0d0cf6b64d04d86e45baf89e2b9059b"},
+    {file = "frozenlist-1.4.1-cp312-cp312-musllinux_1_1_s390x.whl", hash = "sha256:1a4471094e146b6790f61b98616ab8e44f72661879cc63fa1049d13ef711e71e"},
+    {file = "frozenlist-1.4.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:5667ed53d68d91920defdf4035d1cdaa3c3121dc0b113255124bcfada1cfa1b8"},
+    {file = "frozenlist-1.4.1-cp312-cp312-win32.whl", hash = "sha256:beee944ae828747fd7cb216a70f120767fc9f4f00bacae8543c14a6831673f89"},
+    {file = "frozenlist-1.4.1-cp312-cp312-win_amd64.whl", hash = "sha256:64536573d0a2cb6e625cf309984e2d873979709f2cf22839bf2d61790b448ad5"},
+    {file = "frozenlist-1.4.1-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:20b51fa3f588ff2fe658663db52a41a4f7aa6c04f6201449c6c7c476bd255c0d"},
+    {file = "frozenlist-1.4.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:410478a0c562d1a5bcc2f7ea448359fcb050ed48b3c6f6f4f18c313a9bdb1826"},
+    {file = "frozenlist-1.4.1-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:c6321c9efe29975232da3bd0af0ad216800a47e93d763ce64f291917a381b8eb"},
+    {file = "frozenlist-1.4.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:48f6a4533887e189dae092f1cf981f2e3885175f7a0f33c91fb5b7b682b6bab6"},
+    {file = "frozenlist-1.4.1-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6eb73fa5426ea69ee0e012fb59cdc76a15b1283d6e32e4f8dc4482ec67d1194d"},
+    {file = "frozenlist-1.4.1-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:fbeb989b5cc29e8daf7f976b421c220f1b8c731cbf22b9130d8815418ea45887"},
+    {file = "frozenlist-1.4.1-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:32453c1de775c889eb4e22f1197fe3bdfe457d16476ea407472b9442e6295f7a"},
+    {file = "frozenlist-1.4.1-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:693945278a31f2086d9bf3df0fe8254bbeaef1fe71e1351c3bd730aa7d31c41b"},
+    {file = "frozenlist-1.4.1-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:1d0ce09d36d53bbbe566fe296965b23b961764c0bcf3ce2fa45f463745c04701"},
+    {file = "frozenlist-1.4.1-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:3a670dc61eb0d0eb7080890c13de3066790f9049b47b0de04007090807c776b0"},
+    {file = "frozenlist-1.4.1-cp38-cp38-musllinux_1_1_ppc64le.whl", hash = "sha256:dca69045298ce5c11fd539682cff879cc1e664c245d1c64da929813e54241d11"},
+    {file = "frozenlist-1.4.1-cp38-cp38-musllinux_1_1_s390x.whl", hash = "sha256:a06339f38e9ed3a64e4c4e43aec7f59084033647f908e4259d279a52d3757d09"},
+    {file = "frozenlist-1.4.1-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:b7f2f9f912dca3934c1baec2e4585a674ef16fe00218d833856408c48d5beee7"},
+    {file = "frozenlist-1.4.1-cp38-cp38-win32.whl", hash = "sha256:e7004be74cbb7d9f34553a5ce5fb08be14fb33bc86f332fb71cbe5216362a497"},
+    {file = "frozenlist-1.4.1-cp38-cp38-win_amd64.whl", hash = "sha256:5a7d70357e7cee13f470c7883a063aae5fe209a493c57d86eb7f5a6f910fae09"},
+    {file = "frozenlist-1.4.1-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:bfa4a17e17ce9abf47a74ae02f32d014c5e9404b6d9ac7f729e01562bbee601e"},
+    {file = "frozenlist-1.4.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:b7e3ed87d4138356775346e6845cccbe66cd9e207f3cd11d2f0b9fd13681359d"},
+    {file = "frozenlist-1.4.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:c99169d4ff810155ca50b4da3b075cbde79752443117d89429595c2e8e37fed8"},
+    {file = "frozenlist-1.4.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:edb678da49d9f72c9f6c609fbe41a5dfb9a9282f9e6a2253d5a91e0fc382d7c0"},
+    {file = "frozenlist-1.4.1-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6db4667b187a6742b33afbbaf05a7bc551ffcf1ced0000a571aedbb4aa42fc7b"},
+    {file = "frozenlist-1.4.1-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:55fdc093b5a3cb41d420884cdaf37a1e74c3c37a31f46e66286d9145d2063bd0"},
+    {file = "frozenlist-1.4.1-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:82e8211d69a4f4bc360ea22cd6555f8e61a1bd211d1d5d39d3d228b48c83a897"},
+    {file = "frozenlist-1.4.1-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:89aa2c2eeb20957be2d950b85974b30a01a762f3308cd02bb15e1ad632e22dc7"},
+    {file = "frozenlist-1.4.1-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:9d3e0c25a2350080e9319724dede4f31f43a6c9779be48021a7f4ebde8b2d742"},
+    {file = "frozenlist-1.4.1-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:7268252af60904bf52c26173cbadc3a071cece75f873705419c8681f24d3edea"},
+    {file = "frozenlist-1.4.1-cp39-cp39-musllinux_1_1_ppc64le.whl", hash = "sha256:0c250a29735d4f15321007fb02865f0e6b6a41a6b88f1f523ca1596ab5f50bd5"},
+    {file = "frozenlist-1.4.1-cp39-cp39-musllinux_1_1_s390x.whl", hash = "sha256:96ec70beabbd3b10e8bfe52616a13561e58fe84c0101dd031dc78f250d5128b9"},
+    {file = "frozenlist-1.4.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:23b2d7679b73fe0e5a4560b672a39f98dfc6f60df63823b0a9970525325b95f6"},
+    {file = "frozenlist-1.4.1-cp39-cp39-win32.whl", hash = "sha256:a7496bfe1da7fb1a4e1cc23bb67c58fab69311cc7d32b5a99c2007b4b2a0e932"},
+    {file = "frozenlist-1.4.1-cp39-cp39-win_amd64.whl", hash = "sha256:e6a20a581f9ce92d389a8c7d7c3dd47c81fd5d6e655c8dddf341e14aa48659d0"},
+    {file = "frozenlist-1.4.1-py3-none-any.whl", hash = "sha256:04ced3e6a46b4cfffe20f9ae482818e34eba9b5fb0ce4056e4cc9b6e212d09b7"},
+    {file = "frozenlist-1.4.1.tar.gz", hash = "sha256:c037a86e8513059a2613aaba4d817bb90b9d9b6b69aace3ce9c877e8c8ed402b"},
+]
+
 [[package]]
 name = "http-ece"
 version = "1.1.0"
@@ -587,6 +816,105 @@ files = [
     {file = "MarkupSafe-2.1.3.tar.gz", hash = "sha256:af598ed32d6ae86f1b747b82783958b1a4ab8f617b06fe68795c7f026abbdcad"},
 ]
 
+[[package]]
+name = "multidict"
+version = "6.0.5"
+description = "multidict implementation"
+optional = false
+python-versions = ">=3.7"
+files = [
+    {file = "multidict-6.0.5-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:228b644ae063c10e7f324ab1ab6b548bdf6f8b47f3ec234fef1093bc2735e5f9"},
+    {file = "multidict-6.0.5-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:896ebdcf62683551312c30e20614305f53125750803b614e9e6ce74a96232604"},
+    {file = "multidict-6.0.5-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:411bf8515f3be9813d06004cac41ccf7d1cd46dfe233705933dd163b60e37600"},
+    {file = "multidict-6.0.5-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1d147090048129ce3c453f0292e7697d333db95e52616b3793922945804a433c"},
+    {file = "multidict-6.0.5-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:215ed703caf15f578dca76ee6f6b21b7603791ae090fbf1ef9d865571039ade5"},
+    {file = "multidict-6.0.5-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7c6390cf87ff6234643428991b7359b5f59cc15155695deb4eda5c777d2b880f"},
+    {file = "multidict-6.0.5-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:21fd81c4ebdb4f214161be351eb5bcf385426bf023041da2fd9e60681f3cebae"},
+    {file = "multidict-6.0.5-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3cc2ad10255f903656017363cd59436f2111443a76f996584d1077e43ee51182"},
+    {file = "multidict-6.0.5-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:6939c95381e003f54cd4c5516740faba40cf5ad3eeff460c3ad1d3e0ea2549bf"},
+    {file = "multidict-6.0.5-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:220dd781e3f7af2c2c1053da9fa96d9cf3072ca58f057f4c5adaaa1cab8fc442"},
+    {file = "multidict-6.0.5-cp310-cp310-musllinux_1_1_ppc64le.whl", hash = "sha256:766c8f7511df26d9f11cd3a8be623e59cca73d44643abab3f8c8c07620524e4a"},
+    {file = "multidict-6.0.5-cp310-cp310-musllinux_1_1_s390x.whl", hash = "sha256:fe5d7785250541f7f5019ab9cba2c71169dc7d74d0f45253f8313f436458a4ef"},
+    {file = "multidict-6.0.5-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:c1c1496e73051918fcd4f58ff2e0f2f3066d1c76a0c6aeffd9b45d53243702cc"},
+    {file = "multidict-6.0.5-cp310-cp310-win32.whl", hash = "sha256:7afcdd1fc07befad18ec4523a782cde4e93e0a2bf71239894b8d61ee578c1319"},
+    {file = "multidict-6.0.5-cp310-cp310-win_amd64.whl", hash = "sha256:99f60d34c048c5c2fabc766108c103612344c46e35d4ed9ae0673d33c8fb26e8"},
+    {file = "multidict-6.0.5-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:f285e862d2f153a70586579c15c44656f888806ed0e5b56b64489afe4a2dbfba"},
+    {file = "multidict-6.0.5-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:53689bb4e102200a4fafa9de9c7c3c212ab40a7ab2c8e474491914d2305f187e"},
+    {file = "multidict-6.0.5-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:612d1156111ae11d14afaf3a0669ebf6c170dbb735e510a7438ffe2369a847fd"},
+    {file = "multidict-6.0.5-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7be7047bd08accdb7487737631d25735c9a04327911de89ff1b26b81745bd4e3"},
+    {file = "multidict-6.0.5-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:de170c7b4fe6859beb8926e84f7d7d6c693dfe8e27372ce3b76f01c46e489fcf"},
+    {file = "multidict-6.0.5-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:04bde7a7b3de05732a4eb39c94574db1ec99abb56162d6c520ad26f83267de29"},
+    {file = "multidict-6.0.5-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:85f67aed7bb647f93e7520633d8f51d3cbc6ab96957c71272b286b2f30dc70ed"},
+    {file = "multidict-6.0.5-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:425bf820055005bfc8aa9a0b99ccb52cc2f4070153e34b701acc98d201693733"},
+    {file = "multidict-6.0.5-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:d3eb1ceec286eba8220c26f3b0096cf189aea7057b6e7b7a2e60ed36b373b77f"},
+    {file = "multidict-6.0.5-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:7901c05ead4b3fb75113fb1dd33eb1253c6d3ee37ce93305acd9d38e0b5f21a4"},
+    {file = "multidict-6.0.5-cp311-cp311-musllinux_1_1_ppc64le.whl", hash = "sha256:e0e79d91e71b9867c73323a3444724d496c037e578a0e1755ae159ba14f4f3d1"},
+    {file = "multidict-6.0.5-cp311-cp311-musllinux_1_1_s390x.whl", hash = "sha256:29bfeb0dff5cb5fdab2023a7a9947b3b4af63e9c47cae2a10ad58394b517fddc"},
+    {file = "multidict-6.0.5-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:e030047e85cbcedbfc073f71836d62dd5dadfbe7531cae27789ff66bc551bd5e"},
+    {file = "multidict-6.0.5-cp311-cp311-win32.whl", hash = "sha256:2f4848aa3baa109e6ab81fe2006c77ed4d3cd1e0ac2c1fbddb7b1277c168788c"},
+    {file = "multidict-6.0.5-cp311-cp311-win_amd64.whl", hash = "sha256:2faa5ae9376faba05f630d7e5e6be05be22913782b927b19d12b8145968a85ea"},
+    {file = "multidict-6.0.5-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:51d035609b86722963404f711db441cf7134f1889107fb171a970c9701f92e1e"},
+    {file = "multidict-6.0.5-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:cbebcd5bcaf1eaf302617c114aa67569dd3f090dd0ce8ba9e35e9985b41ac35b"},
+    {file = "multidict-6.0.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:2ffc42c922dbfddb4a4c3b438eb056828719f07608af27d163191cb3e3aa6cc5"},
+    {file = "multidict-6.0.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ceb3b7e6a0135e092de86110c5a74e46bda4bd4fbfeeb3a3bcec79c0f861e450"},
+    {file = "multidict-6.0.5-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:79660376075cfd4b2c80f295528aa6beb2058fd289f4c9252f986751a4cd0496"},
+    {file = "multidict-6.0.5-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e4428b29611e989719874670fd152b6625500ad6c686d464e99f5aaeeaca175a"},
+    {file = "multidict-6.0.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d84a5c3a5f7ce6db1f999fb9438f686bc2e09d38143f2d93d8406ed2dd6b9226"},
+    {file = "multidict-6.0.5-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:76c0de87358b192de7ea9649beb392f107dcad9ad27276324c24c91774ca5271"},
+    {file = "multidict-6.0.5-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:79a6d2ba910adb2cbafc95dad936f8b9386e77c84c35bc0add315b856d7c3abb"},
+    {file = "multidict-6.0.5-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:92d16a3e275e38293623ebf639c471d3e03bb20b8ebb845237e0d3664914caef"},
+    {file = "multidict-6.0.5-cp312-cp312-musllinux_1_1_ppc64le.whl", hash = "sha256:fb616be3538599e797a2017cccca78e354c767165e8858ab5116813146041a24"},
+    {file = "multidict-6.0.5-cp312-cp312-musllinux_1_1_s390x.whl", hash = "sha256:14c2976aa9038c2629efa2c148022ed5eb4cb939e15ec7aace7ca932f48f9ba6"},
+    {file = "multidict-6.0.5-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:435a0984199d81ca178b9ae2c26ec3d49692d20ee29bc4c11a2a8d4514c67eda"},
+    {file = "multidict-6.0.5-cp312-cp312-win32.whl", hash = "sha256:9fe7b0653ba3d9d65cbe7698cca585bf0f8c83dbbcc710db9c90f478e175f2d5"},
+    {file = "multidict-6.0.5-cp312-cp312-win_amd64.whl", hash = "sha256:01265f5e40f5a17f8241d52656ed27192be03bfa8764d88e8220141d1e4b3556"},
+    {file = "multidict-6.0.5-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:19fe01cea168585ba0f678cad6f58133db2aa14eccaf22f88e4a6dccadfad8b3"},
+    {file = "multidict-6.0.5-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6bf7a982604375a8d49b6cc1b781c1747f243d91b81035a9b43a2126c04766f5"},
+    {file = "multidict-6.0.5-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:107c0cdefe028703fb5dafe640a409cb146d44a6ae201e55b35a4af8e95457dd"},
+    {file = "multidict-6.0.5-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:403c0911cd5d5791605808b942c88a8155c2592e05332d2bf78f18697a5fa15e"},
+    {file = "multidict-6.0.5-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:aeaf541ddbad8311a87dd695ed9642401131ea39ad7bc8cf3ef3967fd093b626"},
+    {file = "multidict-6.0.5-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e4972624066095e52b569e02b5ca97dbd7a7ddd4294bf4e7247d52635630dd83"},
+    {file = "multidict-6.0.5-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:d946b0a9eb8aaa590df1fe082cee553ceab173e6cb5b03239716338629c50c7a"},
+    {file = "multidict-6.0.5-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:b55358304d7a73d7bdf5de62494aaf70bd33015831ffd98bc498b433dfe5b10c"},
+    {file = "multidict-6.0.5-cp37-cp37m-musllinux_1_1_ppc64le.whl", hash = "sha256:a3145cb08d8625b2d3fee1b2d596a8766352979c9bffe5d7833e0503d0f0b5e5"},
+    {file = "multidict-6.0.5-cp37-cp37m-musllinux_1_1_s390x.whl", hash = "sha256:d65f25da8e248202bd47445cec78e0025c0fe7582b23ec69c3b27a640dd7a8e3"},
+    {file = "multidict-6.0.5-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:c9bf56195c6bbd293340ea82eafd0071cb3d450c703d2c93afb89f93b8386ccc"},
+    {file = "multidict-6.0.5-cp37-cp37m-win32.whl", hash = "sha256:69db76c09796b313331bb7048229e3bee7928eb62bab5e071e9f7fcc4879caee"},
+    {file = "multidict-6.0.5-cp37-cp37m-win_amd64.whl", hash = "sha256:fce28b3c8a81b6b36dfac9feb1de115bab619b3c13905b419ec71d03a3fc1423"},
+    {file = "multidict-6.0.5-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:76f067f5121dcecf0d63a67f29080b26c43c71a98b10c701b0677e4a065fbd54"},
+    {file = "multidict-6.0.5-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:b82cc8ace10ab5bd93235dfaab2021c70637005e1ac787031f4d1da63d493c1d"},
+    {file = "multidict-6.0.5-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:5cb241881eefd96b46f89b1a056187ea8e9ba14ab88ba632e68d7a2ecb7aadf7"},
+    {file = "multidict-6.0.5-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e8e94e6912639a02ce173341ff62cc1201232ab86b8a8fcc05572741a5dc7d93"},
+    {file = "multidict-6.0.5-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:09a892e4a9fb47331da06948690ae38eaa2426de97b4ccbfafbdcbe5c8f37ff8"},
+    {file = "multidict-6.0.5-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:55205d03e8a598cfc688c71ca8ea5f66447164efff8869517f175ea632c7cb7b"},
+    {file = "multidict-6.0.5-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:37b15024f864916b4951adb95d3a80c9431299080341ab9544ed148091b53f50"},
+    {file = "multidict-6.0.5-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f2a1dee728b52b33eebff5072817176c172050d44d67befd681609b4746e1c2e"},
+    {file = "multidict-6.0.5-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:edd08e6f2f1a390bf137080507e44ccc086353c8e98c657e666c017718561b89"},
+    {file = "multidict-6.0.5-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:60d698e8179a42ec85172d12f50b1668254628425a6bd611aba022257cac1386"},
+    {file = "multidict-6.0.5-cp38-cp38-musllinux_1_1_ppc64le.whl", hash = "sha256:3d25f19500588cbc47dc19081d78131c32637c25804df8414463ec908631e453"},
+    {file = "multidict-6.0.5-cp38-cp38-musllinux_1_1_s390x.whl", hash = "sha256:4cc0ef8b962ac7a5e62b9e826bd0cd5040e7d401bc45a6835910ed699037a461"},
+    {file = "multidict-6.0.5-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:eca2e9d0cc5a889850e9bbd68e98314ada174ff6ccd1129500103df7a94a7a44"},
+    {file = "multidict-6.0.5-cp38-cp38-win32.whl", hash = "sha256:4a6a4f196f08c58c59e0b8ef8ec441d12aee4125a7d4f4fef000ccb22f8d7241"},
+    {file = "multidict-6.0.5-cp38-cp38-win_amd64.whl", hash = "sha256:0275e35209c27a3f7951e1ce7aaf93ce0d163b28948444bec61dd7badc6d3f8c"},
+    {file = "multidict-6.0.5-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:e7be68734bd8c9a513f2b0cfd508802d6609da068f40dc57d4e3494cefc92929"},
+    {file = "multidict-6.0.5-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:1d9ea7a7e779d7a3561aade7d596649fbecfa5c08a7674b11b423783217933f9"},
+    {file = "multidict-6.0.5-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:ea1456df2a27c73ce51120fa2f519f1bea2f4a03a917f4a43c8707cf4cbbae1a"},
+    {file = "multidict-6.0.5-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cf590b134eb70629e350691ecca88eac3e3b8b3c86992042fb82e3cb1830d5e1"},
+    {file = "multidict-6.0.5-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5c0631926c4f58e9a5ccce555ad7747d9a9f8b10619621f22f9635f069f6233e"},
+    {file = "multidict-6.0.5-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:dce1c6912ab9ff5f179eaf6efe7365c1f425ed690b03341911bf4939ef2f3046"},
+    {file = "multidict-6.0.5-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c0868d64af83169e4d4152ec612637a543f7a336e4a307b119e98042e852ad9c"},
+    {file = "multidict-6.0.5-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:141b43360bfd3bdd75f15ed811850763555a251e38b2405967f8e25fb43f7d40"},
+    {file = "multidict-6.0.5-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:7df704ca8cf4a073334e0427ae2345323613e4df18cc224f647f251e5e75a527"},
+    {file = "multidict-6.0.5-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:6214c5a5571802c33f80e6c84713b2c79e024995b9c5897f794b43e714daeec9"},
+    {file = "multidict-6.0.5-cp39-cp39-musllinux_1_1_ppc64le.whl", hash = "sha256:cd6c8fca38178e12c00418de737aef1261576bd1b6e8c6134d3e729a4e858b38"},
+    {file = "multidict-6.0.5-cp39-cp39-musllinux_1_1_s390x.whl", hash = "sha256:e02021f87a5b6932fa6ce916ca004c4d441509d33bbdbeca70d05dff5e9d2479"},
+    {file = "multidict-6.0.5-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:ebd8d160f91a764652d3e51ce0d2956b38efe37c9231cd82cfc0bed2e40b581c"},
+    {file = "multidict-6.0.5-cp39-cp39-win32.whl", hash = "sha256:04da1bb8c8dbadf2a18a452639771951c662c5ad03aefe4884775454be322c9b"},
+    {file = "multidict-6.0.5-cp39-cp39-win_amd64.whl", hash = "sha256:d6f6d4f185481c9669b9447bf9d9cf3b95a0e9df9d169bbc17e363b7d5487755"},
+    {file = "multidict-6.0.5-py3-none-any.whl", hash = "sha256:0d63c74e3d7ab26de115c49bffc92cc77ed23395303d496eae515d4204a625e7"},
+    {file = "multidict-6.0.5.tar.gz", hash = "sha256:f7e301075edaf50500f0b341543c41194d8df3ae5caf4702f2095f3ca73dd8da"},
+]
+
 [[package]]
 name = "mypy-protobuf"
 version = "3.5.0"
@@ -816,6 +1144,20 @@ pytest = ">=5.0"
 [package.extras]
 dev = ["pre-commit", "pytest-asyncio", "tox"]
 
+[[package]]
+name = "pytest-socket"
+version = "0.7.0"
+description = "Pytest Plugin to disable socket calls during tests"
+optional = false
+python-versions = ">=3.8,<4.0"
+files = [
+    {file = "pytest_socket-0.7.0-py3-none-any.whl", hash = "sha256:7e0f4642177d55d317bbd58fc68c6bd9048d6eadb2d46a89307fa9221336ce45"},
+    {file = "pytest_socket-0.7.0.tar.gz", hash = "sha256:71ab048cbbcb085c15a4423b73b619a8b35d6a307f46f78ea46be51b1b7e11b3"},
+]
+
+[package.dependencies]
+pytest = ">=6.2.5"
+
 [[package]]
 name = "pytz"
 version = "2023.3.post1"
@@ -890,7 +1232,7 @@ files = [
 name = "requests"
 version = "2.31.0"
 description = "Python HTTP for Humans."
-optional = false
+optional = true
 python-versions = ">=3.7"
 files = [
     {file = "requests-2.31.0-py3-none-any.whl", hash = "sha256:58cd2187c01e70e6e26505bca751777aa9f2ee0b7f4300988b709f44e013003f"},
@@ -907,25 +1249,6 @@ urllib3 = ">=1.21.1,<3"
 socks = ["PySocks (>=1.5.6,!=1.5.7)"]
 use-chardet-on-py3 = ["chardet (>=3.0.2,<6)"]
 
-[[package]]
-name = "requests-mock"
-version = "1.11.0"
-description = "Mock out responses from the requests package"
-optional = false
-python-versions = "*"
-files = [
-    {file = "requests-mock-1.11.0.tar.gz", hash = "sha256:ef10b572b489a5f28e09b708697208c4a3b2b89ef80a9f01584340ea357ec3c4"},
-    {file = "requests_mock-1.11.0-py2.py3-none-any.whl", hash = "sha256:f7fae383f228633f6bececebdab236c478ace2284d6292c6e7e2867b9ab74d15"},
-]
-
-[package.dependencies]
-requests = ">=2.3,<3"
-six = "*"
-
-[package.extras]
-fixture = ["fixtures"]
-test = ["fixtures", "mock", "purl", "pytest", "requests-futures", "sphinx", "testtools"]
-
 [[package]]
 name = "setuptools"
 version = "68.2.2"
@@ -942,17 +1265,6 @@ docs = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "pygments
 testing = ["build[virtualenv]", "filelock (>=3.4.0)", "flake8-2020", "ini2toml[lite] (>=0.9)", "jaraco.develop (>=7.21)", "jaraco.envs (>=2.2)", "jaraco.path (>=3.2.0)", "pip (>=19.1)", "pytest (>=6)", "pytest-black (>=0.3.7)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=2.2)", "pytest-mypy (>=0.9.1)", "pytest-perf", "pytest-ruff", "pytest-timeout", "pytest-xdist", "tomli-w (>=1.0.0)", "virtualenv (>=13.0.0)", "wheel"]
 testing-integration = ["build[virtualenv] (>=1.0.3)", "filelock (>=3.4.0)", "jaraco.envs (>=2.2)", "jaraco.path (>=3.2.0)", "packaging (>=23.1)", "pytest", "pytest-enabler", "pytest-xdist", "tomli", "virtualenv (>=13.0.0)", "wheel"]
 
-[[package]]
-name = "six"
-version = "1.16.0"
-description = "Python 2 and 3 compatibility utilities"
-optional = false
-python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*"
-files = [
-    {file = "six-1.16.0-py2.py3-none-any.whl", hash = "sha256:8abb2f1d86890a2dfb989f9a77cfcfd3e47c2a354b01111771326f8aa26e0254"},
-    {file = "six-1.16.0.tar.gz", hash = "sha256:1e61c37477a1626458e36f7b1d82aa5c9b094fa4802892072e49de9c60c4c926"},
-]
-
 [[package]]
 name = "snowballstemmer"
 version = "2.2.0"
@@ -1193,7 +1505,7 @@ files = [
 name = "urllib3"
 version = "2.0.7"
 description = "HTTP library with thread-safe connection pooling, file post, and more."
-optional = false
+optional = true
 python-versions = ">=3.7"
 files = [
     {file = "urllib3-2.0.7-py3-none-any.whl", hash = "sha256:fdb6d215c776278489906c2f8916e6e7d4f5a9b602ccbcfdf7f016fc8da0596e"},
@@ -1226,6 +1538,109 @@ platformdirs = ">=3.9.1,<4"
 docs = ["furo (>=2023.7.26)", "proselint (>=0.13)", "sphinx (>=7.1.2)", "sphinx-argparse (>=0.4)", "sphinxcontrib-towncrier (>=0.2.1a0)", "towncrier (>=23.6)"]
 test = ["covdefaults (>=2.3)", "coverage (>=7.2.7)", "coverage-enable-subprocess (>=1)", "flaky (>=3.7)", "packaging (>=23.1)", "pytest (>=7.4)", "pytest-env (>=0.8.2)", "pytest-freezer (>=0.4.8)", "pytest-mock (>=3.11.1)", "pytest-randomly (>=3.12)", "pytest-timeout (>=2.1)", "setuptools (>=68)", "time-machine (>=2.10)"]
 
+[[package]]
+name = "yarl"
+version = "1.9.4"
+description = "Yet another URL library"
+optional = false
+python-versions = ">=3.7"
+files = [
+    {file = "yarl-1.9.4-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:a8c1df72eb746f4136fe9a2e72b0c9dc1da1cbd23b5372f94b5820ff8ae30e0e"},
+    {file = "yarl-1.9.4-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:a3a6ed1d525bfb91b3fc9b690c5a21bb52de28c018530ad85093cc488bee2dd2"},
+    {file = "yarl-1.9.4-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:c38c9ddb6103ceae4e4498f9c08fac9b590c5c71b0370f98714768e22ac6fa66"},
+    {file = "yarl-1.9.4-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d9e09c9d74f4566e905a0b8fa668c58109f7624db96a2171f21747abc7524234"},
+    {file = "yarl-1.9.4-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b8477c1ee4bd47c57d49621a062121c3023609f7a13b8a46953eb6c9716ca392"},
+    {file = "yarl-1.9.4-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d5ff2c858f5f6a42c2a8e751100f237c5e869cbde669a724f2062d4c4ef93551"},
+    {file = "yarl-1.9.4-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:357495293086c5b6d34ca9616a43d329317feab7917518bc97a08f9e55648455"},
+    {file = "yarl-1.9.4-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:54525ae423d7b7a8ee81ba189f131054defdb122cde31ff17477951464c1691c"},
+    {file = "yarl-1.9.4-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:801e9264d19643548651b9db361ce3287176671fb0117f96b5ac0ee1c3530d53"},
+    {file = "yarl-1.9.4-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:e516dc8baf7b380e6c1c26792610230f37147bb754d6426462ab115a02944385"},
+    {file = "yarl-1.9.4-cp310-cp310-musllinux_1_1_ppc64le.whl", hash = "sha256:7d5aaac37d19b2904bb9dfe12cdb08c8443e7ba7d2852894ad448d4b8f442863"},
+    {file = "yarl-1.9.4-cp310-cp310-musllinux_1_1_s390x.whl", hash = "sha256:54beabb809ffcacbd9d28ac57b0db46e42a6e341a030293fb3185c409e626b8b"},
+    {file = "yarl-1.9.4-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:bac8d525a8dbc2a1507ec731d2867025d11ceadcb4dd421423a5d42c56818541"},
+    {file = "yarl-1.9.4-cp310-cp310-win32.whl", hash = "sha256:7855426dfbddac81896b6e533ebefc0af2f132d4a47340cee6d22cac7190022d"},
+    {file = "yarl-1.9.4-cp310-cp310-win_amd64.whl", hash = "sha256:848cd2a1df56ddbffeb375535fb62c9d1645dde33ca4d51341378b3f5954429b"},
+    {file = "yarl-1.9.4-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:35a2b9396879ce32754bd457d31a51ff0a9d426fd9e0e3c33394bf4b9036b099"},
+    {file = "yarl-1.9.4-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:4c7d56b293cc071e82532f70adcbd8b61909eec973ae9d2d1f9b233f3d943f2c"},
+    {file = "yarl-1.9.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:d8a1c6c0be645c745a081c192e747c5de06e944a0d21245f4cf7c05e457c36e0"},
+    {file = "yarl-1.9.4-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4b3c1ffe10069f655ea2d731808e76e0f452fc6c749bea04781daf18e6039525"},
+    {file = "yarl-1.9.4-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:549d19c84c55d11687ddbd47eeb348a89df9cb30e1993f1b128f4685cd0ebbf8"},
+    {file = "yarl-1.9.4-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a7409f968456111140c1c95301cadf071bd30a81cbd7ab829169fb9e3d72eae9"},
+    {file = "yarl-1.9.4-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e23a6d84d9d1738dbc6e38167776107e63307dfc8ad108e580548d1f2c587f42"},
+    {file = "yarl-1.9.4-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d8b889777de69897406c9fb0b76cdf2fd0f31267861ae7501d93003d55f54fbe"},
+    {file = "yarl-1.9.4-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:03caa9507d3d3c83bca08650678e25364e1843b484f19986a527630ca376ecce"},
+    {file = "yarl-1.9.4-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:4e9035df8d0880b2f1c7f5031f33f69e071dfe72ee9310cfc76f7b605958ceb9"},
+    {file = "yarl-1.9.4-cp311-cp311-musllinux_1_1_ppc64le.whl", hash = "sha256:c0ec0ed476f77db9fb29bca17f0a8fcc7bc97ad4c6c1d8959c507decb22e8572"},
+    {file = "yarl-1.9.4-cp311-cp311-musllinux_1_1_s390x.whl", hash = "sha256:ee04010f26d5102399bd17f8df8bc38dc7ccd7701dc77f4a68c5b8d733406958"},
+    {file = "yarl-1.9.4-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:49a180c2e0743d5d6e0b4d1a9e5f633c62eca3f8a86ba5dd3c471060e352ca98"},
+    {file = "yarl-1.9.4-cp311-cp311-win32.whl", hash = "sha256:81eb57278deb6098a5b62e88ad8281b2ba09f2f1147c4767522353eaa6260b31"},
+    {file = "yarl-1.9.4-cp311-cp311-win_amd64.whl", hash = "sha256:d1d2532b340b692880261c15aee4dc94dd22ca5d61b9db9a8a361953d36410b1"},
+    {file = "yarl-1.9.4-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:0d2454f0aef65ea81037759be5ca9947539667eecebca092733b2eb43c965a81"},
+    {file = "yarl-1.9.4-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:44d8ffbb9c06e5a7f529f38f53eda23e50d1ed33c6c869e01481d3fafa6b8142"},
+    {file = "yarl-1.9.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:aaaea1e536f98754a6e5c56091baa1b6ce2f2700cc4a00b0d49eca8dea471074"},
+    {file = "yarl-1.9.4-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3777ce5536d17989c91696db1d459574e9a9bd37660ea7ee4d3344579bb6f129"},
+    {file = "yarl-1.9.4-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9fc5fc1eeb029757349ad26bbc5880557389a03fa6ada41703db5e068881e5f2"},
+    {file = "yarl-1.9.4-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ea65804b5dc88dacd4a40279af0cdadcfe74b3e5b4c897aa0d81cf86927fee78"},
+    {file = "yarl-1.9.4-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:aa102d6d280a5455ad6a0f9e6d769989638718e938a6a0a2ff3f4a7ff8c62cc4"},
+    {file = "yarl-1.9.4-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:09efe4615ada057ba2d30df871d2f668af661e971dfeedf0c159927d48bbeff0"},
+    {file = "yarl-1.9.4-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:008d3e808d03ef28542372d01057fd09168419cdc8f848efe2804f894ae03e51"},
+    {file = "yarl-1.9.4-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:6f5cb257bc2ec58f437da2b37a8cd48f666db96d47b8a3115c29f316313654ff"},
+    {file = "yarl-1.9.4-cp312-cp312-musllinux_1_1_ppc64le.whl", hash = "sha256:992f18e0ea248ee03b5a6e8b3b4738850ae7dbb172cc41c966462801cbf62cf7"},
+    {file = "yarl-1.9.4-cp312-cp312-musllinux_1_1_s390x.whl", hash = "sha256:0e9d124c191d5b881060a9e5060627694c3bdd1fe24c5eecc8d5d7d0eb6faabc"},
+    {file = "yarl-1.9.4-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:3986b6f41ad22988e53d5778f91855dc0399b043fc8946d4f2e68af22ee9ff10"},
+    {file = "yarl-1.9.4-cp312-cp312-win32.whl", hash = "sha256:4b21516d181cd77ebd06ce160ef8cc2a5e9ad35fb1c5930882baff5ac865eee7"},
+    {file = "yarl-1.9.4-cp312-cp312-win_amd64.whl", hash = "sha256:a9bd00dc3bc395a662900f33f74feb3e757429e545d831eef5bb280252631984"},
+    {file = "yarl-1.9.4-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:63b20738b5aac74e239622d2fe30df4fca4942a86e31bf47a81a0e94c14df94f"},
+    {file = "yarl-1.9.4-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d7d7f7de27b8944f1fee2c26a88b4dabc2409d2fea7a9ed3df79b67277644e17"},
+    {file = "yarl-1.9.4-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c74018551e31269d56fab81a728f683667e7c28c04e807ba08f8c9e3bba32f14"},
+    {file = "yarl-1.9.4-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ca06675212f94e7a610e85ca36948bb8fc023e458dd6c63ef71abfd482481aa5"},
+    {file = "yarl-1.9.4-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5aef935237d60a51a62b86249839b51345f47564208c6ee615ed2a40878dccdd"},
+    {file = "yarl-1.9.4-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:2b134fd795e2322b7684155b7855cc99409d10b2e408056db2b93b51a52accc7"},
+    {file = "yarl-1.9.4-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:d25039a474c4c72a5ad4b52495056f843a7ff07b632c1b92ea9043a3d9950f6e"},
+    {file = "yarl-1.9.4-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:f7d6b36dd2e029b6bcb8a13cf19664c7b8e19ab3a58e0fefbb5b8461447ed5ec"},
+    {file = "yarl-1.9.4-cp37-cp37m-musllinux_1_1_ppc64le.whl", hash = "sha256:957b4774373cf6f709359e5c8c4a0af9f6d7875db657adb0feaf8d6cb3c3964c"},
+    {file = "yarl-1.9.4-cp37-cp37m-musllinux_1_1_s390x.whl", hash = "sha256:d7eeb6d22331e2fd42fce928a81c697c9ee2d51400bd1a28803965883e13cead"},
+    {file = "yarl-1.9.4-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:6a962e04b8f91f8c4e5917e518d17958e3bdee71fd1d8b88cdce74dd0ebbf434"},
+    {file = "yarl-1.9.4-cp37-cp37m-win32.whl", hash = "sha256:f3bc6af6e2b8f92eced34ef6a96ffb248e863af20ef4fde9448cc8c9b858b749"},
+    {file = "yarl-1.9.4-cp37-cp37m-win_amd64.whl", hash = "sha256:ad4d7a90a92e528aadf4965d685c17dacff3df282db1121136c382dc0b6014d2"},
+    {file = "yarl-1.9.4-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:ec61d826d80fc293ed46c9dd26995921e3a82146feacd952ef0757236fc137be"},
+    {file = "yarl-1.9.4-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:8be9e837ea9113676e5754b43b940b50cce76d9ed7d2461df1af39a8ee674d9f"},
+    {file = "yarl-1.9.4-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:bef596fdaa8f26e3d66af846bbe77057237cb6e8efff8cd7cc8dff9a62278bbf"},
+    {file = "yarl-1.9.4-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2d47552b6e52c3319fede1b60b3de120fe83bde9b7bddad11a69fb0af7db32f1"},
+    {file = "yarl-1.9.4-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:84fc30f71689d7fc9168b92788abc977dc8cefa806909565fc2951d02f6b7d57"},
+    {file = "yarl-1.9.4-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4aa9741085f635934f3a2583e16fcf62ba835719a8b2b28fb2917bb0537c1dfa"},
+    {file = "yarl-1.9.4-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:206a55215e6d05dbc6c98ce598a59e6fbd0c493e2de4ea6cc2f4934d5a18d130"},
+    {file = "yarl-1.9.4-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:07574b007ee20e5c375a8fe4a0789fad26db905f9813be0f9fef5a68080de559"},
+    {file = "yarl-1.9.4-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:5a2e2433eb9344a163aced6a5f6c9222c0786e5a9e9cac2c89f0b28433f56e23"},
+    {file = "yarl-1.9.4-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:6ad6d10ed9b67a382b45f29ea028f92d25bc0bc1daf6c5b801b90b5aa70fb9ec"},
+    {file = "yarl-1.9.4-cp38-cp38-musllinux_1_1_ppc64le.whl", hash = "sha256:6fe79f998a4052d79e1c30eeb7d6c1c1056ad33300f682465e1b4e9b5a188b78"},
+    {file = "yarl-1.9.4-cp38-cp38-musllinux_1_1_s390x.whl", hash = "sha256:a825ec844298c791fd28ed14ed1bffc56a98d15b8c58a20e0e08c1f5f2bea1be"},
+    {file = "yarl-1.9.4-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:8619d6915b3b0b34420cf9b2bb6d81ef59d984cb0fde7544e9ece32b4b3043c3"},
+    {file = "yarl-1.9.4-cp38-cp38-win32.whl", hash = "sha256:686a0c2f85f83463272ddffd4deb5e591c98aac1897d65e92319f729c320eece"},
+    {file = "yarl-1.9.4-cp38-cp38-win_amd64.whl", hash = "sha256:a00862fb23195b6b8322f7d781b0dc1d82cb3bcac346d1e38689370cc1cc398b"},
+    {file = "yarl-1.9.4-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:604f31d97fa493083ea21bd9b92c419012531c4e17ea6da0f65cacdcf5d0bd27"},
+    {file = "yarl-1.9.4-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:8a854227cf581330ffa2c4824d96e52ee621dd571078a252c25e3a3b3d94a1b1"},
+    {file = "yarl-1.9.4-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:ba6f52cbc7809cd8d74604cce9c14868306ae4aa0282016b641c661f981a6e91"},
+    {file = "yarl-1.9.4-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a6327976c7c2f4ee6816eff196e25385ccc02cb81427952414a64811037bbc8b"},
+    {file = "yarl-1.9.4-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8397a3817d7dcdd14bb266283cd1d6fc7264a48c186b986f32e86d86d35fbac5"},
+    {file = "yarl-1.9.4-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e0381b4ce23ff92f8170080c97678040fc5b08da85e9e292292aba67fdac6c34"},
+    {file = "yarl-1.9.4-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:23d32a2594cb5d565d358a92e151315d1b2268bc10f4610d098f96b147370136"},
+    {file = "yarl-1.9.4-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ddb2a5c08a4eaaba605340fdee8fc08e406c56617566d9643ad8bf6852778fc7"},
+    {file = "yarl-1.9.4-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:26a1dc6285e03f3cc9e839a2da83bcbf31dcb0d004c72d0730e755b33466c30e"},
+    {file = "yarl-1.9.4-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:18580f672e44ce1238b82f7fb87d727c4a131f3a9d33a5e0e82b793362bf18b4"},
+    {file = "yarl-1.9.4-cp39-cp39-musllinux_1_1_ppc64le.whl", hash = "sha256:29e0f83f37610f173eb7e7b5562dd71467993495e568e708d99e9d1944f561ec"},
+    {file = "yarl-1.9.4-cp39-cp39-musllinux_1_1_s390x.whl", hash = "sha256:1f23e4fe1e8794f74b6027d7cf19dc25f8b63af1483d91d595d4a07eca1fb26c"},
+    {file = "yarl-1.9.4-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:db8e58b9d79200c76956cefd14d5c90af54416ff5353c5bfd7cbe58818e26ef0"},
+    {file = "yarl-1.9.4-cp39-cp39-win32.whl", hash = "sha256:c7224cab95645c7ab53791022ae77a4509472613e839dab722a72abe5a684575"},
+    {file = "yarl-1.9.4-cp39-cp39-win_amd64.whl", hash = "sha256:824d6c50492add5da9374875ce72db7a0733b29c2394890aef23d533106e2b15"},
+    {file = "yarl-1.9.4-py3-none-any.whl", hash = "sha256:928cecb0ef9d5a7946eb6ff58417ad2fe9375762382f1bf5c55e61645f2c43ad"},
+    {file = "yarl-1.9.4.tar.gz", hash = "sha256:566db86717cf8080b99b58b083b773a908ae40f06681e87e589a976faf8246bf"},
+]
+
+[package.dependencies]
+idna = ">=2.0"
+multidict = ">=4.0"
+
 [[package]]
 name = "zipp"
 version = "3.17.0"
@@ -1247,4 +1662,4 @@ docs = ["sphinx", "sphinx-autodoc-typehints", "sphinx-rtd-theme"]
 [metadata]
 lock-version = "2.0"
 python-versions = "^3.8"
-content-hash = "deb646aa3cc11606127d064f6592574c262033925ea9c48cec4c38089ed54cec"
+content-hash = "600f8035e20ccdff3539d75b65defbf88b962caf8eb3865759cdb9eab4b7b65e"
diff --git a/pyproject.toml b/pyproject.toml
index 5b01a0c..16ac33e 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -32,12 +32,12 @@ include = [
 [tool.poetry.dependencies]
 python = "^3.8"
 protobuf = "^4.24.3"
-requests = ">=2.19.0"
 http-ece = "^1.1.0"
 cryptography = ">=2.5"
 sphinx = {version = "7.1.2", optional = true}
 sphinx-rtd-theme = {version = "^1.3.0", optional = true}
 sphinx-autodoc-typehints = {version = "^1.24.0", optional = true}
+aiohttp = "^3.9.3"
 
 [tool.poetry.extras]
 docs = ["sphinx", "sphinx-rtd-theme", "sphinx-autodoc-typehints"]
@@ -47,16 +47,18 @@ pre-commit = "*"
 tox = "*"
 pytest = "*"
 pytest-mock = "*"
-requests-mock = "*"
 pytest-asyncio = "*"
 pytest-cov = "*"
 async-timeout = ">=3.0.0"
 mypy-protobuf = "^3.5.0"
+pytest-socket = "^0.7.0"
+aioresponses = "^0.7.6"
 
 [tool.pytest.ini_options]
 testpaths = "tests"
 norecursedirs = ".git"
 asyncio_mode = "auto"
+addopts = "--disable-socket --allow-unix-socket"
 
 [tool.coverage.run]
 omit = [
@@ -105,4 +107,11 @@ convention = "pep257"
 "docs/source/conf.py" = [
     "D100",
     "D103",
-]
\ No newline at end of file
+]
+
+[tool.mypy]
+exclude = [
+    'tests/.*',  # TOML literal string (single-quotes, no escaping necessary)
+    'docs/.*'
+]
+disallow_untyped_defs = true
diff --git a/tests/conftest.py b/tests/conftest.py
index e11d798..0311df4 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -6,7 +6,7 @@
 import threading
 
 import pytest
-import requests_mock
+from aioresponses import CallbackResult, aioresponses
 from google.protobuf.json_format import Parse as JsonParse
 
 from firebase_messaging.fcmpushclient import FcmPushClient, FcmPushClientConfig
@@ -61,7 +61,7 @@ async def _logged_in_push_client(
     ):
         config = FcmPushClientConfig(**config_kwargs)
         pr = FcmPushClient(credentials=credentials, config=config)
-        pr.checkin(1234, 4321)
+        await pr.checkin(1234, 4321)
 
         cb_loop = asyncio.get_running_loop() if callback_loop else None
         pr.start(
@@ -91,23 +91,21 @@ async def _logged_in_push_client(
             k.stop()
 
 
-# setting the fixture name to requests_mock allows other
-# tests to pull in request_mock and append uris
-@pytest.fixture(autouse=True, name="requests_mock")
-def requests_mock_fixture():
-    with requests_mock.Mocker() as mock:
+@pytest.fixture(autouse=True, name="aioresponses_mock")
+def aioresponses_mock_fixture():
+    with aioresponses() as mock:
         mock.post(
             "https://android.clients.google.com/checkin",
-            content=load_fixture_as_msg(
+            body=load_fixture_as_msg(
                 "android_checkin_response.json", AndroidCheckinResponse
             ).SerializeToString(),
         )
         mock.post(
             "https://android.clients.google.com/c2dm/register3",
-            text=load_fixture("gcm_register_response.txt"),
+            body=load_fixture("gcm_register_response.txt"),
         )
         mock.post(
             "https://fcm.googleapis.com/fcm/connect/subscribe",
-            json=load_fixture_as_dict("fcm_register_response.json"),
+            payload=load_fixture_as_dict("fcm_register_response.json"),
         )
         yield mock
diff --git a/tests/test_fcmpushclient.py b/tests/test_fcmpushclient.py
index 42fcc87..514fdff 100644
--- a/tests/test_fcmpushclient.py
+++ b/tests/test_fcmpushclient.py
@@ -19,9 +19,9 @@
 from tests.conftest import load_fixture_as_dict, load_fixture_as_msg
 
 
-def test_register(requests_mock):
+async def test_register():
     pr = FcmPushClient(credentials=None)
-    pr.checkin(1234, 4321)
+    await pr.checkin(1234, 4321)
 
 
 async def test_no_disconnect(logged_in_push_client, fake_mcs_endpoint, mocker, caplog):