From 21983a966d4e2f35851a0e121ad0e1f6342a73bf Mon Sep 17 00:00:00 2001
From: Aleksandr Soloshenko <capcom2me@gmail.com>
Date: Mon, 13 Oct 2025 06:38:08 +0700
Subject: [PATCH 01/10] [client] add devices and new messages types support

---
 android_sms_gateway/ahttp.py  |  70 +++++++++++++++
 android_sms_gateway/client.py |  68 ++++++++++++++-
 android_sms_gateway/domain.py | 160 +++++++++++++++++++++++++++++++---
 android_sms_gateway/http.py   |  74 ++++++++++++++++
 4 files changed, 357 insertions(+), 15 deletions(-)

diff --git a/android_sms_gateway/ahttp.py b/android_sms_gateway/ahttp.py
index eb095f8..cb4eafd 100644
--- a/android_sms_gateway/ahttp.py
+++ b/android_sms_gateway/ahttp.py
@@ -13,6 +13,16 @@ async def post(
         self, url: str, payload: dict, *, headers: t.Optional[t.Dict[str, str]] = None
     ) -> dict: ...
 
+    @abc.abstractmethod
+    async def put(
+        self, url: str, payload: dict, *, headers: t.Optional[t.Dict[str, str]] = None
+    ) -> dict: ...
+
+    @abc.abstractmethod
+    async def patch(
+        self, url: str, payload: dict, *, headers: t.Optional[t.Dict[str, str]] = None
+    ) -> dict: ...
+
     @abc.abstractmethod
     async def delete(
         self, url: str, *, headers: t.Optional[t.Dict[str, str]] = None
@@ -86,6 +96,38 @@ async def post(
                 response.raise_for_status()
                 return await response.json()
 
+        async def put(
+            self,
+            url: str,
+            payload: dict,
+            *,
+            headers: t.Optional[t.Dict[str, str]] = None,
+        ) -> dict:
+            if self._session is None:
+                raise ValueError("Session not initialized")
+
+            async with self._session.put(
+                url, headers=headers, json=payload
+            ) as response:
+                response.raise_for_status()
+                return await response.json()
+
+        async def patch(
+            self,
+            url: str,
+            payload: dict,
+            *,
+            headers: t.Optional[t.Dict[str, str]] = None,
+        ) -> dict:
+            if self._session is None:
+                raise ValueError("Session not initialized")
+
+            async with self._session.patch(
+                url, headers=headers, json=payload
+            ) as response:
+                response.raise_for_status()
+                return await response.json()
+
         async def delete(
             self, url: str, *, headers: t.Optional[t.Dict[str, str]] = None
         ) -> None:
@@ -145,6 +187,34 @@ async def post(
 
             return response.raise_for_status().json()
 
+        async def put(
+            self,
+            url: str,
+            payload: dict,
+            *,
+            headers: t.Optional[t.Dict[str, str]] = None,
+        ) -> dict:
+            if self._client is None:
+                raise ValueError("Client not initialized")
+
+            response = await self._client.put(url, headers=headers, json=payload)
+
+            return response.raise_for_status().json()
+
+        async def patch(
+            self,
+            url: str,
+            payload: dict,
+            *,
+            headers: t.Optional[t.Dict[str, str]] = None,
+        ) -> dict:
+            if self._client is None:
+                raise ValueError("Client not initialized")
+
+            response = await self._client.patch(url, headers=headers, json=payload)
+
+            return response.raise_for_status().json()
+
         async def delete(
             self, url: str, *, headers: t.Optional[t.Dict[str, str]] = None
         ) -> None:
diff --git a/android_sms_gateway/client.py b/android_sms_gateway/client.py
index 3e87ef5..472cfb9 100644
--- a/android_sms_gateway/client.py
+++ b/android_sms_gateway/client.py
@@ -42,7 +42,21 @@ def _encrypt(self, message: domain.Message) -> domain.Message:
         message = dataclasses.replace(
             message,
             is_encrypted=True,
-            message=self.encryptor.encrypt(message.message),
+            text_message=(
+                domain.TextMessage(
+                    text=self.encryptor.encrypt(message.text_message.text)
+                )
+                if message.text_message
+                else None
+            ),
+            data_message=(
+                domain.DataMessage(
+                    data=self.encryptor.encrypt(message.data_message.data),
+                    port=message.data_message.port,
+                )
+                if message.data_message
+                else None
+            ),
             phone_numbers=[
                 self.encryptor.encrypt(phone) for phone in message.phone_numbers
             ],
@@ -177,6 +191,32 @@ def delete_webhook(self, _id: str) -> None:
 
         self.http.delete(f"{self.base_url}/webhooks/{_id}", headers=self.headers)
 
+    def list_devices(self) -> t.List[domain.Device]:
+        """Lists all devices."""
+        if self.http is None:
+            raise ValueError("HTTP client not initialized")
+
+        return [
+            domain.Device.from_dict(device)
+            for device in self.http.get(
+                f"{self.base_url}/devices", headers=self.headers
+            )
+        ]
+
+    def remove_device(self, _id: str) -> None:
+        """Removes a device."""
+        if self.http is None:
+            raise ValueError("HTTP client not initialized")
+
+        self.http.delete(f"{self.base_url}/devices/{_id}", headers=self.headers)
+
+    def health_check(self) -> dict:
+        """Performs a health check."""
+        if self.http is None:
+            raise ValueError("HTTP client not initialized")
+
+        return self.http.get(f"{self.base_url}/health", headers=self.headers)
+
 
 class AsyncAPIClient(BaseClient):
     def __init__(
@@ -286,3 +326,29 @@ async def delete_webhook(self, _id: str) -> None:
             raise ValueError("HTTP client not initialized")
 
         await self.http.delete(f"{self.base_url}/webhooks/{_id}", headers=self.headers)
+
+    async def list_devices(self) -> t.List[domain.Device]:
+        """Lists all devices."""
+        if self.http is None:
+            raise ValueError("HTTP client not initialized")
+
+        return [
+            domain.Device.from_dict(device)
+            for device in await self.http.get(
+                f"{self.base_url}/devices", headers=self.headers
+            )
+        ]
+
+    async def remove_device(self, _id: str) -> None:
+        """Removes a device."""
+        if self.http is None:
+            raise ValueError("HTTP client not initialized")
+
+        await self.http.delete(f"{self.base_url}/devices/{_id}", headers=self.headers)
+
+    async def health_check(self) -> dict:
+        """Performs a health check."""
+        if self.http is None:
+            raise ValueError("HTTP client not initialized")
+
+        return await self.http.get(f"{self.base_url}/health", headers=self.headers)
diff --git a/android_sms_gateway/domain.py b/android_sms_gateway/domain.py
index a29990f..44939ef 100644
--- a/android_sms_gateway/domain.py
+++ b/android_sms_gateway/domain.py
@@ -1,4 +1,7 @@
+import base64
 import dataclasses
+import datetime
+from io import BytesIO
 import typing as t
 
 from .enums import ProcessState, WebhookEvent, MessagePriority
@@ -9,31 +12,47 @@ def snake_to_camel(snake_str):
     return components[0] + "".join(x.title() for x in components[1:])
 
 
-@dataclasses.dataclass(frozen=True)
+@dataclasses.dataclass(frozen=True, kw_only=True)
 class Message:
     """
     Represents an SMS message.
 
     Attributes:
-        message (str): The message text.
-        phone_numbers (List[str]): A list of phone numbers to send the message to.
-        with_delivery_report (bool): Whether to request a delivery report. Defaults to True.
-        is_encrypted (bool): Whether the message is encrypted. Defaults to False.
-        id (Optional[str]): The message ID. Defaults to None.
-        ttl (Optional[int]): The time-to-live in seconds. Defaults to None.
-        sim_number (Optional[int]): The SIM number to use. Defaults to None.
-        priority (Optional[MessagePriority]): The priority of the message. Defaults to None.
+        phone_numbers (List[str]): Recipients (phone numbers).
+        tex_message (Optional[TextMessage]): Text message.
+        data_message (Optional[DataMessage]): Data message.
+        priority (Optional[MessagePriority]): Priority.
+        sim_number (Optional[int]): SIM card number (1-3), if not set - default SIM will be used.
+        with_delivery_report (Optional[bool]): With delivery report.
+        is_encrypted (Optional[bool]): Is encrypted.
+        ttl (Optional[int]): Time to live in seconds (conflicts with `validUntil`).
+        valid_until (Optional[str]): Valid until (conflicts with `ttl`).
+        id (Optional[str]): ID (if not set - will be generated).
+        device_id (Optional[str]): Optional device ID for explicit selection.
     """
 
-    message: str
     phone_numbers: t.List[str]
+    text_message: t.Optional["TextMessage"] = None
+    data_message: t.Optional["DataMessage"] = None
+
+    priority: t.Optional[MessagePriority] = None
+    sim_number: t.Optional[int] = None
     with_delivery_report: bool = True
     is_encrypted: bool = False
 
-    id: t.Optional[str] = None
     ttl: t.Optional[int] = None
-    sim_number: t.Optional[int] = None
-    priority: t.Optional[MessagePriority] = None
+    valid_until: t.Optional[datetime.datetime] = None
+
+    id: t.Optional[str] = None
+    device_id: t.Optional[str] = None
+
+    @property
+    def content(self) -> str:
+        if self.text_message:
+            return self.text_message.text
+        if self.data_message:
+            return self.data_message.data
+        raise ValueError("Message has no content")
 
     def asdict(self) -> t.Dict[str, t.Any]:
         """
@@ -43,12 +62,89 @@ def asdict(self) -> t.Dict[str, t.Any]:
             Dict[str, Any]: A dictionary representation of the message.
         """
         return {
-            snake_to_camel(field.name): getattr(self, field.name)
+            snake_to_camel(field.name): (
+                getattr(self, field.name).asdict()
+                if hasattr(getattr(self, field.name), "asdict")
+                else getattr(self, field.name)
+            )
             for field in dataclasses.fields(self)
             if getattr(self, field.name) is not None
         }
 
 
+@dataclasses.dataclass(frozen=True)
+class DataMessage:
+    """
+    Represents a data message.
+
+    Attributes:
+        data (str): Base64-encoded payload.
+        port (int): Destination port.
+    """
+
+    data: str
+    port: int
+
+    def asdict(self) -> t.Dict[str, t.Any]:
+        return {
+            "data": self.data,
+            "port": self.port,
+        }
+
+    @classmethod
+    def with_bytes(cls, data: bytes, port: int) -> "DataMessage":
+        return cls(
+            data=base64.b64encode(data).decode("utf-8"),
+            port=port,
+        )
+
+    @classmethod
+    def from_dict(cls, payload: t.Dict[str, t.Any]) -> "DataMessage":
+        """Creates a DataMessage instance from a dictionary.
+
+        Args:
+            payload: A dictionary containing the data message's data.
+
+        Returns:
+            A DataMessage instance.
+        """
+        return cls(
+            data=payload["data"],
+            port=payload["port"],
+        )
+
+
+@dataclasses.dataclass(frozen=True)
+class TextMessage:
+    """
+    Represents a text message.
+
+    Attributes:
+        text (str): Message text.
+    """
+
+    text: str
+
+    def asdict(self) -> t.Dict[str, t.Any]:
+        return {
+            "text": self.text,
+        }
+
+    @classmethod
+    def from_dict(cls, payload: t.Dict[str, t.Any]) -> "TextMessage":
+        """Creates a TextMessage instance from a dictionary.
+
+        Args:
+            payload: A dictionary containing the text message's data.
+
+        Returns:
+            A TextMessage instance.
+        """
+        return cls(
+            text=payload["text"],
+        )
+
+
 @dataclasses.dataclass(frozen=True)
 class RecipientState:
     phone_number: str
@@ -124,3 +220,39 @@ def asdict(self) -> t.Dict[str, t.Any]:
             "url": self.url,
             "event": self.event.value,
         }
+
+
+@dataclasses.dataclass(frozen=True)
+class Device:
+    """Represents a device."""
+
+    id: str
+    """The unique identifier of the device."""
+    name: str
+    """The name of the device."""
+
+    @classmethod
+    def from_dict(cls, payload: t.Dict[str, t.Any]) -> "Device":
+        """Creates a Device instance from a dictionary."""
+        return cls(
+            id=payload["id"],
+            name=payload["name"],
+        )
+
+
+@dataclasses.dataclass(frozen=True)
+class ErrorResponse:
+    """Represents an error response from the API."""
+
+    code: int
+    """The error code."""
+    message: str
+    """The error message."""
+
+    @classmethod
+    def from_dict(cls, payload: t.Dict[str, t.Any]) -> "ErrorResponse":
+        """Creates an ErrorResponse instance from a dictionary."""
+        return cls(
+            code=payload["code"],
+            message=payload["message"],
+        )
diff --git a/android_sms_gateway/http.py b/android_sms_gateway/http.py
index 4bfed3c..3a05044 100644
--- a/android_sms_gateway/http.py
+++ b/android_sms_gateway/http.py
@@ -1,5 +1,8 @@
 import abc
 import typing as t
+import json
+
+from . import client, domain
 
 
 class HttpClient(t.Protocol):
@@ -13,6 +16,16 @@ def post(
         self, url: str, payload: dict, *, headers: t.Optional[t.Dict[str, str]] = None
     ) -> dict: ...
 
+    @abc.abstractmethod
+    def put(
+        self, url: str, payload: dict, *, headers: t.Optional[t.Dict[str, str]] = None
+    ) -> dict: ...
+
+    @abc.abstractmethod
+    def patch(
+        self, url: str, payload: dict, *, headers: t.Optional[t.Dict[str, str]] = None
+    ) -> dict: ...
+
     @abc.abstractmethod
     def delete(self, url: str, *, headers: t.Optional[t.Dict[str, str]] = None) -> None:
         """
@@ -35,6 +48,7 @@ def __exit__(self, exc_type, exc_val, exc_tb):
 
 DEFAULT_CLIENT: t.Optional[t.Type[HttpClient]] = None
 
+
 try:
     import requests
 
@@ -87,6 +101,34 @@ def delete(
 
             self._session.delete(url, headers=headers).raise_for_status()
 
+        def put(
+            self,
+            url: str,
+            payload: dict,
+            *,
+            headers: t.Optional[t.Dict[str, str]] = None,
+        ) -> dict:
+            if self._session is None:
+                raise ValueError("Session not initialized")
+
+            return self._process_response(
+                self._session.put(url, headers=headers, json=payload)
+            )
+
+        def patch(
+            self,
+            url: str,
+            payload: dict,
+            *,
+            headers: t.Optional[t.Dict[str, str]] = None,
+        ) -> dict:
+            if self._session is None:
+                raise ValueError("Session not initialized")
+
+            return self._process_response(
+                self._session.patch(url, headers=headers, json=payload)
+            )
+
         def _process_response(self, response: requests.Response) -> dict:
             response.raise_for_status()
             return response.json()
@@ -149,6 +191,38 @@ def delete(
 
             self._client.delete(url, headers=headers).raise_for_status()
 
+        def put(
+            self,
+            url: str,
+            payload: dict,
+            *,
+            headers: t.Optional[t.Dict[str, str]] = None,
+        ) -> dict:
+            if self._client is None:
+                raise ValueError("Client not initialized")
+
+            return (
+                self._client.put(url, headers=headers, json=payload)
+                .raise_for_status()
+                .json()
+            )
+
+        def patch(
+            self,
+            url: str,
+            payload: dict,
+            *,
+            headers: t.Optional[t.Dict[str, str]] = None,
+        ) -> dict:
+            if self._client is None:
+                raise ValueError("Client not initialized")
+
+            return (
+                self._client.patch(url, headers=headers, json=payload)
+                .raise_for_status()
+                .json()
+            )
+
     DEFAULT_CLIENT = HttpxHttpClient
 except ImportError:
     pass

From 1330ca22abb6171f810bbffb439fb87158c10ceb Mon Sep 17 00:00:00 2001
From: Aleksandr Soloshenko <capcom2me@gmail.com>
Date: Mon, 13 Oct 2025 06:38:19 +0700
Subject: [PATCH 02/10] [errors] prepare new errors model

---
 android_sms_gateway/ahttp.py  |  66 ++++++---
 android_sms_gateway/errors.py |  72 ++++++++++
 android_sms_gateway/http.py   |  54 ++++++--
 tests/test_client.py          |  19 +--
 tests/test_error_handling.py  | 248 ++++++++++++++++++++++++++++++++++
 5 files changed, 420 insertions(+), 39 deletions(-)
 create mode 100644 android_sms_gateway/errors.py
 create mode 100644 tests/test_error_handling.py

diff --git a/android_sms_gateway/ahttp.py b/android_sms_gateway/ahttp.py
index cb4eafd..9ac6cf0 100644
--- a/android_sms_gateway/ahttp.py
+++ b/android_sms_gateway/ahttp.py
@@ -1,6 +1,10 @@
 import abc
 import typing as t
 
+from .errors import (
+    error_from_status,
+)
+
 
 class AsyncHttpClient(t.Protocol):
     @abc.abstractmethod
@@ -70,6 +74,23 @@ async def __aexit__(self, exc_type, exc_val, exc_tb):
             await self._session.close()
             self._session = None
 
+        async def _process_response(self, response: aiohttp.ClientResponse) -> dict:
+            try:
+                response.raise_for_status()
+                return await response.json()
+            except aiohttp.ClientResponseError as e:
+                # Extract error message from response if available
+                error_data = {}
+                try:
+                    error_data = await response.json()
+                except ValueError:
+                    # Response is not JSON
+                    pass
+
+                # Use the error mapping to create appropriate exception
+                error_message = str(e) or "HTTP request failed"
+                raise error_from_status(error_message, response.status, error_data)
+
         async def get(
             self, url: str, *, headers: t.Optional[t.Dict[str, str]] = None
         ) -> dict:
@@ -77,8 +98,7 @@ async def get(
                 raise ValueError("Session not initialized")
 
             async with self._session.get(url, headers=headers) as response:
-                response.raise_for_status()
-                return await response.json()
+                return await self._process_response(response)
 
         async def post(
             self,
@@ -93,8 +113,7 @@ async def post(
             async with self._session.post(
                 url, headers=headers, json=payload
             ) as response:
-                response.raise_for_status()
-                return await response.json()
+                return await self._process_response(response)
 
         async def put(
             self,
@@ -109,8 +128,7 @@ async def put(
             async with self._session.put(
                 url, headers=headers, json=payload
             ) as response:
-                response.raise_for_status()
-                return await response.json()
+                return await self._process_response(response)
 
         async def patch(
             self,
@@ -125,8 +143,7 @@ async def patch(
             async with self._session.patch(
                 url, headers=headers, json=payload
             ) as response:
-                response.raise_for_status()
-                return await response.json()
+                return await self._process_response(response)
 
         async def delete(
             self, url: str, *, headers: t.Optional[t.Dict[str, str]] = None
@@ -135,7 +152,7 @@ async def delete(
                 raise ValueError("Session not initialized")
 
             async with self._session.delete(url, headers=headers) as response:
-                response.raise_for_status()
+                await self._process_response(response)
 
     DEFAULT_CLIENT = AiohttpAsyncHttpClient
 except ImportError:
@@ -163,6 +180,23 @@ async def __aexit__(self, exc_type, exc_val, exc_tb):
             await self._client.aclose()
             self._client = None
 
+        async def _process_response(self, response: httpx.Response) -> dict:
+            try:
+                response.raise_for_status()
+                return response.json()
+            except httpx.HTTPStatusError as e:
+                # Extract error message from response if available
+                error_data = {}
+                try:
+                    error_data = response.json()
+                except ValueError:
+                    # Response is not JSON
+                    pass
+
+                # Use the error mapping to create appropriate exception
+                error_message = str(e) or "HTTP request failed"
+                raise error_from_status(error_message, response.status_code, error_data)
+
         async def get(
             self, url: str, *, headers: t.Optional[t.Dict[str, str]] = None
         ) -> dict:
@@ -170,8 +204,7 @@ async def get(
                 raise ValueError("Client not initialized")
 
             response = await self._client.get(url, headers=headers)
-
-            return response.raise_for_status().json()
+            return await self._process_response(response)
 
         async def post(
             self,
@@ -184,8 +217,7 @@ async def post(
                 raise ValueError("Client not initialized")
 
             response = await self._client.post(url, headers=headers, json=payload)
-
-            return response.raise_for_status().json()
+            return await self._process_response(response)
 
         async def put(
             self,
@@ -198,8 +230,7 @@ async def put(
                 raise ValueError("Client not initialized")
 
             response = await self._client.put(url, headers=headers, json=payload)
-
-            return response.raise_for_status().json()
+            return await self._process_response(response)
 
         async def patch(
             self,
@@ -212,8 +243,7 @@ async def patch(
                 raise ValueError("Client not initialized")
 
             response = await self._client.patch(url, headers=headers, json=payload)
-
-            return response.raise_for_status().json()
+            return await self._process_response(response)
 
         async def delete(
             self, url: str, *, headers: t.Optional[t.Dict[str, str]] = None
@@ -222,7 +252,7 @@ async def delete(
                 raise ValueError("Client not initialized")
 
             response = await self._client.delete(url, headers=headers)
-            response.raise_for_status()
+            await self._process_response(response)
 
     DEFAULT_CLIENT = HttpxAsyncHttpClient
 except ImportError:
diff --git a/android_sms_gateway/errors.py b/android_sms_gateway/errors.py
new file mode 100644
index 0000000..04d4d6f
--- /dev/null
+++ b/android_sms_gateway/errors.py
@@ -0,0 +1,72 @@
+import typing as t
+
+
+class APIError(Exception):
+    """Base class for API exceptions."""
+
+    def __init__(
+        self,
+        message: str,
+        status_code: t.Optional[int] = None,
+        response: t.Optional[dict] = None,
+    ):
+        super().__init__(message)
+        self.status_code = status_code
+        self.response = response
+
+
+class BadRequestError(APIError):
+    """400 - Bad Request"""
+
+
+class UnauthorizedError(APIError):
+    """401 - Unauthorized"""
+
+
+class ForbiddenError(APIError):
+    """403 - Forbidden"""
+
+
+class NotFoundError(APIError):
+    """404 - Not Found"""
+
+
+class InternalServerError(APIError):
+    """500 - Internal Server Error"""
+
+
+class ServiceUnavailableError(APIError):
+    """503 - Service Unavailable"""
+
+
+class GatewayTimeoutError(APIError):
+    """504 - Gateway Timeout"""
+
+
+_ERROR_MAP = {
+    400: BadRequestError,
+    401: UnauthorizedError,
+    403: ForbiddenError,
+    404: NotFoundError,
+    500: InternalServerError,
+    503: ServiceUnavailableError,
+    504: GatewayTimeoutError,
+}
+
+
+def error_from_status(
+    message: str, status: int, response: t.Optional[dict] = None
+) -> APIError:
+    """Factory function to map HTTP status codes to appropriate APIError subclasses.
+
+    Args:
+        message: Error message
+        status: HTTP status code
+        response: Optional response data
+
+    Returns:
+        Appropriate APIError subclass or APIError as fallback
+    """
+    return _ERROR_MAP.get(status, APIError)(
+        message, status_code=status, response=response
+    )
diff --git a/android_sms_gateway/http.py b/android_sms_gateway/http.py
index 3a05044..9fce2b0 100644
--- a/android_sms_gateway/http.py
+++ b/android_sms_gateway/http.py
@@ -4,6 +4,10 @@
 
 from . import client, domain
 
+from .errors import (
+    error_from_status,
+)
+
 
 class HttpClient(t.Protocol):
     @abc.abstractmethod
@@ -130,8 +134,21 @@ def patch(
             )
 
         def _process_response(self, response: requests.Response) -> dict:
-            response.raise_for_status()
-            return response.json()
+            try:
+                response.raise_for_status()
+                return response.json()
+            except requests.exceptions.HTTPError as e:
+                # Extract error message from response if available
+                error_data = {}
+                try:
+                    error_data = response.json()
+                except ValueError:
+                    # Response is not JSON
+                    pass
+
+                # Use the error mapping to create appropriate exception
+                error_message = str(e) or "HTTP request failed"
+                raise error_from_status(error_message, response.status_code, error_data)
 
     DEFAULT_CLIENT = RequestsHttpClient
 except ImportError:
@@ -159,13 +176,30 @@ def __exit__(self, exc_type, exc_val, exc_tb):
             self._client.close()
             self._client = None
 
+        def _process_response(self, response: httpx.Response) -> dict:
+            try:
+                response.raise_for_status()
+                return response.json()
+            except httpx.HTTPStatusError as e:
+                # Extract error message from response if available
+                error_data = {}
+                try:
+                    error_data = response.json()
+                except ValueError:
+                    # Response is not JSON
+                    pass
+
+                # Use the error mapping to create appropriate exception
+                error_message = str(e) or "HTTP request failed"
+                raise error_from_status(error_message, response.status_code, error_data)
+
         def get(
             self, url: str, *, headers: t.Optional[t.Dict[str, str]] = None
         ) -> dict:
             if self._client is None:
                 raise ValueError("Client not initialized")
 
-            return self._client.get(url, headers=headers).raise_for_status().json()
+            return self._process_response(self._client.get(url, headers=headers))
 
         def post(
             self,
@@ -177,10 +211,8 @@ def post(
             if self._client is None:
                 raise ValueError("Client not initialized")
 
-            return (
+            return self._process_response(
                 self._client.post(url, headers=headers, json=payload)
-                .raise_for_status()
-                .json()
             )
 
         def delete(
@@ -189,7 +221,7 @@ def delete(
             if self._client is None:
                 raise ValueError("Client not initialized")
 
-            self._client.delete(url, headers=headers).raise_for_status()
+            self._process_response(self._client.delete(url, headers=headers))
 
         def put(
             self,
@@ -201,10 +233,8 @@ def put(
             if self._client is None:
                 raise ValueError("Client not initialized")
 
-            return (
+            return self._process_response(
                 self._client.put(url, headers=headers, json=payload)
-                .raise_for_status()
-                .json()
             )
 
         def patch(
@@ -217,10 +247,8 @@ def patch(
             if self._client is None:
                 raise ValueError("Client not initialized")
 
-            return (
+            return self._process_response(
                 self._client.patch(url, headers=headers, json=payload)
-                .raise_for_status()
-                .json()
             )
 
     DEFAULT_CLIENT = HttpxHttpClient
diff --git a/tests/test_client.py b/tests/test_client.py
index 951698c..bd27244 100644
--- a/tests/test_client.py
+++ b/tests/test_client.py
@@ -1,12 +1,12 @@
 import os
 import pytest
-from requests import HTTPError
 
 from android_sms_gateway.client import APIClient
 from android_sms_gateway.constants import DEFAULT_URL
 from android_sms_gateway.domain import Webhook
 from android_sms_gateway.enums import WebhookEvent
 from android_sms_gateway.http import RequestsHttpClient
+from android_sms_gateway import errors
 
 
 @pytest.fixture
@@ -25,12 +25,15 @@ def client():
 
     :yields: An instance of `APIClient`.
     """
-    with RequestsHttpClient() as h, APIClient(
-        os.environ.get("API_LOGIN") or "test",
-        os.environ.get("API_PASSWORD") or "test",
-        base_url=os.environ.get("API_BASE_URL") or DEFAULT_URL,
-        http=h,
-    ) as c:
+    with (
+        RequestsHttpClient() as h,
+        APIClient(
+            os.environ.get("API_LOGIN") or "test",
+            os.environ.get("API_PASSWORD") or "test",
+            base_url=os.environ.get("API_BASE_URL") or DEFAULT_URL,
+            http=h,
+        ) as c,
+    ):
         yield c
 
 
@@ -75,7 +78,7 @@ def test_webhook_create_invalid_url(self, client: APIClient):
 
         :param client: An instance of `APIClient`.
         """
-        with pytest.raises(HTTPError):
+        with pytest.raises(errors.APIError):
             client.create_webhook(
                 Webhook(None, url="not_a_url", event=WebhookEvent.SMS_RECEIVED)
             )
diff --git a/tests/test_error_handling.py b/tests/test_error_handling.py
new file mode 100644
index 0000000..9d4c1e6
--- /dev/null
+++ b/tests/test_error_handling.py
@@ -0,0 +1,248 @@
+import pytest
+from unittest.mock import Mock
+import requests
+import httpx
+import aiohttp
+
+from android_sms_gateway.errors import (
+    APIError,
+    BadRequestError,
+    UnauthorizedError,
+    ForbiddenError,
+    NotFoundError,
+    InternalServerError,
+    ServiceUnavailableError,
+    GatewayTimeoutError,
+    error_from_status,
+)
+from android_sms_gateway.http import RequestsHttpClient, HttpxHttpClient
+from android_sms_gateway.ahttp import AiohttpAsyncHttpClient, HttpxAsyncHttpClient
+
+
+class TestErrorFromStatus:
+    """Test the error_from_status factory function."""
+
+    def test_maps_400_to_bad_request_error(self):
+        """Test that status 400 maps to BadRequestError."""
+        error = error_from_status("Bad request", 400, {"error": "bad request"})
+        assert isinstance(error, BadRequestError)
+        assert error.status_code == 400
+        assert error.response == {"error": "bad request"}
+
+    def test_maps_401_to_unauthorized_error(self):
+        """Test that status 401 maps to UnauthorizedError."""
+        error = error_from_status("Unauthorized", 401)
+        assert isinstance(error, UnauthorizedError)
+        assert error.status_code == 401
+
+    def test_maps_403_to_forbidden_error(self):
+        """Test that status 403 maps to ForbiddenError."""
+        error = error_from_status("Forbidden", 403)
+        assert isinstance(error, ForbiddenError)
+        assert error.status_code == 403
+
+    def test_maps_404_to_not_found_error(self):
+        """Test that status 404 maps to NotFoundError."""
+        error = error_from_status("Not found", 404)
+        assert isinstance(error, NotFoundError)
+        assert error.status_code == 404
+
+    def test_maps_500_to_internal_server_error(self):
+        """Test that status 500 maps to InternalServerError."""
+        error = error_from_status("Internal server error", 500)
+        assert isinstance(error, InternalServerError)
+        assert error.status_code == 500
+
+    def test_maps_503_to_service_unavailable_error(self):
+        """Test that status 503 maps to ServiceUnavailableError."""
+        error = error_from_status("Service unavailable", 503)
+        assert isinstance(error, ServiceUnavailableError)
+        assert error.status_code == 503
+
+    def test_maps_504_to_gateway_timeout_error(self):
+        """Test that status 504 maps to GatewayTimeoutError."""
+        error = error_from_status("Gateway timeout", 504)
+        assert isinstance(error, GatewayTimeoutError)
+        assert error.status_code == 504
+
+    def test_unknown_status_maps_to_api_error(self):
+        """Test that unknown status codes map to APIError."""
+        error = error_from_status("Unknown error", 418)
+        assert isinstance(error, APIError)
+        assert error.status_code == 418
+
+    def test_default_error_message(self):
+        """Test that default error message is used when not provided."""
+        error = error_from_status("", 400)
+        assert str(error) == ""
+
+
+class TestRequestsHttpClientErrorHandling:
+    """Test error handling in RequestsHttpClient."""
+
+    def test_raises_bad_request_error_for_400(self):
+        """Test that BadRequestError is raised for 400 status."""
+        mock_response = Mock()
+        mock_response.status_code = 400
+        mock_response.raise_for_status.side_effect = requests.exceptions.HTTPError(
+            "400 Client Error"
+        )
+        mock_response.json.return_value = {"error": "bad request"}
+
+        client = RequestsHttpClient()
+
+        with pytest.raises(BadRequestError) as exc_info:
+            client._process_response(mock_response)
+
+        assert exc_info.value.status_code == 400
+        assert exc_info.value.response == {"error": "bad request"}
+
+    def test_raises_not_found_error_for_404(self):
+        """Test that NotFoundError is raised for 404 status."""
+        mock_response = Mock()
+        mock_response.status_code = 404
+        mock_response.raise_for_status.side_effect = requests.exceptions.HTTPError(
+            "404 Not Found"
+        )
+        mock_response.json.return_value = {"error": "not found"}
+
+        client = RequestsHttpClient()
+
+        with pytest.raises(NotFoundError) as exc_info:
+            client._process_response(mock_response)
+
+        assert exc_info.value.status_code == 404
+        assert exc_info.value.response == {"error": "not found"}
+
+    def test_raises_api_error_for_unknown_status(self):
+        """Test that APIError is raised for unknown status codes."""
+        mock_response = Mock()
+        mock_response.status_code = 418
+        mock_response.raise_for_status.side_effect = requests.exceptions.HTTPError(
+            "418 I'm a teapot"
+        )
+
+        client = RequestsHttpClient()
+
+        with pytest.raises(APIError) as exc_info:
+            client._process_response(mock_response)
+
+        assert exc_info.value.status_code == 418
+
+
+class TestHttpxHttpClientErrorHandling:
+    """Test error handling in HttpxHttpClient."""
+
+    def test_raises_bad_request_error_for_400(self):
+        """Test that BadRequestError is raised for 400 status."""
+        mock_response = Mock()
+        mock_response.status_code = 400
+        mock_response.raise_for_status.side_effect = httpx.HTTPStatusError(
+            "400 Client Error", request=Mock(), response=mock_response
+        )
+        mock_response.json.return_value = {"error": "bad request"}
+
+        client = HttpxHttpClient()
+
+        with pytest.raises(BadRequestError) as exc_info:
+            client._process_response(mock_response)
+
+        assert exc_info.value.status_code == 400
+        assert exc_info.value.response == {"error": "bad request"}
+
+    def test_raises_not_found_error_for_404(self):
+        """Test that NotFoundError is raised for 404 status."""
+        mock_response = Mock()
+        mock_response.status_code = 404
+        mock_response.raise_for_status.side_effect = httpx.HTTPStatusError(
+            "404 Not Found", request=Mock(), response=mock_response
+        )
+        mock_response.json.return_value = {"error": "not found"}
+
+        client = HttpxHttpClient()
+
+        with pytest.raises(NotFoundError) as exc_info:
+            client._process_response(mock_response)
+
+        assert exc_info.value.status_code == 404
+        assert exc_info.value.response == {"error": "not found"}
+
+
+class TestAiohttpAsyncHttpClientErrorHandling:
+    """Test error handling in AiohttpAsyncHttpClient."""
+
+    @pytest.mark.asyncio
+    async def test_raises_bad_request_error_for_400(self):
+        """Test that BadRequestError is raised for 400 status."""
+        mock_response = Mock()
+        mock_response.status = 400
+        mock_response.raise_for_status.side_effect = aiohttp.ClientResponseError(
+            request_info=Mock(), history=(), status=400, message="400 Client Error"
+        )
+        mock_response.json.return_value = {"error": "bad request"}
+
+        client = AiohttpAsyncHttpClient()
+
+        with pytest.raises(BadRequestError) as exc_info:
+            await client._process_response(mock_response)
+
+        assert exc_info.value.status_code == 400
+        assert exc_info.value.response == {"error": "bad request"}
+
+    @pytest.mark.asyncio
+    async def test_raises_not_found_error_for_404(self):
+        """Test that NotFoundError is raised for 404 status."""
+        mock_response = Mock()
+        mock_response.status = 404
+        mock_response.raise_for_status.side_effect = aiohttp.ClientResponseError(
+            request_info=Mock(), history=(), status=404, message="404 Not Found"
+        )
+        mock_response.json.return_value = {"error": "not found"}
+
+        client = AiohttpAsyncHttpClient()
+
+        with pytest.raises(NotFoundError) as exc_info:
+            await client._process_response(mock_response)
+
+        assert exc_info.value.status_code == 404
+        assert exc_info.value.response == {"error": "not found"}
+
+
+class TestHttpxAsyncHttpClientErrorHandling:
+    """Test error handling in HttpxAsyncHttpClient."""
+
+    @pytest.mark.asyncio
+    async def test_raises_bad_request_error_for_400(self):
+        """Test that BadRequestError is raised for 400 status."""
+        mock_response = Mock()
+        mock_response.status_code = 400
+        mock_response.raise_for_status.side_effect = httpx.HTTPStatusError(
+            "400 Client Error", request=Mock(), response=mock_response
+        )
+        mock_response.json.return_value = {"error": "bad request"}
+
+        client = HttpxAsyncHttpClient()
+
+        with pytest.raises(BadRequestError) as exc_info:
+            await client._process_response(mock_response)
+
+        assert exc_info.value.status_code == 400
+        assert exc_info.value.response == {"error": "bad request"}
+
+    @pytest.mark.asyncio
+    async def test_raises_not_found_error_for_404(self):
+        """Test that NotFoundError is raised for 404 status."""
+        mock_response = Mock()
+        mock_response.status_code = 404
+        mock_response.raise_for_status.side_effect = httpx.HTTPStatusError(
+            "404 Not Found", request=Mock(), response=mock_response
+        )
+        mock_response.json.return_value = {"error": "not found"}
+
+        client = HttpxAsyncHttpClient()
+
+        with pytest.raises(NotFoundError) as exc_info:
+            await client._process_response(mock_response)
+
+        assert exc_info.value.status_code == 404
+        assert exc_info.value.response == {"error": "not found"}

From 38129e2bc139ecf49e351d28404c218a438e1634 Mon Sep 17 00:00:00 2001
From: Aleksandr Soloshenko <capcom2me@gmail.com>
Date: Mon, 13 Oct 2025 06:43:58 +0700
Subject: [PATCH 03/10] [lint] fix lint errors

---
 android_sms_gateway/domain.py | 1 -
 android_sms_gateway/http.py   | 3 ---
 2 files changed, 4 deletions(-)

diff --git a/android_sms_gateway/domain.py b/android_sms_gateway/domain.py
index 44939ef..e1fba9c 100644
--- a/android_sms_gateway/domain.py
+++ b/android_sms_gateway/domain.py
@@ -1,7 +1,6 @@
 import base64
 import dataclasses
 import datetime
-from io import BytesIO
 import typing as t
 
 from .enums import ProcessState, WebhookEvent, MessagePriority
diff --git a/android_sms_gateway/http.py b/android_sms_gateway/http.py
index 9fce2b0..dca1eb7 100644
--- a/android_sms_gateway/http.py
+++ b/android_sms_gateway/http.py
@@ -1,8 +1,5 @@
 import abc
 import typing as t
-import json
-
-from . import client, domain
 
 from .errors import (
     error_from_status,

From ba5eecf5f1c27a59fac689a3c4ef13f427d65361 Mon Sep 17 00:00:00 2001
From: Aleksandr Soloshenko <capcom2me@gmail.com>
Date: Mon, 13 Oct 2025 09:44:22 +0700
Subject: [PATCH 04/10] [actions] install all deps for testings

---
 .github/workflows/testing.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/testing.yml b/.github/workflows/testing.yml
index d965bc5..8ac118d 100644
--- a/.github/workflows/testing.yml
+++ b/.github/workflows/testing.yml
@@ -29,7 +29,7 @@ jobs:
       - name: Install dependencies
         run: |
           pipenv sync --dev
-          pipenv sync --categories encryption
+          pipenv sync --categories requests,httpx,aiohttp,encryption
 
       - name: Lint with flake8
         run: pipenv run flake8 android_sms_gateway tests

From 2d7f0ca385bfea71da3720bf1b7e92bc8cbcb4a3 Mon Sep 17 00:00:00 2001
From: Aleksandr Soloshenko <capcom2me@gmail.com>
Date: Mon, 13 Oct 2025 09:44:43 +0700
Subject: [PATCH 05/10] [errors] minor fixes to errors handling

---
 android_sms_gateway/ahttp.py  | 14 ++++++++++++--
 android_sms_gateway/domain.py | 23 +++++++++++++++--------
 android_sms_gateway/http.py   | 14 ++++++++++++--
 tests/test_client.py          |  4 ++--
 tests/test_error_handling.py  | 17 +++++++++--------
 5 files changed, 50 insertions(+), 22 deletions(-)

diff --git a/android_sms_gateway/ahttp.py b/android_sms_gateway/ahttp.py
index 9ac6cf0..aac37a8 100644
--- a/android_sms_gateway/ahttp.py
+++ b/android_sms_gateway/ahttp.py
@@ -77,6 +77,9 @@ async def __aexit__(self, exc_type, exc_val, exc_tb):
         async def _process_response(self, response: aiohttp.ClientResponse) -> dict:
             try:
                 response.raise_for_status()
+                if response.status == 204:
+                    return {}
+
                 return await response.json()
             except aiohttp.ClientResponseError as e:
                 # Extract error message from response if available
@@ -89,7 +92,9 @@ async def _process_response(self, response: aiohttp.ClientResponse) -> dict:
 
                 # Use the error mapping to create appropriate exception
                 error_message = str(e) or "HTTP request failed"
-                raise error_from_status(error_message, response.status, error_data)
+                raise error_from_status(
+                    error_message, response.status, error_data
+                ) from e
 
         async def get(
             self, url: str, *, headers: t.Optional[t.Dict[str, str]] = None
@@ -183,6 +188,9 @@ async def __aexit__(self, exc_type, exc_val, exc_tb):
         async def _process_response(self, response: httpx.Response) -> dict:
             try:
                 response.raise_for_status()
+                if response.status_code == 204:
+                    return {}
+
                 return response.json()
             except httpx.HTTPStatusError as e:
                 # Extract error message from response if available
@@ -195,7 +203,9 @@ async def _process_response(self, response: httpx.Response) -> dict:
 
                 # Use the error mapping to create appropriate exception
                 error_message = str(e) or "HTTP request failed"
-                raise error_from_status(error_message, response.status_code, error_data)
+                raise error_from_status(
+                    error_message, response.status_code, error_data
+                ) from e
 
         async def get(
             self, url: str, *, headers: t.Optional[t.Dict[str, str]] = None
diff --git a/android_sms_gateway/domain.py b/android_sms_gateway/domain.py
index e1fba9c..320e6f3 100644
--- a/android_sms_gateway/domain.py
+++ b/android_sms_gateway/domain.py
@@ -1,6 +1,7 @@
 import base64
 import dataclasses
 import datetime
+import enum
 import typing as t
 
 from .enums import ProcessState, WebhookEvent, MessagePriority
@@ -18,7 +19,7 @@ class Message:
 
     Attributes:
         phone_numbers (List[str]): Recipients (phone numbers).
-        tex_message (Optional[TextMessage]): Text message.
+        text_message (Optional[TextMessage]): Text message.
         data_message (Optional[DataMessage]): Data message.
         priority (Optional[MessagePriority]): Priority.
         sim_number (Optional[int]): SIM card number (1-3), if not set - default SIM will be used.
@@ -60,14 +61,20 @@ def asdict(self) -> t.Dict[str, t.Any]:
         Returns:
             Dict[str, Any]: A dictionary representation of the message.
         """
+
+        def _serialize(value: t.Any) -> t.Any:
+            if hasattr(value, "asdict"):
+                return value.asdict()
+            if isinstance(value, datetime.datetime):
+                return value.isoformat()
+            if isinstance(value, enum.Enum):
+                return value.value
+            return value
+
         return {
-            snake_to_camel(field.name): (
-                getattr(self, field.name).asdict()
-                if hasattr(getattr(self, field.name), "asdict")
-                else getattr(self, field.name)
-            )
-            for field in dataclasses.fields(self)
-            if getattr(self, field.name) is not None
+            snake_to_camel(f.name): _serialize(getattr(self, f.name))
+            for f in dataclasses.fields(self)
+            if getattr(self, f.name) is not None
         }
 
 
diff --git a/android_sms_gateway/http.py b/android_sms_gateway/http.py
index dca1eb7..c47e2b7 100644
--- a/android_sms_gateway/http.py
+++ b/android_sms_gateway/http.py
@@ -133,6 +133,9 @@ def patch(
         def _process_response(self, response: requests.Response) -> dict:
             try:
                 response.raise_for_status()
+                if response.status_code == 204:
+                    return {}
+
                 return response.json()
             except requests.exceptions.HTTPError as e:
                 # Extract error message from response if available
@@ -145,7 +148,9 @@ def _process_response(self, response: requests.Response) -> dict:
 
                 # Use the error mapping to create appropriate exception
                 error_message = str(e) or "HTTP request failed"
-                raise error_from_status(error_message, response.status_code, error_data)
+                raise error_from_status(
+                    error_message, response.status_code, error_data
+                ) from e
 
     DEFAULT_CLIENT = RequestsHttpClient
 except ImportError:
@@ -176,6 +181,9 @@ def __exit__(self, exc_type, exc_val, exc_tb):
         def _process_response(self, response: httpx.Response) -> dict:
             try:
                 response.raise_for_status()
+                if response.status_code == 204:
+                    return {}
+
                 return response.json()
             except httpx.HTTPStatusError as e:
                 # Extract error message from response if available
@@ -188,7 +196,9 @@ def _process_response(self, response: httpx.Response) -> dict:
 
                 # Use the error mapping to create appropriate exception
                 error_message = str(e) or "HTTP request failed"
-                raise error_from_status(error_message, response.status_code, error_data)
+                raise error_from_status(
+                    error_message, response.status_code, error_data
+                ) from e
 
         def get(
             self, url: str, *, headers: t.Optional[t.Dict[str, str]] = None
diff --git a/tests/test_client.py b/tests/test_client.py
index bd27244..551efb3 100644
--- a/tests/test_client.py
+++ b/tests/test_client.py
@@ -71,10 +71,10 @@ def test_webhook_create(self, client: APIClient):
     def test_webhook_create_invalid_url(self, client: APIClient):
         """
         Tests that attempting to create a webhook with an invalid URL raises an
-        `HTTPError`.
+        `errors.APIError`.
 
         The test creates a webhook with an invalid URL, and then asserts that an
-        `HTTPError` is raised.
+        `errors.APIError` is raised.
 
         :param client: An instance of `APIClient`.
         """
diff --git a/tests/test_error_handling.py b/tests/test_error_handling.py
index 9d4c1e6..49bf4c2 100644
--- a/tests/test_error_handling.py
+++ b/tests/test_error_handling.py
@@ -1,22 +1,23 @@
-import pytest
 from unittest.mock import Mock
-import requests
-import httpx
+
 import aiohttp
+import httpx
+import pytest
+import requests
 
+from android_sms_gateway.ahttp import AiohttpAsyncHttpClient, HttpxAsyncHttpClient
 from android_sms_gateway.errors import (
     APIError,
     BadRequestError,
-    UnauthorizedError,
     ForbiddenError,
-    NotFoundError,
+    GatewayTimeoutError,
     InternalServerError,
+    NotFoundError,
     ServiceUnavailableError,
-    GatewayTimeoutError,
+    UnauthorizedError,
     error_from_status,
 )
-from android_sms_gateway.http import RequestsHttpClient, HttpxHttpClient
-from android_sms_gateway.ahttp import AiohttpAsyncHttpClient, HttpxAsyncHttpClient
+from android_sms_gateway.http import HttpxHttpClient, RequestsHttpClient
 
 
 class TestErrorFromStatus:

From b7987b514b67478e3ffe5a33e512b8a200c7cc49 Mon Sep 17 00:00:00 2001
From: Aleksandr Soloshenko <capcom2me@gmail.com>
Date: Tue, 14 Oct 2025 20:06:18 +0700
Subject: [PATCH 06/10] [domain] minor fixes

---
 android_sms_gateway/domain.py | 10 +++++++---
 tests/test_client.py          |  7 ++-----
 2 files changed, 9 insertions(+), 8 deletions(-)

diff --git a/android_sms_gateway/domain.py b/android_sms_gateway/domain.py
index 320e6f3..7413c2c 100644
--- a/android_sms_gateway/domain.py
+++ b/android_sms_gateway/domain.py
@@ -23,10 +23,10 @@ class Message:
         data_message (Optional[DataMessage]): Data message.
         priority (Optional[MessagePriority]): Priority.
         sim_number (Optional[int]): SIM card number (1-3), if not set - default SIM will be used.
-        with_delivery_report (Optional[bool]): With delivery report.
-        is_encrypted (Optional[bool]): Is encrypted.
+        with_delivery_report (bool): With delivery report.
+        is_encrypted (bool): Is encrypted.
         ttl (Optional[int]): Time to live in seconds (conflicts with `validUntil`).
-        valid_until (Optional[str]): Valid until (conflicts with `ttl`).
+        valid_until (Optional[datetime.datetime]): Valid until (conflicts with `ttl`).
         id (Optional[str]): ID (if not set - will be generated).
         device_id (Optional[str]): Optional device ID for explicit selection.
     """
@@ -46,6 +46,10 @@ class Message:
     id: t.Optional[str] = None
     device_id: t.Optional[str] = None
 
+    def __post_init__(self):
+        if self.ttl is not None and self.valid_until is not None:
+            raise ValueError("ttl and valid_until are mutually exclusive")
+
     @property
     def content(self) -> str:
         if self.text_message:
diff --git a/tests/test_client.py b/tests/test_client.py
index 551efb3..3fbe684 100644
--- a/tests/test_client.py
+++ b/tests/test_client.py
@@ -25,15 +25,12 @@ def client():
 
     :yields: An instance of `APIClient`.
     """
-    with (
-        RequestsHttpClient() as h,
-        APIClient(
+    with RequestsHttpClient() as h, APIClient(
             os.environ.get("API_LOGIN") or "test",
             os.environ.get("API_PASSWORD") or "test",
             base_url=os.environ.get("API_BASE_URL") or DEFAULT_URL,
             http=h,
-        ) as c,
-    ):
+        ) as c:
         yield c
 
 

From c007766f3402d2e78041ef79a0f00208fa1fb357 Mon Sep 17 00:00:00 2001
From: Aleksandr Soloshenko <capcom2me@gmail.com>
Date: Wed, 15 Oct 2025 06:35:51 +0700
Subject: [PATCH 07/10] [lint] fix lint error

---
 tests/test_client.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/test_client.py b/tests/test_client.py
index 3fbe684..45e1fa9 100644
--- a/tests/test_client.py
+++ b/tests/test_client.py
@@ -30,7 +30,7 @@ def client():
             os.environ.get("API_PASSWORD") or "test",
             base_url=os.environ.get("API_BASE_URL") or DEFAULT_URL,
             http=h,
-        ) as c:
+    ) as c:
         yield c
 
 

From 501b4cded0b823dfdded85b4de16f38ffc7b4661 Mon Sep 17 00:00:00 2001
From: Aleksandr Soloshenko <capcom2me@gmail.com>
Date: Wed, 15 Oct 2025 06:53:57 +0700
Subject: [PATCH 08/10] [deps] add asyncio tests support

---
 Pipfile                      |    5 +
 Pipfile.lock                 | 1913 +++++++++++++++++++---------------
 android_sms_gateway/ahttp.py |    4 +-
 tests/test_domain.py         |   20 +-
 4 files changed, 1099 insertions(+), 843 deletions(-)

diff --git a/Pipfile b/Pipfile
index c0f34d6..1c40ad4 100644
--- a/Pipfile
+++ b/Pipfile
@@ -3,6 +3,9 @@ url = "https://pypi.org/simple"
 verify_ssl = true
 name = "pypi"
 
+[pipenv]
+sort_pipfile = true
+
 [packages]
 
 [dev-packages]
@@ -14,6 +17,8 @@ wheel = "*"
 twine = "*"
 build = "*"
 importlib-metadata = "*"
+typing-extensions = "*"
+pytest-asyncio = "*"
 
 [requires]
 python_version = "3"
diff --git a/Pipfile.lock b/Pipfile.lock
index 24736ac..f763ad4 100644
--- a/Pipfile.lock
+++ b/Pipfile.lock
@@ -1,11 +1,11 @@
 {
     "_meta": {
         "hash": {
-            "sha256": "431aa233c3b0cbefd026f87e0ac7aa93472c064d475d0448e7e64033ccfbacc8"
+            "sha256": "815530a1a8e855107d302a876f37114741b834d6ea2a30bbe30d1ed59283fd4f"
         },
         "pipfile-spec": 6,
         "requires": {
-            "python_version": ">=3.9"
+            "python_version": "3"
         },
         "sources": [
             {
@@ -26,726 +26,915 @@
         },
         "aiohttp": {
             "hashes": [
-                "sha256:05875595d2483d96cb61fa9f64e75262d7ac6251a7e3c811d8e26f7d721760bd",
-                "sha256:0728882115bfa85cbd8d0f664c8ccc0cfd5bd3789dd837596785450ae52fac31",
-                "sha256:082c5ec6d262c1b2ee01c63f4fb9152c17f11692bf16f0f100ad94a7a287d456",
-                "sha256:09a213c13fba321586edab1528b530799645b82bd64d79b779eb8d47ceea155a",
-                "sha256:0b84731697325b023902aa643bd1726d999f5bc7854bc28b17ff410a81151d4b",
-                "sha256:0d0b1c27c05a7d39a50e946ec5f94c3af4ffadd33fa5f20705df42fb0a72ca14",
-                "sha256:0e58f5ae79649ffa247081c2e8c85e31d29623cf2a3137dda985ae05c9478aae",
-                "sha256:10237f2c34711215d04ed21da63852ce023608299554080a45c576215d9df81c",
-                "sha256:120b7dd084e96cfdad85acea2ce1e7708c70a26db913eabb8d7b417c728f5d84",
-                "sha256:1c14448d6a86acadc3f7b2f4cc385d1fb390acb6f37dce27f86fe629410d92e3",
-                "sha256:1ebb213445900527831fecc70e185bf142fdfe5f2a691075f22d63c65ee3c35a",
-                "sha256:216abf74b324b0f4e67041dd4fb2819613909a825904f8a51701fbcd40c09cd7",
-                "sha256:22fd867fbd72612dcf670c90486dbcbaf702cb807fb0b42bc0b7a142a573574a",
-                "sha256:277c882916759b4a6b6dc7e2ceb124aad071b3c6456487808d9ab13e1b448d57",
-                "sha256:28ded835c3663fd41c9ad44685811b11e34e6ac9a7516a30bfce13f6abba4496",
-                "sha256:2a813e61583cab6d5cdbaa34bc28863acdb92f9f46e11de1b3b9251a1e8238f6",
-                "sha256:2e0f2e208914ecbc4b2a3b7b4daa759d0c587d9a0b451bb0835ac47fae7fa735",
-                "sha256:38823fe0d8bc059b3eaedb263fe427d887c7032e72b4ef92c472953285f0e658",
-                "sha256:3a2aa255417c8ccf1b39359cd0a3d63ae3b5ced83958dbebc4d9113327c0536a",
-                "sha256:3b1979e1f0c98c06fd0cd940988833b102fa3aa56751f6c40ffe85cabc51f6fd",
-                "sha256:3e092f1a970223794a4bf620a26c0e4e4e8e36bccae9b0b5da35e6d8ee598a03",
-                "sha256:411f821be5af6af11dc5bed6c6c1dc6b6b25b91737d968ec2756f9baa75e5f9b",
-                "sha256:4f4a5af90d5232c41bb857568fe7d11ed84408653ec9da1ff999cc30258b9bd1",
-                "sha256:563ec477c0dc6d56fc7f943a3475b5acdb399c7686c30f5a98ada24bb7562c7a",
-                "sha256:58ecd10fda6a44c311cd3742cfd2aea8c4c600338e9f27cb37434d9f5ca9ddaa",
-                "sha256:5e53cf9c201b45838a2d07b1f2d5f7fec9666db7979240002ce64f9b8a1e0cf2",
-                "sha256:5ee537ad29de716a3d8dc46c609908de0c25ffeebf93cd94a03d64cdc07d66d0",
-                "sha256:60fc7338dfb0626c2927bfbac4785de3ea2e2bbe3d328ba5f3ece123edda4977",
-                "sha256:65c7804a2343893d6dea9fce69811aea0a9ac47f68312cf2e3ee1668cd9a387f",
-                "sha256:65d6cefad286459b68e7f867b9586a821fb7f121057b88f02f536ef570992329",
-                "sha256:6bf3b9d9e767f9d0e09fb1a31516410fc741a62cc08754578c40abc497d09540",
-                "sha256:6f25e9d274d6abbb15254f76f100c3984d6b9ad6e66263cc60a465dd5c7e48f5",
-                "sha256:6fc369fb273a8328077d37798b77c1e65676709af5c182cb74bd169ca9defe81",
-                "sha256:71125b1fc2b6a94bccc63bbece620906a4dead336d2051f8af9cbf04480bc5af",
-                "sha256:7163cc9cf3722d90f1822f8a38b211e3ae2fc651c63bb55449f03dc1b3ff1d44",
-                "sha256:72eae16a9233561d315e72ae78ed9fc65ab3db0196e56cb2d329c755d694f137",
-                "sha256:73b148e606f34e9d513c451fd65efe1091772659ca5703338a396a99f60108ff",
-                "sha256:74fddc0ba8cea6b9c5bd732eb9d97853543586596b86391f8de5d4f6c2a0e068",
-                "sha256:7678147c3c85a7ae61559b06411346272ed40a08f54bc05357079a63127c9718",
-                "sha256:784a66f9f853a22c6b8c2bd0ff157f9b879700f468d6d72cfa99167df08c5c9c",
-                "sha256:7f5f5eb8717ef8ba15ab35fcde5a70ad28bbdc34157595d1cddd888a985f5aae",
-                "sha256:8098a48f93b2cbcdb5778e7c9a0e0375363e40ad692348e6e65c3b70d593b27c",
-                "sha256:81ef2f9253c327c211cb7b06ea2edd90e637cf21c347b894d540466b8d304e08",
-                "sha256:8687cc5f32b4e328c233acd387d09a1b477007896b2f03c1c823a0fd05f63883",
-                "sha256:8ed76bc80177ddb7c5c93e1a6440b115ed2c92a3063420ac55206fd0832a6459",
-                "sha256:98451ce9ce229d092f278a74a7c2a06b3aa72984673c87796126d7ccade893e9",
-                "sha256:9923b025845b72f64d167bca221113377c8ffabd0a351dc18fb839d401ee8e22",
-                "sha256:9aa5f049e3e2745b0141f13e5a64e7c48b1a1427ed18bbb7957b348f282fee56",
-                "sha256:a05917780b7cad1755784b16cfaad806bc16029a93d15f063ca60185b7d9ba05",
-                "sha256:a1b6df6255cfc493454c79221183d64007dd5080bcda100db29b7ff181b8832c",
-                "sha256:a324c6852b6e327811748446e56cc9bb6eaa58710557922183175816e82a4234",
-                "sha256:a4b78ccf254fc10605b263996949a94ca3f50e4f9100e05137d6583e266b711e",
-                "sha256:a4c53b89b3f838e9c25f943d1257efff10b348cb56895f408ddbcb0ec953a2ad",
-                "sha256:a5be0b58670b54301404bd1840e4902570a1c3be00358e2700919cb1ea73c438",
-                "sha256:ace2499bdd03c329c054dc4b47361f2b19d5aa470f7db5c7e0e989336761b33c",
-                "sha256:adbac7286d89245e1aff42e948503fdc6edf6d5d65c8e305a67c40f6a8fb95f4",
-                "sha256:b0066e88f30be00badffb5ef8f2281532b9a9020863d873ae15f7c147770b6ec",
-                "sha256:b265a3a8b379b38696ac78bdef943bdc4f4a5d6bed1a3fb5c75c6bab1ecea422",
-                "sha256:b434bfb49564dc1c318989a0ab1d3000d23e5cfd00d8295dc9d5a44324cdd42d",
-                "sha256:b5a49c2dcb32114455ad503e8354624d85ab311cbe032da03965882492a9cb98",
-                "sha256:b8ec3c1a1c13d24941b5b913607e57b9364e4c0ea69d5363181467492c4b2ba6",
-                "sha256:c944860e86b9f77a462321a440ccf6fa10f5719bb9d026f6b0b11307b1c96c7b",
-                "sha256:ce8f13566fc7bf5a728275b434bc3bdea87a7ed3ad5f734102b02ca59d9b510f",
-                "sha256:d1c1879b2e0fc337d7a1b63fe950553c2b9e93c071cf95928aeea1902d441403",
-                "sha256:d2afc72207ef4c9d4ca9fcd00689a6a37ef2d625600c3d757b5c2b80c9d0cf9a",
-                "sha256:d40e7bfd577fdc8a92b72f35dfbdd3ec90f1bc8a72a42037fefe34d4eca2d4a1",
-                "sha256:d736e57d1901683bc9be648aa308cb73e646252c74b4c639c35dcd401ed385ea",
-                "sha256:db874d3b0c92fdbb553751af9d2733b378c25cc83cd9dfba87f12fafd2dc9cd5",
-                "sha256:ddf40ba4a1d0b4d232dc47d2b98ae7e937dcbc40bb5f2746bce0af490a64526f",
-                "sha256:e03ff38250b8b572dce6fcd7b6fb6ee398bb8a59e6aa199009c5322d721df4fc",
-                "sha256:e1282a9acd378f2aed8dc79c01e702b1d5fd260ad083926a88ec7e987c4e0ade",
-                "sha256:e2007eaa7aae9102f211c519d1ec196bd3cecb1944a095db19eeaf132b798738",
-                "sha256:e408293aa910b0aea48b86a28eace41d497a85ba16c20f619f0c604597ef996c",
-                "sha256:e5928847e6f7b7434921fbabf73fa5609d1f2bf4c25d9d4522b1fcc3b51995cb",
-                "sha256:e5e834f0f11ff5805d11f0f22b627c75eadfaf91377b457875e4e3affd0b924f",
-                "sha256:ea5d604318234427929d486954e3199aded65f41593ac57aa0241ab93dda3d15",
-                "sha256:ef97c4d035b721de6607f3980fa3e4ef0ec3aca76474b5789b7fac286a8c4e23",
-                "sha256:f25990c507dbbeefd5a6a17df32a4ace634f7b20a38211d1b9609410c7f67a24",
-                "sha256:f3d05c46a61aca7c47df74afff818bc06a251ab95d95ff80b53665edfe1e0bdf",
-                "sha256:f3d31faf290f5a30acba46b388465b67c6dbe8655d183e9efe2f6a1d594e6d9d",
-                "sha256:f50057f36f2a1d8e750b273bb966bec9f69ee1e0a20725ae081610501f25d555",
-                "sha256:f68301660f0d7a3eddfb84f959f78a8f9db98c76a49b5235508fa16edaad0f7c",
-                "sha256:f90319d94cf5f9786773237f24bd235a7b5959089f1af8ec1154580a3434b503",
-                "sha256:f94b2e2dea19d09745ef02ed483192260750f18731876a5c76f1c254b841443a",
-                "sha256:feaaaff61966b5f4b4eae0b79fc79427f49484e4cfa5ab7d138ecd933ab540a8",
-                "sha256:ffa5205c2f53f1120e93fdf2eca41b0f6344db131bc421246ee82c1e1038a14a"
+                "sha256:00243e51f16f6ec0fb021659d4af92f675f3cf9f9b39efd142aa3ad641d8d1e6",
+                "sha256:00fdfe370cffede3163ba9d3f190b32c0cfc8c774f6f67395683d7b0e48cdb8a",
+                "sha256:019dbef24fe28ce2301419dd63a2b97250d9760ca63ee2976c2da2e3f182f82e",
+                "sha256:052bcdd80c1c54b8a18a9ea0cd5e36f473dc8e38d51b804cea34841f677a9971",
+                "sha256:059978d2fddc462e9211362cbc8446747ecd930537fa559d3d25c256f032ff54",
+                "sha256:0a2be20eb23888df130214b91c262a90e2de1553d6fb7de9e9010cec994c0ff2",
+                "sha256:0f1338b61ea66f4757a0544ed8a02ccbf60e38d9cfb3225888888dd4475ebb96",
+                "sha256:0f19f7798996d4458c669bd770504f710014926e9970f4729cf55853ae200469",
+                "sha256:0f735e680c323ee7e9ef8e2ea26425c7dbc2ede0086fa83ce9d7ccab8a089f26",
+                "sha256:10b3f01d5aeb632adaaf39c5e93f040a550464a768d54c514050c635adcbb9d0",
+                "sha256:12f5d820fadc5848d4559ea838aef733cf37ed2a1103bba148ac2f5547c14c29",
+                "sha256:19ba8625fa69523627b67f7e9901b587a4952470f68814d79cdc5bc460e9b885",
+                "sha256:19bb08e56f57c215e9572cd65cb6f8097804412c54081d933997ddde3e5ac579",
+                "sha256:1c272a9a18a5ecc48a7101882230046b83023bb2a662050ecb9bfcb28d9ab53a",
+                "sha256:1ccedfe280e804d9a9d7fe8b8c4309d28e364b77f40309c86596baa754af50b1",
+                "sha256:1f164699a060c0b3616459d13c1464a981fddf36f892f0a5027cbd45121fb14b",
+                "sha256:2117be9883501eaf95503bd313eb4c7a23d567edd44014ba15835a1e9ec6d852",
+                "sha256:222c828243b4789d79a706a876910f656fad4381661691220ba57b2ab4547865",
+                "sha256:23ca762140159417a6bbc959ca1927f6949711851e56f2181ddfe8d63512b5ad",
+                "sha256:240f99f88a9a6beb53ebadac79a2e3417247aa756202ed234b1dbae13d248092",
+                "sha256:2c4aeaedd20771b7b4bcdf0ae791904445df6d856c02fc51d809d12d17cffdc7",
+                "sha256:2d71ca30257ce756e37a6078b1dff2d9475fee13609ad831eac9a6531bea903b",
+                "sha256:2e66c57416352f36bf98f6641ddadd47c93740a22af7150d3e9a1ef6e983f9a8",
+                "sha256:2f9d9ea547618d907f2ee6670c9a951f059c5994e4b6de8dcf7d9747b420c820",
+                "sha256:2fd35177dc483ae702f07b86c782f4f4b100a8ce4e7c5778cea016979023d9fd",
+                "sha256:3194b8cab8dbc882f37c13ef1262e0a3d62064fa97533d3aa124771f7bf1ecee",
+                "sha256:34d8af6391c5f2e69749d7f037b614b8c5c42093c251f336bdbfa4b03c57d6c4",
+                "sha256:378dbc57dd8cf341ce243f13fa1fa5394d68e2e02c15cd5f28eae35a70ec7f67",
+                "sha256:3b1eb9871cbe43b6ca6fac3544682971539d8a1d229e6babe43446279679609d",
+                "sha256:3b3bdc89413117b40cc39baae08fd09cbdeb839d421c4e7dce6a34f6b54b3ac1",
+                "sha256:3b64f22fbb6dcd5663de5ef2d847a5638646ef99112503e6f7704bdecb0d1c4d",
+                "sha256:3c11fa5dd2ef773a8a5a6daa40243d83b450915992eab021789498dc87acc114",
+                "sha256:3e6a38366f7f0d0f6ed7a1198055150c52fda552b107dad4785c0852ad7685d1",
+                "sha256:3e77a729df23be2116acc4e9de2767d8e92445fbca68886dd991dc912f473755",
+                "sha256:469167d5372f5bb3aedff4fc53035d593884fff2617a75317740e885acd48b04",
+                "sha256:4696665b2713021c6eba3e2b882a86013763b442577fe5d2056a42111e732eca",
+                "sha256:474cade59a447cb4019c0dce9f0434bf835fb558ea932f62c686fe07fe6db6a1",
+                "sha256:475bd56492ce5f4cffe32b5533c6533ee0c406d1d0e6924879f83adcf51da0ae",
+                "sha256:48fcdd5bc771cbbab8ccc9588b8b6447f6a30f9fe00898b1a5107098e00d6793",
+                "sha256:49ce7525853a981fc35d380aa2353536a01a9ec1b30979ea4e35966316cace7e",
+                "sha256:4aa995b9156ae499393d949a456a7ab0b994a8241a96db73a3b73c7a090eff6a",
+                "sha256:4af1f8877ca46ecdd0bc0d4a6b66d4b2bddc84a79e2e8366bc0d5308e76bceb8",
+                "sha256:4b14bfae90598d331b5061fd15a7c290ea0c15b34aeb1cf620464bb5ec02a602",
+                "sha256:4df1984c8804ed336089e88ac81a9417b1fd0db7c6f867c50a9264488797e778",
+                "sha256:5004d727499ecb95f7c9147dd0bfc5b5670f71d355f0bd26d7af2d3af8e07d2f",
+                "sha256:55ca0e95a3905f62f00900255ed807c580775174252999286f283e646d675a49",
+                "sha256:564b36512a7da3b386143c611867e3f7cfb249300a1bf60889bd9985da67ab77",
+                "sha256:564be41e85318403fdb176e9e5b3e852d528392f42f2c1d1efcbeeed481126d7",
+                "sha256:56f7d230ec66e799fbfd8350e9544f8a45a4353f1cf40c1fea74c1780f555b8f",
+                "sha256:582770f82513419512da096e8df21ca44f86a2e56e25dc93c5ab4df0fe065bf0",
+                "sha256:5ae3a19949a27982c7425a7a5a963c1268fdbabf0be15ab59448cbcf0f992519",
+                "sha256:5b8a5557d5af3f4e3add52a58c4cf2b8e6e59fc56b261768866f5337872d596d",
+                "sha256:5bf635c3476f4119b940cc8d94ad454cbe0c377e61b4527f0192aabeac1e9370",
+                "sha256:62a3cddf8d9a2eae1f79585fa81d32e13d0c509bb9e7ad47d33c83b45a944df7",
+                "sha256:62d8a0adcdaf62ee56bfb37737153251ac8e4b27845b3ca065862fb01d99e247",
+                "sha256:62fd54f3e6f17976962ba67f911d62723c760a69d54f5d7b74c3ceb1a4e9ef8d",
+                "sha256:6475e42ef92717a678bfbf50885a682bb360a6f9c8819fb1a388d98198fdcb80",
+                "sha256:682d2e434ff2f1108314ff7f056ce44e457f12dbed0249b24e106e385cf154b9",
+                "sha256:6a51839f778b0e283b43cd82bb17f1835ee2cc1bf1101765e90ae886e53e751c",
+                "sha256:6b4174fcec98601f0cfdf308ee29a6ae53c55f14359e848dab4e94009112ee7d",
+                "sha256:6b9697d15231aeaed4786f090c9c8bc3ab5f0e0a6da1e76c135a310def271020",
+                "sha256:6c333a2385d2a6298265f4b3e960590f787311b87f6b5e6e21bb8375914ef504",
+                "sha256:703ad3f742fc81e543638a7bebddd35acadaa0004a5e00535e795f4b6f2c25ca",
+                "sha256:72714919ed9b90f030f761c20670e529c4af96c31bd000917dd0c9afd1afb731",
+                "sha256:76484ba17b2832776581b7ab466d094e48eba74cb65a60aea20154dae485e8bd",
+                "sha256:77da5305a410910218b99f2a963092f4277d8a9c1f429c1ff1b026d1826bd0b6",
+                "sha256:7897298b3eedc790257fef8a6ec582ca04e9dbe568ba4a9a890913b925b8ea21",
+                "sha256:7972c82bed87d7bd8e374b60a6b6e816d75ba4f7c2627c2d14eed216e62738e1",
+                "sha256:7c20db99da682f9180fa5195c90b80b159632fb611e8dbccdd99ba0be0970620",
+                "sha256:7c2c4c9ce834801651f81d6760d0a51035b8b239f58f298de25162fcf6f8bb64",
+                "sha256:7ddedba3d0043349edc79df3dc2da49c72b06d59a45a42c1c8d987e6b8d175b8",
+                "sha256:84912962071087286333f70569362e10793f73f45c48854e6859df11001eb2d3",
+                "sha256:90b570f1a146181c3d6ae8f755de66227ded49d30d050479b5ae07710f7894c5",
+                "sha256:97891a23d7fd4e1afe9c2f4473e04595e4acb18e4733b910b6577b74e7e21985",
+                "sha256:990a53b9d6a30b2878789e490758e568b12b4a7fb2527d0c89deb9650b0e5813",
+                "sha256:99a303ad960747c33b65b1cb65d01a62ac73fa39b72f08a2e1efa832529b01ed",
+                "sha256:99eb94e97a42367fef5fc11e28cb2362809d3e70837f6e60557816c7106e2e20",
+                "sha256:a1c20c26af48aea984f63f96e5d7af7567c32cb527e33b60a0ef0a6313cf8b03",
+                "sha256:a4676b978a9711531e7cea499d4cdc0794c617a1c0579310ab46c9fdf5877702",
+                "sha256:a4dc0b83e25267f42ef065ea57653de4365b56d7bc4e4cfc94fabe56998f8ee6",
+                "sha256:a533873a7a4ec2270fb362ee5a0d3b98752e4e1dc9042b257cd54545a96bd8ed",
+                "sha256:a6d9487b9471ec36b0faedf52228cd732e89be0a2bbd649af890b5e2ce422353",
+                "sha256:a921edbe971aade1bf45bcbb3494e30ba6863a5c78f28be992c42de980fd9108",
+                "sha256:a9f3546b503975a69b547c9fd1582cad10ede1ce6f3e313a2f547c73a3d7814f",
+                "sha256:aab715b1a0c37f7f11f9f1f579c6fbaa51ef569e47e3c0a4644fba46077a9409",
+                "sha256:ac90cfab65bc281d6752f22db5fa90419e33220af4b4fa53b51f5948f414c0e7",
+                "sha256:b3a8e6a2058a0240cfde542b641d0e78b594311bc1a710cbcb2e1841417d5cb3",
+                "sha256:bb34001fc1f05f6b323e02c278090c07a47645caae3aa77ed7ed8a3ce6abcce9",
+                "sha256:bc95c49853cd29613e4fe4ff96d73068ff89b89d61e53988442e127e8da8e7ba",
+                "sha256:bfe824d6707a5dc3c5676685f624bc0c63c40d79dc0239a7fd6c034b98c25ebe",
+                "sha256:c32ada0abb4bc94c30be2b681c42f058ab104d048da6f0148280a51ce98add8c",
+                "sha256:c417f8c2e1137775569297c584a8a7144e5d1237789eae56af4faf1894a0b861",
+                "sha256:c811612711e01b901e18964b3e5dec0d35525150f5f3f85d0aee2935f059910a",
+                "sha256:ca69ec38adf5cadcc21d0b25e2144f6a25b7db7bea7e730bac25075bc305eff0",
+                "sha256:ca8313cb852af788c78d5afdea24c40172cbfff8b35e58b407467732fde20390",
+                "sha256:cc6d5fc5edbfb8041d9607f6a417997fa4d02de78284d386bea7ab767b5ea4f3",
+                "sha256:cd45eb70eca63f41bb156b7dffbe1a7760153b69892d923bdb79a74099e2ed90",
+                "sha256:ce887c5e54411d607ee0959cac15bb31d506d86a9bcaddf0b7e9d63325a7a802",
+                "sha256:cf2b60b65df05b6b2fa0d887f2189991a0dbf44a0dd18359001dc8fcdb7f1163",
+                "sha256:cf7a4b976da219e726d0043fc94ae8169c0dba1d3a059b3c1e2c964bafc5a77d",
+                "sha256:cf8b0870047900eb1f17f453b4b3953b8ffbf203ef56c2f346780ff930a4d430",
+                "sha256:cfe6285ef99e7ee51cef20609be2bc1dd0e8446462b71c9db8bb296ba632810a",
+                "sha256:d169c47e40c911f728439da853b6fd06da83761012e6e76f11cb62cddae7282b",
+                "sha256:d812838c109757a11354a161c95708ae4199c4fd4d82b90959b20914c1d097f6",
+                "sha256:d871f6a30d43e32fc9252dc7b9febe1a042b3ff3908aa83868d7cf7c9579a59b",
+                "sha256:dea698b64235d053def7d2f08af9302a69fcd760d1c7bd9988fd5d3b6157e657",
+                "sha256:df46d9a3d78ec19b495b1107bf26e4fcf97c900279901f4f4819ac5bb2a02a4c",
+                "sha256:e04ab827ec4f775817736b20cdc8350f40327f9b598dec4e18c9ffdcbea88a93",
+                "sha256:e68c0076052dd911a81d3acc4ef2911cc4ef65bf7cadbfbc8ae762da24da858f",
+                "sha256:e88ab34826d6eeb6c67e6e92400b9ec653faf5092a35f07465f44c9f1c429f82",
+                "sha256:ea01ffbe23df53ece0c8732d1585b3d6079bb8c9ee14f3745daf000051415a31",
+                "sha256:ea6df292013c9f050cbf3f93eee9953d6e5acd9e64a0bf4ca16404bfd7aa9bcc",
+                "sha256:ee433e594d7948e760b5c2a78cc06ac219df33b0848793cf9513d486a9f90a52",
+                "sha256:eeea0cdd2f687e210c8f605f322d7b0300ba55145014a5dbe98bd4be6fff1f6c",
+                "sha256:f27b7488144eb5dd9151cf839b195edd1569629d90ace4c5b6b18e4e75d1e63a",
+                "sha256:f84b53326abf8e56ebc28a35cebf4a0f396a13a76300f500ab11fe0573bf0b52",
+                "sha256:f8d877aa60d80715b2afc565f0f1aea66565824c229a2d065b31670e09fed6d7",
+                "sha256:f8e38d55ca36c15f36d814ea414ecb2401d860de177c49f84a327a25b3ee752b",
+                "sha256:f91e8f9053a07177868e813656ec57599cd2a63238844393cd01bd69c2e40147",
+                "sha256:fcc425fb6fd2a00c6d91c85d084c6b75a61bc8bc12159d08e17c5711df6c5ba4"
             ],
             "index": "pypi",
             "markers": "python_version >= '3.9'",
-            "version": "==3.12.12"
+            "version": "==3.13.0"
         },
         "aiosignal": {
             "hashes": [
-                "sha256:45cde58e409a301715980c2b01d0c28bdde3770d8290b5eb2173759d9acb31a5",
-                "sha256:a8c255c66fafb1e499c9351d0bf32ff2d8a0321595ebac3b93713656d2436f54"
+                "sha256:053243f8b92b990551949e63930a839ff0cf0b0ebbe0597b0f3fb19e1a0fe82e",
+                "sha256:f47eecd9468083c2029cc99945502cb7708b082c232f9aca65da147157b251c7"
             ],
             "markers": "python_version >= '3.9'",
-            "version": "==1.3.2"
+            "version": "==1.4.0"
         },
         "attrs": {
             "hashes": [
-                "sha256:427318ce031701fea540783410126f03899a97ffc6f61596ad581ac2e40e3bc3",
-                "sha256:75d7cefc7fb576747b2c81b4442d4d4a1ce0900973527c011d1030fd3bf4af1b"
+                "sha256:16d5969b87f0859ef33a48b35d55ac1be6e42ae49d5e853b597db70c35c57e11",
+                "sha256:adcf7e2a1fb3b36ac48d97835bb6d8ade15b8dcce26aba8bf1d14847b57a3373"
             ],
-            "markers": "python_version >= '3.8'",
-            "version": "==25.3.0"
+            "markers": "python_version >= '3.9'",
+            "version": "==25.4.0"
         },
         "frozenlist": {
             "hashes": [
-                "sha256:04fb24d104f425da3540ed83cbfc31388a586a7696142004c577fa61c6298c3f",
-                "sha256:05579bf020096fe05a764f1f84cd104a12f78eaab68842d036772dc6d4870b4b",
-                "sha256:0aa7e176ebe115379b5b1c95b4096fb1c17cce0847402e227e712c27bdb5a949",
-                "sha256:1073557c941395fdfcfac13eb2456cb8aad89f9de27bae29fabca8e563b12615",
-                "sha256:1137b78384eebaf70560a36b7b229f752fb64d463d38d1304939984d5cb887b6",
-                "sha256:15900082e886edb37480335d9d518cec978afc69ccbc30bd18610b7c1b22a718",
-                "sha256:15a7eaba63983d22c54d255b854e8108e7e5f3e89f647fc854bd77a237e767df",
-                "sha256:1a85e345b4c43db8b842cab1feb41be5cc0b10a1830e6295b69d7310f99becaf",
-                "sha256:1e63344c4e929b1a01e29bc184bbb5fd82954869033765bfe8d65d09e336a677",
-                "sha256:1eaa7e9c6d15df825bf255649e05bd8a74b04a4d2baa1ae46d9c2d00b2ca2cb5",
-                "sha256:1ed8d2fa095aae4bdc7fdd80351009a48d286635edffee66bf865e37a9125c50",
-                "sha256:1f5906d3359300b8a9bb194239491122e6cf1444c2efb88865426f170c262cdb",
-                "sha256:21884e23cffabb157a9dd7e353779077bf5b8f9a58e9b262c6caad2ef5f80a56",
-                "sha256:24c34bea555fe42d9f928ba0a740c553088500377448febecaa82cc3e88aa1fa",
-                "sha256:284d233a8953d7b24f9159b8a3496fc1ddc00f4db99c324bd5fb5f22d8698ea7",
-                "sha256:290a172aae5a4c278c6da8a96222e6337744cd9c77313efe33d5670b9f65fc43",
-                "sha256:2e310d81923c2437ea8670467121cc3e9b0f76d3043cc1d2331d56c7fb7a3a8f",
-                "sha256:2ea2a7369eb76de2217a842f22087913cdf75f63cf1307b9024ab82dfb525938",
-                "sha256:32dc2e08c67d86d0969714dd484fd60ff08ff81d1a1e40a77dd34a387e6ebc0c",
-                "sha256:34a69a85e34ff37791e94542065c8416c1afbf820b68f720452f636d5fb990cd",
-                "sha256:376b6222d114e97eeec13d46c486facd41d4f43bab626b7c3f6a8b4e81a5192c",
-                "sha256:3789ebc19cb811163e70fe2bd354cea097254ce6e707ae42e56f45e31e96cb8e",
-                "sha256:387cbfdcde2f2353f19c2f66bbb52406d06ed77519ac7ee21be0232147c2592d",
-                "sha256:3a14027124ddb70dfcee5148979998066897e79f89f64b13328595c4bdf77c81",
-                "sha256:3bf8010d71d4507775f658e9823210b7427be36625b387221642725b515dcf3e",
-                "sha256:3d688126c242a6fabbd92e02633414d40f50bb6002fa4cf995a1d18051525657",
-                "sha256:3dabd5a8f84573c8d10d8859a50ea2dec01eea372031929871368c09fa103478",
-                "sha256:3dbf9952c4bb0e90e98aec1bd992b3318685005702656bc6f67c1a32b76787f2",
-                "sha256:3fbba20e662b9c2130dc771e332a99eff5da078b2b2648153a40669a6d0e36ca",
-                "sha256:400ddd24ab4e55014bba442d917203c73b2846391dd42ca5e38ff52bb18c3c5e",
-                "sha256:41be2964bd4b15bf575e5daee5a5ce7ed3115320fb3c2b71fca05582ffa4dc9e",
-                "sha256:426c7bc70e07cfebc178bc4c2bf2d861d720c4fff172181eeb4a4c41d4ca2ad3",
-                "sha256:43a82fce6769c70f2f5a06248b614a7d268080a9d20f7457ef10ecee5af82b63",
-                "sha256:45a6f2fdbd10e074e8814eb98b05292f27bad7d1883afbe009d96abdcf3bc898",
-                "sha256:46d84d49e00c9429238a7ce02dc0be8f6d7cd0cd405abd1bebdc991bf27c15bd",
-                "sha256:488d0a7d6a0008ca0db273c542098a0fa9e7dfaa7e57f70acef43f32b3f69dca",
-                "sha256:4a646531fa8d82c87fe4bb2e596f23173caec9185bfbca5d583b4ccfb95183e2",
-                "sha256:4e7e9652b3d367c7bd449a727dc79d5043f48b88d0cbfd4f9f1060cf2b414104",
-                "sha256:52109052b9791a3e6b5d1b65f4b909703984b770694d3eb64fad124c835d7cba",
-                "sha256:563b72efe5da92e02eb68c59cb37205457c977aa7a449ed1b37e6939e5c47c6a",
-                "sha256:5fc4df05a6591c7768459caba1b342d9ec23fa16195e744939ba5914596ae3e1",
-                "sha256:61d1a5baeaac6c0798ff6edfaeaa00e0e412d49946c53fae8d4b8e8b3566c4ae",
-                "sha256:69cac419ac6a6baad202c85aaf467b65ac860ac2e7f2ac1686dc40dbb52f6577",
-                "sha256:6a5c505156368e4ea6b53b5ac23c92d7edc864537ff911d2fb24c140bb175e60",
-                "sha256:6aeac207a759d0dedd2e40745575ae32ab30926ff4fa49b1635def65806fddee",
-                "sha256:6eb93efb8101ef39d32d50bce242c84bcbddb4f7e9febfa7b524532a239b4464",
-                "sha256:716a9973a2cc963160394f701964fe25012600f3d311f60c790400b00e568b61",
-                "sha256:72c1b0fe8fe451b34f12dce46445ddf14bd2a5bcad7e324987194dc8e3a74c86",
-                "sha256:73bd45e1488c40b63fe5a7df892baf9e2a4d4bb6409a2b3b78ac1c6236178e01",
-                "sha256:74739ba8e4e38221d2c5c03d90a7e542cb8ad681915f4ca8f68d04f810ee0a87",
-                "sha256:765bb588c86e47d0b68f23c1bee323d4b703218037765dcf3f25c838c6fecceb",
-                "sha256:79b2ffbba483f4ed36a0f236ccb85fbb16e670c9238313709638167670ba235f",
-                "sha256:7d536ee086b23fecc36c2073c371572374ff50ef4db515e4e503925361c24f71",
-                "sha256:7edf5c043c062462f09b6820de9854bf28cc6cc5b6714b383149745e287181a8",
-                "sha256:82d664628865abeb32d90ae497fb93df398a69bb3434463d172b80fc25b0dd7d",
-                "sha256:836b42f472a0e006e02499cef9352ce8097f33df43baaba3e0a28a964c26c7d2",
-                "sha256:8bd7eb96a675f18aa5c553eb7ddc24a43c8c18f22e1f9925528128c052cdbe00",
-                "sha256:8fc5d5cda37f62b262405cf9652cf0856839c4be8ee41be0afe8858f17f4c94b",
-                "sha256:912a7e8375a1c9a68325a902f3953191b7b292aa3c3fb0d71a216221deca460b",
-                "sha256:9537c2777167488d539bc5de2ad262efc44388230e5118868e172dd4a552b146",
-                "sha256:960d67d0611f4c87da7e2ae2eacf7ea81a5be967861e0c63cf205215afbfac59",
-                "sha256:974c5336e61d6e7eb1ea5b929cb645e882aadab0095c5a6974a111e6479f8878",
-                "sha256:99886d98e1643269760e5fe0df31e5ae7050788dd288947f7f007209b8c33f08",
-                "sha256:9a19e85cc503d958abe5218953df722748d87172f71b73cf3c9257a91b999890",
-                "sha256:9a5af342e34f7e97caf8c995864c7a396418ae2859cc6fdf1b1073020d516a7e",
-                "sha256:9b35db7ce1cd71d36ba24f80f0c9e7cff73a28d7a74e91fe83e23d27c7828750",
-                "sha256:9ccec739a99e4ccf664ea0775149f2749b8a6418eb5b8384b4dc0a7d15d304cb",
-                "sha256:a0fd1bad056a3600047fb9462cff4c5322cebc59ebf5d0a3725e0ee78955001d",
-                "sha256:a26f205c9ca5829cbf82bb2a84b5c36f7184c4316617d7ef1b271a56720d6b30",
-                "sha256:a47f2abb4e29b3a8d0b530f7c3598badc6b134562b1a5caee867f7c62fee51e3",
-                "sha256:a6f86e4193bb0e235ef6ce3dde5cbabed887e0b11f516ce8a0f4d3b33078ec2d",
-                "sha256:aa51e147a66b2d74de1e6e2cf5921890de6b0f4820b257465101d7f37b49fb5a",
-                "sha256:aa57daa5917f1738064f302bf2626281a1cb01920c32f711fbc7bc36111058a8",
-                "sha256:ac64b6478722eeb7a3313d494f8342ef3478dff539d17002f849101b212ef97c",
-                "sha256:acd03d224b0175f5a850edc104ac19040d35419eddad04e7cf2d5986d98427f1",
-                "sha256:af369aa35ee34f132fcfad5be45fbfcde0e3a5f6a1ec0712857f286b7d20cca9",
-                "sha256:b0d5ce521d1dd7d620198829b87ea002956e4319002ef0bc8d3e6d045cb4646e",
-                "sha256:b3950f11058310008a87757f3eee16a8e1ca97979833239439586857bc25482e",
-                "sha256:b8c05e4c8e5f36e5e088caa1bf78a687528f83c043706640a92cb76cd6999384",
-                "sha256:bcacfad3185a623fa11ea0e0634aac7b691aa925d50a440f39b458e41c561d98",
-                "sha256:bd8c4e58ad14b4fa7802b8be49d47993182fdd4023393899632c88fd8cd994eb",
-                "sha256:bfe2b675cf0aaa6d61bf8fbffd3c274b3c9b7b1623beb3809df8a81399a4a9c4",
-                "sha256:c0303e597eb5a5321b4de9c68e9845ac8f290d2ab3f3e2c864437d3c5a30cd65",
-                "sha256:c193dda2b6d49f4c4398962810fa7d7c78f032bf45572b3e04dd5249dff27e08",
-                "sha256:c70db4a0ab5ab20878432c40563573229a7ed9241506181bba12f6b7d0dc41cb",
-                "sha256:cbb65198a9132ebc334f237d7b0df163e4de83fb4f2bdfe46c1e654bdb0c5d43",
-                "sha256:cc4df77d638aa2ed703b878dd093725b72a824c3c546c076e8fdf276f78ee84a",
-                "sha256:ce48b2fece5aeb45265bb7a58259f45027db0abff478e3077e12b05b17fb9da7",
-                "sha256:cea3dbd15aea1341ea2de490574a4a37ca080b2ae24e4b4f4b51b9057b4c3630",
-                "sha256:d1a81c85417b914139e3a9b995d4a1c84559afc839a93cf2cb7f15e6e5f6ed2d",
-                "sha256:d50ac7627b3a1bd2dcef6f9da89a772694ec04d9a61b66cf87f7d9446b4a0c31",
-                "sha256:dab46c723eeb2c255a64f9dc05b8dd601fde66d6b19cdb82b2e09cc6ff8d8b5d",
-                "sha256:dfcebf56f703cb2e346315431699f00db126d158455e513bd14089d992101e44",
-                "sha256:e22b9a99741294b2571667c07d9f8cceec07cb92aae5ccda39ea1b6052ed4319",
-                "sha256:e2cdfaaec6a2f9327bf43c933c0319a7c429058e8537c508964a133dffee412e",
-                "sha256:e4389e06714cfa9d47ab87f784a7c5be91d3934cd6e9a7b85beef808297cc025",
-                "sha256:e793a9f01b3e8b5c0bc646fb59140ce0efcc580d22a3468d70766091beb81b35",
-                "sha256:ee80eeda5e2a4e660651370ebffd1286542b67e268aa1ac8d6dbe973120ef7ee",
-                "sha256:f2038310bc582f3d6a09b3816ab01737d60bf7b1ec70f5356b09e84fb7408ab1",
-                "sha256:f22dac33bb3ee8fe3e013aa7b91dc12f60d61d05b7fe32191ffa84c3aafe77bd",
-                "sha256:f34560fb1b4c3e30ba35fa9a13894ba39e5acfc5f60f57d8accde65f46cc5e74",
-                "sha256:f3f4410a0a601d349dd406b5713fec59b4cee7e71678d5b17edda7f4655a940b",
-                "sha256:f89f65d85774f1797239693cef07ad4c97fdd0639544bad9ac4b869782eb1981",
-                "sha256:fe2365ae915a1fafd982c146754e1de6ab3478def8a59c86e1f7242d794f97d5"
+                "sha256:0325024fe97f94c41c08872db482cf8ac4800d80e79222c6b0b7b162d5b13686",
+                "sha256:032efa2674356903cd0261c4317a561a6850f3ac864a63fc1583147fb05a79b0",
+                "sha256:03ae967b4e297f58f8c774c7eabcce57fe3c2434817d4385c50661845a058121",
+                "sha256:06be8f67f39c8b1dc671f5d83aaefd3358ae5cdcf8314552c57e7ed3e6475bdd",
+                "sha256:073f8bf8becba60aa931eb3bc420b217bb7d5b8f4750e6f8b3be7f3da85d38b7",
+                "sha256:07cdca25a91a4386d2e76ad992916a85038a9b97561bf7a3fd12d5d9ce31870c",
+                "sha256:09474e9831bc2b2199fad6da3c14c7b0fbdd377cce9d3d77131be28906cb7d84",
+                "sha256:0c18a16eab41e82c295618a77502e17b195883241c563b00f0aa5106fc4eaa0d",
+                "sha256:0f96534f8bfebc1a394209427d0f8a63d343c9779cda6fc25e8e121b5fd8555b",
+                "sha256:102e6314ca4da683dca92e3b1355490fed5f313b768500084fbe6371fddfdb79",
+                "sha256:11847b53d722050808926e785df837353bd4d75f1d494377e59b23594d834967",
+                "sha256:119fb2a1bd47307e899c2fac7f28e85b9a543864df47aa7ec9d3c1b4545f096f",
+                "sha256:13d23a45c4cebade99340c4165bd90eeb4a56c6d8a9d8aa49568cac19a6d0dc4",
+                "sha256:154e55ec0655291b5dd1b8731c637ecdb50975a2ae70c606d100750a540082f7",
+                "sha256:168c0969a329b416119507ba30b9ea13688fafffac1b7822802537569a1cb0ef",
+                "sha256:17c883ab0ab67200b5f964d2b9ed6b00971917d5d8a92df149dc2c9779208ee9",
+                "sha256:1a7607e17ad33361677adcd1443edf6f5da0ce5e5377b798fba20fae194825f3",
+                "sha256:1a7fa382a4a223773ed64242dbe1c9c326ec09457e6b8428efb4118c685c3dfd",
+                "sha256:1aa77cb5697069af47472e39612976ed05343ff2e84a3dcf15437b232cbfd087",
+                "sha256:1b9290cf81e95e93fdf90548ce9d3c1211cf574b8e3f4b3b7cb0537cf2227068",
+                "sha256:20e63c9493d33ee48536600d1a5c95eefc870cd71e7ab037763d1fbb89cc51e7",
+                "sha256:21900c48ae04d13d416f0e1e0c4d81f7931f73a9dfa0b7a8746fb2fe7dd970ed",
+                "sha256:229bf37d2e4acdaf808fd3f06e854a4a7a3661e871b10dc1f8f1896a3b05f18b",
+                "sha256:2552f44204b744fba866e573be4c1f9048d6a324dfe14475103fd51613eb1d1f",
+                "sha256:27c6e8077956cf73eadd514be8fb04d77fc946a7fe9f7fe167648b0b9085cc25",
+                "sha256:28bd570e8e189d7f7b001966435f9dac6718324b5be2990ac496cf1ea9ddb7fe",
+                "sha256:294e487f9ec720bd8ffcebc99d575f7eff3568a08a253d1ee1a0378754b74143",
+                "sha256:29548f9b5b5e3460ce7378144c3010363d8035cea44bc0bf02d57f5a685e084e",
+                "sha256:2c5dcbbc55383e5883246d11fd179782a9d07a986c40f49abe89ddf865913930",
+                "sha256:2dc43a022e555de94c3b68a4ef0b11c4f747d12c024a520c7101709a2144fb37",
+                "sha256:2f05983daecab868a31e1da44462873306d3cbfd76d1f0b5b69c473d21dbb128",
+                "sha256:33139dc858c580ea50e7e60a1b0ea003efa1fd42e6ec7fdbad78fff65fad2fd2",
+                "sha256:332db6b2563333c5671fecacd085141b5800cb866be16d5e3eb15a2086476675",
+                "sha256:33f48f51a446114bc5d251fb2954ab0164d5be02ad3382abcbfe07e2531d650f",
+                "sha256:34187385b08f866104f0c0617404c8eb08165ab1272e884abc89c112e9c00746",
+                "sha256:342c97bf697ac5480c0a7ec73cd700ecfa5a8a40ac923bd035484616efecc2df",
+                "sha256:3462dd9475af2025c31cc61be6652dfa25cbfb56cbbf52f4ccfe029f38decaf8",
+                "sha256:39ecbc32f1390387d2aa4f5a995e465e9e2f79ba3adcac92d68e3e0afae6657c",
+                "sha256:3e0761f4d1a44f1d1a47996511752cf3dcec5bbdd9cc2b4fe595caf97754b7a0",
+                "sha256:3ede829ed8d842f6cd48fc7081d7a41001a56f1f38603f9d49bf3020d59a31ad",
+                "sha256:3ef2d026f16a2b1866e1d86fc4e1291e1ed8a387b2c333809419a2f8b3a77b82",
+                "sha256:405e8fe955c2280ce66428b3ca55e12b3c4e9c336fb2103a4937e891c69a4a29",
+                "sha256:42145cd2748ca39f32801dad54aeea10039da6f86e303659db90db1c4b614c8c",
+                "sha256:4314debad13beb564b708b4a496020e5306c7333fa9a3ab90374169a20ffab30",
+                "sha256:433403ae80709741ce34038da08511d4a77062aa924baf411ef73d1146e74faf",
+                "sha256:44389d135b3ff43ba8cc89ff7f51f5a0bb6b63d829c8300f79a2fe4fe61bcc62",
+                "sha256:48e6d3f4ec5c7273dfe83ff27c91083c6c9065af655dc2684d2c200c94308bb5",
+                "sha256:494a5952b1c597ba44e0e78113a7266e656b9794eec897b19ead706bd7074383",
+                "sha256:4970ece02dbc8c3a92fcc5228e36a3e933a01a999f7094ff7c23fbd2beeaa67c",
+                "sha256:4e0c11f2cc6717e0a741f84a527c52616140741cd812a50422f83dc31749fb52",
+                "sha256:50066c3997d0091c411a66e710f4e11752251e6d2d73d70d8d5d4c76442a199d",
+                "sha256:517279f58009d0b1f2e7c1b130b377a349405da3f7621ed6bfae50b10adf20c1",
+                "sha256:54b2077180eb7f83dd52c40b2750d0a9f175e06a42e3213ce047219de902717a",
+                "sha256:5500ef82073f599ac84d888e3a8c1f77ac831183244bfd7f11eaa0289fb30714",
+                "sha256:581ef5194c48035a7de2aefc72ac6539823bb71508189e5de01d60c9dcd5fa65",
+                "sha256:59a6a5876ca59d1b63af8cd5e7ffffb024c3dc1e9cf9301b21a2e76286505c95",
+                "sha256:5a3a935c3a4e89c733303a2d5a7c257ea44af3a56c8202df486b7f5de40f37e1",
+                "sha256:5c1c8e78426e59b3f8005e9b19f6ff46e5845895adbde20ece9218319eca6506",
+                "sha256:5d63a068f978fc69421fb0e6eb91a9603187527c86b7cd3f534a5b77a592b888",
+                "sha256:667c3777ca571e5dbeb76f331562ff98b957431df140b54c85fd4d52eea8d8f6",
+                "sha256:6da155091429aeba16851ecb10a9104a108bcd32f6c1642867eadaee401c1c41",
+                "sha256:6dc4126390929823e2d2d9dc79ab4046ed74680360fc5f38b585c12c66cdf459",
+                "sha256:7398c222d1d405e796970320036b1b563892b65809d9e5261487bb2c7f7b5c6a",
+                "sha256:74c51543498289c0c43656701be6b077f4b265868fa7f8a8859c197006efb608",
+                "sha256:776f352e8329135506a1d6bf16ac3f87bc25b28e765949282dcc627af36123aa",
+                "sha256:778a11b15673f6f1df23d9586f83c4846c471a8af693a22e066508b77d201ec8",
+                "sha256:78f7b9e5d6f2fdb88cdde9440dc147259b62b9d3b019924def9f6478be254ac1",
+                "sha256:799345ab092bee59f01a915620b5d014698547afd011e691a208637312db9186",
+                "sha256:7bf6cdf8e07c8151fba6fe85735441240ec7f619f935a5205953d58009aef8c6",
+                "sha256:8009897cdef112072f93a0efdce29cd819e717fd2f649ee3016efd3cd885a7ed",
+                "sha256:80f85f0a7cc86e7a54c46d99c9e1318ff01f4687c172ede30fd52d19d1da1c8e",
+                "sha256:8585e3bb2cdea02fc88ffa245069c36555557ad3609e83be0ec71f54fd4abb52",
+                "sha256:878be833caa6a3821caf85eb39c5ba92d28e85df26d57afb06b35b2efd937231",
+                "sha256:8a76ea0f0b9dfa06f254ee06053d93a600865b3274358ca48a352ce4f0798450",
+                "sha256:8b7b94a067d1c504ee0b16def57ad5738701e4ba10cec90529f13fa03c833496",
+                "sha256:8d92f1a84bb12d9e56f818b3a746f3efba93c1b63c8387a73dde655e1e42282a",
+                "sha256:908bd3f6439f2fef9e85031b59fd4f1297af54415fb60e4254a95f75b3cab3f3",
+                "sha256:92db2bf818d5cc8d9c1f1fc56b897662e24ea5adb36ad1f1d82875bd64e03c24",
+                "sha256:940d4a017dbfed9daf46a3b086e1d2167e7012ee297fef9e1c545c4d022f5178",
+                "sha256:957e7c38f250991e48a9a73e6423db1bb9dd14e722a10f6b8bb8e16a0f55f695",
+                "sha256:96153e77a591c8adc2ee805756c61f59fef4cf4073a9275ee86fe8cba41241f7",
+                "sha256:96f423a119f4777a4a056b66ce11527366a8bb92f54e541ade21f2374433f6d4",
+                "sha256:97260ff46b207a82a7567b581ab4190bd4dfa09f4db8a8b49d1a958f6aa4940e",
+                "sha256:974b28cf63cc99dfb2188d8d222bc6843656188164848c4f679e63dae4b0708e",
+                "sha256:9ff15928d62a0b80bb875655c39bf517938c7d589554cbd2669be42d97c2cb61",
+                "sha256:a6483e309ca809f1efd154b4d37dc6d9f61037d6c6a81c2dc7a15cb22c8c5dca",
+                "sha256:a88f062f072d1589b7b46e951698950e7da00442fc1cacbe17e19e025dc327ad",
+                "sha256:ac913f8403b36a2c8610bbfd25b8013488533e71e62b4b4adce9c86c8cea905b",
+                "sha256:adbeebaebae3526afc3c96fad434367cafbfd1b25d72369a9e5858453b1bb71a",
+                "sha256:b2a095d45c5d46e5e79ba1e5b9cb787f541a8dee0433836cea4b96a2c439dcd8",
+                "sha256:b3210649ee28062ea6099cfda39e147fa1bc039583c8ee4481cb7811e2448c51",
+                "sha256:b37f6d31b3dcea7deb5e9696e529a6aa4a898adc33db82da12e4c60a7c4d2011",
+                "sha256:b4dec9482a65c54a5044486847b8a66bf10c9cb4926d42927ec4e8fd5db7fed8",
+                "sha256:b4f3b365f31c6cd4af24545ca0a244a53688cad8834e32f56831c4923b50a103",
+                "sha256:b6db2185db9be0a04fecf2f241c70b63b1a242e2805be291855078f2b404dd6b",
+                "sha256:b9be22a69a014bc47e78072d0ecae716f5eb56c15238acca0f43d6eb8e4a5bda",
+                "sha256:bac9c42ba2ac65ddc115d930c78d24ab8d4f465fd3fc473cdedfccadb9429806",
+                "sha256:bf0a7e10b077bf5fb9380ad3ae8ce20ef919a6ad93b4552896419ac7e1d8e042",
+                "sha256:c23c3ff005322a6e16f71bf8692fcf4d5a304aaafe1e262c98c6d4adc7be863e",
+                "sha256:c4c800524c9cd9bac5166cd6f55285957fcfc907db323e193f2afcd4d9abd69b",
+                "sha256:c7366fe1418a6133d5aa824ee53d406550110984de7637d65a178010f759c6ef",
+                "sha256:c8d1634419f39ea6f5c427ea2f90ca85126b54b50837f31497f3bf38266e853d",
+                "sha256:c9a63152fe95756b85f31186bddf42e4c02c6321207fd6601a1c89ebac4fe567",
+                "sha256:cb89a7f2de3602cfed448095bab3f178399646ab7c61454315089787df07733a",
+                "sha256:cba69cb73723c3f329622e34bdbf5ce1f80c21c290ff04256cff1cd3c2036ed2",
+                "sha256:cee686f1f4cadeb2136007ddedd0aaf928ab95216e7691c63e50a8ec066336d0",
+                "sha256:cf253e0e1c3ceb4aaff6df637ce033ff6535fb8c70a764a8f46aafd3d6ab798e",
+                "sha256:d1eaff1d00c7751b7c6662e9c5ba6eb2c17a2306ba5e2a37f24ddf3cc953402b",
+                "sha256:d3bb933317c52d7ea5004a1c442eef86f426886fba134ef8cf4226ea6ee1821d",
+                "sha256:d4d3214a0f8394edfa3e303136d0575eece0745ff2b47bd2cb2e66dd92d4351a",
+                "sha256:d6a5df73acd3399d893dafc71663ad22534b5aa4f94e8a2fabfe856c3c1b6a52",
+                "sha256:d8b7138e5cd0647e4523d6685b0eac5d4be9a184ae9634492f25c6eb38c12a47",
+                "sha256:db1e72ede2d0d7ccb213f218df6a078a9c09a7de257c2fe8fcef16d5925230b1",
+                "sha256:e25ac20a2ef37e91c1b39938b591457666a0fa835c7783c3a8f33ea42870db94",
+                "sha256:e2de870d16a7a53901e41b64ffdf26f2fbb8917b3e6ebf398098d72c5b20bd7f",
+                "sha256:e4a3408834f65da56c83528fb52ce7911484f0d1eaf7b761fc66001db1646eff",
+                "sha256:eaa352d7047a31d87dafcacbabe89df0aa506abb5b1b85a2fb91bc3faa02d822",
+                "sha256:eab8145831a0d56ec9c4139b6c3e594c7a83c2c8be25d5bcf2d86136a532287a",
+                "sha256:ec3cc8c5d4084591b4237c0a272cc4f50a5b03396a47d9caaf76f5d7b38a4f11",
+                "sha256:edee74874ce20a373d62dc28b0b18b93f645633c2943fd90ee9d898550770581",
+                "sha256:eefdba20de0d938cec6a89bd4d70f346a03108a19b9df4248d3cf0d88f1b0f51",
+                "sha256:ef2b7b394f208233e471abc541cc6991f907ffd47dc72584acee3147899d6565",
+                "sha256:f21f00a91358803399890ab167098c131ec2ddd5f8f5fd5fe9c9f2c6fcd91e40",
+                "sha256:f4be2e3d8bc8aabd566f8d5b8ba7ecc09249d74ba3c9ed52e54dc23a293f0b92",
+                "sha256:f57fb59d9f385710aa7060e89410aeb5058b99e62f4d16b08b91986b9a2140c2",
+                "sha256:f6292f1de555ffcc675941d65fffffb0a5bcd992905015f85d0592201793e0e5",
+                "sha256:f833670942247a14eafbb675458b4e61c82e002a148f49e68257b79296e865c4",
+                "sha256:fa47e444b8ba08fffd1c18e8cdb9a75db1b6a27f17507522834ad13ed5922b93",
+                "sha256:fb30f9626572a76dfe4293c7194a09fb1fe93ba94c7d4f720dfae3b646b45027",
+                "sha256:fe3c58d2f5db5fbd18c2987cba06d51b0529f52bc3a6cdc33d3f4eab725104bd"
             ],
             "markers": "python_version >= '3.9'",
-            "version": "==1.7.0"
+            "version": "==1.8.0"
         },
         "idna": {
             "hashes": [
-                "sha256:12f65c9b470abda6dc35cf8e63cc574b1c52b11df2c86030af0ac09b01b13ea9",
-                "sha256:946d195a0d259cbba61165e88e65941f16e9b36ea6ddb97f00452bae8b1287d3"
+                "sha256:771a87f49d9defaf64091e6e6fe9c18d4833f140bd19464795bc32d966ca37ea",
+                "sha256:795dafcc9c04ed0c1fb032c2aa73654d8e8c5023a7df64a53f39190ada629902"
             ],
-            "markers": "python_version >= '3.6'",
-            "version": "==3.10"
+            "markers": "python_version >= '3.8'",
+            "version": "==3.11"
         },
         "multidict": {
             "hashes": [
-                "sha256:0327ad2c747a6600e4797d115d3c38a220fdb28e54983abe8964fd17e95ae83c",
-                "sha256:058cc59b9e9b143cc56715e59e22941a5d868c322242278d28123a5d09cdf6b0",
-                "sha256:0d2b9712211b860d123815a80b859075d86a4d54787e247d7fbee9db6832cf1c",
-                "sha256:0e05c39962baa0bb19a6b210e9b1422c35c093b651d64246b6c2e1a7e242d9fd",
-                "sha256:0f14ea68d29b43a9bf37953881b1e3eb75b2739e896ba4a6aa4ad4c5b9ffa145",
-                "sha256:169c4ba7858176b797fe551d6e99040c531c775d2d57b31bcf4de6d7a669847f",
-                "sha256:19d08b4f22eae45bb018b9f06e2838c1e4b853c67628ef8ae126d99de0da6395",
-                "sha256:1d0121ccce8c812047d8d43d691a1ad7641f72c4f730474878a5aeae1b8ead8c",
-                "sha256:232b7237e57ec3c09be97206bfb83a0aa1c5d7d377faa019c68a210fa35831f1",
-                "sha256:2e543a40e4946cf70a88a3be87837a3ae0aebd9058ba49e91cacb0b2cd631e2b",
-                "sha256:329ae97fc2f56f44d91bc47fe0972b1f52d21c4b7a2ac97040da02577e2daca2",
-                "sha256:3312f63261b9df49be9d57aaa6abf53a6ad96d93b24f9cc16cf979956355ce6e",
-                "sha256:33a12ebac9f380714c298cbfd3e5b9c0c4e89c75fe612ae496512ee51028915f",
-                "sha256:343892a27d1a04d6ae455ecece12904d242d299ada01633d94c4f431d68a8c49",
-                "sha256:3e9f1cd61a0ab857154205fb0b1f3d3ace88d27ebd1409ab7af5096e409614cd",
-                "sha256:3ef4e9096ff86dfdcbd4a78253090ba13b1d183daa11b973e842465d94ae1772",
-                "sha256:4219390fb5bf8e548e77b428bb36a21d9382960db5321b74d9d9987148074d6b",
-                "sha256:496bcf01c76a70a31c3d746fd39383aad8d685ce6331e4c709e9af4ced5fa221",
-                "sha256:49a29d7133b1fc214e818bbe025a77cc6025ed9a4f407d2850373ddde07fd04a",
-                "sha256:4d7b50b673ffb4ff4366e7ab43cf1f0aef4bd3608735c5fbdf0bdb6f690da411",
-                "sha256:4efc31dfef8c4eeb95b6b17d799eedad88c4902daba39ce637e23a17ea078915",
-                "sha256:4f5f29794ac0e73d2a06ac03fd18870adc0135a9d384f4a306a951188ed02f95",
-                "sha256:4ffc3c6a37e048b5395ee235e4a2a0d639c2349dffa32d9367a42fc20d399772",
-                "sha256:50855d03e9e4d66eab6947ba688ffb714616f985838077bc4b490e769e48da51",
-                "sha256:51d662c072579f63137919d7bb8fc250655ce79f00c82ecf11cab678f335062e",
-                "sha256:530d86827a2df6504526106b4c104ba19044594f8722d3e87714e847c74a0275",
-                "sha256:5363f9b2a7f3910e5c87d8b1855c478c05a2dc559ac57308117424dfaad6805c",
-                "sha256:55ae0721c1513e5e3210bca4fc98456b980b0c2c016679d3d723119b6b202c42",
-                "sha256:5883d6ee0fd9d8a48e9174df47540b7545909841ac82354c7ae4cbe9952603bd",
-                "sha256:5bce06b83be23225be1905dcdb6b789064fae92499fbc458f59a8c0e68718601",
-                "sha256:5e0ba18a9afd495f17c351d08ebbc4284e9c9f7971d715f196b79636a4d0de44",
-                "sha256:5e2bcda30d5009996ff439e02a9f2b5c3d64a20151d34898c000a6281faa3781",
-                "sha256:603f39bd1cf85705c6c1ba59644b480dfe495e6ee2b877908de93322705ad7cf",
-                "sha256:60d849912350da557fe7de20aa8cf394aada6980d0052cc829eeda4a0db1c1db",
-                "sha256:622f26ea6a7e19b7c48dd9228071f571b2fbbd57a8cd71c061e848f281550e6b",
-                "sha256:632a3bf8f1787f7ef7d3c2f68a7bde5be2f702906f8b5842ad6da9d974d0aab3",
-                "sha256:66ed0731f8e5dfd8369a883b6e564aca085fb9289aacabd9decd70568b9a30de",
-                "sha256:69133376bc9a03f8c47343d33f91f74a99c339e8b58cea90433d8e24bb298031",
-                "sha256:69ee9e6ba214b5245031b76233dd95408a0fd57fdb019ddcc1ead4790932a8e8",
-                "sha256:6a2f58a66fe2c22615ad26156354005391e26a2f3721c3621504cd87c1ea87bf",
-                "sha256:6a602151dbf177be2450ef38966f4be3467d41a86c6a845070d12e17c858a156",
-                "sha256:6ed5ae5605d4ad5a049fad2a28bb7193400700ce2f4ae484ab702d1e3749c3f9",
-                "sha256:73484a94f55359780c0f458bbd3c39cb9cf9c182552177d2136e828269dee529",
-                "sha256:75493f28dbadecdbb59130e74fe935288813301a8554dc32f0c631b6bdcdf8b0",
-                "sha256:7cf3bd54c56aa16fdb40028d545eaa8d051402b61533c21e84046e05513d5780",
-                "sha256:7e23f2f841fcb3ebd4724a40032d32e0892fbba4143e43d2a9e7695c5e50e6bd",
-                "sha256:7f3d3b3c34867579ea47cbd6c1f2ce23fbfd20a273b6f9e3177e256584f1eacc",
-                "sha256:82ffabefc8d84c2742ad19c37f02cde5ec2a1ee172d19944d380f920a340e4b9",
-                "sha256:83ec4967114295b8afd120a8eec579920c882831a3e4c3331d591a8e5bfbbc0f",
-                "sha256:87a728af265e08f96b6318ebe3c0f68b9335131f461efab2fc64cc84a44aa6ed",
-                "sha256:87cb72263946b301570b0f63855569a24ee8758aaae2cd182aae7d95fbc92ca7",
-                "sha256:8adee3ac041145ffe4488ea73fa0a622b464cc25340d98be76924d0cda8545ff",
-                "sha256:8cc403092a49509e8ef2d2fd636a8ecefc4698cc57bbe894606b14579bc2a955",
-                "sha256:8cd8f81f1310182362fb0c7898145ea9c9b08a71081c5963b40ee3e3cac589b1",
-                "sha256:8ffb40b74400e4455785c2fa37eba434269149ec525fc8329858c862e4b35373",
-                "sha256:93ec84488a384cd7b8a29c2c7f467137d8a73f6fe38bb810ecf29d1ade011a7c",
-                "sha256:941f1bec2f5dbd51feeb40aea654c2747f811ab01bdd3422a48a4e4576b7d76a",
-                "sha256:98af87593a666f739d9dba5d0ae86e01b0e1a9cfcd2e30d2d361fbbbd1a9162d",
-                "sha256:995f985e2e268deaf17867801b859a282e0448633f1310e3704b30616d269d69",
-                "sha256:9abcf56a9511653fa1d052bfc55fbe53dbee8f34e68bd6a5a038731b0ca42d15",
-                "sha256:9bbf7bd39822fd07e3609b6b4467af4c404dd2b88ee314837ad1830a7f4a8299",
-                "sha256:9c17341ee04545fd962ae07330cb5a39977294c883485c8d74634669b1f7fe04",
-                "sha256:9f193eeda1857f8e8d3079a4abd258f42ef4a4bc87388452ed1e1c4d2b0c8740",
-                "sha256:9faf1b1dcaadf9f900d23a0e6d6c8eadd6a95795a0e57fcca73acce0eb912065",
-                "sha256:9fcad2945b1b91c29ef2b4050f590bfcb68d8ac8e0995a74e659aa57e8d78e01",
-                "sha256:a145c550900deb7540973c5cdb183b0d24bed6b80bf7bddf33ed8f569082535e",
-                "sha256:a4d1cb1327c6082c4fce4e2a438483390964c02213bc6b8d782cf782c9b1471f",
-                "sha256:a887b77f51d3d41e6e1a63cf3bc7ddf24de5939d9ff69441387dfefa58ac2e26",
-                "sha256:a920f9cf2abdf6e493c519492d892c362007f113c94da4c239ae88429835bad1",
-                "sha256:aff4cafea2d120327d55eadd6b7f1136a8e5a0ecf6fb3b6863e8aca32cd8e50a",
-                "sha256:b0f1987787f5f1e2076b59692352ab29a955b09ccc433c1f6b8e8e18666f608b",
-                "sha256:b308402608493638763abc95f9dc0030bbd6ac6aff784512e8ac3da73a88af08",
-                "sha256:b61e98c3e2a861035aaccd207da585bdcacef65fe01d7a0d07478efac005e028",
-                "sha256:b9eb4c59c54421a32b3273d4239865cb14ead53a606db066d7130ac80cc8ec93",
-                "sha256:ba852168d814b2c73333073e1c7116d9395bea69575a01b0b3c89d2d5a87c8fb",
-                "sha256:bb5ac9e5bfce0e6282e7f59ff7b7b9a74aa8e5c60d38186a4637f5aa764046ad",
-                "sha256:bb61ffd3ab8310d93427e460f565322c44ef12769f51f77277b4abad7b6f7223",
-                "sha256:bbfcb60396f9bcfa63e017a180c3105b8c123a63e9d1428a36544e7d37ca9e20",
-                "sha256:bd4557071b561a8b3b6075c3ce93cf9bfb6182cb241805c3d66ced3b75eff4ac",
-                "sha256:be06e73c06415199200e9a2324a11252a3d62030319919cde5e6950ffeccf72e",
-                "sha256:c04157266344158ebd57b7120d9b0b35812285d26d0e78193e17ef57bfe2979a",
-                "sha256:c10d17371bff801af0daf8b073c30b6cf14215784dc08cd5c43ab5b7b8029bbc",
-                "sha256:c27e5dcf520923d6474d98b96749e6805f7677e93aaaf62656005b8643f907ab",
-                "sha256:c93a6fb06cc8e5d3628b2b5fda215a5db01e8f08fc15fadd65662d9b857acbe4",
-                "sha256:cbebaa076aaecad3d4bb4c008ecc73b09274c952cf6a1b78ccfd689e51f5a5b0",
-                "sha256:cc5d83c6619ca5c9672cb78b39ed8542f1975a803dee2cda114ff73cbb076edd",
-                "sha256:d1a20707492db9719a05fc62ee215fd2c29b22b47c1b1ba347f9abc831e26683",
-                "sha256:d1f7cbd4f1f44ddf5fd86a8675b7679176eae770f2fc88115d6dddb6cefb59bc",
-                "sha256:d21c1212171cf7da703c5b0b7a0e85be23b720818aef502ad187d627316d5645",
-                "sha256:d2fa86af59f8fc1972e121ade052145f6da22758f6996a197d69bb52f8204e7e",
-                "sha256:d5b1cc3ab8c31d9ebf0faa6e3540fb91257590da330ffe6d2393d4208e638925",
-                "sha256:d693307856d1ef08041e8b6ff01d5b4618715007d288490ce2c7e29013c12b9a",
-                "sha256:d6b15c55721b1b115c5ba178c77104123745b1417527ad9641a4c5e2047450f0",
-                "sha256:d832c608f94b9f92a0ec8b7e949be7792a642b6e535fcf32f3e28fab69eeb046",
-                "sha256:d83f18315b9fca5db2452d1881ef20f79593c4aa824095b62cb280019ef7aa3d",
-                "sha256:d877447e7368c7320832acb7159557e49b21ea10ffeb135c1077dbbc0816b598",
-                "sha256:dc388f75a1c00000824bf28b7633e40854f4127ede80512b44c3cfeeea1839a2",
-                "sha256:dc8c9736d8574b560634775ac0def6bdc1661fc63fa27ffdfc7264c565bcb4f2",
-                "sha256:e32053d6d3a8b0dfe49fde05b496731a0e6099a4df92154641c00aa76786aef5",
-                "sha256:e5f8a146184da7ea12910a4cec51ef85e44f6268467fb489c3caf0cd512f29c2",
-                "sha256:ecde56ea2439b96ed8a8d826b50c57364612ddac0438c39e473fafad7ae1c23b",
-                "sha256:f682c42003c7264134bfe886376299db4cc0c6cd06a3295b41b347044bcb5482",
-                "sha256:fad6daaed41021934917f4fb03ca2db8d8a4d79bf89b17ebe77228eb6710c003",
-                "sha256:fc60f91c02e11dfbe3ff4e1219c085695c339af72d1641800fe6075b91850c8f"
+                "sha256:03ca744319864e92721195fa28c7a3b2bc7b686246b35e4078c1e4d0eb5466d3",
+                "sha256:040f393368e63fb0f3330e70c26bfd336656bed925e5cbe17c9da839a6ab13ec",
+                "sha256:05047ada7a2fde2631a0ed706f1fd68b169a681dfe5e4cf0f8e4cb6618bbc2cd",
+                "sha256:0591b48acf279821a579282444814a2d8d0af624ae0bc600aa4d1b920b6e924b",
+                "sha256:07f5594ac6d084cbb5de2df218d78baf55ef150b91f0ff8a21cc7a2e3a5a58eb",
+                "sha256:08325c9e5367aa379a3496aa9a022fe8837ff22e00b94db256d3a1378c76ab32",
+                "sha256:08d4379f9744d8f78d98c8673c06e202ffa88296f009c71bbafe8a6bf847d01f",
+                "sha256:0934f3843a1860dd465d38895c17fce1f1cb37295149ab05cd1b9a03afacb2a7",
+                "sha256:096f52730c3fb8ed419db2d44391932b63891b2c5ed14850a7e215c0ba9ade36",
+                "sha256:09929cab6fcb68122776d575e03c6cc64ee0b8fca48d17e135474b042ce515cd",
+                "sha256:0a13fb8e748dfc94749f622de065dd5c1def7e0d2216dba72b1d8069a389c6ff",
+                "sha256:0db4956f82723cc1c270de9c6e799b4c341d327762ec78ef82bb962f79cc07d8",
+                "sha256:123e2a72e20537add2f33a79e605f6191fba2afda4cbb876e35c1a7074298a7d",
+                "sha256:14c9e076eede3b54c636f8ce1c9c252b5f057c62131211f0ceeec273810c9721",
+                "sha256:171b73bd4ee683d307599b66793ac80981b06f069b62eea1c9e29c9241aa66b0",
+                "sha256:18706cc31dbf402a7945916dd5cddf160251b6dab8a2c5f3d6d5a55949f676b3",
+                "sha256:19a1d55338ec1be74ef62440ca9e04a2f001a04d0cc49a4983dc320ff0f3212d",
+                "sha256:2049be98fb57a31b4ccf870bf377af2504d4ae35646a19037ec271e4c07998aa",
+                "sha256:2090d3718829d1e484706a2f525e50c892237b2bf9b17a79b059cb98cddc2f10",
+                "sha256:2397ab4daaf2698eb51a76721e98db21ce4f52339e535725de03ea962b5a3202",
+                "sha256:23bfeee5316266e5ee2d625df2d2c602b829435fc3a235c2ba2131495706e4a0",
+                "sha256:27e0b36c2d388dc7b6ced3406671b401e84ad7eb0656b8f3a2f46ed0ce483718",
+                "sha256:28b37063541b897fd6a318007373930a75ca6d6ac7c940dbe14731ffdd8d498e",
+                "sha256:295a92a76188917c7f99cda95858c822f9e4aae5824246bba9b6b44004ddd0a6",
+                "sha256:29fe6740ebccba4175af1b9b87bf553e9c15cd5868ee967e010efcf94e4fd0f1",
+                "sha256:2a7baa46a22e77f0988e3b23d4ede5513ebec1929e34ee9495be535662c0dfe2",
+                "sha256:2d2cfeec3f6f45651b3d408c4acec0ebf3daa9bc8a112a084206f5db5d05b754",
+                "sha256:2f67396ec0310764b9222a1728ced1ab638f61aadc6226f17a71dd9324f9a99c",
+                "sha256:30d193c6cc6d559db42b6bcec8a5d395d34d60c9877a0b71ecd7c204fcf15390",
+                "sha256:31bae522710064b5cbeddaf2e9f32b1abab70ac6ac91d42572502299e9953128",
+                "sha256:329aa225b085b6f004a4955271a7ba9f1087e39dcb7e65f6284a988264a63912",
+                "sha256:363eb68a0a59bd2303216d2346e6c441ba10d36d1f9969fcb6f1ba700de7bb5c",
+                "sha256:394fc5c42a333c9ffc3e421a4c85e08580d990e08b99f6bf35b4132114c5dcb3",
+                "sha256:3996b50c3237c4aec17459217c1e7bbdead9a22a0fcd3c365564fbd16439dde6",
+                "sha256:39f1719f57adbb767ef592a50ae5ebb794220d1188f9ca93de471336401c34d2",
+                "sha256:3b29b980d0ddbecb736735ee5bef69bb2ddca56eff603c86f3f29a1128299b4f",
+                "sha256:3ba3ef510467abb0667421a286dc906e30eb08569365f5cdb131d7aff7c2dd84",
+                "sha256:3bab1e4aff7adaa34410f93b1f8e57c4b36b9af0426a76003f441ee1d3c7e842",
+                "sha256:3d7b6ccce016e29df4b7ca819659f516f0bc7a4b3efa3bb2012ba06431b044f9",
+                "sha256:3da4fb467498df97e986af166b12d01f05d2e04f978a9c1c680ea1988e0bc4b6",
+                "sha256:3e56d780c238f9e1ae66a22d2adf8d16f485381878250db8d496623cd38b22bd",
+                "sha256:3e8bfdd0e487acf992407a140d2589fe598238eaeffa3da8448d63a63cd363f8",
+                "sha256:44b546bd3eb645fd26fb949e43c02a25a2e632e2ca21a35e2e132c8105dc8599",
+                "sha256:478cc36476687bac1514d651cbbaa94b86b0732fb6855c60c673794c7dd2da62",
+                "sha256:490dab541a6a642ce1a9d61a4781656b346a55c13038f0b1244653828e3a83ec",
+                "sha256:4a0df7ff02397bb63e2fd22af2c87dfa39e8c7f12947bc524dbdc528282c7e34",
+                "sha256:4b73189894398d59131a66ff157837b1fafea9974be486d036bb3d32331fdbf0",
+                "sha256:4b7a9db5a870f780220e931d0002bbfd88fb53aceb6293251e2c839415c1b20e",
+                "sha256:4c09703000a9d0fa3c3404b27041e574cc7f4df4c6563873246d0e11812a94b6",
+                "sha256:4d409aa42a94c0b3fa617708ef5276dfe81012ba6753a0370fcc9d0195d0a1fc",
+                "sha256:4d72a9a2d885f5c208b0cb91ff2ed43636bb7e345ec839ff64708e04f69a13cc",
+                "sha256:4ef089f985b8c194d341eb2c24ae6e7408c9a0e2e5658699c92f497437d88c3c",
+                "sha256:51cb455de290ae462593e5b1cb1118c5c22ea7f0d3620d9940bf695cea5a4bd7",
+                "sha256:521f33e377ff64b96c4c556b81c55d0cfffb96a11c194fd0c3f1e56f3d8dd5a4",
+                "sha256:53a42d364f323275126aff81fb67c5ca1b7a04fda0546245730a55c8c5f24bc4",
+                "sha256:5aa873cbc8e593d361ae65c68f85faadd755c3295ea2c12040ee146802f23b38",
+                "sha256:654030da3197d927f05a536a66186070e98765aa5142794c9904555d3a9d8fb5",
+                "sha256:661709cdcd919a2ece2234f9bae7174e5220c80b034585d7d8a755632d3e2111",
+                "sha256:680878b9f3d45c31e1f730eef731f9b0bc1da456155688c6745ee84eb818e90e",
+                "sha256:6843b28b0364dc605f21481c90fadb5f60d9123b442eb8a726bb74feef588a84",
+                "sha256:68af405971779d8b37198726f2b6fe3955db846fee42db7a4286fc542203934c",
+                "sha256:6b4c3d199f953acd5b446bf7c0de1fe25d94e09e79086f8dc2f48a11a129cdf1",
+                "sha256:6bdce131e14b04fd34a809b6380dbfd826065c3e2fe8a50dbae659fa0c390546",
+                "sha256:716133f7d1d946a4e1b91b1756b23c088881e70ff180c24e864c26192ad7534a",
+                "sha256:749a72584761531d2b9467cfbdfd29487ee21124c304c4b6cb760d8777b27f9c",
+                "sha256:7516c579652f6a6be0e266aec0acd0db80829ca305c3d771ed898538804c2036",
+                "sha256:79dcf9e477bc65414ebfea98ffd013cb39552b5ecd62908752e0e413d6d06e38",
+                "sha256:7a0222514e8e4c514660e182d5156a415c13ef0aabbd71682fc714e327b95e99",
+                "sha256:7b022717c748dd1992a83e219587aabe45980d88969f01b316e78683e6285f64",
+                "sha256:7bf77f54997a9166a2f5675d1201520586439424c2511723a7312bdb4bcc034e",
+                "sha256:7e73299c99939f089dd9b2120a04a516b95cdf8c1cd2b18c53ebf0de80b1f18f",
+                "sha256:7ef6b61cad77091056ce0e7ce69814ef72afacb150b7ac6a3e9470def2198159",
+                "sha256:7f5170993a0dd3ab871c74f45c0a21a4e2c37a2f2b01b5f722a2ad9c6650469e",
+                "sha256:803d685de7be4303b5a657b76e2f6d1240e7e0a8aa2968ad5811fa2285553a12",
+                "sha256:8891681594162635948a636c9fe0ff21746aeb3dd5463f6e25d9bea3a8a39ca1",
+                "sha256:8a19cdb57cd3df4cd865849d93ee14920fb97224300c88501f16ecfa2604b4e0",
+                "sha256:8a3862568a36d26e650a19bb5cbbba14b71789032aebc0423f8cc5f150730184",
+                "sha256:8b55d5497b51afdfde55925e04a022f1de14d4f4f25cdfd4f5d9b0aa96166851",
+                "sha256:8cfc12a8630a29d601f48d47787bd7eb730e475e83edb5d6c5084317463373eb",
+                "sha256:9281bf5b34f59afbc6b1e477a372e9526b66ca446f4bf62592839c195a718b32",
+                "sha256:92abb658ef2d7ef22ac9f8bb88e8b6c3e571671534e029359b6d9e845923eb1b",
+                "sha256:94218fcec4d72bc61df51c198d098ce2b378e0ccbac41ddbed5ef44092913288",
+                "sha256:95b5ffa4349df2887518bb839409bcf22caa72d82beec453216802f475b23c81",
+                "sha256:9600082733859f00d79dee64effc7aef1beb26adb297416a4ad2116fd61374bd",
+                "sha256:960c60b5849b9b4f9dcc9bea6e3626143c252c74113df2c1540aebce70209b45",
+                "sha256:9b2fd74c52accced7e75de26023b7dccee62511a600e62311b918ec5c168fc2a",
+                "sha256:9c0359b1ec12b1d6849c59f9d319610b7f20ef990a6d454ab151aa0e3b9f78ca",
+                "sha256:9cf41880c991716f3c7cec48e2f19ae4045fc9db5fc9cff27347ada24d710bb5",
+                "sha256:9d14baca2ee12c1a64740d4531356ba50b82543017f3ad6de0deb943c5979abb",
+                "sha256:9f474ad5acda359c8758c8accc22032c6abe6dc87a8be2440d097785e27a9349",
+                "sha256:9fb0211dfc3b51efea2f349ec92c114d7754dd62c01f81c3e32b765b70c45c9b",
+                "sha256:9fe04da3f79387f450fd0061d4dd2e45a72749d31bf634aecc9e27f24fdc4b3f",
+                "sha256:9ff96e8815eecacc6645da76c413eb3b3d34cfca256c70b16b286a687d013c32",
+                "sha256:a027ec240fe73a8d6281872690b988eed307cd7d91b23998ff35ff577ca688b5",
+                "sha256:a048ce45dcdaaf1defb76b2e684f997fb5abf74437b6cb7b22ddad934a964e34",
+                "sha256:a265acbb7bb33a3a2d626afbe756371dce0279e7b17f4f4eda406459c2b5ff1c",
+                "sha256:a35c5fc61d4f51eb045061e7967cfe3123d622cd500e8868e7c0c592a09fedc4",
+                "sha256:a37bd74c3fa9d00be2d7b8eca074dc56bd8077ddd2917a839bd989612671ed17",
+                "sha256:a60a4d75718a5efa473ebd5ab685786ba0c67b8381f781d1be14da49f1a2dc60",
+                "sha256:a6ef16328011d3f468e7ebc326f24c1445f001ca1dec335b2f8e66bed3006394",
+                "sha256:a90af66facec4cebe4181b9e62a68be65e45ac9b52b67de9eec118701856e7ff",
+                "sha256:ad9ce259f50abd98a1ca0aa6e490b58c316a0fce0617f609723e40804add2c00",
+                "sha256:afa8a2978ec65d2336305550535c9c4ff50ee527914328c8677b3973ade52b85",
+                "sha256:b15b3afff74f707b9275d5ba6a91ae8f6429c3ffb29bbfd216b0b375a56f13d7",
+                "sha256:b284e319754366c1aee2267a2036248b24eeb17ecd5dc16022095e747f2f4304",
+                "sha256:b2d7f80c4e1fd010b07cb26820aae86b7e73b681ee4889684fb8d2d4537aab13",
+                "sha256:b3bc26a951007b1057a1c543af845f1c7e3e71cc240ed1ace7bf4484aa99196e",
+                "sha256:b3e34f3a1b8131ba06f1a73adab24f30934d148afcd5f5de9a73565a4404384e",
+                "sha256:b4121773c49a0776461f4a904cdf6264c88e42218aaa8407e803ca8025872792",
+                "sha256:b61189b29081a20c7e4e0b49b44d5d44bb0dc92be3c6d06a11cc043f81bf9329",
+                "sha256:b6234e14f9314731ec45c42fc4554b88133ad53a09092cc48a88e771c125dadb",
+                "sha256:b8512bac933afc3e45fb2b18da8e59b78d4f408399a960339598374d4ae3b56b",
+                "sha256:ba672b26069957ee369cfa7fc180dde1fc6f176eaf1e6beaf61fbebbd3d9c000",
+                "sha256:bee7c0588aa0076ce77c0ea5d19a68d76ad81fcd9fe8501003b9a24f9d4000f6",
+                "sha256:c04a328260dfd5db8c39538f999f02779012268f54614902d0afc775d44e0a62",
+                "sha256:c1dcc7524066fa918c6a27d61444d4ee7900ec635779058571f70d042d86ed63",
+                "sha256:c6e99d9a65ca282e578dfea819cfa9c0a62b2499d8677392e09feaf305e9e6f5",
+                "sha256:ca43bdfa5d37bd6aee89d85e1d0831fb86e25541be7e9d376ead1b28974f8e5e",
+                "sha256:caf53b15b1b7df9fbd0709aa01409000a2b4dd03a5f6f5cc548183c7c8f8b63c",
+                "sha256:cc41db090ed742f32bd2d2c721861725e6109681eddf835d0a82bd3a5c382827",
+                "sha256:cd240939f71c64bd658f186330603aac1a9a81bf6273f523fca63673cb7378a8",
+                "sha256:ce8fdc2dca699f8dbf055a61d73eaa10482569ad20ee3c36ef9641f69afa8c91",
+                "sha256:d1bed1b467ef657f2a0ae62844a607909ef1c6889562de5e1d505f74457d0b96",
+                "sha256:d1d964afecdf3a8288789df2f5751dc0a8261138c3768d9af117ed384e538fad",
+                "sha256:d4393e3581e84e5645506923816b9cc81f5609a778c7e7534054091acc64d1c6",
+                "sha256:d874eb056410ca05fed180b6642e680373688efafc7f077b2a2f61811e873a40",
+                "sha256:db99677b4457c7a5c5a949353e125ba72d62b35f74e26da141530fbb012218a7",
+                "sha256:dd32a49400a2c3d52088e120ee00c1e3576cbff7e10b98467962c74fdb762ed4",
+                "sha256:df0e3bf7993bdbeca5ac25aa859cf40d39019e015c9c91809ba7093967f7a648",
+                "sha256:e011555abada53f1578d63389610ac8a5400fc70ce71156b0aa30d326f1a5064",
+                "sha256:e2862408c99f84aa571ab462d25236ef9cb12a602ea959ba9c9009a54902fc73",
+                "sha256:e3aa16de190d29a0ea1b48253c57d99a68492c8dd8948638073ab9e74dc9410b",
+                "sha256:e93a0617cd16998784bf4414c7e40f17a35d2350e5c6f0bd900d3a8e02bd3762",
+                "sha256:ea3334cabe4d41b7ccd01e4d349828678794edbc2d3ae97fc162a3312095092e",
+                "sha256:eb866162ef2f45063acc7a53a88ef6fe8bf121d45c30ea3c9cd87ce7e191a8d4",
+                "sha256:ec81878ddf0e98817def1e77d4f50dae5ef5b0e4fe796fae3bd674304172416e",
+                "sha256:efbb54e98446892590dc2458c19c10344ee9a883a79b5cec4bc34d6656e8d546",
+                "sha256:f0e77e3c0008bc9316e662624535b88d360c3a5d3f81e15cf12c139a75250046",
+                "sha256:f0feece2ef8ebc42ed9e2e8c78fc4aa3cf455733b507c09ef7406364c94376c6",
+                "sha256:f470f68adc395e0183b92a2f4689264d1ea4b40504a24d9882c27375e6662bb9",
+                "sha256:f844a1bbf1d207dd311a56f383f7eda2d0e134921d45751842d8235e7778965d",
+                "sha256:f8a93b1c0ed2d04b97a5e9336fd2d33371b9a6e29ab7dd6503d63407c20ffbaf",
+                "sha256:f8e5c0031b90ca9ce555e2e8fd5c3b02a25f14989cbc310701823832c99eb687",
+                "sha256:fb287618b9c7aa3bf8d825f02d9201b2f13078a5ed3b293c8f4d953917d84d5e",
+                "sha256:fbafe31d191dfa7c4c51f7a6149c9fb7e914dcf9ffead27dcfd9f1ae382b3885",
+                "sha256:fbd18dc82d7bf274b37aa48d664534330af744e03bccf696d6f4c6042e7d19e7"
             ],
             "markers": "python_version >= '3.9'",
-            "version": "==6.4.4"
+            "version": "==6.7.0"
         },
         "propcache": {
             "hashes": [
-                "sha256:035e631be25d6975ed87ab23153db6a73426a48db688070d925aa27e996fe93c",
-                "sha256:03c89c1b14a5452cf15403e291c0ccd7751d5b9736ecb2c5bab977ad6c5bcd81",
-                "sha256:06766d8f34733416e2e34f46fea488ad5d60726bb9481d3cddf89a6fa2d9603f",
-                "sha256:0a2f2235ac46a7aa25bdeb03a9e7060f6ecbd213b1f9101c43b3090ffb971ef6",
-                "sha256:0b504d29f3c47cf6b9e936c1852246c83d450e8e063d50562115a6be6d3a2535",
-                "sha256:0b8d2f607bd8f80ddc04088bc2a037fdd17884a6fcadc47a96e334d72f3717be",
-                "sha256:0cc17efde71e12bbaad086d679ce575268d70bc123a5a71ea7ad76f70ba30bba",
-                "sha256:0d0fda578d1dc3f77b6b5a5dce3b9ad69a8250a891760a548df850a5e8da87f3",
-                "sha256:156c03d07dc1323d8dacaa221fbe028c5c70d16709cdd63502778e6c3ccca1b0",
-                "sha256:1f43837d4ca000243fd7fd6301947d7cb93360d03cd08369969450cc6b2ce3b4",
-                "sha256:20d7d62e4e7ef05f221e0db2856b979540686342e7dd9973b815599c7057e168",
-                "sha256:2183111651d710d3097338dd1893fcf09c9f54e27ff1a8795495a16a469cc90b",
-                "sha256:21d8759141a9e00a681d35a1f160892a36fb6caa715ba0b832f7747da48fb6ea",
-                "sha256:22d9962a358aedbb7a2e36187ff273adeaab9743373a272976d2e348d08c7770",
-                "sha256:261df2e9474a5949c46e962065d88eb9b96ce0f2bd30e9d3136bcde84befd8f2",
-                "sha256:261fa020c1c14deafd54c76b014956e2f86991af198c51139faf41c4d5e83892",
-                "sha256:28710b0d3975117239c76600ea351934ac7b5ff56e60953474342608dbbb6154",
-                "sha256:2a4092e8549031e82facf3decdbc0883755d5bbcc62d3aea9d9e185549936dcf",
-                "sha256:2ca6d378f09adb13837614ad2754fa8afaee330254f404299611bce41a8438cb",
-                "sha256:310d11aa44635298397db47a3ebce7db99a4cc4b9bbdfcf6c98a60c8d5261cf1",
-                "sha256:31248e44b81d59d6addbb182c4720f90b44e1efdc19f58112a3c3a1615fb47ef",
-                "sha256:34a624af06c048946709f4278b4176470073deda88d91342665d95f7c6270fbe",
-                "sha256:36c8d9b673ec57900c3554264e630d45980fd302458e4ac801802a7fd2ef7897",
-                "sha256:3def3da3ac3ce41562d85db655d18ebac740cb3fa4367f11a52b3da9d03a5cc3",
-                "sha256:404d70768080d3d3bdb41d0771037da19d8340d50b08e104ca0e7f9ce55fce70",
-                "sha256:4445542398bd0b5d32df908031cb1b30d43ac848e20470a878b770ec2dcc6330",
-                "sha256:46d7f8aa79c927e5f987ee3a80205c987717d3659f035c85cf0c3680526bdb44",
-                "sha256:4927842833830942a5d0a56e6f4839bc484785b8e1ce8d287359794818633ba0",
-                "sha256:4adfb44cb588001f68c5466579d3f1157ca07f7504fc91ec87862e2b8e556b88",
-                "sha256:4ba3fef1c30f306b1c274ce0b8baaa2c3cdd91f645c48f06394068f37d3837a1",
-                "sha256:4c1396592321ac83157ac03a2023aa6cc4a3cc3cfdecb71090054c09e5a7cce3",
-                "sha256:4c181cad81158d71c41a2bce88edce078458e2dd5ffee7eddd6b05da85079f43",
-                "sha256:54e02207c79968ebbdffc169591009f4474dde3b4679e16634d34c9363ff56b4",
-                "sha256:55780d5e9a2ddc59711d727226bb1ba83a22dd32f64ee15594b9392b1f544eb1",
-                "sha256:55ffda449a507e9fbd4aca1a7d9aa6753b07d6166140e5a18d2ac9bc49eac220",
-                "sha256:5745bc7acdafa978ca1642891b82c19238eadc78ba2aaa293c6863b304e552d7",
-                "sha256:59d61f6970ecbd8ff2e9360304d5c8876a6abd4530cb752c06586849ac8a9dc9",
-                "sha256:5f559e127134b07425134b4065be45b166183fdcb433cb6c24c8e4149056ad50",
-                "sha256:5f57aa0847730daceff0497f417c9de353c575d8da3579162cc74ac294c5369e",
-                "sha256:6107ddd08b02654a30fb8ad7a132021759d750a82578b94cd55ee2772b6ebea2",
-                "sha256:62180e0b8dbb6b004baec00a7983e4cc52f5ada9cd11f48c3528d8cfa7b96a66",
-                "sha256:62b4239611205294cc433845b914131b2a1f03500ff3c1ed093ed216b82621e1",
-                "sha256:64a67fb39229a8a8491dd42f864e5e263155e729c2e7ff723d6e25f596b1e8cb",
-                "sha256:6d8f3f0eebf73e3c0ff0e7853f68be638b4043c65a70517bb575eff54edd8dbe",
-                "sha256:7046e79b989d7fe457bb755844019e10f693752d169076138abf17f31380800c",
-                "sha256:70bd8b9cd6b519e12859c99f3fc9a93f375ebd22a50296c3a295028bea73b9e7",
-                "sha256:7435d766f978b4ede777002e6b3b6641dd229cd1da8d3d3106a45770365f9ad9",
-                "sha256:74413c0ba02ba86f55cf60d18daab219f7e531620c15f1e23d95563f505efe7e",
-                "sha256:76cace5d6b2a54e55b137669b30f31aa15977eeed390c7cbfb1dafa8dfe9a701",
-                "sha256:7a2368eed65fc69a7a7a40b27f22e85e7627b74216f0846b04ba5c116e191ec9",
-                "sha256:7a4f30862869fa2b68380d677cc1c5fcf1e0f2b9ea0cf665812895c75d0ca3b8",
-                "sha256:7ca3aee1aa955438c4dba34fc20a9f390e4c79967257d830f137bd5a8a32ed3b",
-                "sha256:7f08f1cc28bd2eade7a8a3d2954ccc673bb02062e3e7da09bc75d843386b342f",
-                "sha256:85871b050f174bc0bfb437efbdb68aaf860611953ed12418e4361bc9c392749e",
-                "sha256:8a08154613f2249519e549de2330cf8e2071c2887309a7b07fb56098f5170a02",
-                "sha256:8a544caaae1ac73f1fecfae70ded3e93728831affebd017d53449e3ac052ac1e",
-                "sha256:8cabf5b5902272565e78197edb682017d21cf3b550ba0460ee473753f28d23c1",
-                "sha256:8de106b6c84506b31c27168582cd3cb3000a6412c16df14a8628e5871ff83c10",
-                "sha256:92b69e12e34869a6970fd2f3da91669899994b47c98f5d430b781c26f1d9f387",
-                "sha256:9704bedf6e7cbe3c65eca4379a9b53ee6a83749f047808cbb5044d40d7d72198",
-                "sha256:98f1ec44fb675f5052cccc8e609c46ed23a35a1cfd18545ad4e29002d858a43f",
-                "sha256:9a3cf035bbaf035f109987d9d55dc90e4b0e36e04bbbb95af3055ef17194057b",
-                "sha256:9bec58347a5a6cebf239daba9bda37dffec5b8d2ce004d9fe4edef3d2815137e",
-                "sha256:9da1cf97b92b51253d5b68cf5a2b9e0dafca095e36b7f2da335e27dc6172a614",
-                "sha256:9ecb0aad4020e275652ba3975740f241bd12a61f1a784df044cf7477a02bc252",
-                "sha256:a2dc1f4a1df4fecf4e6f68013575ff4af84ef6f478fe5344317a65d38a8e6dc9",
-                "sha256:a7fad897f14d92086d6b03fdd2eb844777b0c4d7ec5e3bac0fbae2ab0602bbe5",
-                "sha256:ab50cef01b372763a13333b4e54021bdcb291fc9a8e2ccb9c2df98be51bcde6c",
-                "sha256:abb7fa19dbf88d3857363e0493b999b8011eea856b846305d8c0512dfdf8fbb1",
-                "sha256:acdf05d00696bc0447e278bb53cb04ca72354e562cf88ea6f9107df8e7fd9770",
-                "sha256:aff2e4e06435d61f11a428360a932138d0ec288b0a31dd9bd78d200bd4a2b339",
-                "sha256:b77ec3c257d7816d9f3700013639db7491a434644c906a2578a11daf13176251",
-                "sha256:bca54bd347a253af2cf4544bbec232ab982f4868de0dd684246b67a51bc6b1db",
-                "sha256:be29c4f4810c5789cf10ddf6af80b041c724e629fa51e308a7a0fb19ed1ef7bf",
-                "sha256:c0075bf773d66fa8c9d41f66cc132ecc75e5bb9dd7cce3cfd14adc5ca184cb95",
-                "sha256:c144ca294a204c470f18cf4c9d78887810d04a3e2fbb30eea903575a779159df",
-                "sha256:c5c2a784234c28854878d68978265617aa6dc0780e53d44b4d67f3651a17a9a2",
-                "sha256:ca592ed634a73ca002967458187109265e980422116c0a107cf93d81f95af945",
-                "sha256:cab90ac9d3f14b2d5050928483d3d3b8fb6b4018893fc75710e6aa361ecb2474",
-                "sha256:cc2782eb0f7a16462285b6f8394bbbd0e1ee5f928034e941ffc444012224171b",
-                "sha256:ce26862344bdf836650ed2487c3d724b00fbfec4233a1013f597b78c1cb73615",
-                "sha256:ce2ac2675a6aa41ddb2a0c9cbff53780a617ac3d43e620f8fd77ba1c84dcfc06",
-                "sha256:d1a342c834734edb4be5ecb1e9fb48cb64b1e2320fccbd8c54bf8da8f2a84c33",
-                "sha256:d4a996adb6904f85894570301939afeee65f072b4fd265ed7e569e8d9058e4ec",
-                "sha256:d81ac3ae39d38588ad0549e321e6f773a4e7cc68e7751524a22885d5bbadf886",
-                "sha256:db429c19a6c7e8a1c320e6a13c99799450f411b02251fb1b75e6217cf4a14fcb",
-                "sha256:df4a81b9b53449ebc90cc4deefb052c1dd934ba85012aa912c7ea7b7e38b60c1",
-                "sha256:e41671f1594fc4ab0a6dec1351864713cb3a279910ae8b58f884a88a0a632c05",
-                "sha256:e514326b79e51f0a177daab1052bc164d9d9e54133797a3a58d24c9c87a3fe6d",
-                "sha256:e53af8cb6a781b02d2ea079b5b853ba9430fcbe18a8e3ce647d5982a3ff69f39",
-                "sha256:ee6f22b6eaa39297c751d0e80c0d3a454f112f5c6481214fcf4c092074cecd67",
-                "sha256:eef914c014bf72d18efb55619447e0aecd5fb7c2e3fa7441e2e5d6099bddff7e",
-                "sha256:f066b437bb3fa39c58ff97ab2ca351db465157d68ed0440abecb21715eb24b28",
-                "sha256:f1304b085c83067914721e7e9d9917d41ad87696bf70f0bc7dee450e9c71ad0a",
-                "sha256:f86e5d7cd03afb3a1db8e9f9f6eff15794e79e791350ac48a8c924e6f439f394",
-                "sha256:fad3b2a085ec259ad2c2842666b2a0a49dea8463579c606426128925af1ed725",
-                "sha256:fb075ad271405dcad8e2a7ffc9a750a3bf70e533bd86e89f0603e607b93aa64c",
-                "sha256:fd3e6019dc1261cd0291ee8919dd91fbab7b169bb76aeef6c716833a3f65d206"
+                "sha256:0002004213ee1f36cfb3f9a42b5066100c44276b9b72b4e1504cddd3d692e86e",
+                "sha256:0013cb6f8dde4b2a2f66903b8ba740bdfe378c943c4377a200551ceb27f379e4",
+                "sha256:005f08e6a0529984491e37d8dbc3dd86f84bd78a8ceb5fa9a021f4c48d4984be",
+                "sha256:031dce78b9dc099f4c29785d9cf5577a3faf9ebf74ecbd3c856a7b92768c3df3",
+                "sha256:05674a162469f31358c30bcaa8883cb7829fa3110bf9c0991fe27d7896c42d85",
+                "sha256:060b16ae65bc098da7f6d25bf359f1f31f688384858204fe5d652979e0015e5b",
+                "sha256:120c964da3fdc75e3731aa392527136d4ad35868cc556fd09bb6d09172d9a367",
+                "sha256:15932ab57837c3368b024473a525e25d316d8353016e7cc0e5ba9eb343fbb1cf",
+                "sha256:17612831fda0138059cc5546f4d12a2aacfb9e47068c06af35c400ba58ba7393",
+                "sha256:182b51b421f0501952d938dc0b0eb45246a5b5153c50d42b495ad5fb7517c888",
+                "sha256:1cdb7988c4e5ac7f6d175a28a9aa0c94cb6f2ebe52756a3c0cda98d2809a9e37",
+                "sha256:1eb2994229cc8ce7fe9b3db88f5465f5fd8651672840b2e426b88cdb1a30aac8",
+                "sha256:1f0978529a418ebd1f49dad413a2b68af33f85d5c5ca5c6ca2a3bed375a7ac60",
+                "sha256:204483131fb222bdaaeeea9f9e6c6ed0cac32731f75dfc1d4a567fc1926477c1",
+                "sha256:296f4c8ed03ca7476813fe666c9ea97869a8d7aec972618671b33a38a5182ef4",
+                "sha256:2ad890caa1d928c7c2965b48f3a3815c853180831d0e5503d35cf00c472f4717",
+                "sha256:2b16ec437a8c8a965ecf95739448dd938b5c7f56e67ea009f4300d8df05f32b7",
+                "sha256:2bb07ffd7eaad486576430c89f9b215f9e4be68c4866a96e97db9e97fead85dc",
+                "sha256:333ddb9031d2704a301ee3e506dc46b1fe5f294ec198ed6435ad5b6a085facfe",
+                "sha256:357f5bb5c377a82e105e44bd3d52ba22b616f7b9773714bff93573988ef0a5fb",
+                "sha256:35c3277624a080cc6ec6f847cbbbb5b49affa3598c4535a0a4682a697aaa5c75",
+                "sha256:364426a62660f3f699949ac8c621aad6977be7126c5807ce48c0aeb8e7333ea6",
+                "sha256:381914df18634f5494334d201e98245c0596067504b9372d8cf93f4bb23e025e",
+                "sha256:3d233076ccf9e450c8b3bc6720af226b898ef5d051a2d145f7d765e6e9f9bcff",
+                "sha256:3d902a36df4e5989763425a8ab9e98cd8ad5c52c823b34ee7ef307fd50582566",
+                "sha256:3f7124c9d820ba5548d431afb4632301acf965db49e666aa21c305cbe8c6de12",
+                "sha256:405aac25c6394ef275dee4c709be43745d36674b223ba4eb7144bf4d691b7367",
+                "sha256:41a89040cb10bd345b3c1a873b2bf36413d48da1def52f268a055f7398514874",
+                "sha256:43eedf29202c08550aac1d14e0ee619b0430aaef78f85864c1a892294fbc28cf",
+                "sha256:473c61b39e1460d386479b9b2f337da492042447c9b685f28be4f74d3529e566",
+                "sha256:49a2dc67c154db2c1463013594c458881a069fcf98940e61a0569016a583020a",
+                "sha256:4b536b39c5199b96fc6245eb5fb796c497381d3942f169e44e8e392b29c9ebcc",
+                "sha256:4c3c70630930447f9ef1caac7728c8ad1c56bc5015338b20fed0d08ea2480b3a",
+                "sha256:4d3df5fa7e36b3225954fba85589da77a0fe6a53e3976de39caf04a0db4c36f1",
+                "sha256:4d7af63f9f93fe593afbf104c21b3b15868efb2c21d07d8732c0c4287e66b6a6",
+                "sha256:501d20b891688eb8e7aa903021f0b72d5a55db40ffaab27edefd1027caaafa61",
+                "sha256:521a463429ef54143092c11a77e04056dd00636f72e8c45b70aaa3140d639726",
+                "sha256:5558992a00dfd54ccbc64a32726a3357ec93825a418a401f5cc67df0ac5d9e49",
+                "sha256:55c72fd6ea2da4c318e74ffdf93c4fe4e926051133657459131a95c846d16d44",
+                "sha256:564d9f0d4d9509e1a870c920a89b2fec951b44bf5ba7d537a9e7c1ccec2c18af",
+                "sha256:580e97762b950f993ae618e167e7be9256b8353c2dcd8b99ec100eb50f5286aa",
+                "sha256:5a103c3eb905fcea0ab98be99c3a9a5ab2de60228aa5aceedc614c0281cf6153",
+                "sha256:5c3310452e0d31390da9035c348633b43d7e7feb2e37be252be6da45abd1abcc",
+                "sha256:5d4e2366a9c7b837555cf02fb9be2e3167d333aff716332ef1b7c3a142ec40c5",
+                "sha256:5fd37c406dd6dc85aa743e214cef35dc54bbdd1419baac4f6ae5e5b1a2976938",
+                "sha256:60a8fda9644b7dfd5dece8c61d8a85e271cb958075bfc4e01083c148b61a7caf",
+                "sha256:66c1f011f45a3b33d7bcb22daed4b29c0c9e2224758b6be00686731e1b46f925",
+                "sha256:671538c2262dadb5ba6395e26c1731e1d52534bfe9ae56d0b5573ce539266aa8",
+                "sha256:678ae89ebc632c5c204c794f8dab2837c5f159aeb59e6ed0539500400577298c",
+                "sha256:67fad6162281e80e882fb3ec355398cf72864a54069d060321f6cd0ade95fe85",
+                "sha256:6918ecbd897443087a3b7cd978d56546a812517dcaaca51b49526720571fa93e",
+                "sha256:6f6ff873ed40292cd4969ef5310179afd5db59fdf055897e282485043fc80ad0",
+                "sha256:6f8b465489f927b0df505cbe26ffbeed4d6d8a2bbc61ce90eb074ff129ef0ab1",
+                "sha256:71b749281b816793678ae7f3d0d84bd36e694953822eaad408d682efc5ca18e0",
+                "sha256:74c1fb26515153e482e00177a1ad654721bf9207da8a494a0c05e797ad27b992",
+                "sha256:7c2d1fa3201efaf55d730400d945b5b3ab6e672e100ba0f9a409d950ab25d7db",
+                "sha256:824e908bce90fb2743bd6b59db36eb4f45cd350a39637c9f73b1c1ea66f5b75f",
+                "sha256:8326e144341460402713f91df60ade3c999d601e7eb5ff8f6f7862d54de0610d",
+                "sha256:8873eb4460fd55333ea49b7d189749ecf6e55bf85080f11b1c4530ed3034cba1",
+                "sha256:89eb3fa9524f7bec9de6e83cf3faed9d79bffa560672c118a96a171a6f55831e",
+                "sha256:8c9b3cbe4584636d72ff556d9036e0c9317fa27b3ac1f0f558e7e84d1c9c5900",
+                "sha256:8e57061305815dfc910a3634dcf584f08168a8836e6999983569f51a8544cd89",
+                "sha256:929d7cbe1f01bb7baffb33dc14eb5691c95831450a26354cd210a8155170c93a",
+                "sha256:92d1935ee1f8d7442da9c0c4fa7ac20d07e94064184811b685f5c4fada64553b",
+                "sha256:948dab269721ae9a87fd16c514a0a2c2a1bdb23a9a61b969b0f9d9ee2968546f",
+                "sha256:981333cb2f4c1896a12f4ab92a9cc8f09ea664e9b7dbdc4eff74627af3a11c0f",
+                "sha256:990f6b3e2a27d683cb7602ed6c86f15ee6b43b1194736f9baaeb93d0016633b1",
+                "sha256:99d43339c83aaf4d32bda60928231848eee470c6bda8d02599cc4cebe872d183",
+                "sha256:9a0bd56e5b100aef69bd8562b74b46254e7c8812918d3baa700c8a8009b0af66",
+                "sha256:9a52009f2adffe195d0b605c25ec929d26b36ef986ba85244891dee3b294df21",
+                "sha256:9d2b6caef873b4f09e26ea7e33d65f42b944837563a47a94719cc3544319a0db",
+                "sha256:9f302f4783709a78240ebc311b793f123328716a60911d667e0c036bc5dcbded",
+                "sha256:a0ee98db9c5f80785b266eb805016e36058ac72c51a064040f2bc43b61101cdb",
+                "sha256:a129e76735bc792794d5177069691c3217898b9f5cee2b2661471e52ffe13f19",
+                "sha256:a78372c932c90ee474559c5ddfffd718238e8673c340dc21fe45c5b8b54559a0",
+                "sha256:a9695397f85973bb40427dedddf70d8dc4a44b22f1650dd4af9eedf443d45165",
+                "sha256:ab08df6c9a035bee56e31af99be621526bd237bea9f32def431c656b29e41778",
+                "sha256:ab2943be7c652f09638800905ee1bab2c544e537edb57d527997a24c13dc1455",
+                "sha256:ab4c29b49d560fe48b696cdcb127dd36e0bc2472548f3bf56cc5cb3da2b2984f",
+                "sha256:af223b406d6d000830c6f65f1e6431783fc3f713ba3e6cc8c024d5ee96170a4b",
+                "sha256:af2a6052aeb6cf17d3e46ee169099044fd8224cbaf75c76a2ef596e8163e2237",
+                "sha256:bcc9aaa5d80322bc2fb24bb7accb4a30f81e90ab8d6ba187aec0744bc302ad81",
+                "sha256:c07fda85708bc48578467e85099645167a955ba093be0a2dcba962195676e859",
+                "sha256:c0d4b719b7da33599dfe3b22d3db1ef789210a0597bc650b7cee9c77c2be8c5c",
+                "sha256:c0ef0aaafc66fbd87842a3fe3902fd889825646bc21149eafe47be6072725835",
+                "sha256:c2b5e7db5328427c57c8e8831abda175421b709672f6cfc3d630c3b7e2146393",
+                "sha256:c30b53e7e6bda1d547cabb47c825f3843a0a1a42b0496087bb58d8fedf9f41b5",
+                "sha256:c80ee5802e3fb9ea37938e7eecc307fb984837091d5fd262bb37238b1ae97641",
+                "sha256:c9b822a577f560fbd9554812526831712c1436d2c046cedee4c3796d3543b144",
+                "sha256:cae65ad55793da34db5f54e4029b89d3b9b9490d8abe1b4c7ab5d4b8ec7ebf74",
+                "sha256:cb2d222e72399fcf5890d1d5cc1060857b9b236adff2792ff48ca2dfd46c81db",
+                "sha256:cbc3b6dfc728105b2a57c06791eb07a94229202ea75c59db644d7d496b698cac",
+                "sha256:cd547953428f7abb73c5ad82cbb32109566204260d98e41e5dfdc682eb7f8403",
+                "sha256:cfc27c945f422e8b5071b6e93169679e4eb5bf73bbcbf1ba3ae3a83d2f78ebd9",
+                "sha256:d472aeb4fbf9865e0c6d622d7f4d54a4e101a89715d8904282bb5f9a2f476c3f",
+                "sha256:d62cdfcfd89ccb8de04e0eda998535c406bf5e060ffd56be6c586cbcc05b3311",
+                "sha256:d82ad62b19645419fe79dd63b3f9253e15b30e955c0170e5cebc350c1844e581",
+                "sha256:d8f353eb14ee3441ee844ade4277d560cdd68288838673273b978e3d6d2c8f36",
+                "sha256:daede9cd44e0f8bdd9e6cc9a607fc81feb80fae7a5fc6cecaff0e0bb32e42d00",
+                "sha256:db65d2af507bbfbdcedb254a11149f894169d90488dd3e7190f7cdcb2d6cd57a",
+                "sha256:dee69d7015dc235f526fe80a9c90d65eb0039103fe565776250881731f06349f",
+                "sha256:e153e9cd40cc8945138822807139367f256f89c6810c2634a4f6902b52d3b4e2",
+                "sha256:e35b88984e7fa64aacecea39236cee32dd9bd8c55f57ba8a75cf2399553f9bd7",
+                "sha256:e53f3a38d3510c11953f3e6a33f205c6d1b001129f972805ca9b42fc308bc239",
+                "sha256:e9b0d8d0845bbc4cfcdcbcdbf5086886bc8157aa963c31c777ceff7846c77757",
+                "sha256:ec17c65562a827bba85e3872ead335f95405ea1674860d96483a02f5c698fa72",
+                "sha256:ecef2343af4cc68e05131e45024ba34f6095821988a9d0a02aa7c73fcc448aa9",
+                "sha256:ed5a841e8bb29a55fb8159ed526b26adc5bdd7e8bd7bf793ce647cb08656cdf4",
+                "sha256:ee17f18d2498f2673e432faaa71698032b0127ebf23ae5974eeaf806c279df24",
+                "sha256:f048da1b4f243fc44f205dfd320933a951b8d89e0afd4c7cacc762a8b9165207",
+                "sha256:f10207adf04d08bec185bae14d9606a1444715bc99180f9331c9c02093e1959e",
+                "sha256:f1d2f90aeec838a52f1c1a32fe9a619fefd5e411721a9117fbf82aea638fe8a1",
+                "sha256:f48107a8c637e80362555f37ecf49abe20370e557cc4ab374f04ec4423c97c3d",
+                "sha256:f7ee0e597f495cf415bcbd3da3caa3bd7e816b74d0d52b8145954c5e6fd3ff37",
+                "sha256:f93243fdc5657247533273ac4f86ae106cc6445a0efacb9a1bfe982fcfefd90c",
+                "sha256:f95393b4d66bfae908c3ca8d169d5f79cd65636ae15b5e7a4f6e67af675adb0e",
+                "sha256:fc38cba02d1acba4e2869eef1a57a43dfbd3d49a59bf90dda7444ec2be6a5570",
+                "sha256:fd0858c20f078a32cf55f7e81473d96dcf3b93fd2ccdb3d40fdf54b8573df3af",
+                "sha256:fd138803047fb4c062b1c1dd95462f5209456bfab55c734458f15d11da288f8f",
+                "sha256:fd2dbc472da1f772a4dae4fa24be938a6c544671a912e30529984dd80400cd88",
+                "sha256:fd6f30fdcf9ae2a70abd34da54f18da086160e4d7d9251f81f3da0ff84fc5a48",
+                "sha256:fe49d0a85038f36ba9e3ffafa1103e61170b28e95b16622e11be0a0ea07c6781"
             ],
             "markers": "python_version >= '3.9'",
-            "version": "==0.3.2"
+            "version": "==0.4.1"
+        },
+        "typing-extensions": {
+            "hashes": [
+                "sha256:0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466",
+                "sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548"
+            ],
+            "markers": "python_version < '3.13'",
+            "version": "==4.15.0"
         },
         "yarl": {
             "hashes": [
-                "sha256:03aa1e041727cb438ca762628109ef1333498b122e4c76dd858d186a37cec845",
-                "sha256:041eaa14f73ff5a8986b4388ac6bb43a77f2ea09bf1913df7a35d4646db69e53",
-                "sha256:0b5ff0fbb7c9f1b1b5ab53330acbfc5247893069e7716840c8e7d5bb7355038a",
-                "sha256:0c869f2651cc77465f6cd01d938d91a11d9ea5d798738c1dc077f3de0b5e5fed",
-                "sha256:1112ae8154186dfe2de4732197f59c05a83dc814849a5ced892b708033f40dc2",
-                "sha256:11a62c839c3a8eac2410e951301309426f368388ff2f33799052787035793b02",
-                "sha256:12e768f966538e81e6e7550f9086a6236b16e26cd964cf4df35349970f3551cf",
-                "sha256:14a85f3bd2d7bb255be7183e5d7d6e70add151a98edf56a770d6140f5d5f4010",
-                "sha256:14f326acd845c2b2e2eb38fb1346c94f7f3b01a4f5c788f8144f9b630bfff9a3",
-                "sha256:1c48912653e63aef91ff988c5432832692ac5a1d8f0fb8a33091520b5bbe19ef",
-                "sha256:1c92f4390e407513f619d49319023664643d3339bd5e5a56a3bebe01bc67ec04",
-                "sha256:1f8a891e4a22a89f5dde7862994485e19db246b70bb288d3ce73a34422e55b23",
-                "sha256:21242b4288a6d56f04ea193adde174b7e347ac46ce6bc84989ff7c1b1ecea84e",
-                "sha256:255b468adf57b4a7b65d8aad5b5138dce6a0752c139965711bdcb81bc370e1b6",
-                "sha256:26ef53a9e726e61e9cd1cda6b478f17e350fb5800b4bd1cd9fe81c4d91cfeb2e",
-                "sha256:2c26b0c49220d5799f7b22c6838409ee9bc58ee5c95361a4d7831f03cc225b5a",
-                "sha256:2c7b34d804b8cf9b214f05015c4fee2ebe7ed05cf581e7192c06555c71f4446a",
-                "sha256:2c89b5c792685dd9cd3fa9761c1b9f46fc240c2a3265483acc1565769996a3f8",
-                "sha256:30c41ad5d717b3961b2dd785593b67d386b73feca30522048d37298fee981805",
-                "sha256:33f29ecfe0330c570d997bcf1afd304377f2e48f61447f37e846a6058a4d33b2",
-                "sha256:344d1103e9c1523f32a5ed704d576172d2cabed3122ea90b1d4e11fe17c66458",
-                "sha256:377fae2fef158e8fd9d60b4c8751387b8d1fb121d3d0b8e9b0be07d1b41e83dc",
-                "sha256:3cf34efa60eb81dd2645a2e13e00bb98b76c35ab5061a3989c7a70f78c85006d",
-                "sha256:41493b9b7c312ac448b7f0a42a089dffe1d6e6e981a2d76205801a023ed26a2b",
-                "sha256:41ebd28167bc6af8abb97fec1a399f412eec5fd61a3ccbe2305a18b84fb4ca73",
-                "sha256:468f6e40285de5a5b3c44981ca3a319a4b208ccc07d526b20b12aeedcfa654b7",
-                "sha256:46b5e0ccf1943a9a6e766b2c2b8c732c55b34e28be57d8daa2b3c1d1d4009309",
-                "sha256:47ee6188fea634bdfaeb2cc420f5b3b17332e6225ce88149a17c413c77ff269e",
-                "sha256:48ea7d7f9be0487339828a4de0360d7ce0efc06524a48e1810f945c45b813698",
-                "sha256:495b4ef2fea40596bfc0affe3837411d6aa3371abcf31aac0ccc4bdd64d4ef5c",
-                "sha256:49bdd1b8e00ce57e68ba51916e4bb04461746e794e7c4d4bbc42ba2f18297691",
-                "sha256:4a979218c1fdb4246a05efc2cc23859d47c89af463a90b99b7c56094daf25a16",
-                "sha256:4c3ae28f3ae1563c50f3d37f064ddb1511ecc1d5584e88c6b7c63cf7702a6d5f",
-                "sha256:541d050a355bbbc27e55d906bc91cb6fe42f96c01413dd0f4ed5a5240513874f",
-                "sha256:564ab3d517e3d01c408c67f2e5247aad4019dcf1969982aba3974b4093279004",
-                "sha256:56dac5f452ed25eef0f6e3c6a066c6ab68971d96a9fb441791cad0efba6140d3",
-                "sha256:57edc88517d7fc62b174fcfb2e939fbc486a68315d648d7e74d07fac42cec240",
-                "sha256:59174e7332f5d153d8f7452a102b103e2e74035ad085f404df2e40e663a22b28",
-                "sha256:595c07bc79af2494365cc96ddeb772f76272364ef7c80fb892ef9d0649586513",
-                "sha256:597f40615b8d25812f14562699e287f0dcc035d25eb74da72cae043bb884d773",
-                "sha256:59febc3969b0781682b469d4aca1a5cab7505a4f7b85acf6db01fa500fa3f6ba",
-                "sha256:6032e6da6abd41e4acda34d75a816012717000fa6839f37124a47fcefc49bec4",
-                "sha256:62915e6688eb4d180d93840cda4110995ad50c459bf931b8b3775b37c264af1e",
-                "sha256:642980ef5e0fa1de5fa96d905c7e00cb2c47cb468bfcac5a18c58e27dbf8d8d1",
-                "sha256:66252d780b45189975abfed839616e8fd2dbacbdc262105ad7742c6ae58f3e31",
-                "sha256:67e708dfb8e78d8a19169818eeb5c7a80717562de9051bf2413aca8e3696bf16",
-                "sha256:680e19c7ce3710ac4cd964e90dad99bf9b5029372ba0c7cbfcd55e54d90ea819",
-                "sha256:69e9b141de5511021942a6866990aea6d111c9042235de90e08f94cf972ca03d",
-                "sha256:69ff8439d8ba832d6bed88af2c2b3445977eba9a4588b787b32945871c2444e3",
-                "sha256:6c4fbf6b02d70e512d7ade4b1f998f237137f1417ab07ec06358ea04f69134f8",
-                "sha256:6f3eff4cc3f03d650d8755c6eefc844edde99d641d0dcf4da3ab27141a5f8ddf",
-                "sha256:749d73611db8d26a6281086f859ea7ec08f9c4c56cec864e52028c8b328db723",
-                "sha256:76d12524d05841276b0e22573f28d5fbcb67589836772ae9244d90dd7d66aa13",
-                "sha256:793fd0580cb9664548c6b83c63b43c477212c0260891ddf86809e1c06c8b08f1",
-                "sha256:7a8900a42fcdaad568de58887c7b2f602962356908eedb7628eaf6021a6e435b",
-                "sha256:7bdd2f80f4a7df852ab9ab49484a4dee8030023aa536df41f2d922fd57bf023f",
-                "sha256:812303eb4aa98e302886ccda58d6b099e3576b1b9276161469c25803a8db277d",
-                "sha256:835ab2cfc74d5eb4a6a528c57f05688099da41cf4957cf08cad38647e4a83b30",
-                "sha256:83b8eb083fe4683c6115795d9fc1cfaf2cbbefb19b3a1cb68f6527460f483a77",
-                "sha256:8570d998db4ddbfb9a590b185a0a33dbf8aafb831d07a5257b4ec9948df9cb0a",
-                "sha256:8601bc010d1d7780592f3fc1bdc6c72e2b6466ea34569778422943e1a1f3c389",
-                "sha256:86971e2795584fe8c002356d3b97ef6c61862720eeff03db2a7c86b678d85b3e",
-                "sha256:88cab98aa4e13e1ade8c141daeedd300a4603b7132819c484841bb7af3edce9e",
-                "sha256:8e0fe9364ad0fddab2688ce72cb7a8e61ea42eff3c7caeeb83874a5d479c896c",
-                "sha256:8f64fbf81878ba914562c672024089e3401974a39767747691c65080a67b18c1",
-                "sha256:8f969afbb0a9b63c18d0feecf0db09d164b7a44a053e78a7d05f5df163e43833",
-                "sha256:909313577e9619dcff8c31a0ea2aa0a2a828341d92673015456b3ae492e7317b",
-                "sha256:90bbd29c4fe234233f7fa2b9b121fb63c321830e5d05b45153a2ca68f7d310ee",
-                "sha256:9427925776096e664c39e131447aa20ec738bdd77c049c48ea5200db2237e000",
-                "sha256:97c75596019baae7c71ccf1d8cc4738bc08134060d0adfcbe5642f778d1dca38",
-                "sha256:98c4a7d166635147924aa0bf9bfe8d8abad6fffa6102de9c99ea04a1376f91e8",
-                "sha256:a97d67108e79cfe22e2b430d80d7571ae57d19f17cda8bb967057ca8a7bf5bfd",
-                "sha256:aef6c4d69554d44b7f9d923245f8ad9a707d971e6209d51279196d8e8fe1ae16",
-                "sha256:b121ff6a7cbd4abc28985b6028235491941b9fe8fe226e6fdc539c977ea1739d",
-                "sha256:b29a2c385a5f5b9c7d9347e5812b6f7ab267193c62d282a540b4fc528c8a9d2a",
-                "sha256:b5f307337819cdfdbb40193cad84978a029f847b0a357fbe49f712063cfc4f06",
-                "sha256:b982fa7f74c80d5c0c7b5b38f908971e513380a10fecea528091405f519b9ebb",
-                "sha256:bad6d131fda8ef508b36be3ece16d0902e80b88ea7200f030a0f6c11d9e508d4",
-                "sha256:bdcc4cd244e58593a4379fe60fdee5ac0331f8eb70320a24d591a3be197b94a9",
-                "sha256:bea21cdae6c7eb02ba02a475f37463abfe0a01f5d7200121b03e605d6a0439f8",
-                "sha256:c03bfebc4ae8d862f853a9757199677ab74ec25424d0ebd68a0027e9c639a390",
-                "sha256:c5e9642f27036283550f5f57dc6156c51084b458570b9d0d96100c8bebb186a8",
-                "sha256:c7d7f497126d65e2cad8dc5f97d34c27b19199b6414a40cb36b52f41b79014be",
-                "sha256:c7ddf7a09f38667aea38801da8b8d6bfe81df767d9dfc8c88eb45827b195cd1c",
-                "sha256:d017a4997ee50c91fd5466cef416231bb82177b93b029906cefc542ce14c35ac",
-                "sha256:d0f6500f69e8402d513e5eedb77a4e1818691e8f45e6b687147963514d84b44b",
-                "sha256:d1a4fbb50e14396ba3d375f68bfe02215d8e7bc3ec49da8341fe3157f59d2ff5",
-                "sha256:d25ddcf954df1754ab0f86bb696af765c5bfaba39b74095f27eececa049ef9a4",
-                "sha256:d2b6fb3622b7e5bf7a6e5b679a69326b4279e805ed1699d749739a61d242449e",
-                "sha256:daadbdc1f2a9033a2399c42646fbd46da7992e868a5fe9513860122d7fe7a73f",
-                "sha256:dab096ce479d5894d62c26ff4f699ec9072269d514b4edd630a393223f45a0ee",
-                "sha256:daea0d313868da1cf2fac6b2d3a25c6e3a9e879483244be38c8e6a41f1d876a5",
-                "sha256:dd803820d44c8853a109a34e3660e5a61beae12970da479cf44aa2954019bf70",
-                "sha256:df018d92fe22aaebb679a7f89fe0c0f368ec497e3dda6cb81a567610f04501f1",
-                "sha256:df47c55f7d74127d1b11251fe6397d84afdde0d53b90bedb46a23c0e534f9d24",
-                "sha256:e3968ec7d92a0c0f9ac34d5ecfd03869ec0cab0697c91a45db3fbbd95fe1b653",
-                "sha256:e42ba79e2efb6845ebab49c7bf20306c4edf74a0b20fc6b2ccdd1a219d12fad3",
-                "sha256:eae7bfe2069f9c1c5b05fc7fe5d612e5bbc089a39309904ee8b829e322dcad00",
-                "sha256:f5a5928ff5eb13408c62a968ac90d43f8322fd56d87008b8f9dabf3c0f6ee983",
-                "sha256:f60233b98423aab21d249a30eb27c389c14929f47be8430efa7dbd91493a729d",
-                "sha256:f60e4ad5db23f0b96e49c018596707c3ae89f5d0bd97f0ad3684bcbad899f1e7",
-                "sha256:f6342d643bf9a1de97e512e45e4b9560a043347e779a173250824f8b254bd5ce",
-                "sha256:fe41919b9d899661c5c28a8b4b0acf704510b88f27f0934ac7a7bebdd8938d5e",
-                "sha256:ff70f32aa316393eaf8222d518ce9118148eddb8a53073c2403863b41033eed5"
+                "sha256:01e73b85a5434f89fc4fe27dcda2aff08ddf35e4d47bbbea3bdcd25321af538a",
+                "sha256:029866bde8d7b0878b9c160e72305bbf0a7342bcd20b9999381704ae03308dc8",
+                "sha256:078278b9b0b11568937d9509b589ee83ef98ed6d561dfe2020e24a9fd08eaa2b",
+                "sha256:078a8aefd263f4d4f923a9677b942b445a2be970ca24548a8102689a3a8ab8da",
+                "sha256:07a524d84df0c10f41e3ee918846e1974aba4ec017f990dc735aad487a0bdfdf",
+                "sha256:088e4e08f033db4be2ccd1f34cf29fe994772fb54cfe004bbf54db320af56890",
+                "sha256:0b5bcc1a9c4839e7e30b7b30dd47fe5e7e44fb7054ec29b5bb8d526aa1041093",
+                "sha256:0cf71bf877efeac18b38d3930594c0948c82b64547c1cf420ba48722fe5509f6",
+                "sha256:0d6e6885777af0f110b0e5d7e5dda8b704efed3894da26220b7f3d887b839a79",
+                "sha256:0dd9a702591ca2e543631c2a017e4a547e38a5c0f29eece37d9097e04a7ac683",
+                "sha256:10619d9fdee46d20edc49d3479e2f8269d0779f1b031e6f7c2aa1c76be04b7ed",
+                "sha256:131a085a53bfe839a477c0845acf21efc77457ba2bcf5899618136d64f3303a2",
+                "sha256:1380560bdba02b6b6c90de54133c81c9f2a453dee9912fe58c1dcced1edb7cff",
+                "sha256:139718f35149ff544caba20fce6e8a2f71f1e39b92c700d8438a0b1d2a631a02",
+                "sha256:14291620375b1060613f4aab9ebf21850058b6b1b438f386cc814813d901c60b",
+                "sha256:1834bb90991cc2999f10f97f5f01317f99b143284766d197e43cd5b45eb18d03",
+                "sha256:1ab72135b1f2db3fed3997d7e7dc1b80573c67138023852b6efb336a5eae6511",
+                "sha256:1e7ce67c34138a058fd092f67d07a72b8e31ff0c9236e751957465a24b28910c",
+                "sha256:1e8fbaa7cec507aa24ea27a01456e8dd4b6fab829059b69844bd348f2d467124",
+                "sha256:22965c2af250d20c873cdbee8ff958fb809940aeb2e74ba5f20aaf6b7ac8c70c",
+                "sha256:22b029f2881599e2f1b06f8f1db2ee63bd309e2293ba2d566e008ba12778b8da",
+                "sha256:243dda95d901c733f5b59214d28b0120893d91777cb8aa043e6ef059d3cddfe2",
+                "sha256:2ca6fd72a8cd803be290d42f2dec5cdcd5299eeb93c2d929bf060ad9efaf5de0",
+                "sha256:2e4e1f6f0b4da23e61188676e3ed027ef0baa833a2e633c29ff8530800edccba",
+                "sha256:31f0b53913220599446872d757257be5898019c85e7971599065bc55065dc99d",
+                "sha256:334b8721303e61b00019474cc103bdac3d7b1f65e91f0bfedeec2d56dfe74b53",
+                "sha256:33e32a0dd0c8205efa8e83d04fc9f19313772b78522d1bdc7d9aed706bfd6138",
+                "sha256:34b36c2c57124530884d89d50ed2c1478697ad7473efd59cfd479945c95650e4",
+                "sha256:3aa27acb6de7a23785d81557577491f6c38a5209a254d1191519d07d8fe51748",
+                "sha256:3b06bcadaac49c70f4c88af4ffcfbe3dc155aab3163e75777818092478bcbbe7",
+                "sha256:3b7c88eeef021579d600e50363e0b6ee4f7f6f728cd3486b9d0f3ee7b946398d",
+                "sha256:3e2daa88dc91870215961e96a039ec73e4937da13cf77ce17f9cad0c18df3503",
+                "sha256:3ea66b1c11c9150f1372f69afb6b8116f2dd7286f38e14ea71a44eee9ec51b9d",
+                "sha256:42188e6a615c1a75bcaa6e150c3fe8f3e8680471a6b10150c5f7e83f47cc34d2",
+                "sha256:433885ab5431bc3d3d4f2f9bd15bfa1614c522b0f1405d62c4f926ccd69d04fa",
+                "sha256:437840083abe022c978470b942ff832c3940b2ad3734d424b7eaffcd07f76737",
+                "sha256:4398557cbf484207df000309235979c79c4356518fd5c99158c7d38203c4da4f",
+                "sha256:45c2842ff0e0d1b35a6bf1cd6c690939dacb617a70827f715232b2e0494d55d1",
+                "sha256:47743b82b76d89a1d20b83e60d5c20314cbd5ba2befc9cda8f28300c4a08ed4d",
+                "sha256:4792b262d585ff0dff6bcb787f8492e40698443ec982a3568c2096433660c694",
+                "sha256:47d8a5c446df1c4db9d21b49619ffdba90e77c89ec6e283f453856c74b50b9e3",
+                "sha256:47fdb18187e2a4e18fda2c25c05d8251a9e4a521edaed757fef033e7d8498d9a",
+                "sha256:4c52a6e78aef5cf47a98ef8e934755abf53953379b7d53e68b15ff4420e6683d",
+                "sha256:4dcc74149ccc8bba31ce1944acee24813e93cfdee2acda3c172df844948ddf7b",
+                "sha256:50678a3b71c751d58d7908edc96d332af328839eea883bb554a43f539101277a",
+                "sha256:51af598701f5299012b8416486b40fceef8c26fc87dc6d7d1f6fc30609ea0aa6",
+                "sha256:594fcab1032e2d2cc3321bb2e51271e7cd2b516c7d9aee780ece81b07ff8244b",
+                "sha256:595697f68bd1f0c1c159fcb97b661fc9c3f5db46498043555d04805430e79bea",
+                "sha256:59c189e3e99a59cf8d83cbb31d4db02d66cda5a1a4374e8a012b51255341abf5",
+                "sha256:5a3bf7f62a289fa90f1990422dc8dff5a458469ea71d1624585ec3a4c8d6960f",
+                "sha256:5c401e05ad47a75869c3ab3e35137f8468b846770587e70d71e11de797d113df",
+                "sha256:5cdac20da754f3a723cceea5b3448e1a2074866406adeb4ef35b469d089adb8f",
+                "sha256:5d0fcda9608875f7d052eff120c7a5da474a6796fe4d83e152e0e4d42f6d1a9b",
+                "sha256:5dbeefd6ca588b33576a01b0ad58aa934bc1b41ef89dee505bf2932b22ddffba",
+                "sha256:62441e55958977b8167b2709c164c91a6363e25da322d87ae6dd9c6019ceecf9",
+                "sha256:663e1cadaddae26be034a6ab6072449a8426ddb03d500f43daf952b74553bba0",
+                "sha256:669930400e375570189492dc8d8341301578e8493aec04aebc20d4717f899dd6",
+                "sha256:68986a61557d37bb90d3051a45b91fa3d5c516d177dfc6dd6f2f436a07ff2b6b",
+                "sha256:6944b2dc72c4d7f7052683487e3677456050ff77fcf5e6204e98caf785ad1967",
+                "sha256:6a635ea45ba4ea8238463b4f7d0e721bad669f80878b7bfd1f89266e2ae63da2",
+                "sha256:6c5010a52015e7c70f86eb967db0f37f3c8bd503a695a49f8d45700144667708",
+                "sha256:6dcbb0829c671f305be48a7227918cfcd11276c2d637a8033a99a02b67bf9eda",
+                "sha256:70dfd4f241c04bd9239d53b17f11e6ab672b9f1420364af63e8531198e3f5fe8",
+                "sha256:719ae08b6972befcba4310e49edb1161a88cdd331e3a694b84466bd938a6ab10",
+                "sha256:75976c6945d85dbb9ee6308cd7ff7b1fb9409380c82d6119bd778d8fcfe2931c",
+                "sha256:7861058d0582b847bc4e3a4a4c46828a410bca738673f35a29ba3ca5db0b473b",
+                "sha256:792a2af6d58177ef7c19cbf0097aba92ca1b9cb3ffdd9c7470e156c8f9b5e028",
+                "sha256:8009b3173bcd637be650922ac455946197d858b3630b6d8787aa9e5c4564533e",
+                "sha256:80ddf7a5f8c86cb3eb4bc9028b07bbbf1f08a96c5c0bc1244be5e8fefcb94147",
+                "sha256:8218f4e98d3c10d683584cb40f0424f4b9fd6e95610232dd75e13743b070ee33",
+                "sha256:84fc3ec96fce86ce5aa305eb4aa9358279d1aa644b71fab7b8ed33fe3ba1a7ca",
+                "sha256:852863707010316c973162e703bddabec35e8757e67fcb8ad58829de1ebc8590",
+                "sha256:8884d8b332a5e9b88e23f60bb166890009429391864c685e17bd73a9eda9105c",
+                "sha256:8dee9c25c74997f6a750cd317b8ca63545169c098faee42c84aa5e506c819b53",
+                "sha256:939fe60db294c786f6b7c2d2e121576628468f65453d86b0fe36cb52f987bd74",
+                "sha256:99b6fc1d55782461b78221e95fc357b47ad98b041e8e20f47c1411d0aacddc60",
+                "sha256:9d7672ecf7557476642c88497c2f8d8542f8e36596e928e9bcba0e42e1e7d71f",
+                "sha256:9f6d73c1436b934e3f01df1e1b21ff765cd1d28c77dfb9ace207f746d4610ee1",
+                "sha256:9fb17ea16e972c63d25d4a97f016d235c78dd2344820eb35bc034bc32012ee27",
+                "sha256:a49370e8f711daec68d09b821a34e1167792ee2d24d405cbc2387be4f158b520",
+                "sha256:a4fcfc8eb2c34148c118dfa02e6427ca278bfd0f3df7c5f99e33d2c0e81eae3e",
+                "sha256:a899cbd98dce6f5d8de1aad31cb712ec0a530abc0a86bd6edaa47c1090138467",
+                "sha256:a9b1ba5610a4e20f655258d5a1fdc7ebe3d837bb0e45b581398b99eb98b1f5ca",
+                "sha256:af74f05666a5e531289cb1cc9c883d1de2088b8e5b4de48004e5ca8a830ac859",
+                "sha256:b0748275abb8c1e1e09301ee3cf90c8a99678a4e92e4373705f2a2570d581273",
+                "sha256:b266bd01fedeffeeac01a79ae181719ff848a5a13ce10075adbefc8f1daee70e",
+                "sha256:b4f15793aa49793ec8d1c708ab7f9eded1aa72edc5174cae703651555ed1b601",
+                "sha256:b580e71cac3f8113d3135888770903eaf2f507e9421e5697d6ee6d8cd1c7f054",
+                "sha256:b6a6f620cfe13ccec221fa312139135166e47ae169f8253f72a0abc0dae94376",
+                "sha256:b790b39c7e9a4192dc2e201a282109ed2985a1ddbd5ac08dc56d0e121400a8f7",
+                "sha256:b85b982afde6df99ecc996990d4ad7ccbdbb70e2a4ba4de0aecde5922ba98a0b",
+                "sha256:b8a0588521a26bf92a57a1705b77b8b59044cdceccac7151bd8d229e66b8dedb",
+                "sha256:ba440ae430c00eee41509353628600212112cd5018d5def7e9b05ea7ac34eb65",
+                "sha256:bca03b91c323036913993ff5c738d0842fc9c60c4648e5c8d98331526df89784",
+                "sha256:bebf8557577d4401ba8bd9ff33906f1376c877aa78d1fe216ad01b4d6745af71",
+                "sha256:bec03d0d388060058f5d291a813f21c011041938a441c593374da6077fe21b1b",
+                "sha256:bf4a21e58b9cde0e401e683ebd00f6ed30a06d14e93f7c8fd059f8b6e8f87b6a",
+                "sha256:c0232bce2170103ec23c454e54a57008a9a72b5d1c3105dc2496750da8cfa47c",
+                "sha256:c4647674b6150d2cae088fc07de2738a84b8bcedebef29802cf0b0a82ab6face",
+                "sha256:c7044802eec4524fde550afc28edda0dd5784c4c45f0be151a2d3ba017daca7d",
+                "sha256:c7bd6683587567e5a49ee6e336e0612bec8329be1b7d4c8af5687dcdeb67ee1e",
+                "sha256:ca1f59c4e1ab6e72f0a23c13fca5430f889634166be85dbf1013683e49e3278e",
+                "sha256:cb95a9b1adaa48e41815a55ae740cfda005758104049a640a398120bf02515ca",
+                "sha256:cfebc0ac8333520d2d0423cbbe43ae43c8838862ddb898f5ca68565e395516e9",
+                "sha256:d332fc2e3c94dad927f2112395772a4e4fedbcf8f80efc21ed7cdfae4d574fdb",
+                "sha256:d3e32536234a95f513bd374e93d717cf6b2231a791758de6c509e3653f234c95",
+                "sha256:d5372ca1df0f91a86b047d1277c2aaf1edb32d78bbcefffc81b40ffd18f027ed",
+                "sha256:d77e1b2c6d04711478cb1c4ab90db07f1609ccf06a287d5607fcd90dc9863acf",
+                "sha256:d947071e6ebcf2e2bee8fce76e10faca8f7a14808ca36a910263acaacef08eca",
+                "sha256:dd7afd3f8b0bfb4e0d9fc3c31bfe8a4ec7debe124cfd90619305def3c8ca8cd2",
+                "sha256:de6b9a04c606978fdfe72666fa216ffcf2d1a9f6a381058d4378f8d7b1e5de62",
+                "sha256:e1651bf8e0398574646744c1885a41198eba53dc8a9312b954073f845c90a8df",
+                "sha256:e1b329cb8146d7b736677a2440e422eadd775d1806a81db2d4cded80a48efc1a",
+                "sha256:e1b51bebd221006d3d2f95fbe124b22b247136647ae5dcc8c7acafba66e5ee67",
+                "sha256:e340382d1afa5d32b892b3ff062436d592ec3d692aeea3bef3a5cfe11bbf8c6f",
+                "sha256:e4b582bab49ac33c8deb97e058cd67c2c50dac0dd134874106d9c774fd272529",
+                "sha256:e51ac5435758ba97ad69617e13233da53908beccc6cfcd6c34bbed8dcbede486",
+                "sha256:e5542339dcf2747135c5c85f68680353d5cb9ffd741c0f2e8d832d054d41f35a",
+                "sha256:e6438cc8f23a9c1478633d216b16104a586b9761db62bfacb6425bac0a36679e",
+                "sha256:e81fda2fb4a07eda1a2252b216aa0df23ebcd4d584894e9612e80999a78fd95b",
+                "sha256:ea70f61a47f3cc93bdf8b2f368ed359ef02a01ca6393916bc8ff877427181e74",
+                "sha256:ebd4549b108d732dba1d4ace67614b9545b21ece30937a63a65dd34efa19732d",
+                "sha256:efb07073be061c8f79d03d04139a80ba33cbd390ca8f0297aae9cce6411e4c6b",
+                "sha256:f0d97c18dfd9a9af4490631905a3f131a8e4c9e80a39353919e2cfed8f00aedc",
+                "sha256:f1e09112a2c31ffe8d80be1b0988fa6a18c5d5cad92a9ffbb1c04c91bfe52ad2",
+                "sha256:f3d7a87a78d46a2e3d5b72587ac14b4c16952dd0887dbb051451eceac774411e",
+                "sha256:f4afb5c34f2c6fecdcc182dfcfc6af6cccf1aa923eed4d6a12e9d96904e1a0d8",
+                "sha256:f6d2cb59377d99718913ad9a151030d6f83ef420a2b8f521d94609ecc106ee82",
+                "sha256:f87ac53513d22240c7d59203f25cc3beac1e574c6cd681bbfd321987b69f95fd",
+                "sha256:ff86011bd159a9d2dfc89c34cfd8aff12875980e3bd6a39ff097887520e60249"
             ],
             "markers": "python_version >= '3.9'",
-            "version": "==1.20.1"
+            "version": "==1.22.0"
         }
     },
     "default": {},
     "develop": {
+        "backports.tarfile": {
+            "hashes": [
+                "sha256:77e284d754527b01fb1e6fa8a1afe577858ebe4e9dad8919e34c862cb399bc34",
+                "sha256:d75e02c268746e1b8144c278978b6e98e85de6ad16f8e4b0844a154557eca991"
+            ],
+            "markers": "python_version < '3.12'",
+            "version": "==1.2.0"
+        },
         "black": {
             "hashes": [
-                "sha256:030b9759066a4ee5e5aca28c3c77f9c64789cdd4de8ac1df642c40b708be6171",
-                "sha256:055e59b198df7ac0b7efca5ad7ff2516bca343276c466be72eb04a3bcc1f82d7",
-                "sha256:0e519ecf93120f34243e6b0054db49c00a35f84f195d5bce7e9f5cfc578fc2da",
-                "sha256:172b1dbff09f86ce6f4eb8edf9dede08b1fce58ba194c87d7a4f1a5aa2f5b3c2",
-                "sha256:1e2978f6df243b155ef5fa7e558a43037c3079093ed5d10fd84c43900f2d8ecc",
-                "sha256:33496d5cd1222ad73391352b4ae8da15253c5de89b93a80b3e2c8d9a19ec2666",
-                "sha256:3b48735872ec535027d979e8dcb20bf4f70b5ac75a8ea99f127c106a7d7aba9f",
-                "sha256:4b60580e829091e6f9238c848ea6750efed72140b91b048770b64e74fe04908b",
-                "sha256:759e7ec1e050a15f89b770cefbf91ebee8917aac5c20483bc2d80a6c3a04df32",
-                "sha256:8f0b18a02996a836cc9c9c78e5babec10930862827b1b724ddfe98ccf2f2fe4f",
-                "sha256:95e8176dae143ba9097f351d174fdaf0ccd29efb414b362ae3fd72bf0f710717",
-                "sha256:96c1c7cd856bba8e20094e36e0f948718dc688dba4a9d78c3adde52b9e6c2299",
-                "sha256:a1ee0a0c330f7b5130ce0caed9936a904793576ef4d2b98c40835d6a65afa6a0",
-                "sha256:a22f402b410566e2d1c950708c77ebf5ebd5d0d88a6a2e87c86d9fb48afa0d18",
-                "sha256:a39337598244de4bae26475f77dda852ea00a93bd4c728e09eacd827ec929df0",
-                "sha256:afebb7098bfbc70037a053b91ae8437c3857482d3a690fefc03e9ff7aa9a5fd3",
-                "sha256:bacabb307dca5ebaf9c118d2d2f6903da0d62c9faa82bd21a33eecc319559355",
-                "sha256:bce2e264d59c91e52d8000d507eb20a9aca4a778731a08cfff7e5ac4a4bb7096",
-                "sha256:d9e6827d563a2c820772b32ce8a42828dc6790f095f441beef18f96aa6f8294e",
-                "sha256:db8ea9917d6f8fc62abd90d944920d95e73c83a5ee3383493e35d271aca872e9",
-                "sha256:ea0213189960bda9cf99be5b8c8ce66bb054af5e9e861249cd23471bd7b0b3ba",
-                "sha256:f3df5f1bf91d36002b0a75389ca8663510cf0531cca8aa5c1ef695b46d98655f"
+                "sha256:0172a012f725b792c358d57fe7b6b6e8e67375dd157f64fa7a3097b3ed3e2175",
+                "sha256:0474bca9a0dd1b51791fcc507a4e02078a1c63f6d4e4ae5544b9848c7adfb619",
+                "sha256:154b06d618233fe468236ba1f0e40823d4eb08b26f5e9261526fde34916b9140",
+                "sha256:1b9dc70c21ef8b43248f1d86aedd2aaf75ae110b958a7909ad8463c4aa0880b0",
+                "sha256:2ab0ce111ef026790e9b13bd216fa7bc48edd934ffc4cbf78808b235793cbc92",
+                "sha256:3bec74ee60f8dfef564b573a96b8930f7b6a538e846123d5ad77ba14a8d7a64f",
+                "sha256:456386fe87bad41b806d53c062e2974615825c7a52159cde7ccaeb0695fa28fa",
+                "sha256:474b34c1342cdc157d307b56c4c65bce916480c4a8f6551fdc6bf9b486a7c4ae",
+                "sha256:77e7060a00c5ec4b3367c55f39cf9b06e68965a4f2e61cecacd6d0d9b7ec945a",
+                "sha256:846d58e3ce7879ec1ffe816bb9df6d006cd9590515ed5d17db14e17666b2b357",
+                "sha256:8e46eecf65a095fa62e53245ae2795c90bdecabd53b50c448d0a8bcd0d2e74c4",
+                "sha256:9101ee58ddc2442199a25cb648d46ba22cd580b00ca4b44234a324e3ec7a0f7e",
+                "sha256:a16b14a44c1af60a210d8da28e108e13e75a284bf21a9afa6b4571f96ab8bb9d",
+                "sha256:aaf319612536d502fdd0e88ce52d8f1352b2c0a955cc2798f79eeca9d3af0608",
+                "sha256:b756fc75871cb1bcac5499552d771822fd9db5a2bb8db2a7247936ca48f39831",
+                "sha256:c0372a93e16b3954208417bfe448e09b0de5cc721d521866cd9e0acac3c04a1f",
+                "sha256:ce41ed2614b706fd55fd0b4a6909d06b5bab344ffbfadc6ef34ae50adba3d4f7",
+                "sha256:d119957b37cc641596063cd7db2656c5be3752ac17877017b2ffcdb9dfc4d2b1",
+                "sha256:e3c1f4cd5e93842774d9ee4ef6cd8d17790e65f44f7cdbaab5f2cf8ccf22a823",
+                "sha256:e593466de7b998374ea2585a471ba90553283fb9beefcfa430d84a2651ed5933",
+                "sha256:ef69351df3c84485a8beb6f7b8f9721e2009e20ef80a8d619e2d1788b7816d47",
+                "sha256:f96b6726d690c96c60ba682955199f8c39abc1ae0c3a494a9c62c0184049a713"
             ],
             "index": "pypi",
             "markers": "python_version >= '3.9'",
-            "version": "==25.1.0"
+            "version": "==25.9.0"
         },
         "build": {
             "hashes": [
-                "sha256:1d61c0887fa860c01971625baae8bdd338e517b836a2f70dd1f7aa3a6b2fc5b5",
-                "sha256:b36993e92ca9375a219c99e606a122ff365a760a2d4bba0caa09bd5278b608b7"
+                "sha256:698edd0ea270bde950f53aed21f3a0135672206f3911e0176261a31e0e07b397",
+                "sha256:7145f0b5061ba90a1500d60bd1b13ca0a8a4cebdd0cc16ed8adf1c0e739f43b4"
             ],
             "index": "pypi",
-            "markers": "python_version >= '3.8'",
-            "version": "==1.2.2.post1"
+            "markers": "python_version >= '3.9'",
+            "version": "==1.3.0"
         },
         "certifi": {
             "hashes": [
-                "sha256:0a816057ea3cdefcef70270d2c515e4506bbc954f417fa5ade2021213bb8f0c6",
-                "sha256:30350364dfe371162649852c63336a15c70c6510c2ad5015b21c2345311805f3"
+                "sha256:0f212c2744a9bb6de0c56639a6f68afe01ecd92d91f14ae897c4fe7bbeeef0de",
+                "sha256:47c09d31ccf2acf0be3f701ea53595ee7e0b8fa08801c6624be771df09ae7b43"
             ],
-            "markers": "python_version >= '3.6'",
-            "version": "==2025.4.26"
+            "markers": "python_version >= '3.7'",
+            "version": "==2025.10.5"
         },
         "charset-normalizer": {
             "hashes": [
-                "sha256:005fa3432484527f9732ebd315da8da8001593e2cf46a3d817669f062c3d9ed4",
-                "sha256:046595208aae0120559a67693ecc65dd75d46f7bf687f159127046628178dc45",
-                "sha256:0c29de6a1a95f24b9a1aa7aefd27d2487263f00dfd55a77719b530788f75cff7",
-                "sha256:0c8c57f84ccfc871a48a47321cfa49ae1df56cd1d965a09abe84066f6853b9c0",
-                "sha256:0f5d9ed7f254402c9e7d35d2f5972c9bbea9040e99cd2861bd77dc68263277c7",
-                "sha256:18dd2e350387c87dabe711b86f83c9c78af772c748904d372ade190b5c7c9d4d",
-                "sha256:1b1bde144d98e446b056ef98e59c256e9294f6b74d7af6846bf5ffdafd687a7d",
-                "sha256:1c95a1e2902a8b722868587c0e1184ad5c55631de5afc0eb96bc4b0d738092c0",
-                "sha256:1cad5f45b3146325bb38d6855642f6fd609c3f7cad4dbaf75549bf3b904d3184",
-                "sha256:21b2899062867b0e1fde9b724f8aecb1af14f2778d69aacd1a5a1853a597a5db",
-                "sha256:24498ba8ed6c2e0b56d4acbf83f2d989720a93b41d712ebd4f4979660db4417b",
-                "sha256:25a23ea5c7edc53e0f29bae2c44fcb5a1aa10591aae107f2a2b2583a9c5cbc64",
-                "sha256:289200a18fa698949d2b39c671c2cc7a24d44096784e76614899a7ccf2574b7b",
-                "sha256:28a1005facc94196e1fb3e82a3d442a9d9110b8434fc1ded7a24a2983c9888d8",
-                "sha256:32fc0341d72e0f73f80acb0a2c94216bd704f4f0bce10aedea38f30502b271ff",
-                "sha256:36b31da18b8890a76ec181c3cf44326bf2c48e36d393ca1b72b3f484113ea344",
-                "sha256:3c21d4fca343c805a52c0c78edc01e3477f6dd1ad7c47653241cf2a206d4fc58",
-                "sha256:3fddb7e2c84ac87ac3a947cb4e66d143ca5863ef48e4a5ecb83bd48619e4634e",
-                "sha256:43e0933a0eff183ee85833f341ec567c0980dae57c464d8a508e1b2ceb336471",
-                "sha256:4a476b06fbcf359ad25d34a057b7219281286ae2477cc5ff5e3f70a246971148",
-                "sha256:4e594135de17ab3866138f496755f302b72157d115086d100c3f19370839dd3a",
-                "sha256:50bf98d5e563b83cc29471fa114366e6806bc06bc7a25fd59641e41445327836",
-                "sha256:5a9979887252a82fefd3d3ed2a8e3b937a7a809f65dcb1e068b090e165bbe99e",
-                "sha256:5baececa9ecba31eff645232d59845c07aa030f0c81ee70184a90d35099a0e63",
-                "sha256:5bf4545e3b962767e5c06fe1738f951f77d27967cb2caa64c28be7c4563e162c",
-                "sha256:6333b3aa5a12c26b2a4d4e7335a28f1475e0e5e17d69d55141ee3cab736f66d1",
-                "sha256:65c981bdbd3f57670af8b59777cbfae75364b483fa8a9f420f08094531d54a01",
-                "sha256:68a328e5f55ec37c57f19ebb1fdc56a248db2e3e9ad769919a58672958e8f366",
-                "sha256:6a0289e4589e8bdfef02a80478f1dfcb14f0ab696b5a00e1f4b8a14a307a3c58",
-                "sha256:6b66f92b17849b85cad91259efc341dce9c1af48e2173bf38a85c6329f1033e5",
-                "sha256:6c9379d65defcab82d07b2a9dfbfc2e95bc8fe0ebb1b176a3190230a3ef0e07c",
-                "sha256:6fc1f5b51fa4cecaa18f2bd7a003f3dd039dd615cd69a2afd6d3b19aed6775f2",
-                "sha256:70f7172939fdf8790425ba31915bfbe8335030f05b9913d7ae00a87d4395620a",
-                "sha256:721c76e84fe669be19c5791da68232ca2e05ba5185575086e384352e2c309597",
-                "sha256:7222ffd5e4de8e57e03ce2cef95a4c43c98fcb72ad86909abdfc2c17d227fc1b",
-                "sha256:75d10d37a47afee94919c4fab4c22b9bc2a8bf7d4f46f87363bcf0573f3ff4f5",
-                "sha256:76af085e67e56c8816c3ccf256ebd136def2ed9654525348cfa744b6802b69eb",
-                "sha256:770cab594ecf99ae64c236bc9ee3439c3f46be49796e265ce0cc8bc17b10294f",
-                "sha256:7a6ab32f7210554a96cd9e33abe3ddd86732beeafc7a28e9955cdf22ffadbab0",
-                "sha256:7c48ed483eb946e6c04ccbe02c6b4d1d48e51944b6db70f697e089c193404941",
-                "sha256:7f56930ab0abd1c45cd15be65cc741c28b1c9a34876ce8c17a2fa107810c0af0",
-                "sha256:8075c35cd58273fee266c58c0c9b670947c19df5fb98e7b66710e04ad4e9ff86",
-                "sha256:8272b73e1c5603666618805fe821edba66892e2870058c94c53147602eab29c7",
-                "sha256:82d8fd25b7f4675d0c47cf95b594d4e7b158aca33b76aa63d07186e13c0e0ab7",
-                "sha256:844da2b5728b5ce0e32d863af26f32b5ce61bc4273a9c720a9f3aa9df73b1455",
-                "sha256:8755483f3c00d6c9a77f490c17e6ab0c8729e39e6390328e42521ef175380ae6",
-                "sha256:915f3849a011c1f593ab99092f3cecfcb4d65d8feb4a64cf1bf2d22074dc0ec4",
-                "sha256:926ca93accd5d36ccdabd803392ddc3e03e6d4cd1cf17deff3b989ab8e9dbcf0",
-                "sha256:982bb1e8b4ffda883b3d0a521e23abcd6fd17418f6d2c4118d257a10199c0ce3",
-                "sha256:98f862da73774290f251b9df8d11161b6cf25b599a66baf087c1ffe340e9bfd1",
-                "sha256:9cbfacf36cb0ec2897ce0ebc5d08ca44213af24265bd56eca54bee7923c48fd6",
-                "sha256:a370b3e078e418187da8c3674eddb9d983ec09445c99a3a263c2011993522981",
-                "sha256:a955b438e62efdf7e0b7b52a64dc5c3396e2634baa62471768a64bc2adb73d5c",
-                "sha256:aa6af9e7d59f9c12b33ae4e9450619cf2488e2bbe9b44030905877f0b2324980",
-                "sha256:aa88ca0b1932e93f2d961bf3addbb2db902198dca337d88c89e1559e066e7645",
-                "sha256:aaeeb6a479c7667fbe1099af9617c83aaca22182d6cf8c53966491a0f1b7ffb7",
-                "sha256:aaf27faa992bfee0264dc1f03f4c75e9fcdda66a519db6b957a3f826e285cf12",
-                "sha256:b2680962a4848b3c4f155dc2ee64505a9c57186d0d56b43123b17ca3de18f0fa",
-                "sha256:b2d318c11350e10662026ad0eb71bb51c7812fc8590825304ae0bdd4ac283acd",
-                "sha256:b33de11b92e9f75a2b545d6e9b6f37e398d86c3e9e9653c4864eb7e89c5773ef",
-                "sha256:b3daeac64d5b371dea99714f08ffc2c208522ec6b06fbc7866a450dd446f5c0f",
-                "sha256:be1e352acbe3c78727a16a455126d9ff83ea2dfdcbc83148d2982305a04714c2",
-                "sha256:bee093bf902e1d8fc0ac143c88902c3dfc8941f7ea1d6a8dd2bcb786d33db03d",
-                "sha256:c72fbbe68c6f32f251bdc08b8611c7b3060612236e960ef848e0a517ddbe76c5",
-                "sha256:c9e36a97bee9b86ef9a1cf7bb96747eb7a15c2f22bdb5b516434b00f2a599f02",
-                "sha256:cddf7bd982eaa998934a91f69d182aec997c6c468898efe6679af88283b498d3",
-                "sha256:cf713fe9a71ef6fd5adf7a79670135081cd4431c2943864757f0fa3a65b1fafd",
-                "sha256:d11b54acf878eef558599658b0ffca78138c8c3655cf4f3a4a673c437e67732e",
-                "sha256:d41c4d287cfc69060fa91cae9683eacffad989f1a10811995fa309df656ec214",
-                "sha256:d524ba3f1581b35c03cb42beebab4a13e6cdad7b36246bd22541fa585a56cccd",
-                "sha256:daac4765328a919a805fa5e2720f3e94767abd632ae410a9062dff5412bae65a",
-                "sha256:db4c7bf0e07fc3b7d89ac2a5880a6a8062056801b83ff56d8464b70f65482b6c",
-                "sha256:dc7039885fa1baf9be153a0626e337aa7ec8bf96b0128605fb0d77788ddc1681",
-                "sha256:dccab8d5fa1ef9bfba0590ecf4d46df048d18ffe3eec01eeb73a42e0d9e7a8ba",
-                "sha256:dedb8adb91d11846ee08bec4c8236c8549ac721c245678282dcb06b221aab59f",
-                "sha256:e45ba65510e2647721e35323d6ef54c7974959f6081b58d4ef5d87c60c84919a",
-                "sha256:e53efc7c7cee4c1e70661e2e112ca46a575f90ed9ae3fef200f2a25e954f4b28",
-                "sha256:e635b87f01ebc977342e2697d05b56632f5f879a4f15955dfe8cef2448b51691",
-                "sha256:e70e990b2137b29dc5564715de1e12701815dacc1d056308e2b17e9095372a82",
-                "sha256:e8082b26888e2f8b36a042a58307d5b917ef2b1cacab921ad3323ef91901c71a",
-                "sha256:e8323a9b031aa0393768b87f04b4164a40037fb2a3c11ac06a03ffecd3618027",
-                "sha256:e92fca20c46e9f5e1bb485887d074918b13543b1c2a1185e69bb8d17ab6236a7",
-                "sha256:eb30abc20df9ab0814b5a2524f23d75dcf83cde762c161917a2b4b7b55b1e518",
-                "sha256:eba9904b0f38a143592d9fc0e19e2df0fa2e41c3c3745554761c5f6447eedabf",
-                "sha256:ef8de666d6179b009dce7bcb2ad4c4a779f113f12caf8dc77f0162c29d20490b",
-                "sha256:efd387a49825780ff861998cd959767800d54f8308936b21025326de4b5a42b9",
-                "sha256:f0aa37f3c979cf2546b73e8222bbfa3dc07a641585340179d768068e3455e544",
-                "sha256:f4074c5a429281bf056ddd4c5d3b740ebca4d43ffffe2ef4bf4d2d05114299da",
-                "sha256:f69a27e45c43520f5487f27627059b64aaf160415589230992cec34c5e18a509",
-                "sha256:fb707f3e15060adf5b7ada797624a6c6e0138e2a26baa089df64c68ee98e040f",
-                "sha256:fcbe676a55d7445b22c10967bceaaf0ee69407fbe0ece4d032b6eb8d4565982a",
-                "sha256:fdb20a30fe1175ecabed17cbf7812f7b804b8a315a25f24678bcdf120a90077f"
+                "sha256:027f6de494925c0ab2a55eab46ae5129951638a49a34d87f4c3eda90f696b4ad",
+                "sha256:077fbb858e903c73f6c9db43374fd213b0b6a778106bc7032446a8e8b5b38b93",
+                "sha256:0a98e6759f854bd25a58a73fa88833fba3b7c491169f86ce1180c948ab3fd394",
+                "sha256:0d3d8f15c07f86e9ff82319b3d9ef6f4bf907608f53fe9d92b28ea9ae3d1fd89",
+                "sha256:0f04b14ffe5fdc8c4933862d8306109a2c51e0704acfa35d51598eb45a1e89fc",
+                "sha256:11d694519d7f29d6cd09f6ac70028dba10f92f6cdd059096db198c283794ac86",
+                "sha256:194f08cbb32dc406d6e1aea671a68be0823673db2832b38405deba2fb0d88f63",
+                "sha256:1bee1e43c28aa63cb16e5c14e582580546b08e535299b8b6158a7c9c768a1f3d",
+                "sha256:21d142cc6c0ec30d2efee5068ca36c128a30b0f2c53c1c07bd78cb6bc1d3be5f",
+                "sha256:2437418e20515acec67d86e12bf70056a33abdacb5cb1655042f6538d6b085a8",
+                "sha256:244bfb999c71b35de57821b8ea746b24e863398194a4014e4c76adc2bbdfeff0",
+                "sha256:2677acec1a2f8ef614c6888b5b4ae4060cc184174a938ed4e8ef690e15d3e505",
+                "sha256:277e970e750505ed74c832b4bf75dac7476262ee2a013f5574dd49075879e161",
+                "sha256:2aaba3b0819274cc41757a1da876f810a3e4d7b6eb25699253a4effef9e8e4af",
+                "sha256:2b7d8f6c26245217bd2ad053761201e9f9680f8ce52f0fcd8d0755aeae5b2152",
+                "sha256:2c9d3c380143a1fedbff95a312aa798578371eb29da42106a29019368a475318",
+                "sha256:3162d5d8ce1bb98dd51af660f2121c55d0fa541b46dff7bb9b9f86ea1d87de72",
+                "sha256:31fd66405eaf47bb62e8cd575dc621c56c668f27d46a61d975a249930dd5e2a4",
+                "sha256:362d61fd13843997c1c446760ef36f240cf81d3ebf74ac62652aebaf7838561e",
+                "sha256:376bec83a63b8021bb5c8ea75e21c4ccb86e7e45ca4eb81146091b56599b80c3",
+                "sha256:44c2a8734b333e0578090c4cd6b16f275e07aa6614ca8715e6c038e865e70576",
+                "sha256:47cc91b2f4dd2833fddaedd2893006b0106129d4b94fdb6af1f4ce5a9965577c",
+                "sha256:4902828217069c3c5c71094537a8e623f5d097858ac6ca8252f7b4d10b7560f1",
+                "sha256:4bd5d4137d500351a30687c2d3971758aac9a19208fc110ccb9d7188fbe709e8",
+                "sha256:4fe7859a4e3e8457458e2ff592f15ccb02f3da787fcd31e0183879c3ad4692a1",
+                "sha256:542d2cee80be6f80247095cc36c418f7bddd14f4a6de45af91dfad36d817bba2",
+                "sha256:554af85e960429cf30784dd47447d5125aaa3b99a6f0683589dbd27e2f45da44",
+                "sha256:5833d2c39d8896e4e19b689ffc198f08ea58116bee26dea51e362ecc7cd3ed26",
+                "sha256:5947809c8a2417be3267efc979c47d76a079758166f7d43ef5ae8e9f92751f88",
+                "sha256:5ae497466c7901d54b639cf42d5b8c1b6a4fead55215500d2f486d34db48d016",
+                "sha256:5bd2293095d766545ec1a8f612559f6b40abc0eb18bb2f5d1171872d34036ede",
+                "sha256:5bfbb1b9acf3334612667b61bd3002196fe2a1eb4dd74d247e0f2a4d50ec9bbf",
+                "sha256:5cb4d72eea50c8868f5288b7f7f33ed276118325c1dfd3957089f6b519e1382a",
+                "sha256:5dbe56a36425d26d6cfb40ce79c314a2e4dd6211d51d6d2191c00bed34f354cc",
+                "sha256:5f819d5fe9234f9f82d75bdfa9aef3a3d72c4d24a6e57aeaebba32a704553aa0",
+                "sha256:64b55f9dce520635f018f907ff1b0df1fdc31f2795a922fb49dd14fbcdf48c84",
+                "sha256:6515f3182dbe4ea06ced2d9e8666d97b46ef4c75e326b79bb624110f122551db",
+                "sha256:65e2befcd84bc6f37095f5961e68a6f077bf44946771354a28ad434c2cce0ae1",
+                "sha256:6aee717dcfead04c6eb1ce3bd29ac1e22663cdea57f943c87d1eab9a025438d7",
+                "sha256:6b39f987ae8ccdf0d2642338faf2abb1862340facc796048b604ef14919e55ed",
+                "sha256:6e1fcf0720908f200cd21aa4e6750a48ff6ce4afe7ff5a79a90d5ed8a08296f8",
+                "sha256:74018750915ee7ad843a774364e13a3db91682f26142baddf775342c3f5b1133",
+                "sha256:74664978bb272435107de04e36db5a9735e78232b85b77d45cfb38f758efd33e",
+                "sha256:74bb723680f9f7a6234dcf67aea57e708ec1fbdf5699fb91dfd6f511b0a320ef",
+                "sha256:752944c7ffbfdd10c074dc58ec2d5a8a4cd9493b314d367c14d24c17684ddd14",
+                "sha256:778d2e08eda00f4256d7f672ca9fef386071c9202f5e4607920b86d7803387f2",
+                "sha256:780236ac706e66881f3b7f2f32dfe90507a09e67d1d454c762cf642e6e1586e0",
+                "sha256:798d75d81754988d2565bff1b97ba5a44411867c0cf32b77a7e8f8d84796b10d",
+                "sha256:799a7a5e4fb2d5898c60b640fd4981d6a25f1c11790935a44ce38c54e985f828",
+                "sha256:7a32c560861a02ff789ad905a2fe94e3f840803362c84fecf1851cb4cf3dc37f",
+                "sha256:7c308f7e26e4363d79df40ca5b2be1c6ba9f02bdbccfed5abddb7859a6ce72cf",
+                "sha256:7fa17817dc5625de8a027cb8b26d9fefa3ea28c8253929b8d6649e705d2835b6",
+                "sha256:81d5eb2a312700f4ecaa977a8235b634ce853200e828fbadf3a9c50bab278328",
+                "sha256:82004af6c302b5d3ab2cfc4cc5f29db16123b1a8417f2e25f9066f91d4411090",
+                "sha256:837c2ce8c5a65a2035be9b3569c684358dfbf109fd3b6969630a87535495ceaa",
+                "sha256:840c25fb618a231545cbab0564a799f101b63b9901f2569faecd6b222ac72381",
+                "sha256:8a6562c3700cce886c5be75ade4a5db4214fda19fede41d9792d100288d8f94c",
+                "sha256:8af65f14dc14a79b924524b1e7fffe304517b2bff5a58bf64f30b98bbc5079eb",
+                "sha256:8ef3c867360f88ac904fd3f5e1f902f13307af9052646963ee08ff4f131adafc",
+                "sha256:94537985111c35f28720e43603b8e7b43a6ecfb2ce1d3058bbe955b73404e21a",
+                "sha256:99ae2cffebb06e6c22bdc25801d7b30f503cc87dbd283479e7b606f70aff57ec",
+                "sha256:9a26f18905b8dd5d685d6d07b0cdf98a79f3c7a918906af7cc143ea2e164c8bc",
+                "sha256:9b35f4c90079ff2e2edc5b26c0c77925e5d2d255c42c74fdb70fb49b172726ac",
+                "sha256:9cd98cdc06614a2f768d2b7286d66805f94c48cde050acdbbb7db2600ab3197e",
+                "sha256:9d1bb833febdff5c8927f922386db610b49db6e0d4f4ee29601d71e7c2694313",
+                "sha256:9f7fcd74d410a36883701fafa2482a6af2ff5ba96b9a620e9e0721e28ead5569",
+                "sha256:a59cb51917aa591b1c4e6a43c132f0cdc3c76dbad6155df4e28ee626cc77a0a3",
+                "sha256:a61900df84c667873b292c3de315a786dd8dac506704dea57bc957bd31e22c7d",
+                "sha256:a79cfe37875f822425b89a82333404539ae63dbdddf97f84dcbc3d339aae9525",
+                "sha256:a8a8b89589086a25749f471e6a900d3f662d1d3b6e2e59dcecf787b1cc3a1894",
+                "sha256:a8bf8d0f749c5757af2142fe7903a9df1d2e8aa3841559b2bad34b08d0e2bcf3",
+                "sha256:a9768c477b9d7bd54bc0c86dbaebdec6f03306675526c9927c0e8a04e8f94af9",
+                "sha256:ac1c4a689edcc530fc9d9aa11f5774b9e2f33f9a0c6a57864e90908f5208d30a",
+                "sha256:af2d8c67d8e573d6de5bc30cdb27e9b95e49115cd9baad5ddbd1a6207aaa82a9",
+                "sha256:b435cba5f4f750aa6c0a0d92c541fb79f69a387c91e61f1795227e4ed9cece14",
+                "sha256:b5b290ccc2a263e8d185130284f8501e3e36c5e02750fc6b6bdeb2e9e96f1e25",
+                "sha256:b5d84d37db046c5ca74ee7bb47dd6cbc13f80665fdde3e8040bdd3fb015ecb50",
+                "sha256:b7cf1017d601aa35e6bb650b6ad28652c9cd78ee6caff19f3c28d03e1c80acbf",
+                "sha256:bc7637e2f80d8530ee4a78e878bce464f70087ce73cf7c1caf142416923b98f1",
+                "sha256:c0463276121fdee9c49b98908b3a89c39be45d86d1dbaa22957e38f6321d4ce3",
+                "sha256:c4ef880e27901b6cc782f1b95f82da9313c0eb95c3af699103088fa0ac3ce9ac",
+                "sha256:c8ae8a0f02f57a6e61203a31428fa1d677cbe50c93622b4149d5c0f319c1d19e",
+                "sha256:ca5862d5b3928c4940729dacc329aa9102900382fea192fc5e52eb69d6093815",
+                "sha256:cb01158d8b88ee68f15949894ccc6712278243d95f344770fa7593fa2d94410c",
+                "sha256:cb6254dc36b47a990e59e1068afacdcd02958bdcce30bb50cc1700a8b9d624a6",
+                "sha256:cc00f04ed596e9dc0da42ed17ac5e596c6ccba999ba6bd92b0e0aef2f170f2d6",
+                "sha256:cd09d08005f958f370f539f186d10aec3377d55b9eeb0d796025d4886119d76e",
+                "sha256:cd4b7ca9984e5e7985c12bc60a6f173f3c958eae74f3ef6624bb6b26e2abbae4",
+                "sha256:ce8a0633f41a967713a59c4139d29110c07e826d131a316b50ce11b1d79b4f84",
+                "sha256:cead0978fc57397645f12578bfd2d5ea9138ea0fac82b2f63f7f7c6877986a69",
+                "sha256:d055ec1e26e441f6187acf818b73564e6e6282709e9bcb5b63f5b23068356a15",
+                "sha256:d1f13550535ad8cff21b8d757a3257963e951d96e20ec82ab44bc64aeb62a191",
+                "sha256:d9c7f57c3d666a53421049053eaacdd14bbd0a528e2186fcb2e672effd053bb0",
+                "sha256:d9e45d7faa48ee908174d8fe84854479ef838fc6a705c9315372eacbc2f02897",
+                "sha256:da3326d9e65ef63a817ecbcc0df6e94463713b754fe293eaa03da99befb9a5bd",
+                "sha256:de00632ca48df9daf77a2c65a484531649261ec9f25489917f09e455cb09ddb2",
+                "sha256:e1f185f86a6f3403aa2420e815904c67b2f9ebc443f045edd0de921108345794",
+                "sha256:e824f1492727fa856dd6eda4f7cee25f8518a12f3c4a56a74e8095695089cf6d",
+                "sha256:e912091979546adf63357d7e2ccff9b44f026c075aeaf25a52d0e95ad2281074",
+                "sha256:eaabd426fe94daf8fd157c32e571c85cb12e66692f15516a83a03264b08d06c3",
+                "sha256:ebf3e58c7ec8a8bed6d66a75d7fb37b55e5015b03ceae72a8e7c74495551e224",
+                "sha256:ecaae4149d99b1c9e7b88bb03e3221956f68fd6d50be2ef061b2381b61d20838",
+                "sha256:eecbc200c7fd5ddb9a7f16c7decb07b566c29fa2161a16cf67b8d068bd21690a",
+                "sha256:f155a433c2ec037d4e8df17d18922c3a0d9b3232a396690f17175d2946f0218d",
+                "sha256:f1e34719c6ed0b92f418c7c780480b26b5d9c50349e9a9af7d76bf757530350d",
+                "sha256:f34be2938726fc13801220747472850852fe6b1ea75869a048d6f896838c896f",
+                "sha256:f820802628d2694cb7e56db99213f930856014862f3fd943d290ea8438d07ca8",
+                "sha256:f8bf04158c6b607d747e93949aa60618b61312fe647a6369f88ce2ff16043490",
+                "sha256:f8e160feb2aed042cd657a72acc0b481212ed28b1b9a95c0cee1621b524e1966",
+                "sha256:f9d332f8c2a2fcbffe1378594431458ddbef721c1769d78e2cbc06280d8155f9",
+                "sha256:fa09f53c465e532f4d3db095e0c55b615f010ad81803d383195b6b5ca6cbf5f3",
+                "sha256:faa3a41b2b66b6e50f84ae4a68c64fcd0c44355741c6374813a800cd6695db9e",
+                "sha256:fd44c878ea55ba351104cb93cc85e74916eb8fa440ca7903e57575e97394f608"
             ],
             "markers": "python_version >= '3.7'",
-            "version": "==3.4.2"
+            "version": "==3.4.4"
         },
         "click": {
             "hashes": [
-                "sha256:27c491cc05d968d271d5a1db13e3b5a184636d9d930f148c50b038f0d0646202",
-                "sha256:61a3265b914e850b85317d0b3109c7f8cd35a670f963866005d6ef1d5175a12b"
+                "sha256:9b9f285302c6e3064f4330c05f05b81945b2a39544279343e6e7c5f27a9baddc",
+                "sha256:e7b8232224eba16f4ebe410c25ced9f7875cb5f3263ffc93cc3e8da705e229c4"
             ],
             "markers": "python_version >= '3.10'",
-            "version": "==8.2.1"
+            "version": "==8.3.0"
         },
         "docutils": {
             "hashes": [
-                "sha256:3a6b18732edf182daa3cd12775bbb338cf5691468f91eeeb109deff6ebfa986f",
-                "sha256:dafca5b9e384f0e419294eb4d2ff9fa826435bf15f15b7bd45723e8ad76811b2"
+                "sha256:9fdb771707c8784c8f2728b67cb2c691305933d68137ef95a75db5f4dfbc213d",
+                "sha256:b0e98d679283fc3bb0ead8a5da7f501baa632654e7056e9c5846842213d674d8"
             ],
             "markers": "python_version >= '3.9'",
-            "version": "==0.21.2"
+            "version": "==0.22.2"
         },
         "flake8": {
             "hashes": [
-                "sha256:93b92ba5bdb60754a6da14fa3b93a9361fd00a59632ada61fd7b130436c40343",
-                "sha256:fa558ae3f6f7dbf2b4f22663e5343b6b6023620461f8d4ff2019ef4b5ee70426"
+                "sha256:b9696257b9ce8beb888cdbe31cf885c90d31928fe202be0889a7cdafad32f01e",
+                "sha256:fe044858146b9fc69b551a4b490d69cf960fcb78ad1edcb84e7fbb1b4a8e3872"
             ],
             "index": "pypi",
             "markers": "python_version >= '3.9'",
-            "version": "==7.2.0"
+            "version": "==7.3.0"
         },
         "id": {
             "hashes": [
@@ -757,11 +946,11 @@
         },
         "idna": {
             "hashes": [
-                "sha256:12f65c9b470abda6dc35cf8e63cc574b1c52b11df2c86030af0ac09b01b13ea9",
-                "sha256:946d195a0d259cbba61165e88e65941f16e9b36ea6ddb97f00452bae8b1287d3"
+                "sha256:771a87f49d9defaf64091e6e6fe9c18d4833f140bd19464795bc32d966ca37ea",
+                "sha256:795dafcc9c04ed0c1fb032c2aa73654d8e8c5023a7df64a53f39190ada629902"
             ],
-            "markers": "python_version >= '3.6'",
-            "version": "==3.10"
+            "markers": "python_version >= '3.8'",
+            "version": "==3.11"
         },
         "importlib-metadata": {
             "hashes": [
@@ -798,11 +987,11 @@
         },
         "jaraco.functools": {
             "hashes": [
-                "sha256:70f7e0e2ae076498e212562325e805204fc092d7b4c17e0e86c959e249701a9d",
-                "sha256:ad159f13428bc4acbf5541ad6dec511f91573b90fba04df61dafa2a1231cf649"
+                "sha256:227ff8ed6f7b8f62c56deff101545fa7543cf2c8e7b82a7c2116e672f29c26e8",
+                "sha256:cfd13ad0dd2c47a3600b439ef72d8615d482cedcff1632930d6f28924d92f294"
             ],
-            "markers": "python_version >= '3.8'",
-            "version": "==4.1.0"
+            "markers": "python_version >= '3.9'",
+            "version": "==4.3.0"
         },
         "keyring": {
             "hashes": [
@@ -814,11 +1003,11 @@
         },
         "markdown-it-py": {
             "hashes": [
-                "sha256:355216845c60bd96232cd8d8c40e8f9765cc86f46880e43a8fd22dc1a1a8cab1",
-                "sha256:e3f60a94fa066dc52ec76661e37c851cb232d92f9886b15cb560aaada2df8feb"
+                "sha256:87327c59b172c5011896038353a81343b6754500a08cd7a4973bb48c6d578147",
+                "sha256:cb0a2b4aa34f932c007117b194e945bd74e0ec24133ceb5bac59009cda1cb9f3"
             ],
-            "markers": "python_version >= '3.8'",
-            "version": "==3.0.0"
+            "markers": "python_version >= '3.10'",
+            "version": "==4.0.0"
         },
         "mccabe": {
             "hashes": [
@@ -838,11 +1027,11 @@
         },
         "more-itertools": {
             "hashes": [
-                "sha256:9fddd5403be01a94b204faadcff459ec3568cf110265d3c54323e1e866ad29d3",
-                "sha256:d43980384673cb07d2f7d2d918c616b30c659c089ee23953f601d6609c67510e"
+                "sha256:52d4362373dcf7c52546bc4af9a86ee7c4579df9a8dc268be0a2f949d376cc9b",
+                "sha256:f638ddf8a1a0d134181275fb5d58b086ead7c6a72429ad725c67503f13ba30bd"
             ],
             "markers": "python_version >= '3.9'",
-            "version": "==10.7.0"
+            "version": "==10.8.0"
         },
         "mypy-extensions": {
             "hashes": [
@@ -854,33 +1043,35 @@
         },
         "nh3": {
             "hashes": [
-                "sha256:087ffadfdcd497658c3adc797258ce0f06be8a537786a7217649fc1c0c60c293",
-                "sha256:20979783526641c81d2f5bfa6ca5ccca3d1e4472474b162c6256745fbfe31cd1",
-                "sha256:2a5174551f95f2836f2ad6a8074560f261cf9740a48437d6151fd2d4d7d617ab",
-                "sha256:31eedcd7d08b0eae28ba47f43fd33a653b4cdb271d64f1aeda47001618348fde",
-                "sha256:4990e7ee6a55490dbf00d61a6f476c9a3258e31e711e13713b2ea7d6616f670e",
-                "sha256:55823c5ea1f6b267a4fad5de39bc0524d49a47783e1fe094bcf9c537a37df251",
-                "sha256:6141caabe00bbddc869665b35fc56a478eb774a8c1dfd6fba9fe1dfdf29e6efa",
-                "sha256:637d4a10c834e1b7d9548592c7aad760611415fcd5bd346f77fd8a064309ae6d",
-                "sha256:63ca02ac6f27fc80f9894409eb61de2cb20ef0a23740c7e29f9ec827139fa578",
-                "sha256:6ae319f17cd8960d0612f0f0ddff5a90700fa71926ca800e9028e7851ce44a6f",
-                "sha256:6c9c30b8b0d291a7c5ab0967ab200598ba33208f754f2f4920e9343bdd88f79a",
-                "sha256:713d16686596e556b65e7f8c58328c2df63f1a7abe1277d87625dcbbc012ef82",
-                "sha256:818f2b6df3763e058efa9e69677b5a92f9bc0acff3295af5ed013da544250d5b",
-                "sha256:9d67709bc0d7d1f5797b21db26e7a8b3d15d21c9c5f58ccfe48b5328483b685b",
-                "sha256:a5f77e62aed5c4acad635239ac1290404c7e940c81abe561fd2af011ff59f585",
-                "sha256:a772dec5b7b7325780922dd904709f0f5f3a79fbf756de5291c01370f6df0967",
-                "sha256:a7ea28cd49293749d67e4fcf326c554c83ec912cd09cd94aa7ec3ab1921c8283",
-                "sha256:ac7006c3abd097790e611fe4646ecb19a8d7f2184b882f6093293b8d9b887431",
-                "sha256:b3b5c58161e08549904ac4abd450dacd94ff648916f7c376ae4b2c0652b98ff9",
-                "sha256:b8d55ea1fc7ae3633d758a92aafa3505cd3cc5a6e40470c9164d54dff6f96d42",
-                "sha256:bb0014948f04d7976aabae43fcd4cb7f551f9f8ce785a4c9ef66e6c2590f8629",
-                "sha256:d002b648592bf3033adfd875a48f09b8ecc000abd7f6a8769ed86b6ccc70c759",
-                "sha256:d426d7be1a2f3d896950fe263332ed1662f6c78525b4520c8e9861f8d7f0d243",
-                "sha256:fcff321bd60c6c5c9cb4ddf2554e22772bb41ebd93ad88171bbbb6f271255286"
+                "sha256:0f454ba4c6aabafcaae964ae6f0a96cecef970216a57335fabd229a265fbe007",
+                "sha256:1de5c1a35bed19a1b1286bab3c3abfe42e990a8a6c4ce9bb9ab4bde49107ea3b",
+                "sha256:22b9e9c9eda497b02b7273b79f7d29e1f1170d2b741624c1b8c566aef28b1f48",
+                "sha256:2cb6d9e192fbe0d451c7cb1350dadedbeae286207dbf101a28210193d019752e",
+                "sha256:38b4872499ab15b17c5c6e9f091143d070d75ddad4a4d1ce388d043ca556629c",
+                "sha256:42e426f36e167ed29669b77ae3c4b9e185e4a1b130a86d7c3249194738a1d7b2",
+                "sha256:474b176124c1b495ccfa1c20f61b7eb83ead5ecccb79ab29f602c148e8378489",
+                "sha256:48425995d37880281b467f7cf2b3218c1f4750c55bcb1ff4f47f2320a2bb159c",
+                "sha256:489ca5ecd58555c2865701e65f614b17555179e71ecc76d483b6f3886b813a9b",
+                "sha256:4a2434668f4eef4eab17c128e565ce6bea42113ce10c40b928e42c578d401800",
+                "sha256:5a25662b392b06f251da6004a1f8a828dca7f429cd94ac07d8a98ba94d644438",
+                "sha256:669a908706cd28203d9cfce2f567575686e364a1bc6074d413d88d456066f743",
+                "sha256:670f18b09f75c86c3865f79543bf5acd4bbe2a5a4475672eef2399dd8cdb69d2",
+                "sha256:6a854480058683d60bdc7f0456105092dae17bef1f300642856d74bd4201da93",
+                "sha256:80dc7563a2a3b980e44b221f69848e3645bbf163ab53e3d1add4f47b26120355",
+                "sha256:8f600ad86114df21efc4a3592faa6b1d099c0eebc7e018efebb1c133376097da",
+                "sha256:94292dd1bd2a2e142fa5bb94c0ee1d84433a5d9034640710132da7e0376fca3a",
+                "sha256:a3e810a92fb192373204456cac2834694440af73d749565b4348e30235da7f0b",
+                "sha256:a5721f59afa0ab3dcaa0d47e58af33a5fcd254882e1900ee4a8968692a40f79d",
+                "sha256:b0d6c834d3c07366ecbdcecc1f4804c5ce0a77fa52ee4653a2a26d2d909980ea",
+                "sha256:b222c05ae5139320da6caa1c5aed36dd0ee36e39831541d9b56e048a63b4d701",
+                "sha256:b74bbd047b361c0f21d827250c865ff0895684d9fcf85ea86131a78cfa0b835b",
+                "sha256:c0acef923a1c3a2df3ee5825ea79c149b6748c6449781c53ab6923dc75e87d26",
+                "sha256:d7431b2a39431017f19cd03144005b6c014201b3e73927c05eab6ca37bb1d98c",
+                "sha256:dd6d1be301123a9af3263739726eeeb208197e5e78fc4f522408c50de77a5354",
+                "sha256:eaba26591867f697cffdbc539faddeb1d75a36273f5bfe957eb421d3f87d7da1"
             ],
             "markers": "python_version >= '3.8'",
-            "version": "==0.2.21"
+            "version": "==0.3.1"
         },
         "packaging": {
             "hashes": [
@@ -900,11 +1091,11 @@
         },
         "platformdirs": {
             "hashes": [
-                "sha256:3d512d96e16bcb959a814c9f348431070822a6496326a4be0911c40b5a74c2bc",
-                "sha256:ff7059bb7eb1179e2685604f4aaf157cfd9535242bd23742eadc3c13542139b4"
+                "sha256:70ddccdd7c99fc5942e9fc25636a8b34d04c24b335100223152c2803e4063312",
+                "sha256:e578a81bb873cbb89a41fcc904c7ef523cc18284b7e3b3ccf06aca1403b7ebd3"
             ],
-            "markers": "python_version >= '3.9'",
-            "version": "==4.3.8"
+            "markers": "python_version >= '3.10'",
+            "version": "==4.5.0"
         },
         "pluggy": {
             "hashes": [
@@ -916,27 +1107,27 @@
         },
         "pycodestyle": {
             "hashes": [
-                "sha256:35863c5974a271c7a726ed228a14a4f6daf49df369d8c50cd9a6f58a5e143ba9",
-                "sha256:c8415bf09abe81d9c7f872502a6eee881fbe85d8763dd5b9924bb0a01d67efae"
+                "sha256:c4b5b517d278089ff9d0abdec919cd97262a3367449ea1c8b49b91529167b783",
+                "sha256:dd6bf7cb4ee77f8e016f9c8e74a35ddd9f67e1d5fd4184d86c3b98e07099f42d"
             ],
             "markers": "python_version >= '3.9'",
-            "version": "==2.13.0"
+            "version": "==2.14.0"
         },
         "pyflakes": {
             "hashes": [
-                "sha256:5039c8339cbb1944045f4ee5466908906180f13cc99cc9949348d10f82a5c32a",
-                "sha256:6dfd61d87b97fba5dcfaaf781171ac16be16453be6d816147989e7f6e6a9576b"
+                "sha256:b24f96fafb7d2ab0ec5075b7350b3d2d2218eab42003821c06344973d3ea2f58",
+                "sha256:f742a7dbd0d9cb9ea41e9a24a918996e8170c799fa528688d40dd582c8265f4f"
             ],
             "markers": "python_version >= '3.9'",
-            "version": "==3.3.2"
+            "version": "==3.4.0"
         },
         "pygments": {
             "hashes": [
-                "sha256:61c16d2a8576dc0649d9f39e089b5f02bcd27fba10d8fb4dcc28173f7a45151f",
-                "sha256:9ea1544ad55cecf4b8242fab6dd35a93bbce657034b0611ee383099054ab6d8c"
+                "sha256:636cb2477cec7f8952536970bc533bc43743542f70392ae026374600add5b887",
+                "sha256:86540386c03d588bb81d44bc3928634ff26449851e99741617ecb9037ee5ec0b"
             ],
             "markers": "python_version >= '3.8'",
-            "version": "==2.19.1"
+            "version": "==2.19.2"
         },
         "pyproject-hooks": {
             "hashes": [
@@ -948,12 +1139,29 @@
         },
         "pytest": {
             "hashes": [
-                "sha256:14d920b48472ea0dbf68e45b96cd1ffda4705f33307dcc86c676c1b5104838a6",
-                "sha256:f40f825768ad76c0977cbacdf1fd37c6f7a468e460ea6a0636078f8972d4517e"
+                "sha256:86c0d0b93306b961d58d62a4db4879f27fe25513d4b969df351abdddb3c30e01",
+                "sha256:872f880de3fc3a5bdc88a11b39c9710c3497a547cfa9320bc3c5e62fbf272e79"
             ],
             "index": "pypi",
             "markers": "python_version >= '3.9'",
-            "version": "==8.4.0"
+            "version": "==8.4.2"
+        },
+        "pytest-asyncio": {
+            "hashes": [
+                "sha256:8e17ae5e46d8e7efe51ab6494dd2010f4ca8dae51652aa3c8d55acf50bfb2e99",
+                "sha256:c609a64a2a8768462d0c99811ddb8bd2583c33fd33cf7f21af1c142e824ffb57"
+            ],
+            "index": "pypi",
+            "markers": "python_version >= '3.9'",
+            "version": "==1.2.0"
+        },
+        "pytokens": {
+            "hashes": [
+                "sha256:c9a4bfa0be1d26aebce03e6884ba454e842f186a59ea43a6d3b25af58223c044",
+                "sha256:db7b72284e480e69fb085d9f251f66b3d2df8b7166059261258ff35f50fb711b"
+            ],
+            "markers": "python_version >= '3.8'",
+            "version": "==0.1.10"
         },
         "readme-renderer": {
             "hashes": [
@@ -965,11 +1173,11 @@
         },
         "requests": {
             "hashes": [
-                "sha256:27babd3cda2a6d50b30443204ee89830707d396671944c998b5975b031ac2b2c",
-                "sha256:27d0316682c8a29834d3264820024b62a36942083d52caf2f14c0591336d3422"
+                "sha256:2462f94637a34fd532264295e186976db0f5d453d1cdd31473c85a6a161affb6",
+                "sha256:dbba0bac56e100853db0ea71b82b4dfd5fe2bf6d3754a8893c3af500cec7d7cf"
             ],
-            "markers": "python_version >= '3.8'",
-            "version": "==2.32.4"
+            "markers": "python_version >= '3.9'",
+            "version": "==2.32.5"
         },
         "requests-toolbelt": {
             "hashes": [
@@ -989,11 +1197,11 @@
         },
         "rich": {
             "hashes": [
-                "sha256:1c9491e1951aac09caffd42f448ee3d04e58923ffe14993f6e83068dc395d7e0",
-                "sha256:82f1bc23a6a21ebca4ae0c45af9bdbc492ed20231dcb63f297d6d1021a9d5725"
+                "sha256:73ff50c7c0c1c77c8243079283f4edb376f0f6442433aecb8ce7e6d0b92d1fe4",
+                "sha256:76bc51fe2e57d2b1be1f96c524b890b816e334ab4c1e45888799bfaab0021edd"
             ],
             "markers": "python_full_version >= '3.8.0'",
-            "version": "==14.0.0"
+            "version": "==14.2.0"
         },
         "setuptools": {
             "hashes": [
@@ -1006,19 +1214,27 @@
         },
         "twine": {
             "hashes": [
-                "sha256:a47f973caf122930bf0fbbf17f80b83bc1602c9ce393c7845f289a3001dc5384",
-                "sha256:be324f6272eff91d07ee93f251edf232fc647935dd585ac003539b42404a8dbd"
+                "sha256:418ebf08ccda9a8caaebe414433b0ba5e25eb5e4a927667122fbe8f829f985d8",
+                "sha256:e5ed0d2fd70c9959770dce51c8f39c8945c574e18173a7b81802dab51b4b75cf"
             ],
             "index": "pypi",
-            "markers": "python_version >= '3.8'",
-            "version": "==6.1.0"
+            "markers": "python_version >= '3.9'",
+            "version": "==6.2.0"
+        },
+        "typing-extensions": {
+            "hashes": [
+                "sha256:0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466",
+                "sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548"
+            ],
+            "index": "pypi",
+            "markers": "python_version >= '3.9'",
+            "version": "==4.15.0"
         },
         "urllib3": {
             "hashes": [
                 "sha256:3fc47733c7e419d4bc3f6b3dc2b4f890bb743906a30d56ba4a5bfa4bbff92760",
                 "sha256:e6b01673c0fa6a13e374b50871808eb3bf7046c4b125b216f6bf1cc604cff0dc"
             ],
-            "index": "pypi",
             "markers": "python_version >= '3.9'",
             "version": "==2.5.0"
         },
@@ -1093,19 +1309,19 @@
     "httpx": {
         "anyio": {
             "hashes": [
-                "sha256:673c0c244e15788651a4ff38710fea9675823028a6f08a5eda409e0c9840a028",
-                "sha256:9f76d541cad6e36af7beb62e978876f3b41e3e04f2c1fbf0884604c0a9c4d93c"
+                "sha256:0287e96f4d26d4149305414d4e3bc32f0dcd0862365a4bddea19d7a1ec38c4fc",
+                "sha256:82a8d0b81e318cc5ce71a5f1f8b5c4e63619620b63141ef8c995fa0db95a57c4"
             ],
             "markers": "python_version >= '3.9'",
-            "version": "==4.9.0"
+            "version": "==4.11.0"
         },
         "certifi": {
             "hashes": [
-                "sha256:0a816057ea3cdefcef70270d2c515e4506bbc954f417fa5ade2021213bb8f0c6",
-                "sha256:30350364dfe371162649852c63336a15c70c6510c2ad5015b21c2345311805f3"
+                "sha256:0f212c2744a9bb6de0c56639a6f68afe01ecd92d91f14ae897c4fe7bbeeef0de",
+                "sha256:47c09d31ccf2acf0be3f701ea53595ee7e0b8fa08801c6624be771df09ae7b43"
             ],
-            "markers": "python_version >= '3.6'",
-            "version": "==2025.4.26"
+            "markers": "python_version >= '3.7'",
+            "version": "==2025.10.5"
         },
         "h11": {
             "hashes": [
@@ -1134,11 +1350,11 @@
         },
         "idna": {
             "hashes": [
-                "sha256:12f65c9b470abda6dc35cf8e63cc574b1c52b11df2c86030af0ac09b01b13ea9",
-                "sha256:946d195a0d259cbba61165e88e65941f16e9b36ea6ddb97f00452bae8b1287d3"
+                "sha256:771a87f49d9defaf64091e6e6fe9c18d4833f140bd19464795bc32d966ca37ea",
+                "sha256:795dafcc9c04ed0c1fb032c2aa73654d8e8c5023a7df64a53f39190ada629902"
             ],
-            "markers": "python_version >= '3.6'",
-            "version": "==3.10"
+            "markers": "python_version >= '3.8'",
+            "version": "==3.11"
         },
         "sniffio": {
             "hashes": [
@@ -1147,6 +1363,14 @@
             ],
             "markers": "python_version >= '3.7'",
             "version": "==1.3.1"
+        },
+        "typing-extensions": {
+            "hashes": [
+                "sha256:0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466",
+                "sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548"
+            ],
+            "markers": "python_version < '3.13'",
+            "version": "==4.15.0"
         }
     },
     "reqeusts": {
@@ -1283,134 +1507,155 @@
     "requests": {
         "certifi": {
             "hashes": [
-                "sha256:0a816057ea3cdefcef70270d2c515e4506bbc954f417fa5ade2021213bb8f0c6",
-                "sha256:30350364dfe371162649852c63336a15c70c6510c2ad5015b21c2345311805f3"
+                "sha256:0f212c2744a9bb6de0c56639a6f68afe01ecd92d91f14ae897c4fe7bbeeef0de",
+                "sha256:47c09d31ccf2acf0be3f701ea53595ee7e0b8fa08801c6624be771df09ae7b43"
             ],
-            "markers": "python_version >= '3.6'",
-            "version": "==2025.4.26"
+            "markers": "python_version >= '3.7'",
+            "version": "==2025.10.5"
         },
         "charset-normalizer": {
             "hashes": [
-                "sha256:005fa3432484527f9732ebd315da8da8001593e2cf46a3d817669f062c3d9ed4",
-                "sha256:046595208aae0120559a67693ecc65dd75d46f7bf687f159127046628178dc45",
-                "sha256:0c29de6a1a95f24b9a1aa7aefd27d2487263f00dfd55a77719b530788f75cff7",
-                "sha256:0c8c57f84ccfc871a48a47321cfa49ae1df56cd1d965a09abe84066f6853b9c0",
-                "sha256:0f5d9ed7f254402c9e7d35d2f5972c9bbea9040e99cd2861bd77dc68263277c7",
-                "sha256:18dd2e350387c87dabe711b86f83c9c78af772c748904d372ade190b5c7c9d4d",
-                "sha256:1b1bde144d98e446b056ef98e59c256e9294f6b74d7af6846bf5ffdafd687a7d",
-                "sha256:1c95a1e2902a8b722868587c0e1184ad5c55631de5afc0eb96bc4b0d738092c0",
-                "sha256:1cad5f45b3146325bb38d6855642f6fd609c3f7cad4dbaf75549bf3b904d3184",
-                "sha256:21b2899062867b0e1fde9b724f8aecb1af14f2778d69aacd1a5a1853a597a5db",
-                "sha256:24498ba8ed6c2e0b56d4acbf83f2d989720a93b41d712ebd4f4979660db4417b",
-                "sha256:25a23ea5c7edc53e0f29bae2c44fcb5a1aa10591aae107f2a2b2583a9c5cbc64",
-                "sha256:289200a18fa698949d2b39c671c2cc7a24d44096784e76614899a7ccf2574b7b",
-                "sha256:28a1005facc94196e1fb3e82a3d442a9d9110b8434fc1ded7a24a2983c9888d8",
-                "sha256:32fc0341d72e0f73f80acb0a2c94216bd704f4f0bce10aedea38f30502b271ff",
-                "sha256:36b31da18b8890a76ec181c3cf44326bf2c48e36d393ca1b72b3f484113ea344",
-                "sha256:3c21d4fca343c805a52c0c78edc01e3477f6dd1ad7c47653241cf2a206d4fc58",
-                "sha256:3fddb7e2c84ac87ac3a947cb4e66d143ca5863ef48e4a5ecb83bd48619e4634e",
-                "sha256:43e0933a0eff183ee85833f341ec567c0980dae57c464d8a508e1b2ceb336471",
-                "sha256:4a476b06fbcf359ad25d34a057b7219281286ae2477cc5ff5e3f70a246971148",
-                "sha256:4e594135de17ab3866138f496755f302b72157d115086d100c3f19370839dd3a",
-                "sha256:50bf98d5e563b83cc29471fa114366e6806bc06bc7a25fd59641e41445327836",
-                "sha256:5a9979887252a82fefd3d3ed2a8e3b937a7a809f65dcb1e068b090e165bbe99e",
-                "sha256:5baececa9ecba31eff645232d59845c07aa030f0c81ee70184a90d35099a0e63",
-                "sha256:5bf4545e3b962767e5c06fe1738f951f77d27967cb2caa64c28be7c4563e162c",
-                "sha256:6333b3aa5a12c26b2a4d4e7335a28f1475e0e5e17d69d55141ee3cab736f66d1",
-                "sha256:65c981bdbd3f57670af8b59777cbfae75364b483fa8a9f420f08094531d54a01",
-                "sha256:68a328e5f55ec37c57f19ebb1fdc56a248db2e3e9ad769919a58672958e8f366",
-                "sha256:6a0289e4589e8bdfef02a80478f1dfcb14f0ab696b5a00e1f4b8a14a307a3c58",
-                "sha256:6b66f92b17849b85cad91259efc341dce9c1af48e2173bf38a85c6329f1033e5",
-                "sha256:6c9379d65defcab82d07b2a9dfbfc2e95bc8fe0ebb1b176a3190230a3ef0e07c",
-                "sha256:6fc1f5b51fa4cecaa18f2bd7a003f3dd039dd615cd69a2afd6d3b19aed6775f2",
-                "sha256:70f7172939fdf8790425ba31915bfbe8335030f05b9913d7ae00a87d4395620a",
-                "sha256:721c76e84fe669be19c5791da68232ca2e05ba5185575086e384352e2c309597",
-                "sha256:7222ffd5e4de8e57e03ce2cef95a4c43c98fcb72ad86909abdfc2c17d227fc1b",
-                "sha256:75d10d37a47afee94919c4fab4c22b9bc2a8bf7d4f46f87363bcf0573f3ff4f5",
-                "sha256:76af085e67e56c8816c3ccf256ebd136def2ed9654525348cfa744b6802b69eb",
-                "sha256:770cab594ecf99ae64c236bc9ee3439c3f46be49796e265ce0cc8bc17b10294f",
-                "sha256:7a6ab32f7210554a96cd9e33abe3ddd86732beeafc7a28e9955cdf22ffadbab0",
-                "sha256:7c48ed483eb946e6c04ccbe02c6b4d1d48e51944b6db70f697e089c193404941",
-                "sha256:7f56930ab0abd1c45cd15be65cc741c28b1c9a34876ce8c17a2fa107810c0af0",
-                "sha256:8075c35cd58273fee266c58c0c9b670947c19df5fb98e7b66710e04ad4e9ff86",
-                "sha256:8272b73e1c5603666618805fe821edba66892e2870058c94c53147602eab29c7",
-                "sha256:82d8fd25b7f4675d0c47cf95b594d4e7b158aca33b76aa63d07186e13c0e0ab7",
-                "sha256:844da2b5728b5ce0e32d863af26f32b5ce61bc4273a9c720a9f3aa9df73b1455",
-                "sha256:8755483f3c00d6c9a77f490c17e6ab0c8729e39e6390328e42521ef175380ae6",
-                "sha256:915f3849a011c1f593ab99092f3cecfcb4d65d8feb4a64cf1bf2d22074dc0ec4",
-                "sha256:926ca93accd5d36ccdabd803392ddc3e03e6d4cd1cf17deff3b989ab8e9dbcf0",
-                "sha256:982bb1e8b4ffda883b3d0a521e23abcd6fd17418f6d2c4118d257a10199c0ce3",
-                "sha256:98f862da73774290f251b9df8d11161b6cf25b599a66baf087c1ffe340e9bfd1",
-                "sha256:9cbfacf36cb0ec2897ce0ebc5d08ca44213af24265bd56eca54bee7923c48fd6",
-                "sha256:a370b3e078e418187da8c3674eddb9d983ec09445c99a3a263c2011993522981",
-                "sha256:a955b438e62efdf7e0b7b52a64dc5c3396e2634baa62471768a64bc2adb73d5c",
-                "sha256:aa6af9e7d59f9c12b33ae4e9450619cf2488e2bbe9b44030905877f0b2324980",
-                "sha256:aa88ca0b1932e93f2d961bf3addbb2db902198dca337d88c89e1559e066e7645",
-                "sha256:aaeeb6a479c7667fbe1099af9617c83aaca22182d6cf8c53966491a0f1b7ffb7",
-                "sha256:aaf27faa992bfee0264dc1f03f4c75e9fcdda66a519db6b957a3f826e285cf12",
-                "sha256:b2680962a4848b3c4f155dc2ee64505a9c57186d0d56b43123b17ca3de18f0fa",
-                "sha256:b2d318c11350e10662026ad0eb71bb51c7812fc8590825304ae0bdd4ac283acd",
-                "sha256:b33de11b92e9f75a2b545d6e9b6f37e398d86c3e9e9653c4864eb7e89c5773ef",
-                "sha256:b3daeac64d5b371dea99714f08ffc2c208522ec6b06fbc7866a450dd446f5c0f",
-                "sha256:be1e352acbe3c78727a16a455126d9ff83ea2dfdcbc83148d2982305a04714c2",
-                "sha256:bee093bf902e1d8fc0ac143c88902c3dfc8941f7ea1d6a8dd2bcb786d33db03d",
-                "sha256:c72fbbe68c6f32f251bdc08b8611c7b3060612236e960ef848e0a517ddbe76c5",
-                "sha256:c9e36a97bee9b86ef9a1cf7bb96747eb7a15c2f22bdb5b516434b00f2a599f02",
-                "sha256:cddf7bd982eaa998934a91f69d182aec997c6c468898efe6679af88283b498d3",
-                "sha256:cf713fe9a71ef6fd5adf7a79670135081cd4431c2943864757f0fa3a65b1fafd",
-                "sha256:d11b54acf878eef558599658b0ffca78138c8c3655cf4f3a4a673c437e67732e",
-                "sha256:d41c4d287cfc69060fa91cae9683eacffad989f1a10811995fa309df656ec214",
-                "sha256:d524ba3f1581b35c03cb42beebab4a13e6cdad7b36246bd22541fa585a56cccd",
-                "sha256:daac4765328a919a805fa5e2720f3e94767abd632ae410a9062dff5412bae65a",
-                "sha256:db4c7bf0e07fc3b7d89ac2a5880a6a8062056801b83ff56d8464b70f65482b6c",
-                "sha256:dc7039885fa1baf9be153a0626e337aa7ec8bf96b0128605fb0d77788ddc1681",
-                "sha256:dccab8d5fa1ef9bfba0590ecf4d46df048d18ffe3eec01eeb73a42e0d9e7a8ba",
-                "sha256:dedb8adb91d11846ee08bec4c8236c8549ac721c245678282dcb06b221aab59f",
-                "sha256:e45ba65510e2647721e35323d6ef54c7974959f6081b58d4ef5d87c60c84919a",
-                "sha256:e53efc7c7cee4c1e70661e2e112ca46a575f90ed9ae3fef200f2a25e954f4b28",
-                "sha256:e635b87f01ebc977342e2697d05b56632f5f879a4f15955dfe8cef2448b51691",
-                "sha256:e70e990b2137b29dc5564715de1e12701815dacc1d056308e2b17e9095372a82",
-                "sha256:e8082b26888e2f8b36a042a58307d5b917ef2b1cacab921ad3323ef91901c71a",
-                "sha256:e8323a9b031aa0393768b87f04b4164a40037fb2a3c11ac06a03ffecd3618027",
-                "sha256:e92fca20c46e9f5e1bb485887d074918b13543b1c2a1185e69bb8d17ab6236a7",
-                "sha256:eb30abc20df9ab0814b5a2524f23d75dcf83cde762c161917a2b4b7b55b1e518",
-                "sha256:eba9904b0f38a143592d9fc0e19e2df0fa2e41c3c3745554761c5f6447eedabf",
-                "sha256:ef8de666d6179b009dce7bcb2ad4c4a779f113f12caf8dc77f0162c29d20490b",
-                "sha256:efd387a49825780ff861998cd959767800d54f8308936b21025326de4b5a42b9",
-                "sha256:f0aa37f3c979cf2546b73e8222bbfa3dc07a641585340179d768068e3455e544",
-                "sha256:f4074c5a429281bf056ddd4c5d3b740ebca4d43ffffe2ef4bf4d2d05114299da",
-                "sha256:f69a27e45c43520f5487f27627059b64aaf160415589230992cec34c5e18a509",
-                "sha256:fb707f3e15060adf5b7ada797624a6c6e0138e2a26baa089df64c68ee98e040f",
-                "sha256:fcbe676a55d7445b22c10967bceaaf0ee69407fbe0ece4d032b6eb8d4565982a",
-                "sha256:fdb20a30fe1175ecabed17cbf7812f7b804b8a315a25f24678bcdf120a90077f"
+                "sha256:027f6de494925c0ab2a55eab46ae5129951638a49a34d87f4c3eda90f696b4ad",
+                "sha256:077fbb858e903c73f6c9db43374fd213b0b6a778106bc7032446a8e8b5b38b93",
+                "sha256:0a98e6759f854bd25a58a73fa88833fba3b7c491169f86ce1180c948ab3fd394",
+                "sha256:0d3d8f15c07f86e9ff82319b3d9ef6f4bf907608f53fe9d92b28ea9ae3d1fd89",
+                "sha256:0f04b14ffe5fdc8c4933862d8306109a2c51e0704acfa35d51598eb45a1e89fc",
+                "sha256:11d694519d7f29d6cd09f6ac70028dba10f92f6cdd059096db198c283794ac86",
+                "sha256:194f08cbb32dc406d6e1aea671a68be0823673db2832b38405deba2fb0d88f63",
+                "sha256:1bee1e43c28aa63cb16e5c14e582580546b08e535299b8b6158a7c9c768a1f3d",
+                "sha256:21d142cc6c0ec30d2efee5068ca36c128a30b0f2c53c1c07bd78cb6bc1d3be5f",
+                "sha256:2437418e20515acec67d86e12bf70056a33abdacb5cb1655042f6538d6b085a8",
+                "sha256:244bfb999c71b35de57821b8ea746b24e863398194a4014e4c76adc2bbdfeff0",
+                "sha256:2677acec1a2f8ef614c6888b5b4ae4060cc184174a938ed4e8ef690e15d3e505",
+                "sha256:277e970e750505ed74c832b4bf75dac7476262ee2a013f5574dd49075879e161",
+                "sha256:2aaba3b0819274cc41757a1da876f810a3e4d7b6eb25699253a4effef9e8e4af",
+                "sha256:2b7d8f6c26245217bd2ad053761201e9f9680f8ce52f0fcd8d0755aeae5b2152",
+                "sha256:2c9d3c380143a1fedbff95a312aa798578371eb29da42106a29019368a475318",
+                "sha256:3162d5d8ce1bb98dd51af660f2121c55d0fa541b46dff7bb9b9f86ea1d87de72",
+                "sha256:31fd66405eaf47bb62e8cd575dc621c56c668f27d46a61d975a249930dd5e2a4",
+                "sha256:362d61fd13843997c1c446760ef36f240cf81d3ebf74ac62652aebaf7838561e",
+                "sha256:376bec83a63b8021bb5c8ea75e21c4ccb86e7e45ca4eb81146091b56599b80c3",
+                "sha256:44c2a8734b333e0578090c4cd6b16f275e07aa6614ca8715e6c038e865e70576",
+                "sha256:47cc91b2f4dd2833fddaedd2893006b0106129d4b94fdb6af1f4ce5a9965577c",
+                "sha256:4902828217069c3c5c71094537a8e623f5d097858ac6ca8252f7b4d10b7560f1",
+                "sha256:4bd5d4137d500351a30687c2d3971758aac9a19208fc110ccb9d7188fbe709e8",
+                "sha256:4fe7859a4e3e8457458e2ff592f15ccb02f3da787fcd31e0183879c3ad4692a1",
+                "sha256:542d2cee80be6f80247095cc36c418f7bddd14f4a6de45af91dfad36d817bba2",
+                "sha256:554af85e960429cf30784dd47447d5125aaa3b99a6f0683589dbd27e2f45da44",
+                "sha256:5833d2c39d8896e4e19b689ffc198f08ea58116bee26dea51e362ecc7cd3ed26",
+                "sha256:5947809c8a2417be3267efc979c47d76a079758166f7d43ef5ae8e9f92751f88",
+                "sha256:5ae497466c7901d54b639cf42d5b8c1b6a4fead55215500d2f486d34db48d016",
+                "sha256:5bd2293095d766545ec1a8f612559f6b40abc0eb18bb2f5d1171872d34036ede",
+                "sha256:5bfbb1b9acf3334612667b61bd3002196fe2a1eb4dd74d247e0f2a4d50ec9bbf",
+                "sha256:5cb4d72eea50c8868f5288b7f7f33ed276118325c1dfd3957089f6b519e1382a",
+                "sha256:5dbe56a36425d26d6cfb40ce79c314a2e4dd6211d51d6d2191c00bed34f354cc",
+                "sha256:5f819d5fe9234f9f82d75bdfa9aef3a3d72c4d24a6e57aeaebba32a704553aa0",
+                "sha256:64b55f9dce520635f018f907ff1b0df1fdc31f2795a922fb49dd14fbcdf48c84",
+                "sha256:6515f3182dbe4ea06ced2d9e8666d97b46ef4c75e326b79bb624110f122551db",
+                "sha256:65e2befcd84bc6f37095f5961e68a6f077bf44946771354a28ad434c2cce0ae1",
+                "sha256:6aee717dcfead04c6eb1ce3bd29ac1e22663cdea57f943c87d1eab9a025438d7",
+                "sha256:6b39f987ae8ccdf0d2642338faf2abb1862340facc796048b604ef14919e55ed",
+                "sha256:6e1fcf0720908f200cd21aa4e6750a48ff6ce4afe7ff5a79a90d5ed8a08296f8",
+                "sha256:74018750915ee7ad843a774364e13a3db91682f26142baddf775342c3f5b1133",
+                "sha256:74664978bb272435107de04e36db5a9735e78232b85b77d45cfb38f758efd33e",
+                "sha256:74bb723680f9f7a6234dcf67aea57e708ec1fbdf5699fb91dfd6f511b0a320ef",
+                "sha256:752944c7ffbfdd10c074dc58ec2d5a8a4cd9493b314d367c14d24c17684ddd14",
+                "sha256:778d2e08eda00f4256d7f672ca9fef386071c9202f5e4607920b86d7803387f2",
+                "sha256:780236ac706e66881f3b7f2f32dfe90507a09e67d1d454c762cf642e6e1586e0",
+                "sha256:798d75d81754988d2565bff1b97ba5a44411867c0cf32b77a7e8f8d84796b10d",
+                "sha256:799a7a5e4fb2d5898c60b640fd4981d6a25f1c11790935a44ce38c54e985f828",
+                "sha256:7a32c560861a02ff789ad905a2fe94e3f840803362c84fecf1851cb4cf3dc37f",
+                "sha256:7c308f7e26e4363d79df40ca5b2be1c6ba9f02bdbccfed5abddb7859a6ce72cf",
+                "sha256:7fa17817dc5625de8a027cb8b26d9fefa3ea28c8253929b8d6649e705d2835b6",
+                "sha256:81d5eb2a312700f4ecaa977a8235b634ce853200e828fbadf3a9c50bab278328",
+                "sha256:82004af6c302b5d3ab2cfc4cc5f29db16123b1a8417f2e25f9066f91d4411090",
+                "sha256:837c2ce8c5a65a2035be9b3569c684358dfbf109fd3b6969630a87535495ceaa",
+                "sha256:840c25fb618a231545cbab0564a799f101b63b9901f2569faecd6b222ac72381",
+                "sha256:8a6562c3700cce886c5be75ade4a5db4214fda19fede41d9792d100288d8f94c",
+                "sha256:8af65f14dc14a79b924524b1e7fffe304517b2bff5a58bf64f30b98bbc5079eb",
+                "sha256:8ef3c867360f88ac904fd3f5e1f902f13307af9052646963ee08ff4f131adafc",
+                "sha256:94537985111c35f28720e43603b8e7b43a6ecfb2ce1d3058bbe955b73404e21a",
+                "sha256:99ae2cffebb06e6c22bdc25801d7b30f503cc87dbd283479e7b606f70aff57ec",
+                "sha256:9a26f18905b8dd5d685d6d07b0cdf98a79f3c7a918906af7cc143ea2e164c8bc",
+                "sha256:9b35f4c90079ff2e2edc5b26c0c77925e5d2d255c42c74fdb70fb49b172726ac",
+                "sha256:9cd98cdc06614a2f768d2b7286d66805f94c48cde050acdbbb7db2600ab3197e",
+                "sha256:9d1bb833febdff5c8927f922386db610b49db6e0d4f4ee29601d71e7c2694313",
+                "sha256:9f7fcd74d410a36883701fafa2482a6af2ff5ba96b9a620e9e0721e28ead5569",
+                "sha256:a59cb51917aa591b1c4e6a43c132f0cdc3c76dbad6155df4e28ee626cc77a0a3",
+                "sha256:a61900df84c667873b292c3de315a786dd8dac506704dea57bc957bd31e22c7d",
+                "sha256:a79cfe37875f822425b89a82333404539ae63dbdddf97f84dcbc3d339aae9525",
+                "sha256:a8a8b89589086a25749f471e6a900d3f662d1d3b6e2e59dcecf787b1cc3a1894",
+                "sha256:a8bf8d0f749c5757af2142fe7903a9df1d2e8aa3841559b2bad34b08d0e2bcf3",
+                "sha256:a9768c477b9d7bd54bc0c86dbaebdec6f03306675526c9927c0e8a04e8f94af9",
+                "sha256:ac1c4a689edcc530fc9d9aa11f5774b9e2f33f9a0c6a57864e90908f5208d30a",
+                "sha256:af2d8c67d8e573d6de5bc30cdb27e9b95e49115cd9baad5ddbd1a6207aaa82a9",
+                "sha256:b435cba5f4f750aa6c0a0d92c541fb79f69a387c91e61f1795227e4ed9cece14",
+                "sha256:b5b290ccc2a263e8d185130284f8501e3e36c5e02750fc6b6bdeb2e9e96f1e25",
+                "sha256:b5d84d37db046c5ca74ee7bb47dd6cbc13f80665fdde3e8040bdd3fb015ecb50",
+                "sha256:b7cf1017d601aa35e6bb650b6ad28652c9cd78ee6caff19f3c28d03e1c80acbf",
+                "sha256:bc7637e2f80d8530ee4a78e878bce464f70087ce73cf7c1caf142416923b98f1",
+                "sha256:c0463276121fdee9c49b98908b3a89c39be45d86d1dbaa22957e38f6321d4ce3",
+                "sha256:c4ef880e27901b6cc782f1b95f82da9313c0eb95c3af699103088fa0ac3ce9ac",
+                "sha256:c8ae8a0f02f57a6e61203a31428fa1d677cbe50c93622b4149d5c0f319c1d19e",
+                "sha256:ca5862d5b3928c4940729dacc329aa9102900382fea192fc5e52eb69d6093815",
+                "sha256:cb01158d8b88ee68f15949894ccc6712278243d95f344770fa7593fa2d94410c",
+                "sha256:cb6254dc36b47a990e59e1068afacdcd02958bdcce30bb50cc1700a8b9d624a6",
+                "sha256:cc00f04ed596e9dc0da42ed17ac5e596c6ccba999ba6bd92b0e0aef2f170f2d6",
+                "sha256:cd09d08005f958f370f539f186d10aec3377d55b9eeb0d796025d4886119d76e",
+                "sha256:cd4b7ca9984e5e7985c12bc60a6f173f3c958eae74f3ef6624bb6b26e2abbae4",
+                "sha256:ce8a0633f41a967713a59c4139d29110c07e826d131a316b50ce11b1d79b4f84",
+                "sha256:cead0978fc57397645f12578bfd2d5ea9138ea0fac82b2f63f7f7c6877986a69",
+                "sha256:d055ec1e26e441f6187acf818b73564e6e6282709e9bcb5b63f5b23068356a15",
+                "sha256:d1f13550535ad8cff21b8d757a3257963e951d96e20ec82ab44bc64aeb62a191",
+                "sha256:d9c7f57c3d666a53421049053eaacdd14bbd0a528e2186fcb2e672effd053bb0",
+                "sha256:d9e45d7faa48ee908174d8fe84854479ef838fc6a705c9315372eacbc2f02897",
+                "sha256:da3326d9e65ef63a817ecbcc0df6e94463713b754fe293eaa03da99befb9a5bd",
+                "sha256:de00632ca48df9daf77a2c65a484531649261ec9f25489917f09e455cb09ddb2",
+                "sha256:e1f185f86a6f3403aa2420e815904c67b2f9ebc443f045edd0de921108345794",
+                "sha256:e824f1492727fa856dd6eda4f7cee25f8518a12f3c4a56a74e8095695089cf6d",
+                "sha256:e912091979546adf63357d7e2ccff9b44f026c075aeaf25a52d0e95ad2281074",
+                "sha256:eaabd426fe94daf8fd157c32e571c85cb12e66692f15516a83a03264b08d06c3",
+                "sha256:ebf3e58c7ec8a8bed6d66a75d7fb37b55e5015b03ceae72a8e7c74495551e224",
+                "sha256:ecaae4149d99b1c9e7b88bb03e3221956f68fd6d50be2ef061b2381b61d20838",
+                "sha256:eecbc200c7fd5ddb9a7f16c7decb07b566c29fa2161a16cf67b8d068bd21690a",
+                "sha256:f155a433c2ec037d4e8df17d18922c3a0d9b3232a396690f17175d2946f0218d",
+                "sha256:f1e34719c6ed0b92f418c7c780480b26b5d9c50349e9a9af7d76bf757530350d",
+                "sha256:f34be2938726fc13801220747472850852fe6b1ea75869a048d6f896838c896f",
+                "sha256:f820802628d2694cb7e56db99213f930856014862f3fd943d290ea8438d07ca8",
+                "sha256:f8bf04158c6b607d747e93949aa60618b61312fe647a6369f88ce2ff16043490",
+                "sha256:f8e160feb2aed042cd657a72acc0b481212ed28b1b9a95c0cee1621b524e1966",
+                "sha256:f9d332f8c2a2fcbffe1378594431458ddbef721c1769d78e2cbc06280d8155f9",
+                "sha256:fa09f53c465e532f4d3db095e0c55b615f010ad81803d383195b6b5ca6cbf5f3",
+                "sha256:faa3a41b2b66b6e50f84ae4a68c64fcd0c44355741c6374813a800cd6695db9e",
+                "sha256:fd44c878ea55ba351104cb93cc85e74916eb8fa440ca7903e57575e97394f608"
             ],
             "markers": "python_version >= '3.7'",
-            "version": "==3.4.2"
+            "version": "==3.4.4"
         },
         "idna": {
             "hashes": [
-                "sha256:12f65c9b470abda6dc35cf8e63cc574b1c52b11df2c86030af0ac09b01b13ea9",
-                "sha256:946d195a0d259cbba61165e88e65941f16e9b36ea6ddb97f00452bae8b1287d3"
+                "sha256:771a87f49d9defaf64091e6e6fe9c18d4833f140bd19464795bc32d966ca37ea",
+                "sha256:795dafcc9c04ed0c1fb032c2aa73654d8e8c5023a7df64a53f39190ada629902"
             ],
-            "markers": "python_version >= '3.6'",
-            "version": "==3.10"
+            "markers": "python_version >= '3.8'",
+            "version": "==3.11"
         },
         "requests": {
             "hashes": [
-                "sha256:27babd3cda2a6d50b30443204ee89830707d396671944c998b5975b031ac2b2c",
-                "sha256:27d0316682c8a29834d3264820024b62a36942083d52caf2f14c0591336d3422"
+                "sha256:2462f94637a34fd532264295e186976db0f5d453d1cdd31473c85a6a161affb6",
+                "sha256:dbba0bac56e100853db0ea71b82b4dfd5fe2bf6d3754a8893c3af500cec7d7cf"
             ],
             "index": "pypi",
-            "markers": "python_version >= '3.8'",
-            "version": "==2.32.4"
+            "markers": "python_version >= '3.9'",
+            "version": "==2.32.5"
         },
         "urllib3": {
             "hashes": [
-                "sha256:414bc6535b787febd7567804cc015fee39daab8ad86268f1310a9250697de466",
-                "sha256:4e16665048960a0900c702d4a66415956a584919c03361cac9f1df5c5dd7e813"
+                "sha256:3fc47733c7e419d4bc3f6b3dc2b4f890bb743906a30d56ba4a5bfa4bbff92760",
+                "sha256:e6b01673c0fa6a13e374b50871808eb3bf7046c4b125b216f6bf1cc604cff0dc"
             ],
             "markers": "python_version >= '3.9'",
-            "version": "==2.4.0"
+            "version": "==2.5.0"
         }
     }
 }
diff --git a/android_sms_gateway/ahttp.py b/android_sms_gateway/ahttp.py
index aac37a8..28386d8 100644
--- a/android_sms_gateway/ahttp.py
+++ b/android_sms_gateway/ahttp.py
@@ -80,12 +80,12 @@ async def _process_response(self, response: aiohttp.ClientResponse) -> dict:
                 if response.status == 204:
                     return {}
 
-                return await response.json()
+                return response.json()
             except aiohttp.ClientResponseError as e:
                 # Extract error message from response if available
                 error_data = {}
                 try:
-                    error_data = await response.json()
+                    error_data = response.json()
                 except ValueError:
                     # Response is not JSON
                     pass
diff --git a/tests/test_domain.py b/tests/test_domain.py
index 8287640..3f226be 100644
--- a/tests/test_domain.py
+++ b/tests/test_domain.py
@@ -1,7 +1,13 @@
 import pytest
 
 from android_sms_gateway.enums import WebhookEvent, MessagePriority
-from android_sms_gateway.domain import MessageState, RecipientState, Webhook, Message
+from android_sms_gateway.domain import (
+    MessageState,
+    RecipientState,
+    Webhook,
+    Message,
+    TextMessage,
+)
 
 
 # Test for successful instantiation from a dictionary
@@ -150,7 +156,7 @@ def test_webhook_asdict():
             1,
             MessagePriority.BYPASS_THRESHOLD,
             {
-                "message": "Hello, world!",
+                "textMessage": {"text": "Hello, world!"},
                 "phoneNumbers": ["123", "456"],
                 "withDeliveryReport": True,
                 "isEncrypted": False,
@@ -170,7 +176,7 @@ def test_webhook_asdict():
             None,
             None,
             {
-                "message": "Hello, world!",
+                "textMessage": {"text": "Hello, world!"},
                 "phoneNumbers": ["123", "456"],
                 "withDeliveryReport": True,
                 "isEncrypted": False,
@@ -186,7 +192,7 @@ def test_webhook_asdict():
             1,
             None,
             {
-                "message": "Hello, world!",
+                "textMessage": {"text": "Hello, world!"},
                 "phoneNumbers": ["123", "456"],
                 "withDeliveryReport": True,
                 "isEncrypted": False,
@@ -204,7 +210,7 @@ def test_webhook_asdict():
             None,
             MessagePriority.DEFAULT,
             {
-                "message": "Hello, world!",
+                "textMessage": {"text": "Hello, world!"},
                 "phoneNumbers": ["123", "456"],
                 "withDeliveryReport": True,
                 "isEncrypted": False,
@@ -222,7 +228,7 @@ def test_webhook_asdict():
             None,
             MessagePriority.MINIMUM,
             {
-                "message": "Hi",
+                "textMessage": {"text": "Hi"},
                 "phoneNumbers": ["555"],
                 "withDeliveryReport": True,
                 "isEncrypted": False,
@@ -248,7 +254,7 @@ def test_message_asdict(
     Uses parametrized testing to cover multiple scenarios.
     """
     message = Message(
-        message=message_content,
+        text_message=TextMessage(text=message_content),
         phone_numbers=phone_numbers,
         with_delivery_report=with_delivery_report,
         is_encrypted=is_encrypted,

From 130ac2fab8888899b1d34f9bec8b1cf81a22e16e Mon Sep 17 00:00:00 2001
From: Aleksandr Soloshenko <capcom@soft-c.ru>
Date: Wed, 15 Oct 2025 10:00:58 +0700
Subject: [PATCH 09/10] [tests] add more tests

---
 android_sms_gateway/ahttp.py |   4 +-
 tests/test_domain.py         | 218 +++++++++++++++++++++++++++++++++++
 tests/test_error_handling.py |  12 +-
 3 files changed, 229 insertions(+), 5 deletions(-)

diff --git a/android_sms_gateway/ahttp.py b/android_sms_gateway/ahttp.py
index 28386d8..aac37a8 100644
--- a/android_sms_gateway/ahttp.py
+++ b/android_sms_gateway/ahttp.py
@@ -80,12 +80,12 @@ async def _process_response(self, response: aiohttp.ClientResponse) -> dict:
                 if response.status == 204:
                     return {}
 
-                return response.json()
+                return await response.json()
             except aiohttp.ClientResponseError as e:
                 # Extract error message from response if available
                 error_data = {}
                 try:
-                    error_data = response.json()
+                    error_data = await response.json()
                 except ValueError:
                     # Response is not JSON
                     pass
diff --git a/tests/test_domain.py b/tests/test_domain.py
index 3f226be..0ef1edd 100644
--- a/tests/test_domain.py
+++ b/tests/test_domain.py
@@ -1,4 +1,5 @@
 import pytest
+import datetime
 
 from android_sms_gateway.enums import WebhookEvent, MessagePriority
 from android_sms_gateway.domain import (
@@ -7,6 +8,7 @@
     Webhook,
     Message,
     TextMessage,
+    DataMessage,
 )
 
 
@@ -265,3 +267,219 @@ def test_message_asdict(
     )
 
     assert message.asdict() == expected
+
+
+# Test for Message with data_message instead of text_message
+def test_message_with_data_message_only():
+    """Test creating a message with data_message only"""
+    data_msg = DataMessage(data="base64encodeddata", port=1234)
+    message = Message(
+        phone_numbers=["123", "456"],
+        data_message=data_msg,
+        with_delivery_report=True,
+        is_encrypted=False,
+    )
+
+    assert message.data_message == data_msg
+    assert message.text_message is None
+
+
+def test_message_serialization_with_data_message():
+    """Test serialization includes data_message"""
+    data_msg = DataMessage(data="base64encodeddata", port=1234)
+    message = Message(
+        phone_numbers=["123", "456"],
+        data_message=data_msg,
+        with_delivery_report=True,
+        is_encrypted=False,
+        id="msg_123",
+        device_id="device_001",
+    )
+
+    expected_dict = {
+        "dataMessage": {"data": "base64encodeddata", "port": 1234},
+        "phoneNumbers": ["123", "456"],
+        "withDeliveryReport": True,
+        "isEncrypted": False,
+        "id": "msg_123",
+        "deviceId": "device_001",
+    }
+
+    assert message.asdict() == expected_dict
+
+
+# Test for Message with both ttl and valid_until (should raise ValueError)
+def test_message_with_both_ttl_and_valid_until_raises_error():
+    """Test that providing both ttl and valid_until raises ValueError"""
+    text_msg = TextMessage(text="Hello, world!")
+
+    with pytest.raises(ValueError, match="ttl and valid_until are mutually exclusive"):
+        Message(
+            phone_numbers=["123", "456"],
+            text_message=text_msg,
+            ttl=300,
+            valid_until=datetime.datetime.now() + datetime.timedelta(seconds=600),
+        )
+
+
+def test_message_with_ttl_only():
+    """Test that providing only ttl works correctly"""
+    text_msg = TextMessage(text="Hello, world!")
+    message = Message(
+        phone_numbers=["123", "456"],
+        text_message=text_msg,
+        ttl=300,
+    )
+
+    assert message.ttl == 300
+    assert message.valid_until is None
+    assert "ttl" in message.asdict()
+    assert "validUntil" not in message.asdict()
+
+
+def test_message_with_valid_until_only():
+    """Test that providing only valid_until works correctly"""
+    text_msg = TextMessage(text="Hello, world!")
+    valid_until_time = datetime.datetime.now() + datetime.timedelta(seconds=600)
+    message = Message(
+        phone_numbers=["123", "456"],
+        text_message=text_msg,
+        valid_until=valid_until_time,
+    )
+
+    assert message.valid_until == valid_until_time
+    assert message.ttl is None
+    assert "validUntil" in message.asdict()
+    assert "ttl" not in message.asdict()
+
+
+# Test content property for both text and data messages, plus error case
+def test_message_content_property_with_text_message():
+    """Test content property returns text_message when text is set"""
+    text_msg = TextMessage(text="Hello, world!")
+    message = Message(
+        phone_numbers=["123", "456"],
+        text_message=text_msg,
+    )
+
+    assert message.content == "Hello, world!"
+
+
+def test_message_content_property_with_data_message():
+    """Test content property returns data_message when data is set"""
+    data_msg = DataMessage(data="base64encodeddata", port=1234)
+    message = Message(
+        phone_numbers=["123", "456"],
+        data_message=data_msg,
+    )
+
+    assert message.content == "base64encodeddata"
+
+
+def test_message_without_text_or_data_raises_error():
+    """Test that creating message without text or data raises appropriate error"""
+    message = Message(phone_numbers=["123", "456"])
+
+    with pytest.raises(ValueError, match="Message has no content"):
+        _ = message.content
+
+
+# Test serialization including device_id and valid_until
+def test_message_serialization_with_device_id():
+    """Test serialization includes device_id when present"""
+    text_msg = TextMessage(text="Hello, world!")
+    message = Message(
+        phone_numbers=["123", "456"],
+        text_message=text_msg,
+        device_id="device_001",
+    )
+
+    assert "deviceId" in message.asdict()
+    assert message.asdict()["deviceId"] == "device_001"
+
+
+def test_message_serialization_with_valid_until():
+    """Test serialization includes valid_until when present"""
+    text_msg = TextMessage(text="Hello, world!")
+    valid_until_time = datetime.datetime.now() + datetime.timedelta(seconds=600)
+    message = Message(
+        phone_numbers=["123", "456"],
+        text_message=text_msg,
+        valid_until=valid_until_time,
+    )
+
+    assert "validUntil" in message.asdict()
+    assert message.asdict()["validUntil"] == valid_until_time.isoformat()
+
+
+def test_message_serialization_with_ttl():
+    """Test serialization includes ttl when present"""
+    text_msg = TextMessage(text="Hello, world!")
+    message = Message(
+        phone_numbers=["123", "456"],
+        text_message=text_msg,
+        ttl=300,
+    )
+
+    assert "ttl" in message.asdict()
+    assert message.asdict()["ttl"] == 300
+
+
+def test_message_serialization_format_for_text_message():
+    """Test serialization format for text message"""
+    text_msg = TextMessage(text="Hello, world!")
+    message = Message(
+        phone_numbers=["123", "456"],
+        text_message=text_msg,
+        with_delivery_report=True,
+        is_encrypted=False,
+        id="msg_123",
+        device_id="device_001",
+        ttl=300,
+        sim_number=1,
+        priority=MessagePriority.BYPASS_THRESHOLD,
+    )
+
+    expected_dict = {
+        "textMessage": {"text": "Hello, world!"},
+        "phoneNumbers": ["123", "456"],
+        "withDeliveryReport": True,
+        "isEncrypted": False,
+        "id": "msg_123",
+        "deviceId": "device_001",
+        "ttl": 300,
+        "simNumber": 1,
+        "priority": 100,
+    }
+
+    assert message.asdict() == expected_dict
+
+
+def test_message_serialization_format_for_data_message():
+    """Test serialization format for data message"""
+    data_msg = DataMessage(data="base64encodeddata", port=1234)
+    message = Message(
+        phone_numbers=["123", "456"],
+        data_message=data_msg,
+        with_delivery_report=True,
+        is_encrypted=False,
+        id="msg_123",
+        device_id="device_001",
+        ttl=300,
+        sim_number=1,
+        priority=MessagePriority.BYPASS_THRESHOLD,
+    )
+
+    expected_dict = {
+        "dataMessage": {"data": "base64encodeddata", "port": 1234},
+        "phoneNumbers": ["123", "456"],
+        "withDeliveryReport": True,
+        "isEncrypted": False,
+        "id": "msg_123",
+        "deviceId": "device_001",
+        "ttl": 300,
+        "simNumber": 1,
+        "priority": 100,
+    }
+
+    assert message.asdict() == expected_dict
diff --git a/tests/test_error_handling.py b/tests/test_error_handling.py
index 49bf4c2..7247401 100644
--- a/tests/test_error_handling.py
+++ b/tests/test_error_handling.py
@@ -1,4 +1,4 @@
-from unittest.mock import Mock
+from unittest.mock import AsyncMock, Mock
 
 import aiohttp
 import httpx
@@ -175,12 +175,15 @@ class TestAiohttpAsyncHttpClientErrorHandling:
     @pytest.mark.asyncio
     async def test_raises_bad_request_error_for_400(self):
         """Test that BadRequestError is raised for 400 status."""
+        json = AsyncMock()
+        json.return_value = {"error": "bad request"}
+
         mock_response = Mock()
         mock_response.status = 400
         mock_response.raise_for_status.side_effect = aiohttp.ClientResponseError(
             request_info=Mock(), history=(), status=400, message="400 Client Error"
         )
-        mock_response.json.return_value = {"error": "bad request"}
+        mock_response.json = json
 
         client = AiohttpAsyncHttpClient()
 
@@ -193,12 +196,15 @@ async def test_raises_bad_request_error_for_400(self):
     @pytest.mark.asyncio
     async def test_raises_not_found_error_for_404(self):
         """Test that NotFoundError is raised for 404 status."""
+        json = AsyncMock()
+        json.return_value = {"error": "not found"}
+
         mock_response = Mock()
         mock_response.status = 404
         mock_response.raise_for_status.side_effect = aiohttp.ClientResponseError(
             request_info=Mock(), history=(), status=404, message="404 Not Found"
         )
-        mock_response.json.return_value = {"error": "not found"}
+        mock_response.json = json
 
         client = AiohttpAsyncHttpClient()
 

From dd24b481d0ee0bbe1cd2bc74224951279b16089c Mon Sep 17 00:00:00 2001
From: Aleksandr Soloshenko <capcom2me@gmail.com>
Date: Thu, 16 Oct 2025 08:52:28 +0700
Subject: [PATCH 10/10] [http] improve errors handling

---
 android_sms_gateway/ahttp.py | 13 +++++++------
 android_sms_gateway/http.py  | 10 ++++++----
 2 files changed, 13 insertions(+), 10 deletions(-)

diff --git a/android_sms_gateway/ahttp.py b/android_sms_gateway/ahttp.py
index aac37a8..595704e 100644
--- a/android_sms_gateway/ahttp.py
+++ b/android_sms_gateway/ahttp.py
@@ -1,4 +1,5 @@
 import abc
+from contextlib import suppress
 import typing as t
 
 from .errors import (
@@ -81,14 +82,13 @@ async def _process_response(self, response: aiohttp.ClientResponse) -> dict:
                     return {}
 
                 return await response.json()
+            except aiohttp.ContentTypeError:
+                return {}
             except aiohttp.ClientResponseError as e:
                 # Extract error message from response if available
                 error_data = {}
-                try:
+                with suppress(ValueError, aiohttp.ContentTypeError):
                     error_data = await response.json()
-                except ValueError:
-                    # Response is not JSON
-                    pass
 
                 # Use the error mapping to create appropriate exception
                 error_message = str(e) or "HTTP request failed"
@@ -188,7 +188,7 @@ async def __aexit__(self, exc_type, exc_val, exc_tb):
         async def _process_response(self, response: httpx.Response) -> dict:
             try:
                 response.raise_for_status()
-                if response.status_code == 204:
+                if response.status_code == 204 or not response.content:
                     return {}
 
                 return response.json()
@@ -196,7 +196,8 @@ async def _process_response(self, response: httpx.Response) -> dict:
                 # Extract error message from response if available
                 error_data = {}
                 try:
-                    error_data = response.json()
+                    if response.content:
+                        error_data = response.json()
                 except ValueError:
                     # Response is not JSON
                     pass
diff --git a/android_sms_gateway/http.py b/android_sms_gateway/http.py
index c47e2b7..bd74b0b 100644
--- a/android_sms_gateway/http.py
+++ b/android_sms_gateway/http.py
@@ -133,7 +133,7 @@ def patch(
         def _process_response(self, response: requests.Response) -> dict:
             try:
                 response.raise_for_status()
-                if response.status_code == 204:
+                if response.status_code == 204 or not response.content:
                     return {}
 
                 return response.json()
@@ -141,7 +141,8 @@ def _process_response(self, response: requests.Response) -> dict:
                 # Extract error message from response if available
                 error_data = {}
                 try:
-                    error_data = response.json()
+                    if response.content:
+                        error_data = response.json()
                 except ValueError:
                     # Response is not JSON
                     pass
@@ -181,7 +182,7 @@ def __exit__(self, exc_type, exc_val, exc_tb):
         def _process_response(self, response: httpx.Response) -> dict:
             try:
                 response.raise_for_status()
-                if response.status_code == 204:
+                if response.status_code == 204 or not response.content:
                     return {}
 
                 return response.json()
@@ -189,7 +190,8 @@ def _process_response(self, response: httpx.Response) -> dict:
                 # Extract error message from response if available
                 error_data = {}
                 try:
-                    error_data = response.json()
+                    if response.content:
+                        error_data = response.json()
                 except ValueError:
                     # Response is not JSON
                     pass