From f5ebcf481969c0c72218f8cdd1d26db4b7bb5bcb Mon Sep 17 00:00:00 2001 From: lovvskillz <14542790+lovvskillz@users.noreply.github.com> Date: Sun, 16 Aug 2026 15:48:25 +0200 Subject: [PATCH 1/8] add support for message components --- CHANGES.md | 3 + README.md | 91 ++++ discord_webhook/__init__.py | 32 +- discord_webhook/components.py | 485 ++++++++++++++++++++ discord_webhook/constants.py | 88 ++++ discord_webhook/utils.py | 39 ++ discord_webhook/webhook.py | 46 +- discord_webhook/webhook_exceptions.py | 8 + examples/components.py | 52 +++ tests/components/__init__.py | 0 tests/components/test_action_row.py | 96 ++++ tests/components/test_button.py | 58 +++ tests/components/test_component.py | 43 ++ tests/components/test_emoji.py | 34 ++ tests/components/test_select.py | 152 ++++++ tests/components/test_text_input.py | 69 +++ tests/components/test_webhook_components.py | 82 ++++ 17 files changed, 1374 insertions(+), 4 deletions(-) create mode 100644 discord_webhook/components.py create mode 100644 discord_webhook/utils.py create mode 100644 examples/components.py create mode 100644 tests/components/__init__.py create mode 100644 tests/components/test_action_row.py create mode 100644 tests/components/test_button.py create mode 100644 tests/components/test_component.py create mode 100644 tests/components/test_emoji.py create mode 100644 tests/components/test_select.py create mode 100644 tests/components/test_text_input.py create mode 100644 tests/components/test_webhook_components.py diff --git a/CHANGES.md b/CHANGES.md index e8aeef7..fc158bc 100644 --- a/CHANGES.md +++ b/CHANGES.md @@ -2,6 +2,9 @@ ## development +### 🎉 Features +- add support for message components (action rows, buttons, select menus, text inputs) + ## 2025-03-04 1.4.1 ### 🩹 Fixes diff --git a/README.md b/README.md index 42b77c1..5dfecec 100644 --- a/README.md +++ b/README.md @@ -293,6 +293,97 @@ webhook.remove_file("example.jpg") response = webhook.execute() ``` +### Add Components + +Components like buttons and select menus are always wrapped in an action row. +A message can contain up to 5 action rows, an action row can contain up to 5 buttons +*or* a single select menu. + +Note that Discord only renders interactive components for webhooks that are owned by an +application. Link buttons work with every webhook. + +```python +from discord_webhook import ( + DiscordComponentActionRow, + DiscordComponentButton, + DiscordComponentEmoji, + DiscordComponentStringSelect, + DiscordSelectOption, + DiscordWebhook, + constants, +) + +webhook = DiscordWebhook(url="your webhook url", content="Webhook Message") + +# a row with two buttons +buttons = DiscordComponentActionRow( + components=[ + DiscordComponentButton( + style=constants.DISCORD_COMPONENT_BUTTON_STYLE_LINK, + label="Documentation", + url="https://github.com/lovvskillz/python-discord-webhook", + ), + DiscordComponentButton( + style=constants.DISCORD_COMPONENT_BUTTON_STYLE_DANGER, + custom_id="delete_message", + label="Delete", + emoji=DiscordComponentEmoji(name="🗑️"), + ), + ] +) +webhook.add_component_row(buttons) + +# a select menu needs its own action row +select = DiscordComponentStringSelect( + custom_id="favourite_color", + placeholder="Choose your favourite color", + options=[ + DiscordSelectOption(label="Red", value="red", description="like a tomato"), + DiscordSelectOption(label="Blue", value="blue", default=True), + ], +) +webhook.add_component_row(DiscordComponentActionRow(components=[select])) + +response = webhook.execute() +``` + +These components are available: + +| Class | Description | +|--------------------------------------|------------------------------------------------------| +| `DiscordComponentActionRow` | container for other components | +| `DiscordComponentButton` | button (styles 1 - 5) | +| `DiscordComponentStringSelect` | select menu with your own options | +| `DiscordComponentUserSelect` | select menu with users | +| `DiscordComponentRoleSelect` | select menu with roles | +| `DiscordComponentMentionableSelect` | select menu with users and roles | +| `DiscordComponentChannelSelect` | select menu with channels | +| `DiscordComponentTextInput` | text input (modals only) | +| `DiscordSelectOption` | option of a `DiscordComponentStringSelect` | +| `DiscordComponentEmoji` | emoji for buttons and select options | + +The select menus that are populated by Discord accept default values: + +```python +from discord_webhook import DiscordComponentChannelSelect, constants + +channel_select = DiscordComponentChannelSelect( + custom_id="channel", + placeholder="Choose a channel", + channel_types=[constants.DISCORD_CHANNEL_TYPE_GUILD_TEXT], + max_values=3, +) +channel_select.add_default_value(123456789) +``` + +Already added action rows can be inspected and removed again: + +```python +webhook.get_component_rows() +webhook.remove_component_row(0) +webhook.remove_component_rows() +``` + ### Allowed Mentions Look into the [Discord Docs](https://discord.com/developers/docs/resources/channel#allowed-mentions-object) for examples and for more explanation. diff --git a/discord_webhook/__init__.py b/discord_webhook/__init__.py index b6a966f..531fa36 100644 --- a/discord_webhook/__init__.py +++ b/discord_webhook/__init__.py @@ -1,5 +1,31 @@ -__all__ = ["DiscordWebhook", "DiscordEmbed", "AsyncDiscordWebhook"] +__all__ = [ + "AsyncDiscordWebhook", + "DiscordComponentActionRow", + "DiscordComponentButton", + "DiscordComponentChannelSelect", + "DiscordComponentEmoji", + "DiscordComponentMentionableSelect", + "DiscordComponentRoleSelect", + "DiscordComponentStringSelect", + "DiscordComponentTextInput", + "DiscordComponentUserSelect", + "DiscordEmbed", + "DiscordSelectOption", + "DiscordWebhook", +] -from .webhook import DiscordWebhook, DiscordEmbed -from .async_webhook import AsyncDiscordWebhook +from .components import ( # isort:skip + DiscordComponentActionRow, + DiscordComponentButton, + DiscordComponentChannelSelect, + DiscordComponentEmoji, + DiscordComponentMentionableSelect, + DiscordComponentRoleSelect, + DiscordComponentStringSelect, + DiscordComponentTextInput, + DiscordComponentUserSelect, + DiscordSelectOption, +) +from .webhook import DiscordEmbed, DiscordWebhook # isort:skip +from .async_webhook import AsyncDiscordWebhook # isort:skip diff --git a/discord_webhook/components.py b/discord_webhook/components.py new file mode 100644 index 0000000..1f22ed4 --- /dev/null +++ b/discord_webhook/components.py @@ -0,0 +1,485 @@ +from typing import Any, Dict, List, Optional, Union + +from . import constants +from .utils import check_max_length, is_int, to_dict +from .webhook_exceptions import ComponentException + + +class DiscordComponentEmoji: + """ + Represent a partial emoji that can be used in components. + """ + + animated: Optional[bool] + id: Optional[str] + name: Optional[str] + + def __init__( + self, + name: Optional[str] = None, + id: Optional[str] = None, + animated: bool = False, + ) -> None: + """ + :param str name: name of the emoji (unicode emoji for standard emojis) + :param str id: id of the emoji for custom emojis + :param bool animated: whether the emoji is animated + """ + if not name and not id: + raise ComponentException("Either name or id needs to be provided.") + + self.name = name + self.id = id + self.animated = animated + + def to_dict(self) -> Dict[str, Any]: + """ + Convert the emoji to a dict. + :return: emoji as dict + """ + return {key: value for key, value in self.__dict__.items() if value is not None} + + +class BaseDiscordComponent: + """ + A base class for discord components. + """ + + custom_id: str + label: str + type: int + + def __init__(self, **kwargs): + self.custom_id = kwargs.get("custom_id") + self.label = kwargs.get("label") + + if not is_int(self.type) or self.type not in constants.DISCORD_COMPONENT_TYPES: + raise ComponentException( + "The provided component type is invalid. A valid component type is an" + " integer between 1 and 8." + ) + if self.custom_id and len(self.custom_id) > 100: + raise ComponentException("custom_id can be a maximum of 100 characters.") + + def to_dict(self) -> Dict[str, Any]: + """ + Convert the component to a dict. + :return: component as dict + """ + data = {"type": self.type} + for key, value in self.__dict__.items(): + if value is None or value == []: + continue + data[key] = to_dict(value) + return data + + +class DiscordComponentButton(BaseDiscordComponent): + """ + Represent a button that can be used in a message. + """ + + disabled: Optional[bool] + emoji: Optional[Union[dict, DiscordComponentEmoji]] + label: Optional[str] + style: int + type: int + url: Optional[str] + + def __init__( + self, style: int = constants.DISCORD_COMPONENT_BUTTON_STYLE_PRIMARY, **kwargs + ): + """ + :param style: button style (int 1 - 5) + :keyword disabled: Whether the button is disabled (defaults to false) + :keyword custom_id: developer-defined identifier for the button + :keyword emoji: emoji that appears on the button + :keyword label: Text that appears on the button + :keyword url: URL for DISCORD_COMPONENT_BUTTON_STYLE_LINK (int 5) buttons + """ + self.type = constants.DISCORD_COMPONENT_TYPE_BUTTON + self.style = style + self.disabled = kwargs.get("disabled", False) + self.custom_id = kwargs.get("custom_id") + self.emoji = kwargs.get("emoji") + self.label = kwargs.get("label") + self.url = kwargs.get("url") + + if ( + not is_int(self.style) + or self.style not in constants.DISCORD_COMPONENT_BUTTON_STYLES + ): + raise ComponentException( + "The provided button style is invalid. A valid button style is an" + " integer between 1 and 5." + ) + if ( + constants.DISCORD_COMPONENT_BUTTON_STYLE_PRIMARY + <= self.style + <= constants.DISCORD_COMPONENT_BUTTON_STYLE_DANGER + and not self.custom_id + ): + raise ComponentException("custom_id needs to be provided as a kwarg.") + if self.style == constants.DISCORD_COMPONENT_BUTTON_STYLE_LINK and not self.url: + raise ComponentException("url needs to be provided as a kwarg.") + if self.label and len(self.label) > 80: + raise ComponentException( + "The label can be a maximum of 80 characters long." + ) + + super().__init__(**kwargs) + + +class DiscordSelectOption: + """ + Represent an option of a string select menu. + """ + + default: Optional[bool] + description: Optional[str] + emoji: Optional[Union[dict, DiscordComponentEmoji]] + label: str + value: str + + def __init__(self, label: str, value: str, **kwargs) -> None: + """ + :param str label: user-facing name of the option + :param str value: developer-defined value of the option + :keyword str description: additional description of the option + :keyword emoji: emoji that appears next to the option + :keyword bool default: whether the option is selected by default + """ + self.label = label + self.value = value + self.description = kwargs.get("description") + self.emoji = kwargs.get("emoji") + self.default = kwargs.get("default", False) + + check_max_length(self.label, 100, "label", ComponentException) + check_max_length(self.value, 100, "value", ComponentException) + check_max_length(self.description, 100, "description", ComponentException) + + def to_dict(self) -> Dict[str, Any]: + """ + Convert the option to a dict. + :return: option as dict + """ + return { + key: to_dict(value) + for key, value in self.__dict__.items() + if value is not None + } + + +class BaseDiscordComponentSelect(BaseDiscordComponent): + """ + A base class for the different select menus. + """ + + disabled: Optional[bool] + max_values: Optional[int] + min_values: Optional[int] + placeholder: Optional[str] + + def __init__(self, custom_id: str, **kwargs) -> None: + """ + :param str custom_id: developer-defined identifier for the select menu + :keyword bool disabled: whether the select menu is disabled (defaults to false) + :keyword int max_values: maximum amount of options that can be chosen (1 - 25) + :keyword int min_values: minimum amount of options that have to be chosen (0 - 25) + :keyword str placeholder: text that is shown if nothing is selected + """ + kwargs["custom_id"] = custom_id + self.disabled = kwargs.get("disabled", False) + self.max_values = kwargs.get("max_values", 1) + self.min_values = kwargs.get("min_values", 1) + self.placeholder = kwargs.get("placeholder") + + if not custom_id: + raise ComponentException("custom_id needs to be provided.") + check_max_length(self.placeholder, 150, "placeholder", ComponentException) + for name, value, minimum in [ + ("min_values", self.min_values, 0), + ("max_values", self.max_values, 1), + ]: + if not is_int(value) or not minimum <= value <= 25: + raise ComponentException( + f"{name} needs to be an integer between {minimum} and 25." + ) + + super().__init__(**kwargs) + + +class DiscordComponentStringSelect(BaseDiscordComponentSelect): + """ + Represent a select menu with developer-defined options. + """ + + options: List[Union[dict, DiscordSelectOption]] + + def __init__( + self, + custom_id: str, + options: Optional[List[Union[dict, DiscordSelectOption]]] = None, + **kwargs, + ) -> None: + """ + :param str custom_id: developer-defined identifier for the select menu + :param list options: choices of the select menu (up to 25) + """ + self.type = constants.DISCORD_COMPONENT_TYPE_STRING_SELECT + self.options = [] + + super().__init__(custom_id, **kwargs) + + for option in options or []: + self.add_option(option) + + def add_option(self, option: Union[dict, DiscordSelectOption]) -> None: + """ + Add an option to the select menu. + :param option: option instance or dict + """ + if len(self.options) >= constants.DISCORD_MAX_SELECT_OPTIONS: + raise ComponentException( + "A select menu can contain up to" + f" {constants.DISCORD_MAX_SELECT_OPTIONS} options." + ) + self.options.append(option) + + +class BaseDiscordComponentAutoPopulatedSelect(BaseDiscordComponentSelect): + """ + A base class for select menus that are populated by Discord itself. + """ + + default_values: List[Dict[str, str]] + + #: value of the ``type`` field of a default value entry + default_value_type: str = "" + + def __init__(self, custom_id: str, **kwargs) -> None: + """ + :param str custom_id: developer-defined identifier for the select menu + :keyword list default_values: ids that are selected by default + """ + self.default_values = [] + + super().__init__(custom_id, **kwargs) + + for default_value in kwargs.get("default_values") or []: + self.add_default_value(default_value) + + def add_default_value( + self, value: Union[str, int, Dict[str, str]], value_type: Optional[str] = None + ) -> None: + """ + Add a default value to the select menu. + :param value: id of the user, role or channel or a dict with id and type + :param str value_type: type of the value ("user", "role" or "channel") + """ + if not isinstance(value, dict): + value = { + "id": str(value), + "type": value_type or self.default_value_type, + } + if value.get("type") not in ["user", "role", "channel"]: + raise ComponentException( + 'The type of a default value needs to be "user", "role" or "channel".' + ) + self.default_values.append(value) + + +class DiscordComponentUserSelect(BaseDiscordComponentAutoPopulatedSelect): + """ + Represent a select menu for users. + """ + + default_value_type = "user" + + def __init__(self, custom_id: str, **kwargs) -> None: + self.type = constants.DISCORD_COMPONENT_TYPE_USER_SELECT + super().__init__(custom_id, **kwargs) + + +class DiscordComponentRoleSelect(BaseDiscordComponentAutoPopulatedSelect): + """ + Represent a select menu for roles. + """ + + default_value_type = "role" + + def __init__(self, custom_id: str, **kwargs) -> None: + self.type = constants.DISCORD_COMPONENT_TYPE_ROLE_SELECT + super().__init__(custom_id, **kwargs) + + +class DiscordComponentMentionableSelect(BaseDiscordComponentAutoPopulatedSelect): + """ + Represent a select menu for mentionables (users and roles). + """ + + default_value_type = "user" + + def __init__(self, custom_id: str, **kwargs) -> None: + self.type = constants.DISCORD_COMPONENT_TYPE_MENTIONABLE_SELECT + super().__init__(custom_id, **kwargs) + + +class DiscordComponentChannelSelect(BaseDiscordComponentAutoPopulatedSelect): + """ + Represent a select menu for channels. + """ + + channel_types: List[int] + default_value_type = "channel" + + def __init__( + self, custom_id: str, channel_types: Optional[List[int]] = None, **kwargs + ) -> None: + """ + :param str custom_id: developer-defined identifier for the select menu + :param list channel_types: channel types that should be included in the menu + """ + self.type = constants.DISCORD_COMPONENT_TYPE_CHANNEL_SELECT + self.channel_types = channel_types or [] + + for channel_type in self.channel_types: + if channel_type not in constants.DISCORD_CHANNEL_TYPES: + raise ComponentException( + f"{channel_type!r} is not a valid channel type." + ) + + super().__init__(custom_id, **kwargs) + + +class DiscordComponentTextInput(BaseDiscordComponent): + """ + Represent a text input that can be used in a modal. + """ + + max_length: Optional[int] + min_length: Optional[int] + placeholder: Optional[str] + required: Optional[bool] + style: int + value: Optional[str] + + def __init__( + self, + custom_id: str, + label: str, + style: int = constants.DISCORD_COMPONENT_TEXT_INPUT_STYLE_SHORT, + **kwargs, + ) -> None: + """ + :param str custom_id: developer-defined identifier for the text input + :param str label: label of the text input + :param int style: text input style (int 1 - 2) + :keyword int max_length: maximum input length (1 - 4000) + :keyword int min_length: minimum input length (0 - 4000) + :keyword str placeholder: text that is shown if the input is empty + :keyword bool required: whether the text input is required (defaults to true) + :keyword str value: pre-filled value of the text input + """ + kwargs["custom_id"] = custom_id + kwargs["label"] = label + self.type = constants.DISCORD_COMPONENT_TYPE_TEXT_INPUT + self.style = style + self.max_length = kwargs.get("max_length") + self.min_length = kwargs.get("min_length") + self.placeholder = kwargs.get("placeholder") + self.required = kwargs.get("required", True) + self.value = kwargs.get("value") + + if ( + not is_int(self.style) + or self.style not in constants.DISCORD_COMPONENT_TEXT_INPUT_STYLES + ): + raise ComponentException( + "The provided text input style is invalid. A valid text input style is" + " an integer between 1 and 2." + ) + if not custom_id: + raise ComponentException("custom_id needs to be provided.") + check_max_length(label, 45, "label", ComponentException) + check_max_length(self.placeholder, 100, "placeholder", ComponentException) + check_max_length(self.value, 4000, "value", ComponentException) + + super().__init__(**kwargs) + + +class DiscordComponentActionRow(BaseDiscordComponent): + """ + Represent an action row that can be used in a message. + """ + + components: list + type: int = constants.DISCORD_COMPONENT_TYPE_ACTION_ROW + + def __init__( + self, + components: Optional[List[Union[dict, BaseDiscordComponent]]] = None, + **kwargs, + ): + """ + :keyword components: displayed components in an action row + """ + self.components = [] + self.type = constants.DISCORD_COMPONENT_TYPE_ACTION_ROW + + super().__init__(**kwargs) + + for component in components or []: + self.add_component(component) + + def _component_types(self) -> List[Optional[int]]: + """ + Get the types of all already added components. + :return: list of component types + """ + return [component.get("type") for component in self.components] + + def add_component(self, component: Union[dict, BaseDiscordComponent]) -> None: + """ + Add a component to the row + :param component: discord component instance + """ + if isinstance(component, DiscordComponentActionRow): + raise ComponentException("An action row can't contain another action row.") + if ( + isinstance(component, DiscordComponentButton) + and sum( + 1 + for component_type in self._component_types() + if component_type == constants.DISCORD_COMPONENT_TYPE_BUTTON + ) + >= constants.DISCORD_MAX_BUTTONS_PER_ACTION_ROW + ): + raise ComponentException("An Action Row can contain up to 5 buttons.") + + if not isinstance(component, dict): + component = component.to_dict() + + component_type = component.get("type") + existing_types = self._component_types() + exclusive_types = constants.DISCORD_COMPONENT_SELECT_TYPES + [ + constants.DISCORD_COMPONENT_TYPE_TEXT_INPUT + ] + if existing_types and ( + component_type in exclusive_types + or any(existing_type in exclusive_types for existing_type in existing_types) + ): + raise ComponentException( + "A select menu or text input has to be the only component in an action" + " row." + ) + + self.components.append(component) + + def to_dict(self) -> Dict[str, Any]: + """ + Convert the action row and its components to a dict. + :return: action row as dict + """ + return {"type": self.type, "components": to_dict(self.components)} diff --git a/discord_webhook/constants.py b/discord_webhook/constants.py index 65bf80d..da823c6 100644 --- a/discord_webhook/constants.py +++ b/discord_webhook/constants.py @@ -5,3 +5,91 @@ class MessageFlags(Enum): NONE = 0 SUPPRESS_EMBEDS = 4 SUPPRESS_NOTIFICATIONS = 4096 + + +DISCORD_COMPONENT_TYPE_ACTION_ROW = 1 +DISCORD_COMPONENT_TYPE_BUTTON = 2 +DISCORD_COMPONENT_TYPE_STRING_SELECT = 3 +DISCORD_COMPONENT_TYPE_TEXT_INPUT = 4 +DISCORD_COMPONENT_TYPE_USER_SELECT = 5 +DISCORD_COMPONENT_TYPE_ROLE_SELECT = 6 +DISCORD_COMPONENT_TYPE_MENTIONABLE_SELECT = 7 +DISCORD_COMPONENT_TYPE_CHANNEL_SELECT = 8 + +DISCORD_COMPONENT_TYPES = [ + DISCORD_COMPONENT_TYPE_ACTION_ROW, + DISCORD_COMPONENT_TYPE_BUTTON, + DISCORD_COMPONENT_TYPE_STRING_SELECT, + DISCORD_COMPONENT_TYPE_TEXT_INPUT, + DISCORD_COMPONENT_TYPE_USER_SELECT, + DISCORD_COMPONENT_TYPE_ROLE_SELECT, + DISCORD_COMPONENT_TYPE_MENTIONABLE_SELECT, + DISCORD_COMPONENT_TYPE_CHANNEL_SELECT, +] + +DISCORD_COMPONENT_SELECT_TYPES = [ + DISCORD_COMPONENT_TYPE_STRING_SELECT, + DISCORD_COMPONENT_TYPE_USER_SELECT, + DISCORD_COMPONENT_TYPE_ROLE_SELECT, + DISCORD_COMPONENT_TYPE_MENTIONABLE_SELECT, + DISCORD_COMPONENT_TYPE_CHANNEL_SELECT, +] + +DISCORD_COMPONENT_BUTTON_STYLE_PRIMARY = 1 +DISCORD_COMPONENT_BUTTON_STYLE_SECONDARY = 2 +DISCORD_COMPONENT_BUTTON_STYLE_SUCCESS = 3 +DISCORD_COMPONENT_BUTTON_STYLE_DANGER = 4 +DISCORD_COMPONENT_BUTTON_STYLE_LINK = 5 + +DISCORD_COMPONENT_BUTTON_STYLES = [ + DISCORD_COMPONENT_BUTTON_STYLE_PRIMARY, + DISCORD_COMPONENT_BUTTON_STYLE_SECONDARY, + DISCORD_COMPONENT_BUTTON_STYLE_SUCCESS, + DISCORD_COMPONENT_BUTTON_STYLE_DANGER, + DISCORD_COMPONENT_BUTTON_STYLE_LINK, +] + +DISCORD_COMPONENT_TEXT_INPUT_STYLE_SHORT = 1 +DISCORD_COMPONENT_TEXT_INPUT_STYLE_PARAGRAPH = 2 + +DISCORD_COMPONENT_TEXT_INPUT_STYLES = [ + DISCORD_COMPONENT_TEXT_INPUT_STYLE_SHORT, + DISCORD_COMPONENT_TEXT_INPUT_STYLE_PARAGRAPH, +] + +DISCORD_CHANNEL_TYPE_GUILD_TEXT = 0 +DISCORD_CHANNEL_TYPE_DM = 1 +DISCORD_CHANNEL_TYPE_GUILD_VOICE = 2 +DISCORD_CHANNEL_TYPE_GROUP_DM = 3 +DISCORD_CHANNEL_TYPE_GUILD_CATEGORY = 4 +DISCORD_CHANNEL_TYPE_GUILD_ANNOUNCEMENT = 5 +DISCORD_CHANNEL_TYPE_ANNOUNCEMENT_THREAD = 10 +DISCORD_CHANNEL_TYPE_PUBLIC_THREAD = 11 +DISCORD_CHANNEL_TYPE_PRIVATE_THREAD = 12 +DISCORD_CHANNEL_TYPE_GUILD_STAGE_VOICE = 13 +DISCORD_CHANNEL_TYPE_GUILD_DIRECTORY = 14 +DISCORD_CHANNEL_TYPE_GUILD_FORUM = 15 +DISCORD_CHANNEL_TYPE_GUILD_MEDIA = 16 + +DISCORD_CHANNEL_TYPES = [ + DISCORD_CHANNEL_TYPE_GUILD_TEXT, + DISCORD_CHANNEL_TYPE_DM, + DISCORD_CHANNEL_TYPE_GUILD_VOICE, + DISCORD_CHANNEL_TYPE_GROUP_DM, + DISCORD_CHANNEL_TYPE_GUILD_CATEGORY, + DISCORD_CHANNEL_TYPE_GUILD_ANNOUNCEMENT, + DISCORD_CHANNEL_TYPE_ANNOUNCEMENT_THREAD, + DISCORD_CHANNEL_TYPE_PUBLIC_THREAD, + DISCORD_CHANNEL_TYPE_PRIVATE_THREAD, + DISCORD_CHANNEL_TYPE_GUILD_STAGE_VOICE, + DISCORD_CHANNEL_TYPE_GUILD_DIRECTORY, + DISCORD_CHANNEL_TYPE_GUILD_FORUM, + DISCORD_CHANNEL_TYPE_GUILD_MEDIA, +] + +# maximum amount of action rows a message can contain +DISCORD_MAX_ACTION_ROWS = 5 +# maximum amount of buttons a single action row can contain +DISCORD_MAX_BUTTONS_PER_ACTION_ROW = 5 +# maximum amount of options a select menu can contain +DISCORD_MAX_SELECT_OPTIONS = 25 diff --git a/discord_webhook/utils.py b/discord_webhook/utils.py new file mode 100644 index 0000000..4f636cb --- /dev/null +++ b/discord_webhook/utils.py @@ -0,0 +1,39 @@ +from typing import Any, Type + + +def to_dict(value: Any) -> Any: + """ + Convert objects and nested values to JSON serializable data. + :param value: value that should be converted + :return: converted value + """ + if isinstance(value, list): + return [to_dict(item) for item in value] + if isinstance(value, dict): + return {key: to_dict(item) for key, item in value.items() if item is not None} + if hasattr(value, "to_dict"): + return value.to_dict() + return value + + +def is_int(value: Any) -> bool: + """ + Check whether the given value is an integer. Booleans are not accepted. + :param value: value that should be checked + :return: whether the value is an integer + """ + return isinstance(value, int) and not isinstance(value, bool) + + +def check_max_length( + value: Any, max_length: int, name: str, exception: Type[Exception] +) -> None: + """ + Raise the given exception if the value exceeds the maximum length. + :param value: value that should be checked + :param int max_length: maximum amount of characters + :param str name: name of the field that is being checked + :param exception: exception that should be raised + """ + if value is not None and len(value) > max_length: + raise exception(f"{name} can be a maximum of {max_length} characters.") diff --git a/discord_webhook/webhook.py b/discord_webhook/webhook.py index 8291814..8597136 100644 --- a/discord_webhook/webhook.py +++ b/discord_webhook/webhook.py @@ -7,7 +7,9 @@ from typing import Any, Dict, List, Optional, Tuple, Union import requests -from .webhook_exceptions import ColorNotInRangeException +from . import constants +from .components import DiscordComponentActionRow +from .webhook_exceptions import ColorNotInRangeException, ComponentException logger = logging.getLogger(__name__) @@ -250,6 +252,7 @@ def __init__(self, url: str, **kwargs) -> None: :keyword dict allowed_mentions: allowed mentions for the message :keyword dict attachments: attachments that should be included :keyword str avatar_url: override the default avatar of the webhook + :keyword list components: list of action rows with components :keyword str content: the message contents :keyword list embeds: list of embedded rich content :keyword int flags: apply flags to the message @@ -267,6 +270,7 @@ def __init__(self, url: str, **kwargs) -> None: self.allowed_mentions = kwargs.get("allowed_mentions", {}) self.attachments = kwargs.get("attachments", []) self.avatar_url = kwargs.get("avatar_url") + self.components = [] self.content = kwargs.get("content") self.embeds = kwargs.get("embeds", []) self.flags = kwargs.get("flags") @@ -281,6 +285,46 @@ def __init__(self, url: str, **kwargs) -> None: self.url = url self.username = kwargs.get("username", False) self.wait = kwargs.get("wait", True) + for action_row in kwargs.get("components", []): + self.add_component_row(action_row) + + def add_component_row( + self, action_row: Union[DiscordComponentActionRow, Dict[str, Any]] + ) -> None: + """ + Add an action row with components to the webhook. + :param action_row: action row instance or dict + """ + if len(self.components) >= constants.DISCORD_MAX_ACTION_ROWS: + raise ComponentException( + f"A message can contain up to {constants.DISCORD_MAX_ACTION_ROWS} action" + " rows." + ) + self.components.append( + action_row.to_dict() + if isinstance(action_row, DiscordComponentActionRow) + else action_row + ) + + def get_component_rows(self) -> List[Dict[str, Any]]: + """ + Get all action rows as a list. + :return: action rows + """ + return self.components + + def remove_component_row(self, index: int) -> None: + """ + Remove an action row from the already added action rows. + :param int index: index of the action row + """ + self.components.pop(index) + + def remove_component_rows(self) -> None: + """ + Remove all action rows. + """ + self.components = [] def add_embed(self, embed: Union[DiscordEmbed, Dict[str, Any]]) -> None: """ diff --git a/discord_webhook/webhook_exceptions.py b/discord_webhook/webhook_exceptions.py index 6342cf1..b1c3036 100644 --- a/discord_webhook/webhook_exceptions.py +++ b/discord_webhook/webhook_exceptions.py @@ -16,3 +16,11 @@ def __init__(self, color: Union[str, int], message=None) -> None: " (HEXADECIMAL)." ) super().__init__(message) + + +class ComponentException(Exception): + """ + This Exception will be raised for components. + """ + + pass diff --git a/examples/components.py b/examples/components.py new file mode 100644 index 0000000..7d5d92c --- /dev/null +++ b/examples/components.py @@ -0,0 +1,52 @@ +from discord_webhook import ( + DiscordComponentActionRow, + DiscordComponentButton, + DiscordComponentChannelSelect, + DiscordComponentEmoji, + DiscordComponentStringSelect, + DiscordSelectOption, + DiscordWebhook, + constants, +) + +webhook = DiscordWebhook(url="your webhook url", content="Webhook Message") + +# a row with two buttons +buttons = DiscordComponentActionRow( + components=[ + DiscordComponentButton( + style=constants.DISCORD_COMPONENT_BUTTON_STYLE_LINK, + label="Documentation", + url="https://github.com/lovvskillz/python-discord-webhook", + ), + DiscordComponentButton( + style=constants.DISCORD_COMPONENT_BUTTON_STYLE_DANGER, + custom_id="delete_message", + label="Delete", + emoji=DiscordComponentEmoji(name="🗑️"), + ), + ] +) +webhook.add_component_row(buttons) + +# a select menu needs its own action row +select = DiscordComponentStringSelect( + custom_id="favourite_color", + placeholder="Choose your favourite color", + options=[ + DiscordSelectOption(label="Red", value="red", description="like a tomato"), + DiscordSelectOption(label="Blue", value="blue", default=True), + ], +) +webhook.add_component_row(DiscordComponentActionRow(components=[select])) + +# select menus that are populated by Discord itself +channel_select = DiscordComponentChannelSelect( + custom_id="channel", + placeholder="Choose a channel", + channel_types=[constants.DISCORD_CHANNEL_TYPE_GUILD_TEXT], + max_values=3, +) +webhook.add_component_row(DiscordComponentActionRow(components=[channel_select])) + +response = webhook.execute() diff --git a/tests/components/__init__.py b/tests/components/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/components/test_action_row.py b/tests/components/test_action_row.py new file mode 100644 index 0000000..7697da5 --- /dev/null +++ b/tests/components/test_action_row.py @@ -0,0 +1,96 @@ +import pytest +from pytest import mark + +from discord_webhook import ( + DiscordComponentActionRow, + DiscordComponentButton, + DiscordComponentStringSelect, + DiscordComponentTextInput, + DiscordSelectOption, + constants, +) +from discord_webhook.webhook_exceptions import ComponentException + + +def test__action_row_in_action_row(): + action_row_1 = DiscordComponentActionRow() + action_row_2 = DiscordComponentActionRow() + + with pytest.raises(ComponentException) as excinfo: + action_row_1.add_component(action_row_2) + + assert str(excinfo.value) == "An action row can't contain another action row." + assert len(action_row_1.components) == 0 + + +def test__max_buttons(): + action_row = DiscordComponentActionRow() + button = DiscordComponentButton(custom_id="test") + for _ in range(0, 5): + action_row.add_component(button) + + with pytest.raises(ComponentException) as excinfo: + action_row.add_component(button) + + assert str(excinfo.value) == "An Action Row can contain up to 5 buttons." + assert len(action_row.components) == 5 + + +def _exclusive_components(): + return [ + DiscordComponentStringSelect( + custom_id="select", options=[DiscordSelectOption(label="a", value="a")] + ), + DiscordComponentTextInput(custom_id="input", label="test"), + ] + + +@mark.parametrize("component", _exclusive_components()) +def test__exclusive_component__with_existing_button(component): + action_row = DiscordComponentActionRow( + components=[DiscordComponentButton(custom_id="test")] + ) + + with pytest.raises(ComponentException) as excinfo: + action_row.add_component(component) + + assert ( + str(excinfo.value) + == "A select menu or text input has to be the only component in an action row." + ) + assert len(action_row.components) == 1 + + +@mark.parametrize("component", _exclusive_components()) +def test__exclusive_component__followed_by_button(component): + action_row = DiscordComponentActionRow(components=[component]) + + with pytest.raises(ComponentException) as excinfo: + action_row.add_component(DiscordComponentButton(custom_id="test")) + + assert ( + str(excinfo.value) + == "A select menu or text input has to be the only component in an action row." + ) + assert len(action_row.components) == 1 + + +def test__action_row__to_dict(): + action_row = DiscordComponentActionRow( + components=[ + DiscordComponentButton(custom_id="test", label="Click me", disabled=True) + ] + ) + + assert action_row.to_dict() == { + "type": constants.DISCORD_COMPONENT_TYPE_ACTION_ROW, + "components": [ + { + "type": constants.DISCORD_COMPONENT_TYPE_BUTTON, + "style": constants.DISCORD_COMPONENT_BUTTON_STYLE_PRIMARY, + "custom_id": "test", + "label": "Click me", + "disabled": True, + } + ], + } diff --git a/tests/components/test_button.py b/tests/components/test_button.py new file mode 100644 index 0000000..acf98d4 --- /dev/null +++ b/tests/components/test_button.py @@ -0,0 +1,58 @@ +import pytest +from pytest import mark + +from discord_webhook import DiscordComponentButton, constants +from discord_webhook.webhook_exceptions import ComponentException + + +@mark.parametrize( + "style, field, error_message", + [ + ( + constants.DISCORD_COMPONENT_BUTTON_STYLE_PRIMARY, + "custom_id", + "custom_id needs to be provided as a kwarg.", + ), + ( + constants.DISCORD_COMPONENT_BUTTON_STYLE_SECONDARY, + "custom_id", + "custom_id needs to be provided as a kwarg.", + ), + ( + constants.DISCORD_COMPONENT_BUTTON_STYLE_SUCCESS, + "custom_id", + "custom_id needs to be provided as a kwarg.", + ), + ( + constants.DISCORD_COMPONENT_BUTTON_STYLE_DANGER, + "custom_id", + "custom_id needs to be provided as a kwarg.", + ), + ( + constants.DISCORD_COMPONENT_BUTTON_STYLE_LINK, + "url", + "url needs to be provided as a kwarg.", + ), + ], +) +def test__styles__required_fields(style, field, error_message): + # valid button + DiscordComponentButton(**{"style": style, field: "test_string"}) + + # required field is missing + with pytest.raises(ComponentException) as excinfo: + DiscordComponentButton(style=style) + + assert str(excinfo.value) == error_message + + +@mark.parametrize("invalid_style", [0, 6, "a", True, None]) +def test__styles__invalid(invalid_style): + with pytest.raises(ComponentException) as excinfo: + DiscordComponentButton(style=invalid_style) + + assert ( + str(excinfo.value) + == "The provided button style is invalid. A valid button style is an integer" + " between 1 and 5." + ) diff --git a/tests/components/test_component.py b/tests/components/test_component.py new file mode 100644 index 0000000..9193a89 --- /dev/null +++ b/tests/components/test_component.py @@ -0,0 +1,43 @@ +import pytest + +from discord_webhook.components import BaseDiscordComponent +from discord_webhook import constants +from discord_webhook.webhook_exceptions import ComponentException + + +def test__component__types(): + for component_type in constants.DISCORD_COMPONENT_TYPES: + + class TestDiscordComponent(BaseDiscordComponent): + type = component_type + + TestDiscordComponent() + + for component_type in [0, 9, "a", True]: + + class TestDiscordComponent(BaseDiscordComponent): + type = component_type + + with pytest.raises(ComponentException) as excinfo: + TestDiscordComponent() + + assert ( + str(excinfo.value) + == "The provided component type is invalid. A valid component type is an" + " integer between 1 and 8." + ) + + +def test__component__custom_id_max_length(): + class TestDiscordComponent(BaseDiscordComponent): + type = constants.DISCORD_COMPONENT_TYPE_BUTTON + + custom_id = "".join("a" for i in range(100)) + + TestDiscordComponent(custom_id=custom_id) + + # total length of 101 chars + with pytest.raises(ComponentException) as excinfo: + TestDiscordComponent(custom_id=f"{custom_id}a") + + assert str(excinfo.value) == "custom_id can be a maximum of 100 characters." diff --git a/tests/components/test_emoji.py b/tests/components/test_emoji.py new file mode 100644 index 0000000..e0356e5 --- /dev/null +++ b/tests/components/test_emoji.py @@ -0,0 +1,34 @@ +import pytest + +from discord_webhook import DiscordComponentButton, DiscordComponentEmoji +from discord_webhook.webhook_exceptions import ComponentException + + +def test__emoji__unicode(): + assert DiscordComponentEmoji(name="🔥").to_dict() == { + "name": "🔥", + "animated": False, + } + + +def test__emoji__custom(): + assert DiscordComponentEmoji(name="blob", id="123", animated=True).to_dict() == { + "name": "blob", + "id": "123", + "animated": True, + } + + +def test__emoji__missing_name_and_id(): + with pytest.raises(ComponentException) as excinfo: + DiscordComponentEmoji() + + assert str(excinfo.value) == "Either name or id needs to be provided." + + +def test__emoji__in_button(): + button = DiscordComponentButton( + custom_id="test", label="fire", emoji=DiscordComponentEmoji(name="🔥") + ) + + assert button.to_dict()["emoji"] == {"name": "🔥", "animated": False} diff --git a/tests/components/test_select.py b/tests/components/test_select.py new file mode 100644 index 0000000..9459d12 --- /dev/null +++ b/tests/components/test_select.py @@ -0,0 +1,152 @@ +import pytest +from pytest import mark + +from discord_webhook import ( + DiscordComponentChannelSelect, + DiscordComponentMentionableSelect, + DiscordComponentRoleSelect, + DiscordComponentStringSelect, + DiscordComponentUserSelect, + DiscordSelectOption, + constants, +) +from discord_webhook.webhook_exceptions import ComponentException + +AUTO_POPULATED_SELECTS = [ + (DiscordComponentUserSelect, constants.DISCORD_COMPONENT_TYPE_USER_SELECT, "user"), + (DiscordComponentRoleSelect, constants.DISCORD_COMPONENT_TYPE_ROLE_SELECT, "role"), + ( + DiscordComponentMentionableSelect, + constants.DISCORD_COMPONENT_TYPE_MENTIONABLE_SELECT, + "user", + ), + ( + DiscordComponentChannelSelect, + constants.DISCORD_COMPONENT_TYPE_CHANNEL_SELECT, + "channel", + ), +] + + +@mark.parametrize("select_class, component_type, _", AUTO_POPULATED_SELECTS) +def test__auto_populated_selects__type(select_class, component_type, _): + assert select_class(custom_id="test").to_dict()["type"] == component_type + + +@mark.parametrize("select_class, _, value_type", AUTO_POPULATED_SELECTS) +def test__auto_populated_selects__default_values(select_class, _, value_type): + select = select_class(custom_id="test") + select.add_default_value(123456789) + + assert select.to_dict()["default_values"] == [ + {"id": "123456789", "type": value_type} + ] + + +def test__default_values__invalid_type(): + select = DiscordComponentUserSelect(custom_id="test") + + with pytest.raises(ComponentException) as excinfo: + select.add_default_value(123456789, value_type="invalid") + + assert ( + str(excinfo.value) + == 'The type of a default value needs to be "user", "role" or "channel".' + ) + + +def test__string_select__options(): + select = DiscordComponentStringSelect( + custom_id="test", + options=[DiscordSelectOption(label="first", value="1")], + placeholder="choose", + ) + select.add_option({"label": "second", "value": "2"}) + + assert select.to_dict() == { + "type": constants.DISCORD_COMPONENT_TYPE_STRING_SELECT, + "custom_id": "test", + "placeholder": "choose", + "disabled": False, + "min_values": 1, + "max_values": 1, + "options": [ + {"label": "first", "value": "1", "default": False}, + {"label": "second", "value": "2"}, + ], + } + + +def test__string_select__max_options(): + select = DiscordComponentStringSelect(custom_id="test") + for index in range(constants.DISCORD_MAX_SELECT_OPTIONS): + select.add_option(DiscordSelectOption(label=str(index), value=str(index))) + + with pytest.raises(ComponentException) as excinfo: + select.add_option(DiscordSelectOption(label="too much", value="26")) + + assert str(excinfo.value) == "A select menu can contain up to 25 options." + assert len(select.options) == constants.DISCORD_MAX_SELECT_OPTIONS + + +@mark.parametrize( + "kwargs, error_message", + [ + ({"min_values": 26}, "min_values needs to be an integer between 0 and 25."), + ({"min_values": -1}, "min_values needs to be an integer between 0 and 25."), + ({"max_values": 0}, "max_values needs to be an integer between 1 and 25."), + ({"max_values": "a"}, "max_values needs to be an integer between 1 and 25."), + ( + {"placeholder": "a" * 151}, + "placeholder can be a maximum of 150 characters.", + ), + ], +) +def test__select__invalid_values(kwargs, error_message): + with pytest.raises(ComponentException) as excinfo: + DiscordComponentStringSelect(custom_id="test", **kwargs) + + assert str(excinfo.value) == error_message + + +def test__select__missing_custom_id(): + with pytest.raises(ComponentException) as excinfo: + DiscordComponentStringSelect(custom_id="") + + assert str(excinfo.value) == "custom_id needs to be provided." + + +def test__channel_select__channel_types(): + select = DiscordComponentChannelSelect( + custom_id="test", channel_types=[constants.DISCORD_CHANNEL_TYPE_GUILD_TEXT] + ) + + assert select.to_dict()["channel_types"] == [ + constants.DISCORD_CHANNEL_TYPE_GUILD_TEXT + ] + + with pytest.raises(ComponentException) as excinfo: + DiscordComponentChannelSelect(custom_id="test", channel_types=[99]) + + assert str(excinfo.value) == "99 is not a valid channel type." + + +@mark.parametrize( + "kwargs, error_message", + [ + ({"label": "a" * 101}, "label can be a maximum of 100 characters."), + ({"value": "a" * 101}, "value can be a maximum of 100 characters."), + ( + {"description": "a" * 101}, + "description can be a maximum of 100 characters.", + ), + ], +) +def test__select_option__max_lengths(kwargs, error_message): + option_kwargs = {"label": "test", "value": "test"} + option_kwargs.update(kwargs) + + with pytest.raises(ComponentException) as excinfo: + DiscordSelectOption(**option_kwargs) + + assert str(excinfo.value) == error_message diff --git a/tests/components/test_text_input.py b/tests/components/test_text_input.py new file mode 100644 index 0000000..eff5551 --- /dev/null +++ b/tests/components/test_text_input.py @@ -0,0 +1,69 @@ +import pytest +from pytest import mark + +from discord_webhook import DiscordComponentTextInput, constants +from discord_webhook.webhook_exceptions import ComponentException + + +def test__text_input__defaults(): + text_input = DiscordComponentTextInput(custom_id="test", label="Your name") + + assert text_input.to_dict() == { + "type": constants.DISCORD_COMPONENT_TYPE_TEXT_INPUT, + "custom_id": "test", + "label": "Your name", + "style": constants.DISCORD_COMPONENT_TEXT_INPUT_STYLE_SHORT, + "required": True, + } + + +def test__text_input__paragraph(): + text_input = DiscordComponentTextInput( + custom_id="test", + label="Your feedback", + style=constants.DISCORD_COMPONENT_TEXT_INPUT_STYLE_PARAGRAPH, + placeholder="Tell us more", + min_length=10, + max_length=1000, + required=False, + ) + data = text_input.to_dict() + + assert data["style"] == constants.DISCORD_COMPONENT_TEXT_INPUT_STYLE_PARAGRAPH + assert data["min_length"] == 10 + assert data["max_length"] == 1000 + assert data["placeholder"] == "Tell us more" + assert data["required"] is False + + +@mark.parametrize("invalid_style", [0, 3, "a", True, None]) +def test__text_input__invalid_style(invalid_style): + with pytest.raises(ComponentException) as excinfo: + DiscordComponentTextInput(custom_id="test", label="test", style=invalid_style) + + assert ( + str(excinfo.value) + == "The provided text input style is invalid. A valid text input style is an" + " integer between 1 and 2." + ) + + +@mark.parametrize( + "kwargs, error_message", + [ + ({"label": "a" * 46}, "label can be a maximum of 45 characters."), + ( + {"placeholder": "a" * 101}, + "placeholder can be a maximum of 100 characters.", + ), + ({"value": "a" * 4001}, "value can be a maximum of 4000 characters."), + ], +) +def test__text_input__max_lengths(kwargs, error_message): + input_kwargs = {"custom_id": "test", "label": "test"} + input_kwargs.update(kwargs) + + with pytest.raises(ComponentException) as excinfo: + DiscordComponentTextInput(**input_kwargs) + + assert str(excinfo.value) == error_message diff --git a/tests/components/test_webhook_components.py b/tests/components/test_webhook_components.py new file mode 100644 index 0000000..533d9c6 --- /dev/null +++ b/tests/components/test_webhook_components.py @@ -0,0 +1,82 @@ +import pytest + +from discord_webhook import ( + DiscordComponentActionRow, + DiscordComponentButton, + DiscordWebhook, + constants, +) +from discord_webhook.webhook_exceptions import ComponentException + + +def _action_row(): + return DiscordComponentActionRow( + components=[ + DiscordComponentButton( + style=constants.DISCORD_COMPONENT_BUTTON_STYLE_LINK, + label="GitHub", + url="https://github.com/lovvskillz/python-discord-webhook", + ) + ] + ) + + +def test__webhook__add_component_row(): + webhook = DiscordWebhook(url="webhook_url", content="test") + webhook.add_component_row(_action_row()) + + assert webhook.json["components"] == [ + { + "type": constants.DISCORD_COMPONENT_TYPE_ACTION_ROW, + "components": [ + { + "type": constants.DISCORD_COMPONENT_TYPE_BUTTON, + "style": constants.DISCORD_COMPONENT_BUTTON_STYLE_LINK, + "label": "GitHub", + "url": "https://github.com/lovvskillz/python-discord-webhook", + "disabled": False, + } + ], + } + ] + + +def test__webhook__components_kwarg(): + webhook = DiscordWebhook( + url="webhook_url", content="test", components=[_action_row()] + ) + + assert len(webhook.get_component_rows()) == 1 + + +def test__webhook__components_are_not_shared_between_instances(): + webhook_1 = DiscordWebhook(url="webhook_url", content="test") + webhook_1.add_component_row(_action_row()) + webhook_2 = DiscordWebhook(url="webhook_url", content="test") + + assert webhook_2.get_component_rows() == [] + + +def test__webhook__remove_component_rows(): + webhook = DiscordWebhook(url="webhook_url", content="test") + webhook.add_component_row(_action_row()) + webhook.add_component_row(_action_row()) + + webhook.remove_component_row(0) + assert len(webhook.get_component_rows()) == 1 + + webhook.remove_component_rows() + assert webhook.get_component_rows() == [] + assert "components" not in webhook.json + + +def test__webhook__max_action_rows(): + webhook = DiscordWebhook(url="webhook_url", content="test") + for _ in range(constants.DISCORD_MAX_ACTION_ROWS): + webhook.add_component_row(_action_row()) + + with pytest.raises(ComponentException) as excinfo: + webhook.add_component_row(_action_row()) + + assert str(excinfo.value) == "A message can contain up to 5 action rows." + assert len(webhook.get_component_rows()) == constants.DISCORD_MAX_ACTION_ROWS From fbf9c777ddd5c286fa4ba4cea785d1b07f889263 Mon Sep 17 00:00:00 2001 From: lovvskillz <14542790+lovvskillz@users.noreply.github.com> Date: Sun, 16 Aug 2026 15:48:51 +0200 Subject: [PATCH 2/8] add support for polls --- CHANGES.md | 1 + README.md | 42 +++++++ discord_webhook/__init__.py | 4 + discord_webhook/constants.py | 17 +++ discord_webhook/poll.py | 165 ++++++++++++++++++++++++++ discord_webhook/webhook.py | 26 +++- discord_webhook/webhook_exceptions.py | 8 ++ examples/poll.py | 28 +++++ tests/test_poll.py | 136 +++++++++++++++++++++ 9 files changed, 426 insertions(+), 1 deletion(-) create mode 100644 discord_webhook/poll.py create mode 100644 examples/poll.py create mode 100644 tests/test_poll.py diff --git a/CHANGES.md b/CHANGES.md index fc158bc..4dd0ccd 100644 --- a/CHANGES.md +++ b/CHANGES.md @@ -4,6 +4,7 @@ ### 🎉 Features - add support for message components (action rows, buttons, select menus, text inputs) +- add support for polls ## 2025-03-04 1.4.1 diff --git a/README.md b/README.md index 5dfecec..40bd3af 100644 --- a/README.md +++ b/README.md @@ -293,6 +293,48 @@ webhook.remove_file("example.jpg") response = webhook.execute() ``` +### Send a Poll + +A poll can contain up to 10 answers and is open for 24 hours by default. +The `duration` is set in hours and can be up to 768 (32 days). + +```python +from discord_webhook import ( + DiscordComponentEmoji, + DiscordPoll, + DiscordPollAnswer, + DiscordWebhook, +) + +# a simple poll with two answers +poll = DiscordPoll(question="Your favourite color?", answers=["Red", "Blue"]) + +webhook = DiscordWebhook(url="your webhook url", poll=poll) +response = webhook.execute() +``` + +Answers can also use emojis and be added afterwards: + +```python +poll = DiscordPoll( + question="Which languages do you use?", + answers=[ + DiscordPollAnswer(text="Python", emoji=DiscordComponentEmoji(name="🐍")), + DiscordPollAnswer(text="Rust", emoji=DiscordComponentEmoji(name="🦀")), + ], + allow_multiselect=True, + duration=72, +) +poll.add_answer("Something else") + +webhook = DiscordWebhook(url="your webhook url") +webhook.set_poll(poll) +response = webhook.execute() +``` + +Use `webhook.remove_poll()` to remove an already set poll and +`poll.get_answers()` / `poll.remove_answer(index)` to manage the answers. + ### Add Components Components like buttons and select menus are always wrapped in an action row. diff --git a/discord_webhook/__init__.py b/discord_webhook/__init__.py index 531fa36..9d37011 100644 --- a/discord_webhook/__init__.py +++ b/discord_webhook/__init__.py @@ -10,6 +10,9 @@ "DiscordComponentTextInput", "DiscordComponentUserSelect", "DiscordEmbed", + "DiscordPoll", + "DiscordPollAnswer", + "DiscordPollMedia", "DiscordSelectOption", "DiscordWebhook", ] @@ -27,5 +30,6 @@ DiscordComponentUserSelect, DiscordSelectOption, ) +from .poll import DiscordPoll, DiscordPollAnswer, DiscordPollMedia # isort:skip from .webhook import DiscordEmbed, DiscordWebhook # isort:skip from .async_webhook import AsyncDiscordWebhook # isort:skip diff --git a/discord_webhook/constants.py b/discord_webhook/constants.py index da823c6..9dd74bc 100644 --- a/discord_webhook/constants.py +++ b/discord_webhook/constants.py @@ -93,3 +93,20 @@ class MessageFlags(Enum): DISCORD_MAX_BUTTONS_PER_ACTION_ROW = 5 # maximum amount of options a select menu can contain DISCORD_MAX_SELECT_OPTIONS = 25 + +DISCORD_POLL_LAYOUT_TYPE_DEFAULT = 1 + +DISCORD_POLL_LAYOUT_TYPES = [ + DISCORD_POLL_LAYOUT_TYPE_DEFAULT, +] + +# maximum amount of answers a poll can contain +DISCORD_POLL_MAX_ANSWERS = 10 +# maximum amount of characters of a poll question +DISCORD_POLL_MAX_QUESTION_LENGTH = 300 +# maximum amount of characters of a poll answer +DISCORD_POLL_MAX_ANSWER_LENGTH = 55 +# hours a poll is open for if no duration is provided +DISCORD_POLL_DEFAULT_DURATION = 24 +# maximum amount of hours a poll can be open for (32 days) +DISCORD_POLL_MAX_DURATION = 768 diff --git a/discord_webhook/poll.py b/discord_webhook/poll.py new file mode 100644 index 0000000..0a8401f --- /dev/null +++ b/discord_webhook/poll.py @@ -0,0 +1,165 @@ +from typing import Any, Dict, List, Optional, Union + +from . import constants +from .components import DiscordComponentEmoji +from .utils import check_max_length, is_int, to_dict +from .webhook_exceptions import PollException + + +class DiscordPollMedia: + """ + Represent the common object that is used by the question and the answers of a poll. + """ + + emoji: Optional[Union[dict, DiscordComponentEmoji]] + text: Optional[str] + + def __init__( + self, + text: Optional[str] = None, + emoji: Optional[Union[dict, DiscordComponentEmoji]] = None, + max_text_length: int = constants.DISCORD_POLL_MAX_QUESTION_LENGTH, + ) -> None: + """ + :param str text: text of the media object + :param emoji: emoji of the media object + :param int max_text_length: maximum amount of characters of the text + """ + if text is None and emoji is None: + raise PollException("Either text or emoji needs to be provided.") + + self.text = text + self.emoji = emoji + + check_max_length(self.text, max_text_length, "text", PollException) + + def to_dict(self) -> Dict[str, Any]: + """ + Convert the media object to a dict. + :return: media object as dict + """ + return { + key: to_dict(value) + for key, value in self.__dict__.items() + if value is not None + } + + +class DiscordPollAnswer(DiscordPollMedia): + """ + Represent an answer of a poll. + """ + + def __init__( + self, + text: Optional[str] = None, + emoji: Optional[Union[dict, DiscordComponentEmoji]] = None, + ) -> None: + """ + :param str text: text of the answer + :param emoji: emoji of the answer + """ + super().__init__( + text=text, + emoji=emoji, + max_text_length=constants.DISCORD_POLL_MAX_ANSWER_LENGTH, + ) + + def to_dict(self) -> Dict[str, Any]: + """ + Convert the answer to a dict. + :return: answer as dict + """ + return {"poll_media": super().to_dict()} + + +class DiscordPoll: + """ + Represent a poll object for the use in webhooks. + """ + + allow_multiselect: bool + answers: List[Union[dict, DiscordPollAnswer]] + duration: int + layout_type: int + question: Union[dict, DiscordPollMedia, str] + + def __init__( + self, + question: Union[dict, DiscordPollMedia, str], + answers: Optional[List[Union[dict, DiscordPollAnswer, str]]] = None, + **kwargs, + ) -> None: + """ + :param question: question of the poll (only text is supported by Discord) + :param list answers: answers of the poll (up to 10) + :keyword bool allow_multiselect: whether multiple answers can be selected + :keyword int duration: hours the poll is open for (1 - 768, defaults to 24) + :keyword int layout_type: layout of the poll (defaults to 1) + """ + self.question = ( + DiscordPollMedia(text=question) if isinstance(question, str) else question + ) + self.answers = [] + self.allow_multiselect = kwargs.get("allow_multiselect", False) + self.duration = kwargs.get("duration", constants.DISCORD_POLL_DEFAULT_DURATION) + self.layout_type = kwargs.get( + "layout_type", constants.DISCORD_POLL_LAYOUT_TYPE_DEFAULT + ) + + if ( + not is_int(self.duration) + or not 1 <= self.duration <= constants.DISCORD_POLL_MAX_DURATION + ): + raise PollException( + "duration needs to be an integer between 1 and" + f" {constants.DISCORD_POLL_MAX_DURATION}." + ) + if self.layout_type not in constants.DISCORD_POLL_LAYOUT_TYPES: + raise PollException("The provided layout type is invalid.") + + for answer in answers or []: + self.add_answer(answer) + + def add_answer(self, answer: Union[dict, DiscordPollAnswer, str]) -> None: + """ + Add an answer to the poll. + :param answer: answer instance, dict or the text of the answer + """ + if len(self.answers) >= constants.DISCORD_POLL_MAX_ANSWERS: + raise PollException( + f"A poll can contain up to {constants.DISCORD_POLL_MAX_ANSWERS} answers." + ) + self.answers.append( + DiscordPollAnswer(text=answer) if isinstance(answer, str) else answer + ) + + def remove_answer(self, index: int) -> None: + """ + Remove an answer from the already added answers. + :param int index: index of the answer + """ + self.answers.pop(index) + + def get_answers(self) -> List[Union[dict, DiscordPollAnswer]]: + """ + Get all answers of the poll as a list. + :return: answers of the poll + """ + return self.answers + + def to_dict(self) -> Dict[str, Any]: + """ + Convert the poll to a dict. + :return: poll as dict + """ + if not self.answers: + raise PollException("A poll needs at least one answer.") + + return { + "question": to_dict(self.question), + "answers": to_dict(self.answers), + "allow_multiselect": self.allow_multiselect, + "duration": self.duration, + "layout_type": self.layout_type, + } diff --git a/discord_webhook/webhook.py b/discord_webhook/webhook.py index 8597136..a70c825 100644 --- a/discord_webhook/webhook.py +++ b/discord_webhook/webhook.py @@ -9,6 +9,7 @@ from . import constants from .components import DiscordComponentActionRow +from .poll import DiscordPoll from .webhook_exceptions import ColorNotInRangeException, ComponentException logger = logging.getLogger(__name__) @@ -240,6 +241,7 @@ class DiscordWebhook: thread_name: Optional[str] timeout: Optional[float] tts: Optional[bool] + poll: Optional[dict] url: str username: Optional[str] wait: Optional[bool] @@ -258,6 +260,7 @@ def __init__(self, url: str, **kwargs) -> None: :keyword int flags: apply flags to the message :keyword dict files: to apply file(s) with message :keyword str id: webhook id + :keyword poll: poll that should be sent with the message :keyword dict proxies: proxies that should be used :keyword bool rate_limit_retry: whether the message should be sent again when being rate limited :keyword str thread_id: send message to a thread specified by its thread id @@ -276,6 +279,7 @@ def __init__(self, url: str, **kwargs) -> None: self.flags = kwargs.get("flags") self.files = kwargs.get("files", {}) self.id = kwargs.get("id") + self.poll = None self.proxies = kwargs.get("proxies") self.rate_limit_retry = kwargs.get("rate_limit_retry", False) self.thread_id = kwargs.get("thread_id") @@ -287,6 +291,21 @@ def __init__(self, url: str, **kwargs) -> None: self.wait = kwargs.get("wait", True) for action_row in kwargs.get("components", []): self.add_component_row(action_row) + if poll := kwargs.get("poll"): + self.set_poll(poll) + + def set_poll(self, poll: Union[DiscordPoll, Dict[str, Any]]) -> None: + """ + Set the poll of the webhook. + :param poll: poll instance or dict + """ + self.poll = poll.to_dict() if isinstance(poll, DiscordPoll) else poll + + def remove_poll(self) -> None: + """ + Remove the poll of the webhook. + """ + self.poll = None def add_component_row( self, action_row: Union[DiscordComponentActionRow, Dict[str, Any]] @@ -432,7 +451,12 @@ def json(self) -> Dict[str, Any]: if value and key not in ["url", "files"] or key in ["embeds", "attachments"] } embeds_empty = not any(data["embeds"]) if "embeds" in data else True - if embeds_empty and "content" not in data and bool(self.files) is False: + if ( + embeds_empty + and "content" not in data + and bool(self.files) is False + and not self.poll + ): logger.error("webhook message is empty! set content or embed data") return data diff --git a/discord_webhook/webhook_exceptions.py b/discord_webhook/webhook_exceptions.py index b1c3036..5bea713 100644 --- a/discord_webhook/webhook_exceptions.py +++ b/discord_webhook/webhook_exceptions.py @@ -24,3 +24,11 @@ class ComponentException(Exception): """ pass + + +class PollException(Exception): + """ + This Exception will be raised for polls. + """ + + pass diff --git a/examples/poll.py b/examples/poll.py new file mode 100644 index 0000000..23ace39 --- /dev/null +++ b/examples/poll.py @@ -0,0 +1,28 @@ +from discord_webhook import ( + DiscordComponentEmoji, + DiscordPoll, + DiscordPollAnswer, + DiscordWebhook, +) + +# a simple poll with two answers that is open for 24 hours +poll = DiscordPoll(question="Your favourite color?", answers=["Red", "Blue"]) + +webhook = DiscordWebhook(url="your webhook url", poll=poll) +response = webhook.execute() + +# a poll with emojis, multiple answers and a custom duration +poll = DiscordPoll( + question="Which languages do you use?", + answers=[ + DiscordPollAnswer(text="Python", emoji=DiscordComponentEmoji(name="🐍")), + DiscordPollAnswer(text="Rust", emoji=DiscordComponentEmoji(name="🦀")), + ], + allow_multiselect=True, + duration=72, +) +poll.add_answer("Something else") + +webhook = DiscordWebhook(url="your webhook url", content="Please vote!") +webhook.set_poll(poll) +response = webhook.execute() diff --git a/tests/test_poll.py b/tests/test_poll.py new file mode 100644 index 0000000..695e4ab --- /dev/null +++ b/tests/test_poll.py @@ -0,0 +1,136 @@ +import pytest +from pytest import mark + +from discord_webhook import ( + DiscordComponentEmoji, + DiscordPoll, + DiscordPollAnswer, + DiscordPollMedia, + DiscordWebhook, + constants, +) +from discord_webhook.webhook_exceptions import PollException + + +def test__poll__defaults(): + poll = DiscordPoll(question="Your favourite color?", answers=["Red", "Blue"]) + + assert poll.to_dict() == { + "question": {"text": "Your favourite color?"}, + "answers": [ + {"poll_media": {"text": "Red"}}, + {"poll_media": {"text": "Blue"}}, + ], + "allow_multiselect": False, + "duration": constants.DISCORD_POLL_DEFAULT_DURATION, + "layout_type": constants.DISCORD_POLL_LAYOUT_TYPE_DEFAULT, + } + + +def test__poll__custom_values(): + poll = DiscordPoll( + question=DiscordPollMedia(text="Your favourite color?"), + allow_multiselect=True, + duration=48, + ) + poll.add_answer( + DiscordPollAnswer(text="Red", emoji=DiscordComponentEmoji(name="🔴")) + ) + poll.add_answer({"poll_media": {"text": "Blue"}}) + + assert poll.to_dict() == { + "question": {"text": "Your favourite color?"}, + "answers": [ + {"poll_media": {"text": "Red", "emoji": {"name": "🔴", "animated": False}}}, + {"poll_media": {"text": "Blue"}}, + ], + "allow_multiselect": True, + "duration": 48, + "layout_type": constants.DISCORD_POLL_LAYOUT_TYPE_DEFAULT, + } + + +def test__poll__answer_without_text_and_emoji(): + with pytest.raises(PollException) as excinfo: + DiscordPollAnswer() + + assert str(excinfo.value) == "Either text or emoji needs to be provided." + + +def test__poll__max_answers(): + poll = DiscordPoll( + question="test", + answers=[str(index) for index in range(constants.DISCORD_POLL_MAX_ANSWERS)], + ) + + with pytest.raises(PollException) as excinfo: + poll.add_answer("one too many") + + assert str(excinfo.value) == "A poll can contain up to 10 answers." + assert len(poll.get_answers()) == constants.DISCORD_POLL_MAX_ANSWERS + + +def test__poll__remove_answer(): + poll = DiscordPoll(question="test", answers=["Red", "Blue"]) + poll.remove_answer(0) + + assert poll.to_dict()["answers"] == [{"poll_media": {"text": "Blue"}}] + + +def test__poll__without_answers(): + poll = DiscordPoll(question="test") + + with pytest.raises(PollException) as excinfo: + poll.to_dict() + + assert str(excinfo.value) == "A poll needs at least one answer." + + +@mark.parametrize("invalid_duration", [0, 769, "a", True, None]) +def test__poll__invalid_duration(invalid_duration): + with pytest.raises(PollException) as excinfo: + DiscordPoll(question="test", duration=invalid_duration) + + assert str(excinfo.value) == "duration needs to be an integer between 1 and 768." + + +def test__poll__invalid_layout_type(): + with pytest.raises(PollException) as excinfo: + DiscordPoll(question="test", layout_type=2) + + assert str(excinfo.value) == "The provided layout type is invalid." + + +@mark.parametrize( + "poll_media_class, max_length", + [ + (DiscordPollMedia, constants.DISCORD_POLL_MAX_QUESTION_LENGTH), + (DiscordPollAnswer, constants.DISCORD_POLL_MAX_ANSWER_LENGTH), + ], +) +def test__poll__max_text_length(poll_media_class, max_length): + poll_media_class(text="a" * max_length) + + with pytest.raises(PollException) as excinfo: + poll_media_class(text="a" * (max_length + 1)) + + assert str(excinfo.value) == f"text can be a maximum of {max_length} characters." + + +def test__webhook__poll(): + webhook = DiscordWebhook( + url="webhook_url", + poll=DiscordPoll(question="Your favourite color?", answers=["Red", "Blue"]), + ) + + assert webhook.json["poll"]["question"] == {"text": "Your favourite color?"} + + webhook.remove_poll() + assert "poll" not in webhook.json + + +def test__webhook__set_poll(): + webhook = DiscordWebhook(url="webhook_url") + webhook.set_poll({"question": {"text": "test"}}) + + assert webhook.json["poll"] == {"question": {"text": "test"}} From 9a5c96d55567547a4c0101d1b468e62df67f860b Mon Sep 17 00:00:00 2001 From: lovvskillz <14542790+lovvskillz@users.noreply.github.com> Date: Sun, 16 Aug 2026 16:00:12 +0200 Subject: [PATCH 3/8] switch from poetry to uv --- .github/workflows/python-package.yml | 19 +- .gitignore | 3 - README.md | 14 +- pyproject.toml | 44 +- uv.lock | 631 +++++++++++++++++++++++++++ 5 files changed, 671 insertions(+), 40 deletions(-) create mode 100644 uv.lock diff --git a/.github/workflows/python-package.yml b/.github/workflows/python-package.yml index adfff56..ad92936 100644 --- a/.github/workflows/python-package.yml +++ b/.github/workflows/python-package.yml @@ -18,17 +18,14 @@ jobs: python-version: ["3.10", "3.11"] steps: - - uses: actions/checkout@v3 - - name: Set up Python ${{ matrix.python-version }} - uses: actions/setup-python@v3 - with: - python-version: ${{ matrix.python-version }} - - name: Run image - uses: abatilo/actions-poetry@v2.0.0 + - uses: actions/checkout@v4 + - name: Install uv + uses: astral-sh/setup-uv@v5 with: - poetry-version: '1.2.0' + enable-cache: true + - name: Set up Python ${{ matrix.python-version }} + run: uv python install ${{ matrix.python-version }} - name: Install Dependencies - run: poetry install + run: uv sync --all-extras --dev - name: Run Tests - run: | - poetry run pytest + run: uv run pytest diff --git a/.gitignore b/.gitignore index 59a7136..a34c3ae 100644 --- a/.gitignore +++ b/.gitignore @@ -106,6 +106,3 @@ venv.bak/ # PyCharm .idea .vscode/ - -# Poetry -poetry.lock \ No newline at end of file diff --git a/README.md b/README.md index 40bd3af..34e8913 100644 --- a/README.md +++ b/README.md @@ -563,20 +563,20 @@ optional arguments: ## Development ### Dev Setup -This project uses [Poetry](https://python-poetry.org/docs/) for dependency management and packaging. +This project uses [uv](https://docs.astral.sh/uv/) for dependency management and packaging. -Install Poetry and add Poetry to [Path](https://python-poetry.org/docs/#installation). +Install uv: **Debian / Ubuntu / Mac** -`curl -sSL https://install.python-poetry.org | python3 -` +`curl -LsSf https://astral.sh/uv/install.sh | sh` **Windows** -open powershell and run: `(Invoke-WebRequest -Uri https://install.python-poetry.org -UseBasicParsing).Content | py -` +open powershell and run: `powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"` -Install dependencies: `poetry install` +Install dependencies: `uv sync --all-extras --dev` -Install the defined pre-commit hooks: `poetry run pre-commit install` +Install the defined pre-commit hooks: `uv run pre-commit install` -Activate the virtualenv: `poetry shell` \ No newline at end of file +Run a command in the virtualenv: `uv run pytest` \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml index 333939b..9fb7e78 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,36 +1,42 @@ -[tool.poetry] +[project] name = "discord-webhook" version = "1.4.1" description = "Easily send Discord webhooks with Python" -authors = ["lovvskillz <14542790+lovvskillz@users.noreply.github.com>"] +authors = [ + { name = "lovvskillz", email = "14542790+lovvskillz@users.noreply.github.com" }, +] license = "MIT" readme = "README.md" -packages = [{include = "discord_webhook"}] -repository = "https://github.com/lovvskillz/python-discord-webhook" +requires-python = ">=3.10" keywords = ["discord", "webhook"] +dependencies = [ + "requests>=2.32.3,<3", +] +[project.optional-dependencies] +async = ["httpx>=0.28.1,<1"] -[tool.poetry.dependencies] -python = "^3.10" -requests = "^2.32.3" -httpx = { version = "^0.28.1", optional = true } +[project.urls] +Repository = "https://github.com/lovvskillz/python-discord-webhook" -[tool.poetry.extras] -async = ["httpx"] +[project.scripts] +discord_webhook = "discord_webhook.__main__:main" -[tool.poetry.group.dev.dependencies] -pre-commit = "^3.3.3" -types-requests = "^2.28.11.4" -pytest = "^7.4.0" -ruff = "^0.1.15" +[dependency-groups] +dev = [ + "pre-commit>=3.3.3", + "types-requests>=2.28.11.4", + "pytest>=7.4.0", + "ruff>=0.1.15,<0.2", +] -[tool.poetry.scripts] -discord_webhook = "discord_webhook.__main__:main" +[tool.hatch.build.targets.wheel] +packages = ["discord_webhook"] [tool.ruff] line-length = 88 ignore = ["E501"] [build-system] -requires = ["poetry-core"] -build-backend = "poetry.core.masonry.api" +requires = ["hatchling"] +build-backend = "hatchling.build" diff --git a/uv.lock b/uv.lock new file mode 100644 index 0000000..474e83d --- /dev/null +++ b/uv.lock @@ -0,0 +1,631 @@ +version = 1 +revision = 3 +requires-python = ">=3.10" + +[[package]] +name = "anyio" +version = "4.14.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "exceptiongroup", marker = "python_full_version < '3.11'" }, + { name = "idna" }, + { name = "typing-extensions", marker = "python_full_version < '3.13'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/61/cc/a381afa6efea9f496eff839d4a6a1aed3bfafc7b3ab4b0d1b243a12573dd/anyio-4.14.2.tar.gz", hash = "sha256:cfa139f3ed1a23ee8f88a145ddb5ac7605b8bbfd8592baacd7ce3d8bb4313c7f", size = 260176, upload-time = "2026-07-12T20:29:07.082Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/da/35/f2287558c17e29fafc8ef3daf819bb9834061cfa43bff8014f7df7f63bdc/anyio-4.14.2-py3-none-any.whl", hash = "sha256:9f505dda5ac9f0c8309b5e8bd445a8c2bf7246f3ce950121e45ea15bc41d1494", size = 125813, upload-time = "2026-07-12T20:29:05.763Z" }, +] + +[[package]] +name = "certifi" +version = "2026.7.22" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a3/c2/24167ea9858356b47a87a50d39908bfdb72ceeefe0041586e704e5376b3a/certifi-2026.7.22.tar.gz", hash = "sha256:741e2c3b351ddf169a738da9f2c048608ff7f2c5cc02f1ebc6b118bb090d5d55", size = 138112, upload-time = "2026-07-22T03:35:12.644Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0b/a7/71ac2cff56fec219ed242bb11b8efb69fcc4bec75db06fb7bfe35de520e6/certifi-2026.7.22-py3-none-any.whl", hash = "sha256:62f22742b58a1a33014a2b6b706588a8d7e2a88ae7bd1a6ebe8c992928483775", size = 136983, upload-time = "2026-07-22T03:35:11.276Z" }, +] + +[[package]] +name = "cfgv" +version = "3.5.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/4e/b5/721b8799b04bf9afe054a3899c6cf4e880fcf8563cc71c15610242490a0c/cfgv-3.5.0.tar.gz", hash = "sha256:d5b1034354820651caa73ede66a6294d6e95c1b00acc5e9b098e917404669132", size = 7334, upload-time = "2025-11-19T20:55:51.612Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/db/3c/33bac158f8ab7f89b2e59426d5fe2e4f63f7ed25df84c036890172b412b5/cfgv-3.5.0-py2.py3-none-any.whl", hash = "sha256:a8dc6b26ad22ff227d2634a65cb388215ce6cc96bbcc5cfde7641ae87e8dacc0", size = 7445, upload-time = "2025-11-19T20:55:50.744Z" }, +] + +[[package]] +name = "charset-normalizer" +version = "3.5.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e5/3f/143b048436775b0f76ac3eec145c019e8173ccc2885c8f20319b996d5e83/charset_normalizer-3.5.1.tar.gz", hash = "sha256:6117b84ea48435e5356dc737f5121485c30920ba43375fa7b434fd753df0eac3", size = 171764, upload-time = "2026-08-15T08:20:44.807Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/71/aa/554e2614f38fc34c58ff1d0911ae8535ad2516440d5482d76fe59f1088b0/charset_normalizer-3.5.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:d1ee1e296209fdce05b81b663250eefa02213a2da7b41bf26f7829b8ba3545aa", size = 369072, upload-time = "2026-08-15T08:16:22.964Z" }, + { url = "https://files.pythonhosted.org/packages/03/6d/439231dfc3ccfa6f8c06477b7da2219cbd41a2de3d49084df8ec7b5100f2/charset_normalizer-3.5.1-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e9fbdce1e47394b09bc9f26ab117dfc8d6491977a11d86f592bb42c779db2fda", size = 251142, upload-time = "2026-08-15T08:16:24.81Z" }, + { url = "https://files.pythonhosted.org/packages/55/53/7d819bd23a00ef45039146fa2cce1daa2f0771e758c5653ee1f6edac91ed/charset_normalizer-3.5.1-cp310-cp310-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:00668ebb0609751758682eb0b5857e7c35b9f00e84dfdef062e103244ec94d45", size = 240714, upload-time = "2026-08-15T08:16:26.392Z" }, + { url = "https://files.pythonhosted.org/packages/b2/2c/45847198c16f4b38090cc7423b2b6a9008e438704d8ab413211832498d31/charset_normalizer-3.5.1-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ba2f37ee79e6338845261a3c5b1784e5d1acdff2c0785b284f1b633033d136ab", size = 279637, upload-time = "2026-08-15T08:16:27.961Z" }, + { url = "https://files.pythonhosted.org/packages/69/2b/d8be3523ddf9f0b0f3e56d1359034aa10653a4d11564c697f802b4775766/charset_normalizer-3.5.1-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:ce854f5f478050ade5a238731c4ca985a7d3b3cb53ff600a9b5c3b689b5f0a7a", size = 276543, upload-time = "2026-08-15T08:16:29.399Z" }, + { url = "https://files.pythonhosted.org/packages/32/cd/4f564b8f132de25db594efc706897069f016790cea63a5669c9df2675f64/charset_normalizer-3.5.1-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:96eefc178f8636b9c760c5829345307fd81cfae9ab1e80997dbddeb0f54ee9a3", size = 261644, upload-time = "2026-08-15T08:16:30.722Z" }, + { url = "https://files.pythonhosted.org/packages/f5/e3/38b975422534a608f98c360e79c2f07c763d66dd4272300d45fb1fee54b0/charset_normalizer-3.5.1-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:366ec70f5547c640d3ce1985722490f23faf4eb5216a7eeba78277490e78dacb", size = 259609, upload-time = "2026-08-15T08:16:32.248Z" }, + { url = "https://files.pythonhosted.org/packages/87/bd/fbc24d825c66f1c74f6ccdea3742c3d8354a4888e86d1315a197fee69061/charset_normalizer-3.5.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:950f23cb393f85543777b0433f082cddd25b51ab398eac7971146495679efe5f", size = 252457, upload-time = "2026-08-15T08:16:33.849Z" }, + { url = "https://files.pythonhosted.org/packages/b9/2d/918d0e98a0e679469ed05bb2d90c2088b4d315bb612969d8499f76fb5210/charset_normalizer-3.5.1-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:c1dcc36dcb96abc02236e182d17e0f71430152a6c2c7447421da2d2dc144edea", size = 242240, upload-time = "2026-08-15T08:16:35.396Z" }, + { url = "https://files.pythonhosted.org/packages/20/c8/c36f6e0b2dfec351bd38cbc05362697e58bcd073d7dbd95154290c9714ce/charset_normalizer-3.5.1-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:07ffd07412fc5d5e84cd8952acf9ff7e4ed7a708e69d1bada19d8ba91711353f", size = 280308, upload-time = "2026-08-15T08:16:36.825Z" }, + { url = "https://files.pythonhosted.org/packages/ca/7b/311b3e02e8c4092400c449c850a760d8c45d900983c83a70cc07208c551d/charset_normalizer-3.5.1-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:f5542f9b941279d82d41eb0aa9f98eba36fe4df5c7086c651df7944935b37182", size = 258679, upload-time = "2026-08-15T08:16:38.22Z" }, + { url = "https://files.pythonhosted.org/packages/b9/90/082cc45599c392f28c036a497f49e0634041a785fc3849c80ccf396d096f/charset_normalizer-3.5.1-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:a545775cfe815855ea32d7c27731d79da358ef2055b4a25830231b1622dd18aa", size = 277221, upload-time = "2026-08-15T08:16:39.62Z" }, + { url = "https://files.pythonhosted.org/packages/58/ad/b9aecf38d805cbcf84fa94f14c5d972a16561e20296a11dc799a5dcf3763/charset_normalizer-3.5.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:494b70049a4d69aec6e8137c13af4cf8db8c9f9820a1392ac293b0dd2987a818", size = 263799, upload-time = "2026-08-15T08:16:40.885Z" }, + { url = "https://files.pythonhosted.org/packages/b7/23/b38a20598d5a825f85d9d7636860e56ff0db1479f86497a6e485aa9326f7/charset_normalizer-3.5.1-cp310-cp310-win32.whl", hash = "sha256:94fbf1c0c6cc0d3d5e50f9a9313a8cdca90dd696d34b381cd1704f8c9e939f20", size = 182037, upload-time = "2026-08-15T08:16:42.198Z" }, + { url = "https://files.pythonhosted.org/packages/d2/21/83fffb77864408b8bf0fe1ca603926401d6f8775a8e150b39aacc9958f8a/charset_normalizer-3.5.1-cp310-cp310-win_amd64.whl", hash = "sha256:be47f99644b208bff7766314013f9acf57b056b04191d570d68ad14022cf5b1d", size = 206030, upload-time = "2026-08-15T08:16:43.787Z" }, + { url = "https://files.pythonhosted.org/packages/86/2e/b93135b5034b1157fb29554b0d06d4844ce62282f0e0a14036f93d7ee2e7/charset_normalizer-3.5.1-cp310-cp310-win_arm64.whl", hash = "sha256:a6d095662e73e74f0a49988e0593373e243e3a52e27bfeea0a859e88acf4a0f5", size = 185092, upload-time = "2026-08-15T08:16:45.177Z" }, + { url = "https://files.pythonhosted.org/packages/6a/b6/034f6802e9c3f6418966cfabb7db8c9252cc2429c5098f41cc43af804149/charset_normalizer-3.5.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:eda059b6bc8bc0812d626fd91a7ce01bf583df0a61296eff390fd94141a34e30", size = 363585, upload-time = "2026-08-15T08:16:46.646Z" }, + { url = "https://files.pythonhosted.org/packages/d5/fa/6a7e2a7c4b5451912b8c417732df79574354443592a88d616de03da66ae5/charset_normalizer-3.5.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:aa2bb0b37202dca27175591f761108b5d34096ade1191ffe4808bdf6b1571488", size = 251189, upload-time = "2026-08-15T08:16:48.287Z" }, + { url = "https://files.pythonhosted.org/packages/a4/c8/ab42b07cfd82e919f427fcfaa7c41abae8242833ad1aad66d42bae40b669/charset_normalizer-3.5.1-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:0b2b1b3fa5670c127b246df1d0c059defd41f689a868a3b9d79df9b1cac42d22", size = 239724, upload-time = "2026-08-15T08:16:49.67Z" }, + { url = "https://files.pythonhosted.org/packages/e7/80/b9348b5d3041209f98b4cdad7655766369233f1d533f4f4f7558e9717bec/charset_normalizer-3.5.1-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6e5e4d73d588ca5ed09df1b7dcd1b203d1df3c542e3f50d126c947d432b10731", size = 280078, upload-time = "2026-08-15T08:16:51.228Z" }, + { url = "https://files.pythonhosted.org/packages/82/38/083a24028304bc85bb9e376fed801178423dcbb67495f73b6ea0624e1894/charset_normalizer-3.5.1-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b54e7e13267d49ffbfe68e25b3cbd774dab38fa37238f71265e91b36146eb21c", size = 276650, upload-time = "2026-08-15T08:16:52.625Z" }, + { url = "https://files.pythonhosted.org/packages/0d/35/731ac04aa0a097fc1c97f0994c375bdb230c6c96619db794208fe664e9ce/charset_normalizer-3.5.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c7b742bf31c88566b4bb6335a7f393bb322e580b6bb98df7bd0c25e6e3519ce8", size = 262325, upload-time = "2026-08-15T08:16:54.085Z" }, + { url = "https://files.pythonhosted.org/packages/f5/28/c2028e7021fb89c6e56868ed0e387b8e9aa811abdd2ab3208d6578d2c930/charset_normalizer-3.5.1-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:6ba32c4d2abf1d2fe7cf27d280f4cca5664233b0f885549c7761719eb977f486", size = 261140, upload-time = "2026-08-15T08:16:55.604Z" }, + { url = "https://files.pythonhosted.org/packages/28/f0/0c0ceec6d98b7daa62e361e418135d59685811d79ba11529aad5cdf15e84/charset_normalizer-3.5.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:0722590aabf9dc6a6c0343d523c05458fa2b5047dbe6302fd526bb570600753f", size = 252791, upload-time = "2026-08-15T08:16:57.103Z" }, + { url = "https://files.pythonhosted.org/packages/f0/3e/48f4cd187b1c33189d86039e9cbe4f92c05454175504b44ff81806d4d1bf/charset_normalizer-3.5.1-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:aa1099b956fb795e686d073568f6dc002a0bb89765ea6d5b055dd7d9bf1b116c", size = 240730, upload-time = "2026-08-15T08:16:58.418Z" }, + { url = "https://files.pythonhosted.org/packages/42/85/f9e22af69af67c54cce42be9455d9c81294f918b4ccc454db01f66efcac2/charset_normalizer-3.5.1-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:bd6c173f04743d483881bffa1478d5a4624475b8cd1d2194956a75548e191c18", size = 280791, upload-time = "2026-08-15T08:16:59.918Z" }, + { url = "https://files.pythonhosted.org/packages/fd/4c/9044135f42127630b6fa742feb51256353f6ab87a78f2fdd1de3de955a7f/charset_normalizer-3.5.1-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:f298e218441525d3794428b4c8b8fb8662c6d3ea79925d4807ee6b9a96a3bca5", size = 259598, upload-time = "2026-08-15T08:17:01.421Z" }, + { url = "https://files.pythonhosted.org/packages/ba/ed/1dd7cfebb4e75812934c49ca3b79757d11948053f7937ab7070c151f3c55/charset_normalizer-3.5.1-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:6e2912d4babbc65196ac13c2f53468dc57fb8b9c25ef913e8c59ddf7c6dc0e1b", size = 278217, upload-time = "2026-08-15T08:17:02.782Z" }, + { url = "https://files.pythonhosted.org/packages/bf/eb/239c84503cc9e3ba6eb34686a24bc66e84f3924efdd7e38e751a19f6bc10/charset_normalizer-3.5.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:3d27167433c0d5f18dc850f07d0b3816221984fecdc405d6c157a6f0b8f8e9e6", size = 263417, upload-time = "2026-08-15T08:17:04.216Z" }, + { url = "https://files.pythonhosted.org/packages/37/ab/4e4510e1e288478e2c8333131d1c1382382ba8cd2165053c79e39d1da961/charset_normalizer-3.5.1-cp311-cp311-win32.whl", hash = "sha256:ac00177c4831ffa650f8609e4bdddd5fe09c03b1c0c47acece7e6ea20421598b", size = 181774, upload-time = "2026-08-15T08:17:05.58Z" }, + { url = "https://files.pythonhosted.org/packages/e3/57/32f0ccea59e8612057c61d6fd22ef2cb63cca93c9fe594094919696ac170/charset_normalizer-3.5.1-cp311-cp311-win_amd64.whl", hash = "sha256:f9b1e28d0e8dbfa858abdba91d6b547beaf2df1a59bec6da6faae7b96a4991a9", size = 206653, upload-time = "2026-08-15T08:17:07.075Z" }, + { url = "https://files.pythonhosted.org/packages/17/d4/b65c433fc521e58b5f54293982a5e51c05cb5f2dd3f1c7a6acb65b75324e/charset_normalizer-3.5.1-cp311-cp311-win_arm64.whl", hash = "sha256:ae31a1a1db2ee6cc2942fccaf695c934bc7f3db9f2133a3fef1f367cf1a4ab10", size = 185630, upload-time = "2026-08-15T08:17:08.502Z" }, + { url = "https://files.pythonhosted.org/packages/30/27/78873dc8b6a56357517b74b6bb9568b80450e7bb4f6ef7e3fa9d22aa0bd7/charset_normalizer-3.5.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:5b6d1386bf0096d26d3a863dc0a487a5b4eb9aa93cf5ba69683d29dde6b9d60f", size = 344456, upload-time = "2026-08-15T08:17:10.072Z" }, + { url = "https://files.pythonhosted.org/packages/9a/4c/be49ada26b1f0232d57aa89bbebf997a5cc2332a5616b6eca26ff680044d/charset_normalizer-3.5.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4582c27e8c889d64811987b5967fbd3ae0c823fe1fd933b543d55ac20bb475fa", size = 238530, upload-time = "2026-08-15T08:17:11.563Z" }, + { url = "https://files.pythonhosted.org/packages/76/84/6f1290fa07ae6978d3960caa3eb1b8019bf9284ab7c2297b00c099ef4250/charset_normalizer-3.5.1-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:1d1c7a53a6c2103925cdd6d7229f8c567379f211c869793df679f2e9f738c369", size = 230200, upload-time = "2026-08-15T08:17:12.919Z" }, + { url = "https://files.pythonhosted.org/packages/e7/a0/47b18adeed31c8f16ba9700f32c1b18594cfa09f47eb672a488c273c22bf/charset_normalizer-3.5.1-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e6621fb2a4988d6e53eedc455e5903e2679f3967b8acb3d639f1b63c14a2e893", size = 262222, upload-time = "2026-08-15T08:17:14.571Z" }, + { url = "https://files.pythonhosted.org/packages/38/fe/341861ac118dae06f3ec0eb487488af52128f2ef2faf0b11003944d22259/charset_normalizer-3.5.1-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:7c0c10730342b0c9b35dd1d619beb8214e520bd96a1f870f452680b238aab3e0", size = 258951, upload-time = "2026-08-15T08:17:16.158Z" }, + { url = "https://files.pythonhosted.org/packages/6f/89/bb5108dc6c3651dca963f2b0a3ba19bbcb370c94e1b6d3e0e844a58e6dca/charset_normalizer-3.5.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b9af956078716df40d985fb0dfeb2c2120c5ca92ba4ff4b388acfd01cdc14d08", size = 248801, upload-time = "2026-08-15T08:17:17.683Z" }, + { url = "https://files.pythonhosted.org/packages/b1/ba/ef83ae3aca816393decfa3530976f38a79812d707b80b580ac33b83f9877/charset_normalizer-3.5.1-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f9f8405c2c758532c74fed975dbee57be1f31a6e865c031870c79a6ed3212ada", size = 244070, upload-time = "2026-08-15T08:17:19.191Z" }, + { url = "https://files.pythonhosted.org/packages/f6/0b/c5292a2462d69b7378ea89793bbb5b2b6fcf6f7dd6d1667f9619094ad553/charset_normalizer-3.5.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:96fef3e886d6a9874b14f27fc193fbdc69d5d8035783d86aa4e1cea594e695f9", size = 240110, upload-time = "2026-08-15T08:17:20.547Z" }, + { url = "https://files.pythonhosted.org/packages/46/22/111e5be3b740d5c2a5bfcedb3d237b6591e5c2e82ae9d6ffcb121fe0909c/charset_normalizer-3.5.1-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:5d8531a6569d025f68e2321e7638fb7978f23db58e5f69f56913837aae03816e", size = 232836, upload-time = "2026-08-15T08:17:21.895Z" }, + { url = "https://files.pythonhosted.org/packages/f9/d2/d2aad6fe0dbb44b194bf3becb60f5a0ac48446ade999a47fe7bb41eb09a7/charset_normalizer-3.5.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:aae2ee51122d3ae968a3837d97dc24a0aeebb0dea23694422cd172bd30017cd6", size = 262712, upload-time = "2026-08-15T08:17:23.727Z" }, + { url = "https://files.pythonhosted.org/packages/35/5a/337e4663a5eae6de99db940ee8066d4145caafb61327db62deda15313cce/charset_normalizer-3.5.1-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:7235dc28fc6dd9d832ac7c7bce95367dedb85929f17368a0c2bee1e080b9acbf", size = 242977, upload-time = "2026-08-15T08:17:25.157Z" }, + { url = "https://files.pythonhosted.org/packages/ca/85/f82f8a92e31c7519410e2e1afdc630f28ec47490ce2c09a11c1a43cbb459/charset_normalizer-3.5.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:4abdc5f9ad448c1ecbfae2974b820535d6bc6e7eef63babbab3d81cf46968c71", size = 260207, upload-time = "2026-08-15T08:17:26.602Z" }, + { url = "https://files.pythonhosted.org/packages/b7/52/643d11ffd60e9ac2fd1fb87e167a19285b9eefeff4a40e63c87cbfbeab36/charset_normalizer-3.5.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:ba501e667c17d8411f98e67a022d9604ef179aff0e459b7e292c796837c13573", size = 250562, upload-time = "2026-08-15T08:17:27.971Z" }, + { url = "https://files.pythonhosted.org/packages/62/16/46556278c2168d12df9da7fede5dc6fc70e60301b26a82bbeec238c9cfe3/charset_normalizer-3.5.1-cp312-cp312-win32.whl", hash = "sha256:cfa1c0cc3a8f9f53f1243a5a99ac36fd003880199383b37672e86ddda9cb07e2", size = 178507, upload-time = "2026-08-15T08:17:29.277Z" }, + { url = "https://files.pythonhosted.org/packages/9d/7a/4c6c298171e6b3e745633180ff59350fc0ca0db1ffd28df1e369e0579f71/charset_normalizer-3.5.1-cp312-cp312-win_amd64.whl", hash = "sha256:3617ac3cfd8b9888f145ad89dd6e692285834b0201c6074a5eeaad3fd4d668c2", size = 200551, upload-time = "2026-08-15T08:17:30.668Z" }, + { url = "https://files.pythonhosted.org/packages/cd/d7/eb95a042f0dd22e304b0b6472b154f3546a1a039a9ee89ccb2a7f61591fc/charset_normalizer-3.5.1-cp312-cp312-win_arm64.whl", hash = "sha256:88e85ab89cb822c1e635f51d6d32e488f94e002e70e2f492bdb8b945543f345a", size = 180700, upload-time = "2026-08-15T08:17:32.028Z" }, + { url = "https://files.pythonhosted.org/packages/bc/61/2cb6ad133dbbb449fa2d37ccae973232f4827e799af258d15e589a3d1e9e/charset_normalizer-3.5.1-cp313-cp313-android_24_arm64_v8a.whl", hash = "sha256:4f298bdadb8f0b9e5672877f647d1be9373ef5320c9e2f049795e26cad28b6a9", size = 211584, upload-time = "2026-08-15T08:17:33.597Z" }, + { url = "https://files.pythonhosted.org/packages/18/57/a305c968be1ca13f3dd1b32f445877e97addf55d80b65c7cb35fac82b777/charset_normalizer-3.5.1-cp313-cp313-android_24_x86_64.whl", hash = "sha256:88ca277405c2d3b71c4e1c2ee0e7966e807bcba86a69d11e19ba199d18ae4491", size = 223359, upload-time = "2026-08-15T08:17:35.022Z" }, + { url = "https://files.pythonhosted.org/packages/09/0a/d3646670292ce8d8f8cc11ac067d44885e697a5591f57a9221128da5e7b3/charset_normalizer-3.5.1-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:9362dd90aa7dab48c0054a21187791ccf05473f7dba5d92b8033ae62164675e7", size = 194464, upload-time = "2026-08-15T08:17:36.452Z" }, + { url = "https://files.pythonhosted.org/packages/de/93/d51ec556e01042fed6f993ea859311bc7917b466684182fbbceb6ca24762/charset_normalizer-3.5.1-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:977cdbd483a9cff38179bea4fd754289a6f2195c7abd414aba85410b3e66cc5e", size = 197676, upload-time = "2026-08-15T08:17:37.819Z" }, + { url = "https://files.pythonhosted.org/packages/a4/a0/562247944386f7d4ef94467e84876600cc1e0f1b93239aaa9213d2bc3cbd/charset_normalizer-3.5.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:e90251c0c7bdd54a100a0dce3c07b7e637278c93af29dbf78ebb89a58c4bac7d", size = 340473, upload-time = "2026-08-15T08:17:39.303Z" }, + { url = "https://files.pythonhosted.org/packages/31/e7/1d994be1b93d41e9502b8b0460eaa88a1dd8df335df415db87d6c3e91ab2/charset_normalizer-3.5.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:94d78ecec2605a8d0398b0f365d5f12a63248438516f5dac536a5eff7337df4a", size = 240156, upload-time = "2026-08-15T08:17:40.66Z" }, + { url = "https://files.pythonhosted.org/packages/09/53/27923ce5cc6cbccb832037b27dca98882d9c53e9b69e866bbbef4aae7fc8/charset_normalizer-3.5.1-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:d59b75732e9b6f27388e10c14b0259cc5f2e48c78627d185e6a177b58ad3cffe", size = 228246, upload-time = "2026-08-15T08:17:42.003Z" }, + { url = "https://files.pythonhosted.org/packages/ce/48/5a97e84d63af1d55c07439cb80e56d99a8efb4295700eb4e18c0d1615d2c/charset_normalizer-3.5.1-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:0d929fc574b4d6fd9e7c0f5c2ede8716a41911923aa7fa5fce38e0818aa4a1ac", size = 263660, upload-time = "2026-08-15T08:17:43.627Z" }, + { url = "https://files.pythonhosted.org/packages/7a/c2/071575791dcc88316c0a9a65ce38897a82e4cfe4a325f0f7fe1b1ac47bcf/charset_normalizer-3.5.1-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:394fea06235c8543390050ed5f529187074b029fb027213f6c46ac11ab5d950e", size = 260354, upload-time = "2026-08-15T08:17:45.094Z" }, + { url = "https://files.pythonhosted.org/packages/fb/af/63240b0c0248c075c2535a1f1bd992821d8251b9f173abc13329661d09e4/charset_normalizer-3.5.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:62b55f6722735a6c472f88361cde6640608773d9443cebdbb51abf436a1fcdd3", size = 250638, upload-time = "2026-08-15T08:17:46.496Z" }, + { url = "https://files.pythonhosted.org/packages/4d/66/70dfad64f15be09c15ccfee81330a7e515895dbe296dd23114e9a231268a/charset_normalizer-3.5.1-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:fa48b1b63d639f9483e0633e092f5851e2348c352f1f9bb6c8182f87884ef876", size = 244583, upload-time = "2026-08-15T08:17:47.963Z" }, + { url = "https://files.pythonhosted.org/packages/c0/24/ef36367d38b9ddd4bccbf72888c342e8de1f5ae506fa0b2dcf970e2732a1/charset_normalizer-3.5.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:c71fb0d56c920c269cd3e2e3fe7c610e3f1fdb21a6ce60efa6430ff63676cea6", size = 242038, upload-time = "2026-08-15T08:17:49.481Z" }, + { url = "https://files.pythonhosted.org/packages/db/ab/55e683ba0fff2e43adafc10daa3001eac90fdaa419a97227d5a7067eedde/charset_normalizer-3.5.1-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:485a0d363cafefcd2538a73c7c838daa2035f09b2c9f9b5e3133f80c6aeb84c2", size = 233677, upload-time = "2026-08-15T08:17:50.845Z" }, + { url = "https://files.pythonhosted.org/packages/bd/67/0f40eaf8d1b6e7cf15e82382a2965efaca787fc1c2794b7021d37aaf5036/charset_normalizer-3.5.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:5c0ea61a470e070686aa30892fed79e297d2c8d0ab46b8bcdf027d38c51da591", size = 264491, upload-time = "2026-08-15T08:17:52.61Z" }, + { url = "https://files.pythonhosted.org/packages/5c/64/12b4c2a11ee8df4fcc518c78b0d93e3a92bd3d5253d1617ce74ff0e8c7ef/charset_normalizer-3.5.1-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:90b7481fb62fbe172c558bc6fd1c4c98d82004a54a7551f20e11ac9bf0b8708c", size = 245196, upload-time = "2026-08-15T08:17:54.023Z" }, + { url = "https://files.pythonhosted.org/packages/37/2e/651d910af6d0fba325eee1cda37ec5443462ed25360e666c144166eb6091/charset_normalizer-3.5.1-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:35fe081843b35aad20ffeccec3eeffbe637b15d14f3fb22cc1b59cd8ec17e93c", size = 261660, upload-time = "2026-08-15T08:17:55.491Z" }, + { url = "https://files.pythonhosted.org/packages/90/c6/b09e05e6db7f64338e0dc067c79577b1138da86c1e38369096851d96be88/charset_normalizer-3.5.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:fd0350afdc3aabd5576f60ea109228bd5538139713c7b094c5cd27c73a98bc6f", size = 252618, upload-time = "2026-08-15T08:17:57.025Z" }, + { url = "https://files.pythonhosted.org/packages/76/4e/362d4f9fdcdf5556fb2aa3ce7d4a58ebce03ed1ff03aa1d9aca8d02f13f3/charset_normalizer-3.5.1-cp313-cp313-pyemscripten_2025_0_wasm32.whl", hash = "sha256:9d9a0dc7cbe9bec24c3f767c9122c41fe5a1bc43f47cd099d00d393e09769de4", size = 140362, upload-time = "2026-08-15T08:17:58.425Z" }, + { url = "https://files.pythonhosted.org/packages/b4/d4/703be739b26acce318bd29eb3b25b7209e1b1f527f9eae3d1f1f01fdde2b/charset_normalizer-3.5.1-cp313-cp313-win32.whl", hash = "sha256:d63600d620ad0064c3a748b950ac5ea38a80190e5498532efefa4b7b3f1da1f3", size = 177755, upload-time = "2026-08-15T08:18:00.037Z" }, + { url = "https://files.pythonhosted.org/packages/8a/33/56d97ade41c8db611e727168c52ae46c9224c362ec28d4b65d7e9869e8da/charset_normalizer-3.5.1-cp313-cp313-win_amd64.whl", hash = "sha256:aea996a6aba25260827c9ea511d1addfde2da9eb686ac961838509086188b7e6", size = 199295, upload-time = "2026-08-15T08:18:01.506Z" }, + { url = "https://files.pythonhosted.org/packages/5b/75/5b20dd1e6573a01a08158fe104104fa2c8abf941745596954185726cd46c/charset_normalizer-3.5.1-cp313-cp313-win_arm64.whl", hash = "sha256:fd0a274c0e5f9a21565cd9d3dd749b61f96b7aa1e20a93aa1ba4029518f2e5c0", size = 179856, upload-time = "2026-08-15T08:18:02.929Z" }, + { url = "https://files.pythonhosted.org/packages/29/cd/2b812ce5e888f1ce69a5350281e58aab07ae64a958ecae8912f30865718e/charset_normalizer-3.5.1-cp314-cp314-android_24_arm64_v8a.whl", hash = "sha256:774d157f112367ff4abd29019f38f023c24e00e56edc7829c20e358a5a913ad8", size = 212318, upload-time = "2026-08-15T08:18:04.403Z" }, + { url = "https://files.pythonhosted.org/packages/9e/4a/a6ee107430768a5334e6d63f31f148a04a1a491ef161a1ac9415a73f2fa8/charset_normalizer-3.5.1-cp314-cp314-android_24_x86_64.whl", hash = "sha256:26422d45fd13551cf564c58932f7d72b4f58b93b0fcf18c35ba6be12b46bb102", size = 224897, upload-time = "2026-08-15T08:18:05.997Z" }, + { url = "https://files.pythonhosted.org/packages/c3/d9/35ae3f64f29d0179c35c3baefe575904df2913dde519129c7f75995a2b1d/charset_normalizer-3.5.1-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:09a7bba9f739468c8e78c36a75c33768e53cb1959fc638f510454c14683f00d5", size = 194848, upload-time = "2026-08-15T08:18:07.397Z" }, + { url = "https://files.pythonhosted.org/packages/74/76/f2fc7380f056cc273a53af37f50d08ad54b2c59f61078f31432edcf1c2bd/charset_normalizer-3.5.1-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:4c9548dc78002099910abaebc0a72ac58b7d30931869e0351c09b507dff4ece3", size = 198163, upload-time = "2026-08-15T08:18:08.989Z" }, + { url = "https://files.pythonhosted.org/packages/e9/40/095ce62fa078483cccc1fa2b36e6bc9580b85422a20ee9f925341c50e44f/charset_normalizer-3.5.1-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:c428c6c31eb5f4277d7f8eccaf767fbd548ddd5ce3c8b4f4cbbfab3d96b5904c", size = 341823, upload-time = "2026-08-15T08:18:10.458Z" }, + { url = "https://files.pythonhosted.org/packages/f1/5a/0e58b1c04a1596e0256f407274a92d5fb2ee21324409d1fab1da48a65b5b/charset_normalizer-3.5.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2f06b7eae9dbe77fe1d644ca244dad508de8d302870a43f3c559b521270938a0", size = 242458, upload-time = "2026-08-15T08:18:11.989Z" }, + { url = "https://files.pythonhosted.org/packages/22/95/b4618ce912e6db0b1aae89ba788e38e8a7eba0f3025cc66e8c0699f977b2/charset_normalizer-3.5.1-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:6b7430cf5728e68f6c462254009a6ef4086e1bea43cf2f57aa9c55fb4f50ff96", size = 226717, upload-time = "2026-08-15T08:18:13.401Z" }, + { url = "https://files.pythonhosted.org/packages/8a/76/c681192bbda3d55356db5dadd64381d5202b37c6b598fcda5282e88b5d3d/charset_normalizer-3.5.1-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ab743e9bc90c1f73552ec33e10e3331315acd2c397b36065b591b0181de533cc", size = 266111, upload-time = "2026-08-15T08:18:14.961Z" }, + { url = "https://files.pythonhosted.org/packages/88/be/55127bfca72c0cff6c022488d140d7c5b04c771e3b72e9bdb4836d54979d/charset_normalizer-3.5.1-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f6f7deae3feb4edfa2efaf7c574fe88cbf055038a6abdb40188e4fff66d5699f", size = 263128, upload-time = "2026-08-15T08:18:16.515Z" }, + { url = "https://files.pythonhosted.org/packages/e0/91/39c3af510b0aa32bbda03374259200f28430febfd1bf5e511fe765282ce5/charset_normalizer-3.5.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:15f024313246a4ed976c60f440bb8d257815513a681d212ff74fd46f7d715a90", size = 251240, upload-time = "2026-08-15T08:18:18.127Z" }, + { url = "https://files.pythonhosted.org/packages/1c/a5/cbe418bbc6ecdfc3e05a0116002897c4b403a5e838d697e64c78e9f0190d/charset_normalizer-3.5.1-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:823f82903d189af463d7df250ef1f7f696f3cee08cc8d91deb565e8d425f6506", size = 245282, upload-time = "2026-08-15T08:18:19.625Z" }, + { url = "https://files.pythonhosted.org/packages/cc/a4/689bb42e8e7cd492f3cb64907c6bc00ad247ec9a3628cd3f8eed126e8ae1/charset_normalizer-3.5.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:01e93745f7f219b703b60ba7afead36cfc4242782be5af484673fc500df12da5", size = 244597, upload-time = "2026-08-15T08:18:21.121Z" }, + { url = "https://files.pythonhosted.org/packages/c1/ce/9962938e179cf9f699d3f1e7b3114b5d7642dee6a893745229f9dd04f274/charset_normalizer-3.5.1-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:329fc3ccb63ad22d867d84c2adea759a64079a37ba4a343433b02c7a2816871e", size = 231376, upload-time = "2026-08-15T08:18:22.57Z" }, + { url = "https://files.pythonhosted.org/packages/85/54/46000450ada53bd9eac5429a2c8c54cd2d9b39c0c255f229aea9af0948a5/charset_normalizer-3.5.1-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:bb57753e36e4855b8ca375069482250a6246372331a3e4f3407eaebb007443f5", size = 266715, upload-time = "2026-08-15T08:18:24.235Z" }, + { url = "https://files.pythonhosted.org/packages/3d/bb/618749d70f792b44252a777bf89bfb86823b9bbc1ea13fe8ce759b07f38a/charset_normalizer-3.5.1-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:fce8cbd4997efeb450bd298b54f755dcdff18d496f7a5ddbb4867c6d7c88fdc3", size = 245848, upload-time = "2026-08-15T08:18:25.726Z" }, + { url = "https://files.pythonhosted.org/packages/7e/3f/ffb64458527c7668031d5eb095d978de561958dc9f5b53f8e488a533e603/charset_normalizer-3.5.1-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:6c9cdde8becb25a7fde49924511aa2644d6f8081cc8df8e9452724303348d8e3", size = 264521, upload-time = "2026-08-15T08:18:27.193Z" }, + { url = "https://files.pythonhosted.org/packages/4f/ab/74a55fd803916a35ac461daf002708191aac19b546b80dc8cabfedc63d98/charset_normalizer-3.5.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:9ac4444d8d4fd4c4bd08bf451ed3167aa9e7ec6cdb41b648794f1d1103652e36", size = 253054, upload-time = "2026-08-15T08:18:28.568Z" }, + { url = "https://files.pythonhosted.org/packages/a0/2a/6a9034b7d3c60b17499afb482df5878bf9fa20b50cc3887d5ef017a833db/charset_normalizer-3.5.1-cp314-cp314-pyemscripten_2026_0_wasm32.whl", hash = "sha256:f03ac127268b43ef4fe9e6ab6794a6794b49485a0cc0c1db79876d2f33f75bc7", size = 140580, upload-time = "2026-08-15T08:18:30.214Z" }, + { url = "https://files.pythonhosted.org/packages/f3/46/1d362e1a00d035d66b9869e1281eee115907f7e390a16a07824ab5737360/charset_normalizer-3.5.1-cp314-cp314-win32.whl", hash = "sha256:1f5883d77fd409a261abb5dc8ccbe335720d798b1de4abb3b1d47ccbbc76b53b", size = 180325, upload-time = "2026-08-15T08:18:31.877Z" }, + { url = "https://files.pythonhosted.org/packages/7a/7c/4938c329b6a9d446f6a59aa2092ff7118f274209b5ed0e26893d1d30a63c/charset_normalizer-3.5.1-cp314-cp314-win_amd64.whl", hash = "sha256:c658c50ac0c98cd755a2dd50b7977d3bca7df401dcc47fbdfa87db53ef7d4e8b", size = 204175, upload-time = "2026-08-15T08:18:33.466Z" }, + { url = "https://files.pythonhosted.org/packages/ac/33/eeb384dbd8dec570661354592f4f2e1b2fcc92585624d146a000caf53841/charset_normalizer-3.5.1-cp314-cp314-win_arm64.whl", hash = "sha256:4bea7f8ebe90bbd7f0e4a2de42ca6924ba23e3e76418c408ff82f1d46fabd687", size = 184123, upload-time = "2026-08-15T08:18:34.913Z" }, + { url = "https://files.pythonhosted.org/packages/1c/6c/c73fa9d5a85f6ab05395de61c5f6984e0a9ff40bb5ff888d46dff02526c6/charset_normalizer-3.5.1-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:fbc597639158fd7c14d55e808718848319540f51b0e6746e3eefa59723a4a348", size = 381682, upload-time = "2026-08-15T08:18:36.349Z" }, + { url = "https://files.pythonhosted.org/packages/30/c7/63565f860921457feba93bae6c86fb7746deb4cffeed2f375cb845318146/charset_normalizer-3.5.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e71c909f353863b2b89c83de2ebed71ea6d0df8a6ef65a128193c5e650766bef", size = 240826, upload-time = "2026-08-15T08:18:37.887Z" }, + { url = "https://files.pythonhosted.org/packages/06/ae/7ae8807410dfa33f8e6f1715740adeaafa8a816cc4cb33508f54b1f7c896/charset_normalizer-3.5.1-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:7ac76cf9afd34929d76eb7fcb63be476a4853d8a96f0dcf2d0db68a0cbdf9885", size = 227861, upload-time = "2026-08-15T08:18:39.315Z" }, + { url = "https://files.pythonhosted.org/packages/e9/a3/887c1642f0da26000b0e0652d91071113c0e72cea33952e225cf589f49a9/charset_normalizer-3.5.1-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a3a370082ce34d0612f421e15fe011c53bb1feff21a26d06ad4fb244dab5a375", size = 260758, upload-time = "2026-08-15T08:18:40.88Z" }, + { url = "https://files.pythonhosted.org/packages/3e/11/e6f5b9a3d0e55b0ef7505cd3765cdd48f22db89994c947b316f52f801fd8/charset_normalizer-3.5.1-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:256dd4d85d9e4dc595e2bc983c980e73f62ddeb3165c58b4c3dfe78c5c8548c1", size = 259950, upload-time = "2026-08-15T08:18:42.351Z" }, + { url = "https://files.pythonhosted.org/packages/1b/ee/e4e10a94d51cd1ee638aa7e00b65399e6b2a4e8376ab6d2eac9f95586671/charset_normalizer-3.5.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:58d4aa13a59c969dbfdf9e6a9560e242cbfd9e8a8f50c2747714df1a423adf65", size = 249329, upload-time = "2026-08-15T08:18:43.914Z" }, + { url = "https://files.pythonhosted.org/packages/c4/25/d5f4198819e6059735a84e8d0bfb72dc33976da67b97adcd3fb5a5e07ec6/charset_normalizer-3.5.1-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0c6dfb5ca6723eeed15aa8e564a014d69fcb8812f94eef11fe3631e0508199f5", size = 243137, upload-time = "2026-08-15T08:18:45.368Z" }, + { url = "https://files.pythonhosted.org/packages/a5/e9/e925ca7569cf9fb9701fd82503fee73eea5268fdb856bdd64947092d3daa/charset_normalizer-3.5.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:c010f5581d9c612804cc59fcf7b524b707fbcb72828551237ab545bb5c7034af", size = 242820, upload-time = "2026-08-15T08:18:46.842Z" }, + { url = "https://files.pythonhosted.org/packages/34/17/672c251a888ed2aebcdd2fe830ad0104e25ff83c43f5c4f9c15e9fc6853c/charset_normalizer-3.5.1-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:52ec005752a56ae79547a05c0139ca2501a0c866390b6115008456b9f0e7cde1", size = 230504, upload-time = "2026-08-15T08:18:48.353Z" }, + { url = "https://files.pythonhosted.org/packages/3f/fc/f6a85abebd42ce4da2f1db0aa56cc6a0df1995e318b3875d14401b8381d1/charset_normalizer-3.5.1-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:2bced4061f000f7187254a02ad3433ae17eaf991747ceea2f478422590a5bba9", size = 263087, upload-time = "2026-08-15T08:18:49.859Z" }, + { url = "https://files.pythonhosted.org/packages/98/66/7c42677e739ba66746b297e2046918d793078094dc239e1e72768cffccc6/charset_normalizer-3.5.1-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:9eea3ab2597a5e65fe65296e2d6a84570845a6b55532d90333d740d48bbc850a", size = 243269, upload-time = "2026-08-15T08:18:51.601Z" }, + { url = "https://files.pythonhosted.org/packages/de/d8/a50b79237f417af10f8c2a501ce8d1ca87829a22e69117891ca4ba20a69e/charset_normalizer-3.5.1-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:496846868fea80e479324862fa877f02411f2fd0f83b79ccee2607aa68b2a032", size = 258766, upload-time = "2026-08-15T08:18:53.23Z" }, + { url = "https://files.pythonhosted.org/packages/2e/1d/0fc91aeaeb3c83b748f532399ce67cf84604b48297405d740000f7a9e786/charset_normalizer-3.5.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:85d5855daafc240cc045c026d7a15fd198a09b0fc8ff6f5ecbb5297b509cb11e", size = 250814, upload-time = "2026-08-15T08:18:54.768Z" }, + { url = "https://files.pythonhosted.org/packages/ae/10/3d8c777cf9024615295aa1b808324ad5b4a77855869c00824bad74ffaf8a/charset_normalizer-3.5.1-cp314-cp314t-win32.whl", hash = "sha256:58d3e12c88e0950bca850ae1f7c256055c097639c2edb9eb123af9807d8b15e4", size = 191074, upload-time = "2026-08-15T08:18:56.305Z" }, + { url = "https://files.pythonhosted.org/packages/4d/81/ae557d3c44d1a1d688696d60563413a0866a91b7ebc50f20df838be3d8c8/charset_normalizer-3.5.1-cp314-cp314t-win_amd64.whl", hash = "sha256:acaf604462bf330b0d07e7a07c1d6e4adac79e5fb13e9c5140590542cafacc00", size = 216476, upload-time = "2026-08-15T08:18:57.889Z" }, + { url = "https://files.pythonhosted.org/packages/27/e9/61c01fb8b804692569c036b3fc50495814502dcf13a60649c6055390b02c/charset_normalizer-3.5.1-cp314-cp314t-win_arm64.whl", hash = "sha256:fdb8a068947befafba9952162645dc2fecaeb400e64584829ed5e9b2fbe21a7f", size = 194115, upload-time = "2026-08-15T08:18:59.418Z" }, + { url = "https://files.pythonhosted.org/packages/4a/4e/8544831ef59d8f27ce92c80871380fdacc8076a8a56ed62f82e54f991333/charset_normalizer-3.5.1-cp315-cp315-macosx_10_15_universal2.whl", hash = "sha256:9085f87b0e38a2b92b8923059b4e8789fe40d9279712d15dcc670048d77079af", size = 342048, upload-time = "2026-08-15T08:19:01.054Z" }, + { url = "https://files.pythonhosted.org/packages/7f/a6/e3b46852424246065355644f4fb6dbccc0239a42a2eee27ecfc8957f0bcd/charset_normalizer-3.5.1-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2679de311c7946dde5d3b6f44941844133ff5c7cb86099c0061ab1e8901c20a8", size = 242997, upload-time = "2026-08-15T08:19:02.492Z" }, + { url = "https://files.pythonhosted.org/packages/03/3b/0cc9a26777334ab2f2e3089b948bbf4e4fe72ea70b897715ef6415043ec8/charset_normalizer-3.5.1-cp315-cp315-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:baf3775a2635e5a11fbd5e4e64ee69c7e86875d224a5c72aca4c141064589a90", size = 237014, upload-time = "2026-08-15T08:19:03.943Z" }, + { url = "https://files.pythonhosted.org/packages/8c/c2/027335f0aa337a2a2e121bac1ad88c4f02ba6053ea0926802784f3db11af/charset_normalizer-3.5.1-cp315-cp315-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:8ac8c94b6539074e0f40899301273ac8402b9b3e01c7b7ba269ff30340aaaf20", size = 266174, upload-time = "2026-08-15T08:19:05.598Z" }, + { url = "https://files.pythonhosted.org/packages/86/d3/e367787febe4e74769dec0f406f2c3c8d1b955fce5aee1fd0f94e8367a45/charset_normalizer-3.5.1-cp315-cp315-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:8fe532b3c966d1fb794e0698e4589d0444017ae77fc0b31edea13c0e35bcc449", size = 263361, upload-time = "2026-08-15T08:19:07.251Z" }, + { url = "https://files.pythonhosted.org/packages/af/3d/391b193eb9f3e84b02f9314088c386debdc0debee843535aaea2e2c6715d/charset_normalizer-3.5.1-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5c84bec0ab5ae0c64bfe73a7d2adcb5ce73b467523fc27fd6a28ab2aa6cbe35a", size = 252143, upload-time = "2026-08-15T08:19:08.816Z" }, + { url = "https://files.pythonhosted.org/packages/2e/57/de221f1745a90d418199761967e2776bfe2c275a1194220985e8c1d37833/charset_normalizer-3.5.1-cp315-cp315-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:854066be00447fa8de2ccbbe893e2ffc4b123ef16d897af794c1e18bd4a714b0", size = 252086, upload-time = "2026-08-15T08:19:10.255Z" }, + { url = "https://files.pythonhosted.org/packages/c8/e3/d119f86a01f9331e8186175f24873b1d74a7ee9e2e4b4d68f9947dae5afd/charset_normalizer-3.5.1-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:21b82d8082f6f5e7f456ef0bd16323d08de1266efbfeb476e64b2a91d1471a4e", size = 245231, upload-time = "2026-08-15T08:19:11.807Z" }, + { url = "https://files.pythonhosted.org/packages/26/de/d8e48c135ae480879539cdb179c8d3b50c7879497d75dd899b5763b69cee/charset_normalizer-3.5.1-cp315-cp315-musllinux_1_2_armv7l.whl", hash = "sha256:838648accb3a7fd9803fd45c87bce8509648eb0c11bc34e216141300977244f2", size = 241546, upload-time = "2026-08-15T08:19:13.416Z" }, + { url = "https://files.pythonhosted.org/packages/67/c4/217755fd1abc50d326c252922cd642002758095a81ff45010337b8b3ef65/charset_normalizer-3.5.1-cp315-cp315-musllinux_1_2_ppc64le.whl", hash = "sha256:195ce897c6153c0700078142cf8efe3e6454ca4cf4357499e4078dfd83396626", size = 267033, upload-time = "2026-08-15T08:19:14.981Z" }, + { url = "https://files.pythonhosted.org/packages/b8/d7/34d8e404e358d2adcc5a228c2134643af00104c8fb0bf525f3688d756f05/charset_normalizer-3.5.1-cp315-cp315-musllinux_1_2_riscv64.whl", hash = "sha256:978eab16f55b4ab2c2a745be9a0a840bf8f09a7f227d9c76eb30214d078865a5", size = 252045, upload-time = "2026-08-15T08:19:16.618Z" }, + { url = "https://files.pythonhosted.org/packages/5e/fa/40414471acf0aa0692ca77305aa00e434fcd8288f0941c93c30e9a5f8f2f/charset_normalizer-3.5.1-cp315-cp315-musllinux_1_2_s390x.whl", hash = "sha256:cc0329df4caaceb950d2f580b5ac716a377f7059624a0bafaeaf8a218c6ed774", size = 264866, upload-time = "2026-08-15T08:19:18.101Z" }, + { url = "https://files.pythonhosted.org/packages/32/90/fcc850bae791abd2e0c041847f13e270aa08692a79f3e00de6d2dce1cb50/charset_normalizer-3.5.1-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:687c9ca3035544b113bea2055e180af96fb63c0c476e22a9180f51925186e7b7", size = 253932, upload-time = "2026-08-15T08:19:19.734Z" }, + { url = "https://files.pythonhosted.org/packages/af/af/53afe99068b3c10b4cbae592a52ef72a7c92c0188440e83ee3a078fd8f75/charset_normalizer-3.5.1-cp315-cp315-win32.whl", hash = "sha256:706bfd38730a5ac7a365793269a00f4e988178cec121391f4248d84ad8c972e9", size = 180320, upload-time = "2026-08-15T08:19:21.37Z" }, + { url = "https://files.pythonhosted.org/packages/c9/bc/f46a132041b29e4a8779ed712d3df1bf112e94ca8de58b66d7ec2c0cf8b9/charset_normalizer-3.5.1-cp315-cp315-win_amd64.whl", hash = "sha256:92caef967d287a407085d61176fce4012b1dd62daed4eb6d5ceb26d3d2538712", size = 204174, upload-time = "2026-08-15T08:19:23.088Z" }, + { url = "https://files.pythonhosted.org/packages/a1/5d/9ed554480eda8e447b673648628fdc29574d23dbad01fe11837adedd1cae/charset_normalizer-3.5.1-cp315-cp315-win_arm64.whl", hash = "sha256:5fc45d653ea8c9a20479167e11d4a0f8cb2fa3470737ab6f9c827532313187b7", size = 184126, upload-time = "2026-08-15T08:19:24.471Z" }, + { url = "https://files.pythonhosted.org/packages/3b/32/9b8929bf384061ee1fe5d9c27c6f9776d3d824039ad4e14c88ec00c7808e/charset_normalizer-3.5.1-cp315-cp315t-macosx_10_15_universal2.whl", hash = "sha256:59171c6e45bf07d0d5cab3b0bf81d945035530f6873398b3b531c31184d46663", size = 381441, upload-time = "2026-08-15T08:19:26.038Z" }, + { url = "https://files.pythonhosted.org/packages/96/10/e9aa7923d3ddac652c99a1c5f7be494e737e151566a44abe018daf757f2c/charset_normalizer-3.5.1-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9dbdd9205662134957cf0c324f639bdc5031c0ca056e2369e238db75187c0f11", size = 241742, upload-time = "2026-08-15T08:19:27.532Z" }, + { url = "https://files.pythonhosted.org/packages/28/53/a2d249ebddf47b889a100c0bdcb61a2f9dbb8bc24ef325cc062e4f476877/charset_normalizer-3.5.1-cp315-cp315t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:e4b018dc5a0eee4676e38fe84a47a427816c590b93b55d9025274ec4d6ffc2dc", size = 235298, upload-time = "2026-08-15T08:19:29.274Z" }, + { url = "https://files.pythonhosted.org/packages/7d/07/469f78af590f7d5cd48e20d8dbfa3d66deeff9ba37768c04d886b5afd45c/charset_normalizer-3.5.1-cp315-cp315t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ced3fdd71aaa83ce593746c2edb42b7a59cb4c19c8b5c407781c72e493aae55a", size = 262500, upload-time = "2026-08-15T08:19:30.955Z" }, + { url = "https://files.pythonhosted.org/packages/55/66/3bb56a47f7dcba014055b1a1d33c6f08bbe9c1e74dba154cfa25f90ae885/charset_normalizer-3.5.1-cp315-cp315t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:19a3dd5aa73cef1c99687c4fc57db016a9c17104ae1185da88ba566a5d3bebe4", size = 258888, upload-time = "2026-08-15T08:19:32.458Z" }, + { url = "https://files.pythonhosted.org/packages/ff/c1/2adc2800903fb013210349313b710a5376856578d9e33e6b9a1d8b36714a/charset_normalizer-3.5.1-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:cc5d36d96478aa9c60654bd932525bf32964c62a7281eafdf16d85003a8d6004", size = 250243, upload-time = "2026-08-15T08:19:33.94Z" }, + { url = "https://files.pythonhosted.org/packages/95/b5/a18d0dd1157ab655cc2cb14a545f4a4784bbad70ab3502412e36097502d9/charset_normalizer-3.5.1-cp315-cp315t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:04368edf83514385ffc3e1cfd4546e595f4f1272dd23ba437a93a9cc3741d47b", size = 249871, upload-time = "2026-08-15T08:19:35.413Z" }, + { url = "https://files.pythonhosted.org/packages/ad/c3/525f508cd1e58d0450ac55ed40ac75bc3a97482c59def5278456a5fbf03c/charset_normalizer-3.5.1-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:9b5db6052055d34d41230fb78d7c439c23dc536a9896f6cb039e8dd92cfc1263", size = 243580, upload-time = "2026-08-15T08:19:36.886Z" }, + { url = "https://files.pythonhosted.org/packages/7c/c1/49a91fe7e97c8140094ca5c64161ab623a70d9f636bf834eace14048acb5/charset_normalizer-3.5.1-cp315-cp315t-musllinux_1_2_armv7l.whl", hash = "sha256:252d099029bcbea642f2a06c4ed5046bdf8b5a8150b64afa5e027e88b106e5ee", size = 239807, upload-time = "2026-08-15T08:19:38.392Z" }, + { url = "https://files.pythonhosted.org/packages/d3/58/56a48c296601274c4689b864a8e2dfb209b81dfcb39472753ce95eea662b/charset_normalizer-3.5.1-cp315-cp315t-musllinux_1_2_ppc64le.whl", hash = "sha256:6199d5606e2bbf2b096cf64d03f8b6790c91081d5ac866b8e7bb6422738cc60c", size = 264083, upload-time = "2026-08-15T08:19:39.856Z" }, + { url = "https://files.pythonhosted.org/packages/10/4c/dc48409274a1817ff349711d26c62aa0c597df865d4d69ef79160c859193/charset_normalizer-3.5.1-cp315-cp315t-musllinux_1_2_riscv64.whl", hash = "sha256:77efcff2b23071c349402ac1066667a3d011f62398d81408c9b88ad991747c9e", size = 250317, upload-time = "2026-08-15T08:19:41.53Z" }, + { url = "https://files.pythonhosted.org/packages/81/58/d325912115caec62d6bdd77bbab5e0b7da5d234a9f20affdffcbcb530d0b/charset_normalizer-3.5.1-cp315-cp315t-musllinux_1_2_s390x.whl", hash = "sha256:a5cbd90ecf0fc62e64726917ad083b73001f0563657a87ec3c0b504e277dc90d", size = 258173, upload-time = "2026-08-15T08:19:43.07Z" }, + { url = "https://files.pythonhosted.org/packages/34/f7/b13b1ccae2c8ec63980d13be1890eb73f8aeabbfce02a24aabc0908788f5/charset_normalizer-3.5.1-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:4d26f14f041e83dd8edfd61f4cd4fa7285d31798b5bf1f28e70c367ba6c41d61", size = 251960, upload-time = "2026-08-15T08:19:44.587Z" }, + { url = "https://files.pythonhosted.org/packages/1e/25/ed3f9919c5aef8cc818be1f972f565f7610d7b2076b8ebb98839516ffc3c/charset_normalizer-3.5.1-cp315-cp315t-win32.whl", hash = "sha256:ac13b004224fb341e1e25a1ed5e19d32f57cdb2a403e01f003b46f051a550f6f", size = 191186, upload-time = "2026-08-15T08:19:46.293Z" }, + { url = "https://files.pythonhosted.org/packages/69/d5/43c2b3e9d8267092b913eb8b0603f0f71993c395632886bd37a7223f96cf/charset_normalizer-3.5.1-cp315-cp315t-win_amd64.whl", hash = "sha256:35aea775dc2bd5f54cd84a1cd2696cc3207c479cb9cf0bd346f0d343e4300ddb", size = 215947, upload-time = "2026-08-15T08:19:47.853Z" }, + { url = "https://files.pythonhosted.org/packages/a8/76/9aad3e9c8865e5e0efa9a7f6f81c37a67635a985145ecd44528a81e088ee/charset_normalizer-3.5.1-cp315-cp315t-win_arm64.whl", hash = "sha256:fb78f6e7fcd8ad785d28cd577168bc1aaee827b25bb8755638f694794ea98f0a", size = 193909, upload-time = "2026-08-15T08:19:49.383Z" }, + { url = "https://files.pythonhosted.org/packages/5b/97/fb4e82231aba271ffd775a1b4993b0defc4e3059f286ae41d9433409fe85/charset_normalizer-3.5.1-cp37-abi3-macosx_10_9_universal2.whl", hash = "sha256:41876ee62a3dddf48ff1121ad8f0798032aa03f2fd35f21f34a4cab14f18d8d2", size = 331467, upload-time = "2026-08-15T08:19:50.959Z" }, + { url = "https://files.pythonhosted.org/packages/9f/2f/fe3f187327aac18e2d54e9d2b08e15d27bf9b642d9e51c219f130fc34d1a/charset_normalizer-3.5.1-cp37-abi3-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:a6dac12ff6b846103483683f60c5f8fee205121adc58ffd87e90a90a3af69e99", size = 253057, upload-time = "2026-08-15T08:19:52.654Z" }, + { url = "https://files.pythonhosted.org/packages/d7/c7/9e48cee5c161fe24da823b61bf381921d77cb994a0a4de148e95018c1984/charset_normalizer-3.5.1-cp37-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:cee5dd7c6fb5dd52a0fe2a740f9bc6e3593f5f8b1788bde49de02086f30182b2", size = 240930, upload-time = "2026-08-15T08:19:54.163Z" }, + { url = "https://files.pythonhosted.org/packages/49/e0/716601f3cc69be7b198951150c75ead1ece33c3c8036ff6ffa46029659a0/charset_normalizer-3.5.1-cp37-abi3-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:343fb4f2821043bd87095f7b08a1a181febc8e36ac64212143bbfd0a0e1bc235", size = 230822, upload-time = "2026-08-15T08:19:55.807Z" }, + { url = "https://files.pythonhosted.org/packages/d3/05/71bfc5caa0abcc45aea1f6a4d50ac68e59605ddc7666fe8494f4cd229665/charset_normalizer-3.5.1-cp37-abi3-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ae4a097991662cd4fff0ddc74e0fe7874f82e00042fa0ea00855645ed0c79598", size = 260037, upload-time = "2026-08-15T08:19:57.312Z" }, + { url = "https://files.pythonhosted.org/packages/c3/92/de7e32ed05341e7a9c4c877c318418197b7f2d66a3b68d561bf2ac57ca3e/charset_normalizer-3.5.1-cp37-abi3-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:4b599739b93b2cbeded49645ae3c8d1405c29ddfbceac1545c87a3f9580a9e96", size = 255097, upload-time = "2026-08-15T08:19:59.056Z" }, + { url = "https://files.pythonhosted.org/packages/f5/7b/ade0a122600319dfa0b1000ab0f9731c94a817904cf3c5de408c73a4ede7/charset_normalizer-3.5.1-cp37-abi3-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:b39b69b347e5e47a3b5b8cfc005c68c1ba347474e3960236c4944a8ecd174962", size = 250166, upload-time = "2026-08-15T08:20:00.612Z" }, + { url = "https://files.pythonhosted.org/packages/75/9c/019fbb9f4834491a160951349b1a3714439376f66e5f7cf18b4f18f0c7aa/charset_normalizer-3.5.1-cp37-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:a2028475ba855475b8b4d3cfeb4994269c967aea8b9892dfba907f4263a863a3", size = 241821, upload-time = "2026-08-15T08:20:02.321Z" }, + { url = "https://files.pythonhosted.org/packages/2b/b8/11d4840bfc99330cc7fbcc2681ee5a044553a6e77655508d8f9b2bff7b34/charset_normalizer-3.5.1-cp37-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:36047af20e17097c3bb9476c2b7655f2f7aa51322c0ba58c07695bedf755a950", size = 232529, upload-time = "2026-08-15T08:20:04.008Z" }, + { url = "https://files.pythonhosted.org/packages/18/96/2b3a21492d9f65171ac75d872f5018260013d00bfa0ff70ec9f179148cbd/charset_normalizer-3.5.1-cp37-abi3-musllinux_1_2_ppc64le.whl", hash = "sha256:4c4fb141a727957c93edfe5c32a26ceb6b5f6461d67146e2d39f51e16170bea8", size = 260348, upload-time = "2026-08-15T08:20:05.877Z" }, + { url = "https://files.pythonhosted.org/packages/d6/aa/a69a2028e8bd052476c245460ab19d7de595de084dd968f2d75cd50c3e25/charset_normalizer-3.5.1-cp37-abi3-musllinux_1_2_riscv64.whl", hash = "sha256:2f293479cce755c75f1697e87c409b7ae4c555c7dfecb6e988ad13abba943031", size = 247234, upload-time = "2026-08-15T08:20:07.487Z" }, + { url = "https://files.pythonhosted.org/packages/35/8a/3d130aeabcaf3d2466af76b7b141c08d9e89c9016ab4b7cdd0f7dc2d1c62/charset_normalizer-3.5.1-cp37-abi3-musllinux_1_2_s390x.whl", hash = "sha256:3588e376b3ea2eea84976f67273d679f229e24c66dce7b82ae45aef04ff6e072", size = 256917, upload-time = "2026-08-15T08:20:09.142Z" }, + { url = "https://files.pythonhosted.org/packages/80/c2/a7379b840292d0c1ab9fbd17d1f3967aa81794dc95bc74be8999d7fedcf7/charset_normalizer-3.5.1-cp37-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:e199fb99720074809a7720f1c0b4d919eea8b87e88713e0f8f602f7bef543d9d", size = 254846, upload-time = "2026-08-15T08:20:10.727Z" }, + { url = "https://files.pythonhosted.org/packages/01/65/d43b714731bb2f40d4053dfa00ecfc1c5a301f8e3316c5db3a09af59fe94/charset_normalizer-3.5.1-cp37-abi3-win32.whl", hash = "sha256:dd732602a7009217f658d5863d12d79d373a4de0eebc111094bcdd3bb8e0a6cc", size = 174216, upload-time = "2026-08-15T08:20:12.334Z" }, + { url = "https://files.pythonhosted.org/packages/35/4f/b911ed898b26a09789eba9c9200c999aff6c61b4bafaf4838e56d1a1e1a3/charset_normalizer-3.5.1-cp37-abi3-win_amd64.whl", hash = "sha256:70055ff39b97c99e7ae40ea3e393fb62aa2e44dbd9b29f8d14f42fb0025c3959", size = 199764, upload-time = "2026-08-15T08:20:13.908Z" }, + { url = "https://files.pythonhosted.org/packages/f0/a7/920baf467bfd9bf689f3b318340f37aee4572a71f162bd8db51da55ba4fa/charset_normalizer-3.5.1-cp37-abi3-win_arm64.whl", hash = "sha256:87e4f41d375c0b9be2fb5251aee4b8a689169e134535aed81bf085c3b647451e", size = 287318, upload-time = "2026-08-15T08:20:15.551Z" }, + { url = "https://files.pythonhosted.org/packages/cc/61/d01fc49b8dea277640b55a9e15960dbca9fdc8c9fde18e572d39c59f4019/charset_normalizer-3.5.1-py3-none-any.whl", hash = "sha256:6df0ec430f9a831772c23ca5a224cba36517a58a84bb32c32bb59a9fa67c47f6", size = 68658, upload-time = "2026-08-15T08:20:43.306Z" }, +] + +[[package]] +name = "colorama" +version = "0.4.6" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" }, +] + +[[package]] +name = "discord-webhook" +version = "1.4.1" +source = { editable = "." } +dependencies = [ + { name = "requests" }, +] + +[package.optional-dependencies] +async = [ + { name = "httpx" }, +] + +[package.dev-dependencies] +dev = [ + { name = "pre-commit" }, + { name = "pytest" }, + { name = "ruff" }, + { name = "types-requests" }, +] + +[package.metadata] +requires-dist = [ + { name = "httpx", marker = "extra == 'async'", specifier = ">=0.28.1,<1" }, + { name = "requests", specifier = ">=2.32.3,<3" }, +] +provides-extras = ["async"] + +[package.metadata.requires-dev] +dev = [ + { name = "pre-commit", specifier = ">=3.3.3" }, + { name = "pytest", specifier = ">=7.4.0" }, + { name = "ruff", specifier = ">=0.1.15,<0.2" }, + { name = "types-requests", specifier = ">=2.28.11.4" }, +] + +[[package]] +name = "distlib" +version = "0.4.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/c9/02/bd72be9134d25ed783ecbbc38a539ffaefbf90c78418c7fb7229600dbac7/distlib-0.4.3.tar.gz", hash = "sha256:f152097224a0ae24be5a0f6bae1b9359af82133bce63f98a95f86cae1aede9ed", size = 615141, upload-time = "2026-06-12T08:04:52.847Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/02/08/9c41fb51ab5b43eb21674aff13df270e8ba6c4b29c8624e328dc7a9482af/distlib-0.4.3-py2.py3-none-any.whl", hash = "sha256:4b0ce306c966eb73bc3a7b6abad017c556dadd92c44701562cd528ac7fde4d5b", size = 470628, upload-time = "2026-06-12T08:04:50.506Z" }, +] + +[[package]] +name = "exceptiongroup" +version = "1.3.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions", marker = "python_full_version < '3.13'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/50/79/66800aadf48771f6b62f7eb014e352e5d06856655206165d775e675a02c9/exceptiongroup-1.3.1.tar.gz", hash = "sha256:8b412432c6055b0b7d14c310000ae93352ed6754f70fa8f7c34141f91c4e3219", size = 30371, upload-time = "2025-11-21T23:01:54.787Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8a/0e/97c33bf5009bdbac74fd2beace167cab3f978feb69cc36f1ef79360d6c4e/exceptiongroup-1.3.1-py3-none-any.whl", hash = "sha256:a7a39a3bd276781e98394987d3a5701d0c4edffb633bb7a5144577f82c773598", size = 16740, upload-time = "2025-11-21T23:01:53.443Z" }, +] + +[[package]] +name = "filelock" +version = "3.32.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/7d/64/a02e6765de08964ed371eca577870593245afc9dfac16d037de7c10d18e6/filelock-3.32.3.tar.gz", hash = "sha256:0ffa185a3540854c95caa7fa76b76cb219d907415e2c5dc9af25fd970563487f", size = 218135, upload-time = "2026-08-13T16:00:05.577Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a7/8e/50f46a9c0ce8d2861a394c1347caae037ea0431d2f67d7feb151cbc4649a/filelock-3.32.3-py3-none-any.whl", hash = "sha256:7f0ca4bcc0e181c60dbbd8aa9ab5b120ebb99e4e064e83636340056f833a1f09", size = 98901, upload-time = "2026-08-13T16:00:03.974Z" }, +] + +[[package]] +name = "h11" +version = "0.16.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/01/ee/02a2c011bdab74c6fb3c75474d40b3052059d95df7e73351460c8588d963/h11-0.16.0.tar.gz", hash = "sha256:4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1", size = 101250, upload-time = "2025-04-24T03:35:25.427Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", hash = "sha256:63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86", size = 37515, upload-time = "2025-04-24T03:35:24.344Z" }, +] + +[[package]] +name = "httpcore" +version = "1.0.9" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "certifi" }, + { name = "h11" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/06/94/82699a10bca87a5556c9c59b5963f2d039dbd239f25bc2a63907a05a14cb/httpcore-1.0.9.tar.gz", hash = "sha256:6e34463af53fd2ab5d807f399a9b45ea31c3dfa2276f15a2c3f00afff6e176e8", size = 85484, upload-time = "2025-04-24T22:06:22.219Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl", hash = "sha256:2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55", size = 78784, upload-time = "2025-04-24T22:06:20.566Z" }, +] + +[[package]] +name = "httpx" +version = "0.28.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio" }, + { name = "certifi" }, + { name = "httpcore" }, + { name = "idna" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", hash = "sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc", size = 141406, upload-time = "2024-12-06T15:37:23.222Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad", size = 73517, upload-time = "2024-12-06T15:37:21.509Z" }, +] + +[[package]] +name = "identify" +version = "2.6.19" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/52/63/51723b5f116cc04b061cb6f5a561790abf249d25931d515cd375e063e0f4/identify-2.6.19.tar.gz", hash = "sha256:6be5020c38fcb07da56c53733538a3081ea5aa70d36a156f83044bfbf9173842", size = 99567, upload-time = "2026-04-17T18:39:50.265Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/94/84/d9273cd09688070a6523c4aee4663a8538721b2b755c4962aafae0011e72/identify-2.6.19-py2.py3-none-any.whl", hash = "sha256:20e6a87f786f768c092a721ad107fc9df0eb89347be9396cadf3f4abbd1fb78a", size = 99397, upload-time = "2026-04-17T18:39:49.221Z" }, +] + +[[package]] +name = "idna" +version = "3.18" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/cd/63/9496c57188a2ee585e0f1db071d75089a11e98aa86eb99d9d7618fc1edce/idna-3.18.tar.gz", hash = "sha256:ffb385a7e039654cef1ab9ef32c6fafe283c0c0467bba1d9029738ce4a14a848", size = 196711, upload-time = "2026-06-02T14:34:07.794Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1e/5e/d4e9f1a599fb8e573b7b87160658329fbf28d19eac2718f51fc3def3aa5a/idna-3.18-py3-none-any.whl", hash = "sha256:7f952cbe720b688055e3f87de14f5c3e5fdaa8bc3928985c4077ca689de849a2", size = 65455, upload-time = "2026-06-02T14:34:06.319Z" }, +] + +[[package]] +name = "iniconfig" +version = "2.3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/72/34/14ca021ce8e5dfedc35312d08ba8bf51fdd999c576889fc2c24cb97f4f10/iniconfig-2.3.0.tar.gz", hash = "sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730", size = 20503, upload-time = "2025-10-18T21:55:43.219Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484, upload-time = "2025-10-18T21:55:41.639Z" }, +] + +[[package]] +name = "nodeenv" +version = "1.10.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/24/bf/d1bda4f6168e0b2e9e5958945e01910052158313224ada5ce1fb2e1113b8/nodeenv-1.10.0.tar.gz", hash = "sha256:996c191ad80897d076bdfba80a41994c2b47c68e224c542b48feba42ba00f8bb", size = 55611, upload-time = "2025-12-20T14:08:54.006Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/88/b2/d0896bdcdc8d28a7fc5717c305f1a861c26e18c05047949fb371034d98bd/nodeenv-1.10.0-py2.py3-none-any.whl", hash = "sha256:5bb13e3eed2923615535339b3c620e76779af4cb4c6a90deccc9e36b274d3827", size = 23438, upload-time = "2025-12-20T14:08:52.782Z" }, +] + +[[package]] +name = "packaging" +version = "26.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/7d/fa/3944b40b07da9ce895c0e6303a5ab7d53da063554f534556b134a54d6093/packaging-26.3.tar.gz", hash = "sha256:94edc256424af38762eb31306eed28beb9f0efc50a8837492c9d6fd6004aed79", size = 313412, upload-time = "2026-08-04T18:15:28.737Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/63/34/ba1c580383c9eada3711951fef0795c80b829a078d72188184bcab9dd527/packaging-26.3-py3-none-any.whl", hash = "sha256:d7193f7c8e4e93f444fde0262bf90af30e16fa0ad0ad44cb553c87339b23cd1c", size = 129956, upload-time = "2026-08-04T18:15:27.159Z" }, +] + +[[package]] +name = "platformdirs" +version = "4.11.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/b8/d7/e7bfbc86e9f99ff7807e24de7703f032e9c9ba80bb355cf26e0e9bc5a75e/platformdirs-4.11.3.tar.gz", hash = "sha256:66a73d38a849810252df809a3d8bcbda8e26f6c189920e7535ad608a48dbb5ab", size = 33050, upload-time = "2026-08-13T22:43:27.52Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/19/a9/c34aebedd3a4c9afe5101b1b8713710b3fec18087c8a36c35d2f909861bd/platformdirs-4.11.3-py3-none-any.whl", hash = "sha256:5ed065d443751de711da036041a7a214122efc4a4de393b3f4137ba5576540e7", size = 23491, upload-time = "2026-08-13T22:43:26.121Z" }, +] + +[[package]] +name = "pluggy" +version = "1.6.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f9/e2/3e91f31a7d2b083fe6ef3fa267035b518369d9511ffab804f839851d2779/pluggy-1.6.0.tar.gz", hash = "sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3", size = 69412, upload-time = "2025-05-15T12:30:07.975Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" }, +] + +[[package]] +name = "pre-commit" +version = "4.6.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cfgv" }, + { name = "identify" }, + { name = "nodeenv" }, + { name = "pyyaml" }, + { name = "virtualenv" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/74/89/1f3e8e1fc3e97de0fa963495832f581f025f29471602a309e48808244292/pre_commit-4.6.2.tar.gz", hash = "sha256:8f5d7bfb021ecdbcd9d49d89847082dd24172ccde534390081a679ad046e2441", size = 198670, upload-time = "2026-08-10T22:07:18.421Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/45/e2/bbb7129c9e7999a6b8ee9cca3b66486c25c423ab5a75f34071798b74ce94/pre_commit-4.6.2-py2.py3-none-any.whl", hash = "sha256:e2dde9a75d3bce11bd3831c26d134df00a2803c1d818be6a0383c3dcda25dc4e", size = 226202, upload-time = "2026-08-10T22:07:16.942Z" }, +] + +[[package]] +name = "pygments" +version = "2.20.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/c3/b2/bc9c9196916376152d655522fdcebac55e66de6603a76a02bca1b6414f6c/pygments-2.20.0.tar.gz", hash = "sha256:6757cd03768053ff99f3039c1a36d6c0aa0b263438fcab17520b30a303a82b5f", size = 4955991, upload-time = "2026-03-29T13:29:33.898Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f4/7e/a72dd26f3b0f4f2bf1dd8923c85f7ceb43172af56d63c7383eb62b332364/pygments-2.20.0-py3-none-any.whl", hash = "sha256:81a9e26dd42fd28a23a2d169d86d7ac03b46e2f8b59ed4698fb4785f946d0176", size = 1231151, upload-time = "2026-03-29T13:29:30.038Z" }, +] + +[[package]] +name = "pytest" +version = "9.1.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama", marker = "sys_platform == 'win32'" }, + { name = "exceptiongroup", marker = "python_full_version < '3.11'" }, + { name = "iniconfig" }, + { name = "packaging" }, + { name = "pluggy" }, + { name = "pygments" }, + { name = "tomli", marker = "python_full_version < '3.11'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/e4/47/b9efed96c114afcfa3c9d3fe98a76a1d14c74a9e266d397cf6eb64be5e01/pytest-9.1.1.tar.gz", hash = "sha256:1088fbde8f2b49d95a549a195707afa7a76a3ce9bcadc26b6d71f0ffda5fe313", size = 1636369, upload-time = "2026-06-19T10:58:32.857Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/24/25/1de2678b631f5a49215c6c96fff41ba892b0a34df68d6d80292b1b48aa7f/pytest-9.1.1-py3-none-any.whl", hash = "sha256:37a86b45efb9a47a61a36449063e8e18d0cab3161329fc099eb21783169c4f0c", size = 386536, upload-time = "2026-06-19T10:58:31.347Z" }, +] + +[[package]] +name = "python-discovery" +version = "1.5.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "filelock" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/38/b7/ac44da2cf0e53ada0e419033c2d058219c95dc1403126f163304c9e814b1/python_discovery-1.5.2.tar.gz", hash = "sha256:45fd4f20a4e3f9b7bf2e0817870bc8e3b320a19658da177af800768c82dbf354", size = 82350, upload-time = "2026-08-12T14:05:26.419Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/71/45/689603d04b3bb8d7faa00f25c24acef993aab7813b3dbbfc472a459ab0b5/python_discovery-1.5.2-py3-none-any.whl", hash = "sha256:3e338c2d0f15dfaeea57493f4c2c6caebe0e998ea815c30ae8bf8ee21f1112d3", size = 38350, upload-time = "2026-08-12T14:05:25.113Z" }, +] + +[[package]] +name = "pyyaml" +version = "6.0.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/05/8e/961c0007c59b8dd7729d542c61a4d537767a59645b82a0b521206e1e25c2/pyyaml-6.0.3.tar.gz", hash = "sha256:d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f", size = 130960, upload-time = "2025-09-25T21:33:16.546Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f4/a0/39350dd17dd6d6c6507025c0e53aef67a9293a6d37d3511f23ea510d5800/pyyaml-6.0.3-cp310-cp310-macosx_10_13_x86_64.whl", hash = "sha256:214ed4befebe12df36bcc8bc2b64b396ca31be9304b8f59e25c11cf94a4c033b", size = 184227, upload-time = "2025-09-25T21:31:46.04Z" }, + { url = "https://files.pythonhosted.org/packages/05/14/52d505b5c59ce73244f59c7a50ecf47093ce4765f116cdb98286a71eeca2/pyyaml-6.0.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:02ea2dfa234451bbb8772601d7b8e426c2bfa197136796224e50e35a78777956", size = 174019, upload-time = "2025-09-25T21:31:47.706Z" }, + { url = "https://files.pythonhosted.org/packages/43/f7/0e6a5ae5599c838c696adb4e6330a59f463265bfa1e116cfd1fbb0abaaae/pyyaml-6.0.3-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b30236e45cf30d2b8e7b3e85881719e98507abed1011bf463a8fa23e9c3e98a8", size = 740646, upload-time = "2025-09-25T21:31:49.21Z" }, + { url = "https://files.pythonhosted.org/packages/2f/3a/61b9db1d28f00f8fd0ae760459a5c4bf1b941baf714e207b6eb0657d2578/pyyaml-6.0.3-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:66291b10affd76d76f54fad28e22e51719ef9ba22b29e1d7d03d6777a9174198", size = 840793, upload-time = "2025-09-25T21:31:50.735Z" }, + { url = "https://files.pythonhosted.org/packages/7a/1e/7acc4f0e74c4b3d9531e24739e0ab832a5edf40e64fbae1a9c01941cabd7/pyyaml-6.0.3-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9c7708761fccb9397fe64bbc0395abcae8c4bf7b0eac081e12b809bf47700d0b", size = 770293, upload-time = "2025-09-25T21:31:51.828Z" }, + { url = "https://files.pythonhosted.org/packages/8b/ef/abd085f06853af0cd59fa5f913d61a8eab65d7639ff2a658d18a25d6a89d/pyyaml-6.0.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:418cf3f2111bc80e0933b2cd8cd04f286338bb88bdc7bc8e6dd775ebde60b5e0", size = 732872, upload-time = "2025-09-25T21:31:53.282Z" }, + { url = "https://files.pythonhosted.org/packages/1f/15/2bc9c8faf6450a8b3c9fc5448ed869c599c0a74ba2669772b1f3a0040180/pyyaml-6.0.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:5e0b74767e5f8c593e8c9b5912019159ed0533c70051e9cce3e8b6aa699fcd69", size = 758828, upload-time = "2025-09-25T21:31:54.807Z" }, + { url = "https://files.pythonhosted.org/packages/a3/00/531e92e88c00f4333ce359e50c19b8d1de9fe8d581b1534e35ccfbc5f393/pyyaml-6.0.3-cp310-cp310-win32.whl", hash = "sha256:28c8d926f98f432f88adc23edf2e6d4921ac26fb084b028c733d01868d19007e", size = 142415, upload-time = "2025-09-25T21:31:55.885Z" }, + { url = "https://files.pythonhosted.org/packages/2a/fa/926c003379b19fca39dd4634818b00dec6c62d87faf628d1394e137354d4/pyyaml-6.0.3-cp310-cp310-win_amd64.whl", hash = "sha256:bdb2c67c6c1390b63c6ff89f210c8fd09d9a1217a465701eac7316313c915e4c", size = 158561, upload-time = "2025-09-25T21:31:57.406Z" }, + { url = "https://files.pythonhosted.org/packages/6d/16/a95b6757765b7b031c9374925bb718d55e0a9ba8a1b6a12d25962ea44347/pyyaml-6.0.3-cp311-cp311-macosx_10_13_x86_64.whl", hash = "sha256:44edc647873928551a01e7a563d7452ccdebee747728c1080d881d68af7b997e", size = 185826, upload-time = "2025-09-25T21:31:58.655Z" }, + { url = "https://files.pythonhosted.org/packages/16/19/13de8e4377ed53079ee996e1ab0a9c33ec2faf808a4647b7b4c0d46dd239/pyyaml-6.0.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:652cb6edd41e718550aad172851962662ff2681490a8a711af6a4d288dd96824", size = 175577, upload-time = "2025-09-25T21:32:00.088Z" }, + { url = "https://files.pythonhosted.org/packages/0c/62/d2eb46264d4b157dae1275b573017abec435397aa59cbcdab6fc978a8af4/pyyaml-6.0.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:10892704fc220243f5305762e276552a0395f7beb4dbf9b14ec8fd43b57f126c", size = 775556, upload-time = "2025-09-25T21:32:01.31Z" }, + { url = "https://files.pythonhosted.org/packages/10/cb/16c3f2cf3266edd25aaa00d6c4350381c8b012ed6f5276675b9eba8d9ff4/pyyaml-6.0.3-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:850774a7879607d3a6f50d36d04f00ee69e7fc816450e5f7e58d7f17f1ae5c00", size = 882114, upload-time = "2025-09-25T21:32:03.376Z" }, + { url = "https://files.pythonhosted.org/packages/71/60/917329f640924b18ff085ab889a11c763e0b573da888e8404ff486657602/pyyaml-6.0.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b8bb0864c5a28024fac8a632c443c87c5aa6f215c0b126c449ae1a150412f31d", size = 806638, upload-time = "2025-09-25T21:32:04.553Z" }, + { url = "https://files.pythonhosted.org/packages/dd/6f/529b0f316a9fd167281a6c3826b5583e6192dba792dd55e3203d3f8e655a/pyyaml-6.0.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:1d37d57ad971609cf3c53ba6a7e365e40660e3be0e5175fa9f2365a379d6095a", size = 767463, upload-time = "2025-09-25T21:32:06.152Z" }, + { url = "https://files.pythonhosted.org/packages/f2/6a/b627b4e0c1dd03718543519ffb2f1deea4a1e6d42fbab8021936a4d22589/pyyaml-6.0.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:37503bfbfc9d2c40b344d06b2199cf0e96e97957ab1c1b546fd4f87e53e5d3e4", size = 794986, upload-time = "2025-09-25T21:32:07.367Z" }, + { url = "https://files.pythonhosted.org/packages/45/91/47a6e1c42d9ee337c4839208f30d9f09caa9f720ec7582917b264defc875/pyyaml-6.0.3-cp311-cp311-win32.whl", hash = "sha256:8098f252adfa6c80ab48096053f512f2321f0b998f98150cea9bd23d83e1467b", size = 142543, upload-time = "2025-09-25T21:32:08.95Z" }, + { url = "https://files.pythonhosted.org/packages/da/e3/ea007450a105ae919a72393cb06f122f288ef60bba2dc64b26e2646fa315/pyyaml-6.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:9f3bfb4965eb874431221a3ff3fdcddc7e74e3b07799e0e84ca4a0f867d449bf", size = 158763, upload-time = "2025-09-25T21:32:09.96Z" }, + { url = "https://files.pythonhosted.org/packages/d1/33/422b98d2195232ca1826284a76852ad5a86fe23e31b009c9886b2d0fb8b2/pyyaml-6.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7f047e29dcae44602496db43be01ad42fc6f1cc0d8cd6c83d342306c32270196", size = 182063, upload-time = "2025-09-25T21:32:11.445Z" }, + { url = "https://files.pythonhosted.org/packages/89/a0/6cf41a19a1f2f3feab0e9c0b74134aa2ce6849093d5517a0c550fe37a648/pyyaml-6.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:fc09d0aa354569bc501d4e787133afc08552722d3ab34836a80547331bb5d4a0", size = 173973, upload-time = "2025-09-25T21:32:12.492Z" }, + { url = "https://files.pythonhosted.org/packages/ed/23/7a778b6bd0b9a8039df8b1b1d80e2e2ad78aa04171592c8a5c43a56a6af4/pyyaml-6.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9149cad251584d5fb4981be1ecde53a1ca46c891a79788c0df828d2f166bda28", size = 775116, upload-time = "2025-09-25T21:32:13.652Z" }, + { url = "https://files.pythonhosted.org/packages/65/30/d7353c338e12baef4ecc1b09e877c1970bd3382789c159b4f89d6a70dc09/pyyaml-6.0.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5fdec68f91a0c6739b380c83b951e2c72ac0197ace422360e6d5a959d8d97b2c", size = 844011, upload-time = "2025-09-25T21:32:15.21Z" }, + { url = "https://files.pythonhosted.org/packages/8b/9d/b3589d3877982d4f2329302ef98a8026e7f4443c765c46cfecc8858c6b4b/pyyaml-6.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ba1cc08a7ccde2d2ec775841541641e4548226580ab850948cbfda66a1befcdc", size = 807870, upload-time = "2025-09-25T21:32:16.431Z" }, + { url = "https://files.pythonhosted.org/packages/05/c0/b3be26a015601b822b97d9149ff8cb5ead58c66f981e04fedf4e762f4bd4/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8dc52c23056b9ddd46818a57b78404882310fb473d63f17b07d5c40421e47f8e", size = 761089, upload-time = "2025-09-25T21:32:17.56Z" }, + { url = "https://files.pythonhosted.org/packages/be/8e/98435a21d1d4b46590d5459a22d88128103f8da4c2d4cb8f14f2a96504e1/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:41715c910c881bc081f1e8872880d3c650acf13dfa8214bad49ed4cede7c34ea", size = 790181, upload-time = "2025-09-25T21:32:18.834Z" }, + { url = "https://files.pythonhosted.org/packages/74/93/7baea19427dcfbe1e5a372d81473250b379f04b1bd3c4c5ff825e2327202/pyyaml-6.0.3-cp312-cp312-win32.whl", hash = "sha256:96b533f0e99f6579b3d4d4995707cf36df9100d67e0c8303a0c55b27b5f99bc5", size = 137658, upload-time = "2025-09-25T21:32:20.209Z" }, + { url = "https://files.pythonhosted.org/packages/86/bf/899e81e4cce32febab4fb42bb97dcdf66bc135272882d1987881a4b519e9/pyyaml-6.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:5fcd34e47f6e0b794d17de1b4ff496c00986e1c83f7ab2fb8fcfe9616ff7477b", size = 154003, upload-time = "2025-09-25T21:32:21.167Z" }, + { url = "https://files.pythonhosted.org/packages/1a/08/67bd04656199bbb51dbed1439b7f27601dfb576fb864099c7ef0c3e55531/pyyaml-6.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:64386e5e707d03a7e172c0701abfb7e10f0fb753ee1d773128192742712a98fd", size = 140344, upload-time = "2025-09-25T21:32:22.617Z" }, + { url = "https://files.pythonhosted.org/packages/d1/11/0fd08f8192109f7169db964b5707a2f1e8b745d4e239b784a5a1dd80d1db/pyyaml-6.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8da9669d359f02c0b91ccc01cac4a67f16afec0dac22c2ad09f46bee0697eba8", size = 181669, upload-time = "2025-09-25T21:32:23.673Z" }, + { url = "https://files.pythonhosted.org/packages/b1/16/95309993f1d3748cd644e02e38b75d50cbc0d9561d21f390a76242ce073f/pyyaml-6.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:2283a07e2c21a2aa78d9c4442724ec1eb15f5e42a723b99cb3d822d48f5f7ad1", size = 173252, upload-time = "2025-09-25T21:32:25.149Z" }, + { url = "https://files.pythonhosted.org/packages/50/31/b20f376d3f810b9b2371e72ef5adb33879b25edb7a6d072cb7ca0c486398/pyyaml-6.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ee2922902c45ae8ccada2c5b501ab86c36525b883eff4255313a253a3160861c", size = 767081, upload-time = "2025-09-25T21:32:26.575Z" }, + { url = "https://files.pythonhosted.org/packages/49/1e/a55ca81e949270d5d4432fbbd19dfea5321eda7c41a849d443dc92fd1ff7/pyyaml-6.0.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a33284e20b78bd4a18c8c2282d549d10bc8408a2a7ff57653c0cf0b9be0afce5", size = 841159, upload-time = "2025-09-25T21:32:27.727Z" }, + { url = "https://files.pythonhosted.org/packages/74/27/e5b8f34d02d9995b80abcef563ea1f8b56d20134d8f4e5e81733b1feceb2/pyyaml-6.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0f29edc409a6392443abf94b9cf89ce99889a1dd5376d94316ae5145dfedd5d6", size = 801626, upload-time = "2025-09-25T21:32:28.878Z" }, + { url = "https://files.pythonhosted.org/packages/f9/11/ba845c23988798f40e52ba45f34849aa8a1f2d4af4b798588010792ebad6/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f7057c9a337546edc7973c0d3ba84ddcdf0daa14533c2065749c9075001090e6", size = 753613, upload-time = "2025-09-25T21:32:30.178Z" }, + { url = "https://files.pythonhosted.org/packages/3d/e0/7966e1a7bfc0a45bf0a7fb6b98ea03fc9b8d84fa7f2229e9659680b69ee3/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:eda16858a3cab07b80edaf74336ece1f986ba330fdb8ee0d6c0d68fe82bc96be", size = 794115, upload-time = "2025-09-25T21:32:31.353Z" }, + { url = "https://files.pythonhosted.org/packages/de/94/980b50a6531b3019e45ddeada0626d45fa85cbe22300844a7983285bed3b/pyyaml-6.0.3-cp313-cp313-win32.whl", hash = "sha256:d0eae10f8159e8fdad514efdc92d74fd8d682c933a6dd088030f3834bc8e6b26", size = 137427, upload-time = "2025-09-25T21:32:32.58Z" }, + { url = "https://files.pythonhosted.org/packages/97/c9/39d5b874e8b28845e4ec2202b5da735d0199dbe5b8fb85f91398814a9a46/pyyaml-6.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:79005a0d97d5ddabfeeea4cf676af11e647e41d81c9a7722a193022accdb6b7c", size = 154090, upload-time = "2025-09-25T21:32:33.659Z" }, + { url = "https://files.pythonhosted.org/packages/73/e8/2bdf3ca2090f68bb3d75b44da7bbc71843b19c9f2b9cb9b0f4ab7a5a4329/pyyaml-6.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:5498cd1645aa724a7c71c8f378eb29ebe23da2fc0d7a08071d89469bf1d2defb", size = 140246, upload-time = "2025-09-25T21:32:34.663Z" }, + { url = "https://files.pythonhosted.org/packages/9d/8c/f4bd7f6465179953d3ac9bc44ac1a8a3e6122cf8ada906b4f96c60172d43/pyyaml-6.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:8d1fab6bb153a416f9aeb4b8763bc0f22a5586065f86f7664fc23339fc1c1fac", size = 181814, upload-time = "2025-09-25T21:32:35.712Z" }, + { url = "https://files.pythonhosted.org/packages/bd/9c/4d95bb87eb2063d20db7b60faa3840c1b18025517ae857371c4dd55a6b3a/pyyaml-6.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:34d5fcd24b8445fadc33f9cf348c1047101756fd760b4dacb5c3e99755703310", size = 173809, upload-time = "2025-09-25T21:32:36.789Z" }, + { url = "https://files.pythonhosted.org/packages/92/b5/47e807c2623074914e29dabd16cbbdd4bf5e9b2db9f8090fa64411fc5382/pyyaml-6.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:501a031947e3a9025ed4405a168e6ef5ae3126c59f90ce0cd6f2bfc477be31b7", size = 766454, upload-time = "2025-09-25T21:32:37.966Z" }, + { url = "https://files.pythonhosted.org/packages/02/9e/e5e9b168be58564121efb3de6859c452fccde0ab093d8438905899a3a483/pyyaml-6.0.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b3bc83488de33889877a0f2543ade9f70c67d66d9ebb4ac959502e12de895788", size = 836355, upload-time = "2025-09-25T21:32:39.178Z" }, + { url = "https://files.pythonhosted.org/packages/88/f9/16491d7ed2a919954993e48aa941b200f38040928474c9e85ea9e64222c3/pyyaml-6.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c458b6d084f9b935061bc36216e8a69a7e293a2f1e68bf956dcd9e6cbcd143f5", size = 794175, upload-time = "2025-09-25T21:32:40.865Z" }, + { url = "https://files.pythonhosted.org/packages/dd/3f/5989debef34dc6397317802b527dbbafb2b4760878a53d4166579111411e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7c6610def4f163542a622a73fb39f534f8c101d690126992300bf3207eab9764", size = 755228, upload-time = "2025-09-25T21:32:42.084Z" }, + { url = "https://files.pythonhosted.org/packages/d7/ce/af88a49043cd2e265be63d083fc75b27b6ed062f5f9fd6cdc223ad62f03e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5190d403f121660ce8d1d2c1bb2ef1bd05b5f68533fc5c2ea899bd15f4399b35", size = 789194, upload-time = "2025-09-25T21:32:43.362Z" }, + { url = "https://files.pythonhosted.org/packages/23/20/bb6982b26a40bb43951265ba29d4c246ef0ff59c9fdcdf0ed04e0687de4d/pyyaml-6.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:4a2e8cebe2ff6ab7d1050ecd59c25d4c8bd7e6f400f5f82b96557ac0abafd0ac", size = 156429, upload-time = "2025-09-25T21:32:57.844Z" }, + { url = "https://files.pythonhosted.org/packages/f4/f4/a4541072bb9422c8a883ab55255f918fa378ecf083f5b85e87fc2b4eda1b/pyyaml-6.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:93dda82c9c22deb0a405ea4dc5f2d0cda384168e466364dec6255b293923b2f3", size = 143912, upload-time = "2025-09-25T21:32:59.247Z" }, + { url = "https://files.pythonhosted.org/packages/7c/f9/07dd09ae774e4616edf6cda684ee78f97777bdd15847253637a6f052a62f/pyyaml-6.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:02893d100e99e03eda1c8fd5c441d8c60103fd175728e23e431db1b589cf5ab3", size = 189108, upload-time = "2025-09-25T21:32:44.377Z" }, + { url = "https://files.pythonhosted.org/packages/4e/78/8d08c9fb7ce09ad8c38ad533c1191cf27f7ae1effe5bb9400a46d9437fcf/pyyaml-6.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c1ff362665ae507275af2853520967820d9124984e0f7466736aea23d8611fba", size = 183641, upload-time = "2025-09-25T21:32:45.407Z" }, + { url = "https://files.pythonhosted.org/packages/7b/5b/3babb19104a46945cf816d047db2788bcaf8c94527a805610b0289a01c6b/pyyaml-6.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6adc77889b628398debc7b65c073bcb99c4a0237b248cacaf3fe8a557563ef6c", size = 831901, upload-time = "2025-09-25T21:32:48.83Z" }, + { url = "https://files.pythonhosted.org/packages/8b/cc/dff0684d8dc44da4d22a13f35f073d558c268780ce3c6ba1b87055bb0b87/pyyaml-6.0.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a80cb027f6b349846a3bf6d73b5e95e782175e52f22108cfa17876aaeff93702", size = 861132, upload-time = "2025-09-25T21:32:50.149Z" }, + { url = "https://files.pythonhosted.org/packages/b1/5e/f77dc6b9036943e285ba76b49e118d9ea929885becb0a29ba8a7c75e29fe/pyyaml-6.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:00c4bdeba853cc34e7dd471f16b4114f4162dc03e6b7afcc2128711f0eca823c", size = 839261, upload-time = "2025-09-25T21:32:51.808Z" }, + { url = "https://files.pythonhosted.org/packages/ce/88/a9db1376aa2a228197c58b37302f284b5617f56a5d959fd1763fb1675ce6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:66e1674c3ef6f541c35191caae2d429b967b99e02040f5ba928632d9a7f0f065", size = 805272, upload-time = "2025-09-25T21:32:52.941Z" }, + { url = "https://files.pythonhosted.org/packages/da/92/1446574745d74df0c92e6aa4a7b0b3130706a4142b2d1a5869f2eaa423c6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:16249ee61e95f858e83976573de0f5b2893b3677ba71c9dd36b9cf8be9ac6d65", size = 829923, upload-time = "2025-09-25T21:32:54.537Z" }, + { url = "https://files.pythonhosted.org/packages/f0/7a/1c7270340330e575b92f397352af856a8c06f230aa3e76f86b39d01b416a/pyyaml-6.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4ad1906908f2f5ae4e5a8ddfce73c320c2a1429ec52eafd27138b7f1cbe341c9", size = 174062, upload-time = "2025-09-25T21:32:55.767Z" }, + { url = "https://files.pythonhosted.org/packages/f1/12/de94a39c2ef588c7e6455cfbe7343d3b2dc9d6b6b2f40c4c6565744c873d/pyyaml-6.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:ebc55a14a21cb14062aa4162f906cd962b28e2e9ea38f9b4391244cd8de4ae0b", size = 149341, upload-time = "2025-09-25T21:32:56.828Z" }, +] + +[[package]] +name = "requests" +version = "2.34.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "certifi" }, + { name = "charset-normalizer" }, + { name = "idna" }, + { name = "urllib3" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ac/c3/e2a2b89f2d3e2179abd6d00ebd70bff6273f37fb3e0cc209f48b39d00cbf/requests-2.34.2.tar.gz", hash = "sha256:f288924cae4e29463698d6d60bc6a4da69c89185ad1e0bcc4104f584e960b9ed", size = 142856, upload-time = "2026-05-14T19:25:27.735Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a0/f4/c67b0b3f1b9245e8d266f0f112c500d50e5b4e83cb6f3b71b6528104182a/requests-2.34.2-py3-none-any.whl", hash = "sha256:2a0d60c172f83ac6ab31e4554906c0f3b3588d37b5cb939b1c061f4907e278e0", size = 73075, upload-time = "2026-05-14T19:25:26.443Z" }, +] + +[[package]] +name = "ruff" +version = "0.1.15" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/42/33/7165f88a156be1c2fd13a18b3af6e75bbf82da5b6978cd2128d666accc18/ruff-0.1.15.tar.gz", hash = "sha256:f6dfa8c1b21c913c326919056c390966648b680966febcb796cc9d1aaab8564e", size = 1971643, upload-time = "2024-01-29T23:06:05.541Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/11/2c/fac0658910ea3ea87a23583e58277533154261b73f9460388eb2e6e02e8f/ruff-0.1.15-py3-none-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:5fe8d54df166ecc24106db7dd6a68d44852d14eb0729ea4672bb4d96c320b7df", size = 14357437, upload-time = "2024-01-29T23:05:04.991Z" }, + { url = "https://files.pythonhosted.org/packages/5b/c1/2116927385c761ffb786dfb77654a634ecd7803dee4de3b47b59536374f1/ruff-0.1.15-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:6f0bfbb53c4b4de117ac4d6ddfd33aa5fc31beeaa21d23c45c6dd249faf9126f", size = 7329669, upload-time = "2024-01-29T23:05:12.437Z" }, + { url = "https://files.pythonhosted.org/packages/18/d7/2199ecb42cef4d70de0e72ce4ca8878d060e25fe4434cb66f51e26158a2a/ruff-0.1.15-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e0d432aec35bfc0d800d4f70eba26e23a352386be3a6cf157083d18f6f5881c8", size = 7137343, upload-time = "2024-01-29T23:05:16.159Z" }, + { url = "https://files.pythonhosted.org/packages/bb/e0/8a6f9db2c5b8c7108c7e7347cd6beca805d1b2ae618569c72f2515d11e52/ruff-0.1.15-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:9405fa9ac0e97f35aaddf185a1be194a589424b8713e3b97b762336ec79ff807", size = 6563223, upload-time = "2024-01-29T23:05:19.687Z" }, + { url = "https://files.pythonhosted.org/packages/98/fa/2a627747a5a5f7e1d3447704f795fd35d486460838485762cd569ef8eb0e/ruff-0.1.15-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c66ec24fe36841636e814b8f90f572a8c0cb0e54d8b5c2d0e300d28a0d7bffec", size = 7534853, upload-time = "2024-01-29T23:05:23.18Z" }, + { url = "https://files.pythonhosted.org/packages/55/09/c09d0f9b41d1f5e3de117579f2fcdb7063fd76cd92d6614eae1b77ccbccb/ruff-0.1.15-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:6f8ad828f01e8dd32cc58bc28375150171d198491fc901f6f98d2a39ba8e3ff5", size = 8168826, upload-time = "2024-01-29T23:05:26.544Z" }, + { url = "https://files.pythonhosted.org/packages/72/48/c9dfc2c87dc6b92446d8092c2be25b42ca4fb201cecb2499996ccf483c34/ruff-0.1.15-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:86811954eec63e9ea162af0ffa9f8d09088bab51b7438e8b6488b9401863c25e", size = 7942963, upload-time = "2024-01-29T23:05:30.655Z" }, + { url = "https://files.pythonhosted.org/packages/0c/57/dbc885f94450335fcff82301c4b25cf614894e79d9afbd249714e709ab42/ruff-0.1.15-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:fd4025ac5e87d9b80e1f300207eb2fd099ff8200fa2320d7dc066a3f4622dc6b", size = 8524998, upload-time = "2024-01-29T23:05:34.503Z" }, + { url = "https://files.pythonhosted.org/packages/39/75/8dea2fc156ae525971fdada8723f78e605dcf89428f5686728438b12f9ef/ruff-0.1.15-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b17b93c02cdb6aeb696effecea1095ac93f3884a49a554a9afa76bb125c114c1", size = 7534144, upload-time = "2024-01-29T23:05:38.642Z" }, + { url = "https://files.pythonhosted.org/packages/47/41/96b770475c46590bfd051ca0c5f797b2d45f2638c45f3a9daf1ae55b96d6/ruff-0.1.15-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:ddb87643be40f034e97e97f5bc2ef7ce39de20e34608f3f829db727a93fb82c5", size = 7055002, upload-time = "2024-01-29T23:05:41.955Z" }, + { url = "https://files.pythonhosted.org/packages/e8/ca/4066dbcc3631a4efe1fe695f42f20aca50474d760b3bd8e57d7565d75aa5/ruff-0.1.15-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:abf4822129ed3a5ce54383d5f0e964e7fef74a41e48eb1dfad404151efc130a2", size = 6552130, upload-time = "2024-01-29T23:05:45.487Z" }, + { url = "https://files.pythonhosted.org/packages/b8/85/da93f0fc8f2424cf776fcce6daef9291162345179d16faf1401ff2890068/ruff-0.1.15-py3-none-musllinux_1_2_i686.whl", hash = "sha256:6c629cf64bacfd136c07c78ac10a54578ec9d1bd2a9d395efbee0935868bf852", size = 7214386, upload-time = "2024-01-29T23:05:48.346Z" }, + { url = "https://files.pythonhosted.org/packages/e5/bf/de34ad339e0d1f6faa858cbcf793f3abc168b7aa516dd9227d843b992be8/ruff-0.1.15-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:1bab866aafb53da39c2cadfb8e1c4550ac5340bb40300083eb8967ba25481447", size = 7602787, upload-time = "2024-01-29T23:05:51.341Z" }, + { url = "https://files.pythonhosted.org/packages/8d/61/ffdccecb0b39521d7060d6a6bc33c53d7f20d48d3511d6333cb01f26e979/ruff-0.1.15-py3-none-win32.whl", hash = "sha256:2417e1cb6e2068389b07e6fa74c306b2810fe3ee3476d5b8a96616633f40d14f", size = 6670488, upload-time = "2024-01-29T23:05:54.454Z" }, + { url = "https://files.pythonhosted.org/packages/2b/5f/3ba51cc770ed2b2df88efc32bba26759e6ac5c6149319a60913a85230936/ruff-0.1.15-py3-none-win_amd64.whl", hash = "sha256:3837ac73d869efc4182d9036b1405ef4c73d9b1f88da2413875e34e0d6919587", size = 7319395, upload-time = "2024-01-29T23:05:58.135Z" }, + { url = "https://files.pythonhosted.org/packages/c9/bd/c196493563d6bf8fe960f10b83926a3fae3a43a96eac6b263aecb96c61d7/ruff-0.1.15-py3-none-win_arm64.whl", hash = "sha256:9a933dfb1c14ec7a33cceb1e49ec4a16b51ce3c20fd42663198746efc0427360", size = 6998592, upload-time = "2024-01-29T23:06:01.904Z" }, +] + +[[package]] +name = "tomli" +version = "2.4.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/22/de/48c59722572767841493b26183a0d1cc411d54fd759c5607c4590b6563a6/tomli-2.4.1.tar.gz", hash = "sha256:7c7e1a961a0b2f2472c1ac5b69affa0ae1132c39adcb67aba98568702b9cc23f", size = 17543, upload-time = "2026-03-25T20:22:03.828Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f4/11/db3d5885d8528263d8adc260bb2d28ebf1270b96e98f0e0268d32b8d9900/tomli-2.4.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:f8f0fc26ec2cc2b965b7a3b87cd19c5c6b8c5e5f436b984e85f486d652285c30", size = 154704, upload-time = "2026-03-25T20:21:10.473Z" }, + { url = "https://files.pythonhosted.org/packages/6d/f7/675db52c7e46064a9aa928885a9b20f4124ecb9bc2e1ce74c9106648d202/tomli-2.4.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:4ab97e64ccda8756376892c53a72bd1f964e519c77236368527f758fbc36a53a", size = 149454, upload-time = "2026-03-25T20:21:12.036Z" }, + { url = "https://files.pythonhosted.org/packages/61/71/81c50943cf953efa35bce7646caab3cf457a7d8c030b27cfb40d7235f9ee/tomli-2.4.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:96481a5786729fd470164b47cdb3e0e58062a496f455ee41b4403be77cb5a076", size = 237561, upload-time = "2026-03-25T20:21:13.098Z" }, + { url = "https://files.pythonhosted.org/packages/48/c1/f41d9cb618acccca7df82aaf682f9b49013c9397212cb9f53219e3abac37/tomli-2.4.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5a881ab208c0baf688221f8cecc5401bd291d67e38a1ac884d6736cbcd8247e9", size = 243824, upload-time = "2026-03-25T20:21:14.569Z" }, + { url = "https://files.pythonhosted.org/packages/22/e4/5a816ecdd1f8ca51fb756ef684b90f2780afc52fc67f987e3c61d800a46d/tomli-2.4.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:47149d5bd38761ac8be13a84864bf0b7b70bc051806bc3669ab1cbc56216b23c", size = 242227, upload-time = "2026-03-25T20:21:15.712Z" }, + { url = "https://files.pythonhosted.org/packages/6b/49/2b2a0ef529aa6eec245d25f0c703e020a73955ad7edf73e7f54ddc608aa5/tomli-2.4.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:ec9bfaf3ad2df51ace80688143a6a4ebc09a248f6ff781a9945e51937008fcbc", size = 247859, upload-time = "2026-03-25T20:21:17.001Z" }, + { url = "https://files.pythonhosted.org/packages/83/bd/6c1a630eaca337e1e78c5903104f831bda934c426f9231429396ce3c3467/tomli-2.4.1-cp311-cp311-win32.whl", hash = "sha256:ff2983983d34813c1aeb0fa89091e76c3a22889ee83ab27c5eeb45100560c049", size = 97204, upload-time = "2026-03-25T20:21:18.079Z" }, + { url = "https://files.pythonhosted.org/packages/42/59/71461df1a885647e10b6bb7802d0b8e66480c61f3f43079e0dcd315b3954/tomli-2.4.1-cp311-cp311-win_amd64.whl", hash = "sha256:5ee18d9ebdb417e384b58fe414e8d6af9f4e7a0ae761519fb50f721de398dd4e", size = 108084, upload-time = "2026-03-25T20:21:18.978Z" }, + { url = "https://files.pythonhosted.org/packages/b8/83/dceca96142499c069475b790e7913b1044c1a4337e700751f48ed723f883/tomli-2.4.1-cp311-cp311-win_arm64.whl", hash = "sha256:c2541745709bad0264b7d4705ad453b76ccd191e64aa6f0fc66b69a293a45ece", size = 95285, upload-time = "2026-03-25T20:21:20.309Z" }, + { url = "https://files.pythonhosted.org/packages/c1/ba/42f134a3fe2b370f555f44b1d72feebb94debcab01676bf918d0cb70e9aa/tomli-2.4.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:c742f741d58a28940ce01d58f0ab2ea3ced8b12402f162f4d534dfe18ba1cd6a", size = 155924, upload-time = "2026-03-25T20:21:21.626Z" }, + { url = "https://files.pythonhosted.org/packages/dc/c7/62d7a17c26487ade21c5422b646110f2162f1fcc95980ef7f63e73c68f14/tomli-2.4.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:7f86fd587c4ed9dd76f318225e7d9b29cfc5a9d43de44e5754db8d1128487085", size = 150018, upload-time = "2026-03-25T20:21:23.002Z" }, + { url = "https://files.pythonhosted.org/packages/5c/05/79d13d7c15f13bdef410bdd49a6485b1c37d28968314eabee452c22a7fda/tomli-2.4.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ff18e6a727ee0ab0388507b89d1bc6a22b138d1e2fa56d1ad494586d61d2eae9", size = 244948, upload-time = "2026-03-25T20:21:24.04Z" }, + { url = "https://files.pythonhosted.org/packages/10/90/d62ce007a1c80d0b2c93e02cab211224756240884751b94ca72df8a875ca/tomli-2.4.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:136443dbd7e1dee43c68ac2694fde36b2849865fa258d39bf822c10e8068eac5", size = 253341, upload-time = "2026-03-25T20:21:25.177Z" }, + { url = "https://files.pythonhosted.org/packages/1a/7e/caf6496d60152ad4ed09282c1885cca4eea150bfd007da84aea07bcc0a3e/tomli-2.4.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:5e262d41726bc187e69af7825504c933b6794dc3fbd5945e41a79bb14c31f585", size = 248159, upload-time = "2026-03-25T20:21:26.364Z" }, + { url = "https://files.pythonhosted.org/packages/99/e7/c6f69c3120de34bbd882c6fba7975f3d7a746e9218e56ab46a1bc4b42552/tomli-2.4.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:5cb41aa38891e073ee49d55fbc7839cfdb2bc0e600add13874d048c94aadddd1", size = 253290, upload-time = "2026-03-25T20:21:27.46Z" }, + { url = "https://files.pythonhosted.org/packages/d6/2f/4a3c322f22c5c66c4b836ec58211641a4067364f5dcdd7b974b4c5da300c/tomli-2.4.1-cp312-cp312-win32.whl", hash = "sha256:da25dc3563bff5965356133435b757a795a17b17d01dbc0f42fb32447ddfd917", size = 98141, upload-time = "2026-03-25T20:21:28.492Z" }, + { url = "https://files.pythonhosted.org/packages/24/22/4daacd05391b92c55759d55eaee21e1dfaea86ce5c571f10083360adf534/tomli-2.4.1-cp312-cp312-win_amd64.whl", hash = "sha256:52c8ef851d9a240f11a88c003eacb03c31fc1c9c4ec64a99a0f922b93874fda9", size = 108847, upload-time = "2026-03-25T20:21:29.386Z" }, + { url = "https://files.pythonhosted.org/packages/68/fd/70e768887666ddd9e9f5d85129e84910f2db2796f9096aa02b721a53098d/tomli-2.4.1-cp312-cp312-win_arm64.whl", hash = "sha256:f758f1b9299d059cc3f6546ae2af89670cb1c4d48ea29c3cacc4fe7de3058257", size = 95088, upload-time = "2026-03-25T20:21:30.677Z" }, + { url = "https://files.pythonhosted.org/packages/07/06/b823a7e818c756d9a7123ba2cda7d07bc2dd32835648d1a7b7b7a05d848d/tomli-2.4.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:36d2bd2ad5fb9eaddba5226aa02c8ec3fa4f192631e347b3ed28186d43be6b54", size = 155866, upload-time = "2026-03-25T20:21:31.65Z" }, + { url = "https://files.pythonhosted.org/packages/14/6f/12645cf7f08e1a20c7eb8c297c6f11d31c1b50f316a7e7e1e1de6e2e7b7e/tomli-2.4.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:eb0dc4e38e6a1fd579e5d50369aa2e10acfc9cace504579b2faabb478e76941a", size = 149887, upload-time = "2026-03-25T20:21:33.028Z" }, + { url = "https://files.pythonhosted.org/packages/5c/e0/90637574e5e7212c09099c67ad349b04ec4d6020324539297b634a0192b0/tomli-2.4.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c7f2c7f2b9ca6bdeef8f0fa897f8e05085923eb091721675170254cbc5b02897", size = 243704, upload-time = "2026-03-25T20:21:34.51Z" }, + { url = "https://files.pythonhosted.org/packages/10/8f/d3ddb16c5a4befdf31a23307f72828686ab2096f068eaf56631e136c1fdd/tomli-2.4.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f3c6818a1a86dd6dca7ddcaaf76947d5ba31aecc28cb1b67009a5877c9a64f3f", size = 251628, upload-time = "2026-03-25T20:21:36.012Z" }, + { url = "https://files.pythonhosted.org/packages/e3/f1/dbeeb9116715abee2485bf0a12d07a8f31af94d71608c171c45f64c0469d/tomli-2.4.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:d312ef37c91508b0ab2cee7da26ec0b3ed2f03ce12bd87a588d771ae15dcf82d", size = 247180, upload-time = "2026-03-25T20:21:37.136Z" }, + { url = "https://files.pythonhosted.org/packages/d3/74/16336ffd19ed4da28a70959f92f506233bd7cfc2332b20bdb01591e8b1d1/tomli-2.4.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:51529d40e3ca50046d7606fa99ce3956a617f9b36380da3b7f0dd3dd28e68cb5", size = 251674, upload-time = "2026-03-25T20:21:38.298Z" }, + { url = "https://files.pythonhosted.org/packages/16/f9/229fa3434c590ddf6c0aa9af64d3af4b752540686cace29e6281e3458469/tomli-2.4.1-cp313-cp313-win32.whl", hash = "sha256:2190f2e9dd7508d2a90ded5ed369255980a1bcdd58e52f7fe24b8162bf9fedbd", size = 97976, upload-time = "2026-03-25T20:21:39.316Z" }, + { url = "https://files.pythonhosted.org/packages/6a/1e/71dfd96bcc1c775420cb8befe7a9d35f2e5b1309798f009dca17b7708c1e/tomli-2.4.1-cp313-cp313-win_amd64.whl", hash = "sha256:8d65a2fbf9d2f8352685bc1364177ee3923d6baf5e7f43ea4959d7d8bc326a36", size = 108755, upload-time = "2026-03-25T20:21:40.248Z" }, + { url = "https://files.pythonhosted.org/packages/83/7a/d34f422a021d62420b78f5c538e5b102f62bea616d1d75a13f0a88acb04a/tomli-2.4.1-cp313-cp313-win_arm64.whl", hash = "sha256:4b605484e43cdc43f0954ddae319fb75f04cc10dd80d830540060ee7cd0243cd", size = 95265, upload-time = "2026-03-25T20:21:41.219Z" }, + { url = "https://files.pythonhosted.org/packages/3c/fb/9a5c8d27dbab540869f7c1f8eb0abb3244189ce780ba9cd73f3770662072/tomli-2.4.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:fd0409a3653af6c147209d267a0e4243f0ae46b011aa978b1080359fddc9b6cf", size = 155726, upload-time = "2026-03-25T20:21:42.23Z" }, + { url = "https://files.pythonhosted.org/packages/62/05/d2f816630cc771ad836af54f5001f47a6f611d2d39535364f148b6a92d6b/tomli-2.4.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:a120733b01c45e9a0c34aeef92bf0cf1d56cfe81ed9d47d562f9ed591a9828ac", size = 149859, upload-time = "2026-03-25T20:21:43.386Z" }, + { url = "https://files.pythonhosted.org/packages/ce/48/66341bdb858ad9bd0ceab5a86f90eddab127cf8b046418009f2125630ecb/tomli-2.4.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:559db847dc486944896521f68d8190be1c9e719fced785720d2216fe7022b662", size = 244713, upload-time = "2026-03-25T20:21:44.474Z" }, + { url = "https://files.pythonhosted.org/packages/df/6d/c5fad00d82b3c7a3ab6189bd4b10e60466f22cfe8a08a9394185c8a8111c/tomli-2.4.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:01f520d4f53ef97964a240a035ec2a869fe1a37dde002b57ebc4417a27ccd853", size = 252084, upload-time = "2026-03-25T20:21:45.62Z" }, + { url = "https://files.pythonhosted.org/packages/00/71/3a69e86f3eafe8c7a59d008d245888051005bd657760e96d5fbfb0b740c2/tomli-2.4.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7f94b27a62cfad8496c8d2513e1a222dd446f095fca8987fceef261225538a15", size = 247973, upload-time = "2026-03-25T20:21:46.937Z" }, + { url = "https://files.pythonhosted.org/packages/67/50/361e986652847fec4bd5e4a0208752fbe64689c603c7ae5ea7cb16b1c0ca/tomli-2.4.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:ede3e6487c5ef5d28634ba3f31f989030ad6af71edfb0055cbbd14189ff240ba", size = 256223, upload-time = "2026-03-25T20:21:48.467Z" }, + { url = "https://files.pythonhosted.org/packages/8c/9a/b4173689a9203472e5467217e0154b00e260621caa227b6fa01feab16998/tomli-2.4.1-cp314-cp314-win32.whl", hash = "sha256:3d48a93ee1c9b79c04bb38772ee1b64dcf18ff43085896ea460ca8dec96f35f6", size = 98973, upload-time = "2026-03-25T20:21:49.526Z" }, + { url = "https://files.pythonhosted.org/packages/14/58/640ac93bf230cd27d002462c9af0d837779f8773bc03dee06b5835208214/tomli-2.4.1-cp314-cp314-win_amd64.whl", hash = "sha256:88dceee75c2c63af144e456745e10101eb67361050196b0b6af5d717254dddf7", size = 109082, upload-time = "2026-03-25T20:21:50.506Z" }, + { url = "https://files.pythonhosted.org/packages/d5/2f/702d5e05b227401c1068f0d386d79a589bb12bf64c3d2c72ce0631e3bc49/tomli-2.4.1-cp314-cp314-win_arm64.whl", hash = "sha256:b8c198f8c1805dc42708689ed6864951fd2494f924149d3e4bce7710f8eb5232", size = 96490, upload-time = "2026-03-25T20:21:51.474Z" }, + { url = "https://files.pythonhosted.org/packages/45/4b/b877b05c8ba62927d9865dd980e34a755de541eb65fffba52b4cc495d4d2/tomli-2.4.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:d4d8fe59808a54658fcc0160ecfb1b30f9089906c50b23bcb4c69eddc19ec2b4", size = 164263, upload-time = "2026-03-25T20:21:52.543Z" }, + { url = "https://files.pythonhosted.org/packages/24/79/6ab420d37a270b89f7195dec5448f79400d9e9c1826df982f3f8e97b24fd/tomli-2.4.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:7008df2e7655c495dd12d2a4ad038ff878d4ca4b81fccaf82b714e07eae4402c", size = 160736, upload-time = "2026-03-25T20:21:53.674Z" }, + { url = "https://files.pythonhosted.org/packages/02/e0/3630057d8eb170310785723ed5adcdfb7d50cb7e6455f85ba8a3deed642b/tomli-2.4.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1d8591993e228b0c930c4bb0db464bdad97b3289fb981255d6c9a41aedc84b2d", size = 270717, upload-time = "2026-03-25T20:21:55.129Z" }, + { url = "https://files.pythonhosted.org/packages/7a/b4/1613716072e544d1a7891f548d8f9ec6ce2faf42ca65acae01d76ea06bb0/tomli-2.4.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:734e20b57ba95624ecf1841e72b53f6e186355e216e5412de414e3c51e5e3c41", size = 278461, upload-time = "2026-03-25T20:21:56.228Z" }, + { url = "https://files.pythonhosted.org/packages/05/38/30f541baf6a3f6df77b3df16b01ba319221389e2da59427e221ef417ac0c/tomli-2.4.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:8a650c2dbafa08d42e51ba0b62740dae4ecb9338eefa093aa5c78ceb546fcd5c", size = 274855, upload-time = "2026-03-25T20:21:57.653Z" }, + { url = "https://files.pythonhosted.org/packages/77/a3/ec9dd4fd2c38e98de34223b995a3b34813e6bdadf86c75314c928350ed14/tomli-2.4.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:504aa796fe0569bb43171066009ead363de03675276d2d121ac1a4572397870f", size = 283144, upload-time = "2026-03-25T20:21:59.089Z" }, + { url = "https://files.pythonhosted.org/packages/ef/be/605a6261cac79fba2ec0c9827e986e00323a1945700969b8ee0b30d85453/tomli-2.4.1-cp314-cp314t-win32.whl", hash = "sha256:b1d22e6e9387bf4739fbe23bfa80e93f6b0373a7f1b96c6227c32bef95a4d7a8", size = 108683, upload-time = "2026-03-25T20:22:00.214Z" }, + { url = "https://files.pythonhosted.org/packages/12/64/da524626d3b9cc40c168a13da8335fe1c51be12c0a63685cc6db7308daae/tomli-2.4.1-cp314-cp314t-win_amd64.whl", hash = "sha256:2c1c351919aca02858f740c6d33adea0c5deea37f9ecca1cc1ef9e884a619d26", size = 121196, upload-time = "2026-03-25T20:22:01.169Z" }, + { url = "https://files.pythonhosted.org/packages/5a/cd/e80b62269fc78fc36c9af5a6b89c835baa8af28ff5ad28c7028d60860320/tomli-2.4.1-cp314-cp314t-win_arm64.whl", hash = "sha256:eab21f45c7f66c13f2a9e0e1535309cee140182a9cdae1e041d02e47291e8396", size = 100393, upload-time = "2026-03-25T20:22:02.137Z" }, + { url = "https://files.pythonhosted.org/packages/7b/61/cceae43728b7de99d9b847560c262873a1f6c98202171fd5ed62640b494b/tomli-2.4.1-py3-none-any.whl", hash = "sha256:0d85819802132122da43cb86656f8d1f8c6587d54ae7dcaf30e90533028b49fe", size = 14583, upload-time = "2026-03-25T20:22:03.012Z" }, +] + +[[package]] +name = "types-requests" +version = "2.33.0.20260712" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "urllib3" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/db/51/703318f7b7be8bee126ec13bf615050f932d0179b8784420f3a0199cc769/types_requests-2.33.0.20260712.tar.gz", hash = "sha256:2141b67ab534a5c5cd2dac5034f2a35f42e699c5bf185eee608c5246a069d7fb", size = 25084, upload-time = "2026-07-12T05:14:20.455Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/62/e7/010c87f559e216d83f9dc51e939633fd0d0ead3377340181ab0e223cd3b5/types_requests-2.33.0.20260712-py3-none-any.whl", hash = "sha256:de027e28c171d3da529689cbfa023b0b4eab188c8dfa22fd834eebd2cee6e7bb", size = 21392, upload-time = "2026-07-12T05:14:19.616Z" }, +] + +[[package]] +name = "typing-extensions" +version = "4.16.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f6/cc/6253133b5bb138fc3306cebfbda2c520f545d36b5be2c7255cc528bb45d6/typing_extensions-4.16.0.tar.gz", hash = "sha256:dc983d19a509c94dba722ee6abd33940f7c05a89e243c47e907eb4db6f1a43e5", size = 113555, upload-time = "2026-07-02T08:40:05.92Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/49/d3/b8441a820a491ddfc024b0b0cf0393375b75ea13866d9c66727e54c2fc80/typing_extensions-4.16.0-py3-none-any.whl", hash = "sha256:481caa481374e813c1b176ada14e97f1f67a4539ce9cfeb3f350d78d6370c2e8", size = 45571, upload-time = "2026-07-02T08:40:04.659Z" }, +] + +[[package]] +name = "urllib3" +version = "2.7.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/53/0c/06f8b233b8fd13b9e5ee11424ef85419ba0d8ba0b3138bf360be2ff56953/urllib3-2.7.0.tar.gz", hash = "sha256:231e0ec3b63ceb14667c67be60f2f2c40a518cb38b03af60abc813da26505f4c", size = 433602, upload-time = "2026-05-07T16:13:18.596Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7f/3e/5db95bcf282c52709639744ca2a8b149baccf648e39c8cc87553df9eae0c/urllib3-2.7.0-py3-none-any.whl", hash = "sha256:9fb4c81ebbb1ce9531cce37674bbc6f1360472bc18ca9a553ede278ef7276897", size = 131087, upload-time = "2026-05-07T16:13:17.151Z" }, +] + +[[package]] +name = "virtualenv" +version = "21.7.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "distlib" }, + { name = "filelock" }, + { name = "platformdirs" }, + { name = "python-discovery" }, + { name = "typing-extensions", marker = "python_full_version < '3.11'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/2d/dc/a6eb1ddfa7f1e390fa599b078453c97edb3f6f846b34fb4eac3e8ea16401/virtualenv-21.7.4.tar.gz", hash = "sha256:c9d960c95fa458171e58222a5ccab7465298e4b6559977865e627c4719f1e825", size = 5345511, upload-time = "2026-08-10T22:54:33.316Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/40/4c/eb2f52aeeaf30dbd073d315a251a63ae2b8263171ec4428c135140cb0802/virtualenv-21.7.4-py3-none-any.whl", hash = "sha256:376ec93cd6aab3044fa395d7db226db38043b7b5748948044b2a87168525e843", size = 5324444, upload-time = "2026-08-10T22:54:31.515Z" }, +] From 430fb2fec6b9c116450a804286d57b4bacec4fb2 Mon Sep 17 00:00:00 2001 From: lovvskillz <14542790+lovvskillz@users.noreply.github.com> Date: Sun, 16 Aug 2026 16:00:20 +0200 Subject: [PATCH 4/8] use python version 3.12 --- .github/workflows/python-package.yml | 2 +- pyproject.toml | 2 +- uv.lock | 122 +-------------------------- 3 files changed, 3 insertions(+), 123 deletions(-) diff --git a/.github/workflows/python-package.yml b/.github/workflows/python-package.yml index ad92936..bf675a9 100644 --- a/.github/workflows/python-package.yml +++ b/.github/workflows/python-package.yml @@ -15,7 +15,7 @@ jobs: strategy: fail-fast: false matrix: - python-version: ["3.10", "3.11"] + python-version: ["3.12", "3.13"] steps: - uses: actions/checkout@v4 diff --git a/pyproject.toml b/pyproject.toml index 9fb7e78..8695769 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -7,7 +7,7 @@ authors = [ ] license = "MIT" readme = "README.md" -requires-python = ">=3.10" +requires-python = ">=3.12" keywords = ["discord", "webhook"] dependencies = [ "requests>=2.32.3,<3", diff --git a/uv.lock b/uv.lock index 474e83d..e79f1c8 100644 --- a/uv.lock +++ b/uv.lock @@ -1,13 +1,12 @@ version = 1 revision = 3 -requires-python = ">=3.10" +requires-python = ">=3.12" [[package]] name = "anyio" version = "4.14.2" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "exceptiongroup", marker = "python_full_version < '3.11'" }, { name = "idna" }, { name = "typing-extensions", marker = "python_full_version < '3.13'" }, ] @@ -40,38 +39,6 @@ version = "3.5.1" source = { registry = "https://pypi.org/simple" } sdist = { url = "https://files.pythonhosted.org/packages/e5/3f/143b048436775b0f76ac3eec145c019e8173ccc2885c8f20319b996d5e83/charset_normalizer-3.5.1.tar.gz", hash = "sha256:6117b84ea48435e5356dc737f5121485c30920ba43375fa7b434fd753df0eac3", size = 171764, upload-time = "2026-08-15T08:20:44.807Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/71/aa/554e2614f38fc34c58ff1d0911ae8535ad2516440d5482d76fe59f1088b0/charset_normalizer-3.5.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:d1ee1e296209fdce05b81b663250eefa02213a2da7b41bf26f7829b8ba3545aa", size = 369072, upload-time = "2026-08-15T08:16:22.964Z" }, - { url = "https://files.pythonhosted.org/packages/03/6d/439231dfc3ccfa6f8c06477b7da2219cbd41a2de3d49084df8ec7b5100f2/charset_normalizer-3.5.1-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e9fbdce1e47394b09bc9f26ab117dfc8d6491977a11d86f592bb42c779db2fda", size = 251142, upload-time = "2026-08-15T08:16:24.81Z" }, - { url = "https://files.pythonhosted.org/packages/55/53/7d819bd23a00ef45039146fa2cce1daa2f0771e758c5653ee1f6edac91ed/charset_normalizer-3.5.1-cp310-cp310-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:00668ebb0609751758682eb0b5857e7c35b9f00e84dfdef062e103244ec94d45", size = 240714, upload-time = "2026-08-15T08:16:26.392Z" }, - { url = "https://files.pythonhosted.org/packages/b2/2c/45847198c16f4b38090cc7423b2b6a9008e438704d8ab413211832498d31/charset_normalizer-3.5.1-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ba2f37ee79e6338845261a3c5b1784e5d1acdff2c0785b284f1b633033d136ab", size = 279637, upload-time = "2026-08-15T08:16:27.961Z" }, - { url = "https://files.pythonhosted.org/packages/69/2b/d8be3523ddf9f0b0f3e56d1359034aa10653a4d11564c697f802b4775766/charset_normalizer-3.5.1-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:ce854f5f478050ade5a238731c4ca985a7d3b3cb53ff600a9b5c3b689b5f0a7a", size = 276543, upload-time = "2026-08-15T08:16:29.399Z" }, - { url = "https://files.pythonhosted.org/packages/32/cd/4f564b8f132de25db594efc706897069f016790cea63a5669c9df2675f64/charset_normalizer-3.5.1-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:96eefc178f8636b9c760c5829345307fd81cfae9ab1e80997dbddeb0f54ee9a3", size = 261644, upload-time = "2026-08-15T08:16:30.722Z" }, - { url = "https://files.pythonhosted.org/packages/f5/e3/38b975422534a608f98c360e79c2f07c763d66dd4272300d45fb1fee54b0/charset_normalizer-3.5.1-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:366ec70f5547c640d3ce1985722490f23faf4eb5216a7eeba78277490e78dacb", size = 259609, upload-time = "2026-08-15T08:16:32.248Z" }, - { url = "https://files.pythonhosted.org/packages/87/bd/fbc24d825c66f1c74f6ccdea3742c3d8354a4888e86d1315a197fee69061/charset_normalizer-3.5.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:950f23cb393f85543777b0433f082cddd25b51ab398eac7971146495679efe5f", size = 252457, upload-time = "2026-08-15T08:16:33.849Z" }, - { url = "https://files.pythonhosted.org/packages/b9/2d/918d0e98a0e679469ed05bb2d90c2088b4d315bb612969d8499f76fb5210/charset_normalizer-3.5.1-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:c1dcc36dcb96abc02236e182d17e0f71430152a6c2c7447421da2d2dc144edea", size = 242240, upload-time = "2026-08-15T08:16:35.396Z" }, - { url = "https://files.pythonhosted.org/packages/20/c8/c36f6e0b2dfec351bd38cbc05362697e58bcd073d7dbd95154290c9714ce/charset_normalizer-3.5.1-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:07ffd07412fc5d5e84cd8952acf9ff7e4ed7a708e69d1bada19d8ba91711353f", size = 280308, upload-time = "2026-08-15T08:16:36.825Z" }, - { url = "https://files.pythonhosted.org/packages/ca/7b/311b3e02e8c4092400c449c850a760d8c45d900983c83a70cc07208c551d/charset_normalizer-3.5.1-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:f5542f9b941279d82d41eb0aa9f98eba36fe4df5c7086c651df7944935b37182", size = 258679, upload-time = "2026-08-15T08:16:38.22Z" }, - { url = "https://files.pythonhosted.org/packages/b9/90/082cc45599c392f28c036a497f49e0634041a785fc3849c80ccf396d096f/charset_normalizer-3.5.1-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:a545775cfe815855ea32d7c27731d79da358ef2055b4a25830231b1622dd18aa", size = 277221, upload-time = "2026-08-15T08:16:39.62Z" }, - { url = "https://files.pythonhosted.org/packages/58/ad/b9aecf38d805cbcf84fa94f14c5d972a16561e20296a11dc799a5dcf3763/charset_normalizer-3.5.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:494b70049a4d69aec6e8137c13af4cf8db8c9f9820a1392ac293b0dd2987a818", size = 263799, upload-time = "2026-08-15T08:16:40.885Z" }, - { url = "https://files.pythonhosted.org/packages/b7/23/b38a20598d5a825f85d9d7636860e56ff0db1479f86497a6e485aa9326f7/charset_normalizer-3.5.1-cp310-cp310-win32.whl", hash = "sha256:94fbf1c0c6cc0d3d5e50f9a9313a8cdca90dd696d34b381cd1704f8c9e939f20", size = 182037, upload-time = "2026-08-15T08:16:42.198Z" }, - { url = "https://files.pythonhosted.org/packages/d2/21/83fffb77864408b8bf0fe1ca603926401d6f8775a8e150b39aacc9958f8a/charset_normalizer-3.5.1-cp310-cp310-win_amd64.whl", hash = "sha256:be47f99644b208bff7766314013f9acf57b056b04191d570d68ad14022cf5b1d", size = 206030, upload-time = "2026-08-15T08:16:43.787Z" }, - { url = "https://files.pythonhosted.org/packages/86/2e/b93135b5034b1157fb29554b0d06d4844ce62282f0e0a14036f93d7ee2e7/charset_normalizer-3.5.1-cp310-cp310-win_arm64.whl", hash = "sha256:a6d095662e73e74f0a49988e0593373e243e3a52e27bfeea0a859e88acf4a0f5", size = 185092, upload-time = "2026-08-15T08:16:45.177Z" }, - { url = "https://files.pythonhosted.org/packages/6a/b6/034f6802e9c3f6418966cfabb7db8c9252cc2429c5098f41cc43af804149/charset_normalizer-3.5.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:eda059b6bc8bc0812d626fd91a7ce01bf583df0a61296eff390fd94141a34e30", size = 363585, upload-time = "2026-08-15T08:16:46.646Z" }, - { url = "https://files.pythonhosted.org/packages/d5/fa/6a7e2a7c4b5451912b8c417732df79574354443592a88d616de03da66ae5/charset_normalizer-3.5.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:aa2bb0b37202dca27175591f761108b5d34096ade1191ffe4808bdf6b1571488", size = 251189, upload-time = "2026-08-15T08:16:48.287Z" }, - { url = "https://files.pythonhosted.org/packages/a4/c8/ab42b07cfd82e919f427fcfaa7c41abae8242833ad1aad66d42bae40b669/charset_normalizer-3.5.1-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:0b2b1b3fa5670c127b246df1d0c059defd41f689a868a3b9d79df9b1cac42d22", size = 239724, upload-time = "2026-08-15T08:16:49.67Z" }, - { url = "https://files.pythonhosted.org/packages/e7/80/b9348b5d3041209f98b4cdad7655766369233f1d533f4f4f7558e9717bec/charset_normalizer-3.5.1-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6e5e4d73d588ca5ed09df1b7dcd1b203d1df3c542e3f50d126c947d432b10731", size = 280078, upload-time = "2026-08-15T08:16:51.228Z" }, - { url = "https://files.pythonhosted.org/packages/82/38/083a24028304bc85bb9e376fed801178423dcbb67495f73b6ea0624e1894/charset_normalizer-3.5.1-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b54e7e13267d49ffbfe68e25b3cbd774dab38fa37238f71265e91b36146eb21c", size = 276650, upload-time = "2026-08-15T08:16:52.625Z" }, - { url = "https://files.pythonhosted.org/packages/0d/35/731ac04aa0a097fc1c97f0994c375bdb230c6c96619db794208fe664e9ce/charset_normalizer-3.5.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c7b742bf31c88566b4bb6335a7f393bb322e580b6bb98df7bd0c25e6e3519ce8", size = 262325, upload-time = "2026-08-15T08:16:54.085Z" }, - { url = "https://files.pythonhosted.org/packages/f5/28/c2028e7021fb89c6e56868ed0e387b8e9aa811abdd2ab3208d6578d2c930/charset_normalizer-3.5.1-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:6ba32c4d2abf1d2fe7cf27d280f4cca5664233b0f885549c7761719eb977f486", size = 261140, upload-time = "2026-08-15T08:16:55.604Z" }, - { url = "https://files.pythonhosted.org/packages/28/f0/0c0ceec6d98b7daa62e361e418135d59685811d79ba11529aad5cdf15e84/charset_normalizer-3.5.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:0722590aabf9dc6a6c0343d523c05458fa2b5047dbe6302fd526bb570600753f", size = 252791, upload-time = "2026-08-15T08:16:57.103Z" }, - { url = "https://files.pythonhosted.org/packages/f0/3e/48f4cd187b1c33189d86039e9cbe4f92c05454175504b44ff81806d4d1bf/charset_normalizer-3.5.1-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:aa1099b956fb795e686d073568f6dc002a0bb89765ea6d5b055dd7d9bf1b116c", size = 240730, upload-time = "2026-08-15T08:16:58.418Z" }, - { url = "https://files.pythonhosted.org/packages/42/85/f9e22af69af67c54cce42be9455d9c81294f918b4ccc454db01f66efcac2/charset_normalizer-3.5.1-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:bd6c173f04743d483881bffa1478d5a4624475b8cd1d2194956a75548e191c18", size = 280791, upload-time = "2026-08-15T08:16:59.918Z" }, - { url = "https://files.pythonhosted.org/packages/fd/4c/9044135f42127630b6fa742feb51256353f6ab87a78f2fdd1de3de955a7f/charset_normalizer-3.5.1-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:f298e218441525d3794428b4c8b8fb8662c6d3ea79925d4807ee6b9a96a3bca5", size = 259598, upload-time = "2026-08-15T08:17:01.421Z" }, - { url = "https://files.pythonhosted.org/packages/ba/ed/1dd7cfebb4e75812934c49ca3b79757d11948053f7937ab7070c151f3c55/charset_normalizer-3.5.1-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:6e2912d4babbc65196ac13c2f53468dc57fb8b9c25ef913e8c59ddf7c6dc0e1b", size = 278217, upload-time = "2026-08-15T08:17:02.782Z" }, - { url = "https://files.pythonhosted.org/packages/bf/eb/239c84503cc9e3ba6eb34686a24bc66e84f3924efdd7e38e751a19f6bc10/charset_normalizer-3.5.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:3d27167433c0d5f18dc850f07d0b3816221984fecdc405d6c157a6f0b8f8e9e6", size = 263417, upload-time = "2026-08-15T08:17:04.216Z" }, - { url = "https://files.pythonhosted.org/packages/37/ab/4e4510e1e288478e2c8333131d1c1382382ba8cd2165053c79e39d1da961/charset_normalizer-3.5.1-cp311-cp311-win32.whl", hash = "sha256:ac00177c4831ffa650f8609e4bdddd5fe09c03b1c0c47acece7e6ea20421598b", size = 181774, upload-time = "2026-08-15T08:17:05.58Z" }, - { url = "https://files.pythonhosted.org/packages/e3/57/32f0ccea59e8612057c61d6fd22ef2cb63cca93c9fe594094919696ac170/charset_normalizer-3.5.1-cp311-cp311-win_amd64.whl", hash = "sha256:f9b1e28d0e8dbfa858abdba91d6b547beaf2df1a59bec6da6faae7b96a4991a9", size = 206653, upload-time = "2026-08-15T08:17:07.075Z" }, - { url = "https://files.pythonhosted.org/packages/17/d4/b65c433fc521e58b5f54293982a5e51c05cb5f2dd3f1c7a6acb65b75324e/charset_normalizer-3.5.1-cp311-cp311-win_arm64.whl", hash = "sha256:ae31a1a1db2ee6cc2942fccaf695c934bc7f3db9f2133a3fef1f367cf1a4ab10", size = 185630, upload-time = "2026-08-15T08:17:08.502Z" }, { url = "https://files.pythonhosted.org/packages/30/27/78873dc8b6a56357517b74b6bb9568b80450e7bb4f6ef7e3fa9d22aa0bd7/charset_normalizer-3.5.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:5b6d1386bf0096d26d3a863dc0a487a5b4eb9aa93cf5ba69683d29dde6b9d60f", size = 344456, upload-time = "2026-08-15T08:17:10.072Z" }, { url = "https://files.pythonhosted.org/packages/9a/4c/be49ada26b1f0232d57aa89bbebf997a5cc2332a5616b6eca26ff680044d/charset_normalizer-3.5.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4582c27e8c889d64811987b5967fbd3ae0c823fe1fd933b543d55ac20bb475fa", size = 238530, upload-time = "2026-08-15T08:17:11.563Z" }, { url = "https://files.pythonhosted.org/packages/76/84/6f1290fa07ae6978d3960caa3eb1b8019bf9284ab7c2297b00c099ef4250/charset_normalizer-3.5.1-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:1d1c7a53a6c2103925cdd6d7229f8c567379f211c869793df679f2e9f738c369", size = 230200, upload-time = "2026-08-15T08:17:12.919Z" }, @@ -251,18 +218,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/02/08/9c41fb51ab5b43eb21674aff13df270e8ba6c4b29c8624e328dc7a9482af/distlib-0.4.3-py2.py3-none-any.whl", hash = "sha256:4b0ce306c966eb73bc3a7b6abad017c556dadd92c44701562cd528ac7fde4d5b", size = 470628, upload-time = "2026-06-12T08:04:50.506Z" }, ] -[[package]] -name = "exceptiongroup" -version = "1.3.1" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "typing-extensions", marker = "python_full_version < '3.13'" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/50/79/66800aadf48771f6b62f7eb014e352e5d06856655206165d775e675a02c9/exceptiongroup-1.3.1.tar.gz", hash = "sha256:8b412432c6055b0b7d14c310000ae93352ed6754f70fa8f7c34141f91c4e3219", size = 30371, upload-time = "2025-11-21T23:01:54.787Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/8a/0e/97c33bf5009bdbac74fd2beace167cab3f978feb69cc36f1ef79360d6c4e/exceptiongroup-1.3.1-py3-none-any.whl", hash = "sha256:a7a39a3bd276781e98394987d3a5701d0c4edffb633bb7a5144577f82c773598", size = 16740, upload-time = "2025-11-21T23:01:53.443Z" }, -] - [[package]] name = "filelock" version = "3.32.3" @@ -403,12 +358,10 @@ version = "9.1.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "colorama", marker = "sys_platform == 'win32'" }, - { name = "exceptiongroup", marker = "python_full_version < '3.11'" }, { name = "iniconfig" }, { name = "packaging" }, { name = "pluggy" }, { name = "pygments" }, - { name = "tomli", marker = "python_full_version < '3.11'" }, ] sdist = { url = "https://files.pythonhosted.org/packages/e4/47/b9efed96c114afcfa3c9d3fe98a76a1d14c74a9e266d397cf6eb64be5e01/pytest-9.1.1.tar.gz", hash = "sha256:1088fbde8f2b49d95a549a195707afa7a76a3ce9bcadc26b6d71f0ffda5fe313", size = 1636369, upload-time = "2026-06-19T10:58:32.857Z" } wheels = [ @@ -433,24 +386,6 @@ version = "6.0.3" source = { registry = "https://pypi.org/simple" } sdist = { url = "https://files.pythonhosted.org/packages/05/8e/961c0007c59b8dd7729d542c61a4d537767a59645b82a0b521206e1e25c2/pyyaml-6.0.3.tar.gz", hash = "sha256:d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f", size = 130960, upload-time = "2025-09-25T21:33:16.546Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/f4/a0/39350dd17dd6d6c6507025c0e53aef67a9293a6d37d3511f23ea510d5800/pyyaml-6.0.3-cp310-cp310-macosx_10_13_x86_64.whl", hash = "sha256:214ed4befebe12df36bcc8bc2b64b396ca31be9304b8f59e25c11cf94a4c033b", size = 184227, upload-time = "2025-09-25T21:31:46.04Z" }, - { url = "https://files.pythonhosted.org/packages/05/14/52d505b5c59ce73244f59c7a50ecf47093ce4765f116cdb98286a71eeca2/pyyaml-6.0.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:02ea2dfa234451bbb8772601d7b8e426c2bfa197136796224e50e35a78777956", size = 174019, upload-time = "2025-09-25T21:31:47.706Z" }, - { url = "https://files.pythonhosted.org/packages/43/f7/0e6a5ae5599c838c696adb4e6330a59f463265bfa1e116cfd1fbb0abaaae/pyyaml-6.0.3-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b30236e45cf30d2b8e7b3e85881719e98507abed1011bf463a8fa23e9c3e98a8", size = 740646, upload-time = "2025-09-25T21:31:49.21Z" }, - { url = "https://files.pythonhosted.org/packages/2f/3a/61b9db1d28f00f8fd0ae760459a5c4bf1b941baf714e207b6eb0657d2578/pyyaml-6.0.3-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:66291b10affd76d76f54fad28e22e51719ef9ba22b29e1d7d03d6777a9174198", size = 840793, upload-time = "2025-09-25T21:31:50.735Z" }, - { url = "https://files.pythonhosted.org/packages/7a/1e/7acc4f0e74c4b3d9531e24739e0ab832a5edf40e64fbae1a9c01941cabd7/pyyaml-6.0.3-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9c7708761fccb9397fe64bbc0395abcae8c4bf7b0eac081e12b809bf47700d0b", size = 770293, upload-time = "2025-09-25T21:31:51.828Z" }, - { url = "https://files.pythonhosted.org/packages/8b/ef/abd085f06853af0cd59fa5f913d61a8eab65d7639ff2a658d18a25d6a89d/pyyaml-6.0.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:418cf3f2111bc80e0933b2cd8cd04f286338bb88bdc7bc8e6dd775ebde60b5e0", size = 732872, upload-time = "2025-09-25T21:31:53.282Z" }, - { url = "https://files.pythonhosted.org/packages/1f/15/2bc9c8faf6450a8b3c9fc5448ed869c599c0a74ba2669772b1f3a0040180/pyyaml-6.0.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:5e0b74767e5f8c593e8c9b5912019159ed0533c70051e9cce3e8b6aa699fcd69", size = 758828, upload-time = "2025-09-25T21:31:54.807Z" }, - { url = "https://files.pythonhosted.org/packages/a3/00/531e92e88c00f4333ce359e50c19b8d1de9fe8d581b1534e35ccfbc5f393/pyyaml-6.0.3-cp310-cp310-win32.whl", hash = "sha256:28c8d926f98f432f88adc23edf2e6d4921ac26fb084b028c733d01868d19007e", size = 142415, upload-time = "2025-09-25T21:31:55.885Z" }, - { url = "https://files.pythonhosted.org/packages/2a/fa/926c003379b19fca39dd4634818b00dec6c62d87faf628d1394e137354d4/pyyaml-6.0.3-cp310-cp310-win_amd64.whl", hash = "sha256:bdb2c67c6c1390b63c6ff89f210c8fd09d9a1217a465701eac7316313c915e4c", size = 158561, upload-time = "2025-09-25T21:31:57.406Z" }, - { url = "https://files.pythonhosted.org/packages/6d/16/a95b6757765b7b031c9374925bb718d55e0a9ba8a1b6a12d25962ea44347/pyyaml-6.0.3-cp311-cp311-macosx_10_13_x86_64.whl", hash = "sha256:44edc647873928551a01e7a563d7452ccdebee747728c1080d881d68af7b997e", size = 185826, upload-time = "2025-09-25T21:31:58.655Z" }, - { url = "https://files.pythonhosted.org/packages/16/19/13de8e4377ed53079ee996e1ab0a9c33ec2faf808a4647b7b4c0d46dd239/pyyaml-6.0.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:652cb6edd41e718550aad172851962662ff2681490a8a711af6a4d288dd96824", size = 175577, upload-time = "2025-09-25T21:32:00.088Z" }, - { url = "https://files.pythonhosted.org/packages/0c/62/d2eb46264d4b157dae1275b573017abec435397aa59cbcdab6fc978a8af4/pyyaml-6.0.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:10892704fc220243f5305762e276552a0395f7beb4dbf9b14ec8fd43b57f126c", size = 775556, upload-time = "2025-09-25T21:32:01.31Z" }, - { url = "https://files.pythonhosted.org/packages/10/cb/16c3f2cf3266edd25aaa00d6c4350381c8b012ed6f5276675b9eba8d9ff4/pyyaml-6.0.3-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:850774a7879607d3a6f50d36d04f00ee69e7fc816450e5f7e58d7f17f1ae5c00", size = 882114, upload-time = "2025-09-25T21:32:03.376Z" }, - { url = "https://files.pythonhosted.org/packages/71/60/917329f640924b18ff085ab889a11c763e0b573da888e8404ff486657602/pyyaml-6.0.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b8bb0864c5a28024fac8a632c443c87c5aa6f215c0b126c449ae1a150412f31d", size = 806638, upload-time = "2025-09-25T21:32:04.553Z" }, - { url = "https://files.pythonhosted.org/packages/dd/6f/529b0f316a9fd167281a6c3826b5583e6192dba792dd55e3203d3f8e655a/pyyaml-6.0.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:1d37d57ad971609cf3c53ba6a7e365e40660e3be0e5175fa9f2365a379d6095a", size = 767463, upload-time = "2025-09-25T21:32:06.152Z" }, - { url = "https://files.pythonhosted.org/packages/f2/6a/b627b4e0c1dd03718543519ffb2f1deea4a1e6d42fbab8021936a4d22589/pyyaml-6.0.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:37503bfbfc9d2c40b344d06b2199cf0e96e97957ab1c1b546fd4f87e53e5d3e4", size = 794986, upload-time = "2025-09-25T21:32:07.367Z" }, - { url = "https://files.pythonhosted.org/packages/45/91/47a6e1c42d9ee337c4839208f30d9f09caa9f720ec7582917b264defc875/pyyaml-6.0.3-cp311-cp311-win32.whl", hash = "sha256:8098f252adfa6c80ab48096053f512f2321f0b998f98150cea9bd23d83e1467b", size = 142543, upload-time = "2025-09-25T21:32:08.95Z" }, - { url = "https://files.pythonhosted.org/packages/da/e3/ea007450a105ae919a72393cb06f122f288ef60bba2dc64b26e2646fa315/pyyaml-6.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:9f3bfb4965eb874431221a3ff3fdcddc7e74e3b07799e0e84ca4a0f867d449bf", size = 158763, upload-time = "2025-09-25T21:32:09.96Z" }, { url = "https://files.pythonhosted.org/packages/d1/33/422b98d2195232ca1826284a76852ad5a86fe23e31b009c9886b2d0fb8b2/pyyaml-6.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7f047e29dcae44602496db43be01ad42fc6f1cc0d8cd6c83d342306c32270196", size = 182063, upload-time = "2025-09-25T21:32:11.445Z" }, { url = "https://files.pythonhosted.org/packages/89/a0/6cf41a19a1f2f3feab0e9c0b74134aa2ce6849093d5517a0c550fe37a648/pyyaml-6.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:fc09d0aa354569bc501d4e787133afc08552722d3ab34836a80547331bb5d4a0", size = 173973, upload-time = "2025-09-25T21:32:12.492Z" }, { url = "https://files.pythonhosted.org/packages/ed/23/7a778b6bd0b9a8039df8b1b1d80e2e2ad78aa04171592c8a5c43a56a6af4/pyyaml-6.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9149cad251584d5fb4981be1ecde53a1ca46c891a79788c0df828d2f166bda28", size = 775116, upload-time = "2025-09-25T21:32:13.652Z" }, @@ -530,60 +465,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/c9/bd/c196493563d6bf8fe960f10b83926a3fae3a43a96eac6b263aecb96c61d7/ruff-0.1.15-py3-none-win_arm64.whl", hash = "sha256:9a933dfb1c14ec7a33cceb1e49ec4a16b51ce3c20fd42663198746efc0427360", size = 6998592, upload-time = "2024-01-29T23:06:01.904Z" }, ] -[[package]] -name = "tomli" -version = "2.4.1" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/22/de/48c59722572767841493b26183a0d1cc411d54fd759c5607c4590b6563a6/tomli-2.4.1.tar.gz", hash = "sha256:7c7e1a961a0b2f2472c1ac5b69affa0ae1132c39adcb67aba98568702b9cc23f", size = 17543, upload-time = "2026-03-25T20:22:03.828Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/f4/11/db3d5885d8528263d8adc260bb2d28ebf1270b96e98f0e0268d32b8d9900/tomli-2.4.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:f8f0fc26ec2cc2b965b7a3b87cd19c5c6b8c5e5f436b984e85f486d652285c30", size = 154704, upload-time = "2026-03-25T20:21:10.473Z" }, - { url = "https://files.pythonhosted.org/packages/6d/f7/675db52c7e46064a9aa928885a9b20f4124ecb9bc2e1ce74c9106648d202/tomli-2.4.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:4ab97e64ccda8756376892c53a72bd1f964e519c77236368527f758fbc36a53a", size = 149454, upload-time = "2026-03-25T20:21:12.036Z" }, - { url = "https://files.pythonhosted.org/packages/61/71/81c50943cf953efa35bce7646caab3cf457a7d8c030b27cfb40d7235f9ee/tomli-2.4.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:96481a5786729fd470164b47cdb3e0e58062a496f455ee41b4403be77cb5a076", size = 237561, upload-time = "2026-03-25T20:21:13.098Z" }, - { url = "https://files.pythonhosted.org/packages/48/c1/f41d9cb618acccca7df82aaf682f9b49013c9397212cb9f53219e3abac37/tomli-2.4.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5a881ab208c0baf688221f8cecc5401bd291d67e38a1ac884d6736cbcd8247e9", size = 243824, upload-time = "2026-03-25T20:21:14.569Z" }, - { url = "https://files.pythonhosted.org/packages/22/e4/5a816ecdd1f8ca51fb756ef684b90f2780afc52fc67f987e3c61d800a46d/tomli-2.4.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:47149d5bd38761ac8be13a84864bf0b7b70bc051806bc3669ab1cbc56216b23c", size = 242227, upload-time = "2026-03-25T20:21:15.712Z" }, - { url = "https://files.pythonhosted.org/packages/6b/49/2b2a0ef529aa6eec245d25f0c703e020a73955ad7edf73e7f54ddc608aa5/tomli-2.4.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:ec9bfaf3ad2df51ace80688143a6a4ebc09a248f6ff781a9945e51937008fcbc", size = 247859, upload-time = "2026-03-25T20:21:17.001Z" }, - { url = "https://files.pythonhosted.org/packages/83/bd/6c1a630eaca337e1e78c5903104f831bda934c426f9231429396ce3c3467/tomli-2.4.1-cp311-cp311-win32.whl", hash = "sha256:ff2983983d34813c1aeb0fa89091e76c3a22889ee83ab27c5eeb45100560c049", size = 97204, upload-time = "2026-03-25T20:21:18.079Z" }, - { url = "https://files.pythonhosted.org/packages/42/59/71461df1a885647e10b6bb7802d0b8e66480c61f3f43079e0dcd315b3954/tomli-2.4.1-cp311-cp311-win_amd64.whl", hash = "sha256:5ee18d9ebdb417e384b58fe414e8d6af9f4e7a0ae761519fb50f721de398dd4e", size = 108084, upload-time = "2026-03-25T20:21:18.978Z" }, - { url = "https://files.pythonhosted.org/packages/b8/83/dceca96142499c069475b790e7913b1044c1a4337e700751f48ed723f883/tomli-2.4.1-cp311-cp311-win_arm64.whl", hash = "sha256:c2541745709bad0264b7d4705ad453b76ccd191e64aa6f0fc66b69a293a45ece", size = 95285, upload-time = "2026-03-25T20:21:20.309Z" }, - { url = "https://files.pythonhosted.org/packages/c1/ba/42f134a3fe2b370f555f44b1d72feebb94debcab01676bf918d0cb70e9aa/tomli-2.4.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:c742f741d58a28940ce01d58f0ab2ea3ced8b12402f162f4d534dfe18ba1cd6a", size = 155924, upload-time = "2026-03-25T20:21:21.626Z" }, - { url = "https://files.pythonhosted.org/packages/dc/c7/62d7a17c26487ade21c5422b646110f2162f1fcc95980ef7f63e73c68f14/tomli-2.4.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:7f86fd587c4ed9dd76f318225e7d9b29cfc5a9d43de44e5754db8d1128487085", size = 150018, upload-time = "2026-03-25T20:21:23.002Z" }, - { url = "https://files.pythonhosted.org/packages/5c/05/79d13d7c15f13bdef410bdd49a6485b1c37d28968314eabee452c22a7fda/tomli-2.4.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ff18e6a727ee0ab0388507b89d1bc6a22b138d1e2fa56d1ad494586d61d2eae9", size = 244948, upload-time = "2026-03-25T20:21:24.04Z" }, - { url = "https://files.pythonhosted.org/packages/10/90/d62ce007a1c80d0b2c93e02cab211224756240884751b94ca72df8a875ca/tomli-2.4.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:136443dbd7e1dee43c68ac2694fde36b2849865fa258d39bf822c10e8068eac5", size = 253341, upload-time = "2026-03-25T20:21:25.177Z" }, - { url = "https://files.pythonhosted.org/packages/1a/7e/caf6496d60152ad4ed09282c1885cca4eea150bfd007da84aea07bcc0a3e/tomli-2.4.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:5e262d41726bc187e69af7825504c933b6794dc3fbd5945e41a79bb14c31f585", size = 248159, upload-time = "2026-03-25T20:21:26.364Z" }, - { url = "https://files.pythonhosted.org/packages/99/e7/c6f69c3120de34bbd882c6fba7975f3d7a746e9218e56ab46a1bc4b42552/tomli-2.4.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:5cb41aa38891e073ee49d55fbc7839cfdb2bc0e600add13874d048c94aadddd1", size = 253290, upload-time = "2026-03-25T20:21:27.46Z" }, - { url = "https://files.pythonhosted.org/packages/d6/2f/4a3c322f22c5c66c4b836ec58211641a4067364f5dcdd7b974b4c5da300c/tomli-2.4.1-cp312-cp312-win32.whl", hash = "sha256:da25dc3563bff5965356133435b757a795a17b17d01dbc0f42fb32447ddfd917", size = 98141, upload-time = "2026-03-25T20:21:28.492Z" }, - { url = "https://files.pythonhosted.org/packages/24/22/4daacd05391b92c55759d55eaee21e1dfaea86ce5c571f10083360adf534/tomli-2.4.1-cp312-cp312-win_amd64.whl", hash = "sha256:52c8ef851d9a240f11a88c003eacb03c31fc1c9c4ec64a99a0f922b93874fda9", size = 108847, upload-time = "2026-03-25T20:21:29.386Z" }, - { url = "https://files.pythonhosted.org/packages/68/fd/70e768887666ddd9e9f5d85129e84910f2db2796f9096aa02b721a53098d/tomli-2.4.1-cp312-cp312-win_arm64.whl", hash = "sha256:f758f1b9299d059cc3f6546ae2af89670cb1c4d48ea29c3cacc4fe7de3058257", size = 95088, upload-time = "2026-03-25T20:21:30.677Z" }, - { url = "https://files.pythonhosted.org/packages/07/06/b823a7e818c756d9a7123ba2cda7d07bc2dd32835648d1a7b7b7a05d848d/tomli-2.4.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:36d2bd2ad5fb9eaddba5226aa02c8ec3fa4f192631e347b3ed28186d43be6b54", size = 155866, upload-time = "2026-03-25T20:21:31.65Z" }, - { url = "https://files.pythonhosted.org/packages/14/6f/12645cf7f08e1a20c7eb8c297c6f11d31c1b50f316a7e7e1e1de6e2e7b7e/tomli-2.4.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:eb0dc4e38e6a1fd579e5d50369aa2e10acfc9cace504579b2faabb478e76941a", size = 149887, upload-time = "2026-03-25T20:21:33.028Z" }, - { url = "https://files.pythonhosted.org/packages/5c/e0/90637574e5e7212c09099c67ad349b04ec4d6020324539297b634a0192b0/tomli-2.4.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c7f2c7f2b9ca6bdeef8f0fa897f8e05085923eb091721675170254cbc5b02897", size = 243704, upload-time = "2026-03-25T20:21:34.51Z" }, - { url = "https://files.pythonhosted.org/packages/10/8f/d3ddb16c5a4befdf31a23307f72828686ab2096f068eaf56631e136c1fdd/tomli-2.4.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f3c6818a1a86dd6dca7ddcaaf76947d5ba31aecc28cb1b67009a5877c9a64f3f", size = 251628, upload-time = "2026-03-25T20:21:36.012Z" }, - { url = "https://files.pythonhosted.org/packages/e3/f1/dbeeb9116715abee2485bf0a12d07a8f31af94d71608c171c45f64c0469d/tomli-2.4.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:d312ef37c91508b0ab2cee7da26ec0b3ed2f03ce12bd87a588d771ae15dcf82d", size = 247180, upload-time = "2026-03-25T20:21:37.136Z" }, - { url = "https://files.pythonhosted.org/packages/d3/74/16336ffd19ed4da28a70959f92f506233bd7cfc2332b20bdb01591e8b1d1/tomli-2.4.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:51529d40e3ca50046d7606fa99ce3956a617f9b36380da3b7f0dd3dd28e68cb5", size = 251674, upload-time = "2026-03-25T20:21:38.298Z" }, - { url = "https://files.pythonhosted.org/packages/16/f9/229fa3434c590ddf6c0aa9af64d3af4b752540686cace29e6281e3458469/tomli-2.4.1-cp313-cp313-win32.whl", hash = "sha256:2190f2e9dd7508d2a90ded5ed369255980a1bcdd58e52f7fe24b8162bf9fedbd", size = 97976, upload-time = "2026-03-25T20:21:39.316Z" }, - { url = "https://files.pythonhosted.org/packages/6a/1e/71dfd96bcc1c775420cb8befe7a9d35f2e5b1309798f009dca17b7708c1e/tomli-2.4.1-cp313-cp313-win_amd64.whl", hash = "sha256:8d65a2fbf9d2f8352685bc1364177ee3923d6baf5e7f43ea4959d7d8bc326a36", size = 108755, upload-time = "2026-03-25T20:21:40.248Z" }, - { url = "https://files.pythonhosted.org/packages/83/7a/d34f422a021d62420b78f5c538e5b102f62bea616d1d75a13f0a88acb04a/tomli-2.4.1-cp313-cp313-win_arm64.whl", hash = "sha256:4b605484e43cdc43f0954ddae319fb75f04cc10dd80d830540060ee7cd0243cd", size = 95265, upload-time = "2026-03-25T20:21:41.219Z" }, - { url = "https://files.pythonhosted.org/packages/3c/fb/9a5c8d27dbab540869f7c1f8eb0abb3244189ce780ba9cd73f3770662072/tomli-2.4.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:fd0409a3653af6c147209d267a0e4243f0ae46b011aa978b1080359fddc9b6cf", size = 155726, upload-time = "2026-03-25T20:21:42.23Z" }, - { url = "https://files.pythonhosted.org/packages/62/05/d2f816630cc771ad836af54f5001f47a6f611d2d39535364f148b6a92d6b/tomli-2.4.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:a120733b01c45e9a0c34aeef92bf0cf1d56cfe81ed9d47d562f9ed591a9828ac", size = 149859, upload-time = "2026-03-25T20:21:43.386Z" }, - { url = "https://files.pythonhosted.org/packages/ce/48/66341bdb858ad9bd0ceab5a86f90eddab127cf8b046418009f2125630ecb/tomli-2.4.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:559db847dc486944896521f68d8190be1c9e719fced785720d2216fe7022b662", size = 244713, upload-time = "2026-03-25T20:21:44.474Z" }, - { url = "https://files.pythonhosted.org/packages/df/6d/c5fad00d82b3c7a3ab6189bd4b10e60466f22cfe8a08a9394185c8a8111c/tomli-2.4.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:01f520d4f53ef97964a240a035ec2a869fe1a37dde002b57ebc4417a27ccd853", size = 252084, upload-time = "2026-03-25T20:21:45.62Z" }, - { url = "https://files.pythonhosted.org/packages/00/71/3a69e86f3eafe8c7a59d008d245888051005bd657760e96d5fbfb0b740c2/tomli-2.4.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7f94b27a62cfad8496c8d2513e1a222dd446f095fca8987fceef261225538a15", size = 247973, upload-time = "2026-03-25T20:21:46.937Z" }, - { url = "https://files.pythonhosted.org/packages/67/50/361e986652847fec4bd5e4a0208752fbe64689c603c7ae5ea7cb16b1c0ca/tomli-2.4.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:ede3e6487c5ef5d28634ba3f31f989030ad6af71edfb0055cbbd14189ff240ba", size = 256223, upload-time = "2026-03-25T20:21:48.467Z" }, - { url = "https://files.pythonhosted.org/packages/8c/9a/b4173689a9203472e5467217e0154b00e260621caa227b6fa01feab16998/tomli-2.4.1-cp314-cp314-win32.whl", hash = "sha256:3d48a93ee1c9b79c04bb38772ee1b64dcf18ff43085896ea460ca8dec96f35f6", size = 98973, upload-time = "2026-03-25T20:21:49.526Z" }, - { url = "https://files.pythonhosted.org/packages/14/58/640ac93bf230cd27d002462c9af0d837779f8773bc03dee06b5835208214/tomli-2.4.1-cp314-cp314-win_amd64.whl", hash = "sha256:88dceee75c2c63af144e456745e10101eb67361050196b0b6af5d717254dddf7", size = 109082, upload-time = "2026-03-25T20:21:50.506Z" }, - { url = "https://files.pythonhosted.org/packages/d5/2f/702d5e05b227401c1068f0d386d79a589bb12bf64c3d2c72ce0631e3bc49/tomli-2.4.1-cp314-cp314-win_arm64.whl", hash = "sha256:b8c198f8c1805dc42708689ed6864951fd2494f924149d3e4bce7710f8eb5232", size = 96490, upload-time = "2026-03-25T20:21:51.474Z" }, - { url = "https://files.pythonhosted.org/packages/45/4b/b877b05c8ba62927d9865dd980e34a755de541eb65fffba52b4cc495d4d2/tomli-2.4.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:d4d8fe59808a54658fcc0160ecfb1b30f9089906c50b23bcb4c69eddc19ec2b4", size = 164263, upload-time = "2026-03-25T20:21:52.543Z" }, - { url = "https://files.pythonhosted.org/packages/24/79/6ab420d37a270b89f7195dec5448f79400d9e9c1826df982f3f8e97b24fd/tomli-2.4.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:7008df2e7655c495dd12d2a4ad038ff878d4ca4b81fccaf82b714e07eae4402c", size = 160736, upload-time = "2026-03-25T20:21:53.674Z" }, - { url = "https://files.pythonhosted.org/packages/02/e0/3630057d8eb170310785723ed5adcdfb7d50cb7e6455f85ba8a3deed642b/tomli-2.4.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1d8591993e228b0c930c4bb0db464bdad97b3289fb981255d6c9a41aedc84b2d", size = 270717, upload-time = "2026-03-25T20:21:55.129Z" }, - { url = "https://files.pythonhosted.org/packages/7a/b4/1613716072e544d1a7891f548d8f9ec6ce2faf42ca65acae01d76ea06bb0/tomli-2.4.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:734e20b57ba95624ecf1841e72b53f6e186355e216e5412de414e3c51e5e3c41", size = 278461, upload-time = "2026-03-25T20:21:56.228Z" }, - { url = "https://files.pythonhosted.org/packages/05/38/30f541baf6a3f6df77b3df16b01ba319221389e2da59427e221ef417ac0c/tomli-2.4.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:8a650c2dbafa08d42e51ba0b62740dae4ecb9338eefa093aa5c78ceb546fcd5c", size = 274855, upload-time = "2026-03-25T20:21:57.653Z" }, - { url = "https://files.pythonhosted.org/packages/77/a3/ec9dd4fd2c38e98de34223b995a3b34813e6bdadf86c75314c928350ed14/tomli-2.4.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:504aa796fe0569bb43171066009ead363de03675276d2d121ac1a4572397870f", size = 283144, upload-time = "2026-03-25T20:21:59.089Z" }, - { url = "https://files.pythonhosted.org/packages/ef/be/605a6261cac79fba2ec0c9827e986e00323a1945700969b8ee0b30d85453/tomli-2.4.1-cp314-cp314t-win32.whl", hash = "sha256:b1d22e6e9387bf4739fbe23bfa80e93f6b0373a7f1b96c6227c32bef95a4d7a8", size = 108683, upload-time = "2026-03-25T20:22:00.214Z" }, - { url = "https://files.pythonhosted.org/packages/12/64/da524626d3b9cc40c168a13da8335fe1c51be12c0a63685cc6db7308daae/tomli-2.4.1-cp314-cp314t-win_amd64.whl", hash = "sha256:2c1c351919aca02858f740c6d33adea0c5deea37f9ecca1cc1ef9e884a619d26", size = 121196, upload-time = "2026-03-25T20:22:01.169Z" }, - { url = "https://files.pythonhosted.org/packages/5a/cd/e80b62269fc78fc36c9af5a6b89c835baa8af28ff5ad28c7028d60860320/tomli-2.4.1-cp314-cp314t-win_arm64.whl", hash = "sha256:eab21f45c7f66c13f2a9e0e1535309cee140182a9cdae1e041d02e47291e8396", size = 100393, upload-time = "2026-03-25T20:22:02.137Z" }, - { url = "https://files.pythonhosted.org/packages/7b/61/cceae43728b7de99d9b847560c262873a1f6c98202171fd5ed62640b494b/tomli-2.4.1-py3-none-any.whl", hash = "sha256:0d85819802132122da43cb86656f8d1f8c6587d54ae7dcaf30e90533028b49fe", size = 14583, upload-time = "2026-03-25T20:22:03.012Z" }, -] - [[package]] name = "types-requests" version = "2.33.0.20260712" @@ -623,7 +504,6 @@ dependencies = [ { name = "filelock" }, { name = "platformdirs" }, { name = "python-discovery" }, - { name = "typing-extensions", marker = "python_full_version < '3.11'" }, ] sdist = { url = "https://files.pythonhosted.org/packages/2d/dc/a6eb1ddfa7f1e390fa599b078453c97edb3f6f846b34fb4eac3e8ea16401/virtualenv-21.7.4.tar.gz", hash = "sha256:c9d960c95fa458171e58222a5ccab7465298e4b6559977865e627c4719f1e825", size = 5345511, upload-time = "2026-08-10T22:54:33.316Z" } wheels = [ From aac147a48123770eec73783fc9217d99417a82fb Mon Sep 17 00:00:00 2001 From: lovvskillz <14542790+lovvskillz@users.noreply.github.com> Date: Sun, 16 Aug 2026 16:00:31 +0200 Subject: [PATCH 5/8] update dev dependencies --- .github/workflows/code-format.yml | 4 +-- .pre-commit-config.yaml | 6 ++--- pyproject.toml | 16 ++++++++--- uv.lock | 45 ++++++++++++++++--------------- 4 files changed, 40 insertions(+), 31 deletions(-) diff --git a/.github/workflows/code-format.yml b/.github/workflows/code-format.yml index 2c8cf73..8eb55aa 100644 --- a/.github/workflows/code-format.yml +++ b/.github/workflows/code-format.yml @@ -9,12 +9,12 @@ jobs: - uses: actions/checkout@v3 - uses: chartboost/ruff-action@v1 with: - version: 0.1.15 + version: 0.16.3 ruff-format: runs-on: ubuntu-latest steps: - uses: actions/checkout@v3 - uses: chartboost/ruff-action@v1 with: - version: 0.1.15 + version: 0.16.3 args: format diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 1414718..50bb8fd 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -2,13 +2,13 @@ fail_fast: true repos: - repo: https://github.com/astral-sh/ruff-pre-commit - rev: v0.1.15 + rev: v0.16.3 hooks: - - id: ruff + - id: ruff-check args: [ --fix ] - id: ruff-format - repo: https://github.com/pre-commit/pre-commit-hooks - rev: v4.3.0 + rev: v6.0.0 hooks: - id: check-added-large-files args: ['--maxkb=1024'] diff --git a/pyproject.toml b/pyproject.toml index 8695769..9eb19ad 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -24,10 +24,10 @@ discord_webhook = "discord_webhook.__main__:main" [dependency-groups] dev = [ - "pre-commit>=3.3.3", - "types-requests>=2.28.11.4", - "pytest>=7.4.0", - "ruff>=0.1.15,<0.2", + "pre-commit>=4.6.2", + "types-requests>=2.33.0.20260712", + "pytest>=9.1.1", + "ruff==0.16.3", ] [tool.hatch.build.targets.wheel] @@ -35,6 +35,14 @@ packages = ["discord_webhook"] [tool.ruff] line-length = 88 + +[tool.ruff.format] +# newer ruff also formats code blocks in markdown; keep docs as written +exclude = ["*.md"] + +[tool.ruff.lint] +# ruff's implicit default ruleset widened in newer versions; keep the previous scope +select = ["E", "F"] ignore = ["E501"] [build-system] diff --git a/uv.lock b/uv.lock index e79f1c8..f7fce53 100644 --- a/uv.lock +++ b/uv.lock @@ -203,10 +203,10 @@ provides-extras = ["async"] [package.metadata.requires-dev] dev = [ - { name = "pre-commit", specifier = ">=3.3.3" }, - { name = "pytest", specifier = ">=7.4.0" }, - { name = "ruff", specifier = ">=0.1.15,<0.2" }, - { name = "types-requests", specifier = ">=2.28.11.4" }, + { name = "pre-commit", specifier = ">=4.6.2" }, + { name = "pytest", specifier = ">=9.1.1" }, + { name = "ruff", specifier = "==0.16.3" }, + { name = "types-requests", specifier = ">=2.33.0.20260712" }, ] [[package]] @@ -443,26 +443,27 @@ wheels = [ [[package]] name = "ruff" -version = "0.1.15" +version = "0.16.3" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/42/33/7165f88a156be1c2fd13a18b3af6e75bbf82da5b6978cd2128d666accc18/ruff-0.1.15.tar.gz", hash = "sha256:f6dfa8c1b21c913c326919056c390966648b680966febcb796cc9d1aaab8564e", size = 1971643, upload-time = "2024-01-29T23:06:05.541Z" } +sdist = { url = "https://files.pythonhosted.org/packages/61/b3/3213589383f8f1b3938781bd1278713f6d18621a14992b3e81fefb8a5ef9/ruff-0.16.3.tar.gz", hash = "sha256:e76d33a347661a84b5be6d043d0347fdc745dfdcf825a8f4fed64b5e26eebdf2", size = 4891904, upload-time = "2026-08-13T15:17:13.381Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/11/2c/fac0658910ea3ea87a23583e58277533154261b73f9460388eb2e6e02e8f/ruff-0.1.15-py3-none-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:5fe8d54df166ecc24106db7dd6a68d44852d14eb0729ea4672bb4d96c320b7df", size = 14357437, upload-time = "2024-01-29T23:05:04.991Z" }, - { url = "https://files.pythonhosted.org/packages/5b/c1/2116927385c761ffb786dfb77654a634ecd7803dee4de3b47b59536374f1/ruff-0.1.15-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:6f0bfbb53c4b4de117ac4d6ddfd33aa5fc31beeaa21d23c45c6dd249faf9126f", size = 7329669, upload-time = "2024-01-29T23:05:12.437Z" }, - { url = "https://files.pythonhosted.org/packages/18/d7/2199ecb42cef4d70de0e72ce4ca8878d060e25fe4434cb66f51e26158a2a/ruff-0.1.15-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e0d432aec35bfc0d800d4f70eba26e23a352386be3a6cf157083d18f6f5881c8", size = 7137343, upload-time = "2024-01-29T23:05:16.159Z" }, - { url = "https://files.pythonhosted.org/packages/bb/e0/8a6f9db2c5b8c7108c7e7347cd6beca805d1b2ae618569c72f2515d11e52/ruff-0.1.15-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:9405fa9ac0e97f35aaddf185a1be194a589424b8713e3b97b762336ec79ff807", size = 6563223, upload-time = "2024-01-29T23:05:19.687Z" }, - { url = "https://files.pythonhosted.org/packages/98/fa/2a627747a5a5f7e1d3447704f795fd35d486460838485762cd569ef8eb0e/ruff-0.1.15-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c66ec24fe36841636e814b8f90f572a8c0cb0e54d8b5c2d0e300d28a0d7bffec", size = 7534853, upload-time = "2024-01-29T23:05:23.18Z" }, - { url = "https://files.pythonhosted.org/packages/55/09/c09d0f9b41d1f5e3de117579f2fcdb7063fd76cd92d6614eae1b77ccbccb/ruff-0.1.15-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:6f8ad828f01e8dd32cc58bc28375150171d198491fc901f6f98d2a39ba8e3ff5", size = 8168826, upload-time = "2024-01-29T23:05:26.544Z" }, - { url = "https://files.pythonhosted.org/packages/72/48/c9dfc2c87dc6b92446d8092c2be25b42ca4fb201cecb2499996ccf483c34/ruff-0.1.15-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:86811954eec63e9ea162af0ffa9f8d09088bab51b7438e8b6488b9401863c25e", size = 7942963, upload-time = "2024-01-29T23:05:30.655Z" }, - { url = "https://files.pythonhosted.org/packages/0c/57/dbc885f94450335fcff82301c4b25cf614894e79d9afbd249714e709ab42/ruff-0.1.15-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:fd4025ac5e87d9b80e1f300207eb2fd099ff8200fa2320d7dc066a3f4622dc6b", size = 8524998, upload-time = "2024-01-29T23:05:34.503Z" }, - { url = "https://files.pythonhosted.org/packages/39/75/8dea2fc156ae525971fdada8723f78e605dcf89428f5686728438b12f9ef/ruff-0.1.15-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b17b93c02cdb6aeb696effecea1095ac93f3884a49a554a9afa76bb125c114c1", size = 7534144, upload-time = "2024-01-29T23:05:38.642Z" }, - { url = "https://files.pythonhosted.org/packages/47/41/96b770475c46590bfd051ca0c5f797b2d45f2638c45f3a9daf1ae55b96d6/ruff-0.1.15-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:ddb87643be40f034e97e97f5bc2ef7ce39de20e34608f3f829db727a93fb82c5", size = 7055002, upload-time = "2024-01-29T23:05:41.955Z" }, - { url = "https://files.pythonhosted.org/packages/e8/ca/4066dbcc3631a4efe1fe695f42f20aca50474d760b3bd8e57d7565d75aa5/ruff-0.1.15-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:abf4822129ed3a5ce54383d5f0e964e7fef74a41e48eb1dfad404151efc130a2", size = 6552130, upload-time = "2024-01-29T23:05:45.487Z" }, - { url = "https://files.pythonhosted.org/packages/b8/85/da93f0fc8f2424cf776fcce6daef9291162345179d16faf1401ff2890068/ruff-0.1.15-py3-none-musllinux_1_2_i686.whl", hash = "sha256:6c629cf64bacfd136c07c78ac10a54578ec9d1bd2a9d395efbee0935868bf852", size = 7214386, upload-time = "2024-01-29T23:05:48.346Z" }, - { url = "https://files.pythonhosted.org/packages/e5/bf/de34ad339e0d1f6faa858cbcf793f3abc168b7aa516dd9227d843b992be8/ruff-0.1.15-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:1bab866aafb53da39c2cadfb8e1c4550ac5340bb40300083eb8967ba25481447", size = 7602787, upload-time = "2024-01-29T23:05:51.341Z" }, - { url = "https://files.pythonhosted.org/packages/8d/61/ffdccecb0b39521d7060d6a6bc33c53d7f20d48d3511d6333cb01f26e979/ruff-0.1.15-py3-none-win32.whl", hash = "sha256:2417e1cb6e2068389b07e6fa74c306b2810fe3ee3476d5b8a96616633f40d14f", size = 6670488, upload-time = "2024-01-29T23:05:54.454Z" }, - { url = "https://files.pythonhosted.org/packages/2b/5f/3ba51cc770ed2b2df88efc32bba26759e6ac5c6149319a60913a85230936/ruff-0.1.15-py3-none-win_amd64.whl", hash = "sha256:3837ac73d869efc4182d9036b1405ef4c73d9b1f88da2413875e34e0d6919587", size = 7319395, upload-time = "2024-01-29T23:05:58.135Z" }, - { url = "https://files.pythonhosted.org/packages/c9/bd/c196493563d6bf8fe960f10b83926a3fae3a43a96eac6b263aecb96c61d7/ruff-0.1.15-py3-none-win_arm64.whl", hash = "sha256:9a933dfb1c14ec7a33cceb1e49ec4a16b51ce3c20fd42663198746efc0427360", size = 6998592, upload-time = "2024-01-29T23:06:01.904Z" }, + { url = "https://files.pythonhosted.org/packages/bf/96/493770daebd68c0a67f1549fdf519f53be51fc435186c0585bcc272fd76c/ruff-0.16.3-py3-none-linux_armv6l.whl", hash = "sha256:0c5710e247a58a4521e66e124ba9a74655b414f61ba3a2e9e3811e11098f48f7", size = 10902799, upload-time = "2026-08-13T15:16:27.382Z" }, + { url = "https://files.pythonhosted.org/packages/5e/e6/2becf3942fddc29a29b8df47691d456fb1085391a694f74d84513251418c/ruff-0.16.3-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:fe155130631a2471fd2e14a7a664a4dfbd7194b8229c3d7b2a40b21178639081", size = 11135539, upload-time = "2026-08-13T15:16:30.87Z" }, + { url = "https://files.pythonhosted.org/packages/3e/1e/4b8b72f0d006dbf19326aa99f9ca0ee2ff374187c4d301cf529a51aa06fe/ruff-0.16.3-py3-none-macosx_11_0_arm64.whl", hash = "sha256:e2ed719e14aa64d895c2ee922594a90a43c861a93f0575a95ff8c47cdbd13eb9", size = 10475095, upload-time = "2026-08-13T15:16:33.259Z" }, + { url = "https://files.pythonhosted.org/packages/92/32/2201fa49ba1f6c101ee321e83f051ac7a4b8d07b0ef6b4d3f2772b302275/ruff-0.16.3-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9e0b1da805eb043654645d74d5de1e5ce2edc686e40790d2b86f56d71cc06a84", size = 10668771, upload-time = "2026-08-13T15:16:35.65Z" }, + { url = "https://files.pythonhosted.org/packages/c3/66/4afc5c8363bd04d45effce1b7c8713ca037d7a6740b7451a2403a6e3a972/ruff-0.16.3-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:a37bdea0bbe21780f590bf437d6412c8c4e1b6cd010f91a65c2c40c5e5f5f870", size = 10699568, upload-time = "2026-08-13T15:16:38.195Z" }, + { url = "https://files.pythonhosted.org/packages/53/fd/c67d246bf36bf1698551c56de39e95cd07f70e64433e0098e6267d77061b/ruff-0.16.3-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:09571e6d1288ed9be475207a3ac04ada404f1cd898104be0f6ab8d7df438575b", size = 11499365, upload-time = "2026-08-13T15:16:40.623Z" }, + { url = "https://files.pythonhosted.org/packages/67/0b/00ecbceb99a263af7b12f6f05ac3c92bc47b905e91adc3f207a836e3bc01/ruff-0.16.3-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:2c18c5a101eb540010638cc1ff3c84944d3adb3df62b8d98ca8f22ba484d3413", size = 12311728, upload-time = "2026-08-13T15:16:43.564Z" }, + { url = "https://files.pythonhosted.org/packages/54/b2/b7b3bb54f4d3f7db504e476ad4ab8de530dceebe2c061384b2757ee419e8/ruff-0.16.3-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8457c44f15033c85ddbb77b15d451df9e24e4bd03b628396dd3610cedc3b8f82", size = 11699896, upload-time = "2026-08-13T15:16:46.209Z" }, + { url = "https://files.pythonhosted.org/packages/c7/30/4c468429ac195addc5ee1b717b6ab1b66632786737ca3b2ed3443fb0c26a/ruff-0.16.3-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:294b95c4ae0cda9388525c2047778aa758d6b8d4bb876fd4e9eaa3ebc92343eb", size = 11058736, upload-time = "2026-08-13T15:16:48.823Z" }, + { url = "https://files.pythonhosted.org/packages/43/67/7a113cdaddf24b64d7f75b1242a99d04c82fcef4f6921fdbb832beaffb5f/ruff-0.16.3-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:3d0c7c40c87c2a820509c31ba007968da6e1306468c067b2d82fbfdbcd0e8474", size = 11586911, upload-time = "2026-08-13T15:16:51.913Z" }, + { url = "https://files.pythonhosted.org/packages/f1/c1/2e66f24c0f3ead25a5e660111778685e505e5da353c82802bf49f0cbe7b9/ruff-0.16.3-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:9f738c0fdfa8eed0b2ce7fb27ee7258208a92a68d7949e62aa15164bc7b389da", size = 10954265, upload-time = "2026-08-13T15:16:54.763Z" }, + { url = "https://files.pythonhosted.org/packages/c2/ba/4cee23bf52cba9a058d3726de623624daf50ef9638868edd86f4126157f6/ruff-0.16.3-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:fb785f0be25abe69d320415cd4f833b59e17ba7613d9ba6a958023b6bceb0a50", size = 10709886, upload-time = "2026-08-13T15:16:57.339Z" }, + { url = "https://files.pythonhosted.org/packages/82/df/7da7194fa5d9dc0a285f7e6fa5a4722e7c63faac0b45b614ded9314363a1/ruff-0.16.3-py3-none-musllinux_1_2_i686.whl", hash = "sha256:c5536e3acfbf9563085aa2be7b13c629c3077e902afc5b941ac44024dbb9f506", size = 11210392, upload-time = "2026-08-13T15:17:00.171Z" }, + { url = "https://files.pythonhosted.org/packages/35/85/7795f6e817af050e7517bf3e7aa9b061cce70ef33d280aad902c956c1ecf/ruff-0.16.3-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:a2d85c02f9b8e165d85e6779184d38c4132de12603dab59c51c28e22584f9e4d", size = 11626910, upload-time = "2026-08-13T15:17:03.299Z" }, + { url = "https://files.pythonhosted.org/packages/78/9b/475b927cf27a5cbbda3c7bafb69ed6ff77e1d7923d5d85f17c2749d7ae32/ruff-0.16.3-py3-none-win32.whl", hash = "sha256:388cdf2166642bd9b13d52b5932d3170f34f8abed7e8d9a855f1d84b83645a0a", size = 10931415, upload-time = "2026-08-13T15:17:05.726Z" }, + { url = "https://files.pythonhosted.org/packages/b2/99/e2a2bfc4fbf0a1e8a916bc9ebe6fe6c58cc34c28e0ffc6ce281d572d1c2e/ruff-0.16.3-py3-none-win_amd64.whl", hash = "sha256:e80a7d69ca2a6d1c4d352ec91458cdca6e56c83cdbcabd93e4abe1e53591d948", size = 11445993, upload-time = "2026-08-13T15:17:08.353Z" }, + { url = "https://files.pythonhosted.org/packages/69/3e/4132e539aed78c148854d4997a2685b0ed4dc4e87110b59ce528564e184e/ruff-0.16.3-py3-none-win_arm64.whl", hash = "sha256:b8ca152da82c1acc1fa8d5874b15951935f0eef46f10e6954c83859011b6178a", size = 11399302, upload-time = "2026-08-13T15:17:10.908Z" }, ] [[package]] From 1c7b020b137c4592b3c48d566342422550f64e93 Mon Sep 17 00:00:00 2001 From: lovvskillz <14542790+lovvskillz@users.noreply.github.com> Date: Sun, 16 Aug 2026 16:00:59 +0200 Subject: [PATCH 6/8] reformat with ruff formatter --- discord_webhook/__main__.py | 3 ++- discord_webhook/async_webhook.py | 24 ++++++++++++------------ discord_webhook/webhook.py | 24 ++++++++++++------------ 3 files changed, 26 insertions(+), 25 deletions(-) diff --git a/discord_webhook/__main__.py b/discord_webhook/__main__.py index 1eb8c89..04db1ce 100644 --- a/discord_webhook/__main__.py +++ b/discord_webhook/__main__.py @@ -1,4 +1,5 @@ -""" Entry point to trigger webhook(s). """ +"""Entry point to trigger webhook(s).""" + import argparse import sys diff --git a/discord_webhook/async_webhook.py b/discord_webhook/async_webhook.py index 250c658..476e337 100644 --- a/discord_webhook/async_webhook.py +++ b/discord_webhook/async_webhook.py @@ -125,12 +125,12 @@ async def edit(self) -> "httpx.Response": Edit an already sent webhook with updated data. :return: Response of the sent webhook """ - assert isinstance( - self.id, str - ), "Webhook ID needs to be set in order to edit the webhook." - assert isinstance( - self.url, str - ), "Webhook URL needs to be set in order to edit the webhook." + assert isinstance(self.id, str), ( + "Webhook ID needs to be set in order to edit the webhook." + ) + assert isinstance(self.url, str), ( + "Webhook URL needs to be set in order to edit the webhook." + ) async with self.http_client as client: # type: httpx.AsyncClient url = f"{self.url}/messages/{self.id}" if bool(self.files) is False: @@ -167,12 +167,12 @@ async def delete(self) -> "httpx.Response": Delete the already sent webhook. :return: webhook response """ - assert isinstance( - self.id, str - ), "Webhook ID needs to be set in order to delete the webhook." - assert isinstance( - self.url, str - ), "Webhook URL needs to be set in order to delete the webhook." + assert isinstance(self.id, str), ( + "Webhook ID needs to be set in order to delete the webhook." + ) + assert isinstance(self.url, str), ( + "Webhook URL needs to be set in order to delete the webhook." + ) url = f"{self.url}/messages/{self.id}" async with self.http_client as client: # type: httpx.AsyncClient response = await client.delete( diff --git a/discord_webhook/webhook.py b/discord_webhook/webhook.py index a70c825..861fa93 100644 --- a/discord_webhook/webhook.py +++ b/discord_webhook/webhook.py @@ -550,12 +550,12 @@ def edit(self) -> "requests.Response": Edit an already sent webhook with updated data. :return: Response of the sent webhook """ - assert isinstance( - self.id, str - ), "Webhook ID needs to be set in order to edit the webhook." - assert isinstance( - self.url, str - ), "Webhook URL needs to be set in order to edit the webhook." + assert isinstance(self.id, str), ( + "Webhook ID needs to be set in order to edit the webhook." + ) + assert isinstance(self.url, str), ( + "Webhook URL needs to be set in order to edit the webhook." + ) url = f"{self.url}/messages/{self.id}" if bool(self.files) is False: request = partial( @@ -595,12 +595,12 @@ def delete(self) -> "requests.Response": Delete the already sent webhook. :return: webhook response """ - assert isinstance( - self.id, str - ), "Webhook ID needs to be set in order to delete the webhook." - assert isinstance( - self.url, str - ), "Webhook URL needs to be set in order to delete the webhook." + assert isinstance(self.id, str), ( + "Webhook ID needs to be set in order to delete the webhook." + ) + assert isinstance(self.url, str), ( + "Webhook URL needs to be set in order to delete the webhook." + ) url = f"{self.url}/messages/{self.id}" request = partial( requests.delete, From e59029ee946732ec0d6d535f538eb41c3e3aa425 Mon Sep 17 00:00:00 2001 From: lovvskillz <14542790+lovvskillz@users.noreply.github.com> Date: Sun, 16 Aug 2026 16:02:22 +0200 Subject: [PATCH 7/8] modernize type annotations --- discord_webhook/async_webhook.py | 6 +- discord_webhook/components.py | 72 +++++++++--------- discord_webhook/poll.py | 32 ++++---- discord_webhook/utils.py | 4 +- discord_webhook/webhook.py | 101 +++++++++++++------------- discord_webhook/webhook_exceptions.py | 5 +- pyproject.toml | 3 +- 7 files changed, 108 insertions(+), 115 deletions(-) diff --git a/discord_webhook/async_webhook.py b/discord_webhook/async_webhook.py index 476e337..0e782a7 100644 --- a/discord_webhook/async_webhook.py +++ b/discord_webhook/async_webhook.py @@ -86,9 +86,7 @@ async def handle_rate_limit(self, response, request) -> "httpx.Response": raise HTTPException(errors) wh_sleep = float(errors["retry_after"]) + 0.15 logger.error( - "Webhook rate limited: sleeping for {wh_sleep} seconds...".format( - wh_sleep=round(wh_sleep, 2) - ) + f"Webhook rate limited: sleeping for {round(wh_sleep, 2)} seconds..." ) await asyncio.sleep(wh_sleep) response = await request() @@ -149,7 +147,7 @@ async def edit(self) -> "httpx.Response": request = partial(client.patch, url, **patch_kwargs) response = await request() if response.status_code in [200, 204]: - logger.debug("Webhook with id {id} edited".format(id=self.id)) + logger.debug(f"Webhook with id {self.id} edited") elif response.status_code == 429 and self.rate_limit_retry: response = await self.handle_rate_limit(response, request) logger.debug("Webhook edited") diff --git a/discord_webhook/components.py b/discord_webhook/components.py index 1f22ed4..8a69763 100644 --- a/discord_webhook/components.py +++ b/discord_webhook/components.py @@ -1,4 +1,4 @@ -from typing import Any, Dict, List, Optional, Union +from typing import Any from . import constants from .utils import check_max_length, is_int, to_dict @@ -10,14 +10,14 @@ class DiscordComponentEmoji: Represent a partial emoji that can be used in components. """ - animated: Optional[bool] - id: Optional[str] - name: Optional[str] + animated: bool | None + id: str | None + name: str | None def __init__( self, - name: Optional[str] = None, - id: Optional[str] = None, + name: str | None = None, + id: str | None = None, animated: bool = False, ) -> None: """ @@ -32,7 +32,7 @@ def __init__( self.id = id self.animated = animated - def to_dict(self) -> Dict[str, Any]: + def to_dict(self) -> dict[str, Any]: """ Convert the emoji to a dict. :return: emoji as dict @@ -61,7 +61,7 @@ def __init__(self, **kwargs): if self.custom_id and len(self.custom_id) > 100: raise ComponentException("custom_id can be a maximum of 100 characters.") - def to_dict(self) -> Dict[str, Any]: + def to_dict(self) -> dict[str, Any]: """ Convert the component to a dict. :return: component as dict @@ -79,12 +79,12 @@ class DiscordComponentButton(BaseDiscordComponent): Represent a button that can be used in a message. """ - disabled: Optional[bool] - emoji: Optional[Union[dict, DiscordComponentEmoji]] - label: Optional[str] + disabled: bool | None + emoji: dict | DiscordComponentEmoji | None + label: str | None style: int type: int - url: Optional[str] + url: str | None def __init__( self, style: int = constants.DISCORD_COMPONENT_BUTTON_STYLE_PRIMARY, **kwargs @@ -135,9 +135,9 @@ class DiscordSelectOption: Represent an option of a string select menu. """ - default: Optional[bool] - description: Optional[str] - emoji: Optional[Union[dict, DiscordComponentEmoji]] + default: bool | None + description: str | None + emoji: dict | DiscordComponentEmoji | None label: str value: str @@ -159,7 +159,7 @@ def __init__(self, label: str, value: str, **kwargs) -> None: check_max_length(self.value, 100, "value", ComponentException) check_max_length(self.description, 100, "description", ComponentException) - def to_dict(self) -> Dict[str, Any]: + def to_dict(self) -> dict[str, Any]: """ Convert the option to a dict. :return: option as dict @@ -176,10 +176,10 @@ class BaseDiscordComponentSelect(BaseDiscordComponent): A base class for the different select menus. """ - disabled: Optional[bool] - max_values: Optional[int] - min_values: Optional[int] - placeholder: Optional[str] + disabled: bool | None + max_values: int | None + min_values: int | None + placeholder: str | None def __init__(self, custom_id: str, **kwargs) -> None: """ @@ -215,12 +215,12 @@ class DiscordComponentStringSelect(BaseDiscordComponentSelect): Represent a select menu with developer-defined options. """ - options: List[Union[dict, DiscordSelectOption]] + options: list[dict | DiscordSelectOption] def __init__( self, custom_id: str, - options: Optional[List[Union[dict, DiscordSelectOption]]] = None, + options: list[dict | DiscordSelectOption] | None = None, **kwargs, ) -> None: """ @@ -235,7 +235,7 @@ def __init__( for option in options or []: self.add_option(option) - def add_option(self, option: Union[dict, DiscordSelectOption]) -> None: + def add_option(self, option: dict | DiscordSelectOption) -> None: """ Add an option to the select menu. :param option: option instance or dict @@ -253,7 +253,7 @@ class BaseDiscordComponentAutoPopulatedSelect(BaseDiscordComponentSelect): A base class for select menus that are populated by Discord itself. """ - default_values: List[Dict[str, str]] + default_values: list[dict[str, str]] #: value of the ``type`` field of a default value entry default_value_type: str = "" @@ -271,7 +271,7 @@ def __init__(self, custom_id: str, **kwargs) -> None: self.add_default_value(default_value) def add_default_value( - self, value: Union[str, int, Dict[str, str]], value_type: Optional[str] = None + self, value: str | int | dict[str, str], value_type: str | None = None ) -> None: """ Add a default value to the select menu. @@ -331,11 +331,11 @@ class DiscordComponentChannelSelect(BaseDiscordComponentAutoPopulatedSelect): Represent a select menu for channels. """ - channel_types: List[int] + channel_types: list[int] default_value_type = "channel" def __init__( - self, custom_id: str, channel_types: Optional[List[int]] = None, **kwargs + self, custom_id: str, channel_types: list[int] | None = None, **kwargs ) -> None: """ :param str custom_id: developer-defined identifier for the select menu @@ -358,12 +358,12 @@ class DiscordComponentTextInput(BaseDiscordComponent): Represent a text input that can be used in a modal. """ - max_length: Optional[int] - min_length: Optional[int] - placeholder: Optional[str] - required: Optional[bool] + max_length: int | None + min_length: int | None + placeholder: str | None + required: bool | None style: int - value: Optional[str] + value: str | None def __init__( self, @@ -419,7 +419,7 @@ class DiscordComponentActionRow(BaseDiscordComponent): def __init__( self, - components: Optional[List[Union[dict, BaseDiscordComponent]]] = None, + components: list[dict | BaseDiscordComponent] | None = None, **kwargs, ): """ @@ -433,14 +433,14 @@ def __init__( for component in components or []: self.add_component(component) - def _component_types(self) -> List[Optional[int]]: + def _component_types(self) -> list[int | None]: """ Get the types of all already added components. :return: list of component types """ return [component.get("type") for component in self.components] - def add_component(self, component: Union[dict, BaseDiscordComponent]) -> None: + def add_component(self, component: dict | BaseDiscordComponent) -> None: """ Add a component to the row :param component: discord component instance @@ -477,7 +477,7 @@ def add_component(self, component: Union[dict, BaseDiscordComponent]) -> None: self.components.append(component) - def to_dict(self) -> Dict[str, Any]: + def to_dict(self) -> dict[str, Any]: """ Convert the action row and its components to a dict. :return: action row as dict diff --git a/discord_webhook/poll.py b/discord_webhook/poll.py index 0a8401f..14047dc 100644 --- a/discord_webhook/poll.py +++ b/discord_webhook/poll.py @@ -1,4 +1,4 @@ -from typing import Any, Dict, List, Optional, Union +from typing import Any from . import constants from .components import DiscordComponentEmoji @@ -11,13 +11,13 @@ class DiscordPollMedia: Represent the common object that is used by the question and the answers of a poll. """ - emoji: Optional[Union[dict, DiscordComponentEmoji]] - text: Optional[str] + emoji: dict | DiscordComponentEmoji | None + text: str | None def __init__( self, - text: Optional[str] = None, - emoji: Optional[Union[dict, DiscordComponentEmoji]] = None, + text: str | None = None, + emoji: dict | DiscordComponentEmoji | None = None, max_text_length: int = constants.DISCORD_POLL_MAX_QUESTION_LENGTH, ) -> None: """ @@ -33,7 +33,7 @@ def __init__( check_max_length(self.text, max_text_length, "text", PollException) - def to_dict(self) -> Dict[str, Any]: + def to_dict(self) -> dict[str, Any]: """ Convert the media object to a dict. :return: media object as dict @@ -52,8 +52,8 @@ class DiscordPollAnswer(DiscordPollMedia): def __init__( self, - text: Optional[str] = None, - emoji: Optional[Union[dict, DiscordComponentEmoji]] = None, + text: str | None = None, + emoji: dict | DiscordComponentEmoji | None = None, ) -> None: """ :param str text: text of the answer @@ -65,7 +65,7 @@ def __init__( max_text_length=constants.DISCORD_POLL_MAX_ANSWER_LENGTH, ) - def to_dict(self) -> Dict[str, Any]: + def to_dict(self) -> dict[str, Any]: """ Convert the answer to a dict. :return: answer as dict @@ -79,15 +79,15 @@ class DiscordPoll: """ allow_multiselect: bool - answers: List[Union[dict, DiscordPollAnswer]] + answers: list[dict | DiscordPollAnswer] duration: int layout_type: int - question: Union[dict, DiscordPollMedia, str] + question: dict | DiscordPollMedia | str def __init__( self, - question: Union[dict, DiscordPollMedia, str], - answers: Optional[List[Union[dict, DiscordPollAnswer, str]]] = None, + question: dict | DiscordPollMedia | str, + answers: list[dict | DiscordPollAnswer | str] | None = None, **kwargs, ) -> None: """ @@ -121,7 +121,7 @@ def __init__( for answer in answers or []: self.add_answer(answer) - def add_answer(self, answer: Union[dict, DiscordPollAnswer, str]) -> None: + def add_answer(self, answer: dict | DiscordPollAnswer | str) -> None: """ Add an answer to the poll. :param answer: answer instance, dict or the text of the answer @@ -141,14 +141,14 @@ def remove_answer(self, index: int) -> None: """ self.answers.pop(index) - def get_answers(self) -> List[Union[dict, DiscordPollAnswer]]: + def get_answers(self) -> list[dict | DiscordPollAnswer]: """ Get all answers of the poll as a list. :return: answers of the poll """ return self.answers - def to_dict(self) -> Dict[str, Any]: + def to_dict(self) -> dict[str, Any]: """ Convert the poll to a dict. :return: poll as dict diff --git a/discord_webhook/utils.py b/discord_webhook/utils.py index 4f636cb..9f80ea6 100644 --- a/discord_webhook/utils.py +++ b/discord_webhook/utils.py @@ -1,4 +1,4 @@ -from typing import Any, Type +from typing import Any def to_dict(value: Any) -> Any: @@ -26,7 +26,7 @@ def is_int(value: Any) -> bool: def check_max_length( - value: Any, max_length: int, name: str, exception: Type[Exception] + value: Any, max_length: int, name: str, exception: type[Exception] ) -> None: """ Raise the given exception if the value exceeds the maximum length. diff --git a/discord_webhook/webhook.py b/discord_webhook/webhook.py index 861fa93..880c13d 100644 --- a/discord_webhook/webhook.py +++ b/discord_webhook/webhook.py @@ -1,10 +1,11 @@ import json import logging import time -from datetime import datetime, timezone +from datetime import UTC, datetime from functools import partial from http.client import HTTPException -from typing import Any, Dict, List, Optional, Tuple, Union +from typing import Any + import requests from . import constants @@ -20,23 +21,23 @@ class DiscordEmbed: Discord Embed """ - author: Optional[Dict[str, Optional[str]]] - color: Optional[int] - description: Optional[str] - fields: List[Dict[str, Optional[Any]]] - footer: Optional[Dict[str, Optional[str]]] - image: Optional[Dict[str, Optional[Union[str, int]]]] - provider: Optional[Dict[str, Any]] - thumbnail: Optional[Dict[str, Optional[Union[str, int]]]] - timestamp: Optional[str] - title: Optional[str] - url: Optional[str] - video: Optional[Dict[str, Optional[Union[str, int]]]] + author: dict[str, str | None] | None + color: int | None + description: str | None + fields: list[dict[str, Any | None]] + footer: dict[str, str | None] | None + image: dict[str, str | int | None] | None + provider: dict[str, Any] | None + thumbnail: dict[str, str | int | None] | None + timestamp: str | None + title: str | None + url: str | None + video: dict[str, str | int | None] | None def __init__( self, - title: Optional[str] = None, - description: Optional[str] = None, + title: str | None = None, + description: str | None = None, **kwargs: Any, ) -> None: """ @@ -91,25 +92,23 @@ def set_url(self, url: str) -> None: self.url = url def set_timestamp( - self, timestamp: Optional[Union[float, int, str, datetime]] = None + self, timestamp: float | int | str | datetime | None = None ) -> None: """ Set timestamp of the embed content. :param timestamp: optional timestamp of embed content """ if timestamp is None: - timestamp = datetime.now(timezone.utc) + timestamp = datetime.now(UTC) elif isinstance(timestamp, float) or isinstance(timestamp, int): - timestamp = datetime.fromtimestamp(timestamp, timezone.utc).replace( - tzinfo=None - ) + timestamp = datetime.fromtimestamp(timestamp, UTC).replace(tzinfo=None) if not isinstance(timestamp, str): timestamp = timestamp.isoformat() self.timestamp = timestamp - def set_color(self, color: Union[str, int]) -> None: + def set_color(self, color: str | int) -> None: """ Set the color of the embed. :param color: color code as decimal(int) or hex(string) @@ -131,7 +130,7 @@ def set_footer(self, text: str, **kwargs) -> None: "proxy_icon_url": kwargs.get("proxy_icon_url"), } - def set_image(self, url: str, **kwargs: Union[str, int]) -> None: + def set_image(self, url: str, **kwargs: str | int) -> None: """ Set the image that will be displayed in the embed. :param str url: source url of image (only supports http(s) and attachments) @@ -146,7 +145,7 @@ def set_image(self, url: str, **kwargs: Union[str, int]) -> None: "width": kwargs.get("width"), } - def set_thumbnail(self, url: str, **kwargs: Union[str, int]) -> None: + def set_thumbnail(self, url: str, **kwargs: str | int) -> None: """ Set the thumbnail that will be displayed in the embed. :param str url: source url of thumbnail (only supports http(s) and attachments) @@ -161,7 +160,7 @@ def set_thumbnail(self, url: str, **kwargs: Union[str, int]) -> None: "width": kwargs.get("width"), } - def set_video(self, **kwargs: Union[str, int]) -> None: + def set_video(self, **kwargs: str | int) -> None: """ Set the video that will be displayed in the embed. :keyword str url: source url of video @@ -214,7 +213,7 @@ def delete_embed_field(self, index: int) -> None: """ self.fields.pop(index) - def get_embed_fields(self) -> List[Dict[str, Optional[Any]]]: + def get_embed_fields(self) -> list[dict[str, Any | None]]: """ Get all stored fields of the embed as a list. :return: fields of the embed @@ -227,24 +226,24 @@ class DiscordWebhook: Webhook for Discord """ - allowed_mentions: Dict[str, List[str]] - attachments: Optional[List[Dict[str, Any]]] - avatar_url: Optional[str] - components: Optional[list] - content: Optional[Union[str, bytes]] - embeds: List[Dict[str, Any]] - files: Dict[str, Tuple[Optional[str], Union[bytes, str]]] - id: Optional[str] - proxies: Optional[Dict[str, str]] + allowed_mentions: dict[str, list[str]] + attachments: list[dict[str, Any]] | None + avatar_url: str | None + components: list | None + content: str | bytes | None + embeds: list[dict[str, Any]] + files: dict[str, tuple[str | None, bytes | str]] + id: str | None + proxies: dict[str, str] | None rate_limit_retry: bool = False - thread_id: Optional[str] - thread_name: Optional[str] - timeout: Optional[float] - tts: Optional[bool] - poll: Optional[dict] + thread_id: str | None + thread_name: str | None + timeout: float | None + tts: bool | None + poll: dict | None url: str - username: Optional[str] - wait: Optional[bool] + username: str | None + wait: bool | None def __init__(self, url: str, **kwargs) -> None: """ @@ -294,7 +293,7 @@ def __init__(self, url: str, **kwargs) -> None: if poll := kwargs.get("poll"): self.set_poll(poll) - def set_poll(self, poll: Union[DiscordPoll, Dict[str, Any]]) -> None: + def set_poll(self, poll: DiscordPoll | dict[str, Any]) -> None: """ Set the poll of the webhook. :param poll: poll instance or dict @@ -308,7 +307,7 @@ def remove_poll(self) -> None: self.poll = None def add_component_row( - self, action_row: Union[DiscordComponentActionRow, Dict[str, Any]] + self, action_row: DiscordComponentActionRow | dict[str, Any] ) -> None: """ Add an action row with components to the webhook. @@ -325,7 +324,7 @@ def add_component_row( else action_row ) - def get_component_rows(self) -> List[Dict[str, Any]]: + def get_component_rows(self) -> list[dict[str, Any]]: """ Get all action rows as a list. :return: action rows @@ -345,14 +344,14 @@ def remove_component_rows(self) -> None: """ self.components = [] - def add_embed(self, embed: Union[DiscordEmbed, Dict[str, Any]]) -> None: + def add_embed(self, embed: DiscordEmbed | dict[str, Any]) -> None: """ Add an embedded rich content. :param embed: embed object or dict """ self.embeds.append(embed.__dict__ if isinstance(embed, DiscordEmbed) else embed) - def get_embeds(self) -> List[Dict[str, Any]]: + def get_embeds(self) -> list[dict[str, Any]]: """ Get all embeds as a list. :return: embeds @@ -413,7 +412,7 @@ def clear_attachments(self) -> None: """ self.attachments = [] - def set_proxies(self, proxies: Dict[str, str]) -> None: + def set_proxies(self, proxies: dict[str, str]) -> None: """ Set proxies that should be used when sending the webhook. :param dict proxies: dict of proxies @@ -435,7 +434,7 @@ def set_flags(self, flags: int) -> None: self.flags = flags @property - def json(self) -> Dict[str, Any]: + def json(self) -> dict[str, Any]: """ Convert data of the webhook to JSON. :return: webhook data as json @@ -577,7 +576,7 @@ def edit(self) -> "requests.Response": ) response = request() if response.status_code in [200, 204]: - logger.debug("Webhook with id {id} edited".format(id=self.id)) + logger.debug(f"Webhook with id {self.id} edited") elif response.status_code == 429 and self.rate_limit_retry: response = self.handle_rate_limit(response, request) logger.debug("Webhook edited") @@ -618,7 +617,7 @@ def delete(self) -> "requests.Response": return response @classmethod - def create_batch(cls, urls: List[str], **kwargs) -> Tuple["DiscordWebhook", ...]: + def create_batch(cls, urls: list[str], **kwargs) -> tuple["DiscordWebhook", ...]: """ Create a webhook instance for each specified URL. :param list urls: webhook URLs to be used for the instances diff --git a/discord_webhook/webhook_exceptions.py b/discord_webhook/webhook_exceptions.py index 5bea713..bdf0b8d 100644 --- a/discord_webhook/webhook_exceptions.py +++ b/discord_webhook/webhook_exceptions.py @@ -1,6 +1,3 @@ -from typing import Union - - class ColorNotInRangeException(Exception): """ This Exception will be raised when a color is not in that range. @@ -8,7 +5,7 @@ class ColorNotInRangeException(Exception): A valid color must take an integer value between 0 and 16777216 inclusive """ - def __init__(self, color: Union[str, int], message=None) -> None: + def __init__(self, color: str | int, message=None) -> None: if not message: message = ( f"{color!r} is not in valid range of colors. The valid ranges of colors" diff --git a/pyproject.toml b/pyproject.toml index 9eb19ad..6add164 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -41,8 +41,7 @@ line-length = 88 exclude = ["*.md"] [tool.ruff.lint] -# ruff's implicit default ruleset widened in newer versions; keep the previous scope -select = ["E", "F"] +select = ["E", "F", "UP"] ignore = ["E501"] [build-system] From 5b8d476f1f72fef62699b9c4e10f95feb3a7d3aa Mon Sep 17 00:00:00 2001 From: lovvskillz <14542790+lovvskillz@users.noreply.github.com> Date: Sun, 16 Aug 2026 16:25:01 +0200 Subject: [PATCH 8/8] update example images --- README.md | 4 ++-- img/basic_webhook.png | Bin 7981 -> 7327 bytes img/extended_embed.png | Bin 172546 -> 111608 bytes img/extended_embed2.png | Bin 26443 -> 23428 bytes img/extended_embed3.png | Bin 20913 -> 24490 bytes img/multiple_urls.png | Bin 12796 -> 14397 bytes img/simple_embed.png | Bin 8951 -> 8499 bytes img/webhook_files.png | Bin 148836 -> 235395 bytes 8 files changed, 2 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index 34e8913..0c031d9 100644 --- a/README.md +++ b/README.md @@ -40,6 +40,8 @@ webhook = DiscordWebhook(url="your webhook url", content="Webhook Message") response = webhook.execute() ``` +![Image](img/basic_webhook.png "Basic Example Result") + ### Create multiple instances If you want to use multiple URLs you need to create multiple instances. @@ -89,8 +91,6 @@ webhook = DiscordWebhook(url="your webhook url", rate_limit_retry=True, content= response = webhook.execute() ``` -![Image](img/basic_webhook.png "Basic Example Result") - ### Webhook with Embedded Content ```python diff --git a/img/basic_webhook.png b/img/basic_webhook.png index d684c8c40b92caa4cf2a10e0b9c42d369cf6b320..491f91ef3933d568c0354c08d7cbe2a8c683623d 100644 GIT binary patch literal 7327 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%0A}R)s4$3F2+%*GRM|{3QDo{ zqL!)}P&M!aX&~;|w;xD8wOdsKss=7I4XB`WnLTiIxT*%)x&~BGYU@u(l~2{cWu^fY zlrFOet`1k#KwH;<3QBGL390g_8o10fpn}q6_Q2KQsv2nP8c;#0tv?}EK2-yknFdr) zy38K9I$Tu)ZCwK@D7Ez`q{^pi;4;&I3QCvR16PNuYM`xaKn10?{)ANdR1I8a8c;#$ jGJD|aa8(Vobq)MKOqZ1)G_D4000000NkvXXu0mjfUAl$a diff --git a/img/extended_embed.png b/img/extended_embed.png index 56f25dc2a13b91449a37cb76171f44f54e311f08..7c69255ada7d66897f2e52aa1853881634f98b09 100644 GIT binary patch literal 111608 zcmX_{1z3|&`~MM8M@e^gw}8k1>68}6K)Q5vNP{5Vozf+elalU{(%qd(cm5yV_x=5M zv1_o6?L6n)=Z??$-l1wLa#-kO=txLNSPJse8c0ab%#e_f$w4oGXBL7tih+k`P8xEO zNaaHmyTBi)mJ;tJkdWZf7I|S<)MFEb{h^Hdaae8$jp9%?3&}fQ z1NB%2JOYKd*|tJ_W*65F&AwWf`J(B`F4$+5tQLih4TX){XLVUVd&Nav7xTkaW>2@f z`Pd8$zNg!RsG0xw*w|QjXbhU8tgI}8$$w@?@rnnFcaF4~B}w zz27>N3U4NiLn@6VED2wUo*6}nKhSd+wtUZvdRypp9>Acp5TxrQK9pa4o0G7k-`qYr z_si?}-=OavcrUR>M90#si34Iu?Kr$4HT!9J*_Ma*MT)?s{g=7Zx-(_5YNtu1jvoowqjnab<86u&IrV`Y5M3Fj?z8kJqY*{@hlZoPBYtKUpY|9!O< zp2BbW#q#`v<8e2!!@n9G7cN_RU@X&reJC|8{iJ~;Gw@`}JoM@$#~Z$!J*ctd^Bfp6mKicIh%2Mrp^9%d)jsQn4N^-V~$6-RwU) zs$Qs)(Xm_P`>Se?ZFg@^vj4-Q?qJ&OaU@e$1`8uF1M3;#{CoyPr8oWL!Sy0uuHT^D z?50x-ovDqTt|G*CJQvHphUkIdVelztQRa<;ZNu*Ncb^-}-*+b^EXnLzY?DLp1symZ z@3!d|yiU364;uEb+p)Q5q6GLYln+aPFDa)r7;e)cp}Svg9Dnn=uC~1137#8XR_KX1 z-W<=gVI4lMk0*B6@q^X2BqncpCk+DDh)*Y~{_h!lJ!yg_5z1lN5; zp?-rrYOI#&*spMRw=Hh-o8&)>y5!Cr){Q)E;7KU7=xmyv_yEjtjN#pyWz#Xf#zAzo$?ZGzM`*b#Czxts zEX~w>>e#mN9j#$EM8WV9G;cfEvIOl8A1FNT2Ks zO~RG(|ebUwOZ z4J2dpx$F@<+_tuk>0;seiCxU(q4`r>E7&7l#ae4sS@*AzqQ!1VGK*$l70pO9wv9UcJUs7epqs9(w>EhhUr^`mS}B96Ja`Vh z4~@P4nlfi6Y;gP5W5fxH-S0l;Yq2>_f4n>@F%AC|JSrmX}7%=&b{?ysn9an zGVTA^?CFq5mdIgK<7v2dzo1@#{3jB!-JVOSFH3OmX1IS(X8-AWiIF6>#}{JUXLb#A#3>f$?qK<@hmPb{;e8bYC3Rf%&l3C5;?HC zF8q?qvKDT5$Nfs|>K}#I(R@ANsDN2g^}P|FeKK3ugDnWg<+87@X*zS3SJ<1Wv$M16 zni{UAhng7dJr3%<^{Hj48tv@H*9ad^!F_q-*)O({rqLl+JHemNE-~?C#G>zEf2Jz1 zR7KAj>K?X|1B}by){XzZnDtK-1CO;7-h;<~Yc3yH3bY#+y?vY0g`F&%&UkxHhg@5N zd#F7Fa&mJ1YkMVx8@o;_`ukSs!{0PQ3GWJ5k`lvKY7AeNbf0<`4hzGbj$fGWjum*V zlUq97{_{m$5vbU8TUu(&W8b zpI_z!WCy_ltAO`1?~7wZm1r~YtogB~)b*Ft^lSGeeUvC2-4uF(iD3F9rW3Iwzs-t_ zg{od#wO_Z@zvDLgaWenLhVy+Xu`JV)vbxpP;Kz3J=TuEp_70*8rB{0erb|8al8h`(@@>U@%3vr0TOQ!lO!2;=-wFs`mpeD(W+9v6o^; zwpU$pNsenTlSh~LleQhpQJ*RAeT(+77tVU)!%FRzJkJC|5Fe^o{1K%PuQTQf81~xI zy!&f8eY$i>HC2!P)vPq9?KvQoIIPd@+&XO|%@y6h z;urQ%d4B&~qlj}w;XI;8?ovB{F!{H3exE$+@hEs6tuv&oZV8W-@$vBSz6Eak9?d`d z_@THcQv&4n4`w(IsohL+ItI%WXnf+(BmT08<`HHJGENz5O_&`g8d>HKY2&jw;j>`$ zqndNOJ6`&8RpBJK-a6z?XzA@s*7`}fbh6Bl8q6J>;Ln_OM+}9%c$s{4IJ=Q=r3~c zLk~&gzorzwC1Ygqj!To;MRWrp?lmkC9rt?`fiD@v@bL?m2BkbyA9>$HmeX2t(_kA$ zNmLHV#OzJj#J)>^Cv0i7n$O}-TKAC1uxU}o7JR?FF=k-%Y9u(yI%Ms9dRe|+-?;Vu zf;M^JnEKHHDNxc+)oYF5=JpoS;7q#waN(N5Yx?5$UmZ4rq`dXv1&|)jdLD|V3Og~0 z{H>&%x2Y37^xB?3_KpU&|9heP?|tzv-Ofwu%zG$Zjf{-=8vk8*0Na%0V#$-6%I7MJ z!=Nd^d>{$Fo$1K~#FH}Z?YmQMGiT@OQywI@L(k=J8exn|Nxx<-DolXSUIm<>AF!Kn zgJ_fW9Z7+J#BzJs%I&l@Xi-vDyCzWKj&e)5|@1m}QOe{E^;`7-Mwl<9dv z>LtFiBDFNs5qMgxy%_o1rSXs8GV=1J?r-~N_wh{d`-@Yzwc|mXSoo@LK_J+BNJNCV zh89(s^y~d4r0dpkKvDLkd8bJGWdddnU(n~teGnB*>8O-FP<R_SPMeG_Q1#C%(U{r_SG*@~ksXBo}4`m&{=S9iY(J1xmh}3f5dbDW2)3E5gt^mDhv+gIZaG;bKoL~Pn z)NLb=b|{8gn||vhWj0L+V~hri29w(bO-4%k>f_#6)M3#N9#bnbT{4g%g~I32(KSYVLs7&a$1HF&4@KIQw^UMu%^+rF6yAk0-- z&z`(jjCi&s?y~e&x0oEcjPo?>ZN<}P4)`acJE~@d`+X!;6kg6LT9XZ)yfHr38hm#9 zyH=-r@4|+T-~9yXX(zair(alFTSwUWoa$wKc=$KL9({V*xHJ$K=sRQ8QCef(*CBoc zJdtkhIp8+?OCz~Es&QGe*mF~~Pju0K;r8V&S7a1@Z*k~+Jy^zw{L#)(47$6PTf)T4 z=krL2v^lzc-SaWnnd_;LOBpGhkR007$xM(1G4~eahKt(hew(5i2x5Xe+kb`Ja<2WI z>Y20LT|pWMX3D9VhA(NbCG74R)XbZFxJ?4;OHHmZcv*KJQq$dGA{5PGV-r6yQU|)JhMAoX^uz;@@oYf ze13F;h52J}Ca62BHIv0bu5}B4eOnS(F}F?HfVNXGknA}-yXA$RC{m)(OJTckK~Xp) zAs+Fx;~6H(W1ps%`Q_~{SALr`F_q4@)bP9Qe8S>=T5qdvs1kvU!d!p}uqh${lXSnT z$OtD3h^=y-$CY+ygA`yib~F&eL5QD>xo>tr-cF+=t85EhC3AHGj2?fKvf}vY=}k@W zdw7>*Ble)hj@ms``P!6!^)cIaSne){`9XR5;VIDk*WmjO2HUGi3MyXN9ytSF0I{%)W+k>iJ)uV$!(G zCf(;>fklCs+1F3$8U0)H6yxq2G_+`yDg`E*T$KBX1MlJ zv4w%l0xK5a4J4J#YFX?LC~}&8-3+(g(Vut+b31tc`(oSvVRPL5Q6nB~nPpf{QkCZ2|FqwF z0V`xmwefgwiN(6{ac^*rZ0Ip%ScJU+>VhJp-E&t|z8T2eI#utM(aW&`%z=P$JUr$Z zk*KejLr-brx-qBLPZ$?sMV}S++o4wcJO)viARmD&@c?R>t zv0>NhRYt^rUVI6>h(xbsXYrsp{e^4E3J8f%*`x;6=%*cIP+mF}ywLws_OMyYIz-)l z{aE8BCNWa|n8Yvi$U35iD^8mJ-A$K4raa+j$Ns`=deitGA>IP32>(!=-<3S392)4Q zl@QaI^?qu`-#Zc^?{g}v{F$eMOq zS+kJ;fJ#hC>XP?E8{fVyw5DTYDl{?qtc`CRQrfQQmxx?UprL4D%2RBl5J_&p2>k6_zC5akW--L?ucPASGHNV}W<<_0|czW_W_Bs*(d1AQqyB`eGvI0**X zW!kG;Tu|wAQtjSI&cD`7z(jRp%b~5OG>mpl(*MgC}u1uH-xVUsawUCNl6MODn8!5R>^!g@rIsWHSRRC{a?l7#G5 zLs+F@+h1BkgVJ=gG3~bTz(2)uV`3AU7b15cZu%{-&PLf0J)v@gk$}Ms4@}#uAhE*g zrK)zsD6ERZ;)f{r_?!?C@g7r?im7xG1QW=GM!vy}MXaGo7`PLBqbTr-(%@3nDVNvb z$|krxC61>HC)7q!nqfzLu-+XQJ>-H@j#GS zL*Wn`_}4gpnTLp>LZHG|u=pUN!Go@Yiu~(b3n@K`~K-|d)0 zN}N&fp^p(N3wYXZ{c03qC9`oz%6Or9U~I}B`Q5vTA;l!fv&{qDKG!nx^iu5l_%{?A zz}`YEKe*uxgCF7(w^|^CHG4F`@AwZFJ>T3``zmY*czud1CA0I}*g}g4{J4+vrQPs` zHLo(I75$hQwB-{LHk!|G(0~!LX;c%lw;{nRNoYqjatpf9w_nzNTFyW%MjgWkQ6H7E z_a|z7jU)`^V8o|o{=_3nt1gMh65VvT>WQwZkgv6Y?(VhBY}mX0Qp{k5KGB&n;!Af# zd^+F0Ic>CD4vbl`xgxK~j;i|rNK}i2w%W!Wq?>C)`gh_ZFh!*Sr%leFKGJZc0qJe7 zxrSh55}a*$dF>wD7=={l;OXV#$kT?_NU+M#tdbTw3ns?G75J)_Y-#nrvwS<9Z_xdU z3K>5_)Dwpbz6c19v%-9##QB-NG88l&uL5R$?lT5YCRqz*r^j`N6;JGKI7&D74eNpQ3gLxYe*)@?lbgw8hw%5TTM&(jL>!9B2K z$#GsVCgPiIGkl@@jL%y0I)6U2!t+q!Qfrq%7|qj(^UZM-oqt=8QO2S0?z=iBv?7%L z#j5c|LuSE38q47U@|dPy2>~=k1n!18@jMjl9I=6F$?s2$rU+sOgJq|Eq=6l*_X;xncW zJLdGy2yM2A4pACo(aGqPHC-&I1*@tN_M>IfJli(gsi1NU_v}yZ(#S!$3o35W?bO`SgXHg z77gV?+DK4hEp*L_btQh}h~QXZEV^fD@Y0}X^jLFLga2#{6;7o93^I9lyy&TTfo~@1 zWhbn4VE7IKS-&Sq&;7_Aky|JEmprvzp*cQ;{ceHIQEeTiqOUJ^UY_aMnKOOBN;fg_ zY1ZR4>CZ_v>YI_+C+=|MO%3B5NaEZch!;n++#YnUtkB%wds~(1*yrgx zbTe)^K9iE72a2XkNR$_*8uC) z;7Z=z-34YFU-d2=7`Bku<7rm(Ndb2~m?Pu1$*fOf=*{{7hhA+H+>o?H?v?m^*Orht zyic6ZR%W}}X-e5YO)H#yE|Y*oYM|$3?yyRvhoW6txV!Jgy& z`0x>@i8-6O?tm-&U+sL9Lj3og`&I0^Dz9rCMOFX;91i_lcYL@e<^zNMYmxwdoD$B} z5C9Nh3?x>@%znn6VSzb9 zWTy9fme(f|RNiN32n2#`A9}q`{U}W!Gnmo%9H=nE%9G0KGL-yUd(t0dS{CJ(rOkeZ=H>c&z{(j!X)eZX(MT) z=zz$}hDjUrHmE^hqO`z*^TWELj2;_28xKQPN@)^AM*z3)&gPL1h+!#K)4;n5YdhUx zBT8AA2CUt{qcQC43*j!?R^N3?yb~-|f#sJ57rGQ{U`&_?M6PiZf*+DQ!V^T{tFQo4Hm_;xoe#4cuw-06YSHd^NIM-D9~iH}?Go=htaJ9B&cm|$uj)M3r0 zZPCL6{Xg4cmoj2^tLwmt5PSVr+J1=Xd-x2P%M?@me)m0KrO~8RRJyBG3I2Y53haMR zg<2d0jY;@CFK)VvTJTt(Kl3|jYp|~yA*pr|TY2L!+Ks@2g$PX0NijzJkWEu0(Fhla zg&T|Mpxzb1S&&Lft3I|Q6 zDj-@CDyr2#c0Tmy9#~~q_4;k|OJC$I&$0Y9&|#dDp9#MLD6v38Mp44fPBm|7XXi@W zf%yqV0aM1R$rL}lJvT+^b)*L{=kWT~ppxq@W|fZ9w7ySML9dJdkS`s1*ft%L0rAJF zchiyFrMx;BL$-lOsDPmZvgVP&5)sk?!tb#SLbq8c;dOhrq?6!C^|AhI?qR)piQ)=- zXpug+MT0BIkfw4DrzeditT=c`=X+SCLM}59j4nmJhUr1zllreFV$p4AjzdnNjn%rB z`}@lhOughWxsF_DI0OY4qoke}>X|p^H5@msS$r#>ywDVXZm4kembl!aUCdhAH8eCJ zr3gE{m7~6=T{@1EBByi)pk2ezdxW_S%682Zh?b1VEk`XI!eJC)?&kLI^ac3w4r9S( zdQqO0B{6Nh41o4i6z&_h00X4H-!W;qsIkK-TUYbW7)1MWxp;YU;M!WD9tA$>%=o~s z-6^kc$x&MGME0p6UsV-ngmPo&mE#%eGtv65ncs7ni+27rP9HRFD-Pv}#3UfgjOuK7 zDXgF+;Ds&=yYNG*N2TY`oJz5vJt{vsNva(lOxEAtSM$1QtSJyk zL1HoVeKh2KlE%rFP-`lHLCtP%J?H1#kGs1;v@@Se%HFJnbn1{F+XHMfx5gs*TG*x57s3^{BdvwQg5THqeCqD`_-72SPyRx#p2F_o?hDR9aIH; zjQVshZ`jjlx!dIaqWuSgRA3iS$| zzD;ERwxS}O5xp~#9kjRD#_>$}8(1MYwh`VmoaZx@TAtD!%wtJvERv|*?_!9Fo^6Qs zL7FaHk0f*2ru6IrYmxx>Tx7Gz?c;zk`59~Za@I1-yM8UKbzQZh2z zlE;0+WyNL#%ZtCMz=>)wpZCo~?Rmz6$G**i<3Po;Hybf^fEO5)P3UgWDATV0SG#Pi zw{_BR*mCQBckGLc`V5GkFLw?OK3_FXC+XQWNA6cVk{SuGd=+wRduG=Kz1lZ?oYNIB z6*${OzVQdgpSa(gK5uCL3dS>k*OTT*!D~XF6fBT5z0Xnh!5t3n$LN&epyH}>{?RdF zl`*O~XeCgnj|~(}#uTOz?IhpM82k=bUyAvxtUjlbRj9_3?$8hl8u^?|%Js!I!fQpd z_xaUWy%;ccIH*_n9NTV07fF@09ZLq=+-8mjYYGsJm!=#LiA8kuu@wv{Gb4^K&FvtG z?zYymhTvv%Gizl*A*Ff5xGv4FpwFE7F&O&6`e{`pF~3puko|BBPSRdg)Ivxbalasb z?>`6Sg+Mu#Ur04l5DUK7W&b#nPJl@2)PK$*Ll265Mt@MH4I`u((c&^T2lPr7B9aCFF!w%(Bj2K<$njp9y;9o z9=EY$rW|3Up>#nVWKzbF?a)N?N%VoA9}quzO+WmB04o<+JYn+lJOtV-JjOLeX2aQX zh>I#Fv4VRg=Dtb$EK~;SSJ@W>ThElPA+)7H8Y|e+!dp&OKCqL0P)6lTmgxwx*R{4G z<`Mpy22U_$amUe1ey(I35|MB5T`gLg%eRynb=Xr^Y$GDH-MYE@_{@@ng*7ztmV8=P zvuv7W%kk`5Ec4_j!75@UUcr%;wLnQTz3WxHnP+DMLFRBYCa$c*T8F$o_0;=|?EDTL zDoJz`jFvc>=TmRKv5XMWbHFE!u+mjYSE5!g?E7oXO&d7)BvfW_{J|myJ5)JwS^>>| z+2xB}FXkHFxsAGU@FvhFJ6pLM-+So;d?I{lbURkkgmw;VT|B}>Jdz3Si?d}yJ9Z9aiOR61{+oqvQ-ASa)98Cxhd*vw$acCI|JQDMQHAME&j&+@XiM9m-%h~Hxw7<$G?)UA zWbqEBd&U;6vjlXO0yVq<0{ML=mKsQa!zhA_MnN;2?&q)W()WB0H~ms%z&Kafae^S} z`QvJ8(WYLTxU#soFT!asO$*O291LCVC6}LyTdwdYl2}*~<7yi$nb}kX+Q)q>D9_-x zt=_wxIx+v}OyOQRePVb+p;;PkQ4KY()-bnnj%XiMPl}G>eXVWrTLXBuK)*u0?gcls z8rudd(aFZ?GYK)81Jq=b~!#!jGn3~K+<^9panyaf(}SQKcqm?s(PS;5_JRPxnm%*1Z~^E z^_B1?o0m)kZLI=d4hy1-%jvrSQAGOdnwZOD@a_pUJ2s31K6TaS$%@+X70=&9Os*-a z-sIuqe}r&wgglCasEI~#SAIEO^EKEn0f*eW^cd%iz{!~q-I?%Y!^yotNhYC)q*$vs z2sdYRqNbf@1o<_MXkdar%O6*Y#zEV+tk-QtDHv)RJR{QsMCpH?na1?t*lY?v@=g8j zI@eYk++b+jk(+CDZU_Xt!AZ4=kQ1jm!IYiwXPGa3%=IR_9EL$k(*A(YGU8ka9fnZ~TvFYjP z_l_nIp;lHBkXM!ld?W>_!~GZYt5h0GGqY0O*k}8<@@ScSJNkYHl2obr&wjwZspENJ z6S~PW!s$}~pj6Ij93eNHKEDZj{=%an1z79+a$96oUXAiMuJSc1Btcp~1spTYs&x5h zy@n{lu92HRe&m4uZgY=(E)9Q?&h-1GD!Ny3NKLAJu?e39aDo6a4S3Fui5zK(1&XY- zC5kSWj5_d&YT8~!3l|_Ob&18z?2uDC^Zq$Wmgt!1s06U*ZmVy2zj))r1(I~^_>)_f z41$7#-A{Hcfuy~#t}YpVLL&LQ?UF1(8 z?<4H!IJmUm;Ka506O)6>)ZfZZ!?b!3B;=HgKZAjja;-T3ap=gLiAgvPm+fq5UHVFO zV@WUna7)`M1~D(RJUc*!O+qY-IZR(xhE|&XUr|xM(w)U?M8oxE0;KL!>;E?$X{N17 zekNQNP-G#EzL*Is2Nh9)DLO=&B)1w-7v%5%4jSR$v^hyn{A-In)Or2wckUTz*fqG` z>s_g75_Y6U@gxbm&f?%$rX=VGQ;xOYA@g;N9=Lm|faNG&?KdK(8BLO@7nmAY6f;^b z=o1#-Hh)=T0G#P~85$6ZmS3==@S@>_0L2fFSNPN73eM)Q8eQ0ri9KmJQ-ppw1}j4% zG;$Pqqb$oF=P%Z9F>Q#c7bvC5^Q&Wfk`?UYi2r&k>w??+3TWZ)3IbX+bi|Mgn}L6JdnK5+!#nt7YUGoMMwwX1j5Cb zke5$GYYMfoM-jOR49OUf2CoeHD>gEJJE4MXjS8@}E^rsh6kB|uL2)%BJEvm|DS&L;ls`|ki*bqY-uLO0`8 zWFelp_}}erxyH}K2`2^_-=)cy+Ji`82>0!bfk+{PPR3+?=^QmHj%7e?_j~WBQvERk zcC|()_#7;i*|u0V7~V#OmSyAVeFjx)STPop{jq8uGAi(|%}$^L zA%i#ZQN=P3)ypU1STK`)Q>Bk=_{h`XM6e7`RC+Z>6LZZ$RCh|C@FWj4eXpYvx*jFc z0Kb!>zCo(jj{+D0F!-sbaRLgq!I}BDPEHMjBvQ==+W?JfZ(P0?QxUtamdz;EWNxga z<-XPIg@{UmN^9j)&8(`7N+sBYzNbomeZO{_i0ml5%|FDdMgkO@pwNp`<@wL#7b0i> ztef|3-R?C*92u))K&;22*sA?zYg)T;6D15BD!)erhjpw>j}p3&K6WFw6tQeAuEfzm zS~t$f)Bm#R%RL-E+HM2V8(C000Ct~b9#uV5jeuN>2m-4IWGe0eCVDI6sc;3bHL_sJ zFQ`vsd1q!mzJpb>& zIcUBHNOd&hR1HCcL`ZNoS2wijw0y_)lJXi?Az6II#m1qo`gc!$Nxm zj`nC?N=coAswp`gKe0iK7u5ck5m}W$O{_89qZ9mS(Y3Tc`*ZsaBW7e?4 zu&A&3%^B%aNkl?Px!#4Z`eG$M>kd`qUp2iVYiSLKp;)i*wpX+qm3x5HE8&nQai53i zMlZcMX6WteWW~~xw&FXt*Q!$F@UXae7Ab$>syh|7_#Ft)Blx=fjik5Hg#GzH5DqV| z`6m-j1P4ThulVjySShUXd~$aB%KIdOYiv4E+*y^ z{SeovbPZFj;3gi3@z8hSLEi)6lWSyci8B38{J0U>4HN)e;u2M)SpLwri0jAIg%F`F zISls99!I|94>ESMN}$<}AKqk%#&nwMiDqDKljZeGaFa9{?c@2RBnJ8sj4N7zw+W2| zLJD=@XxjHf^|HVX^)L!pI0O>vo|CU=;tD1T*+8iKd`Hh}d+jcRGhwS&f?X zZz|H80V)`EE*(gt+6tv4k;!oK$V5Aiv^Q-s=L&cb$Ex#FP4I#*4IGEiRcmkLbsi9iPAsG z_EB{4No>P9{aI^|)|f=IB(N(s#~}JBF*#+OGYHiv5aV~{C);qdS?MZ4ehC9ru7({G zK%(oGDX9o3@|3Q3RqdX1O%~ytf}PNTVV?^Ov8(pH>xm*Uxial1{GU`uF*7^C#+uCT zwWpc24j9LvP|I=I&?M{+Al7PAm!ni_rZS0GebRjY$cx&%*|*y%?SB%GcANM))^`X@ z>kk8HrtR^5nVJ_-d4B;w`e8RxP5v~T@Fagl692e}#Ga8UlfZX0-^Hh2yEv6SX zfP>3Pl4rPSkaw@!8HDjS&hw#VCxBa_GUaffa9WQPM==6KgNRe`+8Y2RQhn>nKpygWk{9V>-q%p&c6eO)emtuK8ZH>r zljVh{>Q3N~WV3i=#V88iWIW&thfjIyh~`4Eb;ZE`ggnqPJkuXRxUujqe5Gi9i6tCN zEUfxL%_#s+Pt@O-cb;s1Yr0)Lgs~SNimWHLLz-pH1bBmTfV>0!=Q$btc@9G+b8Jg6 zGdLhdKIaI?LlwA^rR4qKX?EW0u$f8~Rk5D*i}~Q$@uJ+))yvlANMd468HTCqw)dkO z?qiHNap(p5OXvj)n#Cs!5?t@}2CT|tt+6^c!>ZC`lJr?n0G$(a$U4dJ>CBgT8`@n| zj>Iqs?0UL2(|RINgU4wL6Fm?aIDxVGWWG)lVAP+$nh{QZw{NIwQdUq@6bz78aU|d! z!IT%7wIqKdlEsa!;fW!V)~Wg|Uu&FQU%K^oo^o9KcYjtY$5E@0V`&>tYKlYklM{&8 zCBnP^JFb6UAI*0+EW*nT4su^bJE-4Pe6Zh?u`c)Wz}fKo&MW~ON^&{Eg%gK$YoVl;uN2i~1xN1juo?@a^BK-fbsf zkJ~n%3np>uMe!!-bM@4@d{zClW@ZY zNdg&EKUJ|T`Y3vz`+dFQ$A=tjE! zQdqH@u7fOJiv|^5yCJGT@)_}&7XW{~ijaWGnKyJr4BB#M2`5JM=zcUsuNleJM?N(C z7^kNX6U=9SS@69hxjf^w4_%aitt^w@Hf!$4rkEgtE`U6HjTIZiE%Rl^AGlC#?^+E0 z6yqyl`t?LaPV_QvJ;E+BvZSBKAg7APg;5tERnMQyzH}7xqmp%nOI-t#(cf z1`aY%xu_HH)z5UV?2t&%%2{(x{umO^Q^*L0YnwSdrM>A4p_fUJ9?VzKI9Fnd*V*(5 z2`t=l*$h_iS6HhBHwq+4m2_IZMwupYQ=9ayZF1;|DO2d?far<+2uTT*cI39+0?tC(;ZHtT`nSA zykrmlFjje)WK5QuXOoH{aNCvOcDe*W6d;4sO$Kw|{{X`RqY16Q{_nS8vGuiC zMBqysUV}*l}^W%Vml9ZP=N8rFXygaO9 zD?&oDFcx%ebv!DzRN$Di(0>eJ5{ITNx><{I1ePgI=|MIoFp0bF$03+q$MjL z_4x)^!R#YcIhw?VQD)e(FMQy~oB-ktb)T=>+dt%Z1>eJW70?4I z3MBpfsaMcsC_c#!5bmjm5M&21f(YQFTw`=$M+uJguk*uWH8V}BHH_`e5?I1S{)@Sv z*aZSzfdD2HoGD=S>|-~DR3e!aJ^cpQk0_25C4QHSpm>sw?L1`LP#-ZK{?dJ~+jxt+ zq7n#*?9Q5X{vZWRt&SMtU|C&)BwZ7!AkoO(KI2BOrgy8J$jh$0!y1rW9#oip-epFh zwLO0%YKy8ECkKyqHSjILi1*x##dEtU_P+n_5Knu^nz zzr>~3k}q_o5%A-CepjZ<=CGJy$A8DiG+D=TPsaYBIq#C=bAMKk*^XWO=uN;y>yb z*}lqWOfWu~$h>zl%7{(wChZV{d?JbG7RU3GHb924Y6v5yCU-N>N~PZWhUmbsO0NEQOuB371As^;~z=P6Jp-w^uTo9WVuGpky0*` zG%{&Gkr?W7_Vj;{q{1hN>9*A>#z^PJ@erF-RBpz@|FAa$7|hwRXkZb;B$N`y>9H5d1=ro_>8<@tv|22R8?KCrHNN>o1guf@NgtOYFDfG!FnqZ`aH6wTc|N~0fmr-K~@98|@85FzP$u(861)t26Q73w=+-4qmXzB-B@hig0as6vaJ&f5f(+mXa@4Cy0x1jtDk-!m z3Qe%W4bvG}5ZLsAy*cX~pUTB1`V z#=WfJ%&+O9`mPn|JZP916xkHVdNxiu*r!R$gCIFSnANG7`oh85s9;EF&=>nVez3_3_gOq=LUMsa5SS*Hw>J;xXJDM`;FnJ}YOu&ET{cHrZ-J ziudr?VJAw_ALK7c$SaAVKSJ#i$S+=>#~GGPK4H105|wDHUb1aadY-_I+rn^$N{BWI zlI=(_#@E2d#mW7#jyp;SI_al*9}*YG6Na`#R?!(YGY2|__(Q}5*n|AoSgFKYfZul)i|@N94Ndp$OB?p4Yl00m-aOzj`vVP z9g8_-z>sAFw_3+Q-dS^!Nf;>M&@ei0i=N;m9M*sO9)OCW6fApm(#%ovp;(sJeK=2u z#oqU|1ILDP4E_^#gNWMg81!nRj34ds)_6pQMZ)3j=-rTynnL~!g0_wt3tdGmhj6cI zNtN@jF*N!?wKLE)v!9HH(9&15QMglM^B=oDe=8#J$*#mZAv=K@7xZ9sehW~2EYyR2}N6){W=IFy5C&FN1JwgdABIxjEMy-M5MYhrKW_GXzKF`O| zViy3se$CJ}o5Lr;f*9q4{q^GZO_ojEPn~0XB*upeL!A(I09dPXyc}Ta0=iw+flkq_ z0DQ5rdNxx^;iEPbpnp&4=}|H89yC!b~S*s0tIimw2aw3Vy4x zdhi^h9`-k+O2l+ukuslH;}2@>x)CFtfeHV%Ti!tk~I=Fji8n_xj8^ znPg|*bSz&%nT&*HSu}7}?N{|rUHvEsSi`h$gheSx7E)~;!$>dX=4a&Lnn^0^UU<2Y zx|D4B*)UT-2UVN4jDeZp<8`P2njKRww^PgQqSIBMD%YO=clZkmmx-6a;0FM4|I*Br z7a(kN)%KKGB@QPz5mr>>QRu*AOi9q$DCn-@bvIu0H0D9@XitOd-BMm=LAy{?Ik$3( zh>nk(l-!M3%(_^Tv{wV$-$rwitWghh052JC!T@lr0MNgTQepart8BQSjK zVm*RiZ1`-KUwAkFKa!=YZX&%Ecd9^1pghJFyTY-|ICnvc61{-Ddb1MA?&S+3M*@U5 zxEFIU)t38zPAP9)-cnz+-2!0G)fElK`P6R>_^d=gbz)k!*~gr&%XG~}xN#&x&;VOyNq_HR%7OX@CMIf|vL%(L$lZYzEi4qdBW+ak-G_*rif zHHv3um@uV=#BP1vSNwv>1`N=YBQvF-Xz&68R6zfm>C(5h4u}kSWKGvnnz&OZKH8)0 zil)Aa{`gSC6Y)c9-#PK5eAP_)qgZn1CB{?q^R1LD1xK8PL?BGQW6wdVd0BRI0_^#d zS00$XqDQ*UJlvbqG|~3KAHUCefMD;pqupA=X<;y!Fo`0lAwS`wrp^3VC)ru6*lpMO?&|?T(jq4^bBs_%hG|;1JHh%%s*dk=hr|HWJ z{iV89sl28hdKuWhR}i1e#%18Z31J-EoCP!={m}VNf&$X*`iUHSL>k2rUP6oU8CS`K zgpew4DvtxXpKsU^zcRZVLa?bzuu1xJlLXT{DTwNHKW-ZqNBlYNxj=WvPZQ(G^2$#m*y96X8r19+eo&S12oR9BW zhs7*dYvy@o_Vet0@B6;)>$*nj;iE4p!Vc8aHjyr)cT%4}zXF5YAq?hi`h5aH0X7KR z=?-f^Y7CTxhjfqkkpv})v#}K5rd0aXM^3%3uAu8%zr3C9BKrk^7p%+X z?5c<7Yv=qfBv})cZtpKXt^$VVM(&sUk@{MobhdE1JO@z*q4 z0O_qQ%Y>IXH!O;jgH7lW0EUO`n_8&B?W=*@$Wiq2`uW}c{xMi?=-i*5;X0wnAptcP zxlYKTe5FVpHlY!d6o-~gZbnZ}MUa-FM_%mINGMGOPT@q{`K+cO(#AJl6E~X#&9K zeSAqpYXDO2dyuFrE!I1Ksps3~w;i07WuF%)7jA6FX)D)3*Hq z5^loagOxVxaWvnRFHR$FEHAFdqY2P}MTj2odSD0fX@B#y|C_5kB?eO}sFxd>x;769 z;~TME$sRPiNE!L7FUJ!ns&GP-rS-61j?~|FJq(XQ+rg$pg;a`{y0iVeKLtKSnM+8kCf8CRR_Gm*ygFy}@4brEh?;G{ z2R4fUf?C0(gJz`M>YK*Xe*`w><|#ja(g79s9c*iezYU@9*79qph7UHcRqAHyKFHO! z3Gm#tKq9rx)|>ktTjOemrlZzJDAHrZT6BxI(EZN7KGvT0v)xHCT~r=EKD7Qxd7wYn ztU~-S?_WrC^ ztu0zpO*HiI&>rk*#V zi8h-K8{?fDhSHbeFTlSXr`s*TAOKV0(wu-@{&m91@iR@%Ji~~mj5?#Y?u(vJGJw|D}?B=@NRrja_Jvx`GEwa;ckCx8>*E|K( z_pjA^-n>FOmS3o9cLH!mtVSg-HbEHtxs`146NE}0knVW6&qJw^5H2vX5eJ$KD{9YG zy7J}|o4s?f!Ypq-;LJdnsPwc2l^WyY@#oV}vtgv`jmc%lPG#+GEyzN?)c@(p=5yJ0 z<*r}#MLHfFpG~T}95&eVfG)j+a*@{NmlqNhPKU_%Av5-r@;Rtsxmfn00q-f-D_q{U zx{BWhY&C#zU4Fv{DA5T%oTi(2=xl+VMc#I}pXFl)=*GBik1YMD9vI9DIND$^%6nBx zK$?IROD~g)^$8-mZSsnDGznug3M-4F^OpDLEpO*~qlJJ**JhDTHk0;G7c*Y{26NNBUDTLiz_&Q1eqWl2zDQud$_=i#2gcw#LjvPV^x0 z62gnFlxpZdD(eDkaDCE4T!X_b%uBg$Hj^33m=J*Z8>>;@C8I=;OI|{mgkU(Cc*X92 zV+A;2;)y*LG%}bw2DRKgQE6}SXLfPX{k(##%$(U@>Lr&bD1;t)dHR15NHUE1_LYJ9 z!##$;VNthU`1nH(bOt{cu~yH6zK&&};}cR$`b8K!OtA2bS5$`bjoe#dQmEhq)S*6o zOOp4&4k>%K%r{AjtpzLmXWrb9uL=r^foE62QqL{hXH=d%)B}-CHqC(=l@21WBW`yxgx?)p4Uv`oaf2z56kHF1vK_p+M?W71WrFn~Bt>rk+%! zt!Ib7_A>oG;$oJzBQH3bBsdzaMPAaaa&%<2Uvy{3JJy-eO31GyT0rUxewp3KSTV3& z0|n9)nX(m)yqMj#$bSv+=5zGI4?i_Lka8(>pEO{96UxacD-2x~ymOw*Iv9I}W#R&vw_TsO>wP}V@ROCcG(aKn*Po^nI1LMgR=tt&iX2}HZ@{oCcgRx4Im>DFKICc zRC5AQmZa_bP(3&Iz`zvh&uisTHBKxHdCs`NGA8QbQt{wa69{mCOo}s?JUli)U zu9O&~+!l^NB7GaYll{^ETl769U?Ftblx>{n8smX#YYn7n>%o-vnEsqYHw2LnL$58S-*qcendzwih1IRZ zWXFxj8AotH_0@K|n-1zK5dW-$ZW90P@fR}J@&UaEz@Whw7;&&8&8|?S&T<)m0%MSJ z=kE5jt+%~BZ)Er#*N1PE4!3Ne`loSUyMyxi3kNkbB!>}mhoxr_1M?c8=yvDXgzWPMFr?BMv&}ff$O&EEDCy7_8_AY?^iM7_+dBa zob~ZO2ndI%JhN9x40fT_t80EtR@+J7{0y2N#(QPE6l#{A1Ssyr>xOn zCBFP^^+Jw2+05EHh;h;dXWH5GFSiu0HaAo zPPFFZ4w;jyXQ$f-@QKEiYlP?`xW5voLoP5kK19^=a#roiFF<*DXGQXNe$cHEm|NgE z{^?FWiFC+NB@YI9eM$A6*quDEh@q@s4LD5^v}OJuW!7G4Tx=}X$+boq!V^?RGpxNd zA5E=DBt|p0!D)jBO{<43>&o^^DSI1XUOkP~c609*9L|EC`xaFzF`%vEI(SMVDM_Fe zDZ1(0;3Td*^H=zKwpVIkw=i2NH)f}H;hv_K=3mwCer7X6KIvu5t}6e$x;AZckOhX2 zbSzFZX6>NUn{DLO5Y2#OukJut?4%FRL&vCO#d^lbWDt}SK{bvCHNwt6F^OjU zBij$^R@52{a|;X8f&Y#e()QsBKt-D@FB)P}`K{iSp`yF&jBEjBjop;w-Pt4<_j3Do zdRuXIe+2FjkPQKbtC71G7fY5W8uFoQ50*ISSAVPmUCs|T z3oB-2??FUZ2jUtcGDAlKus9_DdOiSi0&DLa-&S`8noxC!6bFDLWE5o(^-*)|gD0L0 zhz@{L=%O69TvRBqdEG4Fz3-(msqSfe>rjy%+*(-JG#u@>=tN@~Es3z_(dZe>w#zf_ zn2(wo1bc`@OeFGepC?A#{}>tmU&KnR6R{tsBd7Jhe}s#!1xAC#Hye0$f6+DyfUUcc zZjMUilbdlgF01~J+{*|0Jp235uPjD9+I*h8xayY!$f6Lzhm-j5%R`S*sBi0P0FC1i zZ!dhh-*YPl>trxPQ(ZFBEK0N-Dfa9Do$cPDLZKa_GYOg%6FAJ<+^%~*`=|wwT>^2|b6&q|SHO@d5iGA?XGdOcC13m}xmN^9-IlvyQ0+_YK*yo_XuFdZW zpd;)&pz(a+RJwb}{l07~`=4)Mk!B&E#ejKfjl|Wartkf!75rePXB|E%^%K;+Px6W1 z5^I#mfw8EG?dAzyM*?9C1Zi%E1attCDgNxd;Wvzd;ai5!;f3d~+&1JTug&}na`y4p z!VUpfzFE~H*X;aOBQG(f^EK9*Pe*o^ef|xA8|6pJ1!)Jw8zgiZk}w>2iA+U-?AA7N z^yxq9ADc4IAAq`o_~Aolkkjfq&qE9O#l!|cDEuk3VE5qDkq~8PFHyz~g z0@`;dS1w7B;2${Ld7yvu)C&cWKf`2@Qc;dY-{sRR52S_6i~B!J;PxkjM*D_fMe2+W zNasIvt$m^S+1E!7rq7Y+@5&1+(_3st!0Gq|2xXm%-Kzo=2vjOZ$lC~0z0=9`A6!-FM$nslKGQa2OeC*Z7o$LLNO28Qn)QxDgj~PI1 z=}i6c_76#x20(u`u-zA(9)W)V4$BS}zxw>1xj9(m%AMfD$7%pyLdrp8z4Mi|K+lyl zu_kGJe7xs6E6dp1yRrWMx}*X50F;>BT{d2efdu(X)-cK=aRQl~slAVC8Z)Rh=t|Z=KlI{K?JfzqIM4t(b^%e%5?1Kiu=LLr95o=M`wJ|XoM{JoUXQ#9glyO zd`tsDs_L3U#H;Ap1IH7EDQvHuuG(By97h6 zLWJ%jAw0lr3`RniH-|Tr6<)(pzguspQP8C|-vq^MsNFXd@$&Jh?#*XfY-X32#&smVUT&^7* zlr|baeysAJ$0g8WgY}>Ym=4Iv_v7xbxMM%li*2O+CBPZICA-M2&V&9>(7<8ecV4Rj z6qjtoC%)@Mg<~r#y~udj{*tD2&4Dq{{Q3-v1T7*W5=76&KF_+%7^Mmy34*KD^nH2{ zBv({aD~?r`!YhEPgp`6U!33){x^-q>A{~cHj?+~T>$QgQiX3^~1kM0EoyGRL~ zP5o1l`q`AX{AE`YSz`d=)4oK&=!#K*<0SJ0z_wW;NHYEjsv-qr8 z^b&G*dCfE}{{$X^S68DS#{v38PRUUXMEov4F?Ol}XnHdC>fh?gV8tp3*eQ=_ZpFn9 z1fr2x9sp)D7aaca<4GLj>l%9rf{h&PU8(WvQlU!u5s35;j!3+d2w7|+55eIU$rf&b zt_an27JvALq_hG@vY(IIYX0~Hzwbg;^~g=7v<4Z>=NIWXHb7BfW^Nvc9EG9d&nw{n z$lY=lH)4Y#anknPbY0NDFC61pBpUOk*0fIiT{Z4tmj5=JeGwl=4rylG&jsWxQxKXxU?+LN5 zbFDYEfBwFy$2E9SfsPuI^qiRMpy|0g2c>qY>R-ioupiuBsuz8b&o%bxu9*+vm3i8c z<9hLS&uORVvam6IX;w59UQ&MMeTbsoVA5|IcL%%sFk=~?L{sk%%UVUiCS5Xo|0c}L zPJOLJm}$L!++)$0|5f)&fm1IsarbCx+;YPBG+W$6udc#AwEfa+-4IV6V|Zyu@A(h( zb0U-#`7@nl!e8_3c~IYpLC;8~ub*wTP&j16Ls-b%dadld&3@@Ee?Q{>OQN*nQC3`< zXaALMV~QZf^9a-TUh{E<#F;uob`+a6*-}kT= z*Yp}+GCBB}Q9#|o(CtW^s*w3gL|IedV31k0${ZR1zoy?Xb@h9MK@f8Jh{h%QhTGnAMwZB-~L4t`Zg#x*AY(*dpIZA9o>x|6ra1?iRgRH7=_d zT4OH}*5t-@R71DNxmyb%qCBA9Df7w0i_E3&4TMtJW_)^|Nt=#1oudDO2*6ihqm(N` zVPcXAs7ey~LlvIaT5TA4s?IVolXKPn8NXw<%B{m*p|)l?y(2C5c9}5n3=^OAB^yTn zia*ho&d(#e+zpc-A32huaQT_hk<((HnckGEXEs=`!L%wZul^i5-h=fDLcbr#%tfKR zsH5`AaRECRbHkWuJWMlI2wxwQE3gOXeAB9?;7;A-d-Fm{)||PuQ)P5^L?hcD8qG+$ zbaH-TxtdN3{jJWI{i-iE)7?Y$%AAX!wk(RE*6Euw!f&6$Q?%_Z$e)h=oIjlU0eP^0 zbhfX~fMl-7e*N4y!t#Nz%BDNT`a=b#SS8v-aE;;yu6*-l`|`@Vj5fS6d!am6O+~!~ ztvi};r1%7z7Yun+Uz`jW40wuy%1Ug)615iFj{TiHOZPi?kM-yAhp>zwa>%O`%w6mN zyNs=0VYV*a6WqV6c&E%%nIej0dAE29p2=%?S%b65ERl$i-*6 zMOyc}&No!LwWcz{<&{{z_b_vRPFis&d#pf5NRZ@NRuL)^zs#fYJ}6PC=;qE0_z}er zG7}u#(+(*+tb2&zIM{5mNN#?~>C5orjDS>`B&A*~!QqfM+9JCoSV;)Hc&4MUZ*ba5^)^Wa^a`MK?3#zn} zC!vY}Us7rMRImIKE1V!e0h@kH={tIE+*CeoLVzAC{Eap7ypkyc1ruLfA2SodF9n>A zyeaYJnMg)>*q8!v5>fGOlX;f_sCaKnu`4G!6?Uu;3XieFA87#2s3&29ojW?S3=Co@ zP?X*idJ-nbB3x*x7?|3%^`2>7sZ?8!W6`~*A3IY@BV&-3D{`cvYjn>(n445|yd!v| zfXYJS(<4tET9{@j1o~60RyWXRiWH6Mr5-MGtdcFo%}y61bTn;K zJdHFP-tSbJr&q=+W}l>IW*RyD5FYOtDhk#*YfRbHmQ40Zg=tWHH zNu0{Y7!R3#K5Zst;>sdEY^fZEl{$U3!|kvRbfS+$gwE}S@wi6|aC?2Ok zUV`EJCo{Ez4@-=IyV`eZ!s%DwUhf0l2tg2m6LAw^6XC8U{Iv~%ZH8@k!}EEXlX%U& zQuRdHR@R^dw8UT@?6oX%*_*BLTQ|a3wGWx{jFHLkImFeD@9?TTC53I~uR7sh2$qk^ zu=`(m=FNP4Knn)dGpmK>rgouCK*Xy;%sNDv!{T(Qi1t%hqe9kW6j%l!^Ul%^2+3>a z=pRbOj9qFG{J%RT>3s-^N#CbOVZImaurW-iA~H?X8^Hz*Kf+8*xSXCYPyg^wA&j}J z2ZjWC2{~`guT!#!P1w;!8IFCOv($66G#LF8Hk%P&`@D>O{8n)*HoUO2A1>AY{^7_lCyacfr=~Ni!i>ZjGabasJ0a_;2t|9brq%3X9~*x0F%j!&)!(^kU*R_kz%l{+L+R<{q(lS%A=|l zQ!#)jkaM6B6Co6@rHMKqQJ-S)((wLT0^+R4H^G>Ag2FR2VjMHHshp ztGV;GGbomuVE7r+?l3W7U6lJswgM%))6g4>1esO^kE+!XA8$2-dv{Z+x=g&X^c!hs z>a?Q;9l^f>`HPZ;Fj!Ax6|ajvXa!W(25^!|BJf+aB!V1u(woLIE9-Hlv68B5 zO4BKDX1k9ouZT-3uQWX=4&HxN|0H)?z9>)N(ZgBBqPO03b#`e=mK!cEK89#nPn5a3 zh0r+(3J@b@I&1dL4rF2OOp2Vt=q&H;KXTdY)u_tMRO0VzV>-X8T)fd52+LAeW7o>S ztg&gJE0>K?{X)x-!74ne=iItT)lHQvs2IS)(x=q)em_x!8J<)HN%WOcXUld$_zsGy zj5{r!`LUoK*wp$uIA;N^jR;tE1bQaYhg3$hp4kf0nwXPWSDSn`dYbiHhiK~E4PLl4 z#?G*S3|~@3tMmnxcR|qVoKmM&%{A{dia|;TgXFc2Dhg$Yth>ZK*CuHOVGX9Va~ISn zayadyrF`Lgh}tFv!i~O%9y)<0CThaG+x6Li$F&tTYBD9VRlhb;G=P0!%uLU{<4HH2YvjxyZVV1yjd0ki zS@*4B6Y>jGU&4jL<;+@OH_NkPx#yo=dW|q;Z4T2)mQQs~T&_)|hu97tG%0l48b(wr zh~GQD_@t=b zqNonlG5L2fR91m;oV1M2d?0Vl_Fynym2*9>x=de;USwjzDX4bZU}<`xe}2j&_YfP0 z!iS9z*!XrY1ssS}aEOnV?V#w~dYdh^CxtNXyyny3`4K$E_-Ztgc`9wJYpP~2pMYXR zo^y}9%*|{pRH$)WnzHbLRw>N2npyg@VjT0uV0sjlhjUv;dDN?$U}(LGcURegYf?lg z*kmaE&*E%|#*#QJEoAtq%hszKVPgB`DhZk%eLZxM8<5Fw))mv9QzjUsR;~ryMDYbJ3PY6+q8)NO|s=i+sOH;;FRolx%(71`!@<-}! zQLB5qwJbxYNMXf;T6f`n*-MR*w~*0SJMljUtbg0DGehhBC|-3;I?840)kiwmdaYb@ zWwLy0kVx#EYKi$vM-HR)qF4AQsQ+k7Z9eyHOT+VFKZomaer9AE#eb0O;Ee@(SRssc z{(}x<4KO}ddN#$sU-HTjwMHnJ_WeZfYbX`QcYE3kuH1XsA`wQ4Mi0x%AFM5Q_79PS z=G3d?_E)ZMG6(EeQtsr4S!3($_~mLJ>TqHuZOU()Xym<)8Ax52(Q#5%NUsd7=&1iQ z#jJXnx1=CNMfsK0nJFq>AY->@x3w-$3l_1i36sMno6LB^`Br9CG3dxkfev$D+gE*! z4ev#0zS^l(VG(4(*(#iI+pt*v*2@+$<9e*L;ka;Aw~;jv5&8<5EZ9ys&6I4&&gnzc zoO>>o+`}xY>w9gIQB_%Fnq_3AO|@!5?VM4SP_tqp{p^Vlc=m!GsQk##>mvQ>ovR^i! za@oHL|570#%p=DpQK5g^BX+UpgFWi9&WRrQK4j-nf6kK_ja4>9?&E$8ZVPK}MVh@Z zO5*raKj;1&@)Zx@aQHIr@8>*Kf35>{m8V3}Dls#$Y8(Q?5|%{aoJ`Xqx{J=~D)7|S z#yEK55N)hGZDgTe8R1-Qqg>!5J)tzIBKyF|2)w7&4cm>qXJbWM2y@p%xF=iiZ|>8- z)9nZ5r?7oR>wLPd0NUd|45=$x+U&u%17yFz@5s*Xz!oby^;J6y%_XsKcEC>Tg^?2j zCX+wQAHcXL9#EET$iGxt2WDY$t{F;kkH3GTMjT6wZuKZ+iDW>Jp3FHeGCM&$@zW*dosW3|qA{H7K_m@P_@UccC zx=>mFcs%dW53`=fZ0U;A`3bCZL;DMr8JblJvO}SDL})>F2_vufrt)JiMbhr0lGfwS z1j3bV7&Fe7^$xr0y&gESC@`uP%1paQX((4#!86aE%CYT;DR4oG0tZVGwd$)_;R&Q$ zgi8(Ye}%f0O%z5Z-8m#_nJgT*(V+v1`O8%=R*vIRS{}5OPZOm1TpHrZVNFHCUsmf# z&2S?>>Uik2a}fyVt%caXNOPKaN)(D5RKX>-0{TFr8b?0cK>w%3vjO!2Cz*PVCT&)V z_1RzeN~QT)T9gRA6NU1O)jaRRE<=$=j^RhubW@>%nPH~v5&h)?zPa2Uviy$%iCB_9 zONZr2@{UB(UPZai7oWMXI~T1?t3szGH0@^$qMPo_Yp+!@eXL1bOI0+jYq>g^L!~3D z`QksIK#dMJ;hr1BiI%OMjXsJK&4^&0$NgKUmr9L75gb`g(3goM-;+iZ6@0gu&ofz= zR9h3I-ZDY&aJe;&PbKsCE+octphMwY{H$+74w)P9$RhVB|9063EFh-7vE*7 zwnUIuZ5y$%rAlE3(KPQV8=G5&{8Y0W<7c697F6SSWkIh04AdbT z^_rR@s>ulhUpWr1q*7DO@^?(P;D?=IrH%zT;~#b^s<36N)(W;yWyc|$Q}0UJQUxE0F3fjZE>#2~JZDL?IH9#w~Jd2YqeHxE8xCm$Hp6qd2{PT;db1b$Lc@!-5>Qe>d*7Ihfo+%BJO? zrjsKJ&Vw~|LX+!AAYgpH`|D4_=~81gNihdF-E)8>4WmhKk9H#J1Q{;KP1vg?G>%=Rfs z>z1`@mNQBA@U(Pco=m=hNOKoW2BvB!2FmL2`iaJ9QjYXfyz&7hdnt@kHT4u6?<<@EVk_#D(uxSis(L zx3Q|ft2k}U#->1juLrK8#!hj*-!p7@Fz-Z^8H~`F>8}-It16&wn1KWAK+?T4dSA@_ zReX(mJiH)u%fPbXNe!LS_GNekN0nP=#)i3&!=z~_HrufT-l(o;>wdd!;8(A#rUs^5 z=cKdEnlHf(6Ki#dRHmP zK51dEsM}*cB?<%5ppJQFvNS{eMbGDf?Y5x=iR@LD8e$`k^c)8`@q&ojya5#xgZmZd zD<;0lTf53%wVW1*AB)KIN%M&wjBzytl@XAq51G>~K65?{j=2^ja>9qE_v6aA9$FD8 z7IWG^r(7R*wzm^=XPA?M6?tWhXt}n|Zn`*+kZ>P1N_&@LWofA8IG&;jsr6y|G}?qLPIFSu-IEJ*Z)rif#w&>><~N~l#0Cer zCi*LviRb7n8=0CFJurVz>cvU$ZM2TYaX-jpv{NS#h+is1+jAd_!ExrApnEg0<;R>@ z?{psq`3wJJ?An(rXkW{kj!BGIDxGlIvPbJ5Mm?687RfGW;3b(a;K?Vx&AIErEZ0f@ z9$Br~?=ZcnQNN^gQ5Cp}lK!9m`wc@b#+&rp8Df+9M-OTs zy+Wz+jFPKo8MBO0`ii4|4nIEB^ORMAQmUF4L-drcg5hmkD=!~(To#cyCYB8~hwqaU z<;Yb}avmgvRmqamKYsrs)80j<-gc4^VQ&}DY2L$B5Upuqr(p^UiLg$X{Zz%5`4$g` zF6N}F$0+j=b5Qzo(6CnPJ-v&)*YHBApsWui6V#eb~4vi}zTj>(hQEVZEC2 zOn?jJchcvdRJ#WRGn<8i%Fgjd+{}fdXK+giLM2mV*%;N)Q5vV0-Z_0;u5F*z)L3JY zGN)LdmRLSxp0lB=8!#x@!mSti6&xc})$jFqBgHvirRq)lsg?oP`-N;~3T~qPsEPHg z$BRFbq&}JJZzOI8Ms4g($bZY55jjHX>>iR?#uEUBCK9q15^gn|rywIPBdg<|ZQTbFPqAK$0Hz&TF z)9JG&{s2|?2?{ccIGsx1xdyw=`tm$I;PLQow8CHM3fhXVPM_^!L|};;V|+Y80_zOp z-4MwZXsyI}T8W0fTuaoCZonv+4}F2}jbfC*_F)e29X33bde+1V#S zBOG@%*^wW`THq%luAapJy6*^SHoTQn3a@h5MDC0yp$)X!Uv)&TF&i;mrI#0@x6nLS*c&T#m&YX- zRPU9SO6x$5BuJH3(7smAW<(IQl7VljTIg7IMmyniddk>3qSM3guE|I`$G0--*}$9Q z#ngyX-wkIPHu%l`){3d=A%vkT4RLyzck({I@Jdfa5&HK;`1P3L1LN@Tv!uBS5a`Ws z!=|E^^qB9;H?>?YhfF#(2vvWf`l3|GtDmL^mavf>XYK`~-qx3=O@`|s+osBzDU%8z z1)j{k3(gbpnyGJ?>8=6=<;iEB>4bBO3QDQ<0&(d^acj>dXCfC=Pg)vit+U2S$y9fS zwewDiYM+f-&qN^DpYHed5N`_d#_{z?D+LMWNQ@3MX5?9EWpyM6WRPrfZgQd{gqC+o zjV%5UTo&s~pi*xTqblj;RbsCF(5+t&ei5JKI!nzp2uZHvwl&C(>LXHfjla4}aFc_4 zR*Bo7bp7TsL9%2V2aQ?Jo8*@#!ud?_aEXv2&p@41LG6E@bj7;g>w_{Y|~!LyJE*A?w( z8=%Q^<&)I1n~XxR&h-pWl2Od`Q$AgK24!7pPiEC8GpLgiY80hqetI0Q1{5Y`0olA& zplNMXMW}ww%F&M%8wC#RV zyBoHDAWYuD)TDm$S)YPQP1(#fD;xzXAFXFPS!xy0-o>r-YM&9(DUw|w2>rgGq@+xE zUvNIl&CL;FH@}t`c<^+G#kxp(qhNe?tkHALb^R01RA4M~6c=Q}*epDhYyJ}fwT`#m zuGt%FjyP26a)B4hFB=SP5ONl*j7n_HIiKFxvo`SB%aaK&e968Y890c>Fca*dSl0vJ zS>yEVn_I*<_g+^XQBf^1@R=hfl;ee@cacm@sK?wsm;4y{B3g`B|mM_uv3X`GcmTA=Uh93YE;n~Vb$Z}*%G-zQ>D=9 z`OVm6@*S(`9({+he7e@iV@WHFM!J#UHwN^o)#Ph|syL=xp*1h}U033K$*2xP|5%HO zYm_XzSqhpK7<5c8`qx`9hql-!Y&x~Qm4s^3j=xoTCiiQ${?yK#zc5oU zO)~F&|N-1Kni z^)P%zV+dV)<3(BW>!#;*e#fOG9bS*q?7L*$Cr6}vFOv;!G_2l4{X30nf_LIA&KVQ2 zd<%uRmqMzxNW`ijm0al}vCb=VztC-$ro@ybnB?*GllfDUMl{SaYM!RgO8V!?6dQ^_ ziVb#8W%ol>{i;X)Wqi;jRL@vFBzd^zrR65u0LhJc9utopZCNX++i?D@G5rgo(J2to z_{O$Q=nn`(S@k)4?{V3H^K#Rj5;K*eqQ}ZrO!`W)+a8Qur~nVSsko7uD?4};sm7#- z1jp1GCmnR`sWdrNm@Ec4EOvFPJ_xa7C^@C6y|2#{G-$I8dVw}5Vvv`ov30*vI&GIP zsA1aOLlj5(DSXfkRuJse7+F*F;%TX>rIXrNKMIv?CY}+NV$5Ldsn)Bh1eE8Q`b<}9 z(tK`&hZ41i#nocsBQ*w-zP6~u2%^W@#Sz*AX9^#lLrrJc6#0ghE_}h5=!pG~nnpTD+H$vZk;XKYAn|e0FJ+KXg1htnFrG+PcYd3i z_eg3g&4#$)t!t0lSXU1t!|Gy4lL%I(k`WPeLk?xPm|Goj!x4pAE)NM~^Mr7Hg=NK(1Jl^vv!PQjj}TVM1* zOILZm!rrHrK(yj8Ax+A}#%s1OHmc#|(viMR>0Y5aYQulw$gnOg5Lp9?aAmRN8Zt79 z>C$YyypV!RX5oiBVo-O|f~Wy`16*N;$>G>_^oHGiHv{)uTcUk8Ti!V!X^rJQulEf#Rkw;K&XEryQj#be;7IY$B zA*ns zuc9e>6+Fl;QxP*xnnmy!Zkq=9+owJa+@hrDm7qG$?)l^l`Vpk zk}We+f)qkIwmgr{v8*~7Q<_RyFf1l3x;Ck=9(CnVSS1d(CUJ^t`kC`m$ZJx>a8KOG z+Z0lT!^Zw2W~PBtUW5h?gU$O{`gVfYs89o?o-PKWO}9K&GhZr=m-K?3q1Jiq3!bd7 zD#twhew8Po5du?H-PlUEpEpQsGb@E)PO*$|b>&Ghce0Nqg4>+u|FT;?;?;5uPBc}n zq_~vV{N2cKao8T#wQy@`Dw$sLhBM|pWYj0Mr+alQAJUE)NZ|g7!LFm{Jp(2EGgJa0 z%+tco_unczN#7BX%e`X=q!v>6p*qV)+c3@LCfQWnSbXA?y_3;$0kItsz3nA;Iq0IcR)D@DU6_s@mZ)WxKgS0Yhe?vdH9)!R9-AUBzG5E*N;j_Jy8FgDrCYfBzr{f1L zO^bf@pIW(T&6K~<*pxBn>SKp-20f-@l=*e*AR_~JDsWn!fN*3UuZ4S98=vk@tez!g z>048*^_AV2QV@82&K&H3j!lH?7JFm4oq7%v4TlGQ-_oD?+S`4a25WhZVvJbp=626o z1mE~dnW-7G>4*JlqXZ@j1Coc3Su3WLIvSb!c(h&J-y?+hN+Wr+)-@_|W(2V-?bE1| zWHuuS5}GGPi1RrqHg`22mzzqcgGp&Lm!u+W;5i{@yKbqgr`PTTMciha$z!tux#k07ml;`OQx?ZXy=K0;-&`snvk9+ zvESAyUOqZwxnWynngMiRGtZIvregV}zJ39tBi~imkW;d>-SLGdxuNhClHZu4ez#}) zqetshhdQd#<=s04abDi_Ou=2nG`}cze60RundIW>9o*gw%C$K5nK-OSw5aKG_^mt` z%RltAMs*;vKy*9q^qyuO51d@uJ-6S1*QtMcy09u*LSIll7DsSvX(y~dh(D%-R{A7P zxjR)8H;N#Nt5)LTI`bmSfFg%0+jfQIRfeHmjP>&SW6mc8bc?Cy?9g%TIxW6aCn_FU zKZ@l6Ty?f!n!Fz{R*{13CB<*zSf=amnt%J$KwG`%v$RjHoWz1$yd_4nS++c*ilmM? z;Zcv?kUd-p{5U`1c~t8t_V~LTYE#UwB(-&xts@p{-mD_DALiR3WbPp>!|(&$!gool z+(O|`HF{fy({9pn7h260SZe)DspvCV6%)|ksHdSWj)zJuuyl`nx(z50dLhi|Y&_;{ z8{Ix#I;E7wA$p@R6mPH0CC@Nx5`IXTB6K)YxMt&faJuL`EtGFRX*()x>>Ldf9d^Y0 z>DeQ%j7~uIm~T91H9_U%j2HfLSYi0@(^6T9Fdw+b_Dz`g>zE{VL}NI-`|Me%PYAIb z#1#HWo=ft8Sbw424gI*-WAt0d+t)(vo^N;{_s$XH?GtQ4o2VV!@}pbl*!37H$tigs z3;hLT2@p%|>~g{QyDd1Oorh>W^rX$D)2vC`SU0oPtcQZvUy1j#e>r@^rhBMk^mQnR zZ#V(UNF%@9>F*^G(;F)hHMHTs%i}DfGU!~Zo|ValQ-`Ol@9X}deo+t3R`5WMU=oje z`b0arm4SSSy3Lxp(C1y@>Grl{1Iwc)D)q~M@TxX^xC-ZfyP8n4vP$K=!@zdt+YnS* zzsz?m=HlF*5!~nTXF5(+cYjl*aZDulR%DlgkYu92_3824Mp*tMoj-HI9ljGOH4}Lp zuxcYE57}R2;*y?^hPSG+cXozbolY7YCD!*IWC!8Hjzh|1jRUOIo<&z>HZ}RYw-gn2 zm+JMh97>&V{>o8$lSLdb$t9({>Uo!>Pp0>7<~$xX%kabXVb924nZJB&;rz5setIwO z&n}mpzs%i@*<-W*eA!Tpk@)*w1np$^fE%aX4}~^dlVUJ9>7&~3%SDL}BIrV9ypNn(I?2S?#0qzglH>n9r9ky z28Z#z9vm0MCoG76LXS&c=8Z3NrV?o(cmLb<+!@{c)b!5#*>jvv1OkQ0ou6xzv4lv+ zNRE74@`~s--(7VN?#RHWvzy%oh;kp1?+gt~@Xav8u+z(5xW_mZX^4|07H192s+D=8 zOlPlTpkA3(@zb`U-+cdcyM4Lb;X^%qD1v)PSLD?{FESF;Bp{fYyZ@5Q!X9H28uu|niV zt?>N9fy0}MsGlgaC_Pv2ecut?1gt;E_*jQhJ)e9aILa<6x%Y6O_2{xeK&(TTvyfrt z55LFAC?D;W2hXx(U#uxKyBrB|MUn9pRPtne@|L% zRQK<{B~2;Gx?b3#AsE(1WinPD4Nsf+LPZaAnF?Gk^^;lF>N-MS}PWFPb z8{DdqoMUxzXeG3zGC5?qWP_&UvgC}jg!85n1x~3l7mIu-4=QC81t+Id%SXJWvn=`&8iKPc>E)fwi*(IUQ%%fS&1-T8j%S!Z0uL;Ew zRUlE%<@cw>c?T85=eziYsnRxK`poWg&xUx93w23%l(yOZMZ-p!jm0Fy?qAwIXZ>pf zsz7+7S}&e{$I?!%q>s^`D7rxt(jKFRjob08+G3$o`t*0vomzv0Skx(}c5z8h{hWnJ z$8!qY-uJ%kZ&h)#EKj{fRc70I5R}2rtgupUR1~C<)~-d@Bp>`|<285vR(1F@{uid0 zd8<_BzPv3@ZWiF;8kI8>S0neb^H)Dwa#T;d1k%xxC8dny3nXGsRk)sXG12soYuf#J z911D1V1g4@6epqN+w|jfV>6jwoj4hVbNP!HsI3^G)J-=_;&mPH-_p($WwqePbJ3yW z-On{LhP1H+vf@XVrId1Bx*C+N|2{n3qy3PPw6L=Gwx?TIs{cp37orw@$E^kD(=Ppt zDcX^je941%H7e22MgC=d`E4ijH0B-&u7iwi34S%A4FRW=ClRMABSCY6NrV0G;GD!w z^rX{u0PJS?hC#USE#TBufF-vMnzSgwC9Unpywf=EIstv(fT#e{2JT&n&((M+ccA?Fsg+$Vm5Hb^aYy{Q zwG83zwM3+N(B?R`%?UxRnKxC9c1P~ zc_B0W7m*y8hC5kd=ZD++n3C&eRXWBohICEb_){$P!A9P|deOF<_QvjvZY6P1O#(K@ z>HX(<7?}^jM60QsMLcd(7Y!KHG?{-wx%>O7+lqi!4Zy1bhE}K#Em#04)O{tmlV3*VCbcRnm z!@#ANfJ~Fh|97mN8neyqbSUKyb(bH4wno(m%MA0;%;fEcHfKlh%sNNFEh{E_yIQ_2 z0XMwC1a)~uiD>)1~_>k>}RZFi+oH;%Av3U$)KJ_v2R}Yi9bcFBD(@#?}Spme1?*5d8zzeE?_2^ zE(jAcF@>@vWpk-yL(_75XZ^EnlgA7ww-A#e`LQKnzc{*F+ z7SY_%*WLEY8q+zYy{FBC-Q5GK7cO9Ru|XPcT35EhO8`qRcF^y`ThI54HPM)ECCn$Z zQD;hmM6o%O7mU$2bWr$*Dm>TnkH{TMvfS_NyW%=zgyxMFB4_jw1&% z8)1$&C;R54KUk}F2YxwK{wR{%i}wzz%hn2R6N#nM2Q8q#WB}c+y`K|ns+Fiih>X~} zAjA1pm`_Z(hxD=HO8uaTzn!7#s)04{3r|b?-HqLC|J-C%N0ZsK6Xv{YR*`v?v|l0L zy*5}y*3%gIgSK77N%Vw%{hBS*^XTyfDibtlO?+`u^!)m(=%U`&ed?vTMG0&{N?mS> z{lZgkiaYPB%XuSh>U|uBS6z*(u2;*QKf zRKjg^K#T9H+0OmQ!#c}S&F0Npe3GH51fh?@7QPTX?$#x+*a7%@?#cE%=UVKdP!A~E z7iewzRNxc$=$I!g1bdCTF=yzcc%!D04zR~J_Rb&9=WTOU_D3g^UdNsJ>lCmVKXKK5 zu?4{u(&%Z%T@d zogvIXiGv^hpd^!K5(&~St$;lIO8EU@4FN4H=4Gm(fSZE|))j|#tqbHA*&CAi?~uYq3RqG{HTjT zIOj_GZ2@}YJ90NKX)!d)Lcc5-PahmS6TE-Zq!XXlzv@D9XV{d&8!hM({`N@D!K-C< zX!`QAkClxN$-OwR&x0+8Rjp29 zT*MtoXLk!MR>qYJ3ISMFla)qKu`^#H({gW53dXL!RT?Av?^@<0*#t@=C{`EBzHrzV`Tk^4iP zE<9sl3j-v`h{(ZRac$>aaM=VxDVtZD_^82ae&+$(q%X`PvSs}IM-6#SsR+T^%o~N> z<|!d|fXW2tiMIR(H69c^7RZ8#VE@jtt^Be*kG0+xz%HWBOmO=^cWn0}Jm*O+r66BT z7gj#u*FsfVz2gCyUdhJnS*O;x&nAa#OoLqxBu1s4O{Lx{2AIPTfe9vU^{hNm@{I8kmYg}dS804RJ$<5H#=C^I zgh;hQ$E5SbucL$KTlnNw-pUCi_$TDg*-|-p#u>*YF&J_YqqoX z8D!`i1A@rkfhZT<(bMu!eX_8N76a2PgK%ufhyYIXEW(y(*L=GsW+_GjwL|*UO zbAykh*;V*GZTD5`oIk#>&uOjEpnA0!tfl0G9G6EBzrW61^Xy?fqwhJ>=2y1F3b*`2 zJT6)TwJ}}G5If$t%L&W$eigCND}IA{Ckz_Wl=pV8In(RbLikS}V1w}_GbOP%-H;e` zE<40;c~)y>$jk&qSe1F8RI>!5hyrTP*I z-<-9Pg@-FOvwl*E#xRk2#^m}ZoV!75{DLR%SM(J-H8y{Y7z7(w6@@b8mtn&sIEfGP zID^1o4;bURUiB2BMes=JjG1EGR-+1zqPS;Ji3Ni6Dx^q2o>N=OT z;CX58vs)QL(7g-+GR|Fot{LT(KBzL!Ff~XYTy(i;T9)BQm&)Q57O- zR?$(imv3ZI_B0F4$JXC(THv&t%6Zf(tv(R(k>?{w!%6~hqJe8rX~cd!EKWB;;Hc()a?i;-%hk$;7`+lCdG&MF|%L7=?PYumkesORJp#x+r<*F zAu+(A6fXC#6Ce)S`{H~G*P_C29>7Q;A$vS)!YVxWf}^wqx27%Y#8`C&m$8>8mKf#Hy|V>jQl&kV|g%D&?tkWDMAK;n{8=1oy%D>s+-Epopd zi~u(cGyp}SL$X1C>FLxDF6a4BowC$Ur!Nm|yj2n4ALf$k7kKQkAtP5$ZbJNQU1|g^ zxO5n=pX^%r_kYz=8aFOnbKKl8`_PpB?)0g+&zi!iGCyUAeC_(OI*ZOp+qwoQwY-_c zzmq5s;Wb$o_F{X%Kv=%X3FzJES-l!2y6hm69qk-S7Pfqk*FF7&RpagdEIQ|jyyVBX zy~4D=o;j&q-D_r;-MX$pNpBIi>^-A-BbvyszVWb3WcEo{E6Ak)e764GpkHA(sXw#; zKhL<_9prnED2CymnKDES3Bi~Frdyv~qJLSac^>}tI?RK~7x8{uoFcK)OL<2kkn8MP zZMg8i-?eQT9P^US7y9I)p$hN6MbZ+}X}Z&ak3RABibuR|WWXqH!m(25O*b^_G*hyZD-f+w#T$LE^_IgFp3|`%sj5L0AB`q^ub`UFPk6xj|gBmhJ{)oEfwF zp&rU29$oF%=N2Vm%FjW8U7wwqZ2Yky9$B$20cDhMrYC?fQI*2*Fn<4-+=};#^m)AT)3L#<^k8sx@t4@9qd(AoV;4t=pHDRdc)1H!=(xIof{3tJf_Zy4TDGQjC$emH z44j*SN-J=X77f;BlC7G3(vSm{=7jVkU6Ym%UDltPZfu~rkA^`rPm{@Q+-u62d1wXy|bpT+pK^3HXwbP1U*oK`kBYTDOp+P&)=tU7nxe>NI> zRz(il%R@fa`$3(9rI&gS(Vppgp1&`WE?Cv^zNeKy|MD~~NmcZZ?5R>1UR;i86%#z4 zG@mGkAsfU)Hvagrax|8KMKP*h>z8mW)kiiVXV_0nQW*VNv3>%a7#9SI4MPnqIlUtK zT4=%cJT47s3R9_BvG2{|xoJD!y@e4EKJj{Yh8(zMi?wMjWH>9@j(7`CqbS`>^4nms zl{rHTRyKo7TIWzF+UkSrD|lGYsWRw94wFNkE_%NL`He$QIrDlVRu8o~7?F`UApSdG zWzJh9-~|1+(rO7$q*UyG)r%-^POh<$@YN5JgyEtH2&T_O35qBla|Ty~w6M_=k`FFh#zFS)^ zYe7AiKsQm<1(5#SiPe^XCP=o7IG0mUe@65#m0~W}RrnQeesg$CRfdXedfL$S!RO-- z0&wniHM0V;?nj?LEv|Cl^5f0oWy(~keqe`5-s#3oT|<;MbfhF9+6dIQ4hIZkr7!mH z&|FTz71gRt>=;U@-NO)T3S8f|m>GPWr;#LNfW9|aUCHd8Cc_&hAyPCOKb${SE&RWT z@oSr~XouXd)^st!-1t~3a}e6kbit=vV+?%(0-Im^3kF{sCo49W*SdZ?GPo??{Sekt zx!*~NG&vhO8w7lN-6E~)~9?i)()+-YCc%t1k#)`=ArHV`@3vJ5^ znID{mO~X678Bg8Fs9Am+FtT(In)0Dp>mVsT4DalfT$%XrX%7#si8n|(nj;ZpKHlio zT~AJVL7GSAU!7)p@RCVT|Dn+>=eY1VP^VXG1&-_w@6Etb=W^ciPP@TSdC({(^4ekULNh+`%yO+eGu9I2PBt2dbBIAvp`44`nC*&cop3<6xd%U z7-YYnlo?x=!@$zlv{<+5?YfcP_KVKM-3;!xNKctfIiJmTol)PLile z;*N=lCe$nE20+HY)Tz1rIb*QySqY)Npa`g|4<%%0TRT3WVfqogKp;_Ng(G)K z!cO&>%`WhAjps!p3Maj`)nTsBNFYtm&NH*xpZjMU}TVf?x8D@Pmk}@yCX7cKGd;=O*>eDX>r;f_BE*~=?-k5;!`hB3|Xnw zarB#ky%c;~6tWS2XOqRiY&s1p(;Im*#x4ONPJS8@KMwps@So_1?c8MQ4>c<*#!x2|uie zw!wjc?6dst`ErSR@g-YRv*KZgcpE*L_jTt*6;~uDPp#gvl)I*C;Q|>b8>};34`;-k z!ry={lnGiJ+c2TfhB*TRjuY#F+7AaT%kWIR6f1|jSv{D72$aL$Tg zu5HR5m>nciPL$cTzi#lXas(I%wIASSn@D)I^+AsNIs z_gRb789$&ItD-;`e9$25{&IjU*DS&{Yww5L0==;KCqE}kyjy2NI1yLe*~Ai6{0l*j z5On6wl)Cm3-cq36cgYQP%6E+mgsCd1fyz6$d#i(=WizWYxO1TJ^Uu$Hjc`BWXPM9w z$yKc~efh1ZF-GYQ?T<7%<>|4yG-|rHYf__XANE*d3XpF$z)Q)mHlOott$)fX&CRTw zyl*vIbTjZDf^bH16p^Z9lBJIm&U+@krmxt=k(WqwT_9s48MMEsCKqD37k zvpjnuGeQfr%kQGZLrL&WZXEobpe;)&lOsh3I?9xxi(++V)fXew5^Gp_MAIL`2i~2y zr|qrP2JId(ar1X_AZ#RsJEew=XWx~Ox3`Gfhnq~Wdvq2ON zM>CIppF7$zj4JKQZ$~)afemHVx>T$wL0LbsLl=a`(q!F=eT)oFikhJ3s?pza(9U*V z14xyo@5dS%BhT*5MfUvpwvC_1*O0mU23+to{cf^lVL;PyyYWQ+9U08ChkRO0ZUp&q z$Ewby2;prDZLdRRCm)QebT5dR7~p_^ayDl_@{nSliEiXRHUFs20AJ0Kz!5#J_mIp) z8(?@ zDwhecrBMCHVC!Zb=_;p%sVQ)9ok_Kl$i<)*6Za>z-WL6@BfVSa8SW+u*>)ROYw%=< z5xh_!4FspHmONp6R904EE}fEekU7{|63NJk?+l|TFDQLmi$>=6ls{9A&bOY^PseDZ zl0~m)jYpO*uN8QD2%PYxO!N1# zmha~b-=;ht$XA$vA|Z1maxytAz*#pu0G-U4Mc>e0hBe z#*ZI~AVZu(*wJ>H)khZz*k&>AO9(sT)CvV%5quCPrkc5ruK#~82EJa4!!Crx`{L~W znsmY?MS*5BMjd*4GQiULXlsQ_nygJoQ2{*Bqe*hKe|wvZ@DC_dGVgkgzs*OBS| zDQ&y!(Y-7zYW;k3%W2_2$Ia%FvUfvcY|;SRSIEmS9$I`O{oXGQnuR6oN2r&g>x_^a zpZHkwtk9nr1B2}$zoFSO3&!;%?B64YBie?+SbY)=%?ac7sj>NF_lV(r6_-dj>X%0I zNw}&aa~1Zmmf=RqH^Av7jX$qMQn!I0=*oNr#8lAN4CP`916WHu(A0Kv%fmd=(*P+N zL?d%HMEx@>b5cD-I8rO$Gz1avL}~pqDX#yU%k{e7h=hu#Cp9aeq`8;&Go3H~qv3b` z)~5JPlm?c$TAI)d3!wHbnOA9jtL-MHc0puhNAd)Od?vR_Njvk0pDO1Z)mz64QS-8= z5z1x3+F2?bQ*4<8MG;TODKOuOnV(+JXlpINGrvWZQAW97^#DdC`q#icL^L1I94X{z zqg(H;s$&|)k?yRi0$+bqU>~l`h#9{&_MktWhO0BhZE9_hU)5(@L)A9Rs&`WofKF}! z_VsEk+fxuMka}h%M`YI4h-ra2>_l%*=z8N&?ZAK3V{P$?JRx$Nb^g^YM3zxH=5vBO zzVo#*WP)n$Zdv+n`+ZB`{Cv0W-vaf?)I$^n5$Abm6cV`Tlo$)O)s7-(X#8s>I`Ff3 z%(q`;g}%WGUDTnVNDX)w|BpUuYK3;RDFX$JDnXDDT%Hlg{UQT!$aP^mGR+!ji(ASJZn{RHp zbGEkCMy4su`S3T~Jb7Y5@XQ!mNiM2(!D7Q?p$fEbj;tioz5Wo?llw2=pL`RA*Ju#M z^#~9`X+pkNhkok6d#H*6AQZ-q1(*EnNZ2(gl<7NileB`gqg%Y=`b6L4TlQHwV*5o(Eo z)>38DFjRLOw#N|@hzVs$SLl>#5Gn5GjwB$LONDw{)`&tqK7YmG zFO6^PdnA6rHOCs>2`E|m4?Q5R@<+3W3`9FFYxDnj}hf*I114Vw)f(Bezl+wmfL zY`RZA;pmmf+nNDpA9%5%kUkYG9Q@eGGMrT?_Vu*~%=XE^4ffZAK8}t)V-7mqo~da_4A)%x+B0`%I;ufPo12e*bu7k z`I5_*h~8G0yqe|sa~YcKEa&6Ohj_aDBcZb#fB&i4EKNLbr7A>#Xw-fM7VeUOrKjBt z*4YE3=`^v(WjOrFw3n#utVr9obTIGpCI4*R`Ox`)Fj+|I4?!^N*{L&_w2aFqJgDN! zO}wZ2&u*WvJ0~q1J;KbZIm+J*ZYUDCrHfb{wb9$)zc<$rBP^eW&=2s+9vYEPl8MnE z)o0jj^)U_iNtT0uIo{ly!i-J`lkdsneuw=)_tF8i8*Rt3D9ndsm1XVDfzchq7jhT+ zt#JIDA8ad6#t=~yRYHPVvO_=yO3+QWqMb%(nc>hw-PWgo0-n) zUR)Z7O2B=1xcQlMQ{|?2NMcMLrHN3x7gGoMx#zqKmrpmwPRR!(iv;k^Y zxHbMTJeU{w4snK&5Viu%svP{@%$^)YfQy|h#%KvnXrd&yc$(&)L8x8dd{It#Fr)Wp zs&x0l{?o1W>LKBthzhXGth>u!DMuZVfRzx&fCe11ob8sVo}0Oh6A}zB?Z4l_h~yo1R1VdX7=^Om_yKwG+;rA96I+C}H4b?-bOJNlaOhjRKM=Fsa>!nVOJ==%k>dhp z2}sAdJTTO@wEb}O9^^0tV$iGR5pv)sQ?obR)>?^R1M(cj(pgszo)Ghy6slNk{e(l( zJb_S-FXk^lJ!u`e)5lp+l`XY4e&JleT$>B8`XV{;HxTs^C%(u2k8NXBQ=P&`=t92T z#K_E)?*NawBLT)OwoNRm2J9~8YG9o{`##UR8&cW~lm(mTSlqq;>C?f|hcRm=h&d?v zGRI)Fr5)U8DBKxQ`^?)+@ld2=1+K1i^RKQR&=?!Qk;e^RvhQ|O3@?$y03dsaim&Mk zuO7ZSTrG;$rLRD|S zI;BIB7vzfh#H}o=W@7kYR3rHO207-ke~;O;b_K6`5}2DTr+sf_Ev9-4x2(vBJ7`JH zXh0Bbx0$6+b3K>5jAB5}{L`=mKI&D0g`zdf#evVlXayE82EI=t{K3Mew%92r&2Xn2(DQKfrHy}vTS5H>lpR8-OFw^&Ggz%&E z{q7{Y$DYySyiMR>Z{^^J;&o0HvX+gS-#PcuYx%`z7>Ldo{vTyqHh6A?h48WI*J4DK zu2&KCs>jW9hzw=G{M%BBpj&Ppu?tc7ONDcrqrFFIKrXl7xy6T)>FL(KDZQ@XK^tmR zfY5uj!gQt`nQEI479-{|tge*mHl0Sy>lhaxh}jEaFWrn1KQSnIle03ZBuVBwhwFE) zNQ1=o#DmgR>-W%9F-$n=!H*FDhYVu_NIjO zXPC&7peu1TT-#n$t(LF5fjbHD#8|S9TJQ4O^j{0H>hIMG+!nr$iaM8{R!u%V_V^yl z;=*MsGl!{A6J=#?HM*@2Y`ApWMV@Tg9)<|^!MddVHaop4Bw)6xSw^AaoW^}|lLneK zlNcF|9hEIBcL0q7Nl8n6t*6&&a`klW#Dt1huj9YcIpfJTMio`VHbm(m#3C_d`J_C{ z-Gd6W%0j!c)c0Vae6!*~WHa7DbtG-ACoC`2GH+p#|35bHZV;fL!v;-YPEZha*KWZo zFKQ=n89XmDF^&XYiP_HY_Qn_v5&TXQ5AP3ca8aX$RYbmyURy$v$m4;S_$!1B$~=dw z^Y3Wm#!r}prg{_E#RTIi0NF)0;FYfV(^X4qlK zM93o;o71FF?8;m>j)GJiNa`%MO!VuI4rL}Cd*zOzDqGl2?zOr`WddL1Q*3V$2lVig zu^R$LUr(T)mhSrg7L6NZ=B%;hnbAyo3 zPrr)=uS%{t<6r`{fi?eEME5iQ)JL^2b~ja>p<)Udf-5rZQ-i;MuDEU}I4D;5wWSd4 zpcv(Xg|YxtArupzRb$qXpjGaCG~yJm5JzG3_-9)%80Oo4;dbF5N9BHiTF9yy_fG(; zH78ZhKy`IStf!xCn!og-S(b(2sks+iPLlF83y|^`>XjYH*2;xW8GNQIL<(3@&)PAl z6OE1u>k&LW%NlbfGrD^7ANkhrKD-3!YmSq4gwhTx`nGWgP>thR2``W*yfy$9hgV3W%gKqn6y}FYmFQS3CDoJg$aNQp zE!oXC{a*FTKBLh3UB`A;vZZuk9B+ZB?u==vg@Lce^05PkNZ)>1ir^|AXs&+c3ip{G zlcpC)zUhj(X9?bXFhXZ~-hz5k6>G0__HH3;{5S4Bej?ANU<2}dOOz?64e>8%SYSb{IvBT1>lhSunr;wU_uwi7|@1Owp$>9z+C4&mo*ELl}MN1Xr4y9VJ6w zFDw`(GeIlKdGh5e1QUl1qxY{aw>$w{cOv zm8Dd3Jrm@FV*IJ!K(yiVghH5v9mSVJikoPO`gTOVw5pEVJ&EDk;{?jg7yxP@}srqwwZ@Rv)D?k>o<_pxj9p3B@mxq1_3OfqReui)BLu zLW?6#Gz|^V5`VjTL^7gM3hiGixA|BRMd)M6)5CeFAhEWeSx#_SY;GMYMS&&=4f33w zDp}>mKdq$0Kx!uo`Bu2>F2C~$Ft$vix2_vUE)hQEH#B7bi(N(O#u3mJwL_%Gjb$=B zM9%3+QhNS5wJznQW5OC!wac+i!xD6&5^Lf3^&I34z4oR|1v$_fu2kU-HtHSa$)C&E zKgRNxmuIcXDkj@G4>PCg8rGuAPC|T-wX65%8?$rsyt9!9iPB_C5c;ac3Y-R{OO13E zo~-@PzI;$Nq$ctX0Cg4-I5202PH9Ls-5Xm>PZ}fyclnIE{q9nnPD$!6)I57-5Z0r) zs1__ljDMe8m~#JYvs>eB4~5Pp7#w6(36S1vE=D1&OD)$sz1fYZ9Abw}X4vUw&knA!J`*Q$K|Z z49L?UQbmeKA9y0pgnkM{laQ#86u?j53+z6r&nt+g(*KQear{D!y5HWz`}k|$#n4O1 ze=4fT>uWwT9z(mOp$bBFV}SeF85M-Pj`>v9NvEZ|GtghEuPrfwZE%efz_+2frpmR; zy(Sp?Q%QJn(ic*RMk`Yd1xxY;qY@K^;@8~ zSu5pOOw}~Xd+xo`YGI*%L(Y_rV@Vb@`DaqALU*yGZH!tqv8uuOf zT+cLi_gI90_z9u6!*P!;&_^B9+d>$;=UvMN0%Wue6ZXSIN1^HjjO^MDIEL8P;Xlne z`(F~fnheWn{Ev&VMMI}XS)WHM8Xdtkimy*LHkkhq!;h)*px4f2pw^r{P&>$JHq9po zjxb{U>^C`}b|vbvSkn23k{O_RPvc|x*|~R?p*a-*!%=W0isQlw#VLB27-|@CUw=3U zJ8F8?@5DfX2r~@%;tCh5&Mz4zL)_6B&-7BBRDUi+dcv_==nAoMxnyxs{t*>L(G?WEwp{$0!1#Uccq z(6Tj#>*4xOpBB&_<@Czcnpm0Q+|PmvncUi0PW224_U`6M*j_RZT0<*4#> zm`9(mtXcL7@nH1L`KAdLQKPZq9%=+MWAF6q9US{MtreYMuBYCr_a}4y&Ad4Q4+&)a z;q&g{l^Uo@D2*27j1&H@pILNo6p%yHLSq_C(2YFE6^Aczq=ldPbe$|(dD5yNU7C{SZ3O$ite zEism0CfC_LyA&iiIJ)okW61i4@QmCLAL6nXK66={9+E6eB2liPPIDE0e|BaCrw6$V zOOzp`ZK7n6x|X%Sqau9tY={k>s88~c?ZNa5YuHZIuh4`{qrxq3iW(ogL)5^u_29`j)9J>~ zEl|V3f2OP3faSf-Y{Q82BUuJVOJ561OOY3Dqy>y|d900*Hp3dH6tJ#_UgiXp@+E-) zqwr=gm_|p(DW^K)LC-j_9CgTMMrtwIQQ_Qw!TG*V%a$0{`fP_J@f&5tb zy7$XBRs%Zp%^&C{yaA2dpn%RBmsKd5-+C;B!ZW0c2nA+NEjaj8AM8D(6uz+vuvhZX z!K0dCF#LqxGh*I%YnSbB@RW?3tk8jz&et;MQwb*`z|fa2(Af}Tv$RvjDHSMUDI?v_ zKIWOepZgb>c`v=dh7@WVqsyqboHfyy!w-^Tjxi7wEs}`jMXhSJqrvms>2cDqCt;QS z4D2%|P``X|2f5u;ySGm${AyA+i}_UVo0Y9fQVH3h*rtZUH6R@HDf^)mn_&i_5xbm= zRd-kNHo@9O&3(Ow>WJ?=hRw!}@U9|%cy50-{FJrfPs>_q-SbAxUg|5`@`1&J1jSip z!xJqS(;p)CzUnsfaLs&4!Qta;9n4sDA+<-myTg%z;D8zwE;P(#(om@2NmdM<}m zWGKnaw(0|15dR0N7n}7azwCKPbZg)qEgWYX()|m$F-5EY#x9wUiHxrFsT&-Pc{Wkl zU%#oKb~6SvJ$XWN%N|udS7>UQgYx21x}GNkh6}xZ#5W?ZlX0Okvs+PQz*k-y<$&vs zdZVmN7Y&ZH9H|jZru>In&-l^FUYe&s5da85vR&)chYSX1_gju5JOdQHwv`>%Qr}&T z$iq0ytSG?8)6Df-p0EuZlc?|hNz#ihVb${%Bfhcwv=o&QrQs%i-z|Dzy&+CyA?|>{8Gu;9Re%AfQw%6(6=yjZdvP>h z(r<5tS?X_NoE+k2g^8$R3}K|zE2*jRZWLP0berkDEG$`zE}!%)FS-=!=s6rqb^xDy zfh$=)i{ym){Xf8KJB>m^nn1iKla^c7UcphieH;E63tPKkfSDa}v?82Qx>w2p7Il)^ zLD*q#;B3hiT^iaiFQQdEQP~3BNE7LHY>#ZW5W{P7fZtp~LLytM3=<8CuajK0rdA*> zx%)DB#hX0mEH9)`OceT=`mbv-ca_iX;O8K$JG3NO&eawB>OmsnGDs0MP=2wBtW;!v zJU2j?WBkJ-)WWsWX~gP-ke5zdpC_wyDzLtT^vSbPh-w*40K1-JdJrL z`gf(XTIzzDD27CwC>@R4lum){$g?$GufVvN4%AU)v(eC6r+8QY&Ib{`4h96>Y*Zb< z;(u5$o+7HXwZ4A-is^#VzfRrnA>6fp;oshF|G0?00)m>6Oq)(@WrR^(m~w;CHVC6oQ1L=p+Q;0(I=HDRY> ziu7TRN;GDJJ36fYaH}4a_@x>k(UPy%u>z`+A}I`mXTeajL%S*Dla($+WWhBLcnwzh zb~Zn7IaaJ_5u49YFUe_oO6WtT8$|{YVVz(@#81#NvYP89wIRVfu+jP` z869d%cScNN`$2TKPFEw&vBiOvm2K6;R%ZMvr>jc#{b)|BA4JQBT8EE8O8yXcl3+8kAJ6RMTw%-mrqL-z4kI7+BHC zt+0{d2v$vZ#E3h4tF5%KvNo-i7T$yT`gFkXM@7qi7Pf1MY@H zNfofs%(#(-LE5wL7!AETUvTVKVw$Mm#jp1fM~lu7?AZDqo4sLJ8GvU|92*UhlZBO|!@{j-av^2cS+I1y6aYZb z>6n{^w4Y*B!N*A%iAxw5zC?UHc#C#Wp& z=`}bzS0-Ium}-ysWpKM$}Hlnvwy-GaI)|E_V-NSJ%)i3N&7Gmh54TiWK8b%4@}0*q;2i zgH{%flt4t7_67$Lu`E*DH#pZ=yiHv=a)Td=6^!;nvhJ!@D{5DMlD~HE7?R34e zcat1 zUkK@Hp)OvG)jnpyd#>8PCbYz~$o;a&~rZhnSVCMh6P9 zfbkbq@b#Z7&8?uvj7Ut%o41z)pZDL?VA0M}MP5TS?aCyy5WMgsW>KwKCCU^}#B`~h zw~Af+C`X~y!Erz;m5lq?*}V{BTC34uybrPCx&%WMVRc5N(-7NIteK;irDB|Gi||hWU$kja^_%7)b5|YF_S^5X%q`>XZM4(z`}5-^4+EHUET3$IP^D4 z2-YyID6JrxVvME+m4VXMWA?4#$PX#Na@A%=`0O1*7lDMEnl+Gtwz8sB=>CJ3$+d$Z zdYUW&FxVctfR{dab_i|@VGQbbhH5oyoY+j}X*Rj$v`LD2$bhUES-0^<>%p)<$$9i= zx`Qy;o7?>80f@%PKt@h%YQ&2uyxp-)s9z-hhRue{&GM8(Q;&DrmsuE_(AkIRsft6n zt-#pYzw@p1CG5rW+jJ44^*^iH+g2NlUDm2}jf{<`;OwIpg>R-`wttTm(RIBaMO0;0 zzBmLP*t{V?X5fju?aTy(3HXCuah4^H!b;lCF_uy5@G5uY8L*}PklmkY2Z++4q>bcg zSjtCJdEJ)NIqc6(p*Opo1-=30!x#N!mGj%0%J`SAnz8dn`erokh$W*k_ zT1_9n2RYGHoK;o*C9IU}NDienC)TQ)#M~Y&Nt^c#sy7bJo-^%O zp|hT2Fo7Hf0v{s!B_?eDQ;^LMZ`~a9D?%x;#H(h#NrCfPoTDJpaSD) zw~GGUUU4~t$$g$}M=tJ323RWoqzC;@|8CI!FrK#khcqbbviBvi_qo}H!zR&^?B0s< zNQBMLdlgrzP6EX6PHA`EiD^{q4J*fQxH^#`&JaCahBA&ldf z2qqY9g19eqW>GX-f@kb`W=m}C&1+n}1bdx~MG24`bhn=7v2rS%B|3G23zrELU?5~v zzh=(an`KGkl{py~tJ)Lap^@|Z%D~?i8-D4YhnaTcds)?W)Hcp8Uc#L}>rL)zR$P_f zG`H>Ug7B0a+A?6Wn(I*ZG@=>w-v<^sisLh2YBxLgQePg35O$Xx#?p|JQ9`6SN-O+Qh%W{m^dl5^;1IxLCC)q3ptvIS$=hT?A+OAe+$xX zWAR_`+6PLXSUV4PFCNi&f9iK6Y(r^0r)pP2yl@*4k&6q1__t9b*agSuA8DQT!BrQx zE%~_}6f!a7Ya*)v$?~*$c!bp@3aF72L0B1oWsY0?89ny8!CM>>V+I5m2HA+M>wI)H z!-8-^zNoTIfh9FUs5?CFcaE!MjuStUCEu%QRI@Bb1GEDMHvfx&*LAZ{NkV2B z)#e6+YF~(9+wy-62LPS2yZks1P#2egijF^JwF(GQ#vae=XovdJdtV9iUN#S(djFcf zTU3aPN%uUKuwC8WrtBgo zt-tUG%1;{jc5N4cIp+5?kmpEIeO$FuvvYm-v{OwX=_~K2wiSkd$6x3zV97ysIBwL$ZFNbN+;X7bpUQR=F6hYN8kG|Wu8Nc!t8J* zmczcojMdd6Mm1>&K_g9A~>pI2!|?-86TT! zrZKhua3HRP&RKJY(W^Kk!~XXgw?-Ff>sXi0LN8LaX`XSfTNW0CcWSx_I=&q-{|{Nl z4eEN2;<|vIFWGk#Vf0BCZjS`VfD<#KFKmKm_bsg)4+G!1ku&xa%RPhMniDTnOu1AT z{BsQI?o8t+eUi~!TP1#|={0G`=N=1i^#?4(*=2axc)`(Ov5lKxXxTsG4NHFcY2(Q@ zD>e0I4qUYhgDar&W&WiVCX8WaX}LjReeH>3Z8jey;A^>#mB_8*GSiJ;EPQ>|*PE`r z727Jrv@a!>eZp-Pil=tBuE%H}7{klXen%fo#caGxxMD*78{BYFTQ)y-@}> zM4<(~^Dj8>Dbw^v?ccGyorJeJG1;hZ3cvduFry&)DVJhEJ}b$yPaJi};o5{_C3T%Y zH;5mkkkrurSh zUI_C{rZ?71Hce;&BP*ssH$m60vG4C@32*U1C(}24?}NQwhfhJ^09nkv3Ot^Gn6vfX z!BIgi)}(p(0s>fx)X}Pta=!_`YDWz-E{{@|%F;z%ZHPt+HNtQEZcfiOdu6rQXJuXG z{Nc$)v_;`o>!s9%qzQXxUeXA2Gaj_6=MV@4GK-1!*R1etjIpO<@3|9Upu-0OEDToyTjlDi51g2H`KRl|wFXTb^?=r_7@fm_% zk+7Q1O_8%Q6B^&_a}r7z{3CMJa_B7YOhtG9bLD!5S%bt80mAYYG)}UziRN z-U^MySuwfaVSo3cXvtN^mpHT=gyFs@CP%@$v5Zhz4lt4{R=D=U}{*6 z{54#>T>g{6Xl4ENlCnxX%uV zl4j+(XMQk6p?>wAUtx{YsZeQQ##qg?*nwr&LgIgRkul1{KWWtRBWsT{-Rr=6bq%_l zen-1;eR;9y!VMWq#9;E_D^gExmN6 zCjBthJ3pd=YUjhbFDDZD+VBrpZqo#Ei>oj(u&oRA|-D>7>Zx&#DF?Tsou7dr(+ zlqxyKj`Tg>1=d}XDAjr?hk1C7T{>?&z14ygx`gIzN4q%+u1)1t-2fUZb_)cf#b7A2Q&`$! zP8>f|jL>2$$CZ!|qaEry@Dz^? zj=A`OP%D%-8SdnN#vgkpfjE$5g=S`vvzWA^i|>sAJr=>r@COmfFvvM7WnhPuoWAN6 zjr0Y_0x_WD^%RI&fXaiZ9SpTaNEEw|{ z&*KofY#j7NB;0%5>o#3@N&5jo>BC_CszRAu%r_g?xa~R_PiDi`i9KL1e9dVT<`VLl zkllAw^h<};8q{^Dj-I<)%d?;edH_IA=q`QcdL*+J5;b0};yFk6E13&13wl-hz$X#x zS@r~p(V$yF`oUikOZ>vi{l5T8t0U8eMA zXHR}47yD;&_9J->luat98}%+f`OMXS5TpOkEoO&?J~mvii}^iIz1;e{gYu^KgZ&Q? z5@}Z)G3XWPJq3JdSeXZm2fhTRm%y`jZHU2C3KIn*a zZ)b4yJpnw`E1Ank>s7x|w^`-$yq}TzVcv&V%}OnWB^FIyN1!P!f(E6c(-8y9CE2FW zh{0n6g=DWfO0Uyd^B+U&yo864u15Am>m(W$pn)-AjUGG=G1FSIVEvlW#bvSnZR(#Z z0@&Wf@U{cq9LlyWcOG|qjjK?OGte%%+$Qt*%hVS9x8U!dg2>0-W5<8cokw&MPE5j6 z9B&)J8xJ`^An|f5KjgmOIT(Dl@zbhP@2+CeI+(W3;6c9zzJ{CO(x9q6sQqAbIK>Y@ z*pi8pxo8~2BcNcY0qDA>NHvut-h|Q%l+-h2-63S4_;2Zeg1Q6GAtM`8oL!RZ z%g*Y<=PM!qp-yzto6SM#uBU6ZD?#6ZxA>fENW0XmUgPwrzqQWpbDC{YbniX}`yO;k z6Bv^FdYkHf_JGjk3x@1A`kXm6K3>>LsJF!Mqo?%gB=88wUFg>P`xF9f?XS-6?q*{v zPTRbS6V4}t(e9YfsQ^M|mX=8Er5`T9oEOu=mIpR_-WkkUyjf$q*lJtVHL_hDj*wg+ z8OWee|C}vsTR(sh{Ovzp0U*sdq;?JAj%hZlpbZ|VJR4F9xK#6hd0^P=3F@DHk}I#9 zN{J^J>Xj7C-I-pFQ2XKB?@|GOQ&YkC9KpT0c{>upfRRF)8SmHg zHIds@wNmb|{Hs+*O?~?%$dCOp12Z=vbF1E^fxh$AZpd3IV7<5P{s8hOb-lM^-?h-mh^T2WW2s$F0RJ2Dvu5DNsJTC@sY47liLlSea?h*Arr#C0Qm#QGko26$ z)M6pxrZ14FeS>u60-c#tU4`+pl0=>cBeFcNn#Q+SETtSlx9dg`%j)FJ%<>X=k(%9gk~~eSin&bKNI*3)O9jeb!4B*2-Cr*fj7COl?*CY(F$O8*A$329yR=`Utr0a^?E(;stP^ z2q~b6NE<5{%WW4(wZJmJ{k)j1*ZKVDb&RJ%b9)Bm~eNVY@XpqztZy0x3`~ds=~p6KA0KFeQW?38u=1Zo$Bf&m7vC+s& zkK>#1HiWMZ+ZuuUDCMF?9HYCHGJebBC%duy2`1+dR6m$f9-_`0F z(CU5t3_8{788LdPG}-}f1w=fN3Lfkf(hU7Nj@Xn?*-VW{WEeHB~RyZ&Y;yQ)w*vdC7x67}jNsDeg;7bH$je%#$2d^MX|N|EYu3z&Hl z?zm-#ACd4)Br#MKp9)aRf0;^&arsCAYDmTM&8Wvw+0?{>Gmx4wn<#Am8>i4L`Xu|X ztuHH;G=fnjoT)XaA)n8RfDO^;3YUl+!^{qN zC84As55Bv0qZ4RvKj?4Q=xu!n^*%Q{-6q!t{l4nDW4;pbA1JhH z73k~(86_`--{gYQjh@4M2Ur5m^!$&2TNH3q66hm4whrbJ4M_03WO{t$ z@NILqi4htzvrnkvGq&1u9=PwQ+T#VxpX{1a;Z6wPmWYC-LWzUoFE|GNBOPuGC^+|D zG@K=<^orQBo0p28TsF=*k5z?U$Rio%5kW?)aO3*eDiRf#b&ts~>EycxU1$2179ef6TPyZOMf_2}e*333T0pSFUA z_#vWs_Y>)D_tVzV%|jd#iI0#Yk9(CCf>8Q+9lHSQb8LK8*R%K>^V?s~I2P+|aOmQ)Zz^zR%5n7JG6neY=e&Img4Q5tUw3WaaIQCKT&-HIav)u< z#L4x&`)t_lmAh!XD;_@Hm?=2p_{3b2+b$TpufM8<@Hn6I(R9R0{PUBrD77ydMDAPUq*>jg=T>Gc73VFgzDE8~y;2)DLy45C}@vJCl-596&TNATb_pv72 z*BY~9KFz`CDc>`(7u=#XV$bz+r}oV)f={HLL}-3;!u&*dr7&y~hCvTFJ zG|yZ{Aa*hwmoj>IZQ9us2F58)oQ=QS8F2vwoNIi%C` zSP|fuYNRW}nUGT?XQ#X?;~D%B^Dxr2&|}4Qe;**dESY#$@4z<8*2k7@*-R2V9Aeb0 z`$Gh>f0x2meRyzm=J~L-XCmkp5cCtg&jJd18DH+5^6CLILn`-y&iI^LP@z@V9SAEB z#9*}dLBpf3uMf!-^g}G^z=w=Q*4d{q-=%g$e^hES0!Z|_!6H0tiMUu70sYI_FoOTp zTl}*b__B8<_njl?XKld4ng8oW>jfVDg6W$OM3i?_8apMaMo+?->AC^RrUv!ZvJv$! z&=&qax|kY15bSY5o}Bu*ys^}1e}X!atNp)H@)N`Pb*6m~-pf*JP`VTNmcI-9OsC}N zs@ahl`Pw?pbjj@l`jdo= z8tJ$8WEXtxrD|sDodew!vzw|YtYfYSZ=VAOq$?4wY@4BfsImtvvngP8e*Cn_Xz%Vm zwDg*oy7;`zvn=4_IrY1AS)e;`WNL~jVo;`r`kKQ%N<)~{9i}pH_+#R2y|Zg{aaeGv zl8IbfMY>S3>f0PWUSTb&!1bP{n(bGWM8Ofy(CrC%7%9*n^saaCt zo(;F+N@u8o0Gx`(gMQn{nX;UK$kuW?mC3q{LH><~SRq^*OeCldgw{#ZiBvnwl8coW zIfXfj)pHoV5GX^H)!SL$|5}=94zrxJ5+AzUfU{;T@4ZF2OQ&T>{$9TdfmuticC*pF z-UKhQ+>3cB8kqob$k@ij02$VDs2NB7Ge+ax6p-8{XwhvE?o~3+VAl5I0oCTxSM$OV zXOiEZw=w`AI9y$bk}z#^sTd|CRhf9^r`c^oxvYvOy)1^7?IHMcgF-0&Xnnev^&nl7 zv1P-sZo_fKkq6B@g_LNBz)f*)r>r>3;X{S-tBFqHlnf=TEYtg9ZD43F_>|{)>8W?- z!ExrIKV`1_!zE{fAFZV8FyK&Gd_!ZB&dA)RNSIwzs+;Wj4j)NS&=jr3> z?&B&j6=IceRdH?Ux>c?CFSTMSiBYg7_!5cJcLX-=sA~lw?S z$qzJ||KGQi_R=O=1wj`j;JcP)f&(%tK^tO19Kez?T?FpNKcvG*XA8(cp<)k8=&z{e8grcC*`s zC&ngvA5*g@y46V4kYG)5%l2KDyAN`LD)Wz$D^XsV(<32P6*dpe%dCQ%F$nU{E7EIx zvkKnP(dl{fY4gal*No>Ugn(?4f%lrD)cZp1)b)z&)bmK-)D3y{f*`LOKBwLX_}sU9 zp#R~#(~X+&i{0~WYR`9!v=aH#xXzz*;|aejEAXF@k?QTRrzTq33hQ(pip-%!#8bVW zHX{Djo8$afJ)@8$)tKetSIB63vjuj?)2q{c&$`Mn71Lk~zpWC9Z^~^i?24kGLd)WH zOO^h&m+xGO4TbD-aj~e)n_)S(GahNROf!_EK$_Ls%3%V}>%eAPBZ}2q7{pm8T)?G* zmuYK7%b|)QO0F4c>mK}{=`IxYo`Y4b^4Z(a?1Q^FI$M2ha40+)0q;T|WdbiHnh?j& zjQ=wJvxOp0u*Q1VKPgS9!Npvv-#b=ZRX{nUV*V5-h`0ix)+j)x0v!50T9{@?mz?x* z5~m%d=M&;?8`Q!>syAowX*8tbg{TYB%OqXnndpW`aR}&XZc>Q%43&p=id|uSSsY3= zPTroKd;iKI!N7s1O`kt3y>}#AA0R)-=?wba`x@tT3jj6t4*5Z(jnfZ?4raF0@ubF^ zRRh!G>b*we+4`V{cV7KmYy z0PkRVA1`cZC^#*9zKXDVN7C@&AaYi_1`b5~h(9QQ<6irFeA*b$@Go6uokG6DTTQ>D zS<X{4g1V&hEgYtXD^!L%!DJo4eDUInc?I{^S{MdpYwObgCKlt%?}KxGIVh~F15b$m zL!kNMUtQQpNMdAkcmJ9KskSkoD+8Tb>m64lE9VH^4p|jrnR{w#PDBt(!gpRq+@}3c zr+C^r+KjpGCy)d!GqNZf1QBGQ^*1^pd{@K~yG$Js`)&g7>oph%=&XJj8E3o0AO>^>*kWMH@d+d+z0sVt%_hMqi44fK+rZoltK zvzG*&sc5?gz$XA})g1~NI}E>b{FFTzo=nlCDHBNE4HaDRx44hh-Cip+Sqa^42~wG} z8u}b#g?yGs5i~LQy_kHW8;vjW2t_{>DLe7b1?s9$)%&8r*-s5;Cw&mAzzk=)&wtf5 zVf6lDwErQkw0eOyS=>MhA(uBzCj0W#(anv=5Pl=}M6lH$>2e*m3fxzNcSga}E$2c} zP%hJWd2H>qSXQYo;u&7EY+uh{{=WM21hI`m^HTn8lI|OiZ$C6rPN4NwD;KTdKsiW3 z*ahVp^a*h*An@Pn0*KPe-b+3t=j>4b*NW93>=++95=yfC)Y!v4p(9WKexOCGCEIn5 zPLLy8v5FrM^aSMyvYx080 zG}+!9hJ!Td%-ov3>t0dVSu9hl<|M@1dc(QdXfR=T&~(&dvSD~p%;dbwllmwbVaH4* ziQq+A2-$UUQlFkpXWLoZfs7J>S>MkH%P=!CzowWy)pI7G;6NSz#}8uHc|PI5ZtH5R z`@mx0_(}e^7)?WdNH{X|qwABa>>S(tbi9l}3ZL0Bu&;M2@Ml+uhsDiu77urwCx&Jp zm5wCSjNp-&kc)>nVv#rO%ihD?O@18mCfU>frQc?Pw})wC&?#9q6u<6Dj}~u?T-4uH zh~!~*RI%C-bUaBE(=z5iCq48RwGom zn#yM}2bjlrsJ!yJRXfj-*m?l?Y5(5e&b;!_e3#$s9;!xf1hr&ab zdv7_z50Q5vaZrIk&#A^ty??3_#ENxo?1XOlx8muN#~Lvk?eIhfk}%quds`0d_idi~NVRa~o{^VMDZ=Ajw#P6c`IOpt-bKf$J0F)qVB?Qn-wR)%K&0-`owro{Y$q`U#+kMA<7T1+*$v zzei@P<^6^F`RGzB{|tA~z#gBr?uhlS(cp{hD^|&-xEAPp`oqvWWfj*O%{A(~n61W;1zA!QAz9_pz*4 zX;jMA2b!0q&r>GBfC&wzW@Y_8&;qJIw1z?sd)V;_+ERtk4~ZcGF%=KnLb2?8%>oHu zBvjozsUCRS1C`cUDzCv`{HH9|d); zlM#X877^-obLebX@ryXYY{7mzbV5GqN>%H6uUCAa_WXmLX|I_0s5;!=zJm{~gcZFA z2O7obJ|dH7R%(R(kr}@uhnuW@?5}Rj0^Jb7<~I$*8ebEt#$IVMTyX|Sm;YiyBwgY| zJz^bdfT1c(gtIHJICdN&W#iovYEq@E?1ZGR8!JM54_8Zu%Kck}{J%VuU`jF6S*o4Q zgXk%~{ANaI*;Rxva`l$_+fy=q2(DPBN({0NQG>I&$6}ioNHhJfyw;36DaNFgsDO=@ zKpuM@mcrU)o+Z|MXVeRm%zQ==e#^@C-}j-B5rnI15pr47g^DuH$;k|p($pJGys*^f zOI5cXa}mnsahmb07pvwLV)SqI@oj-QywZR@@x_BL!ShM78u(!7c_s{G>OH%92flQJ zAB6j6K!QPlpe^Csx0g$*66jv(?v&6;Rjg>_&+9Gn34+y(L%sW#tr~*l zMtg#9@*HgNmm8gRrWm#MTN|5yJ&mMF2oL{yY{;lW3$*YJtTaXTP4KPnPb zD;boIQxo882UoH3KCO8~X`3K^DQ~39%2yBTG1B=VnG*|LHm*)AuU2pc{ht*BK6T<3 zO86f_Un*=U^nM{mTS2I6U8+pmJgM^47>OKnB(V+m{6w)|!-gCu6^Y1{ty^y3&6M&YPH+^Xvng7d;sv{Y^$9-_zzqe{66AsS?X zH!()rko_O}TbF%{%c`icdy|1#W5u(>Lw4wf2iZ>~I=o)@5VIUaCWhTPd8qd3Gu6SX z49wHC$ZFKs2==)WJ?=QBP+jU|u>$_AuzAWPQ)L}fJ8J4&0Lmlhqp%Jc(?!v_a^QG2 zPHBg%c+^c(;m-QEX2JMD(inQ*0-&qpu~ZmDQ9N?Ulw_u?)0tKd)K*Fi2=yOT1lMX_ z^~Y5Oalb{P>~Y301M!Bar&F#_?)2ra4~MYSfZyND9$CY;1y>k_J?PWh(}*lm`6i5* zq`u>7L?dct;yh_G%zt;D^8pG{wdd%(-5`ol=2N;t{u7G9jNY5p4^Plb&`!|!)mtbS zRv6-z!Zmm6$D=@?*fW-XRLHI;Q8 z?rgEnL`S3}5YEY9mToePY{y11WoEBn)~Af)d&$4NUj-4g{JSZ_F-1;GOjTi0B1a9- zBagX>ELs+B2NBkma@PhpqIK*GG3lG>O{gjyozd$GJX=Ykqm4cq$zj=*YgEWIdBtcp z90>#6*9gpYf6JdyV(K^gaJi$-b!5=~k}Fn>B!keJmZf)W$4%fsI5)yk9u^$CNv zwtHW;Kv%b?Kw&Wj7&n=u6}Adz4uIw7{a=3)@fhSaR%Vuh>VW#!UZ8I9r=aWHcbe7p z-kHHn!oRG>-TTm@Fe(=5#d30zdW!ifgcXOYtzziIgagRjgeSh(SmGItQJm=lW!ZCy zC_XKmZNvWGvm2&x*B;dx-cLVF3MzP%6`~f$WhZae-C*<(RBn0#ce5H;M)Y-v3O*c* zG{U3d6s8!QdK30)nvdd`A$P%ve|N#9MHo9|Hl-rIxy2~ft-s4K0pD(YdNY6p;r?qJ zG*FCJ?nsEMGy?M0i@|asja!pK4uTo^9-a9yUhj3#xN?QfRj_QzciaBU9z_`Oec#9A z=~HxQ|mAc9>FR9|`k$Efic@TyY*YEo@dwdM#3VO|X5hN&C> zQ^InQ&HoRAca)`~G2*l9yaFu0?^l1n5wOY;3Xoc+YRTjR5USNTKCF1yaQxbS8Lu`- zshveQ_WYp~iY9Fr`i-WSY8ZYEqM%y+Q&2lkDTH5EmtR;uI%e)Tj6m4`e)Dl|e^4YG zC&JXgl%=#Su1v4VpjF0Zar0muagsw($A2bZIlfxzC_=2nD@%j%2l!W`uEx-%bZSlU zW3i=AYo3$2%1>fpZQ|4HaoXK&4n0l?m7k-31)6wBz zc_g-~u)y|J7d36TV%)aenkkYteVmB?&4%5%uL&TVQ;r;tD*|cX90OqvRKLnf$Ig9| ztvyE;JyA7>@UzCCl|+ds7c^BXAfeZP^Kw?jl$~uy&;O!2RH`ux*Q3Loyz#LcsPF~vyGm6;fdki*PRoYdmFdI3Urc7a&EM^`W1vkx*` zqNq~9vIbpr`(?XdGLdt>!bh=TA~?lo2#2~a3#FSBevUVsRy~goPS^LA(pw%QOS0GF zU3Huq$+I_8SN`#5KtXbN$OIKR71)e3+%{RNnfZIA&LY&ZFj$OLwm>Oc4a>6{ZT`L39dOM)^;lVfmH>Ity}wUPD0z&2(_$QCPpxY$ivFXTCEH{*CPR&z7~VCl1&8L z?gkXFqHY%Jr00Vq9!?Tc%81Prry344jYfL}pIJ>=r_2`wM)ATQj9)(=*1xstzUneu z(+;1+SWels*vH}@^k?SoUcDlKM3-v2#;aH@EGEOVa58>`4p=r9$RYK=LMr{L2q>Fi z#wap)MgmN#dx2GpKrrcZ==+bY=gjmN99g_AQ@F1w?v^ioT%Cb+ZvAddRhkS-z&PG~ zsVVj&`*gHsM)hgPlqwf8QCeIn!=;M5YZBVQ!YKOB@RNx(|1ag+C*xF4!V-twYFh%R|$8+kmA5d)1!1u8Dx} zlxLgX!L25Rc$=Yxe&aVr()Xc1wcwN7Lyp|HEE}mXk&*9ep?EaJFn8x-g3PNg`(tW{ zK22n0Ya%ex2Mwo&Ca3&jTX%lo{GhbJ?h@-}M(i)H%}|9NSvjtj)8XwaTP_(oPD@qX zgxFVg5WLxRhq@kEu+X_=&b`76QQy#j)jj*BKQ5Gcv4I13C&vtX>PMZC;5Xg$cZ6SP zGz;)@WY3QIqnLGqKqD{6b%-Cn+|=Zr=fO}T@W`7icK(yD^Yyn>g@jn-(uG(OpJCxV zlL{j%S7&Q>W!)*olcr#IT4a|`*%x(0`YKqy`UaC~>h4wSoif~2r?+{EYs|2oD@5B9 z?-@V6#RvaR^JKeS-sXyuix>n%BcBJM-UBBP;T(2)g@r3bHBA}V=fhRNsYw|y0=4HJ z#lI&A5A@#FzMFs+!7shzLDw`O*sGp9w9bv6Hk>!l5Mob72P5?WpyygL@RTNK{MoSn zJWRieXam~2C29A56saLy&4Dupnx`{i!^HB~_eUUEn8;RUMHckgVg{bWM_f`F$vq0Q zDhrgIWO%YOp_+TwrUSxS4>yK`F1~|uVX`hy^cV+i$ePt~kT^|mokjQKIWr%yviG%r z$3E!dUl@3Hp|qWfVX19URDr3Ru8pLQO#aTCCm#TX9knp4LKz~Vicx^ehpd948cRxI zRb2L;!seEvw{x=vVK@l}*Ne0aD%-7b<6#3So+%`^3(JYzt~-&Z%(h{yA%H zH=g4qlo7Bll9iq7up2ec(+uzNiTnI+djP7ey&j48&me%NLgeBkJ``CRcO>%hbenj1 z_zZp}{V06j2|6*_1>YQjh^_*_Z(UE9o$t~?k2AMU?}T7J;U_oYQO=poYDx}%GCgpo zSY+_lM=Qt?B8L*Bo}SvbW4}>#@~k#cN>mvi@^AU2*7_e*R%z)$=4llvBRl{}Q;L!t zed8<+Si&Jy2=hG~0@9mSk&Ccf`eE{Afgag9SGvUVvYzCWM~#51DL3LFhJnq%H#O9=9NFT$8VmijX7BWt#Kh|( z@O$pT)=Mkc0di}uy@@k=r8WYOEdSHrhTDYeI#+K{daqITZNwzXni*BIF`1r<_Wzwf zIBo#ph|fUNF;Rp|yh@nOG`0r%3Q}t)%vQh?xq+;{q5W9(TSaFXx0y3qM=|`8{b->k zmCnsMuKNkBYlf{=sP@E{7W}_#Mk_UT%)|6|?-geVrj~BMuQGzq?^s%3>LRRALHqy6 zIkTpSLwNtOk&_d1gezSl_ZrN?<02L$%TU`=S8xrff2oj&zAv#kbC;${BlEkqES#6A zlC@qWGvwkPl1Pi`zJx4O5JYde!h3~f!l?=dXhy%^pQvfk+vVh4K#KKgv()HW2m)*Y z*vA5i6)clr{I(Fn)@ab2NWeXQl{vNN1CN5A!Qoas%liWLex8GaURyhrMlZ-l;I(D% z*L|d|_g9{0$kkH7HW94SMu!Qo3g#NBI2V&evmNKutL+^2PfBy8ULIh*k71S^Rqc?>~rY9x?Q}B%OGCiOfxOEw_Ro*B&ubS*h-vsf|M^ReR$R z7?+QFRdwO@51bhntteh7YYaQgDvEg37UB9*I_9OX9i7BdfD*0jeVPuP=5)6Xx;y#p z`D;q-0cK^{31gA5Kpj0CLqnP!+ZQhcTAX54a*^tAK82b`+!OyiWZM6dHDU#Po`rhv z<7zn+5YAS*@Kf&Y_HV=?hNj8A(RiO{khnzHG|n=C6>xfsGfoOla)L1DFgYJn=Vlozr=(SvUBB-FNe{KD5K!hS-Bo8_Bv2ZM+XUH=L`14DCo+i`%`K{HA)U76F*<${Uk$j%)GMI; z25yTUgn6*`?Sq)s{v9UAKl;m2ynXvTj*wF~l#|Jyaam8$oS))E&%7DB<~8c#DVp~u zAJtsYR)YhJ_9m$-f0(Dt1`TBenD@V{LEJZfINda#E-pXIYi-euV~Jz|{(Qi^OVXFjC0R zOXT_nk)-r^Mkj~tEht9LSrMk3kXI}$*(p~Q)Rn;*Rm%NbO1yZm)uH(@%57H$A;4MW zFBFs^sKlsgv|}69dU&N%rPcjLvc{@H_^x$JRY6Vrg)SkFxv^riVXRfhHqUxgA6hqT zx-hsxOr45C4rlk@0wTzB(wqs9#;@Tvqr_b5W0}+FqgwO2ROM0mhwAs;q`;K?y#1E| z#sgWsxv-1|Jvcj5`jSz5wKK{5)zT$d0JKV&PY&a+FclomS^!^UT(4 z03iJ+-6bo~*th!QUG8w)e5#lGk6#Oi%C250viW&! zodb|YC$F0o+6s>tXQ`Sr*20Tk)GuWngB7oqRKR=5)~lYj6VLe(1S(dN2#K{k*oL<$4sj}V-CcIp z=$HhLB_)O$tKB|-M@(fnU{XFm*ngbN_}v0>*JW>?OwyHyVooh?Y&Jm0vaMKrBtJ4e zu@OzNvmrKNq^$sjDwpy$_$@W6kxD_Wa%C$^A#>F1F9&J`{^!bM&SYMV&4$ssGJHa7 zb_Veh&;09&Q&dfJ^ke$xH;WF4Uy^jb3;DdNHfQ1@Y;(tHARI@-%|#z|w19Ed<~3)@ ztm~4vo5Ktl{N7kQ-sk%Osra83g&Mo+Rs9vPp)Yl$zw_> zT5LP2jQKqHt1o#xY5b`N9AHc5o-^NR=y0rdl$XmJi`A?NdIL`i4?4Y1^`;Nb6L#Q@ zN%F2w`h%o}XOuqfYmXX*UnL)XOe@kUq9w3MPdoP0(UYA5?^6F+LO$0#smPl20)HR* zq}S@#EU$OAHJxEoKqU7*J5FdRxaWt{P6^o@rSnv!n9sIQGhNQ(WRd6{o9iAKmUbE% zD0FFuk`uc4f{}P?(ijY}W4s)P>A(|_C9&f~sCIg@>DXrHvSfptxfS(ovY~Aq64vE$ zb@oC876nyo=N{dF-2bcQ=fTy#?+T><2;)s+BA+DL31B`ybWk%nThiC~d@|IP$qRHB zetRoHwFF|aLGU@>8gtp-Ox4!PH7%K9o9l8pej|LoAbE6L`S#4|MA$Vj;~LFWw{qAG zowlMVn?MH78bf+QaX#j^+#KC}6?nxj;1BMmN~5J1O2g}z?lAF+(nZdFJ3o2`fQN&E zh3{uR;-3wA?|LU^KsC7sxv!;Qz4u1&Iyf!pnDpaA!29mAYh8~|L{@t?4VsT-t1zn~ z!eQ2nTM%gG7V_vFv6&Hwk14&J77jt`_G0^H<%CbcS!W;+1XSve=2MM?1w_U}x_xQH zqEArdkvEHTGf|s+I;o#NHLm|BA*!BDh~UC_ycE)kd(JRvF|dX~zy|q*YF7K2RM2dj z#FIUlINmaN_vH;$FV6qsRht_Nvluq`EnnQ4gg%X#qPO~sU$NKYzqY{VUY2w53l2rZliUG7!eEw>8)sMjmN@MB#K&gc z>gRVrPoMBjJQxd7sJ@`z3BRR+EI6=3zd&pT%OR;ewpBXSwrKeV`IV9Ocx`s0UEI(X% zSfTMNJsp5sSnNL4IFCH#@~F;``KqU(OPBJAu(DVl3BIpit!(ndllXu(j53Ut(xrC8 z$&}S;y36Fw8xC(YYE;Q7{U{29EDx1VTZ`W)!g&4#_FiMG6(JB(!?Q1=Z_(_3Ddz|d zk+odH*En+w)+})`XAaj-UU;zQeo{VZ6N<%l;3L%ZS@zN-!=#s?^S=OqkmI-fW(XP% z#ikqIdOUk_NRjUBD|{QwRokS`k5<$#&iPZ!E?y4$MR-CR0M#yQ+-fZ-nt!6T*w->^=tH`W#l*1t1a_r_y(=fbeapb^$LM*UgvJ0Urj@Q zENrH4bXsbLsd?w=YRM3;Nf|u*8HSGop0`IMMB<-wV}@+`u1Mb}aTWNI+`G8}8J?@k zQo7WM%FxYuMNM3!ki#)2*5O#pOTt>T0(E#2gc_ikD`!b9H(ySdUt)qDg^PszQbo~G z>9G7}i&_E@1dxIU)6y$h7bQx}R=UJw2q8e!*pL39fJDS3F_r;YXgwUz4EPlse94M+ zw7ZevC8eUnF-5*!qIs zdC4|8X}9+N&ZtGl7a96_g2OV=3CxlqB<1j|wak&fLd2#Jm*myHsp8YY!hg|3Y*iw; zO9c%CO}2u^jegu@D5EXy(x+)vAd*w6wwlr_pQLgAI>Cz(Irq69KRZW*ghbZ0kvysw zT#CeB%)p1eW34@}G49QnO5?4-{q>gHQ0mK%jCPunF8fIC>qY(ZP}@cnC}w8vs)%6h z^Ngn2dO9wzV1)E(2&9?Y7AKhiKX%EYdToCV|xE$0X8bW-Oq ziV4V+8Xqn)1$p#BrYI-ny#D)(&WCUHX1Dpjr*5IMppwAmmTNW*WL1})iTb>owYr$v z%XqOeDCqoS>^CDYWi#Sq>2h6=g8i0**aN@bnk6-lHmr&$oNUnR)cwC)iS&l*GUg+ zJd!?Bqq)Xw$=GfrS}}cCvv5ea%7ri73Oj6s?soA^?(t1<({^<~a6#8u@gl?DEShmM zFl5$eOB*hudpYs>eLnXN9h?iM68JmO^Wq>ceeyNfqpi8+=VJ@ zWgdq2OuF)g+}g!l> zM+$zF_3QARon&DsO0~XNlWqG@-clBiLa11R&x;U0r?hp;JgI7`HV*^ln|C1t{C#7zH!CBj=RZJQL&>!T-^` zR=iGB*`w|LNJ4RgcM+8%m8x@eX=MGrBwfrVeL2{`rps_4Zmr|!@GuvG*WVHg)H}}l zbrdE1+`Y9&3fcmp2!Z#6DK|DTR0onnu=-o+`lj_fEyEfB`F@?y)|5@XAKNEc zi$WsI+I@uLq(tHX?avG$ZZwYWbm18u$iJyWl3b~IXwK#xW$*PBmjcjl42S<+KJBwV zI_1{LnHh9+lBYkJsS&g9AON_dCJvVBn^aj%Q7`wHPTdE{;@~S7MWV=`kB6!vNik~= zFf|^JpT`xLC3RrCIozrD6#84-J*S;zSaI{YY0##&?}-3`Nl%v&p=wst78tV)EKGuZ z-$uBjw49f=8S%=!k-LNWl-}>Qz~CG3^BWimd`|jdRwMj|4Y2CM4pFxstIFE`@0U~; zrEli9Gvf<(yWiRqv4WeoN}!maKJbSyNVxwdrQh6M;ah$(Y*Woy)!#YP)3n_x8;gkO zC-`9r2TOW@m>2pc{?cF`f2`_B#^iAWtHaYClDFJ=8+S;ynj^j!)}7O*oJPefkNkOq za4$SNrBI3y?W}p?Xs(cIV^zuMpZxrG$DyT-KQ*qiYJZeuR(m44_=QwjZM^M6M%P5XGbp8cmGqu>v;(9!MLCi&Jzlx>|5Eq-sf&lf+ARP%!O zkSH^y!d1S6F46zJ?(x}eW~x_Avk4tnJ}%mhwKR7dm#?oQ{n}|37EO@aqI=!2fk6D~ ztT;jPiOnvqp(Vk%xXy;|YpMK{&P=P%HLu_ESlWK ziy?Op(M9hFpVs3K2UOHbr+b?u9oQ`E`M-FDKeuB3C~NeWZ#UOhJQ`G-m{i>s$1OID zVDNQ3x@oUVU#e^=2C<>v2!#iL-UoxOfLrg7#bMy;prh(q;rAKvU~3O3W;fKIY++!} z_!|nE(%h>lSCMTL@&w{`k!uTyI%8>tr5L?(Q8J6G>A}uT-tHBZIIQVnyd=FQGT?|I zI)vi~9Sugcjv9lhyKX%Dx5};k0bjz~S zHFiyp&seI_JKft2pJILGiFnrnZwnuif=a=3M&R?(s^VSw;s2jLaj`r zxGe;V?0FbV9KWF*-Ggiyp76eOY$Nt_O!LWJ#^&?jI-Qrt?p6u;1+1Mt62u znldgReL?O`yneHkBl~sQ$HF(#+3nje+Sr}l>fY4|?^Z-|X91F)kBcBW^4>fC-nZI) zRY+UXf7Sc&u=VT(-qbS!OWrKsQZYomFNIqm{z&6ctB6H%Of)maX=z0@ zeKg8J_FUD3yW3LJ=I}-K`Jq&BFVLLiYp4B+#fpXuH22K=V{O16R?_s*gvxqnLMEpX z*(eUuT!g@jReVgZNw))5>YBsJgEZ%nyZ1TXeE9`^Jd{|v#!Sm;t>73B1c(1a(_8p8 z{l4Gh2HnkQ5dj$u(xtQ@AU(RfyHUD_D9z{|qZtiK4I~DLjPCAk)Zbq3-}m!)+<(Dy zyYF+Z>pIst2i>Z1a>FpJ@%9r?Kuk%$YmhlO&O>h%fRaK6X=y8|!Ud>x6%rHxRtSl~ zRKXXbcDNyfb9Z70^k_5N7%1}KWXra0VLhKrB3J{}GUlfAFkESdUREk#7drUuzI<6~ z2?b8kxcx9vsZ5L^O-Q$4G=q4Bc&QFYt)@*j7+x(dx?T}dGGhz|0$SVK6dKwCbvB+9 zZ_z)`rACO6olF7}0ccKgS-5kx#R^Z;g#e-_CjIi3&VF3Gmt3T$5gRgr@g9355TfK> zY~Jri=#~W(rrk|pCE!6)C$5l>r|@-J5vc>@doEBPwZ1<6cK_A(jQY+k$qD1ZRknzm z>8FQ)@NX5y_UUk&0I71TAs^hF)}yK-wOaTQ z_U=_gT&y*L;dw}>a{y!Cn|vs_px5qCAUXfVr4u;wONp*BL}d$hg?Y;dTILQiYAw5}nIGOIAn zGQ84TSTJ)`EJcXYDC%QWw=D0l4hdY|24LgB@BIf=++zFc@=_Mm?qj{vqg5Km zuN5EEmqsFIbdsDnn5z_TGEjId`#nDOy*LdE)N$qmCR%Hpb9usU#GIo-bu|3mrR5ux z;7i$UdCSMbpsF-l7b4%Mc8eU^Gl7lAPma?QV*K;hpMF{4PnEUxs7CGN>gHlQO)_r< z!GAUynSyf|4HbjAq&QT4{j{(s2>HwcgNTTc=k!tV3TFGYF*WDQh31Pl zx!AnJuTBxaXyo{!m&Nr^e1MT*LuByad?3~V08)Gd4I-U)YW;X?oCEes+FFI}I=ONo zMPZ*=Eryi2RrW@*0MnGzK@K^WfikjLLXs2ikPbB#(@Ae^{ zQ>l6+6iv-WmDOwIE1x)NSNHoC7rre2>*V%UWep6-U%tO%;Qv!S(P$4pP_*z~DdLyz ze;_6P{0Od39Ct(&WfeND*1Lanq618j?nwMF$>wv5(en^Gb4(o2;L+9=Rg+GdW?DuQU+VnLUK9YXmx_zdJHRE)Vhhp3>KnY z`SnzvVUJifWqIoRN|JBtRawv`F*#=k zTU3>9@|$dC7t(Ld=JED&O*%GXyMJ<*f45jVwEtOem5^aErzX1SZMyaP-WG{M*ArfF zR34(6Y5h+E_S?Tinog`3D*|I3qZe;_4S{fbt7s?z?q_5G<~S5Q0oU>TEugsb`$*JZ z$$c21Y~b^Wcu@Jw$=9nP&_MAVUj;Twxd$}bw8-S;4fcK`ltyn?5QO|_*?HqFRaIz(qf#q~ z1(_mf!p|e|ekI|r>K?t?Bu1@m3z;X8AMs3j>IBRUTgKtEGY}hD#n2|x!czopz}6o< z^1dii8Ub+Hcj3X!j)?ZpIrZvJvqyeZeq^PDhK@q}zbv>E58vCB6bXa z7=7}@a__vQA<|UsXnpGNH^AlNd-7@yh3Zf0rK1WM<&;v1Mc5A;VIIif`*qfTk5g{9 z>*qs|m$|yqwbgqVLwL=!4bFoLp8_Tg)0??nFKa@o62!~#71e=5R!N34<;HdDRr!8$ zM230wMdMc4EK`t7D=mZqT~P(jo9t{tDkjOAix-Y@I#ubP(yM(dqcXKQiC>ik=uz+4 zyx3x7ouHFDAvjo_#TZcQ*5$)$8udt8kee7yZeJO|Um(<#5%;-S;s{dF>}ry`IP zVZ3kvJ%KDki{^*m9-p<5{bDI!Rmzu_a){h_`}V-N$BOsq+L|MkTW)r14F_%9lGak} zQp9q_N=1Hkk4IdxI#=U1lf-A;XqNaX1H{8MNdOd0HrrLAfKsTq{H~(PZmVFic_&Dl z(lYq4*-wc|4w*T-g$)`K*I*wQRckT82=5qgzngS)|6?v&q#}*DNUtFVIAyA60rf{V z)v7_j9tS^}>0j1tS77w=dn3xZaa zTEYQm%}$&(&}(e*Fd1zUA5f{5qfbTQ&tM9kfoe*Mkv%_FJz?@UOp-Z0jr#;WxTZ;&^;nQe+_o`jG4XM~^B2R^c0FJZKo809 zKe) zYbV}?1?KEO2SrW2MoPn3I%NENMa|~HrE!mM3Un?OTG$^$HMv9#n&g&=+GbvKKAgJn z7k)bHlIb_w{@;aqi3!Jy>ON_b4iImc$87=sp%>)PPmFUGCekJ+s{XU}br#H`-Rz8% zvGBjdJ=l@ieB8sn>}h1?9}Rk@D|iB>p?N!lc@=NOa|``f9lZ5kf3I3aQe^>Y==Q$) zcahPNZIMILeIpHbntvF)1qwHh?34WVxz4b@d)B;qBA{=TdmO1Bd}%*sU^naCTb#Br z+Nbc@&S?ZY=f_3i#!FFQR2`WG>#kB{62Ihm7(4T62{D95HJJ~`8DeF_HI5XPWDImn zyzG&y_IBC#$YVnUSSFIs#H8f#Td=NH6*q$EH{x(#>iIBw>Uzy)Zg3n>dq0U3z7HLi z`o#Pix}Sq{+2gb!WXBLC60IZX1qL|1hPwmUEr05aR!Wv8w510%%*XG_8Z3NPt0Ab4 z^ftUU8m@+)s_aPR5(5pBd5$?)+s$bLyN={K&CZ?-od75ey_65?*}LsK!a3QUq+Fg9 z{%|O9M_ok%Q{Ry9#CoJx{YhDQD9%5Pk-1CF54{f0IU?d*b?V88bfMvicGF!Zi)o?o{;D((Y8x=niQ5Nq~_+Q3~@!GJyI^)hY{xnJZW{ z<-r(D)pT?>({4Kvf3*Hg%b{rIfWpF~ZI5n>OAbwhzJ#1!hN)I=aEd_!W#jb&1z zGEMubQU!-Mf!!h~WCh$&yMov&Eh+eyQM9quX074?o_-Hc(jC+IXGm2r{k>=lbx%HJ z`p~kzJab<@ot^5rVzBwQ3(Wzj&>R4%c_MkRss7R4VOTep^5b`@lCTE6-FUeUu`x=~cr0o8vRr-)SD!rM6^f^^K|!fH=gU{2bQ1b1X7_HI)1J!Ham$ueRXQ`& zJ2G0MqF;#^*`pQRc`I1^5^vLNU-6aqANh_SxsI=il6n0Sh~(dYv-CFjPBKU0p|s^V z)Zth2XkeRp2I~`tPcb)+!_WRju%^V^j?n!_pfnrX5s{!8UzV1KxCQ<*TagP# z2`{)t;xuWgQw%%J2*xPKKCzFY>XgG)P{*n@)GO#gy;1UX^h_^rwR*d&Qo*F^;MQv- z=Jhae{q7&uW%*8y&_Ur$E{-fv_uY3rAvPB_EO^#8p1JDu4{vjVtEocn+mC*{T?v}J zF)GornXB4c|3`A-Ci&!CLa|Vwyd>CkV3pkE=iOVCxe)zp*18uzEu1#8`i=@oT7 zr?$-o;9Sly@nf}|Wqi~x8mZ`2Tx8YL3QcG>P9i#co%w9fXY(SbKfz^dz-4VfJ-OC5 zj(Xv_+4Az~z!7)QPkI*%&$QhrYaqwi;&F55?Y)p$SMbjfk&Mo^_O)%_5wu0a)e-o} zRU;9%KuA=r(O%1^iAPlYM5nySLHBl5olv6^7%e}=BMtsG9GmWG8H-WA@38E26kN#N zpPCJwU*fR|$i0&32`DE|;6@^a3A>|oSE_({@cCEVS&6hcWrkT^n)Q{wM%)3fjL9p^ zAj8z59h3~y#LIg;cs3Wmqgpki?vHp@~YVK@IYb1MaENlCq+CYQVaOt@MY@fauIR)+t()!=aNYJnGtFo_02G6c7diO#U3dTQ*B{A32HT%KuliP~mh5VX=aUCMuOt7}2nNqk?W$G6rir zw`z;gP6}Al{C79l_Wh$|{{!X!UMbC`B`a?0DyyaefXWW2t(Vw%lRV>Y)>?X&0CbY2 zrg6zx=IGry2M~J28X?aoIQ^<%T@Y4P*z)&?e^z*z^X-gJq@JqK+ZvL}S5u@%v?o}y zl(I;e{BF+35D1Q_%oW*=AI_7z~M=+q{a2ykz;@)*nIcFR&8rH zoX7ztVKIekXFBU|v1MLY)GLeP6ZJdK>C>?s`-qo|6Cnf(;Y?_%?4FQ-wE%cQysZVS zfSq}g_*h^agVOb2%7*_YA0yiD1g!1l!b9VP=65{+EK=uTZ^VSymTXYf*km|g#)o%v zB#8Ys6jY+n#?h^?j1mYp5Ny+1u7F#rvQlJs#0h_({sPkh^LxSR5A8H@*Q4uk>s!acV%M_T|-3%n;X1EdpcXlBI0TCY6g?3Rr zhFCkgXVqSpRbgYrUU|W%5T<`=OlOnqOac%>pg|TnD@UWHir|BTt$N&sq+qFX4e9Gx z4v?mJt`G@qdXQhy4BrZeUGp`=1(-u{JkCK~nS5Jcy`jAfCjs#HS?I@kz+KU{J}{Gj zCqluk)}ZFt9VXeh z3H!_Z_xyiDii!kp)`a3n#yzZRtLE*=3BSvbf(yo}U(^P#ovV+zeu*|ztA4t1-DTHJ z<%RtXh`%dc8brsRE~WRKDQB|?am0w`4C}YFJYMjA-`x6}{u9TWik~urlev=7^L3qo zctt(cT6ph8w!g}H5!=0_mDa0_p%0s1*jzV;j^5Pg+qxofjeii@UD_p!eY)n~8JAu^ zoKu2G{flkfVQL7tX0}Vt|Md`-b|QA55Ak_khV%6YMTKHT*8uF>>wh*z%s>8mMrMt*b!$A516C%O2GVjv2V3g-D6~90$KoYCFOV3v8W*X zOA4fg*oJX`LBWCvlToT|{VVY;!(H)-ZW)A^K{dVe0mu+@7w({J78|j4)*}bDB(-;!2g+H;_(SZSr|4>%G>(Y=W~N+$nboo5}i^6@0(hmOXfE zPj97y2)v7k4A7VC|O!W#5?F1$R5M1KO9hV}2a2+UB(` z9tC)HY+PM&^P&v|8a2#Luk>rh4iz1F9C6}_QvIz?O$9+asn2$DhkbyUnmONW&sv?{ zc7EpfshnxPDHK!T{Tx(FuYoLONGgBS3#Ox3*f~F3H}zU>=-Ic}H?$@gFZixXO5TaX#)Pr2P9^UVD32^*lc$r0;6lbYSG9 zp5;w?O}D2?5>5zpUD3<^k-EVaxtsts45cQ70U^k47UBlFG4bMTzC<< zK|xz8B95t~TNIow>RofrV@a|Po7(v;ur)A-DJmu~1HBZ0iie~c(y1bZ z5mC_PEX0ZM%S{`1441#U^Y-l(PPbZ|-Mm;$?kVqLgb2c&6w9@MCE-6YwMrG2NGVC7 z^^vX$HI4~s&}$rwLaL?0%1qKttx3mB_!H#%BdG&(gk8AT3vkT0_OCVZVEmHnVxj|zAP$9ll4>o1M;A>rUGK(ZK z#Q_;RE1XhJb+%4V)3uw_a=T0(9d>n>t&}`&;3gj3O=#%9>s)w~mPU?c)w(Nbmus^X zwXCc64ustY#Hlg|VVVHK1=T>xu@qqWnn4!*4KTI7+wI|&YUuqIe(3c&CaG12l;$P=n9xgbpuGB>WWr+JOwZhU1y3*BW`w$cxY(B9_Qzp zXuY!dH?GlyRPxHWkM^2RF?UimvMB;p|J3TabnuL3*l3zwOAcqZspe%w(E`zG@7kJ{ z;6L~AwJXLA`DEI_RAB6GQBlMTm%|R5f%4>pj^BMH%Rw~%AWv2jeg_`gB?dJPCY ze^G)b*p{1|E=x=#MR0*AV|I3Qo(k3MPP(dTCrUirIy5zOjP~<5aH>I5%V4juV_yw= z`1KLc8`W@@2ls&u@WooNro-#!KMT%(@gDk#Aq0>^hkDgmb<<-NlK2W{02{GZW4QCu@tU-elQ98*S zbyZ-pULL#!qw-bbPxX0 zu+=?Lq6<#Y2!jPTW%IVxziq*MuvbzM`HLH7pU9%ILAL2D9xWV!bC))ylkVZpv zET6E&0|~@4h7g3u$Pl^bXj$Oy3LJ;6#Q~7eLh3Q;8|xb9tzl4&^B~#w!L5tZ{6oL2Ntlg?e&h0eKJ{$NJq@zOkq!inck8#bw61W2NSfxFc7~ zPahJkY~y?1P?og`C}grE;x=2oq*DU9r4sEvUzY-vdTtq4PMat7(Ix|8t{5zYR%e_} z!5mfKOMu`YKn#(!A?cNAM}*c@>oIJKs+D-WOcLz2MxjnCydc!1E;&Py83( zDUWg-8+CC}yG_;$A-gAZo|Kl+nNh|@l4v00-Ryifkdm_k$L-Olf>emJh2kgCa> zj}#RHndEYVu_%^KulWRbMk@#q*YY(;Wtv5=uR<4~l5;LmefpmQ$m}%Zn&e**Xg?Ni zVPCm*dH1!%o_xqM>Er9)ijBWK7FArJrZ$yw%?sRG*@lRTAQM<-xEE;Wtxl9P#LiL$ zXtsy(>ZKwLW+~8Qxb-PHRs~ii77LNnvt{m>a$>OB4#+Rs$Bw2`vwHh(Xl#padm~Sj zXYi?3F9qeZ2KdDL0o8$)yYxPf_4E7mg(XI6$v)e$y8*G}eCf4~WEr#}M>%Z9&bx}T z`D92Bo;+w=FE&x<tI~dGR4GZo|UaMaiAPMWsFB?Bup!lB)(vw|iiR=F%wmP|B#*q*-lY<5}xmP0iCiM5f;5=CTh^*eiSwo%$La%liZ=udT|HNu{aq8b*l=4a8*=euK(TFKrv0cm zWoKUd{MwBx6@w}3p7a~yduicLr7koT_^CzEPUnFQrO7mx+gv0PFhhNmrrAP{!#u0~ z6k_H_H4b`5U-PMDp}~91bv$P&uMhH;YXc%WTKUr-@5=0l)2G<)i)W`bT~?5as-t~_ zz(q=u4rdL_nSOWUsYRiq@Z)x{9oqV7^1=>nNeH_qI+0qI=*RK;;0Sa~?Jarv_8uTs z73#?om7Vr_C%5o~i_?v-`KvsgmCTCi#Y)H>$M=8J_@Qye~i1aOE0Mh zw=>*%OPo(%rN3b?@X14~>yZ53VBHggt1#x)sro&s9OgO$KS;Gy2)lm{P4F6wJdYsS z?rC1@uoanfQl_ZoRO}cz8(5i^KcGJ&E3L{Hv{sK}M}bVLJ0|SbuEwV0LIow>0GR4( z`dZ(fg#jcRi9hg=$Z1?YSHe9^_%-Cnt)k)d184t{TTw_-{pG)+Y^uUD$W^IpP~NtM zU1EDe&;gvvIL)T;=c$Q`pNOIs_OV9s|`28>l##Fx$|f2kut30L46 zd~fDmlEg;PPHY<=LfN&Qn)vMRf7s)-X!5x{v5Zw(vFT~?3)lxdOg)A*wfCx&9IO>- zjaOwR#)i<$@+^@Vk2WS}L&lvG@oY&d?N+X8#|VX#uaCxMbva^Lp$=iC=P z`q2^ZM{^=j^|1{=Fs>I(EWVcYQ{6QGB5Dt6^yQl30)d)nZYZj8rox1HG}>5*@T!uV{7?60s?;vXv^ zI|<$Lwx^M!>+t)ey;7qf(vJWo5a&%?fp#h_D=fX+YsDgxJ@hty$M~Q8Pfe1J?|4Vw zv_WJ}57H;8$}&K{7i`kf)V(L-U^IJKhSd2+svp)X$sk6b+_|WR{>KebcZ?>Ou)$M| z%*>V3nDwHeURFIIWJg{PW(gJ+frj%IcJ3NEXRz~X%<^erm84HpdCmC{$4N`oD&B{= z(=GeEZwD;-V`_!Q0&~qD(+?<+l8ou;p&9)sdtf4xN*MU)VI%Y8Iothd*Ofjg05pj+$qnd|#D; zzmPu9;PBs%vkYVlA)BIX+d87^S$|-)Syx0%-aDia5-xAG7BRqY?YcXBai=$nph=oo381T# zw=ddId{H_I!4ord6mF&Ukca*RU@Kcg*gcV%HRYFf{jPo8feiph6>rM>X9qfaUeiaO zPtAI)Rk_nm3C45RVtUS5h-JQv5)(*TY!{8fHik&-^xzY^x?z1j#*-IQChO%fqvNi2 zriW`&CTn&b{dPgO!De^C=oMs6^f9B4tObK>?M6oIXLWln!$P-cP+_5hd=QseXCzHD zArh-1+JUDZq+Ds~Svs;x#ZG}gN7X>lywR^4Ibz=i;m(+J&t(vq_B7%i>%4{|NHFEyN-a%NEnQXd#9#A1J^ zeD?z{uk8v4;qN!kXr{MtnG zDno(8bNN?5vKMj2^#cH1B1s^Os5Lsw)A8-@EUGC#Oi9_}xgl{B$;72K`Ly;RntlWV z5ftq;0kb}9-aYv7f6LnBb+m`H;@Y4A4jdF5{=ELg%lh2xxA9)U({AId`BMkADnot> zcnUC1Qk@P~o}!xsdB2?!p_J>6>KWD*&jDo(jLGM!rE4CW11f9fHR zJ9-0-W!I}x;_t^B)OihnY3JSk`BLTtdv-1EYofx8P)M$$ zEwOz!FU0$iT(&44nmDH2pVrI53%PNeb;v!}Ss|*{jkhKVDXG*c!;3MFE3?cMCaZpa zpl~vXkDzJqEb|vndI}Y#)S`}r7w>csz+!PMTXA#sqrRePvQT0P#Y(xMX zs}NgP6+S0A0wmM&SIPm_@yn6Vaet9F4n6?u&^AKmQ{pA3ql~#8-Qza>RCSM!ca>01qadmZ z3~#yAD;1t;uB&(7j>Na~KP1!$-*T`EprRjd@7M@9mApu|>p7pr&($6MiK7jthpze7 z99r7Or)8R}yF>6}&;Z*D;ne0jL}c}Ol*zyL>KUbEiV^~+2@(_vVC)(Xyf00chuD^R z6m3UR?uOg!iX(-c7&_~rn3I?qIHqdGs?5|rD;4nFAibvM+F=L3w|b5PnR?jAlFNI_ zjid}O`EL*f5+`%8z>s9GBE4$fnMF3iB;b=@_TDf0AwQG0W9@n0LXVAsct5(^)K>-; z@cT@v+d`Zr3bgPBHy%+Z|0nJvZQS4AHda>Pb!9l7NHAnS%+5Ew(5)){8gC14sXVm> z(wABll@EUwc{)-=Vn?}}E%&Ax;aIZH6+0E^R1XdTKCapE-ge3Sq4{^XV|Ia^AKJ$h zdQJH0e40|`ZaX@^t8;CK*X?%udT1nv#q4{x#V5cXq)%eEq(Q))G1ALT^rAOQ&{%XN zss$1xr%_lN)s6C{2)w+Yj8dxcoD72TTQ@b*gqI(LpO+41^;xWoDwc5wsK*89#f@sc zL-y1+og9e$qAqW$8Dy1+u$ zBcE4uG==!-(iOa`69Fz?;l=oQNGGW|A!;(ar2TIt@&$5SNIWTu$I_x zm9>RIT-keHr&D(feY#rtm-^{ZDgPqI%=BVR&H6*S7Q?b=XFYIL7jIM6VSN`xmB@{b zO~gE~BQTadEy9fPuY)jJcH|kJ%V+jD=%LO9vT=`I zuFhNU6zkp`5V$~8d#z)lG~)vaxc#9KJYmCl*NdP)nyl6HN;XH?$*p?0Luf!V!)>I< z>N@^jgg)|NcS$C% zgvHGCs8y1x2GLt3w?6H-W}iU^=lj1w1t0B;Lr$uH?k&yR@)1S#50GaibQM)MkTovxeuzwcx_TA7Ke@8@9t_RiSaizD>Zd(GpT$C(E6_&nwA()LtE!4I>NO+8G zUI>0MP-Xo+Y7UHeCsWJ4z&4fQA!M5Cc?MW(;i0V&eNQ$WDMq+K2sdozrhB%8Tu*`M{*NC$RAifYx zLRY)U1&b*~a8}DtW``VeGY~N3Ajc}+`pG)JQ^*^zN)`K% z5;r7ybhj{$4CvmU)%;>HKtZ0-BGG{1f|oXG{Clp5%euo5Ev$bJ?6pv#*Ro~8=g>#V zY1rWjGo@I%lO0R-Db@?vpP1Ui)fsrNb$&s1b2sjai85}+AX8e@=wJo|t7>}fO?RC_ zKR2KLSNN(vD9gCfa44F@7n!dxK zY%dyj;+Ot~fXU_(GiH#xeaP< zXYd&+*9$zsMSXtzGwbLq)(5Orm97%*XhL@|BiQEd*)K5=*tI>DGqdvd`g^MX5L#01+H6GN-b@Rsjb;R+acak`7|eo1nY^D4>GV3TW^#6L2xQ0#rE{%_^JPcr@pa1?7qq`^ zPX7rY(y^>V&n)*u#%Y8#K-J?kdYtzbFJOAN)A6B=y)jP|6&|g)hk^EQnqG!kN)BMK z5iIDm<&n=|yIdzdWS#NxC#R5+v$A<6ZU(T8rBF;SxMeGr?G3%zw_qiAW(JHk=l-60 z5euloDnh)h-aeE|KEZCcch+gWDlN^N z@|pvFglDGhb}C1}Py0{rem}rtsmduHjaE#%yKfFwOf%8ly}19nd!i>&c5>J+KWNJv z8WhArBWMKlUV^jIMkG%NnXY=<#xB)6j$i7%tK{*KtJcpJMy7{}*_CMxp_om6WJ8}= z=~@rY#S3Dx(^y6AOIk`HKrjHNzxG+#s{Mi|Mus38J2HIdB}Vw9SLi`S>7KM**+!Vd zqL<|HtcH>=YlBEyhQ~U4t=YwtTg~m9NXFwKI*X~hdu>XjCHQ(fdYs42|7<(G%IXze z3|-)EpvrC>(yQNH8#rUo%Hf`chps{OV}|rQSUgl_#rFBfF5wfJIIlWiaRrLL2iQ7h z6{suc?!umV&VXJ;s1XPY#u6PYZV#(P9<+HftU1;!LcpU}I;~lFGlQd7sR3{aPbmd~ zY*OA`P)_&)nIctuadshNGPy`g%YP~)+w$fQ^{*>(zI8(H|Lm!6)?vS@lk*X#uFo&|MfH9~*b{p|I zC3f;M8{-xKC_=L@zCPTjwmxKBhjRdQ$~fhtyxT(@ds2to$d2~diA3r!UV)jUj4q1H z?IanV(cv@YT}jeNN@4P5nd9YhxO9SSgd%hT6Btbglbtj>ijOQtL_|c4$H`|dMuk~@ z#k_{1tR`9FJ_}~@thO`KJ)3s$HH0WYp4+`v&rk3tR_BHU+Rcd$B8>Eq6LEEC;3OYd zuFcVc`VSiP&O}pj3-k>&0d&JzXJn4fU2jBeA+t3uCC6diH@h_#J-d%PC}tEHOgZRF z$>~e6`mlJcR3^r;D>R=&+9Pa2>NtIW{%nRYHF;|EpvuV9WTiodF{?4V2D+M)t_Ihi);|+ z>}8R$7HiQfKs5r1()q0d6z#hs5j}{6b4Z>?6QiV<@@sG1DMcI8x<@aqv9v)C!v=1x z04{3Ik-K3}X#g@XZE6vt&)~#AP+3}Uk-)is^$v_lCqd64u+cJ06za_cWq z0i5$! z1l0w^lz3W#T#1$V^bUIXzc!HICJwm6(jfS(?2JBOVqu0hYb~&RJ=9rGK)bTPum3+i z0kM+l5x8?6+_{WC>YdBUoy%j!3@=*-heE&axX%hQB|CSjHwNJKye>u3COUUBsh;@SDHXY$gqM7r`>Qt-VRBA6=+g+=s7H>dRS1+RSMd_;Jw5PJR znYP8oY+qVu4&PJEWC7MLWAEI zZZhM6j9LY@j&%DKLM*IuYMD@Y2&Xw_wSp1D{n?mq2}(ufz0)AP0*nO>a!C}v@#H9h zCA4^c#n1J-?Aef?1Bg*yZ|x&>jnR zQUn+~Kl#6DvA#D4M%P!Q1*=6RET8unC=I9Ryws#$0L_(+f;i>jO)FMyW4+RS()cXt zR-_0=Rj@jUS?DSzT>_^F3O4&jET^p5u_)l_u2yBcW`(~AP<#H>YA0V zcB&MpHQbuk>{!W5NaU%>-CoSbi%f`d2VijevxCZo4Suox^>pRorhoysIo~h_R`2sP z+`jhBwOjh{b5lzZq%;Gl`$5ppCz4_g1LEFKH|Q6ZNS_?&=<;NI0B)7Q$DY6VH@xwH zu^IDqKmuV;Fl_*;RpUql^1Y2HYR#eI*X8<>|l`1Z<6-QAyR108kL%Lt#~l zAg^-kFPu|xk+NiHD%2m`2|4#BdWD3$(c8aSnZud&tAyVV&%~cfQ zQGs1J5!2Z|C-TH@yD+iovFVK3Uo?f!>D4GIs8q&M4Gs5fXda(@TyA@(R2XyukX?1g zAy{6GyA@a;3Hzv&sId2?=<%vmxdrthp45Tms>$%|m#VQePc#;~Ux1K{UR=)@`|@vI zfjPkf@-oKbWvTLeTq}ZQgYX$Fy@B&!m%Cj{1(mkRZZd72#PUU=?|9c4KRgsZ5UuE?cBl^S+}SjQ23euUIE^Qu_#5K8ilFG={e}ukuIQ3 z!x$V_#a};GSC#JKu}C$@gS%iqt2oPQkx%&GJZszM13cUw8rID-gVm!$d7O6ZYTAn5 zCpY{KpRB{0ezkj$gRmx^ip`lB1C&zC*82Y8T z_l{m2njPt=NUYs86xzS)@2;=3VuaOjYe?JElAV2a`?YYso{oCIdYy8B@vS~pYq#U=`?v`) z*vwZ@JW$=*dX48`-D-X_AKqS^wSC7d_m^@&F8YyCo-g5rs5h!^PjcrVPwj;6b>;2^ znXJ<}mu-fsoJK(`vq5I{yp#`?b5?*a>SFEg$CTRYUe?ZBz~DtfUU|-s;$`>co&ap> zTz6p|p1=`<9RL-nZ>4e`$3~a{p+WfS+Cl5>`aP%ikh=Z}yv z3@DFj8Mk>-RTo}fVccv7iF;vRRDso2r~!bhtHrx#UBc(^hj@P=>`cWBHjg6LdAm%L z;4&Bj$9tDsU8**xo0=fC@qYciE<8<}V-uoLhFvh4F2<&XOf{QmsxoYIWkMrdV$Az4 zs_%y-%isU(lI=WyaM<=`dSAp1<)z{pM2IiHGGWR@v{heirFeZ#6WtkA-i^Mrw(dakvM~dbKU_KNszK zYc(t$?nF=+*Xl&R@7nrSCiFpNrdBZOjhf^>1Ct5F$|_Q;4#A%@+_Q=GY`-j*R+m$6 zEmP7;HmsyV#AF3i2$TEUv%Pf&|7R}>8s7m)gVO4q~2VhH0MKrcU&RpM0IA{-Eb zgA;!K2XODn(PpASgT`$=ty9G&MK=tmCQW~^bVCpDTKjn`Ym8sd0 zn0iX+E)Ft9+ZIf^L-Ck9ZM|ySvbA#@acwBw?-zICrFHWEVC;Kf;QOZt4iDwDNJq{@ zFN@J(24tzM`s1uF}uyin8rhWR;BE1R&MH^&pXURb_ z9bc-JW(z-Cx_*P&f1;8o7#=@c@eMtZv}=A~(f;Xp$pIB$|4hzZSuqDax1*l_{k4r( zIpkTOxjtU4YfA}e)?13Pc>P+71FJ}P*w922Zu^uUpR8g!_YIwW5<6+n??{fb{*i7b zObb{RzhWS#G3*)gb>_UG`}As+E{Q4Qqp7fCBI~s5o>Z-y8_hkq$3GbOk!;y!TdM~P z-G0saBM+1%m80Ck9qFa~?l%scsjQv!94@U`xU~iBJ}`c+@uCMS5yg;_PO_DgF1@2E zmdV*}&g?Y?YI1cm@o9m4h>R?xFkqB?;0!lkdPG(YvA@;pwy!E>7mQZZ3jLswBj3UN z?DF!NbLM5KZjHC0uMIk_y!B#;0@(?O=rQ#Lz=|)0GALhW>u}Obn0g$PD`VsHH*;*8zi&G{)F=7?Ya62yr_iXLCJ-qp zX%HkGxOnmN8)d$v!C3^mQ|PVt7<;mQ@T33ghSGDUJU_`5j69cT8Z&w2oP)(ZyOVTS z-%f2_rs9q#GDGcBPG0|s7j;&yA}lp~w_+t1vnTGnaxi%{Yw_bs9A`az09$EShl9u4 zF=w-DP?Q*bWIpY=E_!OfLHw)9F|*j(83LG&@ciR+ow<)YZqFOD8_Z$Jxq z8XH)=5z?i?Ezd`%sWtDAv&r(%c%Sy`H+I~nS zZ8tYb_XklC(|9JB3CsOm2@W23!`_S*%NbXq1gY0D9g7PCw0?dO_;e6M7y5vm+}5>J zFQcAWvvDyZCDWEUT{XUWnE`;QyoQt;3oO|Gr@r zP`bOMyGvR+MvordjZ)Gm&Bo~N95EOjlG5EV>26ROMMa<8@BO>)=XsA~f9=10k89uS zJU>}l`V$4Dk;(qqK`SIEWTXe1ZYnj&3%fCsa#gsp8K;33jw|+Y2~oL{x!SYus4&Es zNbRzrhqsd{HRC&7qM_{rt-qSoUZjaGiZR50)^(ExJ3qj40%+WmS?fK@_7=S7Cia+K z8JH6;(3+a<4#xWcAoluW6+0R*Zk(SR38Wf%bn(`ODoeib*@2A4N zZ`zMzGw@3bJKZTxFDZuyeH*?ES6mqQwK}i#N8bvShS17Lj=KFklxwaMJcr?0J%#GY zTzhtruisATh8o)~`-8gFZR}6J>rlrrf={S}1IEEe;eTN4@*mIN(;h3;#wfxs;vI&n z$$|lY5U&fb*WU(Aedu!X&u$om%<{i`Y_4IhPZA!cSr8F6@%z*^Y;B%)FXGB+h0Y_u z;@eQ_V5+jzbMWTvW42YWNQ3q(Z$x>jnsc>c`&I%$p3tpGTHY|>9ETY~#iG@|B&Zir zfwI{YQe*|=!l@+w)m<0zXfNcnIFvk_&N8S zOtIoeX1}TH6m1goNMLFBYWQr1?(#&H7@bWhJ_21o+JHN%uck)Bs3zQyvY}C^5-l36 z_~IJvjot3~Ihs!^DLM_dEzsv?ZWt}sa;WKKB=MGVL7^ZuY)YgW( z;LJ`pj6%a15YlLrsJ=2fV53b7e8DB5T9t#Ud3RX6uk9+%X~paA-Dr|Z{3*Mmq^4e= z`m5Lh&#za^-Cyc&Hp)kD_+J)if@_QCkMCxS8nI*8&l6n=IhC_(IE>pU6IE2*$8)|s zUgv&!%zL|Y6g2rDo*FVr@y_$-h40pQI1BDoGgaN-NwXc2ZL+$}0w?SooHI!-d=6SkAg z47Np4gQF3bxgoEsKE)ft`QbAIL(g1tt*il>!MPt%)4BC1|76X%+YpVW6J^7lDNUwN z9jz_Xi*d>)6W_|>PMR346O-sq%`uSO8^_siyK*Peb<4>mwg|?6%46H;r`@sF%cJjl z#0aiEQ9`6`#Smk;zh;lzGm?{O8SIJ79R^3PD{MAayByza$H8B&`}?+kA#}tqR3Gf@ z$tR6b=+@peUY0(SR2+F}-?LhH;_#Vc_cC)HTSN8QrjF6Qf2GU8s_V|EPT_SV0bjEB zQb}C?Y1b#g7)laO)`#CcnYg)|2GyNUe68>=7TUZ&B6EpFosd2IuU< z$m(vR#K>mC{=5Kvt3NZ*#^LI>EHah57$ZiG;Lw^ft66laguS30kPIIdGM(KD_6k^)pc^OUHPI7zcwxvx}h0qSu3AsX?0Ac zUbo8S26W^9nR)joS=UK(9PY@rP_DSVY%iwJq&3w8HvwwqP&xrMr}l?Lrpr@_qDpY0 z9A(e)4H3ALLy$@}eyopuvK5jU8G zvV*j^s*41EpgtVQpm25K*;;n%_j-DI@nIP zSbX5K1FOK0qECPNngWiUxelh)SEzibUlNi7a_9xQ)c9zvH4aNJA5j@-e~w=1JiZsb z+7-C6`Fh)Z9zZTx7~N-g8F)db6LD-x5wI2*lX_b1>#=}SO&adZGwMp|W}TX7=LZdN zT-5Ip4GWdO;Z8Nv>%#M;DStbNdyLZ3)x913;q*By;aqGb3@?mf6~8%5>Eqw*-94hs zVdjBH)CVKXCvh`>--w3g&R|>5Joe5_v%MmQY}J2bD*9Z)N2VHi)eCx9em^7#*m0Ij zBo;TCJu#Z{9K1k6KUlv*GqYZfwN%Dg35{4M7J6e*uzdeXhN*M zMCea-C@aVaLiCXGu2&gm_0ufA1p10AuYE70_M`fG-^`2d;ZqEI9q49tb-ek5elIjG z7Pn)Vzko5zxK?VgIe}fL8Hrxg5I__qN(K6kvWhjaT}D+NeLCt7ti-%5YQ$;oo{r|1K6B>)EC;IMy>;P+50L9yy)TSiaX!UKN!ne{s z%~Gj8M$N2(QQD)43C?0C&_y3EocQpUd>9aTLp9vgK|819yq^+7xa*nTWb!3mr!zhL zCKEddV%DlPZt8}K+#Q+&GsfW?#mQAC1hIkEa*kG9=R3Q^pEK^5_fc0mF-DwAR^&^} zfH_qyEw>nu4b(yO(S4?(ajh4X%*L@`Tf>Lu(ld|Hue zyC~9CM)}*o=#Z7fn?IY|e+6F-N>6Jw36eBpFQl8RbCTGxyxCFbnRO z9YTiuAm&=a82w;tRtDm`u)N-;MinZDAH+2z%64FoAS)wlL2Z?7IOdQ6R=?m%9BjT1 za;D1hnUk~-@Y+!3tm@aNU$-y!O53MRABW@k@Y}%6i{w~~x$ofxnHdj2Q@Ua^6M`;%oAj}+!`5>MgcgSj{SF{-4;jjH>qqSqI=z5-k z4b?9{0KBFxkx0u*#p>TLP^5qMXiSgtu*eMgV;ua;={c$u4r#a^3M_{#Q+tzICXn!t zsyDZ0KVHLceuVv2#eJH4#+c^j6V9PUBEh;)n`6y&h@ULzYmr1YDl${6HTuxtV$W3o%>pZdoIt@5jw{2>tygwBi?OYs#6gm-qHsQn~DZ#wW6YFJqef_ z$$`jCaNH=h$KCymU5)PRXOC8{|FtEHACP-lhQYz#6Mg%y`yV0sju6X;gItO7fp4{b zJwOKIT|%6!(TT&xE7#Y7J@MVE>|3-#S+N7ljqgQ`EL8*Oc)tp7unqF{e@kDP0WUjF zcix($U2lmH`Oi*B8p#Tn7;2s0JGDAISGL_Yxm(?h~UJ0TSX}EjuK7K7FS+bGk&~$ z6aM6w_cNq8)W`Rj0;LAK7%l6}HCYc>g)3@Kf)X|YcTX9y|5l+_wt%Oyg)Jz=Uq@)m zf)uBsy=DMzEk?2awS$y??TMT&-?CMNdB_%(YM_|fYZ8WJwe93ky~bbp%vM>u|BZHE zhr)Yg?8kV+R&gKeJHLi>e}CLeDr)HIw1?(YJ2K_e|A^slBZJ($(?ELEG*2+R50Y_v z%KY8s;lQnQY*1ffAHkxT=&SwnYuI_Lv_A%gD%sh%$6g(|EiXd^L19fE&5=ZtB|#h| zLhBee!7Bw=A@VZf1?JRVj%MFd9HUQd;@96pd8^invw$WsqV-4Dx*GjJa+tHrxWd>A zFl=O_C7hdbiBqYk!*D}YNdp_^F`l*Nt?W?%Z`I`r%f*stJjLDIQEPiIiz`kClJ3c@ z#QkGQT?fPI=d~OCp{b^f-l&jxhVOwG{P`)r;QH0uCkg&~e0$nq@g^Q8%j%Q!j-|*< z_s>QSExMOv&2A2ml+k0Fu%FJuTyz2zPQg6gtMqE6>7O-+gOlEz(R)*}H(}}nhRPN0 zMmSz?KI;#P;0SHF%_Qtwf%<3ei(CgUHg{3%GHyxyKl{AViDzh7}-q0H2w0^&UWmIfZXVw!iEN1o#qZ=@?G}Y{X)2%0zQ7g5F5(Bj#<3E`+q^aYz^d!P zFcx6kBu7C|?ZE4Uutiop)2)h@yt3dcE*u4?_ z7*1SI6U_w#=9SDACd{yR7&uRxMw>DSuZHeEe+O#vpjtaE*g1fRqb+LdYxv2-|uOH`oZ zP;|#GCPvB!wSx6`Zz88vb|*Rr?Ob@!=?KBfW2M-Bv8FzNYOVCmDtfQi>5=Ack_E9i zc*)N>LGUY#plzi!I`c}jw>_PElxVGW>-$@<>PnZM;68Jji!T}DM!YWBZ0P79SI!Ow z3A^DPgr1ydDy&k|oXZH*QL)Od9xN4nDL7I(tME#Bk9Ik2mJF^Lce+ZaCpWSqsZlx? zU96zW>LWc9r?=cE;dGR~?z0%wRRbuyC}2l<3nQB`j%oMBZ?{MOe>ct8TjM`Julu%t zU%!I>ru%I|>0{3Yp54;y{=5t|hy_!8Gs}RbA8~oD&2LQ}uT5pO#lyW#H0C{?95GQW zb_LtFD;!C1mha902n}Irdf8#HR0E@D_B*n6;; zRDshMv*%KvhdpR?GH|r0H)vW`5@^}#gtVMo6d02+Ko)gph-HCtoGkhjKGPf`!_4(6 zlkz!WO;nO0WrI|GP0u=B+*F4wqA#y_$8pJL%Lh>wHY! zX^RY};2AbKkDF zFa<8Sx_OmkCwGuWE7}d*MGrf#c+;4mmGaY^!aKfaIP<*Y83 zMKnl;Dw}HDnXTqf55qRs<4J^7C^_7q1f*CSy=flDDxmDqgtxU|>X%{k%I&1!=3~#Y zq;GYuo*5}r%I>t29*Zt`CuZvM<6q9K-`I|!z^ui}jc1Qr8oeRr0#itK~R3kw@D~h}MGpe0)Dky<<&<^67hCCskmpa`A{PKHS2f?|9p<`Ncv{vIN zcwjOXcr@-fTxQs3wA}g7x^uShsoTHue2Ui{dv{Z|%pvr2h9kTZ-Z1;r+#{@S=cmJA(%RD+T7mkEKR?Wq6DJz*=p$$~c7t9^R4BMx z1Rq0zOSzlfM1ukOCiRj4F1YACga4!ZIOMqMJ1LLchR_7Il5w`j-dFx06m&W(QA1Tk z%vLjDLaMfKm)`98?VQuc_`TGO9@TSLs_UWnwD~vok-f2Hfq>anLIFe~4{156`EsMT zU4})nhUYVo#Ek35C9@>K!cZP1x6g%nYRRUB1+pXOt>Ec;eut&wTBzsxBTHCuZCBj zC!n6n`|Igv-w8lKe3ffU1(ci{KVDAis3mz(kPOh@ietsg@f;MsQK=yh(2>ww%SB2(bAI_UgH8gE~01&+8J{Ci^f^2m)6n*F8U>w0lhKbs}}ZRhgO zh+RyOb+VFJ`1oBpSGhTu)77Wqc|5)}X;lnU=6KaJ8GCn`z4JoBmq#Kez9tjq^odig zdy+WF)TW3emz?)dz}Hj~I=GECNt5X_yyzjRE2#|LmWu{{a9)R2O|uQC#oEr-s@Btv7>WS5cg|$dR8)_qmizB%zwC+v�q^(2%r@=w!wqv=bC`f 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 DzP5=4 diff --git a/img/extended_embed2.png b/img/extended_embed2.png index 493940fef62082e6ecfcb392df132f7fec09dd4c..c9fb641fb38d932e0aa87adcb171a251c0bb883c 100644 GIT binary patch literal 23428 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 literal 26443 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 Bd0hYi diff --git a/img/extended_embed3.png b/img/extended_embed3.png index 3b0d696504cea72c47d649960017557bac3a1eed..c7abca0b9d939175ad47a547f8f03f9a64436411 100644 GIT binary patch literal 24490 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

Y&LVgHKU*oXszoe5tUfP#ylca~;ZamL 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 literal 20913 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

bH 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 V25-@S;46Pf(&7-YVi5zs{|3I!ew6?K literal 12796 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 literal 8951 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 JYQ&6#{s%+Bg#Q2l diff --git a/img/webhook_files.png b/img/webhook_files.png index 6c7df23aaf31d4f68509cb1e27564ee49d8365a4..44bb1f59cf13a1e01fcbe9370c43b69e69a6634e 100644 GIT binary patch literal 235395 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

!d0bv&t_i4v2_CyKPU;yu-oOmin#yS&HLKTLz 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
IV(I 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

YS|!rKZrgtdyJlK&MZdP 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