From ad2faa083abcbd78b93dd6f48647c5b62d2dbc21 Mon Sep 17 00:00:00 2001 From: Henry Wilde Date: Thu, 24 Oct 2024 16:43:32 +0100 Subject: [PATCH 01/26] Move common test strategies out to top-level --- tests/__init__.py | 1 + tests/common.py | 34 +++++++++++++++++++++++ tests/stable_marriage/strategies.py | 37 ++++++++----------------- tests/stable_marriage/test_algorithm.py | 9 ++++-- tests/stable_marriage/test_game.py | 20 ++++++------- 5 files changed, 62 insertions(+), 39 deletions(-) create mode 100644 tests/__init__.py create mode 100644 tests/common.py diff --git a/tests/__init__.py b/tests/__init__.py new file mode 100644 index 0000000..64bfcf1 --- /dev/null +++ b/tests/__init__.py @@ -0,0 +1 @@ +"""Tests for the `matching` package.""" diff --git a/tests/common.py b/tests/common.py new file mode 100644 index 0000000..9d92f14 --- /dev/null +++ b/tests/common.py @@ -0,0 +1,34 @@ +"""Objects used among many tests.""" + +from unittest import mock + +import numpy as np +from hypothesis import strategies as st + + +def mocked_game(game, *args): + """Create an instance of a game that mocks its input validator.""" + + with mock.patch( + f"matching.games.{game.__name__}.check_input_validity" + ) as validator: + instance = game(*args) + + validator.assert_called_once_with() + + return instance + + +@st.composite +def st_single_ranks(draw, num_rank: int, len_rank: int): + """Create a single rank matrix.""" + + rank = draw( + st.lists( + st.permutations(range(len_rank)), + min_size=num_rank, + max_size=num_rank, + ) + ) + + return np.array(rank) diff --git a/tests/stable_marriage/strategies.py b/tests/stable_marriage/strategies.py index 97616e0..aad5078 100644 --- a/tests/stable_marriage/strategies.py +++ b/tests/stable_marriage/strategies.py @@ -1,36 +1,21 @@ """Composite strategies for SM unit tests.""" -from unittest import mock - -import numpy as np from hypothesis import strategies as st from hypothesis.extra import numpy as st_numpy -from matching.games import StableMarriage - - -def mocked_game(suitor_ranks, reviewer_ranks): - """Create an instance of SM that mocks the input validator.""" - - with mock.patch( - "matching.games.StableMarriage.check_input_validity" - ) as validator: - game = StableMarriage(suitor_ranks, reviewer_ranks) +from ..common import st_single_ranks - validator.assert_called_once_with() +# def mocked_game(suitor_ranks, reviewer_ranks): +# """Create an instance of SM that mocks the input validator.""" - return game +# with mock.patch( +# "matching.games.StableMarriage.check_input_validity" +# ) as validator: +# game = StableMarriage(suitor_ranks, reviewer_ranks) +# validator.assert_called_once_with() -@st.composite -def st_single_ranks(draw, size): - """Create a single rank matrix.""" - - rank = draw( - st.lists(st.permutations(range(size)), min_size=size, max_size=size) - ) - - return np.array(rank) +# return game @st.composite @@ -38,8 +23,8 @@ def st_ranks(draw, pmin=1, pmax=5): """Create a set of rankings for a test.""" size = draw(st.integers(pmin, pmax)) - suitor_ranks = draw(st_single_ranks(size)) - reviewer_ranks = draw(st_single_ranks(size)) + suitor_ranks = draw(st_single_ranks(size, size)) + reviewer_ranks = draw(st_single_ranks(size, size)) return suitor_ranks, reviewer_ranks diff --git a/tests/stable_marriage/test_algorithm.py b/tests/stable_marriage/test_algorithm.py index 8c4a478..916687d 100644 --- a/tests/stable_marriage/test_algorithm.py +++ b/tests/stable_marriage/test_algorithm.py @@ -3,7 +3,10 @@ import numpy as np from hypothesis import given -from .strategies import mocked_game, st_ranks +from matching.games import StableMarriage + +from ..common import mocked_game +from .strategies import st_ranks def _assert_matching_is_valid_shape(matching, suitor_ranks, reviewer_ranks): @@ -22,7 +25,7 @@ def test_stable_marriage_suitor_optimal(ranks): """Test that the SM algorithm is valid and suitor-optimal.""" suitor_ranks, reviewer_ranks = ranks - game = mocked_game(*ranks) + game = mocked_game(StableMarriage, *ranks) matching = game._stable_marriage() @@ -42,7 +45,7 @@ def test_stable_marriage_reviewer_pessimal(ranks): """Test that the SM algorithm is valid and reviewer-pessimal.""" suitor_ranks, reviewer_ranks = ranks - game = mocked_game(*ranks) + game = mocked_game(StableMarriage, *ranks) matching = game._stable_marriage() diff --git a/tests/stable_marriage/test_game.py b/tests/stable_marriage/test_game.py index 7881353..e733799 100644 --- a/tests/stable_marriage/test_game.py +++ b/tests/stable_marriage/test_game.py @@ -11,8 +11,8 @@ from matching.games import StableMarriage from matching.matchings import SingleMatching +from ..common import mocked_game from .strategies import ( - mocked_game, st_player_ranks, st_preference_matchings, st_preferences, @@ -26,7 +26,7 @@ def test_init(ranks): """Test for correct instantiation given some rankings.""" suitor_ranks, reviewer_ranks = ranks - game = mocked_game(suitor_ranks, reviewer_ranks) + game = mocked_game(StableMarriage, suitor_ranks, reviewer_ranks) assert (game.suitor_ranks == suitor_ranks).all() assert (game.reviewer_ranks == reviewer_ranks).all() @@ -118,7 +118,7 @@ def test_from_preferences(preferences): def test_check_number_of_players_no_warning(ranks): """Test the number of players can be checked without warning.""" - game = mocked_game(*ranks) + game = mocked_game(StableMarriage, *ranks) with warnings.catch_warnings(): warnings.simplefilter("error") @@ -132,7 +132,7 @@ def test_check_number_of_players_warning(ranks): suitor_ranks, reviewer_ranks = ranks suitor_ranks = np.vstack((suitor_ranks, suitor_ranks[-1][::-1])) - game = mocked_game(suitor_ranks, reviewer_ranks) + game = mocked_game(StableMarriage, suitor_ranks, reviewer_ranks) match = ( r"^Number of suitors \(\d{1,2}\) " @@ -147,7 +147,7 @@ def test_check_player_ranks_no_warning(player_ranks): """Test the rank checker runs without warning for a valid set.""" suitor_ranks, reviewer_ranks, player, ranks, side = player_ranks - game = mocked_game(suitor_ranks, reviewer_ranks) + game = mocked_game(StableMarriage, suitor_ranks, reviewer_ranks) with warnings.catch_warnings(): warnings.simplefilter("error") @@ -161,7 +161,7 @@ def test_check_player_ranks_warning(player_ranks): suitor_ranks, reviewer_ranks, player, ranks, side = player_ranks ranks[-1] = 1000 - game = mocked_game(suitor_ranks, reviewer_ranks) + game = mocked_game(StableMarriage, suitor_ranks, reviewer_ranks) match = f"{side.title()} {player} has not strictly ranked" with pytest.warns(UserWarning, match=match): @@ -179,7 +179,7 @@ def test_check_input_validity(ranks): """Test the logic of the input validator.""" suitor_ranks, reviewer_ranks = ranks - game = mocked_game(*ranks) + game = mocked_game(StableMarriage, *ranks) with ( mock.patch( @@ -214,7 +214,7 @@ def test_invert_player_sets(ranks): """Test that the player set attributes can be swapped.""" suitor_ranks, reviewer_ranks = ranks - game = mocked_game(*ranks) + game = mocked_game(StableMarriage, *ranks) game._invert_player_sets() @@ -232,7 +232,7 @@ def test_invert_player_sets(ranks): def test_solve_valid_optimal(ranks, optimal, solution): """Test the solver runs as it should with valid inputs.""" - game = mocked_game(*ranks) + game = mocked_game(StableMarriage, *ranks) with ( mock.patch( @@ -268,7 +268,7 @@ def test_solve_valid_optimal(ranks, optimal, solution): def test_solve_invalid_optimal_raises(ranks, optimal): """Test the solver raises an error with invalid optimal.""" - game = mocked_game(*ranks) + game = mocked_game(StableMarriage, *ranks) match = "^Invalid choice for `optimal`." with ( From 23859e77fc57160f255ce2761066f8a0c37f2317 Mon Sep 17 00:00:00 2001 From: Henry Wilde Date: Thu, 24 Oct 2024 16:48:10 +0100 Subject: [PATCH 02/26] Write tests for HR init --- tests/hospital_resident/strategies.py | 22 ++++++++++++++++++++++ tests/hospital_resident/test_game.py | 25 +++++++++++++++++++++++++ 2 files changed, 47 insertions(+) create mode 100644 tests/hospital_resident/strategies.py create mode 100644 tests/hospital_resident/test_game.py diff --git a/tests/hospital_resident/strategies.py b/tests/hospital_resident/strategies.py new file mode 100644 index 0000000..740cf7e --- /dev/null +++ b/tests/hospital_resident/strategies.py @@ -0,0 +1,22 @@ +"""Composite strategies for HR unit tests.""" + +import numpy as np +from hypothesis import strategies as st + +from ..common import st_single_ranks + + +@st.composite +def st_ranks_capacities(draw, hmin=1, hmax=3, rmin=1, rmax=5): + """Create a set of rankings and capacities for a test.""" + + hsize = draw(st.integers(hmin, hmax)) + rsize = draw(st.integers(rmin, rmax)) + + resident_ranks = draw(st_single_ranks(rsize, hsize)) + hospital_ranks = draw(st_single_ranks(hsize, rsize)) + capacities = draw( + st.lists(st.integers(1, 3), min_size=hsize, max_size=hsize) + ) + + return resident_ranks, hospital_ranks, np.array(capacities) diff --git a/tests/hospital_resident/test_game.py b/tests/hospital_resident/test_game.py new file mode 100644 index 0000000..e20663e --- /dev/null +++ b/tests/hospital_resident/test_game.py @@ -0,0 +1,25 @@ +"""Unit tests for the HospitalResident class.""" + +from hypothesis import given + +from matching.games import HospitalResident + +from ..common import mocked_game +from .strategies import st_ranks_capacities + + +@given(st_ranks_capacities()) +def test_init(ranks_capacities): + """Check instantiation given some rankings and capacities.""" + + resident_ranks, hospital_ranks, capacities = ranks_capacities + game = mocked_game(HospitalResident, *ranks_capacities) + + assert (game.resident_ranks == resident_ranks).all() + assert (game.hospital_ranks == hospital_ranks).all() + assert (game.capacities == capacities).all() + + assert game.num_residents == len(resident_ranks) + assert game.num_hospitals == len(hospital_ranks) + assert game.matching is None + assert game._preference_lookup is None From 7424a84f4028627568cc346be6ec0b7109b7ffcc Mon Sep 17 00:00:00 2001 From: Henry Wilde Date: Fri, 25 Oct 2024 12:09:19 +0100 Subject: [PATCH 03/26] Move existing code around to avoid mass failure --- src/matching/games/_old_hospital_resident.py | 286 +++++++++++ src/matching/games/hospital_resident.py | 506 ++++++++++--------- src/matching/games/student_allocation.py | 3 +- 3 files changed, 565 insertions(+), 230 deletions(-) create mode 100644 src/matching/games/_old_hospital_resident.py diff --git a/src/matching/games/_old_hospital_resident.py b/src/matching/games/_old_hospital_resident.py new file mode 100644 index 0000000..35af867 --- /dev/null +++ b/src/matching/games/_old_hospital_resident.py @@ -0,0 +1,286 @@ +"""An old module for the hospital-resident assignment problem.""" + +import copy +import warnings + +from matching import BaseGame, MultipleMatching +from matching import Player as Resident +from matching.algorithms import hospital_resident +from matching.exceptions import ( + MatchingError, + PlayerExcludedWarning, + PreferencesChangedWarning, +) +from matching.players import Hospital + + +class HospitalResident(BaseGame): + """Solver for the hospital-resident assignment problem (HR). + + In this case, a blocking pair is any resident-hospital pair that + satisfies **all** of the following: + + - They are present in each other's preference lists; + - either the resident is unmatched, or they prefer the hospital + to their current match; + - either the hospital is under-subscribed, or they prefer the + resident to at least one of their current matches. + + Parameters + ---------- + residents : list of Player + The residents in the matching game. Each resident must rank a + subset of those in ``hospitals``. + hospitals : list of Hospital + The hospitals in the matching game. Each hospital must rank all + of (and only) the residents which rank it. + clean : bool + Indicator for whether the players of the game should be cleaned. + Cleaning is reductive in nature, removing players from the game + and/or other player's preferences if they do not meet the + requirements of the game. + + Attributes + ---------- + matching : MultipleMatching or None + Once the game is solved, a matching is available as a + ``MultipleMatching`` object with the hospitals as keys and their + resident matches as values. Initialises as ``None``. + blocking_pairs : list of (Player, Hospital) or None + Initialises as ``None``. Otherwise, a list of the + resident-hospital blocking pairs. + """ + + def __init__(self, residents, hospitals, clean=False): + residents, hospitals = copy.deepcopy([residents, hospitals]) + self.residents = residents + self.hospitals = hospitals + self.clean = clean + + self._all_residents = residents + self._all_hospitals = hospitals + + super().__init__(clean) + self.check_inputs() + + @classmethod + def create_from_dictionaries( + cls, resident_prefs, hospital_prefs, capacities, clean=False + ): + """Create an instance from a set of dictionaries. + + A preference dictionary for residents and hospitals is required, + along with a dictionary detailing the hospital capacities. If + ``clean``, then remove players from the game and/or player + preferences if they do not satisfy the conditions of the game. + """ + + residents, hospitals = _make_players( + resident_prefs, hospital_prefs, capacities + ) + game = cls(residents, hospitals, clean) + + return game + + def solve(self, optimal="resident"): + """Solve the instance of HR. Return the matching. + + The party optimality can be controlled using the ``optimal`` + parameter. + """ + + self.matching = MultipleMatching( + hospital_resident(self.residents, self.hospitals, optimal) + ) + return self.matching + + def check_validity(self): + """Check whether the current matching is valid.""" + + unacceptable_issues = self._check_for_unacceptable_matches( + "residents" + ) + self._check_for_unacceptable_matches("hospitals") + + oversubscribed_issues = self._check_for_oversubscribed_players( + "hospitals" + ) + + if unacceptable_issues or oversubscribed_issues: + raise MatchingError( + unacceptable_matches=unacceptable_issues, + oversubscribed_hospitals=oversubscribed_issues, + ) + + return True + + def _check_for_unacceptable_matches(self, party): + """Check that no one in ``party`` has an unacceptable match.""" + + issues = [] + for player in vars(self)[party]: + issue = player.check_if_match_is_unacceptable(unmatched_okay=True) + if isinstance(issue, list): + issues.extend(issue) + elif isinstance(issue, str): + issues.append(issue) + + return issues + + def _check_for_oversubscribed_players(self, party): + """Check that no player in `party` is over-subscribed.""" + + issues = [] + for player in vars(self)[party]: + issue = player.check_if_oversubscribed() + if issue: + issues.append(issue) + + return issues + + def check_stability(self): + """Check for the existence of any blocking pairs.""" + + blocking_pairs = [] + for resident in self.residents: + for hospital in self.hospitals: + if ( + _check_mutual_preference(resident, hospital) + and _check_resident_unhappy(resident, hospital) + and _check_hospital_unhappy(resident, hospital) + ): + blocking_pairs.append((resident, hospital)) + + self.blocking_pairs = blocking_pairs + return not any(blocking_pairs) + + def check_inputs(self): + """Check if any rules of the game have been broken. + + Any violations will be flagged as warnings. If the ``clean`` + attribute is in use, then any violations will be removed. + """ + + self._check_inputs_player_prefs_unique("residents") + self._check_inputs_player_prefs_unique("hospitals") + + self._check_inputs_player_prefs_all_in_party("residents", "hospitals") + self._check_inputs_player_prefs_all_in_party("hospitals", "residents") + + self._check_inputs_player_prefs_all_reciprocated("hospitals") + self._check_inputs_player_reciprocated_all_prefs( + "hospitals", "residents" + ) + + self._check_inputs_player_prefs_nonempty("residents", "hospitals") + self._check_inputs_player_prefs_nonempty("hospitals", "residents") + + self._check_inputs_player_capacity("hospitals", "residents") + + def _check_inputs_player_prefs_all_reciprocated(self, party): + """Check everyone has only ranked players who ranked them.""" + + for player in vars(self)[party]: + for other in player.prefs: + if player not in other.prefs: + warnings.warn( + PreferencesChangedWarning( + f"{player} ranked {other} but they did not." + ) + ) + if self.clean: + player._forget(other) + + def _check_inputs_player_reciprocated_all_prefs(self, party, other_party): + """Check everyone has ranked all the players who ranked them.""" + + players = vars(self)[party] + others = vars(self)[other_party] + for player in players: + others_that_ranked = [ + other for other in others if player in other.prefs + ] + for other in others_that_ranked: + if other not in player.prefs: + warnings.warn( + PreferencesChangedWarning( + f"{other} ranked {player} but they did not." + ) + ) + if self.clean: + other._forget(player) + + def _check_inputs_player_capacity(self, party, other_party): + """Check everyone has a capacity of at least one.""" + + for player in vars(self)[party]: + if player.capacity < 1: + warnings.warn(PlayerExcludedWarning(player)) + + if self.clean: + self._remove_player(player, party, other_party) + + +def _check_mutual_preference(resident, hospital): + """Check whether two players have a preference of each other.""" + + return resident in hospital.prefs and hospital in resident.prefs + + +def _check_resident_unhappy(resident, hospital): + """Check whether a resident is unhappy given a hospital. + + An unhappy resident is either unmatched or they prefer the hospital + to their current match. + """ + + return resident.matching is None or resident.prefers( + hospital, resident.matching + ) + + +def _check_hospital_unhappy(resident, hospital): + """Check whether a hospital is unhappy given a resident. + + An unhappy hospital is either under-subscribed or they prefer the + resident to at least one of their current matches. + """ + + return len(hospital.matching) < hospital.capacity or any( + [hospital.prefers(resident, match) for match in hospital.matching] + ) + + +def _make_players(resident_prefs, hospital_prefs, capacities): + """Make a set of residents and hospitals from the dictionaries.""" + + resident_dict, hospital_dict = _make_instances( + resident_prefs, hospital_prefs, capacities + ) + + for resident_name, resident in resident_dict.items(): + prefs = [hospital_dict[name] for name in resident_prefs[resident_name]] + resident.set_prefs(prefs) + + for hospital_name, hospital in hospital_dict.items(): + prefs = [resident_dict[name] for name in hospital_prefs[hospital_name]] + hospital.set_prefs(prefs) + + residents = list(resident_dict.values()) + hospitals = list(hospital_dict.values()) + + return residents, hospitals + + +def _make_instances(resident_prefs, hospital_prefs, capacities): + """Create ``Player`` (resident) and ``Hospital`` instances.""" + + resident_dict, hospital_dict = {}, {} + for resident_name in resident_prefs: + resident = Resident(name=resident_name) + resident_dict[resident_name] = resident + for hospital_name in hospital_prefs: + capacity = capacities[hospital_name] + hospital = Hospital(name=hospital_name, capacity=capacity) + hospital_dict[hospital_name] = hospital + + return resident_dict, hospital_dict diff --git a/src/matching/games/hospital_resident.py b/src/matching/games/hospital_resident.py index 13593fd..1b0eb49 100644 --- a/src/matching/games/hospital_resident.py +++ b/src/matching/games/hospital_resident.py @@ -1,286 +1,334 @@ """The HR game class and supporting functions.""" -import copy -import warnings -from matching import BaseGame, MultipleMatching -from matching import Player as Resident -from matching.algorithms import hospital_resident -from matching.exceptions import ( - MatchingError, - PlayerExcludedWarning, - PreferencesChangedWarning, -) -from matching.players import Hospital - - -class HospitalResident(BaseGame): - """Solver for the hospital-resident assignment problem (HR). - - In this case, a blocking pair is any resident-hospital pair that - satisfies **all** of the following: - - - They are present in each other's preference lists; - - either the resident is unmatched, or they prefer the hospital - to their current match; - - either the hospital is under-subscribed, or they prefer the - resident to at least one of their current matches. +class HospitalResident: + """ + Solver for the hospital-resident assignment problem (HR). Parameters ---------- - residents : list of Player - The residents in the matching game. Each resident must rank a - subset of those in ``hospitals``. - hospitals : list of Hospital - The hospitals in the matching game. Each hospital must rank all - of (and only) the residents which rank it. - clean : bool - Indicator for whether the players of the game should be cleaned. - Cleaning is reductive in nature, removing players from the game - and/or other player's preferences if they do not meet the - requirements of the game. + resident_ranks : np.ndarray + The rank matrix of all hospitals by the residents. + hospital_ranks : np.ndarray + The rank matrix of all residents by the hospitals. + capacities : np.ndarray + Capacity matrix for the hospitals. Attributes ---------- + num_residents : int + Number of residents. + num_hospitals : int + Number of hospitals. matching : MultipleMatching or None - Once the game is solved, a matching is available as a - ``MultipleMatching`` object with the hospitals as keys and their - resident matches as values. Initialises as ``None``. - blocking_pairs : list of (Player, Hospital) or None - Initialises as ``None``. Otherwise, a list of the - resident-hospital blocking pairs. + Once the game is solved, a matching is available. This uses the + indices of the hospital and resident rank matrices as keys and + values, respectively, in a `MultipleMatching` object. + Initialises as `None`. """ - def __init__(self, residents, hospitals, clean=False): - residents, hospitals = copy.deepcopy([residents, hospitals]) - self.residents = residents - self.hospitals = hospitals - self.clean = clean - - self._all_residents = residents - self._all_hospitals = hospitals + def __init__(self, resident_ranks, hospital_ranks, capacities): + self.resident_ranks = resident_ranks.copy() + self.hospital_ranks = hospital_ranks.copy() + self.capacities = capacities.copy() - super().__init__(clean) - self.check_inputs() + self.num_residents = len(resident_ranks) + self.num_hospitals = len(hospital_ranks) + self.matching = None + self._preference_lookup = None - @classmethod - def create_from_dictionaries( - cls, resident_prefs, hospital_prefs, capacities, clean=False - ): - """Create an instance from a set of dictionaries. + self.check_input_validity() - A preference dictionary for residents and hospitals is required, - along with a dictionary detailing the hospital capacities. If - ``clean``, then remove players from the game and/or player - preferences if they do not satisfy the conditions of the game. + def check_input_validity(self): """ + Determine whether this game instance is valid or not. - residents, hospitals = _make_players( - resident_prefs, hospital_prefs, capacities - ) - game = cls(residents, hospitals, clean) - - return game - - def solve(self, optimal="resident"): - """Solve the instance of HR. Return the matching. - - The party optimality can be controlled using the ``optimal`` - parameter. + Invalid games can still be solved, but the matching will not be + truly stable in the absence of blocking pairs. """ - self.matching = MultipleMatching( - hospital_resident(self.residents, self.hospitals, optimal) - ) - return self.matching - - def check_validity(self): - """Check whether the current matching is valid.""" - - unacceptable_issues = self._check_for_unacceptable_matches( - "residents" - ) + self._check_for_unacceptable_matches("hospitals") - - oversubscribed_issues = self._check_for_oversubscribed_players( - "hospitals" - ) - if unacceptable_issues or oversubscribed_issues: - raise MatchingError( - unacceptable_matches=unacceptable_issues, - oversubscribed_hospitals=oversubscribed_issues, - ) +# import copy +# import warnings + +# from matching import BaseGame, MultipleMatching +# from matching import Player as Resident +# from matching.algorithms import hospital_resident +# from matching.exceptions import ( +# MatchingError, +# PlayerExcludedWarning, +# PreferencesChangedWarning, +# ) +# from matching.players import Hospital + + +# class OldHospitalResident(BaseGame): +# """Solver for the hospital-resident assignment problem (HR). + +# In this case, a blocking pair is any resident-hospital pair that +# satisfies **all** of the following: + +# - They are present in each other's preference lists; +# - either the resident is unmatched, or they prefer the hospital +# to their current match; +# - either the hospital is under-subscribed, or they prefer the +# resident to at least one of their current matches. + +# Parameters +# ---------- +# residents : list of Player +# The residents in the matching game. Each resident must rank a +# subset of those in ``hospitals``. +# hospitals : list of Hospital +# The hospitals in the matching game. Each hospital must rank all +# of (and only) the residents which rank it. +# clean : bool +# Indicator for whether the players of the game should be cleaned. +# Cleaning is reductive in nature, removing players from the game +# and/or other player's preferences if they do not meet the +# requirements of the game. + +# Attributes +# ---------- +# matching : MultipleMatching or None +# Once the game is solved, a matching is available as a +# ``MultipleMatching`` object with the hospitals as keys and their +# resident matches as values. Initialises as ``None``. +# blocking_pairs : list of (Player, Hospital) or None +# Initialises as ``None``. Otherwise, a list of the +# resident-hospital blocking pairs. +# """ + +# def __init__(self, residents, hospitals, clean=False): +# residents, hospitals = copy.deepcopy([residents, hospitals]) +# self.residents = residents +# self.hospitals = hospitals +# self.clean = clean + +# self._all_residents = residents +# self._all_hospitals = hospitals + +# super().__init__(clean) +# self.check_inputs() + +# @classmethod +# def create_from_dictionaries( +# cls, resident_prefs, hospital_prefs, capacities, clean=False +# ): +# """Create an instance from a set of dictionaries. + +# A preference dictionary for residents and hospitals is required, +# along with a dictionary detailing the hospital capacities. If +# ``clean``, then remove players from the game and/or player +# preferences if they do not satisfy the conditions of the game. +# """ + +# residents, hospitals = _make_players( +# resident_prefs, hospital_prefs, capacities +# ) +# game = cls(residents, hospitals, clean) + +# return game + +# def solve(self, optimal="resident"): +# """Solve the instance of HR. Return the matching. + +# The party optimality can be controlled using the ``optimal`` +# parameter. +# """ + +# self.matching = MultipleMatching( +# hospital_resident(self.residents, self.hospitals, optimal) +# ) +# return self.matching + +# def check_validity(self): +# """Check whether the current matching is valid.""" + +# unacceptable_issues = self._check_for_unacceptable_matches( +# "residents" +# ) + self._check_for_unacceptable_matches("hospitals") + +# oversubscribed_issues = self._check_for_oversubscribed_players( +# "hospitals" +# ) + +# if unacceptable_issues or oversubscribed_issues: +# raise MatchingError( +# unacceptable_matches=unacceptable_issues, +# oversubscribed_hospitals=oversubscribed_issues, +# ) + +# return True + +# def _check_for_unacceptable_matches(self, party): +# """Check that no one in ``party`` has an unacceptable match.""" + +# issues = [] +# for player in vars(self)[party]: +# issue = player.check_if_match_is_unacceptable(unmatched_okay=True) +# if isinstance(issue, list): +# issues.extend(issue) +# elif isinstance(issue, str): +# issues.append(issue) + +# return issues + +# def _check_for_oversubscribed_players(self, party): +# """Check that no player in `party` is over-subscribed.""" + +# issues = [] +# for player in vars(self)[party]: +# issue = player.check_if_oversubscribed() +# if issue: +# issues.append(issue) + +# return issues + +# def check_stability(self): +# """Check for the existence of any blocking pairs.""" + +# blocking_pairs = [] +# for resident in self.residents: +# for hospital in self.hospitals: +# if ( +# _check_mutual_preference(resident, hospital) +# and _check_resident_unhappy(resident, hospital) +# and _check_hospital_unhappy(resident, hospital) +# ): +# blocking_pairs.append((resident, hospital)) - return True +# self.blocking_pairs = blocking_pairs +# return not any(blocking_pairs) - def _check_for_unacceptable_matches(self, party): - """Check that no one in ``party`` has an unacceptable match.""" +# def check_inputs(self): +# """Check if any rules of the game have been broken. - issues = [] - for player in vars(self)[party]: - issue = player.check_if_match_is_unacceptable(unmatched_okay=True) - if isinstance(issue, list): - issues.extend(issue) - elif isinstance(issue, str): - issues.append(issue) +# Any violations will be flagged as warnings. If the ``clean`` +# attribute is in use, then any violations will be removed. +# """ - return issues +# self._check_inputs_player_prefs_unique("residents") +# self._check_inputs_player_prefs_unique("hospitals") - def _check_for_oversubscribed_players(self, party): - """Check that no player in `party` is over-subscribed.""" +# self._check_inputs_player_prefs_all_in_party("residents", "hospitals") +# self._check_inputs_player_prefs_all_in_party("hospitals", "residents") - issues = [] - for player in vars(self)[party]: - issue = player.check_if_oversubscribed() - if issue: - issues.append(issue) +# self._check_inputs_player_prefs_all_reciprocated("hospitals") +# self._check_inputs_player_reciprocated_all_prefs( +# "hospitals", "residents" +# ) - return issues +# self._check_inputs_player_prefs_nonempty("residents", "hospitals") +# self._check_inputs_player_prefs_nonempty("hospitals", "residents") - def check_stability(self): - """Check for the existence of any blocking pairs.""" +# self._check_inputs_player_capacity("hospitals", "residents") - blocking_pairs = [] - for resident in self.residents: - for hospital in self.hospitals: - if ( - _check_mutual_preference(resident, hospital) - and _check_resident_unhappy(resident, hospital) - and _check_hospital_unhappy(resident, hospital) - ): - blocking_pairs.append((resident, hospital)) +# def _check_inputs_player_prefs_all_reciprocated(self, party): +# """Check everyone has only ranked players who ranked them.""" - self.blocking_pairs = blocking_pairs - return not any(blocking_pairs) +# for player in vars(self)[party]: +# for other in player.prefs: +# if player not in other.prefs: +# warnings.warn( +# PreferencesChangedWarning( +# f"{player} ranked {other} but they did not." +# ) +# ) +# if self.clean: +# player._forget(other) - def check_inputs(self): - """Check if any rules of the game have been broken. +# def _check_inputs_player_reciprocated_all_prefs(self, party, other_party): +# """Check everyone has ranked all the players who ranked them.""" - Any violations will be flagged as warnings. If the ``clean`` - attribute is in use, then any violations will be removed. - """ - - self._check_inputs_player_prefs_unique("residents") - self._check_inputs_player_prefs_unique("hospitals") - - self._check_inputs_player_prefs_all_in_party("residents", "hospitals") - self._check_inputs_player_prefs_all_in_party("hospitals", "residents") - - self._check_inputs_player_prefs_all_reciprocated("hospitals") - self._check_inputs_player_reciprocated_all_prefs( - "hospitals", "residents" - ) - - self._check_inputs_player_prefs_nonempty("residents", "hospitals") - self._check_inputs_player_prefs_nonempty("hospitals", "residents") - - self._check_inputs_player_capacity("hospitals", "residents") +# players = vars(self)[party] +# others = vars(self)[other_party] +# for player in players: +# others_that_ranked = [ +# other for other in others if player in other.prefs +# ] +# for other in others_that_ranked: +# if other not in player.prefs: +# warnings.warn( +# PreferencesChangedWarning( +# f"{other} ranked {player} but they did not." +# ) +# ) +# if self.clean: +# other._forget(player) - def _check_inputs_player_prefs_all_reciprocated(self, party): - """Check everyone has only ranked players who ranked them.""" +# def _check_inputs_player_capacity(self, party, other_party): +# """Check everyone has a capacity of at least one.""" - for player in vars(self)[party]: - for other in player.prefs: - if player not in other.prefs: - warnings.warn( - PreferencesChangedWarning( - f"{player} ranked {other} but they did not." - ) - ) - if self.clean: - player._forget(other) +# for player in vars(self)[party]: +# if player.capacity < 1: +# warnings.warn(PlayerExcludedWarning(player)) - def _check_inputs_player_reciprocated_all_prefs(self, party, other_party): - """Check everyone has ranked all the players who ranked them.""" +# if self.clean: +# self._remove_player(player, party, other_party) - players = vars(self)[party] - others = vars(self)[other_party] - for player in players: - others_that_ranked = [ - other for other in others if player in other.prefs - ] - for other in others_that_ranked: - if other not in player.prefs: - warnings.warn( - PreferencesChangedWarning( - f"{other} ranked {player} but they did not." - ) - ) - if self.clean: - other._forget(player) - def _check_inputs_player_capacity(self, party, other_party): - """Check everyone has a capacity of at least one.""" +# def _check_mutual_preference(resident, hospital): +# """Check whether two players have a preference of each other.""" - for player in vars(self)[party]: - if player.capacity < 1: - warnings.warn(PlayerExcludedWarning(player)) +# return resident in hospital.prefs and hospital in resident.prefs - if self.clean: - self._remove_player(player, party, other_party) +# def _check_resident_unhappy(resident, hospital): +# """Check whether a resident is unhappy given a hospital. -def _check_mutual_preference(resident, hospital): - """Check whether two players have a preference of each other.""" +# An unhappy resident is either unmatched or they prefer the hospital +# to their current match. +# """ - return resident in hospital.prefs and hospital in resident.prefs +# return resident.matching is None or resident.prefers( +# hospital, resident.matching +# ) -def _check_resident_unhappy(resident, hospital): - """Check whether a resident is unhappy given a hospital. +# def _check_hospital_unhappy(resident, hospital): +# """Check whether a hospital is unhappy given a resident. - An unhappy resident is either unmatched or they prefer the hospital - to their current match. - """ - - return resident.matching is None or resident.prefers( - hospital, resident.matching - ) - - -def _check_hospital_unhappy(resident, hospital): - """Check whether a hospital is unhappy given a resident. - - An unhappy hospital is either under-subscribed or they prefer the - resident to at least one of their current matches. - """ +# An unhappy hospital is either under-subscribed or they prefer the +# resident to at least one of their current matches. +# """ - return len(hospital.matching) < hospital.capacity or any( - [hospital.prefers(resident, match) for match in hospital.matching] - ) +# return len(hospital.matching) < hospital.capacity or any( +# [hospital.prefers(resident, match) for match in hospital.matching] +# ) -def _make_players(resident_prefs, hospital_prefs, capacities): - """Make a set of residents and hospitals from the dictionaries.""" +# def _make_players(resident_prefs, hospital_prefs, capacities): +# """Make a set of residents and hospitals from the dictionaries.""" - resident_dict, hospital_dict = _make_instances( - resident_prefs, hospital_prefs, capacities - ) +# resident_dict, hospital_dict = _make_instances( +# resident_prefs, hospital_prefs, capacities +# ) - for resident_name, resident in resident_dict.items(): - prefs = [hospital_dict[name] for name in resident_prefs[resident_name]] - resident.set_prefs(prefs) +# for resident_name, resident in resident_dict.items(): +# prefs = [hospital_dict[name] for name in resident_prefs[resident_name]] +# resident.set_prefs(prefs) - for hospital_name, hospital in hospital_dict.items(): - prefs = [resident_dict[name] for name in hospital_prefs[hospital_name]] - hospital.set_prefs(prefs) +# for hospital_name, hospital in hospital_dict.items(): +# prefs = [resident_dict[name] for name in hospital_prefs[hospital_name]] +# hospital.set_prefs(prefs) - residents = list(resident_dict.values()) - hospitals = list(hospital_dict.values()) +# residents = list(resident_dict.values()) +# hospitals = list(hospital_dict.values()) - return residents, hospitals +# return residents, hospitals -def _make_instances(resident_prefs, hospital_prefs, capacities): - """Create ``Player`` (resident) and ``Hospital`` instances.""" +# def _make_instances(resident_prefs, hospital_prefs, capacities): +# """Create ``Player`` (resident) and ``Hospital`` instances.""" - resident_dict, hospital_dict = {}, {} - for resident_name in resident_prefs: - resident = Resident(name=resident_name) - resident_dict[resident_name] = resident - for hospital_name in hospital_prefs: - capacity = capacities[hospital_name] - hospital = Hospital(name=hospital_name, capacity=capacity) - hospital_dict[hospital_name] = hospital +# resident_dict, hospital_dict = {}, {} +# for resident_name in resident_prefs: +# resident = Resident(name=resident_name) +# resident_dict[resident_name] = resident +# for hospital_name in hospital_prefs: +# capacity = capacities[hospital_name] +# hospital = Hospital(name=hospital_name, capacity=capacity) +# hospital_dict[hospital_name] = hospital - return resident_dict, hospital_dict +# return resident_dict, hospital_dict diff --git a/src/matching/games/student_allocation.py b/src/matching/games/student_allocation.py index 0f576d0..a695449 100644 --- a/src/matching/games/student_allocation.py +++ b/src/matching/games/student_allocation.py @@ -11,9 +11,10 @@ MatchingError, PreferencesChangedWarning, ) -from matching.games import HospitalResident from matching.players import Project, Supervisor +from ._old_hospital_resident import HospitalResident + class StudentAllocation(HospitalResident): """Solver for the student-allocation problem (SA). From fb03f9d957cd03891d96f9d4524ec8985a2969a0 Mon Sep 17 00:00:00 2001 From: Henry Wilde Date: Fri, 25 Oct 2024 12:26:15 +0100 Subject: [PATCH 04/26] Write tests for alt HR instantiations --- tests/common.py | 16 ++ tests/hospital_resident/strategies.py | 67 ++++- tests/hospital_resident/test_game.py | 101 ++++++- tests/hospital_resident/test_solver.py | 371 ------------------------- tests/stable_marriage/strategies.py | 34 +-- tests/stable_marriage/test_game.py | 1 + 6 files changed, 181 insertions(+), 409 deletions(-) delete mode 100644 tests/hospital_resident/test_solver.py diff --git a/tests/common.py b/tests/common.py index 9d92f14..0ab8932 100644 --- a/tests/common.py +++ b/tests/common.py @@ -4,6 +4,7 @@ import numpy as np from hypothesis import strategies as st +from hypothesis.extra import numpy as st_numpy def mocked_game(game, *args): @@ -32,3 +33,18 @@ def st_single_ranks(draw, num_rank: int, len_rank: int): ) return np.array(rank) + + +@st.composite +def st_single_utilities(draw, nrows: int, ncols: int): + """Create a single utility matrix.""" + + utility = draw( + st_numpy.arrays( + dtype=float, + elements=st.floats(0, 1, allow_nan=False), + shape=(nrows, ncols), + ) + ) + + return utility diff --git a/tests/hospital_resident/strategies.py b/tests/hospital_resident/strategies.py index 740cf7e..ac6eee8 100644 --- a/tests/hospital_resident/strategies.py +++ b/tests/hospital_resident/strategies.py @@ -3,20 +3,75 @@ import numpy as np from hypothesis import strategies as st -from ..common import st_single_ranks +from ..common import st_single_ranks, st_single_utilities @st.composite -def st_ranks_capacities(draw, hmin=1, hmax=3, rmin=1, rmax=5): - """Create a set of rankings and capacities for a test.""" +def st_sizes(draw, hmin, hmax, rmin, rmax): + """Create sizes for the resident and hospital sets.""" hsize = draw(st.integers(hmin, hmax)) rsize = draw(st.integers(rmin, rmax)) + return hsize, rsize + + +@st.composite +def st_capacities(draw, size): + """Create a capacity vector.""" + + capacities = draw( + st.lists(st.integers(1, 3), min_size=size, max_size=size) + ) + + return np.array(capacities) + + +@st.composite +def st_ranks_capacities(draw, hmin=1, hmax=3, rmin=1, rmax=5): + """Create a set of rankings and capacities for a test.""" + + hsize, rsize = draw(st_sizes(hmin, hmax, rmin, rmax)) + resident_ranks = draw(st_single_ranks(rsize, hsize)) hospital_ranks = draw(st_single_ranks(hsize, rsize)) - capacities = draw( - st.lists(st.integers(1, 3), min_size=hsize, max_size=hsize) + capacities = draw(st_capacities(hsize)) + + return resident_ranks, hospital_ranks, capacities + + +@st.composite +def st_utilities_capacities(draw, hmin=1, hmax=3, rmin=1, rmax=5): + """Create a set of utilities and capacities for a test.""" + + hsize, rsize = draw(st_sizes(hmin, hmax, rmin, rmax)) + + resident_utility = draw(st_single_utilities(rsize, hsize)) + hospital_utility = draw(st_single_utilities(hsize, rsize)) + capacities = draw(st_capacities(hsize)) + + return resident_utility, hospital_utility, capacities + + +@st.composite +def st_preferences_capacities(draw, hmin=1, hmax=3, rmin=1, rmax=5): + """Create a set of preferences and capacities for a test.""" + + hsize, rsize = draw(st_sizes(hmin, hmax, rmin, rmax)) + + residents = draw( + st.lists(st.integers(), min_size=rsize, max_size=rsize, unique=True) + ) + hospitals = draw( + st.lists(st.text(), min_size=hsize, max_size=hsize, unique=True) ) - return resident_ranks, hospital_ranks, np.array(capacities) + resident_preferences = { + r: draw(st.permutations(hospitals)) for r in residents + } + hospital_preferences = { + h: draw(st.permutations(residents)) for h in hospitals + } + capacities = dict(zip(hospital_preferences, draw(st_capacities(hsize)))) + + return resident_preferences, hospital_preferences, capacities diff --git a/tests/hospital_resident/test_game.py b/tests/hospital_resident/test_game.py index e20663e..0237f48 100644 --- a/tests/hospital_resident/test_game.py +++ b/tests/hospital_resident/test_game.py @@ -1,11 +1,18 @@ """Unit tests for the HospitalResident class.""" +from unittest import mock + +import numpy as np from hypothesis import given from matching.games import HospitalResident from ..common import mocked_game -from .strategies import st_ranks_capacities +from .strategies import ( + st_preferences_capacities, + st_ranks_capacities, + st_utilities_capacities, +) @given(st_ranks_capacities()) @@ -15,6 +22,7 @@ def test_init(ranks_capacities): resident_ranks, hospital_ranks, capacities = ranks_capacities game = mocked_game(HospitalResident, *ranks_capacities) + assert isinstance(game, HospitalResident) assert (game.resident_ranks == resident_ranks).all() assert (game.hospital_ranks == hospital_ranks).all() assert (game.capacities == capacities).all() @@ -23,3 +31,94 @@ def test_init(ranks_capacities): assert game.num_hospitals == len(hospital_ranks) assert game.matching is None assert game._preference_lookup is None + + +@given(st_utilities_capacities()) +def test_from_utilities(utilities_capacities): + """Check instantiation from utility matrices.""" + + *utilities, capacities = utilities_capacities + resident_utility, hospital_utility = utilities + + with ( + mock.patch( + "matching.games.HospitalResident.check_input_validity" + ) as validator, + mock.patch("matching.convert.utility_to_rank") as ranker, + ): + effects = (resident_utility.argsort(), hospital_utility.argsort()) + ranker.side_effect = list(effects) + game = HospitalResident.from_utilities( + resident_utility, hospital_utility, capacities + ) + + assert isinstance(game, HospitalResident) + assert (game.resident_ranks == effects[0]).all() + assert (game.hospital_ranks == effects[1]).all() + assert (game.capacities == capacities).all() + + assert game.num_residents == len(resident_utility) + assert game.num_hospitals == len(hospital_utility) + assert game.matching is None + assert game._preference_lookup is None + + assert ranker.call_count == 2 + for call, utility in zip(ranker.call_args_list, utilities): + arg, *_ = call.args + assert np.array_equal(arg, utility) + + validator.assert_called_once_with() + + +@given(st_preferences_capacities()) +def test_from_preferences(preferences_capacities): + """Check instantiation from preference list dictionaries.""" + + *preferences, capacities = preferences_capacities + resident_preferences, hospital_preferences = preferences + + with ( + mock.patch( + "matching.games.HospitalResident.check_input_validity" + ) as validator, + mock.patch("matching.convert.preference_to_rank") as ranker, + ): + effects = ( + np.array(list(resident_preferences.values())), + np.array(list(hospital_preferences.values())), + ) + ranker.side_effect = list(effects) + game = HospitalResident.from_preferences( + resident_preferences, hospital_preferences, capacities + ) + + assert isinstance(game, HospitalResident) + assert (game.resident_ranks == effects[0]).all() + assert (game.hospital_ranks == effects[1]).all() + + assert game.num_residents == len(resident_preferences) + assert game.num_hospitals == len(hospital_preferences) + assert game.matching is None + + assert isinstance(game._preference_lookup, dict) + assert game._preference_lookup == { + "residents": sorted(resident_preferences), + "hospitals": sorted(hospital_preferences), + } + + assert isinstance(game.capacities, np.ndarray) + assert game.capacities.shape == (len(hospital_preferences),) + for cap, hospital in zip( + game.capacities, game._preference_lookup["hospitals"] + ): + assert cap == capacities.get(hospital) + + assert ranker.call_count == 2 + for call, preference, others in zip( + ranker.call_args_list, + preferences, + (hospital_preferences, resident_preferences), + ): + assert call.args == (preference, sorted(others)) + + validator.assert_called_once_with() diff --git a/tests/hospital_resident/test_solver.py b/tests/hospital_resident/test_solver.py deleted file mode 100644 index dfac0b0..0000000 --- a/tests/hospital_resident/test_solver.py +++ /dev/null @@ -1,371 +0,0 @@ -"""Unit tests for the HR solver.""" - -import warnings - -import pytest -from hypothesis import given -from hypothesis.strategies import booleans, sampled_from - -from matching import MultipleMatching -from matching import Player as Resident -from matching.exceptions import ( - MatchingError, - PlayerExcludedWarning, - PreferencesChangedWarning, -) -from matching.games import HospitalResident -from matching.players import Hospital - -from .util import connections, games, players - - -@given(players=players(), clean=booleans()) -def test_init(players, clean): - """Test for correct instantiation given a set of players.""" - - residents, hospitals = players - - game = HospitalResident(residents, hospitals, clean) - - for resident, game_resident in zip(residents, game.residents): - assert resident.name == game_resident.name - assert resident._pref_names == game_resident._pref_names - - for hospital, game_hospital in zip(hospitals, game.hospitals): - assert hospital.name == game_hospital.name - assert hospital._pref_names == game_hospital._pref_names - assert hospital.capacity == game_hospital.capacity - - assert all([resident.matching is None for resident in game.residents]) - assert all([hospital.matching == [] for hospital in game.hospitals]) - assert game.matching is None - - -@given(connections=connections(), clean=booleans()) -def test_create_from_dictionaries(connections, clean): - """Test for correct instantiation given a set of dictionaries.""" - - resident_prefs, hospital_prefs, capacities = connections - - game = HospitalResident.create_from_dictionaries( - resident_prefs, hospital_prefs, capacities, clean - ) - - for resident in game.residents: - assert resident._pref_names == resident_prefs[resident.name] - assert resident.matching is None - - for hospital in game.hospitals: - assert hospital._pref_names == hospital_prefs[hospital.name] - assert hospital.capacity == capacities[hospital.name] - assert hospital.matching == [] - - assert game.matching is None - assert game.clean is clean - - -@given(game=games()) -def test_check_inputs(game): - """Test that inputs to an instance of HR can be verified.""" - - with warnings.catch_warnings(): - warnings.simplefilter("error") - game.check_inputs() - - assert game.residents == game._all_residents - assert game.hospitals == game._all_hospitals - - -@given(game=games()) -def test_check_inputs_resident_prefs_all_hospitals(game): - """Test each resident has only hospitals in its preference list. - - If not, check that a warning is caught and the resident's - preferences are changed. - """ - - resident = game.residents[0] - resident.prefs = [Resident("foo")] - - with pytest.warns(PreferencesChangedWarning) as record: - game._check_inputs_player_prefs_all_in_party("residents", "hospitals") - - assert len(record) == 1 - - message = str(record[0].message) - - assert resident.name in message - assert "foo" in message - - if game.clean: - assert resident.prefs == [] - - -@given(game=games()) -def test_check_inputs_hospital_prefs_all_residents(game): - """Test each hospital has only residents in its preference list. - - If not, check that a warning is caught and the hospitals's - preferences are changed. - """ - - hospital = game.hospitals[0] - hospital.prefs = [Resident("foo")] - - with pytest.warns(PreferencesChangedWarning) as record: - game._check_inputs_player_prefs_all_in_party("hospitals", "residents") - - assert len(record) == 1 - - message = str(record[0].message) - - assert hospital.name in message - assert "foo" in message - - if game.clean: - assert hospital.prefs == [] - - -@given(game=games()) -def test_check_inputs_hospital_prefs_all_reciprocated(game): - """Test each hospital has ranked only residents that have ranked it. - - If not, check that a warning is caught and the hospital has - forgotten any such residents. - """ - - hospital = game.hospitals[0] - resident = hospital.prefs[0] - resident._forget(hospital) - - with pytest.warns(PreferencesChangedWarning) as record: - game._check_inputs_player_prefs_all_reciprocated("hospitals") - - assert len(record) == 1 - - message = str(record[0].message) - - assert hospital.name in message - assert resident.name in message - - if game.clean: - assert resident not in hospital.prefs - - -@given(game=games()) -def test_check_inputs_hospital_reciprocated_all_prefs(game): - """Test each hospital has ranked all residents that have ranked it. - - If not, check that a warning is caught and any such resident has - forgotten the hospital. - """ - - hospital = game.hospitals[0] - resident = hospital.prefs[0] - hospital._forget(resident) - - with pytest.warns(PreferencesChangedWarning) as record: - game._check_inputs_player_reciprocated_all_prefs( - "hospitals", "residents" - ) - - assert len(record) == 1 - - message = str(record[0].message) - - assert hospital.name in message - assert resident.name in message - - if game.clean: - assert hospital not in resident.prefs - - -@given(game=games()) -def test_check_inputs_resident_prefs_all_nonempty(game): - """Test that each resident has a non-empty preference list. - - If not, check that a warning is caught and the resident has been - removed from the game. - """ - - resident = game.residents[0] - resident.prefs = [] - - with pytest.warns(PlayerExcludedWarning) as record: - game._check_inputs_player_prefs_nonempty("residents", "hospitals") - - assert len(record) == 1 - assert resident.name in str(record[0].message) - - if game.clean: - assert resident not in game.residents - - -@given(game=games()) -def test_check_inputs_hospital_prefs_all_nonempty(game): - """Test that each hospital has a non-empty preference list. - - If not, check that a warning is caught and the player has been - removed from the game. - """ - - hospital = game.hospitals[0] - hospital.prefs = [] - - with pytest.warns(PlayerExcludedWarning) as record: - game._check_inputs_player_prefs_nonempty("hospitals", "residents") - - assert len(record) == 1 - assert hospital.name in str(record[0].message) - - if game.clean: - assert hospital not in game.hospitals - - -@given(game=games()) -def test_check_inputs_hospital_capacity(game): - """Test each hospital has a positive integer capacity. - - If not, raise an Exception detailing the hospital. - """ - - hospital = game.hospitals[0] - capacity = hospital.capacity - hospital.capacity = 0 - - assert hospital._original_capacity == capacity - - with pytest.warns(PlayerExcludedWarning) as record: - game._check_inputs_player_capacity("hospitals", "residents") - - assert len(record) == 1 - assert hospital.name in str(record[0].message) - - if game.clean: - assert hospital not in game.hospitals - - -@given(game=games(), optimal=sampled_from(["resident", "hospital"])) -def test_solve(game, optimal): - """Test for the correct solving of games.""" - - matching = game.solve(optimal) - assert isinstance(matching, MultipleMatching) - - hospitals = sorted(game.hospitals, key=lambda h: h.name) - matching_keys = sorted(matching.keys(), key=lambda k: k.name) - for game_hospital, hospital in zip(matching_keys, hospitals): - assert game_hospital.name == hospital.name - assert game_hospital._pref_names == hospital._pref_names - assert game_hospital.capacity == hospital.capacity - - matched_residents = [ - resident for match in matching.values() for resident in match - ] - - assert matched_residents != [] and set(matched_residents).issubset( - set(game.residents) - ) - - for resident in set(game.residents) - set(matched_residents): - assert resident.matching is None - - -@given(game=games()) -def test_check_validity(game): - """Test for a valid matching when the game is solved.""" - - game.solve() - assert game.check_validity() - - -@given(game=games()) -def test_check_for_unacceptable_matches_residents(game): - """Test that matched residents have a preference of their match.""" - - resident = game.residents[0] - hospital = Hospital(name="foo", capacity=1) - resident.matching = hospital - - issues = game._check_for_unacceptable_matches("residents") - assert len(issues) == 1 - - issue = issues[0] - assert issue.startswith(resident.name) - assert issue.endswith(f"{resident.prefs}.") - assert hospital.name in issue - - with pytest.raises(MatchingError) as e: - game.check_validity() - error = e.unacceptable_matches[0] - assert issue == error - - -@given(game=games()) -def test_check_for_unacceptable_matches_hospitals(game): - """Test that each hospital has a preference of all its matches.""" - - hospital = game.hospitals[0] - resident = Resident(name="foo") - hospital.matching.append(resident) - - issues = game._check_for_unacceptable_matches("hospitals") - assert len(issues) == 1 - - issue = issues[0] - assert issue.startswith(hospital.name) - assert issue.endswith(f"{hospital.prefs}.") - assert resident.name in issue - - with pytest.raises(MatchingError) as e: - game.check_validity() - error = e.unacceptable_matches[0] - assert issue == error - - -@given(game=games()) -def test_check_for_oversubscribed_hospitals(game): - """Test that no hospitals can be oversubscribed.""" - - hospital = game.hospitals[0] - hospital.matching = range(hospital.capacity + 1) - - issues = game._check_for_oversubscribed_players("hospitals") - assert len(issues) == 1 - - issue = issues[0] - assert issue.startswith(hospital.name) - assert issue.endswith(f"{hospital.capacity}.") - assert str(hospital.matching) in issue - - with pytest.raises(MatchingError) as e: - game.check_validity() - error = e.oversubscribed_hospitals[0] - assert issue == error - - -def test_check_stability(): - """Test checker for whether matching is stable or not.""" - - residents = [Resident("A"), Resident("B"), Resident("C")] - hospitals = [Hospital("X", 2), Hospital("Y", 2)] - - (a, b, c), (x, y) = residents, hospitals - - a.set_prefs([x, y]) - b.set_prefs([y]) - c.set_prefs([y, x]) - - x.set_prefs([c, a]) - y.set_prefs([a, b, c]) - - game = HospitalResident(residents, hospitals) - - matching = game.solve() - assert game.check_stability() - - (a, b, c), (x, y) = game.residents, game.hospitals - matching[x] = [c] - matching[y] = [a, b] - - assert not game.check_stability() diff --git a/tests/stable_marriage/strategies.py b/tests/stable_marriage/strategies.py index aad5078..361de3d 100644 --- a/tests/stable_marriage/strategies.py +++ b/tests/stable_marriage/strategies.py @@ -1,21 +1,8 @@ """Composite strategies for SM unit tests.""" from hypothesis import strategies as st -from hypothesis.extra import numpy as st_numpy -from ..common import st_single_ranks - -# def mocked_game(suitor_ranks, reviewer_ranks): -# """Create an instance of SM that mocks the input validator.""" - -# with mock.patch( -# "matching.games.StableMarriage.check_input_validity" -# ) as validator: -# game = StableMarriage(suitor_ranks, reviewer_ranks) - -# validator.assert_called_once_with() - -# return game +from ..common import st_single_ranks, st_single_utilities @st.composite @@ -41,28 +28,13 @@ def st_player_ranks(draw, pmin=1, pmax=5): return suitor_ranks, reviewer_ranks, player, ranks, side -@st.composite -def st_single_utilities(draw, size): - """Create a single utility matrix.""" - - utility = draw( - st_numpy.arrays( - dtype=float, - elements=st.floats(0, 1, allow_nan=False), - shape=(size, size), - ) - ) - - return utility - - @st.composite def st_utilities(draw, pmin=1, pmax=5): """Create a set of utility matrices.""" size = draw(st.integers(pmin, pmax)) - suitor_utility = draw(st_single_utilities(size)) - reviewer_utility = draw(st_single_utilities(size)) + suitor_utility = draw(st_single_utilities(size, size)) + reviewer_utility = draw(st_single_utilities(size, size)) return suitor_utility, reviewer_utility diff --git a/tests/stable_marriage/test_game.py b/tests/stable_marriage/test_game.py index e733799..fa357fa 100644 --- a/tests/stable_marriage/test_game.py +++ b/tests/stable_marriage/test_game.py @@ -28,6 +28,7 @@ def test_init(ranks): suitor_ranks, reviewer_ranks = ranks game = mocked_game(StableMarriage, suitor_ranks, reviewer_ranks) + assert isinstance(game, StableMarriage) assert (game.suitor_ranks == suitor_ranks).all() assert (game.reviewer_ranks == reviewer_ranks).all() From cfc086628991370edf1a888e30fabca3b0279e9b Mon Sep 17 00:00:00 2001 From: Henry Wilde Date: Fri, 25 Oct 2024 12:27:01 +0100 Subject: [PATCH 05/26] Implement instantiation --- src/matching/games/hospital_resident.py | 351 +++++------------------- 1 file changed, 67 insertions(+), 284 deletions(-) diff --git a/src/matching/games/hospital_resident.py b/src/matching/games/hospital_resident.py index 1b0eb49..6aaf10d 100644 --- a/src/matching/games/hospital_resident.py +++ b/src/matching/games/hospital_resident.py @@ -1,5 +1,9 @@ """The HR game class and supporting functions.""" +import numpy as np + +from matching import convert + class HospitalResident: """ @@ -39,296 +43,75 @@ def __init__(self, resident_ranks, hospital_ranks, capacities): self.check_input_validity() - def check_input_validity(self): + @classmethod + def from_utilities(cls, resident_utils, hospital_utils, capacities): """ - Determine whether this game instance is valid or not. - - Invalid games can still be solved, but the matching will not be - truly stable in the absence of blocking pairs. + Create an instance of HR from utility matrices. + + Higher utilities indicate higher preferences. If there are any + ties, they are broken in order of appearance. + + Parameters + ---------- + resident_utils : np.ndarray + Resident utility matrix. + hospital_utils : np.ndarray + Hospital utility matrix. + capacities : np.ndarray + Hospital capacity vector. + + Returns + ------- + game : HospitalResident + An instance of HR with utilities resolved as rank matrices. """ + resident_ranks = convert.utility_to_rank(resident_utils) + hospital_ranks = convert.utility_to_rank(hospital_utils) + return cls(resident_ranks, hospital_ranks, capacities) -# import copy -# import warnings - -# from matching import BaseGame, MultipleMatching -# from matching import Player as Resident -# from matching.algorithms import hospital_resident -# from matching.exceptions import ( -# MatchingError, -# PlayerExcludedWarning, -# PreferencesChangedWarning, -# ) -# from matching.players import Hospital - - -# class OldHospitalResident(BaseGame): -# """Solver for the hospital-resident assignment problem (HR). - -# In this case, a blocking pair is any resident-hospital pair that -# satisfies **all** of the following: - -# - They are present in each other's preference lists; -# - either the resident is unmatched, or they prefer the hospital -# to their current match; -# - either the hospital is under-subscribed, or they prefer the -# resident to at least one of their current matches. - -# Parameters -# ---------- -# residents : list of Player -# The residents in the matching game. Each resident must rank a -# subset of those in ``hospitals``. -# hospitals : list of Hospital -# The hospitals in the matching game. Each hospital must rank all -# of (and only) the residents which rank it. -# clean : bool -# Indicator for whether the players of the game should be cleaned. -# Cleaning is reductive in nature, removing players from the game -# and/or other player's preferences if they do not meet the -# requirements of the game. - -# Attributes -# ---------- -# matching : MultipleMatching or None -# Once the game is solved, a matching is available as a -# ``MultipleMatching`` object with the hospitals as keys and their -# resident matches as values. Initialises as ``None``. -# blocking_pairs : list of (Player, Hospital) or None -# Initialises as ``None``. Otherwise, a list of the -# resident-hospital blocking pairs. -# """ - -# def __init__(self, residents, hospitals, clean=False): -# residents, hospitals = copy.deepcopy([residents, hospitals]) -# self.residents = residents -# self.hospitals = hospitals -# self.clean = clean - -# self._all_residents = residents -# self._all_hospitals = hospitals - -# super().__init__(clean) -# self.check_inputs() - -# @classmethod -# def create_from_dictionaries( -# cls, resident_prefs, hospital_prefs, capacities, clean=False -# ): -# """Create an instance from a set of dictionaries. - -# A preference dictionary for residents and hospitals is required, -# along with a dictionary detailing the hospital capacities. If -# ``clean``, then remove players from the game and/or player -# preferences if they do not satisfy the conditions of the game. -# """ - -# residents, hospitals = _make_players( -# resident_prefs, hospital_prefs, capacities -# ) -# game = cls(residents, hospitals, clean) - -# return game - -# def solve(self, optimal="resident"): -# """Solve the instance of HR. Return the matching. - -# The party optimality can be controlled using the ``optimal`` -# parameter. -# """ - -# self.matching = MultipleMatching( -# hospital_resident(self.residents, self.hospitals, optimal) -# ) -# return self.matching - -# def check_validity(self): -# """Check whether the current matching is valid.""" - -# unacceptable_issues = self._check_for_unacceptable_matches( -# "residents" -# ) + self._check_for_unacceptable_matches("hospitals") - -# oversubscribed_issues = self._check_for_oversubscribed_players( -# "hospitals" -# ) - -# if unacceptable_issues or oversubscribed_issues: -# raise MatchingError( -# unacceptable_matches=unacceptable_issues, -# oversubscribed_hospitals=oversubscribed_issues, -# ) - -# return True - -# def _check_for_unacceptable_matches(self, party): -# """Check that no one in ``party`` has an unacceptable match.""" - -# issues = [] -# for player in vars(self)[party]: -# issue = player.check_if_match_is_unacceptable(unmatched_okay=True) -# if isinstance(issue, list): -# issues.extend(issue) -# elif isinstance(issue, str): -# issues.append(issue) - -# return issues - -# def _check_for_oversubscribed_players(self, party): -# """Check that no player in `party` is over-subscribed.""" - -# issues = [] -# for player in vars(self)[party]: -# issue = player.check_if_oversubscribed() -# if issue: -# issues.append(issue) - -# return issues - -# def check_stability(self): -# """Check for the existence of any blocking pairs.""" - -# blocking_pairs = [] -# for resident in self.residents: -# for hospital in self.hospitals: -# if ( -# _check_mutual_preference(resident, hospital) -# and _check_resident_unhappy(resident, hospital) -# and _check_hospital_unhappy(resident, hospital) -# ): -# blocking_pairs.append((resident, hospital)) - -# self.blocking_pairs = blocking_pairs -# return not any(blocking_pairs) - -# def check_inputs(self): -# """Check if any rules of the game have been broken. - -# Any violations will be flagged as warnings. If the ``clean`` -# attribute is in use, then any violations will be removed. -# """ - -# self._check_inputs_player_prefs_unique("residents") -# self._check_inputs_player_prefs_unique("hospitals") - -# self._check_inputs_player_prefs_all_in_party("residents", "hospitals") -# self._check_inputs_player_prefs_all_in_party("hospitals", "residents") - -# self._check_inputs_player_prefs_all_reciprocated("hospitals") -# self._check_inputs_player_reciprocated_all_prefs( -# "hospitals", "residents" -# ) - -# self._check_inputs_player_prefs_nonempty("residents", "hospitals") -# self._check_inputs_player_prefs_nonempty("hospitals", "residents") - -# self._check_inputs_player_capacity("hospitals", "residents") - -# def _check_inputs_player_prefs_all_reciprocated(self, party): -# """Check everyone has only ranked players who ranked them.""" - -# for player in vars(self)[party]: -# for other in player.prefs: -# if player not in other.prefs: -# warnings.warn( -# PreferencesChangedWarning( -# f"{player} ranked {other} but they did not." -# ) -# ) -# if self.clean: -# player._forget(other) - -# def _check_inputs_player_reciprocated_all_prefs(self, party, other_party): -# """Check everyone has ranked all the players who ranked them.""" - -# players = vars(self)[party] -# others = vars(self)[other_party] -# for player in players: -# others_that_ranked = [ -# other for other in others if player in other.prefs -# ] -# for other in others_that_ranked: -# if other not in player.prefs: -# warnings.warn( -# PreferencesChangedWarning( -# f"{other} ranked {player} but they did not." -# ) -# ) -# if self.clean: -# other._forget(player) - -# def _check_inputs_player_capacity(self, party, other_party): -# """Check everyone has a capacity of at least one.""" - -# for player in vars(self)[party]: -# if player.capacity < 1: -# warnings.warn(PlayerExcludedWarning(player)) - -# if self.clean: -# self._remove_player(player, party, other_party) - - -# def _check_mutual_preference(resident, hospital): -# """Check whether two players have a preference of each other.""" - -# return resident in hospital.prefs and hospital in resident.prefs - - -# def _check_resident_unhappy(resident, hospital): -# """Check whether a resident is unhappy given a hospital. - -# An unhappy resident is either unmatched or they prefer the hospital -# to their current match. -# """ - -# return resident.matching is None or resident.prefers( -# hospital, resident.matching -# ) - - -# def _check_hospital_unhappy(resident, hospital): -# """Check whether a hospital is unhappy given a resident. - -# An unhappy hospital is either under-subscribed or they prefer the -# resident to at least one of their current matches. -# """ - -# return len(hospital.matching) < hospital.capacity or any( -# [hospital.prefers(resident, match) for match in hospital.matching] -# ) - - -# def _make_players(resident_prefs, hospital_prefs, capacities): -# """Make a set of residents and hospitals from the dictionaries.""" - -# resident_dict, hospital_dict = _make_instances( -# resident_prefs, hospital_prefs, capacities -# ) - -# for resident_name, resident in resident_dict.items(): -# prefs = [hospital_dict[name] for name in resident_prefs[resident_name]] -# resident.set_prefs(prefs) - -# for hospital_name, hospital in hospital_dict.items(): -# prefs = [resident_dict[name] for name in hospital_prefs[hospital_name]] -# hospital.set_prefs(prefs) - -# residents = list(resident_dict.values()) -# hospitals = list(hospital_dict.values()) + @classmethod + def from_preferences(cls, resident_prefs, hospital_prefs, capacities): + """ + Create an instance of HR from preference list dictionaries. + + Each dictionary should contain a strict ordering of the other + side by each player. The ranking is taken by the order of the + preference list. + + Parameters + ---------- + resident_prefs : dict + Resident preference lists. + hospital_prefs : dict + Hospital preference lists. + capacities : dict + Hospital capacities. + + Returns + ------- + game : HospitalResident + An instance of HR with preference lists resolved as rank + matrices. + """ + residents, hospitals = sorted(resident_prefs), sorted(hospital_prefs) -# return residents, hospitals + resident_ranks = convert.preference_to_rank(resident_prefs, hospitals) + hospital_ranks = convert.preference_to_rank(hospital_prefs, residents) + capacity_array = np.array([capacities.get(h) for h in hospitals]) + game = cls(resident_ranks, hospital_ranks, capacity_array) + game._preference_lookup = { + "residents": residents, + "hospitals": hospitals, + } -# def _make_instances(resident_prefs, hospital_prefs, capacities): -# """Create ``Player`` (resident) and ``Hospital`` instances.""" + return game -# resident_dict, hospital_dict = {}, {} -# for resident_name in resident_prefs: -# resident = Resident(name=resident_name) -# resident_dict[resident_name] = resident -# for hospital_name in hospital_prefs: -# capacity = capacities[hospital_name] -# hospital = Hospital(name=hospital_name, capacity=capacity) -# hospital_dict[hospital_name] = hospital + def check_input_validity(self): + """ + Determine whether this game instance is valid or not. -# return resident_dict, hospital_dict + Invalid games can still be solved, but the matching will not be + truly stable in the absence of blocking pairs. + """ From 730a46842d2408f6400a16d0ee9873982b2ad134 Mon Sep 17 00:00:00 2001 From: Henry Wilde Date: Mon, 4 Nov 2024 17:27:23 +0000 Subject: [PATCH 06/26] Point HR example at the old version in README --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 6cb4767..52c0405 100644 --- a/README.md +++ b/README.md @@ -122,7 +122,7 @@ of each has not yet been attained. For example, an instance of HR with second: ```python ->>> from matching.games import HospitalResident +>>> from matching.games._old_hospital_resident import HospitalResident >>> import numpy as np >>> prng = np.random.default_rng(0) >>> num_residents, num_hospitals = 400, 20 From 66a5ca4a3fabf6df48cd1e707696a7900154407a Mon Sep 17 00:00:00 2001 From: Henry Wilde Date: Thu, 20 Mar 2025 21:03:54 +0000 Subject: [PATCH 07/26] Move to `uv` (#178) * Set up `uv` files and update workflows * Fix typo in test runner step * Format everything; replace `np.infty` w/ `np.inf` --------- Co-authored-by: Henry Wilde --- .github/workflows/ci.yml | 31 +- .github/workflows/docs.yml | 24 +- docs/how-to/check_matching_status.ipynb | 4 +- docs/how-to/choose_optimality.ipynb | 8 +- docs/how-to/create_from_dictionaries.ipynb | 4 +- docs/tutorials/hospital_resident.ipynb | 4 +- docs/tutorials/student_allocation.ipynb | 74 +- pyproject.toml | 34 +- src/matching/algorithms/hospital_resident.py | 6 +- src/matching/algorithms/student_allocation.py | 8 +- src/matching/base.py | 13 +- src/matching/games/hospital_resident.py | 36 +- src/matching/games/stable_marriage.py | 18 +- src/matching/games/stable_roommates.py | 6 +- src/matching/games/student_allocation.py | 48 +- src/matching/players/supervisor.py | 4 +- tests/base/test_matching.py | 4 +- tests/hospital_resident/test_algorithm.py | 6 +- tests/hospital_resident/test_examples.py | 20 +- tests/hospital_resident/test_solver.py | 12 +- tests/hospital_resident/util.py | 4 +- tests/stable_marriage/test_solver.py | 12 +- tests/stable_marriage/util.py | 12 +- tests/stable_roommates/test_algorithm.py | 4 +- tests/stable_roommates/test_examples.py | 5 +- tests/student_allocation/test_algorithm.py | 20 +- tests/student_allocation/test_examples.py | 4 +- tests/student_allocation/test_solver.py | 104 +- tests/student_allocation/util.py | 38 +- tests/test_matchings.py | 8 +- uv.lock | 6060 +++++++++++++++++ 31 files changed, 6230 insertions(+), 405 deletions(-) create mode 100644 uv.lock diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index ca15859..8c81fff 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -14,39 +14,34 @@ jobs: run: shell: bash strategy: - max-parallel: 10 matrix: os: [ubuntu-latest, windows-latest] - python-version: [3.7, 3.8, 3.9, "3.10", "3.11"] + python-version: ["3.10", "3.11", "3.12", "3.13"] steps: - name: Check out repository uses: actions/checkout@v3 - - name: Set up Python ${{ matrix.python-version }} - uses: actions/setup-python@v4 + - name: Install uv and set the python version + uses: astral-sh/setup-uv@v5 with: python-version: ${{ matrix.python-version }} - cache: "pip" - - name: Update pip and install dependencies - run: | - python -m pip install --upgrade pip - python -m pip install ".[docs,test]" + - name: Install the project + run: uv sync --all-extras - name: Run tests run: | - python -m doctest README.md - python -m doctest paper.md - python -m pytest docs --nbval --nbval-current-env -p no:randomly - python -m pytest tests \ + uv run python -m doctest README.md + uv run python -m doctest paper.md + uv run pytest docs --nbval --nbval-current-env -p no:randomly + uv run pytest tests \ --cov=matching --cov-fail-under=100 --hypothesis-profile=ci - - name: Install and run linters (3.11-ubuntu only) + - name: Run linters (3.13-ubuntu only) if: | - matrix.python-version == '3.11' && + matrix.python-version == '3.13' && matrix.os == 'ubuntu-latest' run: | - python -m pip install ".[lint]" - python -m black --check . - python -m ruff check . + uv run ruff format --check . + uv run ruff check . diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml index b2fc4a8..8d19341 100644 --- a/.github/workflows/docs.yml +++ b/.github/workflows/docs.yml @@ -13,19 +13,25 @@ jobs: steps: - name: Check out repository uses: actions/checkout@v3 + - name: Set up Quarto uses: quarto-dev/quarto-actions/setup@v2 - - name: Install Python and dependencies - uses: actions/setup-python@v4 - with: - python-version: "3.9" - cache: "pip" - - run: | - python -m pip install ".[dev]" - quartodoc build + + - name: Install uv + uses: astral-sh/setup-uv@v5 + + - name: Set up Python + run: | + uv python install + + - name: Install package and build docs + run: | + uv sync --all-extras + uv run quartodoc build + - name: Render and publish uses: quarto-dev/quarto-actions/publish@v2 with: target: gh-pages env: - GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} \ No newline at end of file + GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} diff --git a/docs/how-to/check_matching_status.ipynb b/docs/how-to/check_matching_status.ipynb index 682182b..bf7f74a 100644 --- a/docs/how-to/check_matching_status.ipynb +++ b/docs/how-to/check_matching_status.ipynb @@ -39,9 +39,7 @@ "\n", "project_supervisors = {\"X1\": \"X\", \"X2\": \"X\", \"Y1\": \"Y\", \"Y2\": \"Y\"}\n", "project_capacities = {project: 1 for project in project_supervisors}\n", - "supervisor_capacities = {\n", - " supervisor: 2 for supervisor in supervisor_preferences\n", - "}\n", + "supervisor_capacities = {supervisor: 2 for supervisor in supervisor_preferences}\n", "\n", "\n", "game = StudentAllocation.create_from_dictionaries(\n", diff --git a/docs/how-to/choose_optimality.ipynb b/docs/how-to/choose_optimality.ipynb index c8db482..bfcfd8d 100644 --- a/docs/how-to/choose_optimality.ipynb +++ b/docs/how-to/choose_optimality.ipynb @@ -56,9 +56,7 @@ } ], "source": [ - "game = StableMarriage.create_from_dictionaries(\n", - " suitor_preferences, reviewer_preferences\n", - ")\n", + "game = StableMarriage.create_from_dictionaries(suitor_preferences, reviewer_preferences)\n", "\n", "game.solve(optimal=\"suitor\")" ] @@ -80,9 +78,7 @@ } ], "source": [ - "game = StableMarriage.create_from_dictionaries(\n", - " suitor_preferences, reviewer_preferences\n", - ")\n", + "game = StableMarriage.create_from_dictionaries(suitor_preferences, reviewer_preferences)\n", "\n", "game.solve(optimal=\"reviewer\")" ] diff --git a/docs/how-to/create_from_dictionaries.ipynb b/docs/how-to/create_from_dictionaries.ipynb index 98dc6eb..35132ba 100644 --- a/docs/how-to/create_from_dictionaries.ipynb +++ b/docs/how-to/create_from_dictionaries.ipynb @@ -28,9 +28,7 @@ "\n", "project_supervisors = {\"X1\": \"X\", \"X2\": \"X\", \"Y1\": \"Y\", \"Y2\": \"Y\"}\n", "project_capacities = {project: 1 for project in project_supervisors}\n", - "supervisor_capacities = {\n", - " supervisor: 2 for supervisor in supervisor_preferences\n", - "}" + "supervisor_capacities = {supervisor: 2 for supervisor in supervisor_preferences}" ] }, { diff --git a/docs/tutorials/hospital_resident.ipynb b/docs/tutorials/hospital_resident.ipynb index 8d48746..a901e4b 100644 --- a/docs/tutorials/hospital_resident.ipynb +++ b/docs/tutorials/hospital_resident.ipynb @@ -219,9 +219,7 @@ " for resident in residents:\n", " matched_residents.append(resident.name)\n", "\n", - "unmatched_residents = set(resident_preferences.keys()).difference(\n", - " matched_residents\n", - ")\n", + "unmatched_residents = set(resident_preferences.keys()).difference(matched_residents)\n", "unmatched_residents" ] }, diff --git a/docs/tutorials/student_allocation.ipynb b/docs/tutorials/student_allocation.ipynb index 2a8fb77..22f0276 100644 --- a/docs/tutorials/student_allocation.ipynb +++ b/docs/tutorials/student_allocation.ipynb @@ -53,15 +53,9 @@ "metadata": {}, "outputs": [], "source": [ - "raw_students = pd.read_csv(\n", - " \"https://zenodo.org/record/3514287/files/students.csv\"\n", - ")\n", - "raw_projects = pd.read_csv(\n", - " \"https://zenodo.org/record/3514287/files/projects.csv\"\n", - ")\n", - "raw_supervisors = pd.read_csv(\n", - " \"https://zenodo.org/record/3514287/files/supervisors.csv\"\n", - ")" + "raw_students = pd.read_csv(\"https://zenodo.org/record/3514287/files/students.csv\")\n", + "raw_projects = pd.read_csv(\"https://zenodo.org/record/3514287/files/projects.csv\")\n", + "raw_supervisors = pd.read_csv(\"https://zenodo.org/record/3514287/files/supervisors.csv\")" ] }, { @@ -360,11 +354,7 @@ } ], "source": [ - "students = (\n", - " raw_students.copy()\n", - " .dropna(subset=choices, how=\"all\")\n", - " .reset_index(drop=True)\n", - ")\n", + "students = raw_students.copy().dropna(subset=choices, how=\"all\").reset_index(drop=True)\n", "\n", "students.head()" ] @@ -778,9 +768,7 @@ "supervisor_to_preferences = {}\n", "for supervisor in supervisor_names:\n", " supervisor_preferences = []\n", - " supervisor_projects = [\n", - " p for p, s in project_to_supervisor.items() if s == supervisor\n", - " ]\n", + " supervisor_projects = [p for p, s in project_to_supervisor.items() if s == supervisor]\n", "\n", " for student in sorted_students:\n", " student_preferences = student_to_preferences[student]\n", @@ -823,9 +811,7 @@ } ], "source": [ - "unranked_supervisors = set(supervisor_names).difference(\n", - " supervisor_to_preferences.keys()\n", - ")\n", + "unranked_supervisors = set(supervisor_names).difference(supervisor_to_preferences.keys())\n", "\n", "\n", "unranked_projects = set(project_codes).difference(\n", @@ -934,9 +920,7 @@ ], "source": [ "for supervisor, supervisor_capacity in supervisor_to_capacity.items():\n", - " supervisor_projects = [\n", - " p for p, s in project_to_supervisor.items() if s == supervisor\n", - " ]\n", + " supervisor_projects = [p for p, s in project_to_supervisor.items() if s == supervisor]\n", " supervisor_project_capacities = [\n", " project_to_capacity[project] for project in supervisor_projects\n", " ]\n", @@ -1052,13 +1036,11 @@ "outputs": [], "source": [ "supervisor_free_spaces = {\n", - " supervisor: supervisor.capacity - len(supervisor.matching)\n", - " for supervisor in game.supervisors\n", + " supervisor: supervisor.capacity - len(supervisor.matching) for supervisor in game.supervisors\n", "}\n", "\n", "supervisor_utilisation = {\n", - " supervisor: len(supervisor.matching) / supervisor.capacity\n", - " for supervisor in game.supervisors\n", + " supervisor: len(supervisor.matching) / supervisor.capacity for supervisor in game.supervisors\n", "}" ] }, @@ -1142,9 +1124,7 @@ "ax.hist(values)\n", "\n", "ylims = ax.get_ylim()\n", - "ax.vlines(\n", - " np.mean(list(values)), *ylims, \"tab:orange\", \"dashed\", label=\"Mean\", lw=3\n", - ")\n", + "ax.vlines(np.mean(list(values)), *ylims, \"tab:orange\", \"dashed\", label=\"Mean\", lw=3)\n", "ax.set_ylim(*ylims)\n", "\n", "ax.set_xlabel(\"Utilisation\")\n", @@ -1171,13 +1151,11 @@ "outputs": [], "source": [ "project_free_spaces = {\n", - " project.name: project.capacity - len(project.matching)\n", - " for project in game.projects\n", + " project.name: project.capacity - len(project.matching) for project in game.projects\n", "}\n", "\n", "project_utilisation = {\n", - " project.name: len(project.matching) / project.capacity\n", - " for project in game.projects\n", + " project.name: len(project.matching) / project.capacity for project in game.projects\n", "}" ] }, @@ -1260,9 +1238,7 @@ "ax.hist(values)\n", "\n", "ylims = ax.get_ylim()\n", - "ax.vlines(\n", - " np.mean(list(values)), *ylims, \"tab:orange\", \"dashed\", label=\"Mean\", lw=3\n", - ")\n", + "ax.vlines(np.mean(list(values)), *ylims, \"tab:orange\", \"dashed\", label=\"Mean\", lw=3)\n", "ax.set_ylim(*ylims)\n", "\n", "ax.set_xlabel(\"Utilisation\")\n", @@ -1298,9 +1274,7 @@ "for project, project_students in matching.items():\n", " for student in project_students:\n", " inverted_matching[student.name] = project.name\n", - " student_preference_of_matching.append(\n", - " student._pref_names.index(project.name)\n", - " )" + " student_preference_of_matching.append(student._pref_names.index(project.name))" ] }, { @@ -1692,9 +1666,7 @@ "outputs": [], "source": [ "project_with_space_names = [\n", - " project.name\n", - " for project in game.projects\n", - " if len(project.matching) < project.capacity\n", + " project.name for project in game.projects if len(project.matching) < project.capacity\n", "] + list(unranked_projects)\n", "\n", "supervisor_with_space_names = [\n", @@ -1745,17 +1717,17 @@ "metadata": {}, "outputs": [], "source": [ - "projects_with_space[\"supervisor_capacity\"] = projects_with_space[\n", - " \"supervisor\"\n", - "].apply(lambda x: get_capacity(supervisors, \"supervisor\", x))\n", + "projects_with_space[\"supervisor_capacity\"] = projects_with_space[\"supervisor\"].apply(\n", + " lambda x: get_capacity(supervisors, \"supervisor\", x)\n", + ")\n", "\n", "projects_with_space[\"project_matches\"] = projects_with_space[\"code\"].apply(\n", " lambda x: get_number_of_matches(x, \"projects\", game)\n", ")\n", "\n", - "projects_with_space[\"supervisor_matches\"] = projects_with_space[\n", - " \"supervisor\"\n", - "].apply(lambda x: get_number_of_matches(x, \"supervisors\", game))\n", + "projects_with_space[\"supervisor_matches\"] = projects_with_space[\"supervisor\"].apply(\n", + " lambda x: get_number_of_matches(x, \"supervisors\", game)\n", + ")\n", "\n", "projects_with_space = projects_with_space[\n", " [\n", @@ -1873,9 +1845,7 @@ } ], "source": [ - "projects_with_space = projects_with_space.set_index(\n", - " [\"supervisor\", \"code\"]\n", - ").sort_index()\n", + "projects_with_space = projects_with_space.set_index([\"supervisor\", \"code\"]).sort_index()\n", "\n", "projects_with_space" ] diff --git a/pyproject.toml b/pyproject.toml index 09d9972..24134d0 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,7 +1,3 @@ -[build-system] -requires = ["setuptools>=62"] -build-backend = "setuptools.build_meta" - [project] name = "matching" authors = [ @@ -11,7 +7,7 @@ authors = [ description = "A package for solving matching games" readme = "README.md" requires-python = ">=3.7" -license = {text = "MIT License"} +license = {text = "MIT Licence"} keywords = [ "game-theory", "gale-shapley", @@ -33,6 +29,10 @@ dependencies = [ ] dynamic = ["version"] +[build-system] +requires = ["setuptools>=62"] +build-backend = "setuptools.build_meta" + [project.optional-dependencies] test = [ "hypothesis>=6.31.6", @@ -49,12 +49,10 @@ docs = [ "PyYAML>=6", "quartodoc>=0.5.0; python_version>'3.8'", ] -lint = [ - "black[jupyter]>=22.6.0,<23", - "ruff>=0.1.1", -] dev = [ - "matching[docs,lint,test]", + "matching[docs,test]", + "pytest-sugar>=1.0.0", + "ruff>=0.11.1", ] [project.urls] @@ -65,26 +63,22 @@ changelog = "https://github.com/daffidwilde/matching/blob/main/CHANGES.md" [tool.setuptools.dynamic] version = {attr = "matching.__version__"} -[tool.black] -line-length = 79 - -[tool.coverage.report] -omit = ["src/**/__init__.py"] - [tool.ruff] +line-length = 99 extend-include = ["*.ipynb"] + +[tool.ruff.lint] extend-select = ["D", "I", "W"] ignore = ["D105", "D107", "D202"] -line-length = 79 -[tool.ruff.isort] +[tool.ruff.lint.isort] known-first-party = ["matching"] -[tool.ruff.per-file-ignores] +[tool.ruff.lint.per-file-ignores] "docs/*" = ["D100", "D103", "E402"] "tests/**/*.py" = ["D104", "D401", "E741"] "src/**/*.py" = ["D105", "D107"] "src/matching/base.py" = ["D401"] -[tool.ruff.pydocstyle] +[tool.ruff.lint.pydocstyle] convention = "numpy" diff --git a/src/matching/algorithms/hospital_resident.py b/src/matching/algorithms/hospital_resident.py index 61cf491..52d6c1a 100644 --- a/src/matching/algorithms/hospital_resident.py +++ b/src/matching/algorithms/hospital_resident.py @@ -13,9 +13,9 @@ def _unmatch_pair(resident, hospital): def _check_available(hospital): """Check if a hospital is willing and able to take an applicant.""" - return len(hospital.matching) < hospital.capacity and set( - hospital.prefs - ).difference(hospital.matching) + return len(hospital.matching) < hospital.capacity and set(hospital.prefs).difference( + hospital.matching + ) def hospital_resident(residents, hospitals, optimal="resident"): diff --git a/src/matching/algorithms/student_allocation.py b/src/matching/algorithms/student_allocation.py index 81db0d7..383af81 100644 --- a/src/matching/algorithms/student_allocation.py +++ b/src/matching/algorithms/student_allocation.py @@ -111,9 +111,7 @@ def student_optimal(students, projects): successors = supervisor.get_successors() for successor in successors: supervisor_projects = [ - project - for project in supervisor.projects - if project in successor.prefs + project for project in supervisor.projects if project in successor.prefs ] for project in supervisor_projects: @@ -167,9 +165,7 @@ def supervisor_optimal(projects, supervisors): _delete_pair(student, successor) free_supervisors = [ - supervisor - for supervisor in supervisors - if supervisor.get_favourite() is not None + supervisor for supervisor in supervisors if supervisor.get_favourite() is not None ] return {p: p.matching for p in projects} diff --git a/src/matching/base.py b/src/matching/base.py index 2255a0f..e6e6fac 100644 --- a/src/matching/base.py +++ b/src/matching/base.py @@ -151,9 +151,7 @@ def _check_inputs_player_prefs_unique(self, party): unique_prefs.append(other) else: warnings.warn( - PreferencesChangedWarning( - f"{player} has ranked {other} multiple times." - ) + PreferencesChangedWarning(f"{player} has ranked {other} multiple times.") ) if self.clean: @@ -172,8 +170,7 @@ def _check_inputs_player_prefs_all_in_party(self, party, other_party): if other not in others: warnings.warn( PreferencesChangedWarning( - f"{player} has ranked a non-{other_party[:-1]}: " - f"{other}." + f"{player} has ranked a non-{other_party[:-1]}: {other}." ) ) if self.clean: @@ -187,11 +184,7 @@ def _check_inputs_player_prefs_nonempty(self, party, other_party): for player in vars(self)[party]: if not player.prefs: - warnings.warn( - PlayerExcludedWarning( - f"{player} has an empty preference list." - ) - ) + warnings.warn(PlayerExcludedWarning(f"{player} has an empty preference list.")) if self.clean: self._remove_player(player, party, other_party) diff --git a/src/matching/games/hospital_resident.py b/src/matching/games/hospital_resident.py index 13593fd..4860d0c 100644 --- a/src/matching/games/hospital_resident.py +++ b/src/matching/games/hospital_resident.py @@ -64,9 +64,7 @@ def __init__(self, residents, hospitals, clean=False): self.check_inputs() @classmethod - def create_from_dictionaries( - cls, resident_prefs, hospital_prefs, capacities, clean=False - ): + def create_from_dictionaries(cls, resident_prefs, hospital_prefs, capacities, clean=False): """Create an instance from a set of dictionaries. A preference dictionary for residents and hospitals is required, @@ -75,9 +73,7 @@ def create_from_dictionaries( preferences if they do not satisfy the conditions of the game. """ - residents, hospitals = _make_players( - resident_prefs, hospital_prefs, capacities - ) + residents, hospitals = _make_players(resident_prefs, hospital_prefs, capacities) game = cls(residents, hospitals, clean) return game @@ -101,9 +97,7 @@ def check_validity(self): "residents" ) + self._check_for_unacceptable_matches("hospitals") - oversubscribed_issues = self._check_for_oversubscribed_players( - "hospitals" - ) + oversubscribed_issues = self._check_for_oversubscribed_players("hospitals") if unacceptable_issues or oversubscribed_issues: raise MatchingError( @@ -167,9 +161,7 @@ def check_inputs(self): self._check_inputs_player_prefs_all_in_party("hospitals", "residents") self._check_inputs_player_prefs_all_reciprocated("hospitals") - self._check_inputs_player_reciprocated_all_prefs( - "hospitals", "residents" - ) + self._check_inputs_player_reciprocated_all_prefs("hospitals", "residents") self._check_inputs_player_prefs_nonempty("residents", "hospitals") self._check_inputs_player_prefs_nonempty("hospitals", "residents") @@ -183,9 +175,7 @@ def _check_inputs_player_prefs_all_reciprocated(self, party): for other in player.prefs: if player not in other.prefs: warnings.warn( - PreferencesChangedWarning( - f"{player} ranked {other} but they did not." - ) + PreferencesChangedWarning(f"{player} ranked {other} but they did not.") ) if self.clean: player._forget(other) @@ -196,15 +186,11 @@ def _check_inputs_player_reciprocated_all_prefs(self, party, other_party): players = vars(self)[party] others = vars(self)[other_party] for player in players: - others_that_ranked = [ - other for other in others if player in other.prefs - ] + others_that_ranked = [other for other in others if player in other.prefs] for other in others_that_ranked: if other not in player.prefs: warnings.warn( - PreferencesChangedWarning( - f"{other} ranked {player} but they did not." - ) + PreferencesChangedWarning(f"{other} ranked {player} but they did not.") ) if self.clean: other._forget(player) @@ -233,9 +219,7 @@ def _check_resident_unhappy(resident, hospital): to their current match. """ - return resident.matching is None or resident.prefers( - hospital, resident.matching - ) + return resident.matching is None or resident.prefers(hospital, resident.matching) def _check_hospital_unhappy(resident, hospital): @@ -253,9 +237,7 @@ def _check_hospital_unhappy(resident, hospital): def _make_players(resident_prefs, hospital_prefs, capacities): """Make a set of residents and hospitals from the dictionaries.""" - resident_dict, hospital_dict = _make_instances( - resident_prefs, hospital_prefs, capacities - ) + resident_dict, hospital_dict = _make_instances(resident_prefs, hospital_prefs, capacities) for resident_name, resident in resident_dict.items(): prefs = [hospital_dict[name] for name in resident_prefs[resident_name]] diff --git a/src/matching/games/stable_marriage.py b/src/matching/games/stable_marriage.py index a24e3ec..132a06f 100644 --- a/src/matching/games/stable_marriage.py +++ b/src/matching/games/stable_marriage.py @@ -54,9 +54,7 @@ def solve(self, optimal="suitor"): parameter. """ - self.matching = SingleMatching( - stable_marriage(self.suitors, self.reviewers, optimal) - ) + self.matching = SingleMatching(stable_marriage(self.suitors, self.reviewers, optimal)) return self.matching def check_validity(self): @@ -81,9 +79,9 @@ def check_stability(self): blocking_pairs = [] for suitor in self.suitors: for reviewer in self.reviewers: - if suitor.prefers( - reviewer, suitor.matching - ) and reviewer.prefers(suitor, reviewer.matching): + if suitor.prefers(reviewer, suitor.matching) and reviewer.prefers( + suitor, reviewer.matching + ): blocking_pairs.append((suitor, reviewer)) self.blocking_pairs = blocking_pairs @@ -103,9 +101,7 @@ def _check_for_unmatched_players(self): def _check_for_players_not_in_matching(self): """Check that everyone appears in the matching.""" - players_in_matching = set(self.matching.keys()) | set( - self.matching.values() - ) + players_in_matching = set(self.matching.keys()) | set(self.matching.values()) issues = [] for player in self.suitors + self.reviewers: @@ -140,9 +136,7 @@ def _check_num_players(self): """Check that the number of suitors and reviewers are equal.""" if len(self.suitors) != len(self.reviewers): - raise ValueError( - "There must be an equal number of suitors and reviewers." - ) + raise ValueError("There must be an equal number of suitors and reviewers.") return True diff --git a/src/matching/games/stable_roommates.py b/src/matching/games/stable_roommates.py index 678fac5..77701ba 100644 --- a/src/matching/games/stable_roommates.py +++ b/src/matching/games/stable_roommates.py @@ -75,9 +75,9 @@ def check_stability(self): for other in others: if (other, player) not in blocking_pairs: both_matched = player.matching and other.matching - prefer_each_other = player.prefers( - other, player.matching - ) and other.prefers(player, other.matching) + prefer_each_other = player.prefers(other, player.matching) and other.prefers( + player, other.matching + ) if both_matched and prefer_each_other: blocking_pairs.append((player, other)) diff --git a/src/matching/games/student_allocation.py b/src/matching/games/student_allocation.py index 0f576d0..bdd8693 100644 --- a/src/matching/games/student_allocation.py +++ b/src/matching/games/student_allocation.py @@ -63,9 +63,7 @@ class StudentAllocation(HospitalResident): """ def __init__(self, students, projects, supervisors, clean=False): - students, projects, supervisors = copy.deepcopy( - [students, projects, supervisors] - ) + students, projects, supervisors = copy.deepcopy([students, projects, supervisors]) self.students = students self.projects = projects self.supervisors = supervisors @@ -131,9 +129,7 @@ def solve(self, optimal="student"): """ self.matching = MultipleMatching( - student_allocation( - self.students, self.projects, self.supervisors, optimal - ) + student_allocation(self.students, self.projects, self.supervisors, optimal) ) return self.matching @@ -192,15 +188,11 @@ def check_inputs(self): self._check_inputs_player_prefs_nonempty("supervisors", "students") self._check_inputs_player_prefs_all_reciprocated("projects") - self._check_inputs_player_reciprocated_all_prefs( - "projects", "students" - ) + self._check_inputs_player_reciprocated_all_prefs("projects", "students") self._check_inputs_player_prefs_nonempty("projects", "students") self._check_inputs_player_prefs_all_reciprocated("supervisors") - self._check_inputs_player_reciprocated_all_prefs( - "supervisors", "students" - ) + self._check_inputs_player_reciprocated_all_prefs("supervisors", "students") self._check_inputs_player_prefs_nonempty("supervisors", "students") self._check_inputs_player_capacity("projects", "students") @@ -218,9 +210,7 @@ def _check_inputs_player_prefs_all_reciprocated(self, party): if party == "supervisors": for supervisor in self.supervisors: for student in supervisor.prefs: - student_prefs_supervisors = { - p.supervisor for p in student.prefs - } + student_prefs_supervisors = {p.supervisor for p in student.prefs} if supervisor not in student_prefs_supervisors: warnings.warn( PreferencesChangedWarning( @@ -248,10 +238,7 @@ def _check_inputs_player_reciprocated_all_prefs(self, party, other_party): students_that_ranked = [ student for student in self.students - if any( - project in student.prefs - for project in supervisor.projects - ) + if any(project in student.prefs for project in supervisor.projects) ] for student in students_that_ranked: @@ -264,15 +251,11 @@ def _check_inputs_player_reciprocated_all_prefs(self, party, other_party): ) if self.clean: - for project in set(supervisor.projects) & set( - student.prefs - ): + for project in set(supervisor.projects) & set(student.prefs): student._forget(project) else: - super()._check_inputs_player_reciprocated_all_prefs( - party, other_party - ) + super()._check_inputs_player_reciprocated_all_prefs(party, other_party) def _check_inputs_supervisor_capacities_sufficient(self): """Check each supervisor has space for its largest project.""" @@ -295,9 +278,7 @@ def _check_inputs_supervisor_capacities_necessary(self): """Check each supervisor has no surplus given their projects.""" for supervisor in self.supervisors: - total_project_capacity = sum( - p.capacity for p in supervisor.projects - ) + total_project_capacity = sum(p.capacity for p in supervisor.projects) if supervisor.capacity > total_project_capacity: warnings.warn( @@ -319,9 +300,7 @@ def _check_student_unhappy(student, project): their current match. """ - return student.matching is None or student.prefers( - project, student.matching - ) + return student.matching is None or student.prefers(project, student.matching) def _check_project_unhappy(project, student): @@ -341,8 +320,7 @@ def _check_project_unhappy(project, student): project_undersubscribed = len(project.matching) < project.capacity both_undersubscribed = ( - project_undersubscribed - and len(supervisor.matching) < supervisor.capacity + project_undersubscribed and len(supervisor.matching) < supervisor.capacity ) supervisor_full = len(supervisor.matching) == supervisor.capacity @@ -353,9 +331,7 @@ def _check_project_unhappy(project, student): project_upsetting_supervisor = len( project.matching - ) == project.capacity and supervisor.prefers( - student, project.get_worst_match() - ) + ) == project.capacity and supervisor.prefers(student, project.get_worst_match()) return ( both_undersubscribed diff --git a/src/matching/players/supervisor.py b/src/matching/players/supervisor.py index 421cc26..16d593e 100644 --- a/src/matching/players/supervisor.py +++ b/src/matching/players/supervisor.py @@ -60,9 +60,7 @@ def set_prefs(self, students): self._original_prefs = students[:] for project in self.projects: - acceptable = [ - student for student in students if project in student.prefs - ] + acceptable = [student for student in students if project in student.prefs] project.set_prefs(acceptable) def get_favourite(self): diff --git a/tests/base/test_matching.py b/tests/base/test_matching.py index 153e4e1..5132515 100644 --- a/tests/base/test_matching.py +++ b/tests/base/test_matching.py @@ -65,9 +65,7 @@ def test_getitem(dictionary): """Check that you can access items in a matching correctly.""" matching = BaseMatching(dictionary) - for (mkey, mval), (dkey, dval) in zip( - matching.items(), dictionary.items() - ): + for (mkey, mval), (dkey, dval) in zip(matching.items(), dictionary.items()): assert matching[mkey] == mval assert (mkey, mval) == (dkey, dval) diff --git a/tests/hospital_resident/test_algorithm.py b/tests/hospital_resident/test_algorithm.py index b1c6426..a4923e8 100644 --- a/tests/hospital_resident/test_algorithm.py +++ b/tests/hospital_resident/test_algorithm.py @@ -41,9 +41,7 @@ def test_resident_optimal(players_): assert all( [ r in set(residents) - for r in { - r_match for matches in matching.values() for r_match in matches - } + for r in {r_match for matches in matching.values() for r_match in matches} ] ) @@ -62,7 +60,7 @@ def test_hospital_optimal(players_): assert set(hospitals) == set(matching.keys()) for hospital, matches in matching.items(): - old_idx = -np.infty + old_idx = -np.inf for resident in matches: idx = hospital.prefs.index(resident) assert idx >= old_idx diff --git a/tests/hospital_resident/test_examples.py b/tests/hospital_resident/test_examples.py index 4f1c5e4..2b729d5 100644 --- a/tests/hospital_resident/test_examples.py +++ b/tests/hospital_resident/test_examples.py @@ -25,9 +25,7 @@ def test_readme_example(): capacities = {hosp: 2 for hosp in hospital_prefs} - game = HospitalResident.create_from_dictionaries( - resident_prefs, hospital_prefs, capacities - ) + game = HospitalResident.create_from_dictionaries(resident_prefs, hospital_prefs, capacities) (A, S, D, J, L), (M, C, G) = game.residents, game.hospitals matching = game.solve() @@ -52,9 +50,7 @@ def test_example_in_issue_67(): capacities = {t: 2 for t in topic_hospital_prefs} - game = HospitalResident.create_from_dictionaries( - group_prefs, topic_hospital_prefs, capacities - ) + game = HospitalResident.create_from_dictionaries(group_prefs, topic_hospital_prefs, capacities) (G1, G2, G3), (F, I, P, S) = game.residents, game.hospitals matching = game.solve() @@ -68,9 +64,7 @@ def test_resident_loses_all_preferences(): hospital_prefs = {"X": ["B", "A"], "Y": ["B"]} capacities = {"X": 1, "Y": 1} - game = HospitalResident.create_from_dictionaries( - resident_prefs, hospital_prefs, capacities - ) + game = HospitalResident.create_from_dictionaries(resident_prefs, hospital_prefs, capacities) (_, B), (X, Y) = game.residents, game.hospitals matching = game.solve() @@ -88,12 +82,8 @@ def test_example_in_issue_159(): with open(os.path.join(here, "data", "issue_159.json"), "r") as f: preferences = json.load(f) - resident_prefs = { - int(res): prefs for res, prefs in preferences["residents"].items() - } - hospital_prefs = { - int(hos): prefs for hos, prefs in preferences["hospitals"].items() - } + resident_prefs = {int(res): prefs for res, prefs in preferences["residents"].items()} + hospital_prefs = {int(hos): prefs for hos, prefs in preferences["hospitals"].items()} capacities = {hospital: 1 for hospital in hospital_prefs} diff --git a/tests/hospital_resident/test_solver.py b/tests/hospital_resident/test_solver.py index dfac0b0..e38368b 100644 --- a/tests/hospital_resident/test_solver.py +++ b/tests/hospital_resident/test_solver.py @@ -165,9 +165,7 @@ def test_check_inputs_hospital_reciprocated_all_prefs(game): hospital._forget(resident) with pytest.warns(PreferencesChangedWarning) as record: - game._check_inputs_player_reciprocated_all_prefs( - "hospitals", "residents" - ) + game._check_inputs_player_reciprocated_all_prefs("hospitals", "residents") assert len(record) == 1 @@ -259,13 +257,9 @@ def test_solve(game, optimal): assert game_hospital._pref_names == hospital._pref_names assert game_hospital.capacity == hospital.capacity - matched_residents = [ - resident for match in matching.values() for resident in match - ] + matched_residents = [resident for match in matching.values() for resident in match] - assert matched_residents != [] and set(matched_residents).issubset( - set(game.residents) - ) + assert matched_residents != [] and set(matched_residents).issubset(set(game.residents)) for resident in set(game.residents) - set(matched_residents): assert resident.matching is None diff --git a/tests/hospital_resident/util.py b/tests/hospital_resident/util.py index fb130df..eb6f4ec 100644 --- a/tests/hospital_resident/util.py +++ b/tests/hospital_resident/util.py @@ -43,9 +43,7 @@ def connections( resident_prefs = {} hospital_prefs = {h: [] for h in hospital_names} for resident in resident_names: - hospitals = draw( - lists(sampled_from(hospital_names), min_size=1, unique=True) - ) + hospitals = draw(lists(sampled_from(hospital_names), min_size=1, unique=True)) resident_prefs[resident] = hospitals for hospital in hospitals: hospital_prefs[hospital].append(resident) diff --git a/tests/stable_marriage/test_solver.py b/tests/stable_marriage/test_solver.py index 358bb90..8979e8f 100644 --- a/tests/stable_marriage/test_solver.py +++ b/tests/stable_marriage/test_solver.py @@ -16,15 +16,11 @@ def test_init(player_names, seed): suitors, reviewers = make_players(player_names, seed) game = StableMarriage(suitors, reviewers) - for player, game_player in zip( - suitors + reviewers, game.suitors + game.reviewers - ): + for player, game_player in zip(suitors + reviewers, game.suitors + game.reviewers): assert player.name == game_player.name assert player._pref_names == game_player._pref_names - assert all( - [player.matching is None for player in game.suitors + game.reviewers] - ) + assert all([player.matching is None for player in game.suitors + game.reviewers]) assert game.matching is None @@ -33,9 +29,7 @@ def test_create_from_dictionaries(player_names, seed): """Test for correct instantiation given a set of dictionaries.""" suitor_prefs, reviewer_prefs = make_prefs(player_names, seed) - game = StableMarriage.create_from_dictionaries( - suitor_prefs, reviewer_prefs - ) + game = StableMarriage.create_from_dictionaries(suitor_prefs, reviewer_prefs) for suitor in game.suitors: assert suitor_prefs[suitor.name] == suitor._pref_names diff --git a/tests/stable_marriage/util.py b/tests/stable_marriage/util.py index 566538e..718adbe 100644 --- a/tests/stable_marriage/util.py +++ b/tests/stable_marriage/util.py @@ -53,21 +53,15 @@ def make_prefs(player_names, seed): np.random.seed(seed) suitor_names, reviewer_names = player_names - suitor_prefs = { - name: np.random.permutation(reviewer_names).tolist() - for name in suitor_names - } + suitor_prefs = {name: np.random.permutation(reviewer_names).tolist() for name in suitor_names} reviewer_prefs = { - name: np.random.permutation(suitor_names).tolist() - for name in reviewer_names + name: np.random.permutation(suitor_names).tolist() for name in reviewer_names } return suitor_prefs, reviewer_prefs STABLE_MARRIAGE = given( - player_names=get_player_names( - suitor_pool=["A", "B", "C"], reviewer_pool=["X", "Y", "Z"] - ), + player_names=get_player_names(suitor_pool=["A", "B", "C"], reviewer_pool=["X", "Y", "Z"]), seed=integers(min_value=0, max_value=2**32 - 1), ) diff --git a/tests/stable_roommates/test_algorithm.py b/tests/stable_roommates/test_algorithm.py index bef68f9..a15b4d3 100644 --- a/tests/stable_roommates/test_algorithm.py +++ b/tests/stable_roommates/test_algorithm.py @@ -22,9 +22,7 @@ def test_first_phase(players): players = first_phase(players) - player_matched = { - player: player.matching is not None for player in players - } + player_matched = {player: player.matching is not None for player in players} assert sum(player_matched.values()) >= len(players) - 1 for player in players: diff --git a/tests/stable_roommates/test_examples.py b/tests/stable_roommates/test_examples.py index 2450acb..ecc12be 100644 --- a/tests/stable_roommates/test_examples.py +++ b/tests/stable_roommates/test_examples.py @@ -84,10 +84,7 @@ def test_large_example_from_book(): def test_example_in_issue_64(): """Test the example provided in #64.""" - players = [ - Player(name) - for name in ("charlie", "peter", "elise", "paul", "kelly", "sam") - ] + players = [Player(name) for name in ("charlie", "peter", "elise", "paul", "kelly", "sam")] charlie, peter, elise, paul, kelly, sam = players charlie.set_prefs([peter, paul, sam, kelly, elise]) diff --git a/tests/student_allocation/test_algorithm.py b/tests/student_allocation/test_algorithm.py index d2a8514..32a3e14 100644 --- a/tests/student_allocation/test_algorithm.py +++ b/tests/student_allocation/test_algorithm.py @@ -34,9 +34,7 @@ def test_student_allocation( @STUDENT_ALLOCATION -def test_student_optimal( - student_names, project_names, supervisor_names, capacities, seed, clean -): +def test_student_optimal(student_names, project_names, supervisor_names, capacities, seed, clean): """Test that the student-optimal algorithm is student-optimal.""" np.random.seed(seed) @@ -47,12 +45,7 @@ def test_student_optimal( assert set(projects) == set(matching.keys()) assert all( - [ - s in set(students) - for s in { - match for matches in matching.values() for match in matches - } - ] + [s in set(students) for s in {match for matches in matching.values() for match in matches}] ) for student in students: @@ -74,16 +67,11 @@ def test_supervisor_optimal( assert set(projects) == set(matching.keys()) assert all( - [ - s in set(students) - for s in { - match for matches in matching.values() for match in matches - } - ] + [s in set(students) for s in {match for matches in matching.values() for match in matches}] ) for supervisor in supervisors: - old_idx = -np.infty + old_idx = -np.inf for student in supervisor.matching: idx = supervisor.prefs.index(student) assert idx >= old_idx diff --git a/tests/student_allocation/test_examples.py b/tests/student_allocation/test_examples.py index bafb86f..f1dcbac 100644 --- a/tests/student_allocation/test_examples.py +++ b/tests/student_allocation/test_examples.py @@ -34,7 +34,5 @@ def test_example_in_docs(): a, b, c, d, e = game.students x1, x2, y1, y2 = game.projects - matching = student_allocation( - game.students, game.projects, game.supervisors - ) + matching = student_allocation(game.students, game.projects, game.supervisors) assert matching == {x1: [c, a], x2: [], y1: [d], y2: [b, e]} diff --git a/tests/student_allocation/test_solver.py b/tests/student_allocation/test_solver.py index f94297a..db02a9f 100644 --- a/tests/student_allocation/test_solver.py +++ b/tests/student_allocation/test_solver.py @@ -18,9 +18,7 @@ @STUDENT_ALLOCATION -def test_init( - student_names, project_names, supervisor_names, capacities, seed, clean -): +def test_init(student_names, project_names, supervisor_names, capacities, seed, clean): """Test for correct instantiation given some players.""" students, projects, supervisors, game = make_game( @@ -90,9 +88,7 @@ def test_remove_supervisor_and_projects( ): """Test that a supervisor and its projects can be removed.""" - *_, game = make_game( - student_names, project_names, supervisor_names, capacities, seed, clean - ) + *_, game = make_game(student_names, project_names, supervisor_names, capacities, seed, clean) supervisor = game.supervisors[0] projects = supervisor.projects @@ -103,14 +99,10 @@ def test_remove_supervisor_and_projects( @STUDENT_ALLOCATION -def test_remove_student( - student_names, project_names, supervisor_names, capacities, seed, clean -): +def test_remove_student(student_names, project_names, supervisor_names, capacities, seed, clean): """Test that a student can be removed.""" - *_, game = make_game( - student_names, project_names, supervisor_names, capacities, seed, clean - ) + *_, game = make_game(student_names, project_names, supervisor_names, capacities, seed, clean) student = game.students[0] @@ -119,14 +111,10 @@ def test_remove_student( @STUDENT_ALLOCATION -def test_check_inputs( - student_names, project_names, supervisor_names, capacities, seed, clean -): +def test_check_inputs(student_names, project_names, supervisor_names, capacities, seed, clean): """Test that inputs to an instance of SA can be verified.""" - *_, game = make_game( - student_names, project_names, supervisor_names, capacities, seed, clean - ) + *_, game = make_game(student_names, project_names, supervisor_names, capacities, seed, clean) with warnings.catch_warnings(record=True): warnings.simplefilter("error") @@ -147,9 +135,7 @@ def test_check_inputs_project_prefs_all_reciprocated( any such students. """ - *_, game = make_game( - student_names, project_names, supervisor_names, capacities, seed, clean - ) + *_, game = make_game(student_names, project_names, supervisor_names, capacities, seed, clean) project = game.projects[0] student = project.prefs[0] @@ -179,9 +165,7 @@ def test_check_inputs_supervisor_prefs_all_reciprocated( projects have forgotten any such students. """ - *_, game = make_game( - student_names, project_names, supervisor_names, capacities, seed, clean - ) + *_, game = make_game(student_names, project_names, supervisor_names, capacities, seed, clean) supervisor = game.supervisors[0] student = supervisor.prefs[0] @@ -202,9 +186,7 @@ def test_check_inputs_supervisor_prefs_all_reciprocated( if clean: assert student not in supervisor.prefs - assert all( - student not in project.prefs for project in supervisor.projects - ) + assert all(student not in project.prefs for project in supervisor.projects) @STUDENT_ALLOCATION @@ -217,18 +199,14 @@ def test_check_inputs_project_reciprocated_all_prefs( forgotten the project. """ - *_, game = make_game( - student_names, project_names, supervisor_names, capacities, seed, clean - ) + *_, game = make_game(student_names, project_names, supervisor_names, capacities, seed, clean) project = game.projects[0] student = project.prefs[0] project._forget(student) with pytest.warns(PreferencesChangedWarning) as record: - game._check_inputs_player_reciprocated_all_prefs( - "projects", "students" - ) + game._check_inputs_player_reciprocated_all_prefs("projects", "students") assert len(record) == 1 @@ -252,18 +230,14 @@ def test_check_inputs_supervisor_reciprocated_all_prefs( forgotten all projects belonging to that supervisor. """ - *_, game = make_game( - student_names, project_names, supervisor_names, capacities, seed, clean - ) + *_, game = make_game(student_names, project_names, supervisor_names, capacities, seed, clean) supervisor = game.supervisors[0] student = supervisor.prefs[0] supervisor.prefs.remove(student) with pytest.warns(PreferencesChangedWarning) as record: - game._check_inputs_player_reciprocated_all_prefs( - "supervisors", "students" - ) + game._check_inputs_player_reciprocated_all_prefs("supervisors", "students") assert len(record) == 1 @@ -274,9 +248,7 @@ def test_check_inputs_supervisor_reciprocated_all_prefs( if clean: assert supervisor not in student.prefs - assert all( - project not in student.prefs for project in supervisor.projects - ) + assert all(project not in student.prefs for project in supervisor.projects) @STUDENT_ALLOCATION @@ -289,9 +261,7 @@ def test_check_inputs_supervisor_capacities_sufficient( updated to their supervisor's. """ - *_, game = make_game( - student_names, project_names, supervisor_names, capacities, seed, clean - ) + *_, game = make_game(student_names, project_names, supervisor_names, capacities, seed, clean) project = game.projects[0] supervisor_capacity = project.supervisor.capacity @@ -322,9 +292,7 @@ def test_check_inputs_supervisor_capacities_necessary( updated to be the sum of its projects. """ - *_, game = make_game( - student_names, project_names, supervisor_names, capacities, seed, clean - ) + *_, game = make_game(student_names, project_names, supervisor_names, capacities, seed, clean) supervisor = game.supervisors[0] total_project_capacity = sum(p.capacity for p in supervisor.projects) @@ -346,9 +314,7 @@ def test_check_inputs_supervisor_capacities_necessary( @STUDENT_ALLOCATION -def test_solve( - student_names, project_names, supervisor_names, capacities, seed, clean -): +def test_solve(student_names, project_names, supervisor_names, capacities, seed, clean): """Test that the class can solve games correctly.""" for optimal in ["student", "supervisor"]: @@ -372,12 +338,8 @@ def test_solve( assert game_project.capacity == project.capacity assert game_project.supervisor.name == project.supervisor.name - matched_students = [ - stud for match in matching.values() for stud in match - ] - assert matched_students != [] and set(matched_students).issubset( - set(game.students) - ) + matched_students = [stud for match in matching.values() for stud in match] + assert matched_students != [] and set(matched_students).issubset(set(game.students)) for student in matched_students: supervisor = student.matching.supervisor @@ -388,14 +350,10 @@ def test_solve( @STUDENT_ALLOCATION -def test_check_validity( - student_names, project_names, supervisor_names, capacities, seed, clean -): +def test_check_validity(student_names, project_names, supervisor_names, capacities, seed, clean): """Test for a valid matching when the game is solved.""" - *_, game = make_game( - student_names, project_names, supervisor_names, capacities, seed, clean - ) + *_, game = make_game(student_names, project_names, supervisor_names, capacities, seed, clean) game.solve() assert game.check_validity() @@ -407,9 +365,7 @@ def test_check_for_unacceptable_matches_students( ): """Test that each matched student must have ranked their match.""" - *_, game = make_game( - student_names, project_names, supervisor_names, capacities, seed, clean - ) + *_, game = make_game(student_names, project_names, supervisor_names, capacities, seed, clean) game.solve() student = game.students[0] @@ -430,9 +386,7 @@ def test_check_for_unacceptable_matches_projects( ): """Test that each project must rank all their matches.""" - *_, game = make_game( - student_names, project_names, supervisor_names, capacities, seed, clean - ) + *_, game = make_game(student_names, project_names, supervisor_names, capacities, seed, clean) game.solve() project = game.projects[0] @@ -453,9 +407,7 @@ def test_check_for_unacceptable_matches_supervisors( ): """Test that each supervisor must rank all their matches.""" - *_, game = make_game( - student_names, project_names, supervisor_names, capacities, seed, clean - ) + *_, game = make_game(student_names, project_names, supervisor_names, capacities, seed, clean) game.solve() supervisor = game.supervisors[0] @@ -476,9 +428,7 @@ def test_check_for_oversubscribed_projects( ): """Test that all projects must not be over-subscribed.""" - *_, game = make_game( - student_names, project_names, supervisor_names, capacities, seed, clean - ) + *_, game = make_game(student_names, project_names, supervisor_names, capacities, seed, clean) game.solve() project = game.projects[0] @@ -498,9 +448,7 @@ def test_check_for_oversubscribed_supervisors( ): """Test that all supervisors must not be over-subscribed.""" - *_, game = make_game( - student_names, project_names, supervisor_names, capacities, seed, clean - ) + *_, game = make_game(student_names, project_names, supervisor_names, capacities, seed, clean) game.solve() supervisor = game.supervisors[0] diff --git a/tests/student_allocation/util.py b/tests/student_allocation/util.py index 7545ccd..46fe5ee 100644 --- a/tests/student_allocation/util.py +++ b/tests/student_allocation/util.py @@ -15,15 +15,9 @@ def get_possible_prefs(players): """Get list of possible non-empty preferences from some players.""" - all_ordered_subsets = { - tuple(set(sub)) for sub in it.product(players, repeat=len(players)) - } + all_ordered_subsets = {tuple(set(sub)) for sub in it.product(players, repeat=len(players))} - possible_prefs = [ - list(perm) - for sub in all_ordered_subsets - for perm in it.permutations(sub) - ] + possible_prefs = [list(perm) for sub in all_ordered_subsets for perm in it.permutations(sub)] return possible_prefs @@ -32,12 +26,8 @@ def make_players(student_names, project_names, supervisor_names, capacities): """Given some names and capacities, make a set of players for SA.""" students = [Student(name) for name in student_names] - projects = [ - Project(name, cap) for name, cap in zip(project_names, capacities) - ] - supervisors = [ - Supervisor(name, capacity=None) for name in supervisor_names - ] + projects = [Project(name, cap) for name, cap in zip(project_names, capacities)] + supervisors = [Supervisor(name, capacity=None) for name in supervisor_names] if len(students) > len(projects): students = students[: len(projects)] @@ -45,9 +35,7 @@ def make_players(student_names, project_names, supervisor_names, capacities): for project in projects: project.set_supervisor(np.random.choice(supervisors)) - supervisors = [ - supervisor for supervisor in supervisors if supervisor.projects - ] + supervisors = [supervisor for supervisor in supervisors if supervisor.projects] for supervisor in supervisors: capacities = sorted([proj.capacity for proj in supervisor.projects]) min_cap, max_cap = max(capacities), sum(capacities) @@ -72,9 +60,7 @@ def make_players(student_names, project_names, supervisor_names, capacities): return students, projects, supervisors -def make_game( - student_names, project_names, supervisor_names, capacities, seed, clean -): +def make_game(student_names, project_names, supervisor_names, capacities, seed, clean): """Make all of the players and the game itself.""" np.random.seed(seed) @@ -86,9 +72,7 @@ def make_game( return students, projects, supervisors, game -def make_connections( - student_names, project_names, supervisor_names, capacities, seed -): +def make_connections(student_names, project_names, supervisor_names, capacities, seed): """Make a set of preferences and affiliations from some names.""" np.random.seed(seed) @@ -114,9 +98,7 @@ def make_connections( if student not in sup_prefs: sup_prefs.append(student) - chosen_projects = { - p for projects in student_prefs.values() for p in projects - } + chosen_projects = {p for projects in student_prefs.values() for p in projects} for project in set(project_names) - chosen_projects: del project_supervisors[project] del project_capacities[project] @@ -161,9 +143,7 @@ def make_connections( max_size=3, unique=True, ), - capacities=lists( - integers(min_value=1, max_value=2), min_size=5, max_size=5 - ), + capacities=lists(integers(min_value=1, max_value=2), min_size=5, max_size=5), seed=integers(min_value=0, max_value=2**32 - 1), clean=booleans(), ) diff --git a/tests/test_matchings.py b/tests/test_matchings.py index e93f352..733a1ee 100644 --- a/tests/test_matchings.py +++ b/tests/test_matchings.py @@ -42,9 +42,7 @@ def multiples( num_hosts = draw(integers(min_value=min_hosts, max_value=max_hosts)) num_players = draw(integers(min_value=min_players, max_value=max_players)) - hosts = [ - Hospital(draw(host_names_from), max_players) for _ in range(num_hosts) - ] + hosts = [Hospital(draw(host_names_from), max_players) for _ in range(num_hosts)] players = [Player(draw(player_names_from)) for _ in range(num_players)] dictionary = {} @@ -87,9 +85,7 @@ def test_multiple_setitem(dictionary): matching = MultipleMatching(dictionary) host = list(dictionary.keys())[0] - players = list( - {player for players in dictionary.values() for player in players} - )[:-1] + players = list({player for players in dictionary.values() for player in players})[:-1] matching[host] = players assert matching[host] == players diff --git a/uv.lock b/uv.lock new file mode 100644 index 0000000..54b726c --- /dev/null +++ b/uv.lock @@ -0,0 +1,6060 @@ +version = 1 +requires-python = ">=3.7" +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", + "python_full_version == '3.10.*'", + "python_full_version == '3.9.*'", + "python_full_version == '3.8.*'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine != 'aarch64' and platform_machine != 'arm64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'aarch64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'arm64'", + "python_full_version < '3.7.1'", +] + +[[package]] +name = "alabaster" +version = "0.7.13" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version == '3.8.*'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine != 'aarch64' and platform_machine != 'arm64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'aarch64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'arm64'", + "python_full_version < '3.7.1'", +] +sdist = { url = "https://files.pythonhosted.org/packages/94/71/a8ee96d1fd95ca04a0d2e2d9c4081dac4c2d2b12f7ddb899c8cb9bfd1532/alabaster-0.7.13.tar.gz", hash = "sha256:a27a4a084d5e690e16e01e03ad2b2e552c61a65469419b907243193de1a84ae2", size = 11454 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/64/88/c7083fc61120ab661c5d0b82cb77079fc1429d3f913a456c1c82cf4658f7/alabaster-0.7.13-py3-none-any.whl", hash = "sha256:1ee19aca801bbabb5ba3f5f258e4422dfa86f82f3e9cefb0859b283cdd7f62a3", size = 13857 }, +] + +[[package]] +name = "alabaster" +version = "0.7.16" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version == '3.9.*'", +] +sdist = { url = "https://files.pythonhosted.org/packages/c9/3e/13dd8e5ed9094e734ac430b5d0eb4f2bb001708a8b7856cbf8e084e001ba/alabaster-0.7.16.tar.gz", hash = "sha256:75a8b99c28a5dad50dd7f8ccdd447a121ddb3892da9e53d1ca5cca3106d58d65", size = 23776 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/32/34/d4e1c02d3bee589efb5dfa17f88ea08bdb3e3eac12bc475462aec52ed223/alabaster-0.7.16-py3-none-any.whl", hash = "sha256:b46733c07dce03ae4e150330b975c75737fa60f0a7c591b6c8bf4928a28e2c92", size = 13511 }, +] + +[[package]] +name = "alabaster" +version = "1.0.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", + "python_full_version == '3.10.*'", +] +sdist = { url = "https://files.pythonhosted.org/packages/a6/f8/d9c74d0daf3f742840fd818d69cfae176fa332022fd44e3469487d5a9420/alabaster-1.0.0.tar.gz", hash = "sha256:c00dca57bca26fa62a6d7d0a9fcce65f3e026e9bfe33e9c538fd3fbb2144fd9e", size = 24210 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7e/b3/6b4067be973ae96ba0d615946e314c5ae35f9f993eca561b356540bb0c2b/alabaster-1.0.0-py3-none-any.whl", hash = "sha256:fc6786402dc3fcb2de3cabd5fe455a2db534b371124f1f21de8731783dec828b", size = 13929 }, +] + +[[package]] +name = "annotated-types" +version = "0.7.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ee/67/531ea369ba64dcff5ec9c3402f9f51bf748cec26dde048a2f973a4eea7f5/annotated_types-0.7.0.tar.gz", hash = "sha256:aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89", size = 16081 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53", size = 13643 }, +] + +[[package]] +name = "appnope" +version = "0.1.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/35/5d/752690df9ef5b76e169e68d6a129fa6d08a7100ca7f754c89495db3c6019/appnope-0.1.4.tar.gz", hash = "sha256:1de3860566df9caf38f01f86f65e0e13e379af54f9e4bee1e66b48f2efffd1ee", size = 4170 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/81/29/5ecc3a15d5a33e31b26c11426c45c501e439cb865d0bff96315d86443b78/appnope-0.1.4-py2.py3-none-any.whl", hash = "sha256:502575ee11cd7a28c0205f379b525beefebab9d161b7c964670864014ed7213c", size = 4321 }, +] + +[[package]] +name = "asttokens" +version = "3.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/4a/e7/82da0a03e7ba5141f05cce0d302e6eed121ae055e0456ca228bf693984bc/asttokens-3.0.0.tar.gz", hash = "sha256:0dcd8baa8d62b0c1d118b399b2ddba3c4aff271d0d7a9e0d4c1681c79035bbc7", size = 61978 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/25/8a/c46dcc25341b5bce5472c718902eb3d38600a903b14fa6aeecef3f21a46f/asttokens-3.0.0-py3-none-any.whl", hash = "sha256:e3078351a059199dd5138cb1c706e6430c05eff2ff136af5eb4790f9d28932e2", size = 26918 }, +] + +[[package]] +name = "attrs" +version = "24.2.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine != 'aarch64' and platform_machine != 'arm64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'aarch64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'arm64'", + "python_full_version < '3.7.1'", +] +dependencies = [ + { name = "importlib-metadata", version = "6.7.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/fc/0f/aafca9af9315aee06a89ffde799a10a582fe8de76c563ee80bbcdc08b3fb/attrs-24.2.0.tar.gz", hash = "sha256:5cfb1b9148b5b086569baec03f20d7b6bf3bcacc9a42bebf87ffaaca362f6346", size = 792678 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/6a/21/5b6702a7f963e95456c0de2d495f67bf5fd62840ac655dc451586d23d39a/attrs-24.2.0-py3-none-any.whl", hash = "sha256:81921eb96de3191c8258c199618104dd27ac608d9366f5e35d011eae1867ede2", size = 63001 }, +] + +[[package]] +name = "attrs" +version = "25.3.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", + "python_full_version == '3.10.*'", + "python_full_version == '3.9.*'", + "python_full_version == '3.8.*'", +] +sdist = { url = "https://files.pythonhosted.org/packages/5a/b0/1367933a8532ee6ff8d63537de4f1177af4bff9f3e829baf7331f595bb24/attrs-25.3.0.tar.gz", hash = "sha256:75d7cefc7fb576747b2c81b4442d4d4a1ce0900973527c011d1030fd3bf4af1b", size = 812032 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/77/06/bb80f5f86020c4551da315d78b3ab75e8228f89f0162f2c3a819e407941a/attrs-25.3.0-py3-none-any.whl", hash = "sha256:427318ce031701fea540783410126f03899a97ffc6f61596ad581ac2e40e3bc3", size = 63815 }, +] + +[[package]] +name = "babel" +version = "2.14.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine != 'aarch64' and platform_machine != 'arm64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'aarch64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'arm64'", + "python_full_version < '3.7.1'", +] +dependencies = [ + { name = "pytz", marker = "python_full_version < '3.8'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/e2/80/cfbe44a9085d112e983282ee7ca4c00429bc4d1ce86ee5f4e60259ddff7f/Babel-2.14.0.tar.gz", hash = "sha256:6919867db036398ba21eb5c7a0f6b28ab8cbc3ae7a73a44ebe34ae74a4e7d363", size = 10795622 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0d/35/4196b21041e29a42dc4f05866d0c94fa26c9da88ce12c38c2265e42c82fb/Babel-2.14.0-py3-none-any.whl", hash = "sha256:efb1a25b7118e67ce3a259bed20545c29cb68be8ad2c784c83689981b7a57287", size = 11034798 }, +] + +[[package]] +name = "babel" +version = "2.17.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", + "python_full_version == '3.10.*'", + "python_full_version == '3.9.*'", + "python_full_version == '3.8.*'", +] +dependencies = [ + { name = "pytz", marker = "python_full_version == '3.8.*'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/7d/6b/d52e42361e1aa00709585ecc30b3f9684b3ab62530771402248b1b1d6240/babel-2.17.0.tar.gz", hash = "sha256:0c54cffb19f690cdcc52a3b50bcbf71e07a808d1c80d549f2459b9d2cf0afb9d", size = 9951852 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b7/b8/3fe70c75fe32afc4bb507f75563d39bc5642255d1d94f1f23604725780bf/babel-2.17.0-py3-none-any.whl", hash = "sha256:4d0b53093fdfb4b21c92b5213dba5a1b23885afa8383709427046b21c366e5f2", size = 10182537 }, +] + +[[package]] +name = "backcall" +version = "0.2.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a2/40/764a663805d84deee23043e1426a9175567db89c8b3287b5c2ad9f71aa93/backcall-0.2.0.tar.gz", hash = "sha256:5cbdbf27be5e7cfadb448baf0aa95508f91f2bbc6c6437cd9cd06e2a4c215e1e", size = 18041 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4c/1c/ff6546b6c12603d8dd1070aa3c3d273ad4c07f5771689a7b69a550e8c951/backcall-0.2.0-py2.py3-none-any.whl", hash = "sha256:fbbce6a29f263178a1f7915c1940bde0ec2b2a967566fe1c65c1dfb7422bd255", size = 11157 }, +] + +[[package]] +name = "beartype" +version = "0.20.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/7d/48/fe1177f4272a1bc344f3371414aa5b76e19c30d7280d711ce90c5335a6f5/beartype-0.20.0.tar.gz", hash = "sha256:599ecc86b88549bcb6d1af626f44d85ffbb9151ace5d7f9f3b493dce2ffee529", size = 1390635 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/61/ce/9cf60b72e3fbd36a6dd16e31ecbe9ae137a8ead77cb24a5f75302adfc9a9/beartype-0.20.0-py3-none-any.whl", hash = "sha256:090d10e3540b3fca209a0ab5f1c15f9652a075da0a7249c2e6713011e9e5f6ef", size = 1139097 }, +] + +[[package]] +name = "beautifulsoup4" +version = "4.13.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "soupsieve", version = "2.4.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, + { name = "soupsieve", version = "2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.8'" }, + { name = "typing-extensions", version = "4.7.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, + { name = "typing-extensions", version = "4.12.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.8'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/f0/3c/adaf39ce1fb4afdd21b611e3d530b183bb7759c9b673d60db0e347fd4439/beautifulsoup4-4.13.3.tar.gz", hash = "sha256:1bd32405dacc920b42b83ba01644747ed77456a65760e285fbc47633ceddaf8b", size = 619516 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f9/49/6abb616eb3cbab6a7cca303dc02fdf3836de2e0b834bf966a7f5271a34d8/beautifulsoup4-4.13.3-py3-none-any.whl", hash = "sha256:99045d7d3f08f91f0d656bc9b7efbae189426cd913d830294a15eefa0ea4df16", size = 186015 }, +] + +[[package]] +name = "black" +version = "25.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "click", marker = "python_full_version >= '3.9'" }, + { name = "mypy-extensions", marker = "python_full_version >= '3.9'" }, + { name = "packaging", version = "24.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.9'" }, + { name = "pathspec", marker = "python_full_version >= '3.9'" }, + { name = "platformdirs", version = "4.3.7", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.9'" }, + { name = "tomli", version = "2.2.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.9' and python_full_version < '3.11'" }, + { name = "typing-extensions", version = "4.12.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.9' and python_full_version < '3.11'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/94/49/26a7b0f3f35da4b5a65f081943b7bcd22d7002f5f0fb8098ec1ff21cb6ef/black-25.1.0.tar.gz", hash = "sha256:33496d5cd1222ad73391352b4ae8da15253c5de89b93a80b3e2c8d9a19ec2666", size = 649449 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4d/3b/4ba3f93ac8d90410423fdd31d7541ada9bcee1df32fb90d26de41ed40e1d/black-25.1.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:759e7ec1e050a15f89b770cefbf91ebee8917aac5c20483bc2d80a6c3a04df32", size = 1629419 }, + { url = "https://files.pythonhosted.org/packages/b4/02/0bde0485146a8a5e694daed47561785e8b77a0466ccc1f3e485d5ef2925e/black-25.1.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:0e519ecf93120f34243e6b0054db49c00a35f84f195d5bce7e9f5cfc578fc2da", size = 1461080 }, + { url = "https://files.pythonhosted.org/packages/52/0e/abdf75183c830eaca7589144ff96d49bce73d7ec6ad12ef62185cc0f79a2/black-25.1.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:055e59b198df7ac0b7efca5ad7ff2516bca343276c466be72eb04a3bcc1f82d7", size = 1766886 }, + { url = "https://files.pythonhosted.org/packages/dc/a6/97d8bb65b1d8a41f8a6736222ba0a334db7b7b77b8023ab4568288f23973/black-25.1.0-cp310-cp310-win_amd64.whl", hash = "sha256:db8ea9917d6f8fc62abd90d944920d95e73c83a5ee3383493e35d271aca872e9", size = 1419404 }, + { url = "https://files.pythonhosted.org/packages/7e/4f/87f596aca05c3ce5b94b8663dbfe242a12843caaa82dd3f85f1ffdc3f177/black-25.1.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:a39337598244de4bae26475f77dda852ea00a93bd4c728e09eacd827ec929df0", size = 1614372 }, + { url = "https://files.pythonhosted.org/packages/e7/d0/2c34c36190b741c59c901e56ab7f6e54dad8df05a6272a9747ecef7c6036/black-25.1.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:96c1c7cd856bba8e20094e36e0f948718dc688dba4a9d78c3adde52b9e6c2299", size = 1442865 }, + { url = "https://files.pythonhosted.org/packages/21/d4/7518c72262468430ead45cf22bd86c883a6448b9eb43672765d69a8f1248/black-25.1.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bce2e264d59c91e52d8000d507eb20a9aca4a778731a08cfff7e5ac4a4bb7096", size = 1749699 }, + { url = "https://files.pythonhosted.org/packages/58/db/4f5beb989b547f79096e035c4981ceb36ac2b552d0ac5f2620e941501c99/black-25.1.0-cp311-cp311-win_amd64.whl", hash = "sha256:172b1dbff09f86ce6f4eb8edf9dede08b1fce58ba194c87d7a4f1a5aa2f5b3c2", size = 1428028 }, + { url = "https://files.pythonhosted.org/packages/83/71/3fe4741df7adf015ad8dfa082dd36c94ca86bb21f25608eb247b4afb15b2/black-25.1.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:4b60580e829091e6f9238c848ea6750efed72140b91b048770b64e74fe04908b", size = 1650988 }, + { url = "https://files.pythonhosted.org/packages/13/f3/89aac8a83d73937ccd39bbe8fc6ac8860c11cfa0af5b1c96d081facac844/black-25.1.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:1e2978f6df243b155ef5fa7e558a43037c3079093ed5d10fd84c43900f2d8ecc", size = 1453985 }, + { url = "https://files.pythonhosted.org/packages/6f/22/b99efca33f1f3a1d2552c714b1e1b5ae92efac6c43e790ad539a163d1754/black-25.1.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3b48735872ec535027d979e8dcb20bf4f70b5ac75a8ea99f127c106a7d7aba9f", size = 1783816 }, + { url = "https://files.pythonhosted.org/packages/18/7e/a27c3ad3822b6f2e0e00d63d58ff6299a99a5b3aee69fa77cd4b0076b261/black-25.1.0-cp312-cp312-win_amd64.whl", hash = "sha256:ea0213189960bda9cf99be5b8c8ce66bb054af5e9e861249cd23471bd7b0b3ba", size = 1440860 }, + { url = "https://files.pythonhosted.org/packages/98/87/0edf98916640efa5d0696e1abb0a8357b52e69e82322628f25bf14d263d1/black-25.1.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8f0b18a02996a836cc9c9c78e5babec10930862827b1b724ddfe98ccf2f2fe4f", size = 1650673 }, + { url = "https://files.pythonhosted.org/packages/52/e5/f7bf17207cf87fa6e9b676576749c6b6ed0d70f179a3d812c997870291c3/black-25.1.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:afebb7098bfbc70037a053b91ae8437c3857482d3a690fefc03e9ff7aa9a5fd3", size = 1453190 }, + { url = "https://files.pythonhosted.org/packages/e3/ee/adda3d46d4a9120772fae6de454c8495603c37c4c3b9c60f25b1ab6401fe/black-25.1.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:030b9759066a4ee5e5aca28c3c77f9c64789cdd4de8ac1df642c40b708be6171", size = 1782926 }, + { url = "https://files.pythonhosted.org/packages/cc/64/94eb5f45dcb997d2082f097a3944cfc7fe87e071907f677e80788a2d7b7a/black-25.1.0-cp313-cp313-win_amd64.whl", hash = "sha256:a22f402b410566e2d1c950708c77ebf5ebd5d0d88a6a2e87c86d9fb48afa0d18", size = 1442613 }, + { url = "https://files.pythonhosted.org/packages/d3/b6/ae7507470a4830dbbfe875c701e84a4a5fb9183d1497834871a715716a92/black-25.1.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:a1ee0a0c330f7b5130ce0caed9936a904793576ef4d2b98c40835d6a65afa6a0", size = 1628593 }, + { url = "https://files.pythonhosted.org/packages/24/c1/ae36fa59a59f9363017ed397750a0cd79a470490860bc7713967d89cdd31/black-25.1.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:f3df5f1bf91d36002b0a75389ca8663510cf0531cca8aa5c1ef695b46d98655f", size = 1460000 }, + { url = "https://files.pythonhosted.org/packages/ac/b6/98f832e7a6c49aa3a464760c67c7856363aa644f2f3c74cf7d624168607e/black-25.1.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d9e6827d563a2c820772b32ce8a42828dc6790f095f441beef18f96aa6f8294e", size = 1765963 }, + { url = "https://files.pythonhosted.org/packages/ce/e9/2cb0a017eb7024f70e0d2e9bdb8c5a5b078c5740c7f8816065d06f04c557/black-25.1.0-cp39-cp39-win_amd64.whl", hash = "sha256:bacabb307dca5ebaf9c118d2d2f6903da0d62c9faa82bd21a33eecc319559355", size = 1419419 }, + { url = "https://files.pythonhosted.org/packages/09/71/54e999902aed72baf26bca0d50781b01838251a462612966e9fc4891eadd/black-25.1.0-py3-none-any.whl", hash = "sha256:95e8176dae143ba9097f351d174fdaf0ccd29efb414b362ae3fd72bf0f710717", size = 207646 }, +] + +[[package]] +name = "bleach" +version = "6.0.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine != 'aarch64' and platform_machine != 'arm64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'aarch64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'arm64'", + "python_full_version < '3.7.1'", +] +dependencies = [ + { name = "six", marker = "python_full_version < '3.8'" }, + { name = "webencodings", marker = "python_full_version < '3.8'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/7e/e6/d5f220ca638f6a25557a611860482cb6e54b2d97f0332966b1b005742e1f/bleach-6.0.0.tar.gz", hash = "sha256:1a1a85c1595e07d8db14c5f09f09e6433502c51c595970edc090551f0db99414", size = 201298 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ac/e2/dfcab68c9b2e7800c8f06b85c76e5f978d05b195a958daa9b1dda54a1db6/bleach-6.0.0-py3-none-any.whl", hash = "sha256:33c16e3353dbd13028ab4799a0f89a83f113405c766e9c122df8a06f5b85b3f4", size = 162493 }, +] + +[[package]] +name = "bleach" +version = "6.1.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version == '3.8.*'", +] +dependencies = [ + { name = "six", marker = "python_full_version == '3.8.*'" }, + { name = "webencodings", marker = "python_full_version == '3.8.*'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/6d/10/77f32b088738f40d4f5be801daa5f327879eadd4562f36a2b5ab975ae571/bleach-6.1.0.tar.gz", hash = "sha256:0a31f1837963c41d46bbf1331b8778e1308ea0791db03cc4e7357b97cf42a8fe", size = 202119 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ea/63/da7237f805089ecc28a3f36bca6a21c31fcbc2eb380f3b8f1be3312abd14/bleach-6.1.0-py3-none-any.whl", hash = "sha256:3225f354cfc436b9789c66c4ee030194bee0568fbf9cbdad3bc8b5c26c5f12b6", size = 162750 }, +] + +[package.optional-dependencies] +css = [ + { name = "tinycss2", version = "1.2.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.8.*'" }, +] + +[[package]] +name = "bleach" +version = "6.2.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", + "python_full_version == '3.10.*'", + "python_full_version == '3.9.*'", +] +dependencies = [ + { name = "webencodings", marker = "python_full_version >= '3.9'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/76/9a/0e33f5054c54d349ea62c277191c020c2d6ef1d65ab2cb1993f91ec846d1/bleach-6.2.0.tar.gz", hash = "sha256:123e894118b8a599fd80d3ec1a6d4cc7ce4e5882b1317a7e1ba69b56e95f991f", size = 203083 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fc/55/96142937f66150805c25c4d0f31ee4132fd33497753400734f9dfdcbdc66/bleach-6.2.0-py3-none-any.whl", hash = "sha256:117d9c6097a7c3d22fd578fcd8d35ff1e125df6736f554da4e432fdd63f31e5e", size = 163406 }, +] + +[package.optional-dependencies] +css = [ + { name = "tinycss2", version = "1.4.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.9'" }, +] + +[[package]] +name = "certifi" +version = "2025.1.31" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/1c/ab/c9f1e32b7b1bf505bf26f0ef697775960db7932abeb7b516de930ba2705f/certifi-2025.1.31.tar.gz", hash = "sha256:3d5da6925056f6f18f119200434a4780a94263f10d1c21d032a6f6b2baa20651", size = 167577 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/38/fc/bce832fd4fd99766c04d1ee0eead6b0ec6486fb100ae5e74c1d91292b982/certifi-2025.1.31-py3-none-any.whl", hash = "sha256:ca78db4565a652026a4db2bcdf68f2fb589ea80d0be70e03929ed730746b84fe", size = 166393 }, +] + +[[package]] +name = "cffi" +version = "1.15.1" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine != 'aarch64' and platform_machine != 'arm64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'aarch64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'arm64'", + "python_full_version < '3.7.1'", +] +dependencies = [ + { name = "pycparser", version = "2.21", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/2b/a8/050ab4f0c3d4c1b8aaa805f70e26e84d0e27004907c5b8ecc1d31815f92a/cffi-1.15.1.tar.gz", hash = "sha256:d400bfb9a37b1351253cb402671cea7e89bdecc294e8016a707f6d1d8ac934f9", size = 508501 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e8/ff/c4b7a358526f231efa46a375c959506c87622fb4a2c5726e827c55e6adf2/cffi-1.15.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:39d39875251ca8f612b6f33e6b1195af86d1b3e60086068be9cc053aa4376e21", size = 179233 }, + { url = "https://files.pythonhosted.org/packages/ea/be/c4ad40ad441ac847b67c7a37284ae3c58f39f3e638c6b0f85fb662233825/cffi-1.15.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:285d29981935eb726a4399badae8f0ffdff4f5050eaa6d0cfc3f64b857b77185", size = 174280 }, + { url = "https://files.pythonhosted.org/packages/ed/a3/c5f01988ddb70a187c3e6112152e01696188c9f8a4fa4c68aa330adbb179/cffi-1.15.1-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3eb6971dcff08619f8d91607cfc726518b6fa2a9eba42856be181c6d0d9515fd", size = 421712 }, + { url = "https://files.pythonhosted.org/packages/ef/41/19da352d341963d29a33bdb28433ba94c05672fb16155f794fad3fd907b0/cffi-1.15.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:21157295583fe8943475029ed5abdcf71eb3911894724e360acff1d61c1d54bc", size = 449886 }, + { url = "https://files.pythonhosted.org/packages/af/da/9441d56d7dd19d07dcc40a2a5031a1f51c82a27cee3705edf53dadcac398/cffi-1.15.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5635bd9cb9731e6d4a1132a498dd34f764034a8ce60cef4f5319c0541159392f", size = 450520 }, + { url = "https://files.pythonhosted.org/packages/aa/02/ab15b3aa572759df752491d5fa0f74128cd14e002e8e3257c1ab1587810b/cffi-1.15.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2012c72d854c2d03e45d06ae57f40d78e5770d252f195b93f581acf3ba44496e", size = 446015 }, + { url = "https://files.pythonhosted.org/packages/88/89/c34caf63029fb7628ec2ebd5c88ae0c9bd17db98c812e4065a4d020ca41f/cffi-1.15.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dd86c085fae2efd48ac91dd7ccffcfc0571387fe1193d33b6394db7ef31fe2a4", size = 441830 }, + { url = "https://files.pythonhosted.org/packages/32/bd/d0809593f7976828f06a492716fbcbbfb62798bbf60ea1f65200b8d49901/cffi-1.15.1-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:fa6693661a4c91757f4412306191b6dc88c1703f780c8234035eac011922bc01", size = 434743 }, + { url = "https://files.pythonhosted.org/packages/0e/65/0d7b5dad821ced4dcd43f96a362905a68ce71e6b5f5cfd2fada867840582/cffi-1.15.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:59c0b02d0a6c384d453fece7566d1c7e6b7bae4fc5874ef2ef46d56776d61c9e", size = 464113 }, + { url = "https://files.pythonhosted.org/packages/9f/52/1e2b43cfdd7d9a39f48bc89fcaee8d8685b1295e205a4f1044909ac14d89/cffi-1.15.1-cp310-cp310-win32.whl", hash = "sha256:cba9d6b9a7d64d4bd46167096fc9d2f835e25d7e4c121fb2ddfc6528fb0413b2", size = 170412 }, + { url = "https://files.pythonhosted.org/packages/0e/e2/a23af3d81838c577571da4ff01b799b0c2bbde24bd924d97e228febae810/cffi-1.15.1-cp310-cp310-win_amd64.whl", hash = "sha256:ce4bcc037df4fc5e3d184794f27bdaab018943698f4ca31630bc7f84a7b69c6d", size = 179060 }, + { url = "https://files.pythonhosted.org/packages/23/8b/2e8c2469eaf89f7273ac685164949a7e644cdfe5daf1c036564208c3d26b/cffi-1.15.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:3d08afd128ddaa624a48cf2b859afef385b720bb4b43df214f85616922e6a5ac", size = 179198 }, + { url = "https://files.pythonhosted.org/packages/f9/96/fc9e118c47b7adc45a0676f413b4a47554e5f3b6c99b8607ec9726466ef1/cffi-1.15.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:3799aecf2e17cf585d977b780ce79ff0dc9b78d799fc694221ce814c2c19db83", size = 174221 }, + { url = "https://files.pythonhosted.org/packages/10/72/617ee266192223a38b67149c830bd9376b69cf3551e1477abc72ff23ef8e/cffi-1.15.1-cp311-cp311-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a591fe9e525846e4d154205572a029f653ada1a78b93697f3b5a8f1f2bc055b9", size = 441694 }, + { url = "https://files.pythonhosted.org/packages/91/bc/b7723c2fe7a22eee71d7edf2102cd43423d5f95ff3932ebaa2f82c7ec8d0/cffi-1.15.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3548db281cd7d2561c9ad9984681c95f7b0e38881201e157833a2342c30d5e8c", size = 470613 }, + { url = "https://files.pythonhosted.org/packages/5d/4e/4e0bb5579b01fdbfd4388bd1eb9394a989e1336203a4b7f700d887b233c1/cffi-1.15.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:91fc98adde3d7881af9b59ed0294046f3806221863722ba7d8d120c575314325", size = 472199 }, + { url = "https://files.pythonhosted.org/packages/37/5a/c37631a86be838bdd84cc0259130942bf7e6e32f70f4cab95f479847fb91/cffi-1.15.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:94411f22c3985acaec6f83c6df553f2dbe17b698cc7f8ae751ff2237d96b9e3c", size = 462588 }, + { url = "https://files.pythonhosted.org/packages/71/d7/0fe0d91b0bbf610fb7254bb164fa8931596e660d62e90fb6289b7ee27b09/cffi-1.15.1-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:03425bdae262c76aad70202debd780501fabeaca237cdfddc008987c0e0f59ef", size = 450543 }, + { url = "https://files.pythonhosted.org/packages/d3/56/3e94aa719ae96eeda8b68b3ec6e347e0a23168c6841dc276ccdcdadc9f32/cffi-1.15.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:cc4d65aeeaa04136a12677d3dd0b1c0c94dc43abac5860ab33cceb42b801c1e8", size = 474253 }, + { url = "https://files.pythonhosted.org/packages/87/ee/ddc23981fc0f5e7b5356e98884226bcb899f95ebaefc3e8e8b8742dd7e22/cffi-1.15.1-cp311-cp311-win32.whl", hash = "sha256:a0f100c8912c114ff53e1202d0078b425bee3649ae34d7b070e9697f93c5d52d", size = 170313 }, + { url = "https://files.pythonhosted.org/packages/43/a0/cc7370ef72b6ee586369bacd3961089ab3d94ae712febf07a244f1448ffd/cffi-1.15.1-cp311-cp311-win_amd64.whl", hash = "sha256:04ed324bda3cda42b9b695d51bb7d54b680b9719cfab04227cdd1e04e5de3104", size = 179001 }, + { url = "https://files.pythonhosted.org/packages/b5/7d/df6c088ef30e78a78b0c9cca6b904d5abb698afb5bc8f5191d529d83d667/cffi-1.15.1-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:198caafb44239b60e252492445da556afafc7d1e3ab7a1fb3f0584ef6d742375", size = 178906 }, + { url = "https://files.pythonhosted.org/packages/c2/0b/3b09a755ddb977c167e6d209a7536f6ade43bb0654bad42e08df1406b8e4/cffi-1.15.1-cp37-cp37m-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:5ef34d190326c3b1f822a5b7a45f6c4535e2f47ed06fec77d3d799c450b2651e", size = 405992 }, + { url = "https://files.pythonhosted.org/packages/5b/1a/e1ee5bed11d8b6540c05a8e3c32448832d775364d4461dd6497374533401/cffi-1.15.1-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8102eaf27e1e448db915d08afa8b41d6c7ca7a04b7d73af6514df10a3e74bd82", size = 435560 }, + { url = "https://files.pythonhosted.org/packages/d3/e1/e55ca2e0dd446caa2cc8f73c2b98879c04a1f4064ac529e1836683ca58b8/cffi-1.15.1-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5df2768244d19ab7f60546d0c7c63ce1581f7af8b5de3eb3004b9b6fc8a9f84b", size = 435478 }, + { url = "https://files.pythonhosted.org/packages/2e/7a/68c35c151e5b7a12650ecc12fdfb85211aa1da43e9924598451c4a0a3839/cffi-1.15.1-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a8c4917bd7ad33e8eb21e9a5bbba979b49d9a97acb3a803092cbc1133e20343c", size = 430395 }, + { url = "https://files.pythonhosted.org/packages/93/d0/2e2b27ea2f69b0ec9e481647822f8f77f5fc23faca2dd00d1ff009940eb7/cffi-1.15.1-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0e2642fe3142e4cc4af0799748233ad6da94c62a8bec3a6648bf8ee68b1c7426", size = 427911 }, + { url = "https://files.pythonhosted.org/packages/50/34/4cc590ad600869502c9838b4824982c122179089ed6791a8b1c95f0ff55e/cffi-1.15.1-cp37-cp37m-win32.whl", hash = "sha256:e229a521186c75c8ad9490854fd8bbdd9a0c9aa3a524326b55be83b54d4e0ad9", size = 169721 }, + { url = "https://files.pythonhosted.org/packages/32/2a/63cb8c07d151de92ff9d897b2eb27ba6a0e78dda8e4c5f70d7b8c16cd6a2/cffi-1.15.1-cp37-cp37m-win_amd64.whl", hash = "sha256:a0b71b1b8fbf2b96e41c4d990244165e2c9be83d54962a9a1d118fd8657d2045", size = 179301 }, + { url = "https://files.pythonhosted.org/packages/87/4b/64e8bd9d15d6b22b6cb11997094fbe61edf453ea0a97c8675cb7d1c3f06f/cffi-1.15.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:320dab6e7cb2eacdf0e658569d2575c4dad258c0fcc794f46215e1e39f90f2c3", size = 178940 }, + { url = "https://files.pythonhosted.org/packages/22/c6/df826563f55f7e9dd9a1d3617866282afa969fe0d57decffa1911f416ed8/cffi-1.15.1-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1e74c6b51a9ed6589199c787bf5f9875612ca4a8a0785fb2d4a84429badaf22a", size = 421947 }, + { url = "https://files.pythonhosted.org/packages/c1/25/16a082701378170559bb1d0e9ef2d293cece8dc62913d79351beb34c5ddf/cffi-1.15.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a5c84c68147988265e60416b57fc83425a78058853509c1b0629c180094904a5", size = 449906 }, + { url = "https://files.pythonhosted.org/packages/df/02/aef53d4aa43154b829e9707c8c60bab413cd21819c4a36b0d7aaa83e2a61/cffi-1.15.1-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3b926aa83d1edb5aa5b427b4053dc420ec295a08e40911296b9eb1b6170f6cca", size = 451028 }, + { url = "https://files.pythonhosted.org/packages/79/4b/33494eb0adbcd884656c48f6db0c98ad8a5c678fb8fb5ed41ab546b04d8c/cffi-1.15.1-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:87c450779d0914f2861b8526e035c5e6da0a3199d8f1add1a665e1cbc6fc6d02", size = 446520 }, + { url = "https://files.pythonhosted.org/packages/b7/8b/06f30caa03b5b3ac006de4f93478dbd0239e2a16566d81a106c322dc4f79/cffi-1.15.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4f2c9f67e9821cad2e5f480bc8d83b8742896f1242dba247911072d4fa94c192", size = 442655 }, + { url = "https://files.pythonhosted.org/packages/47/97/137f0e3d2304df2060abb872a5830af809d7559a5a4b6a295afb02728e65/cffi-1.15.1-cp38-cp38-win32.whl", hash = "sha256:8b7ee99e510d7b66cdb6c593f21c043c248537a32e0bedf02e01e9553a172314", size = 170236 }, + { url = "https://files.pythonhosted.org/packages/c9/e3/0a52838832408cfbbf3a59cb19bcd17e64eb33795c9710ca7d29ae10b5b7/cffi-1.15.1-cp38-cp38-win_amd64.whl", hash = "sha256:00a9ed42e88df81ffae7a8ab6d9356b371399b91dbdf0c3cb1e84c03a13aceb5", size = 178835 }, + { url = "https://files.pythonhosted.org/packages/18/8f/5ff70c7458d61fa8a9752e5ee9c9984c601b0060aae0c619316a1e1f1ee5/cffi-1.15.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:54a2db7b78338edd780e7ef7f9f6c442500fb0d41a5a4ea24fff1c929d5af585", size = 179249 }, + { url = "https://files.pythonhosted.org/packages/3a/75/a162315adeaf47e94a3b7f886a8e31d77b9e525a387eef2d6f0efc96a7c8/cffi-1.15.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:fcd131dd944808b5bdb38e6f5b53013c5aa4f334c5cad0c72742f6eba4b73db0", size = 174297 }, + { url = "https://files.pythonhosted.org/packages/85/1f/a3c533f8d377da5ca7edb4f580cc3edc1edbebc45fac8bb3ae60f1176629/cffi-1.15.1-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7473e861101c9e72452f9bf8acb984947aa1661a7704553a9f6e4baa5ba64415", size = 420641 }, + { url = "https://files.pythonhosted.org/packages/77/b7/d3618d612be01e184033eab90006f8ca5b5edafd17bf247439ea4e167d8a/cffi-1.15.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6c9a799e985904922a4d207a94eae35c78ebae90e128f0c4e521ce339396be9d", size = 448814 }, + { url = "https://files.pythonhosted.org/packages/a9/ba/e082df21ebaa9cb29f2c4e1d7e49a29b90fcd667d43632c6674a16d65382/cffi-1.15.1-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3bcde07039e586f91b45c88f8583ea7cf7a0770df3a1649627bf598332cb6984", size = 449647 }, + { url = "https://files.pythonhosted.org/packages/af/cb/53b7bba75a18372d57113ba934b27d0734206c283c1dfcc172347fbd9f76/cffi-1.15.1-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:33ab79603146aace82c2427da5ca6e58f2b3f2fb5da893ceac0c42218a40be35", size = 445191 }, + { url = "https://files.pythonhosted.org/packages/2d/86/3ca57cddfa0419f6a95d1c8478f8f622ba597e3581fd501bbb915b20eb75/cffi-1.15.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5d598b938678ebf3c67377cdd45e09d431369c3b1a5b331058c338e201f12b27", size = 441236 }, + { url = "https://files.pythonhosted.org/packages/ad/26/7b3a73ab7d82a64664c7c4ea470e4ec4a3c73bb4f02575c543a41e272de5/cffi-1.15.1-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:db0fbb9c62743ce59a9ff687eb5f4afbe77e5e8403d6697f7446e5f609976f76", size = 433865 }, + { url = "https://files.pythonhosted.org/packages/da/ff/ab939e2c7b3f40d851c0f7192c876f1910f3442080c9c846532993ec3cef/cffi-1.15.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:98d85c6a2bef81588d9227dde12db8a7f47f639f4a17c9ae08e773aa9c697bf3", size = 463090 }, + { url = "https://files.pythonhosted.org/packages/c6/3d/dd085bb831b22ce4d0b7ba8550e6d78960f02f770bbd1314fea3580727f8/cffi-1.15.1-cp39-cp39-win32.whl", hash = "sha256:40f4774f5a9d4f5e344f31a32b5096977b5d48560c5592e2f3d2c4374bd543ee", size = 170382 }, + { url = "https://files.pythonhosted.org/packages/a8/16/06b84a7063a4c0a2b081030fdd976022086da9c14e80a9ed4ba0183a98a9/cffi-1.15.1-cp39-cp39-win_amd64.whl", hash = "sha256:70df4e3b545a17496c9b3f41f5115e69a4f2e77e94e1d2a8e1070bc0c38c8a3c", size = 179079 }, +] + +[[package]] +name = "cffi" +version = "1.17.1" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", + "python_full_version == '3.10.*'", + "python_full_version == '3.9.*'", + "python_full_version == '3.8.*'", +] +dependencies = [ + { name = "pycparser", version = "2.22", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.8'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/fc/97/c783634659c2920c3fc70419e3af40972dbaf758daa229a7d6ea6135c90d/cffi-1.17.1.tar.gz", hash = "sha256:1c39c6016c32bc48dd54561950ebd6836e1670f2ae46128f67cf49e789c52824", size = 516621 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/90/07/f44ca684db4e4f08a3fdc6eeb9a0d15dc6883efc7b8c90357fdbf74e186c/cffi-1.17.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:df8b1c11f177bc2313ec4b2d46baec87a5f3e71fc8b45dab2ee7cae86d9aba14", size = 182191 }, + { url = "https://files.pythonhosted.org/packages/08/fd/cc2fedbd887223f9f5d170c96e57cbf655df9831a6546c1727ae13fa977a/cffi-1.17.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:8f2cdc858323644ab277e9bb925ad72ae0e67f69e804f4898c070998d50b1a67", size = 178592 }, + { url = "https://files.pythonhosted.org/packages/de/cc/4635c320081c78d6ffc2cab0a76025b691a91204f4aa317d568ff9280a2d/cffi-1.17.1-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:edae79245293e15384b51f88b00613ba9f7198016a5948b5dddf4917d4d26382", size = 426024 }, + { url = "https://files.pythonhosted.org/packages/b6/7b/3b2b250f3aab91abe5f8a51ada1b717935fdaec53f790ad4100fe2ec64d1/cffi-1.17.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:45398b671ac6d70e67da8e4224a065cec6a93541bb7aebe1b198a61b58c7b702", size = 448188 }, + { url = "https://files.pythonhosted.org/packages/d3/48/1b9283ebbf0ec065148d8de05d647a986c5f22586b18120020452fff8f5d/cffi-1.17.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ad9413ccdeda48c5afdae7e4fa2192157e991ff761e7ab8fdd8926f40b160cc3", size = 455571 }, + { url = "https://files.pythonhosted.org/packages/40/87/3b8452525437b40f39ca7ff70276679772ee7e8b394934ff60e63b7b090c/cffi-1.17.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5da5719280082ac6bd9aa7becb3938dc9f9cbd57fac7d2871717b1feb0902ab6", size = 436687 }, + { url = "https://files.pythonhosted.org/packages/8d/fb/4da72871d177d63649ac449aec2e8a29efe0274035880c7af59101ca2232/cffi-1.17.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2bb1a08b8008b281856e5971307cc386a8e9c5b625ac297e853d36da6efe9c17", size = 446211 }, + { url = "https://files.pythonhosted.org/packages/ab/a0/62f00bcb411332106c02b663b26f3545a9ef136f80d5df746c05878f8c4b/cffi-1.17.1-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:045d61c734659cc045141be4bae381a41d89b741f795af1dd018bfb532fd0df8", size = 461325 }, + { url = "https://files.pythonhosted.org/packages/36/83/76127035ed2e7e27b0787604d99da630ac3123bfb02d8e80c633f218a11d/cffi-1.17.1-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:6883e737d7d9e4899a8a695e00ec36bd4e5e4f18fabe0aca0efe0a4b44cdb13e", size = 438784 }, + { url = "https://files.pythonhosted.org/packages/21/81/a6cd025db2f08ac88b901b745c163d884641909641f9b826e8cb87645942/cffi-1.17.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:6b8b4a92e1c65048ff98cfe1f735ef8f1ceb72e3d5f0c25fdb12087a23da22be", size = 461564 }, + { url = "https://files.pythonhosted.org/packages/f8/fe/4d41c2f200c4a457933dbd98d3cf4e911870877bd94d9656cc0fcb390681/cffi-1.17.1-cp310-cp310-win32.whl", hash = "sha256:c9c3d058ebabb74db66e431095118094d06abf53284d9c81f27300d0e0d8bc7c", size = 171804 }, + { url = "https://files.pythonhosted.org/packages/d1/b6/0b0f5ab93b0df4acc49cae758c81fe4e5ef26c3ae2e10cc69249dfd8b3ab/cffi-1.17.1-cp310-cp310-win_amd64.whl", hash = "sha256:0f048dcf80db46f0098ccac01132761580d28e28bc0f78ae0d58048063317e15", size = 181299 }, + { url = "https://files.pythonhosted.org/packages/6b/f4/927e3a8899e52a27fa57a48607ff7dc91a9ebe97399b357b85a0c7892e00/cffi-1.17.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:a45e3c6913c5b87b3ff120dcdc03f6131fa0065027d0ed7ee6190736a74cd401", size = 182264 }, + { url = "https://files.pythonhosted.org/packages/6c/f5/6c3a8efe5f503175aaddcbea6ad0d2c96dad6f5abb205750d1b3df44ef29/cffi-1.17.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:30c5e0cb5ae493c04c8b42916e52ca38079f1b235c2f8ae5f4527b963c401caf", size = 178651 }, + { url = "https://files.pythonhosted.org/packages/94/dd/a3f0118e688d1b1a57553da23b16bdade96d2f9bcda4d32e7d2838047ff7/cffi-1.17.1-cp311-cp311-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f75c7ab1f9e4aca5414ed4d8e5c0e303a34f4421f8a0d47a4d019ceff0ab6af4", size = 445259 }, + { url = "https://files.pythonhosted.org/packages/2e/ea/70ce63780f096e16ce8588efe039d3c4f91deb1dc01e9c73a287939c79a6/cffi-1.17.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a1ed2dd2972641495a3ec98445e09766f077aee98a1c896dcb4ad0d303628e41", size = 469200 }, + { url = "https://files.pythonhosted.org/packages/1c/a0/a4fa9f4f781bda074c3ddd57a572b060fa0df7655d2a4247bbe277200146/cffi-1.17.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:46bf43160c1a35f7ec506d254e5c890f3c03648a4dbac12d624e4490a7046cd1", size = 477235 }, + { url = "https://files.pythonhosted.org/packages/62/12/ce8710b5b8affbcdd5c6e367217c242524ad17a02fe5beec3ee339f69f85/cffi-1.17.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a24ed04c8ffd54b0729c07cee15a81d964e6fee0e3d4d342a27b020d22959dc6", size = 459721 }, + { url = "https://files.pythonhosted.org/packages/ff/6b/d45873c5e0242196f042d555526f92aa9e0c32355a1be1ff8c27f077fd37/cffi-1.17.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:610faea79c43e44c71e1ec53a554553fa22321b65fae24889706c0a84d4ad86d", size = 467242 }, + { url = "https://files.pythonhosted.org/packages/1a/52/d9a0e523a572fbccf2955f5abe883cfa8bcc570d7faeee06336fbd50c9fc/cffi-1.17.1-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:a9b15d491f3ad5d692e11f6b71f7857e7835eb677955c00cc0aefcd0669adaf6", size = 477999 }, + { url = "https://files.pythonhosted.org/packages/44/74/f2a2460684a1a2d00ca799ad880d54652841a780c4c97b87754f660c7603/cffi-1.17.1-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:de2ea4b5833625383e464549fec1bc395c1bdeeb5f25c4a3a82b5a8c756ec22f", size = 454242 }, + { url = "https://files.pythonhosted.org/packages/f8/4a/34599cac7dfcd888ff54e801afe06a19c17787dfd94495ab0c8d35fe99fb/cffi-1.17.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:fc48c783f9c87e60831201f2cce7f3b2e4846bf4d8728eabe54d60700b318a0b", size = 478604 }, + { url = "https://files.pythonhosted.org/packages/34/33/e1b8a1ba29025adbdcda5fb3a36f94c03d771c1b7b12f726ff7fef2ebe36/cffi-1.17.1-cp311-cp311-win32.whl", hash = "sha256:85a950a4ac9c359340d5963966e3e0a94a676bd6245a4b55bc43949eee26a655", size = 171727 }, + { url = "https://files.pythonhosted.org/packages/3d/97/50228be003bb2802627d28ec0627837ac0bf35c90cf769812056f235b2d1/cffi-1.17.1-cp311-cp311-win_amd64.whl", hash = "sha256:caaf0640ef5f5517f49bc275eca1406b0ffa6aa184892812030f04c2abf589a0", size = 181400 }, + { url = "https://files.pythonhosted.org/packages/5a/84/e94227139ee5fb4d600a7a4927f322e1d4aea6fdc50bd3fca8493caba23f/cffi-1.17.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:805b4371bf7197c329fcb3ead37e710d1bca9da5d583f5073b799d5c5bd1eee4", size = 183178 }, + { url = "https://files.pythonhosted.org/packages/da/ee/fb72c2b48656111c4ef27f0f91da355e130a923473bf5ee75c5643d00cca/cffi-1.17.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:733e99bc2df47476e3848417c5a4540522f234dfd4ef3ab7fafdf555b082ec0c", size = 178840 }, + { url = "https://files.pythonhosted.org/packages/cc/b6/db007700f67d151abadf508cbfd6a1884f57eab90b1bb985c4c8c02b0f28/cffi-1.17.1-cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1257bdabf294dceb59f5e70c64a3e2f462c30c7ad68092d01bbbfb1c16b1ba36", size = 454803 }, + { url = "https://files.pythonhosted.org/packages/1a/df/f8d151540d8c200eb1c6fba8cd0dfd40904f1b0682ea705c36e6c2e97ab3/cffi-1.17.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:da95af8214998d77a98cc14e3a3bd00aa191526343078b530ceb0bd710fb48a5", size = 478850 }, + { url = "https://files.pythonhosted.org/packages/28/c0/b31116332a547fd2677ae5b78a2ef662dfc8023d67f41b2a83f7c2aa78b1/cffi-1.17.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d63afe322132c194cf832bfec0dc69a99fb9bb6bbd550f161a49e9e855cc78ff", size = 485729 }, + { url = "https://files.pythonhosted.org/packages/91/2b/9a1ddfa5c7f13cab007a2c9cc295b70fbbda7cb10a286aa6810338e60ea1/cffi-1.17.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f79fc4fc25f1c8698ff97788206bb3c2598949bfe0fef03d299eb1b5356ada99", size = 471256 }, + { url = "https://files.pythonhosted.org/packages/b2/d5/da47df7004cb17e4955df6a43d14b3b4ae77737dff8bf7f8f333196717bf/cffi-1.17.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b62ce867176a75d03a665bad002af8e6d54644fad99a3c70905c543130e39d93", size = 479424 }, + { url = "https://files.pythonhosted.org/packages/0b/ac/2a28bcf513e93a219c8a4e8e125534f4f6db03e3179ba1c45e949b76212c/cffi-1.17.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:386c8bf53c502fff58903061338ce4f4950cbdcb23e2902d86c0f722b786bbe3", size = 484568 }, + { url = "https://files.pythonhosted.org/packages/d4/38/ca8a4f639065f14ae0f1d9751e70447a261f1a30fa7547a828ae08142465/cffi-1.17.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:4ceb10419a9adf4460ea14cfd6bc43d08701f0835e979bf821052f1805850fe8", size = 488736 }, + { url = "https://files.pythonhosted.org/packages/86/c5/28b2d6f799ec0bdecf44dced2ec5ed43e0eb63097b0f58c293583b406582/cffi-1.17.1-cp312-cp312-win32.whl", hash = "sha256:a08d7e755f8ed21095a310a693525137cfe756ce62d066e53f502a83dc550f65", size = 172448 }, + { url = "https://files.pythonhosted.org/packages/50/b9/db34c4755a7bd1cb2d1603ac3863f22bcecbd1ba29e5ee841a4bc510b294/cffi-1.17.1-cp312-cp312-win_amd64.whl", hash = "sha256:51392eae71afec0d0c8fb1a53b204dbb3bcabcb3c9b807eedf3e1e6ccf2de903", size = 181976 }, + { url = "https://files.pythonhosted.org/packages/8d/f8/dd6c246b148639254dad4d6803eb6a54e8c85c6e11ec9df2cffa87571dbe/cffi-1.17.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f3a2b4222ce6b60e2e8b337bb9596923045681d71e5a082783484d845390938e", size = 182989 }, + { url = "https://files.pythonhosted.org/packages/8b/f1/672d303ddf17c24fc83afd712316fda78dc6fce1cd53011b839483e1ecc8/cffi-1.17.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:0984a4925a435b1da406122d4d7968dd861c1385afe3b45ba82b750f229811e2", size = 178802 }, + { url = "https://files.pythonhosted.org/packages/0e/2d/eab2e858a91fdff70533cab61dcff4a1f55ec60425832ddfdc9cd36bc8af/cffi-1.17.1-cp313-cp313-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d01b12eeeb4427d3110de311e1774046ad344f5b1a7403101878976ecd7a10f3", size = 454792 }, + { url = "https://files.pythonhosted.org/packages/75/b2/fbaec7c4455c604e29388d55599b99ebcc250a60050610fadde58932b7ee/cffi-1.17.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:706510fe141c86a69c8ddc029c7910003a17353970cff3b904ff0686a5927683", size = 478893 }, + { url = "https://files.pythonhosted.org/packages/4f/b7/6e4a2162178bf1935c336d4da8a9352cccab4d3a5d7914065490f08c0690/cffi-1.17.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:de55b766c7aa2e2a3092c51e0483d700341182f08e67c63630d5b6f200bb28e5", size = 485810 }, + { url = "https://files.pythonhosted.org/packages/c7/8a/1d0e4a9c26e54746dc08c2c6c037889124d4f59dffd853a659fa545f1b40/cffi-1.17.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c59d6e989d07460165cc5ad3c61f9fd8f1b4796eacbd81cee78957842b834af4", size = 471200 }, + { url = "https://files.pythonhosted.org/packages/26/9f/1aab65a6c0db35f43c4d1b4f580e8df53914310afc10ae0397d29d697af4/cffi-1.17.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dd398dbc6773384a17fe0d3e7eeb8d1a21c2200473ee6806bb5e6a8e62bb73dd", size = 479447 }, + { url = "https://files.pythonhosted.org/packages/5f/e4/fb8b3dd8dc0e98edf1135ff067ae070bb32ef9d509d6cb0f538cd6f7483f/cffi-1.17.1-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:3edc8d958eb099c634dace3c7e16560ae474aa3803a5df240542b305d14e14ed", size = 484358 }, + { url = "https://files.pythonhosted.org/packages/f1/47/d7145bf2dc04684935d57d67dff9d6d795b2ba2796806bb109864be3a151/cffi-1.17.1-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:72e72408cad3d5419375fc87d289076ee319835bdfa2caad331e377589aebba9", size = 488469 }, + { url = "https://files.pythonhosted.org/packages/bf/ee/f94057fa6426481d663b88637a9a10e859e492c73d0384514a17d78ee205/cffi-1.17.1-cp313-cp313-win32.whl", hash = "sha256:e03eab0a8677fa80d646b5ddece1cbeaf556c313dcfac435ba11f107ba117b5d", size = 172475 }, + { url = "https://files.pythonhosted.org/packages/7c/fc/6a8cb64e5f0324877d503c854da15d76c1e50eb722e320b15345c4d0c6de/cffi-1.17.1-cp313-cp313-win_amd64.whl", hash = "sha256:f6a16c31041f09ead72d69f583767292f750d24913dadacf5756b966aacb3f1a", size = 182009 }, + { url = "https://files.pythonhosted.org/packages/48/08/15bf6b43ae9bd06f6b00ad8a91f5a8fe1069d4c9fab550a866755402724e/cffi-1.17.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:636062ea65bd0195bc012fea9321aca499c0504409f413dc88af450b57ffd03b", size = 182457 }, + { url = "https://files.pythonhosted.org/packages/c2/5b/f1523dd545f92f7df468e5f653ffa4df30ac222f3c884e51e139878f1cb5/cffi-1.17.1-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c7eac2ef9b63c79431bc4b25f1cd649d7f061a28808cbc6c47b534bd789ef964", size = 425932 }, + { url = "https://files.pythonhosted.org/packages/53/93/7e547ab4105969cc8c93b38a667b82a835dd2cc78f3a7dad6130cfd41e1d/cffi-1.17.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e221cf152cff04059d011ee126477f0d9588303eb57e88923578ace7baad17f9", size = 448585 }, + { url = "https://files.pythonhosted.org/packages/56/c4/a308f2c332006206bb511de219efeff090e9d63529ba0a77aae72e82248b/cffi-1.17.1-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:31000ec67d4221a71bd3f67df918b1f88f676f1c3b535a7eb473255fdc0b83fc", size = 456268 }, + { url = "https://files.pythonhosted.org/packages/ca/5b/b63681518265f2f4060d2b60755c1c77ec89e5e045fc3773b72735ddaad5/cffi-1.17.1-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:6f17be4345073b0a7b8ea599688f692ac3ef23ce28e5df79c04de519dbc4912c", size = 436592 }, + { url = "https://files.pythonhosted.org/packages/bb/19/b51af9f4a4faa4a8ac5a0e5d5c2522dcd9703d07fac69da34a36c4d960d3/cffi-1.17.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0e2b1fac190ae3ebfe37b979cc1ce69c81f4e4fe5746bb401dca63a9062cdaf1", size = 446512 }, + { url = "https://files.pythonhosted.org/packages/e2/63/2bed8323890cb613bbecda807688a31ed11a7fe7afe31f8faaae0206a9a3/cffi-1.17.1-cp38-cp38-win32.whl", hash = "sha256:7596d6620d3fa590f677e9ee430df2958d2d6d6de2feeae5b20e82c00b76fbf8", size = 171576 }, + { url = "https://files.pythonhosted.org/packages/2f/70/80c33b044ebc79527447fd4fbc5455d514c3bb840dede4455de97da39b4d/cffi-1.17.1-cp38-cp38-win_amd64.whl", hash = "sha256:78122be759c3f8a014ce010908ae03364d00a1f81ab5c7f4a7a5120607ea56e1", size = 181229 }, + { url = "https://files.pythonhosted.org/packages/b9/ea/8bb50596b8ffbc49ddd7a1ad305035daa770202a6b782fc164647c2673ad/cffi-1.17.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:b2ab587605f4ba0bf81dc0cb08a41bd1c0a5906bd59243d56bad7668a6fc6c16", size = 182220 }, + { url = "https://files.pythonhosted.org/packages/ae/11/e77c8cd24f58285a82c23af484cf5b124a376b32644e445960d1a4654c3a/cffi-1.17.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:28b16024becceed8c6dfbc75629e27788d8a3f9030691a1dbf9821a128b22c36", size = 178605 }, + { url = "https://files.pythonhosted.org/packages/ed/65/25a8dc32c53bf5b7b6c2686b42ae2ad58743f7ff644844af7cdb29b49361/cffi-1.17.1-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1d599671f396c4723d016dbddb72fe8e0397082b0a77a4fab8028923bec050e8", size = 424910 }, + { url = "https://files.pythonhosted.org/packages/42/7a/9d086fab7c66bd7c4d0f27c57a1b6b068ced810afc498cc8c49e0088661c/cffi-1.17.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ca74b8dbe6e8e8263c0ffd60277de77dcee6c837a3d0881d8c1ead7268c9e576", size = 447200 }, + { url = "https://files.pythonhosted.org/packages/da/63/1785ced118ce92a993b0ec9e0d0ac8dc3e5dbfbcaa81135be56c69cabbb6/cffi-1.17.1-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f7f5baafcc48261359e14bcd6d9bff6d4b28d9103847c9e136694cb0501aef87", size = 454565 }, + { url = "https://files.pythonhosted.org/packages/74/06/90b8a44abf3556599cdec107f7290277ae8901a58f75e6fe8f970cd72418/cffi-1.17.1-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:98e3969bcff97cae1b2def8ba499ea3d6f31ddfdb7635374834cf89a1a08ecf0", size = 435635 }, + { url = "https://files.pythonhosted.org/packages/bd/62/a1f468e5708a70b1d86ead5bab5520861d9c7eacce4a885ded9faa7729c3/cffi-1.17.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cdf5ce3acdfd1661132f2a9c19cac174758dc2352bfe37d98aa7512c6b7178b3", size = 445218 }, + { url = "https://files.pythonhosted.org/packages/5b/95/b34462f3ccb09c2594aa782d90a90b045de4ff1f70148ee79c69d37a0a5a/cffi-1.17.1-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:9755e4345d1ec879e3849e62222a18c7174d65a6a92d5b346b1863912168b595", size = 460486 }, + { url = "https://files.pythonhosted.org/packages/fc/fc/a1e4bebd8d680febd29cf6c8a40067182b64f00c7d105f8f26b5bc54317b/cffi-1.17.1-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:f1e22e8c4419538cb197e4dd60acc919d7696e5ef98ee4da4e01d3f8cfa4cc5a", size = 437911 }, + { url = "https://files.pythonhosted.org/packages/e6/c3/21cab7a6154b6a5ea330ae80de386e7665254835b9e98ecc1340b3a7de9a/cffi-1.17.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:c03e868a0b3bc35839ba98e74211ed2b05d2119be4e8a0f224fba9384f1fe02e", size = 460632 }, + { url = "https://files.pythonhosted.org/packages/cb/b5/fd9f8b5a84010ca169ee49f4e4ad6f8c05f4e3545b72ee041dbbcb159882/cffi-1.17.1-cp39-cp39-win32.whl", hash = "sha256:e31ae45bc2e29f6b2abd0de1cc3b9d5205aa847cafaecb8af1476a609a2f6eb7", size = 171820 }, + { url = "https://files.pythonhosted.org/packages/8c/52/b08750ce0bce45c143e1b5d7357ee8c55341b52bdef4b0f081af1eb248c2/cffi-1.17.1-cp39-cp39-win_amd64.whl", hash = "sha256:d016c76bdd850f3c626af19b0542c9677ba156e4ee4fccfdd7848803533ef662", size = 181290 }, +] + +[[package]] +name = "charset-normalizer" +version = "3.4.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/16/b0/572805e227f01586461c80e0fd25d65a2115599cc9dad142fee4b747c357/charset_normalizer-3.4.1.tar.gz", hash = "sha256:44251f18cd68a75b56585dd00dae26183e102cd5e0f9f1466e6df5da2ed64ea3", size = 123188 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0d/58/5580c1716040bc89206c77d8f74418caf82ce519aae06450393ca73475d1/charset_normalizer-3.4.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:91b36a978b5ae0ee86c394f5a54d6ef44db1de0815eb43de826d41d21e4af3de", size = 198013 }, + { url = "https://files.pythonhosted.org/packages/d0/11/00341177ae71c6f5159a08168bcb98c6e6d196d372c94511f9f6c9afe0c6/charset_normalizer-3.4.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7461baadb4dc00fd9e0acbe254e3d7d2112e7f92ced2adc96e54ef6501c5f176", size = 141285 }, + { url = "https://files.pythonhosted.org/packages/01/09/11d684ea5819e5a8f5100fb0b38cf8d02b514746607934134d31233e02c8/charset_normalizer-3.4.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e218488cd232553829be0664c2292d3af2eeeb94b32bea483cf79ac6a694e037", size = 151449 }, + { url = "https://files.pythonhosted.org/packages/08/06/9f5a12939db324d905dc1f70591ae7d7898d030d7662f0d426e2286f68c9/charset_normalizer-3.4.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:80ed5e856eb7f30115aaf94e4a08114ccc8813e6ed1b5efa74f9f82e8509858f", size = 143892 }, + { url = "https://files.pythonhosted.org/packages/93/62/5e89cdfe04584cb7f4d36003ffa2936681b03ecc0754f8e969c2becb7e24/charset_normalizer-3.4.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b010a7a4fd316c3c484d482922d13044979e78d1861f0e0650423144c616a46a", size = 146123 }, + { url = "https://files.pythonhosted.org/packages/a9/ac/ab729a15c516da2ab70a05f8722ecfccc3f04ed7a18e45c75bbbaa347d61/charset_normalizer-3.4.1-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4532bff1b8421fd0a320463030c7520f56a79c9024a4e88f01c537316019005a", size = 147943 }, + { url = "https://files.pythonhosted.org/packages/03/d2/3f392f23f042615689456e9a274640c1d2e5dd1d52de36ab8f7955f8f050/charset_normalizer-3.4.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:d973f03c0cb71c5ed99037b870f2be986c3c05e63622c017ea9816881d2dd247", size = 142063 }, + { url = "https://files.pythonhosted.org/packages/f2/e3/e20aae5e1039a2cd9b08d9205f52142329f887f8cf70da3650326670bddf/charset_normalizer-3.4.1-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:3a3bd0dcd373514dcec91c411ddb9632c0d7d92aed7093b8c3bbb6d69ca74408", size = 150578 }, + { url = "https://files.pythonhosted.org/packages/8d/af/779ad72a4da0aed925e1139d458adc486e61076d7ecdcc09e610ea8678db/charset_normalizer-3.4.1-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:d9c3cdf5390dcd29aa8056d13e8e99526cda0305acc038b96b30352aff5ff2bb", size = 153629 }, + { url = "https://files.pythonhosted.org/packages/c2/b6/7aa450b278e7aa92cf7732140bfd8be21f5f29d5bf334ae987c945276639/charset_normalizer-3.4.1-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:2bdfe3ac2e1bbe5b59a1a63721eb3b95fc9b6817ae4a46debbb4e11f6232428d", size = 150778 }, + { url = "https://files.pythonhosted.org/packages/39/f4/d9f4f712d0951dcbfd42920d3db81b00dd23b6ab520419626f4023334056/charset_normalizer-3.4.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:eab677309cdb30d047996b36d34caeda1dc91149e4fdca0b1a039b3f79d9a807", size = 146453 }, + { url = "https://files.pythonhosted.org/packages/49/2b/999d0314e4ee0cff3cb83e6bc9aeddd397eeed693edb4facb901eb8fbb69/charset_normalizer-3.4.1-cp310-cp310-win32.whl", hash = "sha256:c0429126cf75e16c4f0ad00ee0eae4242dc652290f940152ca8c75c3a4b6ee8f", size = 95479 }, + { url = "https://files.pythonhosted.org/packages/2d/ce/3cbed41cff67e455a386fb5e5dd8906cdda2ed92fbc6297921f2e4419309/charset_normalizer-3.4.1-cp310-cp310-win_amd64.whl", hash = "sha256:9f0b8b1c6d84c8034a44893aba5e767bf9c7a211e313a9605d9c617d7083829f", size = 102790 }, + { url = "https://files.pythonhosted.org/packages/72/80/41ef5d5a7935d2d3a773e3eaebf0a9350542f2cab4eac59a7a4741fbbbbe/charset_normalizer-3.4.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:8bfa33f4f2672964266e940dd22a195989ba31669bd84629f05fab3ef4e2d125", size = 194995 }, + { url = "https://files.pythonhosted.org/packages/7a/28/0b9fefa7b8b080ec492110af6d88aa3dea91c464b17d53474b6e9ba5d2c5/charset_normalizer-3.4.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:28bf57629c75e810b6ae989f03c0828d64d6b26a5e205535585f96093e405ed1", size = 139471 }, + { url = "https://files.pythonhosted.org/packages/71/64/d24ab1a997efb06402e3fc07317e94da358e2585165930d9d59ad45fcae2/charset_normalizer-3.4.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f08ff5e948271dc7e18a35641d2f11a4cd8dfd5634f55228b691e62b37125eb3", size = 149831 }, + { url = "https://files.pythonhosted.org/packages/37/ed/be39e5258e198655240db5e19e0b11379163ad7070962d6b0c87ed2c4d39/charset_normalizer-3.4.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:234ac59ea147c59ee4da87a0c0f098e9c8d169f4dc2a159ef720f1a61bbe27cd", size = 142335 }, + { url = "https://files.pythonhosted.org/packages/88/83/489e9504711fa05d8dde1574996408026bdbdbd938f23be67deebb5eca92/charset_normalizer-3.4.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fd4ec41f914fa74ad1b8304bbc634b3de73d2a0889bd32076342a573e0779e00", size = 143862 }, + { url = "https://files.pythonhosted.org/packages/c6/c7/32da20821cf387b759ad24627a9aca289d2822de929b8a41b6241767b461/charset_normalizer-3.4.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:eea6ee1db730b3483adf394ea72f808b6e18cf3cb6454b4d86e04fa8c4327a12", size = 145673 }, + { url = "https://files.pythonhosted.org/packages/68/85/f4288e96039abdd5aeb5c546fa20a37b50da71b5cf01e75e87f16cd43304/charset_normalizer-3.4.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:c96836c97b1238e9c9e3fe90844c947d5afbf4f4c92762679acfe19927d81d77", size = 140211 }, + { url = "https://files.pythonhosted.org/packages/28/a3/a42e70d03cbdabc18997baf4f0227c73591a08041c149e710045c281f97b/charset_normalizer-3.4.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:4d86f7aff21ee58f26dcf5ae81a9addbd914115cdebcbb2217e4f0ed8982e146", size = 148039 }, + { url = "https://files.pythonhosted.org/packages/85/e4/65699e8ab3014ecbe6f5c71d1a55d810fb716bbfd74f6283d5c2aa87febf/charset_normalizer-3.4.1-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:09b5e6733cbd160dcc09589227187e242a30a49ca5cefa5a7edd3f9d19ed53fd", size = 151939 }, + { url = "https://files.pythonhosted.org/packages/b1/82/8e9fe624cc5374193de6860aba3ea8070f584c8565ee77c168ec13274bd2/charset_normalizer-3.4.1-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:5777ee0881f9499ed0f71cc82cf873d9a0ca8af166dfa0af8ec4e675b7df48e6", size = 149075 }, + { url = "https://files.pythonhosted.org/packages/3d/7b/82865ba54c765560c8433f65e8acb9217cb839a9e32b42af4aa8e945870f/charset_normalizer-3.4.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:237bdbe6159cff53b4f24f397d43c6336c6b0b42affbe857970cefbb620911c8", size = 144340 }, + { url = "https://files.pythonhosted.org/packages/b5/b6/9674a4b7d4d99a0d2df9b215da766ee682718f88055751e1e5e753c82db0/charset_normalizer-3.4.1-cp311-cp311-win32.whl", hash = "sha256:8417cb1f36cc0bc7eaba8ccb0e04d55f0ee52df06df3ad55259b9a323555fc8b", size = 95205 }, + { url = "https://files.pythonhosted.org/packages/1e/ab/45b180e175de4402dcf7547e4fb617283bae54ce35c27930a6f35b6bef15/charset_normalizer-3.4.1-cp311-cp311-win_amd64.whl", hash = "sha256:d7f50a1f8c450f3925cb367d011448c39239bb3eb4117c36a6d354794de4ce76", size = 102441 }, + { url = "https://files.pythonhosted.org/packages/0a/9a/dd1e1cdceb841925b7798369a09279bd1cf183cef0f9ddf15a3a6502ee45/charset_normalizer-3.4.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:73d94b58ec7fecbc7366247d3b0b10a21681004153238750bb67bd9012414545", size = 196105 }, + { url = "https://files.pythonhosted.org/packages/d3/8c/90bfabf8c4809ecb648f39794cf2a84ff2e7d2a6cf159fe68d9a26160467/charset_normalizer-3.4.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:dad3e487649f498dd991eeb901125411559b22e8d7ab25d3aeb1af367df5efd7", size = 140404 }, + { url = "https://files.pythonhosted.org/packages/ad/8f/e410d57c721945ea3b4f1a04b74f70ce8fa800d393d72899f0a40526401f/charset_normalizer-3.4.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c30197aa96e8eed02200a83fba2657b4c3acd0f0aa4bdc9f6c1af8e8962e0757", size = 150423 }, + { url = "https://files.pythonhosted.org/packages/f0/b8/e6825e25deb691ff98cf5c9072ee0605dc2acfca98af70c2d1b1bc75190d/charset_normalizer-3.4.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2369eea1ee4a7610a860d88f268eb39b95cb588acd7235e02fd5a5601773d4fa", size = 143184 }, + { url = "https://files.pythonhosted.org/packages/3e/a2/513f6cbe752421f16d969e32f3583762bfd583848b763913ddab8d9bfd4f/charset_normalizer-3.4.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bc2722592d8998c870fa4e290c2eec2c1569b87fe58618e67d38b4665dfa680d", size = 145268 }, + { url = "https://files.pythonhosted.org/packages/74/94/8a5277664f27c3c438546f3eb53b33f5b19568eb7424736bdc440a88a31f/charset_normalizer-3.4.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ffc9202a29ab3920fa812879e95a9e78b2465fd10be7fcbd042899695d75e616", size = 147601 }, + { url = "https://files.pythonhosted.org/packages/7c/5f/6d352c51ee763623a98e31194823518e09bfa48be2a7e8383cf691bbb3d0/charset_normalizer-3.4.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:804a4d582ba6e5b747c625bf1255e6b1507465494a40a2130978bda7b932c90b", size = 141098 }, + { url = "https://files.pythonhosted.org/packages/78/d4/f5704cb629ba5ab16d1d3d741396aec6dc3ca2b67757c45b0599bb010478/charset_normalizer-3.4.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:0f55e69f030f7163dffe9fd0752b32f070566451afe180f99dbeeb81f511ad8d", size = 149520 }, + { url = "https://files.pythonhosted.org/packages/c5/96/64120b1d02b81785f222b976c0fb79a35875457fa9bb40827678e54d1bc8/charset_normalizer-3.4.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:c4c3e6da02df6fa1410a7680bd3f63d4f710232d3139089536310d027950696a", size = 152852 }, + { url = "https://files.pythonhosted.org/packages/84/c9/98e3732278a99f47d487fd3468bc60b882920cef29d1fa6ca460a1fdf4e6/charset_normalizer-3.4.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:5df196eb874dae23dcfb968c83d4f8fdccb333330fe1fc278ac5ceeb101003a9", size = 150488 }, + { url = "https://files.pythonhosted.org/packages/13/0e/9c8d4cb99c98c1007cc11eda969ebfe837bbbd0acdb4736d228ccaabcd22/charset_normalizer-3.4.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e358e64305fe12299a08e08978f51fc21fac060dcfcddd95453eabe5b93ed0e1", size = 146192 }, + { url = "https://files.pythonhosted.org/packages/b2/21/2b6b5b860781a0b49427309cb8670785aa543fb2178de875b87b9cc97746/charset_normalizer-3.4.1-cp312-cp312-win32.whl", hash = "sha256:9b23ca7ef998bc739bf6ffc077c2116917eabcc901f88da1b9856b210ef63f35", size = 95550 }, + { url = "https://files.pythonhosted.org/packages/21/5b/1b390b03b1d16c7e382b561c5329f83cc06623916aab983e8ab9239c7d5c/charset_normalizer-3.4.1-cp312-cp312-win_amd64.whl", hash = "sha256:6ff8a4a60c227ad87030d76e99cd1698345d4491638dfa6673027c48b3cd395f", size = 102785 }, + { url = "https://files.pythonhosted.org/packages/38/94/ce8e6f63d18049672c76d07d119304e1e2d7c6098f0841b51c666e9f44a0/charset_normalizer-3.4.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:aabfa34badd18f1da5ec1bc2715cadc8dca465868a4e73a0173466b688f29dda", size = 195698 }, + { url = "https://files.pythonhosted.org/packages/24/2e/dfdd9770664aae179a96561cc6952ff08f9a8cd09a908f259a9dfa063568/charset_normalizer-3.4.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:22e14b5d70560b8dd51ec22863f370d1e595ac3d024cb8ad7d308b4cd95f8313", size = 140162 }, + { url = "https://files.pythonhosted.org/packages/24/4e/f646b9093cff8fc86f2d60af2de4dc17c759de9d554f130b140ea4738ca6/charset_normalizer-3.4.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8436c508b408b82d87dc5f62496973a1805cd46727c34440b0d29d8a2f50a6c9", size = 150263 }, + { url = "https://files.pythonhosted.org/packages/5e/67/2937f8d548c3ef6e2f9aab0f6e21001056f692d43282b165e7c56023e6dd/charset_normalizer-3.4.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2d074908e1aecee37a7635990b2c6d504cd4766c7bc9fc86d63f9c09af3fa11b", size = 142966 }, + { url = "https://files.pythonhosted.org/packages/52/ed/b7f4f07de100bdb95c1756d3a4d17b90c1a3c53715c1a476f8738058e0fa/charset_normalizer-3.4.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:955f8851919303c92343d2f66165294848d57e9bba6cf6e3625485a70a038d11", size = 144992 }, + { url = "https://files.pythonhosted.org/packages/96/2c/d49710a6dbcd3776265f4c923bb73ebe83933dfbaa841c5da850fe0fd20b/charset_normalizer-3.4.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:44ecbf16649486d4aebafeaa7ec4c9fed8b88101f4dd612dcaf65d5e815f837f", size = 147162 }, + { url = "https://files.pythonhosted.org/packages/b4/41/35ff1f9a6bd380303dea55e44c4933b4cc3c4850988927d4082ada230273/charset_normalizer-3.4.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:0924e81d3d5e70f8126529951dac65c1010cdf117bb75eb02dd12339b57749dd", size = 140972 }, + { url = "https://files.pythonhosted.org/packages/fb/43/c6a0b685fe6910d08ba971f62cd9c3e862a85770395ba5d9cad4fede33ab/charset_normalizer-3.4.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:2967f74ad52c3b98de4c3b32e1a44e32975e008a9cd2a8cc8966d6a5218c5cb2", size = 149095 }, + { url = "https://files.pythonhosted.org/packages/4c/ff/a9a504662452e2d2878512115638966e75633519ec11f25fca3d2049a94a/charset_normalizer-3.4.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:c75cb2a3e389853835e84a2d8fb2b81a10645b503eca9bcb98df6b5a43eb8886", size = 152668 }, + { url = "https://files.pythonhosted.org/packages/6c/71/189996b6d9a4b932564701628af5cee6716733e9165af1d5e1b285c530ed/charset_normalizer-3.4.1-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:09b26ae6b1abf0d27570633b2b078a2a20419c99d66fb2823173d73f188ce601", size = 150073 }, + { url = "https://files.pythonhosted.org/packages/e4/93/946a86ce20790e11312c87c75ba68d5f6ad2208cfb52b2d6a2c32840d922/charset_normalizer-3.4.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:fa88b843d6e211393a37219e6a1c1df99d35e8fd90446f1118f4216e307e48cd", size = 145732 }, + { url = "https://files.pythonhosted.org/packages/cd/e5/131d2fb1b0dddafc37be4f3a2fa79aa4c037368be9423061dccadfd90091/charset_normalizer-3.4.1-cp313-cp313-win32.whl", hash = "sha256:eb8178fe3dba6450a3e024e95ac49ed3400e506fd4e9e5c32d30adda88cbd407", size = 95391 }, + { url = "https://files.pythonhosted.org/packages/27/f2/4f9a69cc7712b9b5ad8fdb87039fd89abba997ad5cbe690d1835d40405b0/charset_normalizer-3.4.1-cp313-cp313-win_amd64.whl", hash = "sha256:b1ac5992a838106edb89654e0aebfc24f5848ae2547d22c2c3f66454daa11971", size = 102702 }, + { url = "https://files.pythonhosted.org/packages/bb/a6/3a22521736a3a75263ce930a2257eb60fd2a6b8fd9293ea1271a074a202f/charset_normalizer-3.4.1-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f30bf9fd9be89ecb2360c7d94a711f00c09b976258846efe40db3d05828e8089", size = 135247 }, + { url = "https://files.pythonhosted.org/packages/c2/1e/fa099993d17c00addbb76b3bfcd3ab1692fefc4e193ba738e111c09cfbe2/charset_normalizer-3.4.1-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:97f68b8d6831127e4787ad15e6757232e14e12060bec17091b85eb1486b91d8d", size = 144536 }, + { url = "https://files.pythonhosted.org/packages/c2/95/8725b2b2fcb418abe048b5558af42e444161433a76b47759539fe5bb7992/charset_normalizer-3.4.1-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7974a0b5ecd505609e3b19742b60cee7aa2aa2fb3151bc917e6e2646d7667dcf", size = 137661 }, + { url = "https://files.pythonhosted.org/packages/10/2f/6e2c727649d5e97ee17230f4c064480c69eb563f52ba87df448647d77a99/charset_normalizer-3.4.1-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fc54db6c8593ef7d4b2a331b58653356cf04f67c960f584edb7c3d8c97e8f39e", size = 138592 }, + { url = "https://files.pythonhosted.org/packages/e9/1b/0cad3a4f1906dc36a9cc89093d36b134638463e8e43479dbb96fd47d99ef/charset_normalizer-3.4.1-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:311f30128d7d333eebd7896965bfcfbd0065f1716ec92bd5638d7748eb6f936a", size = 141250 }, + { url = "https://files.pythonhosted.org/packages/8f/aa/73a89701dd661d9b5d24d0594c42ed0f7a3aed4448cc4f8f7315d0701399/charset_normalizer-3.4.1-cp37-cp37m-musllinux_1_2_aarch64.whl", hash = "sha256:7d053096f67cd1241601111b698f5cad775f97ab25d81567d3f59219b5f1adbd", size = 135234 }, + { url = "https://files.pythonhosted.org/packages/a8/00/b8b43690ecac81e5038dc6332681757123ee9c4c15eb4a6ecf0232393f59/charset_normalizer-3.4.1-cp37-cp37m-musllinux_1_2_i686.whl", hash = "sha256:807f52c1f798eef6cf26beb819eeb8819b1622ddfeef9d0977a8502d4db6d534", size = 142457 }, + { url = "https://files.pythonhosted.org/packages/ec/a3/2db14427b37cefbf9a9ec3d3c861e1b1721e4d4507536df102c2854966dc/charset_normalizer-3.4.1-cp37-cp37m-musllinux_1_2_ppc64le.whl", hash = "sha256:dccbe65bd2f7f7ec22c4ff99ed56faa1e9f785482b9bbd7c717e26fd723a1d1e", size = 145967 }, + { url = "https://files.pythonhosted.org/packages/0a/97/a183d752295997d95d20f2aa34d66ff6abda5af5482d0e7995dbbc9a753a/charset_normalizer-3.4.1-cp37-cp37m-musllinux_1_2_s390x.whl", hash = "sha256:2fb9bd477fdea8684f78791a6de97a953c51831ee2981f8e4f583ff3b9d9687e", size = 145129 }, + { url = "https://files.pythonhosted.org/packages/96/c6/f62d90c0e66525a374c35a1389f4290e5d7a731cd2cfacd9740272f927f9/charset_normalizer-3.4.1-cp37-cp37m-musllinux_1_2_x86_64.whl", hash = "sha256:01732659ba9b5b873fc117534143e4feefecf3b2078b0a6a2e925271bb6f4cfa", size = 138515 }, + { url = "https://files.pythonhosted.org/packages/0b/fe/4ade940a1b4bac031357b4a74fc8406a2ecd9dfc007dea850c5b7ee348de/charset_normalizer-3.4.1-cp37-cp37m-win32.whl", hash = "sha256:7a4f97a081603d2050bfaffdefa5b02a9ec823f8348a572e39032caa8404a487", size = 93486 }, + { url = "https://files.pythonhosted.org/packages/89/17/74bb34d02d62a21cc626c7d4db475b6f2207980f6beb002051db8342b139/charset_normalizer-3.4.1-cp37-cp37m-win_amd64.whl", hash = "sha256:7b1bef6280950ee6c177b326508f86cad7ad4dff12454483b51d8b7d673a2c5d", size = 100195 }, + { url = "https://files.pythonhosted.org/packages/10/bd/6517ea94f2672e801011d50b5d06be2a0deaf566aea27bcdcd47e5195357/charset_normalizer-3.4.1-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:ecddf25bee22fe4fe3737a399d0d177d72bc22be6913acfab364b40bce1ba83c", size = 195653 }, + { url = "https://files.pythonhosted.org/packages/e5/0d/815a2ba3f283b4eeaa5ece57acade365c5b4135f65a807a083c818716582/charset_normalizer-3.4.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8c60ca7339acd497a55b0ea5d506b2a2612afb2826560416f6894e8b5770d4a9", size = 140701 }, + { url = "https://files.pythonhosted.org/packages/aa/17/c94be7ee0d142687e047fe1de72060f6d6837f40eedc26e87e6e124a3fc6/charset_normalizer-3.4.1-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b7b2d86dd06bfc2ade3312a83a5c364c7ec2e3498f8734282c6c3d4b07b346b8", size = 150495 }, + { url = "https://files.pythonhosted.org/packages/f7/33/557ac796c47165fc141e4fb71d7b0310f67e05cb420756f3a82e0a0068e0/charset_normalizer-3.4.1-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:dd78cfcda14a1ef52584dbb008f7ac81c1328c0f58184bf9a84c49c605002da6", size = 142946 }, + { url = "https://files.pythonhosted.org/packages/1e/0d/38ef4ae41e9248d63fc4998d933cae22473b1b2ac4122cf908d0f5eb32aa/charset_normalizer-3.4.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6e27f48bcd0957c6d4cb9d6fa6b61d192d0b13d5ef563e5f2ae35feafc0d179c", size = 144737 }, + { url = "https://files.pythonhosted.org/packages/43/01/754cdb29dd0560f58290aaaa284d43eea343ad0512e6ad3b8b5c11f08592/charset_normalizer-3.4.1-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:01ad647cdd609225c5350561d084b42ddf732f4eeefe6e678765636791e78b9a", size = 147471 }, + { url = "https://files.pythonhosted.org/packages/ba/cd/861883ba5160c7a9bd242c30b2c71074cda2aefcc0addc91118e0d4e0765/charset_normalizer-3.4.1-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:619a609aa74ae43d90ed2e89bdd784765de0a25ca761b93e196d938b8fd1dbbd", size = 140801 }, + { url = "https://files.pythonhosted.org/packages/6f/7f/0c0dad447819e90b93f8ed238cc8f11b91353c23c19e70fa80483a155bed/charset_normalizer-3.4.1-cp38-cp38-musllinux_1_2_i686.whl", hash = "sha256:89149166622f4db9b4b6a449256291dc87a99ee53151c74cbd82a53c8c2f6ccd", size = 149312 }, + { url = "https://files.pythonhosted.org/packages/8e/09/9f8abcc6fff60fb727268b63c376c8c79cc37b833c2dfe1f535dfb59523b/charset_normalizer-3.4.1-cp38-cp38-musllinux_1_2_ppc64le.whl", hash = "sha256:7709f51f5f7c853f0fb938bcd3bc59cdfdc5203635ffd18bf354f6967ea0f824", size = 152347 }, + { url = "https://files.pythonhosted.org/packages/be/e5/3f363dad2e24378f88ccf63ecc39e817c29f32e308ef21a7a6d9c1201165/charset_normalizer-3.4.1-cp38-cp38-musllinux_1_2_s390x.whl", hash = "sha256:345b0426edd4e18138d6528aed636de7a9ed169b4aaf9d61a8c19e39d26838ca", size = 149888 }, + { url = "https://files.pythonhosted.org/packages/e4/10/a78c0e91f487b4ad0ef7480ac765e15b774f83de2597f1b6ef0eaf7a2f99/charset_normalizer-3.4.1-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:0907f11d019260cdc3f94fbdb23ff9125f6b5d1039b76003b5b0ac9d6a6c9d5b", size = 145169 }, + { url = "https://files.pythonhosted.org/packages/d3/81/396e7d7f5d7420da8273c91175d2e9a3f569288e3611d521685e4b9ac9cc/charset_normalizer-3.4.1-cp38-cp38-win32.whl", hash = "sha256:ea0d8d539afa5eb2728aa1932a988a9a7af94f18582ffae4bc10b3fbdad0626e", size = 95094 }, + { url = "https://files.pythonhosted.org/packages/40/bb/20affbbd9ea29c71ea123769dc568a6d42052ff5089c5fe23e21e21084a6/charset_normalizer-3.4.1-cp38-cp38-win_amd64.whl", hash = "sha256:329ce159e82018d646c7ac45b01a430369d526569ec08516081727a20e9e4af4", size = 102139 }, + { url = "https://files.pythonhosted.org/packages/7f/c0/b913f8f02836ed9ab32ea643c6fe4d3325c3d8627cf6e78098671cafff86/charset_normalizer-3.4.1-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:b97e690a2118911e39b4042088092771b4ae3fc3aa86518f84b8cf6888dbdb41", size = 197867 }, + { url = "https://files.pythonhosted.org/packages/0f/6c/2bee440303d705b6fb1e2ec789543edec83d32d258299b16eed28aad48e0/charset_normalizer-3.4.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:78baa6d91634dfb69ec52a463534bc0df05dbd546209b79a3880a34487f4b84f", size = 141385 }, + { url = "https://files.pythonhosted.org/packages/3d/04/cb42585f07f6f9fd3219ffb6f37d5a39b4fd2db2355b23683060029c35f7/charset_normalizer-3.4.1-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1a2bc9f351a75ef49d664206d51f8e5ede9da246602dc2d2726837620ea034b2", size = 151367 }, + { url = "https://files.pythonhosted.org/packages/54/54/2412a5b093acb17f0222de007cc129ec0e0df198b5ad2ce5699355269dfe/charset_normalizer-3.4.1-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:75832c08354f595c760a804588b9357d34ec00ba1c940c15e31e96d902093770", size = 143928 }, + { url = "https://files.pythonhosted.org/packages/5a/6d/e2773862b043dcf8a221342954f375392bb2ce6487bcd9f2c1b34e1d6781/charset_normalizer-3.4.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0af291f4fe114be0280cdd29d533696a77b5b49cfde5467176ecab32353395c4", size = 146203 }, + { url = "https://files.pythonhosted.org/packages/b9/f8/ca440ef60d8f8916022859885f231abb07ada3c347c03d63f283bec32ef5/charset_normalizer-3.4.1-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0167ddc8ab6508fe81860a57dd472b2ef4060e8d378f0cc555707126830f2537", size = 148082 }, + { url = "https://files.pythonhosted.org/packages/04/d2/42fd330901aaa4b805a1097856c2edf5095e260a597f65def493f4b8c833/charset_normalizer-3.4.1-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:2a75d49014d118e4198bcee5ee0a6f25856b29b12dbf7cd012791f8a6cc5c496", size = 142053 }, + { url = "https://files.pythonhosted.org/packages/9e/af/3a97a4fa3c53586f1910dadfc916e9c4f35eeada36de4108f5096cb7215f/charset_normalizer-3.4.1-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:363e2f92b0f0174b2f8238240a1a30142e3db7b957a5dd5689b0e75fb717cc78", size = 150625 }, + { url = "https://files.pythonhosted.org/packages/26/ae/23d6041322a3556e4da139663d02fb1b3c59a23ab2e2b56432bd2ad63ded/charset_normalizer-3.4.1-cp39-cp39-musllinux_1_2_ppc64le.whl", hash = "sha256:ab36c8eb7e454e34e60eb55ca5d241a5d18b2c6244f6827a30e451c42410b5f7", size = 153549 }, + { url = "https://files.pythonhosted.org/packages/94/22/b8f2081c6a77cb20d97e57e0b385b481887aa08019d2459dc2858ed64871/charset_normalizer-3.4.1-cp39-cp39-musllinux_1_2_s390x.whl", hash = "sha256:4c0907b1928a36d5a998d72d64d8eaa7244989f7aaaf947500d3a800c83a3fd6", size = 150945 }, + { url = "https://files.pythonhosted.org/packages/c7/0b/c5ec5092747f801b8b093cdf5610e732b809d6cb11f4c51e35fc28d1d389/charset_normalizer-3.4.1-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:04432ad9479fa40ec0f387795ddad4437a2b50417c69fa275e212933519ff294", size = 146595 }, + { url = "https://files.pythonhosted.org/packages/0c/5a/0b59704c38470df6768aa154cc87b1ac7c9bb687990a1559dc8765e8627e/charset_normalizer-3.4.1-cp39-cp39-win32.whl", hash = "sha256:3bed14e9c89dcb10e8f3a29f9ccac4955aebe93c71ae803af79265c9ca5644c5", size = 95453 }, + { url = "https://files.pythonhosted.org/packages/85/2d/a9790237cb4d01a6d57afadc8573c8b73c609ade20b80f4cda30802009ee/charset_normalizer-3.4.1-cp39-cp39-win_amd64.whl", hash = "sha256:49402233c892a461407c512a19435d1ce275543138294f7ef013f0b63d5d3765", size = 102811 }, + { url = "https://files.pythonhosted.org/packages/0e/f6/65ecc6878a89bb1c23a086ea335ad4bf21a588990c3f535a227b9eea9108/charset_normalizer-3.4.1-py3-none-any.whl", hash = "sha256:d98b1668f06378c6dbefec3b92299716b931cd4e6061f3c875a71ced1780ab85", size = 49767 }, +] + +[[package]] +name = "click" +version = "8.1.8" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama", marker = "python_full_version >= '3.9' and sys_platform == 'win32'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b9/2e/0090cbf739cee7d23781ad4b89a9894a41538e4fcf4c31dcdd705b78eb8b/click-8.1.8.tar.gz", hash = "sha256:ed53c9d8990d83c2a27deae68e4ee337473f6330c040a31d4225c9574d16096a", size = 226593 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7e/d4/7ebdbd03970677812aac39c869717059dbb71a4cfc033ca6e5221787892c/click-8.1.8-py3-none-any.whl", hash = "sha256:63c132bbbed01578a06712a2d1f497bb62d9c1c0d329b7903a866228027263b2", size = 98188 }, +] + +[[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 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335 }, +] + +[[package]] +name = "comm" +version = "0.2.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "traitlets", version = "5.14.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.8'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/e9/a8/fb783cb0abe2b5fded9f55e5703015cdf1c9c85b3669087c538dd15a6a86/comm-0.2.2.tar.gz", hash = "sha256:3fd7a84065306e07bea1773df6eb8282de51ba82f77c72f9c85716ab11fe980e", size = 6210 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e6/75/49e5bfe642f71f272236b5b2d2691cf915a7283cc0ceda56357b61daa538/comm-0.2.2-py3-none-any.whl", hash = "sha256:e6fb86cb70ff661ee8c9c14e7d36d6de3b4066f1441be4063df9c5009f0a64d3", size = 7180 }, +] + +[[package]] +name = "contourpy" +version = "1.1.1" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version == '3.8.*'", +] +dependencies = [ + { name = "numpy", version = "1.24.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.8.*'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b1/7d/087ee4295e7580d3f7eb8a8a4e0ec8c7847e60f34135248ccf831cf5bbfc/contourpy-1.1.1.tar.gz", hash = "sha256:96ba37c2e24b7212a77da85004c38e7c4d155d3e72a45eeaf22c1f03f607e8ab", size = 13433167 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fb/7f/c44a51a83a093bf5c84e07dd1e3cfe9f68c47b6499bd05a9de0c6dbdc2bc/contourpy-1.1.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:46e24f5412c948d81736509377e255f6040e94216bf1a9b5ea1eaa9d29f6ec1b", size = 247207 }, + { url = "https://files.pythonhosted.org/packages/a9/65/544d66da0716b20084874297ff7596704e435cf011512f8e576638e83db2/contourpy-1.1.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:0e48694d6a9c5a26ee85b10130c77a011a4fedf50a7279fa0bdaf44bafb4299d", size = 232428 }, + { url = "https://files.pythonhosted.org/packages/5b/e6/697085cc34a294bd399548fd99562537a75408f113e3a815807e206246f0/contourpy-1.1.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a66045af6cf00e19d02191ab578a50cb93b2028c3eefed999793698e9ea768ae", size = 285304 }, + { url = "https://files.pythonhosted.org/packages/69/4b/52d0d2e85c59f00f6ddbd6fea819f267008c58ee7708da96d112a293e91c/contourpy-1.1.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4ebf42695f75ee1a952f98ce9775c873e4971732a87334b099dde90b6af6a916", size = 322655 }, + { url = "https://files.pythonhosted.org/packages/82/fc/3decc656a547a6d5d5b4249f81c72668a1f3259a62b2def2504120d38746/contourpy-1.1.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f6aec19457617ef468ff091669cca01fa7ea557b12b59a7908b9474bb9674cf0", size = 296430 }, + { url = "https://files.pythonhosted.org/packages/f1/6b/e4b0f8708f22dd7c321f87eadbb98708975e115ac6582eb46d1f32197ce6/contourpy-1.1.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:462c59914dc6d81e0b11f37e560b8a7c2dbab6aca4f38be31519d442d6cde1a1", size = 301672 }, + { url = "https://files.pythonhosted.org/packages/c3/87/201410522a756e605069078833d806147cad8532fdc164a96689d05c5afc/contourpy-1.1.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:6d0a8efc258659edc5299f9ef32d8d81de8b53b45d67bf4bfa3067f31366764d", size = 820145 }, + { url = "https://files.pythonhosted.org/packages/b4/d9/42680a17d43edda04ab2b3f11125cf97b61bce5d3b52721a42960bf748bd/contourpy-1.1.1-cp310-cp310-win32.whl", hash = "sha256:d6ab42f223e58b7dac1bb0af32194a7b9311065583cc75ff59dcf301afd8a431", size = 399542 }, + { url = "https://files.pythonhosted.org/packages/55/14/0dc1884e3c04f9b073a47283f5d424926644250891db392a07c56f05e5c5/contourpy-1.1.1-cp310-cp310-win_amd64.whl", hash = "sha256:549174b0713d49871c6dee90a4b499d3f12f5e5f69641cd23c50a4542e2ca1eb", size = 477974 }, + { url = "https://files.pythonhosted.org/packages/8b/4f/be28a39cd5e988b8d3c2cc642c2c7ffeeb28fe80a86df71b6d1e473c5038/contourpy-1.1.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:407d864db716a067cc696d61fa1ef6637fedf03606e8417fe2aeed20a061e6b2", size = 248613 }, + { url = "https://files.pythonhosted.org/packages/2c/8e/656f8e7cd316aa68d9824744773e90dbd71f847429d10c82001e927480a2/contourpy-1.1.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:dfe80c017973e6a4c367e037cb31601044dd55e6bfacd57370674867d15a899b", size = 233603 }, + { url = "https://files.pythonhosted.org/packages/60/2a/4d4bd4541212ab98f3411f21bf58b0b246f333ae996e9f57e1acf12bcc45/contourpy-1.1.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e30aaf2b8a2bac57eb7e1650df1b3a4130e8d0c66fc2f861039d507a11760e1b", size = 287037 }, + { url = "https://files.pythonhosted.org/packages/24/67/8abf919443381585a4eee74069e311c736350549dae02d3d014fef93d50a/contourpy-1.1.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3de23ca4f381c3770dee6d10ead6fff524d540c0f662e763ad1530bde5112532", size = 323274 }, + { url = "https://files.pythonhosted.org/packages/2a/e5/6da11329dd35a2f2e404a95e5374b5702de6ac52e776e8b87dd6ea4b29d0/contourpy-1.1.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:566f0e41df06dfef2431defcfaa155f0acfa1ca4acbf8fd80895b1e7e2ada40e", size = 297801 }, + { url = "https://files.pythonhosted.org/packages/b7/f6/78f60fa0b6ae64971178e2542e8b3ad3ba5f4f379b918ab7b18038a3f897/contourpy-1.1.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b04c2f0adaf255bf756cf08ebef1be132d3c7a06fe6f9877d55640c5e60c72c5", size = 302821 }, + { url = "https://files.pythonhosted.org/packages/da/25/6062395a1c6a06f46a577da821318886b8b939453a098b9cd61671bb497b/contourpy-1.1.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:d0c188ae66b772d9d61d43c6030500344c13e3f73a00d1dc241da896f379bb62", size = 820121 }, + { url = "https://files.pythonhosted.org/packages/41/5e/64e78b1e8682cbab10c13fc1a2c070d30acedb805ab2f42afbd3d88f7225/contourpy-1.1.1-cp311-cp311-win32.whl", hash = "sha256:0683e1ae20dc038075d92e0e0148f09ffcefab120e57f6b4c9c0f477ec171f33", size = 401590 }, + { url = "https://files.pythonhosted.org/packages/e5/76/94bc17eb868f8c7397f8fdfdeae7661c1b9a35f3a7219da308596e8c252a/contourpy-1.1.1-cp311-cp311-win_amd64.whl", hash = "sha256:8636cd2fc5da0fb102a2504fa2c4bea3cbc149533b345d72cdf0e7a924decc45", size = 480534 }, + { url = "https://files.pythonhosted.org/packages/94/0f/07a5e26fec7176658f6aecffc615900ff1d303baa2b67bc37fd98ce67c87/contourpy-1.1.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:560f1d68a33e89c62da5da4077ba98137a5e4d3a271b29f2f195d0fba2adcb6a", size = 249799 }, + { url = "https://files.pythonhosted.org/packages/32/0b/d7baca3f60d3b3a77c9ba1307c7792befd3c1c775a26c649dca1bfa9b6ba/contourpy-1.1.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:24216552104ae8f3b34120ef84825400b16eb6133af2e27a190fdc13529f023e", size = 232739 }, + { url = "https://files.pythonhosted.org/packages/6d/62/a385b4d4b5718e3a933de5791528f45f1f5b364d3c79172ad0309c832041/contourpy-1.1.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:56de98a2fb23025882a18b60c7f0ea2d2d70bbbcfcf878f9067234b1c4818442", size = 282171 }, + { url = "https://files.pythonhosted.org/packages/91/21/8c6819747fea53557f3963ca936035b3e8bed87d591f5278ad62516a059d/contourpy-1.1.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:07d6f11dfaf80a84c97f1a5ba50d129d9303c5b4206f776e94037332e298dda8", size = 321182 }, + { url = "https://files.pythonhosted.org/packages/22/29/d75da9002f9df09c755b12cf0357eb91b081c858e604f4e92b4b8bfc3c15/contourpy-1.1.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f1eaac5257a8f8a047248d60e8f9315c6cff58f7803971170d952555ef6344a7", size = 295869 }, + { url = "https://files.pythonhosted.org/packages/a7/47/4e7e66159f881c131e3b97d1cc5c0ea72be62bdd292c7f63fd13937d07f4/contourpy-1.1.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:19557fa407e70f20bfaba7d55b4d97b14f9480856c4fb65812e8a05fe1c6f9bf", size = 298756 }, + { url = "https://files.pythonhosted.org/packages/d3/bb/bffc99bc3172942b5eda8027ca0cb80ddd336fcdd634d68adce957d37231/contourpy-1.1.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:081f3c0880712e40effc5f4c3b08feca6d064cb8cfbb372ca548105b86fd6c3d", size = 818441 }, + { url = "https://files.pythonhosted.org/packages/da/1b/904baf0aaaf6c6e2247801dcd1ff0d7bf84352839927d356b28ae804cbb0/contourpy-1.1.1-cp312-cp312-win32.whl", hash = "sha256:059c3d2a94b930f4dafe8105bcdc1b21de99b30b51b5bce74c753686de858cb6", size = 410294 }, + { url = "https://files.pythonhosted.org/packages/75/d4/c3b7a9a0d1f99b528e5a46266b0b9f13aad5a0dd1156d071418df314c427/contourpy-1.1.1-cp312-cp312-win_amd64.whl", hash = "sha256:f44d78b61740e4e8c71db1cf1fd56d9050a4747681c59ec1094750a658ceb970", size = 486678 }, + { url = "https://files.pythonhosted.org/packages/02/7e/ffaba1bf3719088be3ad6983a5e85e1fc9edccd7b406b98e433436ecef74/contourpy-1.1.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:70e5a10f8093d228bb2b552beeb318b8928b8a94763ef03b858ef3612b29395d", size = 247023 }, + { url = "https://files.pythonhosted.org/packages/a6/82/29f5ff4ae074c3230e266bc9efef449ebde43721a727b989dd8ef8f97d73/contourpy-1.1.1-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:8394e652925a18ef0091115e3cc191fef350ab6dc3cc417f06da66bf98071ae9", size = 232380 }, + { url = "https://files.pythonhosted.org/packages/9b/cb/08f884c4c2efd433a38876b1b8069bfecef3f2d21ff0ce635d455962f70f/contourpy-1.1.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c5bd5680f844c3ff0008523a71949a3ff5e4953eb7701b28760805bc9bcff217", size = 285830 }, + { url = "https://files.pythonhosted.org/packages/8e/57/cd4d4c99d999a25e9d518f628b4793e64b1ecb8ad3147f8469d8d4a80678/contourpy-1.1.1-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:66544f853bfa85c0d07a68f6c648b2ec81dafd30f272565c37ab47a33b220684", size = 322038 }, + { url = "https://files.pythonhosted.org/packages/32/b6/c57ed305a6f86731107fc183e97c7e6a6005d145f5c5228a44718082ad12/contourpy-1.1.1-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e0c02b75acfea5cab07585d25069207e478d12309557f90a61b5a3b4f77f46ce", size = 295797 }, + { url = "https://files.pythonhosted.org/packages/8e/71/7f20855592cc929bc206810432b991ec4c702dc26b0567b132e52c85536f/contourpy-1.1.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:41339b24471c58dc1499e56783fedc1afa4bb018bcd035cfb0ee2ad2a7501ef8", size = 301124 }, + { url = "https://files.pythonhosted.org/packages/86/6d/52c2fc80f433e7cdc8624d82e1422ad83ad461463cf16a1953bbc7d10eb1/contourpy-1.1.1-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:f29fb0b3f1217dfe9362ec55440d0743fe868497359f2cf93293f4b2701b8251", size = 819787 }, + { url = "https://files.pythonhosted.org/packages/d0/b0/f8d4548e89f929d6c5ca329df9afad6190af60079ec77d8c31eb48cf6f82/contourpy-1.1.1-cp38-cp38-win32.whl", hash = "sha256:f9dc7f933975367251c1b34da882c4f0e0b2e24bb35dc906d2f598a40b72bfc7", size = 400031 }, + { url = "https://files.pythonhosted.org/packages/96/1b/b05cd42c8d21767a0488b883b38658fb9a45f86c293b7b42521a8113dc5d/contourpy-1.1.1-cp38-cp38-win_amd64.whl", hash = "sha256:498e53573e8b94b1caeb9e62d7c2d053c263ebb6aa259c81050766beb50ff8d9", size = 477949 }, + { url = "https://files.pythonhosted.org/packages/16/d9/8a15ff67fc27c65939e454512955e1b240ec75cd201d82e115b3b63ef76d/contourpy-1.1.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:ba42e3810999a0ddd0439e6e5dbf6d034055cdc72b7c5c839f37a7c274cb4eba", size = 247396 }, + { url = "https://files.pythonhosted.org/packages/09/fe/086e6847ee53da10ddf0b6c5e5f877ab43e68e355d2f4c85f67561ee8a57/contourpy-1.1.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:6c06e4c6e234fcc65435223c7b2a90f286b7f1b2733058bdf1345d218cc59e34", size = 232598 }, + { url = "https://files.pythonhosted.org/packages/a3/9c/662925239e1185c6cf1da8c334e4c61bddcfa8e528f4b51083b613003170/contourpy-1.1.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ca6fab080484e419528e98624fb5c4282148b847e3602dc8dbe0cb0669469887", size = 286436 }, + { url = "https://files.pythonhosted.org/packages/d3/7e/417cdf65da7140981079eda6a81ecd593ae0239bf8c738f2e2b3f6df8920/contourpy-1.1.1-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:93df44ab351119d14cd1e6b52a5063d3336f0754b72736cc63db59307dabb718", size = 322629 }, + { url = "https://files.pythonhosted.org/packages/a8/22/ffd88aef74cc045698c5e5c400e8b7cd62311199c109245ac7827290df2c/contourpy-1.1.1-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:eafbef886566dc1047d7b3d4b14db0d5b7deb99638d8e1be4e23a7c7ac59ff0f", size = 297117 }, + { url = "https://files.pythonhosted.org/packages/2b/c0/24c34c41a180f875419b536125799c61e2330b997d77a5a818a3bc3e08cd/contourpy-1.1.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:efe0fab26d598e1ec07d72cf03eaeeba8e42b4ecf6b9ccb5a356fde60ff08b85", size = 301855 }, + { url = "https://files.pythonhosted.org/packages/bf/ec/f9877f6378a580cd683bd76c8a781dcd972e82965e0da951a739d3364677/contourpy-1.1.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:f08e469821a5e4751c97fcd34bcb586bc243c39c2e39321822060ba902eac49e", size = 820597 }, + { url = "https://files.pythonhosted.org/packages/e1/3a/c41f4bc7122d3a06388acae1bed6f50a665c1031863ca42bd701094dcb1f/contourpy-1.1.1-cp39-cp39-win32.whl", hash = "sha256:bfc8a5e9238232a45ebc5cb3bfee71f1167064c8d382cadd6076f0d51cff1da0", size = 400031 }, + { url = "https://files.pythonhosted.org/packages/87/2b/9b49451f7412cc1a79198e94a771a4e52d65c479aae610b1161c0290ef2c/contourpy-1.1.1-cp39-cp39-win_amd64.whl", hash = "sha256:c84fdf3da00c2827d634de4fcf17e3e067490c4aea82833625c4c8e6cdea0887", size = 435965 }, + { url = "https://files.pythonhosted.org/packages/e6/3c/fc36884b6793e2066a6ff25c86e21b8bd62553456b07e964c260bcf22711/contourpy-1.1.1-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:229a25f68046c5cf8067d6d6351c8b99e40da11b04d8416bf8d2b1d75922521e", size = 246493 }, + { url = "https://files.pythonhosted.org/packages/3d/85/f4c5b09ce79828ed4553a8ae2ebdf937794f57b45848b1f5c95d9744ecc2/contourpy-1.1.1-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a10dab5ea1bd4401c9483450b5b0ba5416be799bbd50fc7a6cc5e2a15e03e8a3", size = 289240 }, + { url = "https://files.pythonhosted.org/packages/18/d3/9d7c0a372baf5130c1417a4b8275079d5379c11355436cb9fc78af7d7559/contourpy-1.1.1-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:4f9147051cb8fdb29a51dc2482d792b3b23e50f8f57e3720ca2e3d438b7adf23", size = 476043 }, + { url = "https://files.pythonhosted.org/packages/e7/12/643242c3d9b031ca19f9a440f63e568dd883a04711056ca5d607f9bda888/contourpy-1.1.1-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:a75cc163a5f4531a256f2c523bd80db509a49fc23721b36dd1ef2f60ff41c3cb", size = 246247 }, + { url = "https://files.pythonhosted.org/packages/e1/37/95716fe235bf441422059e4afcd4b9b7c5821851c2aee992a06d1e9f831a/contourpy-1.1.1-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3b53d5769aa1f2d4ea407c65f2d1d08002952fac1d9e9d307aa2e1023554a163", size = 289029 }, + { url = "https://files.pythonhosted.org/packages/e5/fd/14852c4a688031e0d8a20d9a1b60078d45507186ef17042093835be2f01a/contourpy-1.1.1-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:11b836b7dbfb74e049c302bbf74b4b8f6cb9d0b6ca1bf86cfa8ba144aedadd9c", size = 476043 }, +] + +[[package]] +name = "contourpy" +version = "1.3.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version == '3.9.*'", +] +dependencies = [ + { name = "numpy", version = "2.0.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/f5/f6/31a8f28b4a2a4fa0e01085e542f3081ab0588eff8e589d39d775172c9792/contourpy-1.3.0.tar.gz", hash = "sha256:7ffa0db17717a8ffb127efd0c95a4362d996b892c2904db72428d5b52e1938a4", size = 13464370 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/6c/e0/be8dcc796cfdd96708933e0e2da99ba4bb8f9b2caa9d560a50f3f09a65f3/contourpy-1.3.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:880ea32e5c774634f9fcd46504bf9f080a41ad855f4fef54f5380f5133d343c7", size = 265366 }, + { url = "https://files.pythonhosted.org/packages/50/d6/c953b400219443535d412fcbbc42e7a5e823291236bc0bb88936e3cc9317/contourpy-1.3.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:76c905ef940a4474a6289c71d53122a4f77766eef23c03cd57016ce19d0f7b42", size = 249226 }, + { url = "https://files.pythonhosted.org/packages/6f/b4/6fffdf213ffccc28483c524b9dad46bb78332851133b36ad354b856ddc7c/contourpy-1.3.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:92f8557cbb07415a4d6fa191f20fd9d2d9eb9c0b61d1b2f52a8926e43c6e9af7", size = 308460 }, + { url = "https://files.pythonhosted.org/packages/cf/6c/118fc917b4050f0afe07179a6dcbe4f3f4ec69b94f36c9e128c4af480fb8/contourpy-1.3.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:36f965570cff02b874773c49bfe85562b47030805d7d8360748f3eca570f4cab", size = 347623 }, + { url = "https://files.pythonhosted.org/packages/f9/a4/30ff110a81bfe3abf7b9673284d21ddce8cc1278f6f77393c91199da4c90/contourpy-1.3.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:cacd81e2d4b6f89c9f8a5b69b86490152ff39afc58a95af002a398273e5ce589", size = 317761 }, + { url = "https://files.pythonhosted.org/packages/99/e6/d11966962b1aa515f5586d3907ad019f4b812c04e4546cc19ebf62b5178e/contourpy-1.3.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:69375194457ad0fad3a839b9e29aa0b0ed53bb54db1bfb6c3ae43d111c31ce41", size = 322015 }, + { url = "https://files.pythonhosted.org/packages/4d/e3/182383743751d22b7b59c3c753277b6aee3637049197624f333dac5b4c80/contourpy-1.3.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:7a52040312b1a858b5e31ef28c2e865376a386c60c0e248370bbea2d3f3b760d", size = 1262672 }, + { url = "https://files.pythonhosted.org/packages/78/53/974400c815b2e605f252c8fb9297e2204347d1755a5374354ee77b1ea259/contourpy-1.3.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:3faeb2998e4fcb256542e8a926d08da08977f7f5e62cf733f3c211c2a5586223", size = 1321688 }, + { url = "https://files.pythonhosted.org/packages/52/29/99f849faed5593b2926a68a31882af98afbeac39c7fdf7de491d9c85ec6a/contourpy-1.3.0-cp310-cp310-win32.whl", hash = "sha256:36e0cff201bcb17a0a8ecc7f454fe078437fa6bda730e695a92f2d9932bd507f", size = 171145 }, + { url = "https://files.pythonhosted.org/packages/a9/97/3f89bba79ff6ff2b07a3cbc40aa693c360d5efa90d66e914f0ff03b95ec7/contourpy-1.3.0-cp310-cp310-win_amd64.whl", hash = "sha256:87ddffef1dbe5e669b5c2440b643d3fdd8622a348fe1983fad7a0f0ccb1cd67b", size = 216019 }, + { url = "https://files.pythonhosted.org/packages/b3/1f/9375917786cb39270b0ee6634536c0e22abf225825602688990d8f5c6c19/contourpy-1.3.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:0fa4c02abe6c446ba70d96ece336e621efa4aecae43eaa9b030ae5fb92b309ad", size = 266356 }, + { url = "https://files.pythonhosted.org/packages/05/46/9256dd162ea52790c127cb58cfc3b9e3413a6e3478917d1f811d420772ec/contourpy-1.3.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:834e0cfe17ba12f79963861e0f908556b2cedd52e1f75e6578801febcc6a9f49", size = 250915 }, + { url = "https://files.pythonhosted.org/packages/e1/5d/3056c167fa4486900dfbd7e26a2fdc2338dc58eee36d490a0ed3ddda5ded/contourpy-1.3.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:dbc4c3217eee163fa3984fd1567632b48d6dfd29216da3ded3d7b844a8014a66", size = 310443 }, + { url = "https://files.pythonhosted.org/packages/ca/c2/1a612e475492e07f11c8e267ea5ec1ce0d89971be496c195e27afa97e14a/contourpy-1.3.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4865cd1d419e0c7a7bf6de1777b185eebdc51470800a9f42b9e9decf17762081", size = 348548 }, + { url = "https://files.pythonhosted.org/packages/45/cf/2c2fc6bb5874158277b4faf136847f0689e1b1a1f640a36d76d52e78907c/contourpy-1.3.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:303c252947ab4b14c08afeb52375b26781ccd6a5ccd81abcdfc1fafd14cf93c1", size = 319118 }, + { url = "https://files.pythonhosted.org/packages/03/33/003065374f38894cdf1040cef474ad0546368eea7e3a51d48b8a423961f8/contourpy-1.3.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:637f674226be46f6ba372fd29d9523dd977a291f66ab2a74fbeb5530bb3f445d", size = 323162 }, + { url = "https://files.pythonhosted.org/packages/42/80/e637326e85e4105a802e42959f56cff2cd39a6b5ef68d5d9aee3ea5f0e4c/contourpy-1.3.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:76a896b2f195b57db25d6b44e7e03f221d32fe318d03ede41f8b4d9ba1bff53c", size = 1265396 }, + { url = "https://files.pythonhosted.org/packages/7c/3b/8cbd6416ca1bbc0202b50f9c13b2e0b922b64be888f9d9ee88e6cfabfb51/contourpy-1.3.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:e1fd23e9d01591bab45546c089ae89d926917a66dceb3abcf01f6105d927e2cb", size = 1324297 }, + { url = "https://files.pythonhosted.org/packages/4d/2c/021a7afaa52fe891f25535506cc861c30c3c4e5a1c1ce94215e04b293e72/contourpy-1.3.0-cp311-cp311-win32.whl", hash = "sha256:d402880b84df3bec6eab53cd0cf802cae6a2ef9537e70cf75e91618a3801c20c", size = 171808 }, + { url = "https://files.pythonhosted.org/packages/8d/2f/804f02ff30a7fae21f98198828d0857439ec4c91a96e20cf2d6c49372966/contourpy-1.3.0-cp311-cp311-win_amd64.whl", hash = "sha256:6cb6cc968059db9c62cb35fbf70248f40994dfcd7aa10444bbf8b3faeb7c2d67", size = 217181 }, + { url = "https://files.pythonhosted.org/packages/c9/92/8e0bbfe6b70c0e2d3d81272b58c98ac69ff1a4329f18c73bd64824d8b12e/contourpy-1.3.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:570ef7cf892f0afbe5b2ee410c507ce12e15a5fa91017a0009f79f7d93a1268f", size = 267838 }, + { url = "https://files.pythonhosted.org/packages/e3/04/33351c5d5108460a8ce6d512307690b023f0cfcad5899499f5c83b9d63b1/contourpy-1.3.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:da84c537cb8b97d153e9fb208c221c45605f73147bd4cadd23bdae915042aad6", size = 251549 }, + { url = "https://files.pythonhosted.org/packages/51/3d/aa0fe6ae67e3ef9f178389e4caaaa68daf2f9024092aa3c6032e3d174670/contourpy-1.3.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0be4d8425bfa755e0fd76ee1e019636ccc7c29f77a7c86b4328a9eb6a26d0639", size = 303177 }, + { url = "https://files.pythonhosted.org/packages/56/c3/c85a7e3e0cab635575d3b657f9535443a6f5d20fac1a1911eaa4bbe1aceb/contourpy-1.3.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9c0da700bf58f6e0b65312d0a5e695179a71d0163957fa381bb3c1f72972537c", size = 341735 }, + { url = "https://files.pythonhosted.org/packages/dd/8d/20f7a211a7be966a53f474bc90b1a8202e9844b3f1ef85f3ae45a77151ee/contourpy-1.3.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:eb8b141bb00fa977d9122636b16aa67d37fd40a3d8b52dd837e536d64b9a4d06", size = 314679 }, + { url = "https://files.pythonhosted.org/packages/6e/be/524e377567defac0e21a46e2a529652d165fed130a0d8a863219303cee18/contourpy-1.3.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3634b5385c6716c258d0419c46d05c8aa7dc8cb70326c9a4fb66b69ad2b52e09", size = 320549 }, + { url = "https://files.pythonhosted.org/packages/0f/96/fdb2552a172942d888915f3a6663812e9bc3d359d53dafd4289a0fb462f0/contourpy-1.3.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:0dce35502151b6bd35027ac39ba6e5a44be13a68f55735c3612c568cac3805fd", size = 1263068 }, + { url = "https://files.pythonhosted.org/packages/2a/25/632eab595e3140adfa92f1322bf8915f68c932bac468e89eae9974cf1c00/contourpy-1.3.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:aea348f053c645100612b333adc5983d87be69acdc6d77d3169c090d3b01dc35", size = 1322833 }, + { url = "https://files.pythonhosted.org/packages/73/e3/69738782e315a1d26d29d71a550dbbe3eb6c653b028b150f70c1a5f4f229/contourpy-1.3.0-cp312-cp312-win32.whl", hash = "sha256:90f73a5116ad1ba7174341ef3ea5c3150ddf20b024b98fb0c3b29034752c8aeb", size = 172681 }, + { url = "https://files.pythonhosted.org/packages/0c/89/9830ba00d88e43d15e53d64931e66b8792b46eb25e2050a88fec4a0df3d5/contourpy-1.3.0-cp312-cp312-win_amd64.whl", hash = "sha256:b11b39aea6be6764f84360fce6c82211a9db32a7c7de8fa6dd5397cf1d079c3b", size = 218283 }, + { url = "https://files.pythonhosted.org/packages/53/a1/d20415febfb2267af2d7f06338e82171824d08614084714fb2c1dac9901f/contourpy-1.3.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:3e1c7fa44aaae40a2247e2e8e0627f4bea3dd257014764aa644f319a5f8600e3", size = 267879 }, + { url = "https://files.pythonhosted.org/packages/aa/45/5a28a3570ff6218d8bdfc291a272a20d2648104815f01f0177d103d985e1/contourpy-1.3.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:364174c2a76057feef647c802652f00953b575723062560498dc7930fc9b1cb7", size = 251573 }, + { url = "https://files.pythonhosted.org/packages/39/1c/d3f51540108e3affa84f095c8b04f0aa833bb797bc8baa218a952a98117d/contourpy-1.3.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:32b238b3b3b649e09ce9aaf51f0c261d38644bdfa35cbaf7b263457850957a84", size = 303184 }, + { url = "https://files.pythonhosted.org/packages/00/56/1348a44fb6c3a558c1a3a0cd23d329d604c99d81bf5a4b58c6b71aab328f/contourpy-1.3.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d51fca85f9f7ad0b65b4b9fe800406d0d77017d7270d31ec3fb1cc07358fdea0", size = 340262 }, + { url = "https://files.pythonhosted.org/packages/2b/23/00d665ba67e1bb666152131da07e0f24c95c3632d7722caa97fb61470eca/contourpy-1.3.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:732896af21716b29ab3e988d4ce14bc5133733b85956316fb0c56355f398099b", size = 313806 }, + { url = "https://files.pythonhosted.org/packages/5a/42/3cf40f7040bb8362aea19af9a5fb7b32ce420f645dd1590edcee2c657cd5/contourpy-1.3.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d73f659398a0904e125280836ae6f88ba9b178b2fed6884f3b1f95b989d2c8da", size = 319710 }, + { url = "https://files.pythonhosted.org/packages/05/32/f3bfa3fc083b25e1a7ae09197f897476ee68e7386e10404bdf9aac7391f0/contourpy-1.3.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:c6c7c2408b7048082932cf4e641fa3b8ca848259212f51c8c59c45aa7ac18f14", size = 1264107 }, + { url = "https://files.pythonhosted.org/packages/1c/1e/1019d34473a736664f2439542b890b2dc4c6245f5c0d8cdfc0ccc2cab80c/contourpy-1.3.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:f317576606de89da6b7e0861cf6061f6146ead3528acabff9236458a6ba467f8", size = 1322458 }, + { url = "https://files.pythonhosted.org/packages/22/85/4f8bfd83972cf8909a4d36d16b177f7b8bdd942178ea4bf877d4a380a91c/contourpy-1.3.0-cp313-cp313-win32.whl", hash = "sha256:31cd3a85dbdf1fc002280c65caa7e2b5f65e4a973fcdf70dd2fdcb9868069294", size = 172643 }, + { url = "https://files.pythonhosted.org/packages/cc/4a/fb3c83c1baba64ba90443626c228ca14f19a87c51975d3b1de308dd2cf08/contourpy-1.3.0-cp313-cp313-win_amd64.whl", hash = "sha256:4553c421929ec95fb07b3aaca0fae668b2eb5a5203d1217ca7c34c063c53d087", size = 218301 }, + { url = "https://files.pythonhosted.org/packages/76/65/702f4064f397821fea0cb493f7d3bc95a5d703e20954dce7d6d39bacf378/contourpy-1.3.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:345af746d7766821d05d72cb8f3845dfd08dd137101a2cb9b24de277d716def8", size = 278972 }, + { url = "https://files.pythonhosted.org/packages/80/85/21f5bba56dba75c10a45ec00ad3b8190dbac7fd9a8a8c46c6116c933e9cf/contourpy-1.3.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:3bb3808858a9dc68f6f03d319acd5f1b8a337e6cdda197f02f4b8ff67ad2057b", size = 263375 }, + { url = "https://files.pythonhosted.org/packages/0a/64/084c86ab71d43149f91ab3a4054ccf18565f0a8af36abfa92b1467813ed6/contourpy-1.3.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:420d39daa61aab1221567b42eecb01112908b2cab7f1b4106a52caaec8d36973", size = 307188 }, + { url = "https://files.pythonhosted.org/packages/3d/ff/d61a4c288dc42da0084b8d9dc2aa219a850767165d7d9a9c364ff530b509/contourpy-1.3.0-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4d63ee447261e963af02642ffcb864e5a2ee4cbfd78080657a9880b8b1868e18", size = 345644 }, + { url = "https://files.pythonhosted.org/packages/ca/aa/00d2313d35ec03f188e8f0786c2fc61f589306e02fdc158233697546fd58/contourpy-1.3.0-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:167d6c890815e1dac9536dca00828b445d5d0df4d6a8c6adb4a7ec3166812fa8", size = 317141 }, + { url = "https://files.pythonhosted.org/packages/8d/6a/b5242c8cb32d87f6abf4f5e3044ca397cb1a76712e3fa2424772e3ff495f/contourpy-1.3.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:710a26b3dc80c0e4febf04555de66f5fd17e9cf7170a7b08000601a10570bda6", size = 323469 }, + { url = "https://files.pythonhosted.org/packages/6f/a6/73e929d43028a9079aca4bde107494864d54f0d72d9db508a51ff0878593/contourpy-1.3.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:75ee7cb1a14c617f34a51d11fa7524173e56551646828353c4af859c56b766e2", size = 1260894 }, + { url = "https://files.pythonhosted.org/packages/2b/1e/1e726ba66eddf21c940821df8cf1a7d15cb165f0682d62161eaa5e93dae1/contourpy-1.3.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:33c92cdae89ec5135d036e7218e69b0bb2851206077251f04a6c4e0e21f03927", size = 1314829 }, + { url = "https://files.pythonhosted.org/packages/b3/e3/b9f72758adb6ef7397327ceb8b9c39c75711affb220e4f53c745ea1d5a9a/contourpy-1.3.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:a11077e395f67ffc2c44ec2418cfebed032cd6da3022a94fc227b6faf8e2acb8", size = 265518 }, + { url = "https://files.pythonhosted.org/packages/ec/22/19f5b948367ab5260fb41d842c7a78dae645603881ea6bc39738bcfcabf6/contourpy-1.3.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:e8134301d7e204c88ed7ab50028ba06c683000040ede1d617298611f9dc6240c", size = 249350 }, + { url = "https://files.pythonhosted.org/packages/26/76/0c7d43263dd00ae21a91a24381b7e813d286a3294d95d179ef3a7b9fb1d7/contourpy-1.3.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e12968fdfd5bb45ffdf6192a590bd8ddd3ba9e58360b29683c6bb71a7b41edca", size = 309167 }, + { url = "https://files.pythonhosted.org/packages/96/3b/cadff6773e89f2a5a492c1a8068e21d3fccaf1a1c1df7d65e7c8e3ef60ba/contourpy-1.3.0-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:fd2a0fc506eccaaa7595b7e1418951f213cf8255be2600f1ea1b61e46a60c55f", size = 348279 }, + { url = "https://files.pythonhosted.org/packages/e1/86/158cc43aa549d2081a955ab11c6bdccc7a22caacc2af93186d26f5f48746/contourpy-1.3.0-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4cfb5c62ce023dfc410d6059c936dcf96442ba40814aefbfa575425a3a7f19dc", size = 318519 }, + { url = "https://files.pythonhosted.org/packages/05/11/57335544a3027e9b96a05948c32e566328e3a2f84b7b99a325b7a06d2b06/contourpy-1.3.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:68a32389b06b82c2fdd68276148d7b9275b5f5cf13e5417e4252f6d1a34f72a2", size = 321922 }, + { url = "https://files.pythonhosted.org/packages/0b/e3/02114f96543f4a1b694333b92a6dcd4f8eebbefcc3a5f3bbb1316634178f/contourpy-1.3.0-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:94e848a6b83da10898cbf1311a815f770acc9b6a3f2d646f330d57eb4e87592e", size = 1258017 }, + { url = "https://files.pythonhosted.org/packages/f3/3b/bfe4c81c6d5881c1c643dde6620be0b42bf8aab155976dd644595cfab95c/contourpy-1.3.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:d78ab28a03c854a873787a0a42254a0ccb3cb133c672f645c9f9c8f3ae9d0800", size = 1316773 }, + { url = "https://files.pythonhosted.org/packages/f1/17/c52d2970784383cafb0bd918b6fb036d98d96bbf0bc1befb5d1e31a07a70/contourpy-1.3.0-cp39-cp39-win32.whl", hash = "sha256:81cb5ed4952aae6014bc9d0421dec7c5835c9c8c31cdf51910b708f548cf58e5", size = 171353 }, + { url = "https://files.pythonhosted.org/packages/53/23/db9f69676308e094d3c45f20cc52e12d10d64f027541c995d89c11ad5c75/contourpy-1.3.0-cp39-cp39-win_amd64.whl", hash = "sha256:14e262f67bd7e6eb6880bc564dcda30b15e351a594657e55b7eec94b6ef72843", size = 211817 }, + { url = "https://files.pythonhosted.org/packages/d1/09/60e486dc2b64c94ed33e58dcfb6f808192c03dfc5574c016218b9b7680dc/contourpy-1.3.0-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:fe41b41505a5a33aeaed2a613dccaeaa74e0e3ead6dd6fd3a118fb471644fd6c", size = 261886 }, + { url = "https://files.pythonhosted.org/packages/19/20/b57f9f7174fcd439a7789fb47d764974ab646fa34d1790551de386457a8e/contourpy-1.3.0-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eca7e17a65f72a5133bdbec9ecf22401c62bcf4821361ef7811faee695799779", size = 311008 }, + { url = "https://files.pythonhosted.org/packages/74/fc/5040d42623a1845d4f17a418e590fd7a79ae8cb2bad2b2f83de63c3bdca4/contourpy-1.3.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:1ec4dc6bf570f5b22ed0d7efba0dfa9c5b9e0431aeea7581aa217542d9e809a4", size = 215690 }, + { url = "https://files.pythonhosted.org/packages/2b/24/dc3dcd77ac7460ab7e9d2b01a618cb31406902e50e605a8d6091f0a8f7cc/contourpy-1.3.0-pp39-pypy39_pp73-macosx_10_15_x86_64.whl", hash = "sha256:00ccd0dbaad6d804ab259820fa7cb0b8036bda0686ef844d24125d8287178ce0", size = 261894 }, + { url = "https://files.pythonhosted.org/packages/b1/db/531642a01cfec39d1682e46b5457b07cf805e3c3c584ec27e2a6223f8f6c/contourpy-1.3.0-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8ca947601224119117f7c19c9cdf6b3ab54c5726ef1d906aa4a69dfb6dd58102", size = 311099 }, + { url = "https://files.pythonhosted.org/packages/38/1e/94bda024d629f254143a134eead69e21c836429a2a6ce82209a00ddcb79a/contourpy-1.3.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:c6ec93afeb848a0845a18989da3beca3eec2c0f852322efe21af1931147d12cb", size = 215838 }, +] + +[[package]] +name = "contourpy" +version = "1.3.1" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", + "python_full_version == '3.10.*'", +] +dependencies = [ + { name = "numpy", version = "2.2.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/25/c2/fc7193cc5383637ff390a712e88e4ded0452c9fbcf84abe3de5ea3df1866/contourpy-1.3.1.tar.gz", hash = "sha256:dfd97abd83335045a913e3bcc4a09c0ceadbe66580cf573fe961f4a825efa699", size = 13465753 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b2/a3/80937fe3efe0edacf67c9a20b955139a1a622730042c1ea991956f2704ad/contourpy-1.3.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:a045f341a77b77e1c5de31e74e966537bba9f3c4099b35bf4c2e3939dd54cdab", size = 268466 }, + { url = "https://files.pythonhosted.org/packages/82/1d/e3eaebb4aa2d7311528c048350ca8e99cdacfafd99da87bc0a5f8d81f2c2/contourpy-1.3.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:500360b77259914f7805af7462e41f9cb7ca92ad38e9f94d6c8641b089338124", size = 253314 }, + { url = "https://files.pythonhosted.org/packages/de/f3/d796b22d1a2b587acc8100ba8c07fb7b5e17fde265a7bb05ab967f4c935a/contourpy-1.3.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b2f926efda994cdf3c8d3fdb40b9962f86edbc4457e739277b961eced3d0b4c1", size = 312003 }, + { url = "https://files.pythonhosted.org/packages/bf/f5/0e67902bc4394daee8daa39c81d4f00b50e063ee1a46cb3938cc65585d36/contourpy-1.3.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:adce39d67c0edf383647a3a007de0a45fd1b08dedaa5318404f1a73059c2512b", size = 351896 }, + { url = "https://files.pythonhosted.org/packages/1f/d6/e766395723f6256d45d6e67c13bb638dd1fa9dc10ef912dc7dd3dcfc19de/contourpy-1.3.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:abbb49fb7dac584e5abc6636b7b2a7227111c4f771005853e7d25176daaf8453", size = 320814 }, + { url = "https://files.pythonhosted.org/packages/a9/57/86c500d63b3e26e5b73a28b8291a67c5608d4aa87ebd17bd15bb33c178bc/contourpy-1.3.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a0cffcbede75c059f535725c1680dfb17b6ba8753f0c74b14e6a9c68c29d7ea3", size = 324969 }, + { url = "https://files.pythonhosted.org/packages/b8/62/bb146d1289d6b3450bccc4642e7f4413b92ebffd9bf2e91b0404323704a7/contourpy-1.3.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:ab29962927945d89d9b293eabd0d59aea28d887d4f3be6c22deaefbb938a7277", size = 1265162 }, + { url = "https://files.pythonhosted.org/packages/18/04/9f7d132ce49a212c8e767042cc80ae390f728060d2eea47058f55b9eff1c/contourpy-1.3.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:974d8145f8ca354498005b5b981165b74a195abfae9a8129df3e56771961d595", size = 1324328 }, + { url = "https://files.pythonhosted.org/packages/46/23/196813901be3f97c83ababdab1382e13e0edc0bb4e7b49a7bff15fcf754e/contourpy-1.3.1-cp310-cp310-win32.whl", hash = "sha256:ac4578ac281983f63b400f7fe6c101bedc10651650eef012be1ccffcbacf3697", size = 173861 }, + { url = "https://files.pythonhosted.org/packages/e0/82/c372be3fc000a3b2005061ca623a0d1ecd2eaafb10d9e883a2fc8566e951/contourpy-1.3.1-cp310-cp310-win_amd64.whl", hash = "sha256:174e758c66bbc1c8576992cec9599ce8b6672b741b5d336b5c74e35ac382b18e", size = 218566 }, + { url = "https://files.pythonhosted.org/packages/12/bb/11250d2906ee2e8b466b5f93e6b19d525f3e0254ac8b445b56e618527718/contourpy-1.3.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:3e8b974d8db2c5610fb4e76307e265de0edb655ae8169e8b21f41807ccbeec4b", size = 269555 }, + { url = "https://files.pythonhosted.org/packages/67/71/1e6e95aee21a500415f5d2dbf037bf4567529b6a4e986594d7026ec5ae90/contourpy-1.3.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:20914c8c973f41456337652a6eeca26d2148aa96dd7ac323b74516988bea89fc", size = 254549 }, + { url = "https://files.pythonhosted.org/packages/31/2c/b88986e8d79ac45efe9d8801ae341525f38e087449b6c2f2e6050468a42c/contourpy-1.3.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:19d40d37c1c3a4961b4619dd9d77b12124a453cc3d02bb31a07d58ef684d3d86", size = 313000 }, + { url = "https://files.pythonhosted.org/packages/c4/18/65280989b151fcf33a8352f992eff71e61b968bef7432fbfde3a364f0730/contourpy-1.3.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:113231fe3825ebf6f15eaa8bc1f5b0ddc19d42b733345eae0934cb291beb88b6", size = 352925 }, + { url = "https://files.pythonhosted.org/packages/f5/c7/5fd0146c93220dbfe1a2e0f98969293b86ca9bc041d6c90c0e065f4619ad/contourpy-1.3.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4dbbc03a40f916a8420e420d63e96a1258d3d1b58cbdfd8d1f07b49fcbd38e85", size = 323693 }, + { url = "https://files.pythonhosted.org/packages/85/fc/7fa5d17daf77306840a4e84668a48ddff09e6bc09ba4e37e85ffc8e4faa3/contourpy-1.3.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3a04ecd68acbd77fa2d39723ceca4c3197cb2969633836ced1bea14e219d077c", size = 326184 }, + { url = "https://files.pythonhosted.org/packages/ef/e7/104065c8270c7397c9571620d3ab880558957216f2b5ebb7e040f85eeb22/contourpy-1.3.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:c414fc1ed8ee1dbd5da626cf3710c6013d3d27456651d156711fa24f24bd1291", size = 1268031 }, + { url = "https://files.pythonhosted.org/packages/e2/4a/c788d0bdbf32c8113c2354493ed291f924d4793c4a2e85b69e737a21a658/contourpy-1.3.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:31c1b55c1f34f80557d3830d3dd93ba722ce7e33a0b472cba0ec3b6535684d8f", size = 1325995 }, + { url = "https://files.pythonhosted.org/packages/a6/e6/a2f351a90d955f8b0564caf1ebe4b1451a3f01f83e5e3a414055a5b8bccb/contourpy-1.3.1-cp311-cp311-win32.whl", hash = "sha256:f611e628ef06670df83fce17805c344710ca5cde01edfdc72751311da8585375", size = 174396 }, + { url = "https://files.pythonhosted.org/packages/a8/7e/cd93cab453720a5d6cb75588cc17dcdc08fc3484b9de98b885924ff61900/contourpy-1.3.1-cp311-cp311-win_amd64.whl", hash = "sha256:b2bdca22a27e35f16794cf585832e542123296b4687f9fd96822db6bae17bfc9", size = 219787 }, + { url = "https://files.pythonhosted.org/packages/37/6b/175f60227d3e7f5f1549fcb374592be311293132207e451c3d7c654c25fb/contourpy-1.3.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:0ffa84be8e0bd33410b17189f7164c3589c229ce5db85798076a3fa136d0e509", size = 271494 }, + { url = "https://files.pythonhosted.org/packages/6b/6a/7833cfae2c1e63d1d8875a50fd23371394f540ce809d7383550681a1fa64/contourpy-1.3.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:805617228ba7e2cbbfb6c503858e626ab528ac2a32a04a2fe88ffaf6b02c32bc", size = 255444 }, + { url = "https://files.pythonhosted.org/packages/7f/b3/7859efce66eaca5c14ba7619791b084ed02d868d76b928ff56890d2d059d/contourpy-1.3.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ade08d343436a94e633db932e7e8407fe7de8083967962b46bdfc1b0ced39454", size = 307628 }, + { url = "https://files.pythonhosted.org/packages/48/b2/011415f5e3f0a50b1e285a0bf78eb5d92a4df000553570f0851b6e309076/contourpy-1.3.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:47734d7073fb4590b4a40122b35917cd77be5722d80683b249dac1de266aac80", size = 347271 }, + { url = "https://files.pythonhosted.org/packages/84/7d/ef19b1db0f45b151ac78c65127235239a8cf21a59d1ce8507ce03e89a30b/contourpy-1.3.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2ba94a401342fc0f8b948e57d977557fbf4d515f03c67682dd5c6191cb2d16ec", size = 318906 }, + { url = "https://files.pythonhosted.org/packages/ba/99/6794142b90b853a9155316c8f470d2e4821fe6f086b03e372aca848227dd/contourpy-1.3.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:efa874e87e4a647fd2e4f514d5e91c7d493697127beb95e77d2f7561f6905bd9", size = 323622 }, + { url = "https://files.pythonhosted.org/packages/3c/0f/37d2c84a900cd8eb54e105f4fa9aebd275e14e266736778bb5dccbf3bbbb/contourpy-1.3.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:1bf98051f1045b15c87868dbaea84f92408337d4f81d0e449ee41920ea121d3b", size = 1266699 }, + { url = "https://files.pythonhosted.org/packages/3a/8a/deb5e11dc7d9cc8f0f9c8b29d4f062203f3af230ba83c30a6b161a6effc9/contourpy-1.3.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:61332c87493b00091423e747ea78200659dc09bdf7fd69edd5e98cef5d3e9a8d", size = 1326395 }, + { url = "https://files.pythonhosted.org/packages/1a/35/7e267ae7c13aaf12322ccc493531f1e7f2eb8fba2927b9d7a05ff615df7a/contourpy-1.3.1-cp312-cp312-win32.whl", hash = "sha256:e914a8cb05ce5c809dd0fe350cfbb4e881bde5e2a38dc04e3afe1b3e58bd158e", size = 175354 }, + { url = "https://files.pythonhosted.org/packages/a1/35/c2de8823211d07e8a79ab018ef03960716c5dff6f4d5bff5af87fd682992/contourpy-1.3.1-cp312-cp312-win_amd64.whl", hash = "sha256:08d9d449a61cf53033612cb368f3a1b26cd7835d9b8cd326647efe43bca7568d", size = 220971 }, + { url = "https://files.pythonhosted.org/packages/9a/e7/de62050dce687c5e96f946a93546910bc67e483fe05324439e329ff36105/contourpy-1.3.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:a761d9ccfc5e2ecd1bf05534eda382aa14c3e4f9205ba5b1684ecfe400716ef2", size = 271548 }, + { url = "https://files.pythonhosted.org/packages/78/4d/c2a09ae014ae984c6bdd29c11e74d3121b25eaa117eca0bb76340efd7e1c/contourpy-1.3.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:523a8ee12edfa36f6d2a49407f705a6ef4c5098de4f498619787e272de93f2d5", size = 255576 }, + { url = "https://files.pythonhosted.org/packages/ab/8a/915380ee96a5638bda80cd061ccb8e666bfdccea38d5741cb69e6dbd61fc/contourpy-1.3.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ece6df05e2c41bd46776fbc712e0996f7c94e0d0543af1656956d150c4ca7c81", size = 306635 }, + { url = "https://files.pythonhosted.org/packages/29/5c/c83ce09375428298acd4e6582aeb68b1e0d1447f877fa993d9bf6cd3b0a0/contourpy-1.3.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:573abb30e0e05bf31ed067d2f82500ecfdaec15627a59d63ea2d95714790f5c2", size = 345925 }, + { url = "https://files.pythonhosted.org/packages/29/63/5b52f4a15e80c66c8078a641a3bfacd6e07106835682454647aca1afc852/contourpy-1.3.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a9fa36448e6a3a1a9a2ba23c02012c43ed88905ec80163f2ffe2421c7192a5d7", size = 318000 }, + { url = "https://files.pythonhosted.org/packages/9a/e2/30ca086c692691129849198659bf0556d72a757fe2769eb9620a27169296/contourpy-1.3.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3ea9924d28fc5586bf0b42d15f590b10c224117e74409dd7a0be3b62b74a501c", size = 322689 }, + { url = "https://files.pythonhosted.org/packages/6b/77/f37812ef700f1f185d348394debf33f22d531e714cf6a35d13d68a7003c7/contourpy-1.3.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:5b75aa69cb4d6f137b36f7eb2ace9280cfb60c55dc5f61c731fdf6f037f958a3", size = 1268413 }, + { url = "https://files.pythonhosted.org/packages/3f/6d/ce84e79cdd128542ebeb268f84abb4b093af78e7f8ec504676673d2675bc/contourpy-1.3.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:041b640d4ec01922083645a94bb3b2e777e6b626788f4095cf21abbe266413c1", size = 1326530 }, + { url = "https://files.pythonhosted.org/packages/72/22/8282f4eae20c73c89bee7a82a19c4e27af9b57bb602ecaa00713d5bdb54d/contourpy-1.3.1-cp313-cp313-win32.whl", hash = "sha256:36987a15e8ace5f58d4d5da9dca82d498c2bbb28dff6e5d04fbfcc35a9cb3a82", size = 175315 }, + { url = "https://files.pythonhosted.org/packages/e3/d5/28bca491f65312b438fbf076589dcde7f6f966b196d900777f5811b9c4e2/contourpy-1.3.1-cp313-cp313-win_amd64.whl", hash = "sha256:a7895f46d47671fa7ceec40f31fae721da51ad34bdca0bee83e38870b1f47ffd", size = 220987 }, + { url = "https://files.pythonhosted.org/packages/2f/24/a4b285d6adaaf9746e4700932f579f1a7b6f9681109f694cfa233ae75c4e/contourpy-1.3.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:9ddeb796389dadcd884c7eb07bd14ef12408aaae358f0e2ae24114d797eede30", size = 285001 }, + { url = "https://files.pythonhosted.org/packages/48/1d/fb49a401b5ca4f06ccf467cd6c4f1fd65767e63c21322b29b04ec40b40b9/contourpy-1.3.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:19c1555a6801c2f084c7ddc1c6e11f02eb6a6016ca1318dd5452ba3f613a1751", size = 268553 }, + { url = "https://files.pythonhosted.org/packages/79/1e/4aef9470d13fd029087388fae750dccb49a50c012a6c8d1d634295caa644/contourpy-1.3.1-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:841ad858cff65c2c04bf93875e384ccb82b654574a6d7f30453a04f04af71342", size = 310386 }, + { url = "https://files.pythonhosted.org/packages/b0/34/910dc706ed70153b60392b5305c708c9810d425bde12499c9184a1100888/contourpy-1.3.1-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4318af1c925fb9a4fb190559ef3eec206845f63e80fb603d47f2d6d67683901c", size = 349806 }, + { url = "https://files.pythonhosted.org/packages/31/3c/faee6a40d66d7f2a87f7102236bf4780c57990dd7f98e5ff29881b1b1344/contourpy-1.3.1-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:14c102b0eab282427b662cb590f2e9340a9d91a1c297f48729431f2dcd16e14f", size = 321108 }, + { url = "https://files.pythonhosted.org/packages/17/69/390dc9b20dd4bb20585651d7316cc3054b7d4a7b4f8b710b2b698e08968d/contourpy-1.3.1-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:05e806338bfeaa006acbdeba0ad681a10be63b26e1b17317bfac3c5d98f36cda", size = 327291 }, + { url = "https://files.pythonhosted.org/packages/ef/74/7030b67c4e941fe1e5424a3d988080e83568030ce0355f7c9fc556455b01/contourpy-1.3.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:4d76d5993a34ef3df5181ba3c92fabb93f1eaa5729504fb03423fcd9f3177242", size = 1263752 }, + { url = "https://files.pythonhosted.org/packages/f0/ed/92d86f183a8615f13f6b9cbfc5d4298a509d6ce433432e21da838b4b63f4/contourpy-1.3.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:89785bb2a1980c1bd87f0cb1517a71cde374776a5f150936b82580ae6ead44a1", size = 1318403 }, + { url = "https://files.pythonhosted.org/packages/b3/0e/c8e4950c77dcfc897c71d61e56690a0a9df39543d2164040301b5df8e67b/contourpy-1.3.1-cp313-cp313t-win32.whl", hash = "sha256:8eb96e79b9f3dcadbad2a3891672f81cdcab7f95b27f28f1c67d75f045b6b4f1", size = 185117 }, + { url = "https://files.pythonhosted.org/packages/c1/31/1ae946f11dfbd229222e6d6ad8e7bd1891d3d48bde5fbf7a0beb9491f8e3/contourpy-1.3.1-cp313-cp313t-win_amd64.whl", hash = "sha256:287ccc248c9e0d0566934e7d606201abd74761b5703d804ff3df8935f523d546", size = 236668 }, + { url = "https://files.pythonhosted.org/packages/3e/4f/e56862e64b52b55b5ddcff4090085521fc228ceb09a88390a2b103dccd1b/contourpy-1.3.1-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:b457d6430833cee8e4b8e9b6f07aa1c161e5e0d52e118dc102c8f9bd7dd060d6", size = 265605 }, + { url = "https://files.pythonhosted.org/packages/b0/2e/52bfeeaa4541889f23d8eadc6386b442ee2470bd3cff9baa67deb2dd5c57/contourpy-1.3.1-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cb76c1a154b83991a3cbbf0dfeb26ec2833ad56f95540b442c73950af2013750", size = 315040 }, + { url = "https://files.pythonhosted.org/packages/52/94/86bfae441707205634d80392e873295652fc313dfd93c233c52c4dc07874/contourpy-1.3.1-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:44a29502ca9c7b5ba389e620d44f2fbe792b1fb5734e8b931ad307071ec58c53", size = 218221 }, +] + +[[package]] +name = "coverage" +version = "7.2.7" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine != 'aarch64' and platform_machine != 'arm64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'aarch64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'arm64'", + "python_full_version < '3.7.1'", +] +sdist = { url = "https://files.pythonhosted.org/packages/45/8b/421f30467e69ac0e414214856798d4bc32da1336df745e49e49ae5c1e2a8/coverage-7.2.7.tar.gz", hash = "sha256:924d94291ca674905fe9481f12294eb11f2d3d3fd1adb20314ba89e94f44ed59", size = 762575 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/01/24/be01e62a7bce89bcffe04729c540382caa5a06bee45ae42136c93e2499f5/coverage-7.2.7-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:d39b5b4f2a66ccae8b7263ac3c8170994b65266797fb96cbbfd3fb5b23921db8", size = 200724 }, + { url = "https://files.pythonhosted.org/packages/3d/80/7060a445e1d2c9744b683dc935248613355657809d6c6b2716cdf4ca4766/coverage-7.2.7-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:6d040ef7c9859bb11dfeb056ff5b3872436e3b5e401817d87a31e1750b9ae2fb", size = 201024 }, + { url = "https://files.pythonhosted.org/packages/b8/9d/926fce7e03dbfc653104c2d981c0fa71f0572a9ebd344d24c573bd6f7c4f/coverage-7.2.7-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ba90a9563ba44a72fda2e85302c3abc71c5589cea608ca16c22b9804262aaeb6", size = 229528 }, + { url = "https://files.pythonhosted.org/packages/d1/3a/67f5d18f911abf96857f6f7e4df37ca840e38179e2cc9ab6c0b9c3380f19/coverage-7.2.7-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e7d9405291c6928619403db1d10bd07888888ec1abcbd9748fdaa971d7d661b2", size = 227842 }, + { url = "https://files.pythonhosted.org/packages/b4/bd/1b2331e3a04f4cc9b7b332b1dd0f3a1261dfc4114f8479bebfcc2afee9e8/coverage-7.2.7-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:31563e97dae5598556600466ad9beea39fb04e0229e61c12eaa206e0aa202063", size = 228717 }, + { url = "https://files.pythonhosted.org/packages/2b/86/3dbf9be43f8bf6a5ca28790a713e18902b2d884bc5fa9512823a81dff601/coverage-7.2.7-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:ebba1cd308ef115925421d3e6a586e655ca5a77b5bf41e02eb0e4562a111f2d1", size = 234632 }, + { url = "https://files.pythonhosted.org/packages/91/e8/469ed808a782b9e8305a08bad8c6fa5f8e73e093bda6546c5aec68275bff/coverage-7.2.7-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:cb017fd1b2603ef59e374ba2063f593abe0fc45f2ad9abdde5b4d83bd922a353", size = 232875 }, + { url = "https://files.pythonhosted.org/packages/29/8f/4fad1c2ba98104425009efd7eaa19af9a7c797e92d40cd2ec026fa1f58cb/coverage-7.2.7-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:d62a5c7dad11015c66fbb9d881bc4caa5b12f16292f857842d9d1871595f4495", size = 234094 }, + { url = "https://files.pythonhosted.org/packages/94/4e/d4e46a214ae857be3d7dc5de248ba43765f60daeb1ab077cb6c1536c7fba/coverage-7.2.7-cp310-cp310-win32.whl", hash = "sha256:ee57190f24fba796e36bb6d3aa8a8783c643d8fa9760c89f7a98ab5455fbf818", size = 203184 }, + { url = "https://files.pythonhosted.org/packages/1f/e9/d6730247d8dec2a3dddc520ebe11e2e860f0f98cee3639e23de6cf920255/coverage-7.2.7-cp310-cp310-win_amd64.whl", hash = "sha256:f75f7168ab25dd93110c8a8117a22450c19976afbc44234cbf71481094c1b850", size = 204096 }, + { url = "https://files.pythonhosted.org/packages/c6/fa/529f55c9a1029c840bcc9109d5a15ff00478b7ff550a1ae361f8745f8ad5/coverage-7.2.7-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:06a9a2be0b5b576c3f18f1a241f0473575c4a26021b52b2a85263a00f034d51f", size = 200895 }, + { url = "https://files.pythonhosted.org/packages/67/d7/cd8fe689b5743fffac516597a1222834c42b80686b99f5b44ef43ccc2a43/coverage-7.2.7-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:5baa06420f837184130752b7c5ea0808762083bf3487b5038d68b012e5937dbe", size = 201120 }, + { url = "https://files.pythonhosted.org/packages/8c/95/16eed713202406ca0a37f8ac259bbf144c9d24f9b8097a8e6ead61da2dbb/coverage-7.2.7-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fdec9e8cbf13a5bf63290fc6013d216a4c7232efb51548594ca3631a7f13c3a3", size = 233178 }, + { url = "https://files.pythonhosted.org/packages/c1/49/4d487e2ad5d54ed82ac1101e467e8994c09d6123c91b2a962145f3d262c2/coverage-7.2.7-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:52edc1a60c0d34afa421c9c37078817b2e67a392cab17d97283b64c5833f427f", size = 230754 }, + { url = "https://files.pythonhosted.org/packages/a7/cd/3ce94ad9d407a052dc2a74fbeb1c7947f442155b28264eb467ee78dea812/coverage-7.2.7-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:63426706118b7f5cf6bb6c895dc215d8a418d5952544042c8a2d9fe87fcf09cb", size = 232558 }, + { url = "https://files.pythonhosted.org/packages/8f/a8/12cc7b261f3082cc299ab61f677f7e48d93e35ca5c3c2f7241ed5525ccea/coverage-7.2.7-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:afb17f84d56068a7c29f5fa37bfd38d5aba69e3304af08ee94da8ed5b0865833", size = 241509 }, + { url = "https://files.pythonhosted.org/packages/04/fa/43b55101f75a5e9115259e8be70ff9279921cb6b17f04c34a5702ff9b1f7/coverage-7.2.7-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:48c19d2159d433ccc99e729ceae7d5293fbffa0bdb94952d3579983d1c8c9d97", size = 239924 }, + { url = "https://files.pythonhosted.org/packages/68/5f/d2bd0f02aa3c3e0311986e625ccf97fdc511b52f4f1a063e4f37b624772f/coverage-7.2.7-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:0e1f928eaf5469c11e886fe0885ad2bf1ec606434e79842a879277895a50942a", size = 240977 }, + { url = "https://files.pythonhosted.org/packages/ba/92/69c0722882643df4257ecc5437b83f4c17ba9e67f15dc6b77bad89b6982e/coverage-7.2.7-cp311-cp311-win32.whl", hash = "sha256:33d6d3ea29d5b3a1a632b3c4e4f4ecae24ef170b0b9ee493883f2df10039959a", size = 203168 }, + { url = "https://files.pythonhosted.org/packages/b1/96/c12ed0dfd4ec587f3739f53eb677b9007853fd486ccb0e7d5512a27bab2e/coverage-7.2.7-cp311-cp311-win_amd64.whl", hash = "sha256:5b7540161790b2f28143191f5f8ec02fb132660ff175b7747b95dcb77ac26562", size = 204185 }, + { url = "https://files.pythonhosted.org/packages/ff/d5/52fa1891d1802ab2e1b346d37d349cb41cdd4fd03f724ebbf94e80577687/coverage-7.2.7-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:f2f67fe12b22cd130d34d0ef79206061bfb5eda52feb6ce0dba0644e20a03cf4", size = 201020 }, + { url = "https://files.pythonhosted.org/packages/24/df/6765898d54ea20e3197a26d26bb65b084deefadd77ce7de946b9c96dfdc5/coverage-7.2.7-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a342242fe22407f3c17f4b499276a02b01e80f861f1682ad1d95b04018e0c0d4", size = 233994 }, + { url = "https://files.pythonhosted.org/packages/15/81/b108a60bc758b448c151e5abceed027ed77a9523ecbc6b8a390938301841/coverage-7.2.7-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:171717c7cb6b453aebac9a2ef603699da237f341b38eebfee9be75d27dc38e01", size = 231358 }, + { url = "https://files.pythonhosted.org/packages/61/90/c76b9462f39897ebd8714faf21bc985b65c4e1ea6dff428ea9dc711ed0dd/coverage-7.2.7-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:49969a9f7ffa086d973d91cec8d2e31080436ef0fb4a359cae927e742abfaaa6", size = 233316 }, + { url = "https://files.pythonhosted.org/packages/04/d6/8cba3bf346e8b1a4fb3f084df7d8cea25a6b6c56aaca1f2e53829be17e9e/coverage-7.2.7-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:b46517c02ccd08092f4fa99f24c3b83d8f92f739b4657b0f146246a0ca6a831d", size = 240159 }, + { url = "https://files.pythonhosted.org/packages/6e/ea/4a252dc77ca0605b23d477729d139915e753ee89e4c9507630e12ad64a80/coverage-7.2.7-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:a3d33a6b3eae87ceaefa91ffdc130b5e8536182cd6dfdbfc1aa56b46ff8c86de", size = 238127 }, + { url = "https://files.pythonhosted.org/packages/9f/5c/d9760ac497c41f9c4841f5972d0edf05d50cad7814e86ee7d133ec4a0ac8/coverage-7.2.7-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:976b9c42fb2a43ebf304fa7d4a310e5f16cc99992f33eced91ef6f908bd8f33d", size = 239833 }, + { url = "https://files.pythonhosted.org/packages/69/8c/26a95b08059db1cbb01e4b0e6d40f2e9debb628c6ca86b78f625ceaf9bab/coverage-7.2.7-cp312-cp312-win32.whl", hash = "sha256:8de8bb0e5ad103888d65abef8bca41ab93721647590a3f740100cd65c3b00511", size = 203463 }, + { url = "https://files.pythonhosted.org/packages/b7/00/14b00a0748e9eda26e97be07a63cc911108844004687321ddcc213be956c/coverage-7.2.7-cp312-cp312-win_amd64.whl", hash = "sha256:9e31cb64d7de6b6f09702bb27c02d1904b3aebfca610c12772452c4e6c21a0d3", size = 204347 }, + { url = "https://files.pythonhosted.org/packages/80/d7/67937c80b8fd4c909fdac29292bc8b35d9505312cff6bcab41c53c5b1df6/coverage-7.2.7-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:58c2ccc2f00ecb51253cbe5d8d7122a34590fac9646a960d1430d5b15321d95f", size = 200580 }, + { url = "https://files.pythonhosted.org/packages/7a/05/084864fa4bbf8106f44fb72a56e67e0cd372d3bf9d893be818338c81af5d/coverage-7.2.7-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d22656368f0e6189e24722214ed8d66b8022db19d182927b9a248a2a8a2f67eb", size = 226237 }, + { url = "https://files.pythonhosted.org/packages/67/a2/6fa66a50e6e894286d79a3564f42bd54a9bd27049dc0a63b26d9924f0aa3/coverage-7.2.7-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a895fcc7b15c3fc72beb43cdcbdf0ddb7d2ebc959edac9cef390b0d14f39f8a9", size = 224256 }, + { url = "https://files.pythonhosted.org/packages/e2/c0/73f139794c742840b9ab88e2e17fe14a3d4668a166ff95d812ac66c0829d/coverage-7.2.7-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e84606b74eb7de6ff581a7915e2dab7a28a0517fbe1c9239eb227e1354064dcd", size = 225550 }, + { url = "https://files.pythonhosted.org/packages/03/ec/6f30b4e0c96ce03b0e64aec46b4af2a8c49b70d1b5d0d69577add757b946/coverage-7.2.7-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:0a5f9e1dbd7fbe30196578ca36f3fba75376fb99888c395c5880b355e2875f8a", size = 232440 }, + { url = "https://files.pythonhosted.org/packages/22/c1/2f6c1b6f01a0996c9e067a9c780e1824351dbe17faae54388a4477e6d86f/coverage-7.2.7-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:419bfd2caae268623dd469eff96d510a920c90928b60f2073d79f8fe2bbc5959", size = 230897 }, + { url = "https://files.pythonhosted.org/packages/8d/d6/53e999ec1bf7498ca4bc5f3b8227eb61db39068d2de5dcc359dec5601b5a/coverage-7.2.7-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:2aee274c46590717f38ae5e4650988d1af340fe06167546cc32fe2f58ed05b02", size = 232024 }, + { url = "https://files.pythonhosted.org/packages/e9/40/383305500d24122dbed73e505a4d6828f8f3356d1f68ab6d32c781754b81/coverage-7.2.7-cp37-cp37m-win32.whl", hash = "sha256:61b9a528fb348373c433e8966535074b802c7a5d7f23c4f421e6c6e2f1697a6f", size = 203293 }, + { url = "https://files.pythonhosted.org/packages/0e/bc/7e3a31534fabb043269f14fb64e2bb2733f85d4cf39e5bbc71357c57553a/coverage-7.2.7-cp37-cp37m-win_amd64.whl", hash = "sha256:b1c546aca0ca4d028901d825015dc8e4d56aac4b541877690eb76490f1dc8ed0", size = 204040 }, + { url = "https://files.pythonhosted.org/packages/c6/fc/be19131010930a6cf271da48202c8cc1d3f971f68c02fb2d3a78247f43dc/coverage-7.2.7-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:54b896376ab563bd38453cecb813c295cf347cf5906e8b41d340b0321a5433e5", size = 200689 }, + { url = "https://files.pythonhosted.org/packages/28/d7/9a8de57d87f4bbc6f9a6a5ded1eaac88a89bf71369bb935dac3c0cf2893e/coverage-7.2.7-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:3d376df58cc111dc8e21e3b6e24606b5bb5dee6024f46a5abca99124b2229ef5", size = 200986 }, + { url = "https://files.pythonhosted.org/packages/c8/e4/e6182e4697665fb594a7f4e4f27cb3a4dd00c2e3d35c5c706765de8c7866/coverage-7.2.7-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5e330fc79bd7207e46c7d7fd2bb4af2963f5f635703925543a70b99574b0fea9", size = 230648 }, + { url = "https://files.pythonhosted.org/packages/7b/e3/f552d5871943f747165b92a924055c5d6daa164ae659a13f9018e22f3990/coverage-7.2.7-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1e9d683426464e4a252bf70c3498756055016f99ddaec3774bf368e76bbe02b6", size = 228511 }, + { url = "https://files.pythonhosted.org/packages/44/55/49f65ccdd4dfd6d5528e966b28c37caec64170c725af32ab312889d2f857/coverage-7.2.7-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8d13c64ee2d33eccf7437961b6ea7ad8673e2be040b4f7fd4fd4d4d28d9ccb1e", size = 229852 }, + { url = "https://files.pythonhosted.org/packages/0d/31/340428c238eb506feb96d4fb5c9ea614db1149517f22cc7ab8c6035ef6d9/coverage-7.2.7-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:b7aa5f8a41217360e600da646004f878250a0d6738bcdc11a0a39928d7dc2050", size = 235578 }, + { url = "https://files.pythonhosted.org/packages/dd/ce/97c1dd6592c908425622fe7f31c017d11cf0421729b09101d4de75bcadc8/coverage-7.2.7-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:8fa03bce9bfbeeef9f3b160a8bed39a221d82308b4152b27d82d8daa7041fee5", size = 234079 }, + { url = "https://files.pythonhosted.org/packages/de/a3/5a98dc9e239d0dc5f243ef5053d5b1bdcaa1dee27a691dfc12befeccf878/coverage-7.2.7-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:245167dd26180ab4c91d5e1496a30be4cd721a5cf2abf52974f965f10f11419f", size = 234991 }, + { url = "https://files.pythonhosted.org/packages/4a/fb/78986d3022e5ccf2d4370bc43a5fef8374f092b3c21d32499dee8e30b7b6/coverage-7.2.7-cp38-cp38-win32.whl", hash = "sha256:d2c2db7fd82e9b72937969bceac4d6ca89660db0a0967614ce2481e81a0b771e", size = 203160 }, + { url = "https://files.pythonhosted.org/packages/c3/1c/6b3c9c363fb1433c79128e0d692863deb761b1b78162494abb9e5c328bc0/coverage-7.2.7-cp38-cp38-win_amd64.whl", hash = "sha256:2e07b54284e381531c87f785f613b833569c14ecacdcb85d56b25c4622c16c3c", size = 204085 }, + { url = "https://files.pythonhosted.org/packages/88/da/495944ebf0ad246235a6bd523810d9f81981f9b81c6059ba1f56e943abe0/coverage-7.2.7-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:537891ae8ce59ef63d0123f7ac9e2ae0fc8b72c7ccbe5296fec45fd68967b6c9", size = 200725 }, + { url = "https://files.pythonhosted.org/packages/ca/0c/3dfeeb1006c44b911ee0ed915350db30325d01808525ae7cc8d57643a2ce/coverage-7.2.7-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:06fb182e69f33f6cd1d39a6c597294cff3143554b64b9825d1dc69d18cc2fff2", size = 201022 }, + { url = "https://files.pythonhosted.org/packages/61/af/5964b8d7d9a5c767785644d9a5a63cacba9a9c45cc42ba06d25895ec87be/coverage-7.2.7-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:201e7389591af40950a6480bd9edfa8ed04346ff80002cec1a66cac4549c1ad7", size = 229102 }, + { url = "https://files.pythonhosted.org/packages/d9/1d/cd467fceb62c371f9adb1d739c92a05d4e550246daa90412e711226bd320/coverage-7.2.7-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f6951407391b639504e3b3be51b7ba5f3528adbf1a8ac3302b687ecababf929e", size = 227441 }, + { url = "https://files.pythonhosted.org/packages/fe/57/e4f8ad64d84ca9e759d783a052795f62a9f9111585e46068845b1cb52c2b/coverage-7.2.7-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6f48351d66575f535669306aa7d6d6f71bc43372473b54a832222803eb956fd1", size = 228265 }, + { url = "https://files.pythonhosted.org/packages/88/8b/b0d9fe727acae907fa7f1c8194ccb6fe9d02e1c3e9001ecf74c741f86110/coverage-7.2.7-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:b29019c76039dc3c0fd815c41392a044ce555d9bcdd38b0fb60fb4cd8e475ba9", size = 234217 }, + { url = "https://files.pythonhosted.org/packages/66/2e/c99fe1f6396d93551aa352c75410686e726cd4ea104479b9af1af22367ce/coverage-7.2.7-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:81c13a1fc7468c40f13420732805a4c38a105d89848b7c10af65a90beff25250", size = 232466 }, + { url = "https://files.pythonhosted.org/packages/bb/e9/88747b40c8fb4a783b40222510ce6d66170217eb05d7f46462c36b4fa8cc/coverage-7.2.7-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:975d70ab7e3c80a3fe86001d8751f6778905ec723f5b110aed1e450da9d4b7f2", size = 233669 }, + { url = "https://files.pythonhosted.org/packages/b1/d5/a8e276bc005e42114468d4fe03e0a9555786bc51cbfe0d20827a46c1565a/coverage-7.2.7-cp39-cp39-win32.whl", hash = "sha256:7ee7d9d4822c8acc74a5e26c50604dff824710bc8de424904c0982e25c39c6cb", size = 203199 }, + { url = "https://files.pythonhosted.org/packages/a9/0c/4a848ae663b47f1195abcb09a951751dd61f80b503303b9b9d768e0fd321/coverage-7.2.7-cp39-cp39-win_amd64.whl", hash = "sha256:eb393e5ebc85245347950143969b241d08b52b88a3dc39479822e073a1a8eb27", size = 204109 }, + { url = "https://files.pythonhosted.org/packages/67/fb/b3b1d7887e1ea25a9608b0776e480e4bbc303ca95a31fd585555ec4fff5a/coverage-7.2.7-pp37.pp38.pp39-none-any.whl", hash = "sha256:b7b4c971f05e6ae490fef852c218b0e79d4e52f79ef0c8475566584a8fb3e01d", size = 193207 }, +] + +[package.optional-dependencies] +toml = [ + { name = "tomli", version = "2.0.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, +] + +[[package]] +name = "coverage" +version = "7.6.1" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version == '3.8.*'", +] +sdist = { url = "https://files.pythonhosted.org/packages/f7/08/7e37f82e4d1aead42a7443ff06a1e406aabf7302c4f00a546e4b320b994c/coverage-7.6.1.tar.gz", hash = "sha256:953510dfb7b12ab69d20135a0662397f077c59b1e6379a768e97c59d852ee51d", size = 798791 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7e/61/eb7ce5ed62bacf21beca4937a90fe32545c91a3c8a42a30c6616d48fc70d/coverage-7.6.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:b06079abebbc0e89e6163b8e8f0e16270124c154dc6e4a47b413dd538859af16", size = 206690 }, + { url = "https://files.pythonhosted.org/packages/7d/73/041928e434442bd3afde5584bdc3f932fb4562b1597629f537387cec6f3d/coverage-7.6.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:cf4b19715bccd7ee27b6b120e7e9dd56037b9c0681dcc1adc9ba9db3d417fa36", size = 207127 }, + { url = "https://files.pythonhosted.org/packages/c7/c8/6ca52b5147828e45ad0242388477fdb90df2c6cbb9a441701a12b3c71bc8/coverage-7.6.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e61c0abb4c85b095a784ef23fdd4aede7a2628478e7baba7c5e3deba61070a02", size = 235654 }, + { url = "https://files.pythonhosted.org/packages/d5/da/9ac2b62557f4340270942011d6efeab9833648380109e897d48ab7c1035d/coverage-7.6.1-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:fd21f6ae3f08b41004dfb433fa895d858f3f5979e7762d052b12aef444e29afc", size = 233598 }, + { url = "https://files.pythonhosted.org/packages/53/23/9e2c114d0178abc42b6d8d5281f651a8e6519abfa0ef460a00a91f80879d/coverage-7.6.1-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8f59d57baca39b32db42b83b2a7ba6f47ad9c394ec2076b084c3f029b7afca23", size = 234732 }, + { url = "https://files.pythonhosted.org/packages/0f/7e/a0230756fb133343a52716e8b855045f13342b70e48e8ad41d8a0d60ab98/coverage-7.6.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:a1ac0ae2b8bd743b88ed0502544847c3053d7171a3cff9228af618a068ed9c34", size = 233816 }, + { url = "https://files.pythonhosted.org/packages/28/7c/3753c8b40d232b1e5eeaed798c875537cf3cb183fb5041017c1fdb7ec14e/coverage-7.6.1-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:e6a08c0be454c3b3beb105c0596ebdc2371fab6bb90c0c0297f4e58fd7e1012c", size = 232325 }, + { url = "https://files.pythonhosted.org/packages/57/e3/818a2b2af5b7573b4b82cf3e9f137ab158c90ea750a8f053716a32f20f06/coverage-7.6.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:f5796e664fe802da4f57a168c85359a8fbf3eab5e55cd4e4569fbacecc903959", size = 233418 }, + { url = "https://files.pythonhosted.org/packages/c8/fb/4532b0b0cefb3f06d201648715e03b0feb822907edab3935112b61b885e2/coverage-7.6.1-cp310-cp310-win32.whl", hash = "sha256:7bb65125fcbef8d989fa1dd0e8a060999497629ca5b0efbca209588a73356232", size = 209343 }, + { url = "https://files.pythonhosted.org/packages/5a/25/af337cc7421eca1c187cc9c315f0a755d48e755d2853715bfe8c418a45fa/coverage-7.6.1-cp310-cp310-win_amd64.whl", hash = "sha256:3115a95daa9bdba70aea750db7b96b37259a81a709223c8448fa97727d546fe0", size = 210136 }, + { url = "https://files.pythonhosted.org/packages/ad/5f/67af7d60d7e8ce61a4e2ddcd1bd5fb787180c8d0ae0fbd073f903b3dd95d/coverage-7.6.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:7dea0889685db8550f839fa202744652e87c60015029ce3f60e006f8c4462c93", size = 206796 }, + { url = "https://files.pythonhosted.org/packages/e1/0e/e52332389e057daa2e03be1fbfef25bb4d626b37d12ed42ae6281d0a274c/coverage-7.6.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:ed37bd3c3b063412f7620464a9ac1314d33100329f39799255fb8d3027da50d3", size = 207244 }, + { url = "https://files.pythonhosted.org/packages/aa/cd/766b45fb6e090f20f8927d9c7cb34237d41c73a939358bc881883fd3a40d/coverage-7.6.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d85f5e9a5f8b73e2350097c3756ef7e785f55bd71205defa0bfdaf96c31616ff", size = 239279 }, + { url = "https://files.pythonhosted.org/packages/70/6c/a9ccd6fe50ddaf13442a1e2dd519ca805cbe0f1fcd377fba6d8339b98ccb/coverage-7.6.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:9bc572be474cafb617672c43fe989d6e48d3c83af02ce8de73fff1c6bb3c198d", size = 236859 }, + { url = "https://files.pythonhosted.org/packages/14/6f/8351b465febb4dbc1ca9929505202db909c5a635c6fdf33e089bbc3d7d85/coverage-7.6.1-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0c0420b573964c760df9e9e86d1a9a622d0d27f417e1a949a8a66dd7bcee7bc6", size = 238549 }, + { url = "https://files.pythonhosted.org/packages/68/3c/289b81fa18ad72138e6d78c4c11a82b5378a312c0e467e2f6b495c260907/coverage-7.6.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:1f4aa8219db826ce6be7099d559f8ec311549bfc4046f7f9fe9b5cea5c581c56", size = 237477 }, + { url = "https://files.pythonhosted.org/packages/ed/1c/aa1efa6459d822bd72c4abc0b9418cf268de3f60eeccd65dc4988553bd8d/coverage-7.6.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:fc5a77d0c516700ebad189b587de289a20a78324bc54baee03dd486f0855d234", size = 236134 }, + { url = "https://files.pythonhosted.org/packages/fb/c8/521c698f2d2796565fe9c789c2ee1ccdae610b3aa20b9b2ef980cc253640/coverage-7.6.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:b48f312cca9621272ae49008c7f613337c53fadca647d6384cc129d2996d1133", size = 236910 }, + { url = "https://files.pythonhosted.org/packages/7d/30/033e663399ff17dca90d793ee8a2ea2890e7fdf085da58d82468b4220bf7/coverage-7.6.1-cp311-cp311-win32.whl", hash = "sha256:1125ca0e5fd475cbbba3bb67ae20bd2c23a98fac4e32412883f9bcbaa81c314c", size = 209348 }, + { url = "https://files.pythonhosted.org/packages/20/05/0d1ccbb52727ccdadaa3ff37e4d2dc1cd4d47f0c3df9eb58d9ec8508ca88/coverage-7.6.1-cp311-cp311-win_amd64.whl", hash = "sha256:8ae539519c4c040c5ffd0632784e21b2f03fc1340752af711f33e5be83a9d6c6", size = 210230 }, + { url = "https://files.pythonhosted.org/packages/7e/d4/300fc921dff243cd518c7db3a4c614b7e4b2431b0d1145c1e274fd99bd70/coverage-7.6.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:95cae0efeb032af8458fc27d191f85d1717b1d4e49f7cb226cf526ff28179778", size = 206983 }, + { url = "https://files.pythonhosted.org/packages/e1/ab/6bf00de5327ecb8db205f9ae596885417a31535eeda6e7b99463108782e1/coverage-7.6.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:5621a9175cf9d0b0c84c2ef2b12e9f5f5071357c4d2ea6ca1cf01814f45d2391", size = 207221 }, + { url = "https://files.pythonhosted.org/packages/92/8f/2ead05e735022d1a7f3a0a683ac7f737de14850395a826192f0288703472/coverage-7.6.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:260933720fdcd75340e7dbe9060655aff3af1f0c5d20f46b57f262ab6c86a5e8", size = 240342 }, + { url = "https://files.pythonhosted.org/packages/0f/ef/94043e478201ffa85b8ae2d2c79b4081e5a1b73438aafafccf3e9bafb6b5/coverage-7.6.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:07e2ca0ad381b91350c0ed49d52699b625aab2b44b65e1b4e02fa9df0e92ad2d", size = 237371 }, + { url = "https://files.pythonhosted.org/packages/1f/0f/c890339dd605f3ebc269543247bdd43b703cce6825b5ed42ff5f2d6122c7/coverage-7.6.1-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c44fee9975f04b33331cb8eb272827111efc8930cfd582e0320613263ca849ca", size = 239455 }, + { url = "https://files.pythonhosted.org/packages/d1/04/7fd7b39ec7372a04efb0f70c70e35857a99b6a9188b5205efb4c77d6a57a/coverage-7.6.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:877abb17e6339d96bf08e7a622d05095e72b71f8afd8a9fefc82cf30ed944163", size = 238924 }, + { url = "https://files.pythonhosted.org/packages/ed/bf/73ce346a9d32a09cf369f14d2a06651329c984e106f5992c89579d25b27e/coverage-7.6.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:3e0cadcf6733c09154b461f1ca72d5416635e5e4ec4e536192180d34ec160f8a", size = 237252 }, + { url = "https://files.pythonhosted.org/packages/86/74/1dc7a20969725e917b1e07fe71a955eb34bc606b938316bcc799f228374b/coverage-7.6.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:c3c02d12f837d9683e5ab2f3d9844dc57655b92c74e286c262e0fc54213c216d", size = 238897 }, + { url = "https://files.pythonhosted.org/packages/b6/e9/d9cc3deceb361c491b81005c668578b0dfa51eed02cd081620e9a62f24ec/coverage-7.6.1-cp312-cp312-win32.whl", hash = "sha256:e05882b70b87a18d937ca6768ff33cc3f72847cbc4de4491c8e73880766718e5", size = 209606 }, + { url = "https://files.pythonhosted.org/packages/47/c8/5a2e41922ea6740f77d555c4d47544acd7dc3f251fe14199c09c0f5958d3/coverage-7.6.1-cp312-cp312-win_amd64.whl", hash = "sha256:b5d7b556859dd85f3a541db6a4e0167b86e7273e1cdc973e5b175166bb634fdb", size = 210373 }, + { url = "https://files.pythonhosted.org/packages/8c/f9/9aa4dfb751cb01c949c990d136a0f92027fbcc5781c6e921df1cb1563f20/coverage-7.6.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:a4acd025ecc06185ba2b801f2de85546e0b8ac787cf9d3b06e7e2a69f925b106", size = 207007 }, + { url = "https://files.pythonhosted.org/packages/b9/67/e1413d5a8591622a46dd04ff80873b04c849268831ed5c304c16433e7e30/coverage-7.6.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:a6d3adcf24b624a7b778533480e32434a39ad8fa30c315208f6d3e5542aeb6e9", size = 207269 }, + { url = "https://files.pythonhosted.org/packages/14/5b/9dec847b305e44a5634d0fb8498d135ab1d88330482b74065fcec0622224/coverage-7.6.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d0c212c49b6c10e6951362f7c6df3329f04c2b1c28499563d4035d964ab8e08c", size = 239886 }, + { url = "https://files.pythonhosted.org/packages/7b/b7/35760a67c168e29f454928f51f970342d23cf75a2bb0323e0f07334c85f3/coverage-7.6.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6e81d7a3e58882450ec4186ca59a3f20a5d4440f25b1cff6f0902ad890e6748a", size = 237037 }, + { url = "https://files.pythonhosted.org/packages/f7/95/d2fd31f1d638df806cae59d7daea5abf2b15b5234016a5ebb502c2f3f7ee/coverage-7.6.1-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:78b260de9790fd81e69401c2dc8b17da47c8038176a79092a89cb2b7d945d060", size = 239038 }, + { url = "https://files.pythonhosted.org/packages/6e/bd/110689ff5752b67924efd5e2aedf5190cbbe245fc81b8dec1abaffba619d/coverage-7.6.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a78d169acd38300060b28d600344a803628c3fd585c912cacc9ea8790fe96862", size = 238690 }, + { url = "https://files.pythonhosted.org/packages/d3/a8/08d7b38e6ff8df52331c83130d0ab92d9c9a8b5462f9e99c9f051a4ae206/coverage-7.6.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:2c09f4ce52cb99dd7505cd0fc8e0e37c77b87f46bc9c1eb03fe3bc9991085388", size = 236765 }, + { url = "https://files.pythonhosted.org/packages/d6/6a/9cf96839d3147d55ae713eb2d877f4d777e7dc5ba2bce227167d0118dfe8/coverage-7.6.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6878ef48d4227aace338d88c48738a4258213cd7b74fd9a3d4d7582bb1d8a155", size = 238611 }, + { url = "https://files.pythonhosted.org/packages/74/e4/7ff20d6a0b59eeaab40b3140a71e38cf52547ba21dbcf1d79c5a32bba61b/coverage-7.6.1-cp313-cp313-win32.whl", hash = "sha256:44df346d5215a8c0e360307d46ffaabe0f5d3502c8a1cefd700b34baf31d411a", size = 209671 }, + { url = "https://files.pythonhosted.org/packages/35/59/1812f08a85b57c9fdb6d0b383d779e47b6f643bc278ed682859512517e83/coverage-7.6.1-cp313-cp313-win_amd64.whl", hash = "sha256:8284cf8c0dd272a247bc154eb6c95548722dce90d098c17a883ed36e67cdb129", size = 210368 }, + { url = "https://files.pythonhosted.org/packages/9c/15/08913be1c59d7562a3e39fce20661a98c0a3f59d5754312899acc6cb8a2d/coverage-7.6.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:d3296782ca4eab572a1a4eca686d8bfb00226300dcefdf43faa25b5242ab8a3e", size = 207758 }, + { url = "https://files.pythonhosted.org/packages/c4/ae/b5d58dff26cade02ada6ca612a76447acd69dccdbb3a478e9e088eb3d4b9/coverage-7.6.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:502753043567491d3ff6d08629270127e0c31d4184c4c8d98f92c26f65019962", size = 208035 }, + { url = "https://files.pythonhosted.org/packages/b8/d7/62095e355ec0613b08dfb19206ce3033a0eedb6f4a67af5ed267a8800642/coverage-7.6.1-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6a89ecca80709d4076b95f89f308544ec8f7b4727e8a547913a35f16717856cb", size = 250839 }, + { url = "https://files.pythonhosted.org/packages/7c/1e/c2967cb7991b112ba3766df0d9c21de46b476d103e32bb401b1b2adf3380/coverage-7.6.1-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a318d68e92e80af8b00fa99609796fdbcdfef3629c77c6283566c6f02c6d6704", size = 246569 }, + { url = "https://files.pythonhosted.org/packages/8b/61/a7a6a55dd266007ed3b1df7a3386a0d760d014542d72f7c2c6938483b7bd/coverage-7.6.1-cp313-cp313t-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:13b0a73a0896988f053e4fbb7de6d93388e6dd292b0d87ee51d106f2c11b465b", size = 248927 }, + { url = "https://files.pythonhosted.org/packages/c8/fa/13a6f56d72b429f56ef612eb3bc5ce1b75b7ee12864b3bd12526ab794847/coverage-7.6.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:4421712dbfc5562150f7554f13dde997a2e932a6b5f352edcce948a815efee6f", size = 248401 }, + { url = "https://files.pythonhosted.org/packages/75/06/0429c652aa0fb761fc60e8c6b291338c9173c6aa0f4e40e1902345b42830/coverage-7.6.1-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:166811d20dfea725e2e4baa71fffd6c968a958577848d2131f39b60043400223", size = 246301 }, + { url = "https://files.pythonhosted.org/packages/52/76/1766bb8b803a88f93c3a2d07e30ffa359467810e5cbc68e375ebe6906efb/coverage-7.6.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:225667980479a17db1048cb2bf8bfb39b8e5be8f164b8f6628b64f78a72cf9d3", size = 247598 }, + { url = "https://files.pythonhosted.org/packages/66/8b/f54f8db2ae17188be9566e8166ac6df105c1c611e25da755738025708d54/coverage-7.6.1-cp313-cp313t-win32.whl", hash = "sha256:170d444ab405852903b7d04ea9ae9b98f98ab6d7e63e1115e82620807519797f", size = 210307 }, + { url = "https://files.pythonhosted.org/packages/9f/b0/e0dca6da9170aefc07515cce067b97178cefafb512d00a87a1c717d2efd5/coverage-7.6.1-cp313-cp313t-win_amd64.whl", hash = "sha256:b9f222de8cded79c49bf184bdbc06630d4c58eec9459b939b4a690c82ed05657", size = 211453 }, + { url = "https://files.pythonhosted.org/packages/81/d0/d9e3d554e38beea5a2e22178ddb16587dbcbe9a1ef3211f55733924bf7fa/coverage-7.6.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:6db04803b6c7291985a761004e9060b2bca08da6d04f26a7f2294b8623a0c1a0", size = 206674 }, + { url = "https://files.pythonhosted.org/packages/38/ea/cab2dc248d9f45b2b7f9f1f596a4d75a435cb364437c61b51d2eb33ceb0e/coverage-7.6.1-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:f1adfc8ac319e1a348af294106bc6a8458a0f1633cc62a1446aebc30c5fa186a", size = 207101 }, + { url = "https://files.pythonhosted.org/packages/ca/6f/f82f9a500c7c5722368978a5390c418d2a4d083ef955309a8748ecaa8920/coverage-7.6.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a95324a9de9650a729239daea117df21f4b9868ce32e63f8b650ebe6cef5595b", size = 236554 }, + { url = "https://files.pythonhosted.org/packages/a6/94/d3055aa33d4e7e733d8fa309d9adf147b4b06a82c1346366fc15a2b1d5fa/coverage-7.6.1-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b43c03669dc4618ec25270b06ecd3ee4fa94c7f9b3c14bae6571ca00ef98b0d3", size = 234440 }, + { url = "https://files.pythonhosted.org/packages/e4/6e/885bcd787d9dd674de4a7d8ec83faf729534c63d05d51d45d4fa168f7102/coverage-7.6.1-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8929543a7192c13d177b770008bc4e8119f2e1f881d563fc6b6305d2d0ebe9de", size = 235889 }, + { url = "https://files.pythonhosted.org/packages/f4/63/df50120a7744492710854860783d6819ff23e482dee15462c9a833cc428a/coverage-7.6.1-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:a09ece4a69cf399510c8ab25e0950d9cf2b42f7b3cb0374f95d2e2ff594478a6", size = 235142 }, + { url = "https://files.pythonhosted.org/packages/3a/5d/9d0acfcded2b3e9ce1c7923ca52ccc00c78a74e112fc2aee661125b7843b/coverage-7.6.1-cp38-cp38-musllinux_1_2_i686.whl", hash = "sha256:9054a0754de38d9dbd01a46621636689124d666bad1936d76c0341f7d71bf569", size = 233805 }, + { url = "https://files.pythonhosted.org/packages/c4/56/50abf070cb3cd9b1dd32f2c88f083aab561ecbffbcd783275cb51c17f11d/coverage-7.6.1-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:0dbde0f4aa9a16fa4d754356a8f2e36296ff4d83994b2c9d8398aa32f222f989", size = 234655 }, + { url = "https://files.pythonhosted.org/packages/25/ee/b4c246048b8485f85a2426ef4abab88e48c6e80c74e964bea5cd4cd4b115/coverage-7.6.1-cp38-cp38-win32.whl", hash = "sha256:da511e6ad4f7323ee5702e6633085fb76c2f893aaf8ce4c51a0ba4fc07580ea7", size = 209296 }, + { url = "https://files.pythonhosted.org/packages/5c/1c/96cf86b70b69ea2b12924cdf7cabb8ad10e6130eab8d767a1099fbd2a44f/coverage-7.6.1-cp38-cp38-win_amd64.whl", hash = "sha256:3f1156e3e8f2872197af3840d8ad307a9dd18e615dc64d9ee41696f287c57ad8", size = 210137 }, + { url = "https://files.pythonhosted.org/packages/19/d3/d54c5aa83268779d54c86deb39c1c4566e5d45c155369ca152765f8db413/coverage-7.6.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:abd5fd0db5f4dc9289408aaf34908072f805ff7792632250dcb36dc591d24255", size = 206688 }, + { url = "https://files.pythonhosted.org/packages/a5/fe/137d5dca72e4a258b1bc17bb04f2e0196898fe495843402ce826a7419fe3/coverage-7.6.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:547f45fa1a93154bd82050a7f3cddbc1a7a4dd2a9bf5cb7d06f4ae29fe94eaf8", size = 207120 }, + { url = "https://files.pythonhosted.org/packages/78/5b/a0a796983f3201ff5485323b225d7c8b74ce30c11f456017e23d8e8d1945/coverage-7.6.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:645786266c8f18a931b65bfcefdbf6952dd0dea98feee39bd188607a9d307ed2", size = 235249 }, + { url = "https://files.pythonhosted.org/packages/4e/e1/76089d6a5ef9d68f018f65411fcdaaeb0141b504587b901d74e8587606ad/coverage-7.6.1-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:9e0b2df163b8ed01d515807af24f63de04bebcecbd6c3bfeff88385789fdf75a", size = 233237 }, + { url = "https://files.pythonhosted.org/packages/9a/6f/eef79b779a540326fee9520e5542a8b428cc3bfa8b7c8f1022c1ee4fc66c/coverage-7.6.1-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:609b06f178fe8e9f89ef676532760ec0b4deea15e9969bf754b37f7c40326dbc", size = 234311 }, + { url = "https://files.pythonhosted.org/packages/75/e1/656d65fb126c29a494ef964005702b012f3498db1a30dd562958e85a4049/coverage-7.6.1-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:702855feff378050ae4f741045e19a32d57d19f3e0676d589df0575008ea5004", size = 233453 }, + { url = "https://files.pythonhosted.org/packages/68/6a/45f108f137941a4a1238c85f28fd9d048cc46b5466d6b8dda3aba1bb9d4f/coverage-7.6.1-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:2bdb062ea438f22d99cba0d7829c2ef0af1d768d1e4a4f528087224c90b132cb", size = 231958 }, + { url = "https://files.pythonhosted.org/packages/9b/e7/47b809099168b8b8c72ae311efc3e88c8d8a1162b3ba4b8da3cfcdb85743/coverage-7.6.1-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:9c56863d44bd1c4fe2abb8a4d6f5371d197f1ac0ebdee542f07f35895fc07f36", size = 232938 }, + { url = "https://files.pythonhosted.org/packages/52/80/052222ba7058071f905435bad0ba392cc12006380731c37afaf3fe749b88/coverage-7.6.1-cp39-cp39-win32.whl", hash = "sha256:6e2cd258d7d927d09493c8df1ce9174ad01b381d4729a9d8d4e38670ca24774c", size = 209352 }, + { url = "https://files.pythonhosted.org/packages/b8/d8/1b92e0b3adcf384e98770a00ca095da1b5f7b483e6563ae4eb5e935d24a1/coverage-7.6.1-cp39-cp39-win_amd64.whl", hash = "sha256:06a737c882bd26d0d6ee7269b20b12f14a8704807a01056c80bb881a4b2ce6ca", size = 210153 }, + { url = "https://files.pythonhosted.org/packages/a5/2b/0354ed096bca64dc8e32a7cbcae28b34cb5ad0b1fe2125d6d99583313ac0/coverage-7.6.1-pp38.pp39.pp310-none-any.whl", hash = "sha256:e9a6e0eb86070e8ccaedfbd9d38fec54864f3125ab95419970575b42af7541df", size = 198926 }, +] + +[package.optional-dependencies] +toml = [ + { name = "tomli", version = "2.2.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.8.*'" }, +] + +[[package]] +name = "coverage" +version = "7.7.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", + "python_full_version == '3.10.*'", + "python_full_version == '3.9.*'", +] +sdist = { url = "https://files.pythonhosted.org/packages/02/36/465f5492443265e1278f9a82ffe6aeed3f1db779da0d6e7d4611a5cfb6af/coverage-7.7.0.tar.gz", hash = "sha256:cd879d4646055a573775a1cec863d00c9ff8c55860f8b17f6d8eee9140c06166", size = 809969 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/10/f5/2b801fe88f199707cf9ec66dcee036e7073b5a208a4a161b64371b3f1e35/coverage-7.7.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:a538a23119d1e2e2ce077e902d02ea3d8e0641786ef6e0faf11ce82324743944", size = 210608 }, + { url = "https://files.pythonhosted.org/packages/07/44/bcc030cf977d1069a28742c0a67284c6e831ef172f914055b3d45da83f89/coverage-7.7.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:1586ad158523f4133499a4f322b230e2cfef9cc724820dbd58595a5a236186f4", size = 211042 }, + { url = "https://files.pythonhosted.org/packages/2c/3f/b427f17e1bcf3e1f5ac42fc0b6cb623616f2aedcfc7fde17a058afb62568/coverage-7.7.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7b6c96d69928a3a6767fab8dc1ce8a02cf0156836ccb1e820c7f45a423570d98", size = 240168 }, + { url = "https://files.pythonhosted.org/packages/58/92/6e8d71c5e651f152ffc518ec4cd7add87035533e88af29e233635c0f0dfb/coverage-7.7.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7f18d47641282664276977c604b5a261e51fefc2980f5271d547d706b06a837f", size = 238079 }, + { url = "https://files.pythonhosted.org/packages/40/33/1c25ae35c16972dc379c24cd7dde20359d076dee00687825c92a53e43b02/coverage-7.7.0-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f2a1e18a85bd066c7c556d85277a7adf4651f259b2579113844835ba1a74aafd", size = 239216 }, + { url = "https://files.pythonhosted.org/packages/4d/3d/adf40bdd07a49e1880632c1bc6b31f42d32cf0bfe6b4d294a8f706d70078/coverage-7.7.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:70f0925c4e2bfc965369f417e7cc72538fd1ba91639cf1e4ef4b1a6b50439b3b", size = 239126 }, + { url = "https://files.pythonhosted.org/packages/72/a5/51e39811cd0ec0569a25fe8e6bac0a00efa222a3e49d51d64f5ba0dce24a/coverage-7.7.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:b0fac2088ec4aaeb5468b814bd3ff5e5978364bfbce5e567c44c9e2854469f6c", size = 237842 }, + { url = "https://files.pythonhosted.org/packages/ab/b7/c5796906cd9eed6d258138f1fddc8d6af01b6d07b3c183bac4a9731ac383/coverage-7.7.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:b3e212a894d8ae07fde2ca8b43d666a6d49bbbddb10da0f6a74ca7bd31f20054", size = 238136 }, + { url = "https://files.pythonhosted.org/packages/d7/8a/bd34ea3c602b3ef323a001d375f9b1d663e901079bb26b5f9b8f96fae32b/coverage-7.7.0-cp310-cp310-win32.whl", hash = "sha256:f32b165bf6dfea0846a9c9c38b7e1d68f313956d60a15cde5d1709fddcaf3bee", size = 213320 }, + { url = "https://files.pythonhosted.org/packages/94/60/6e7efe849e305a233623a80aaeba7ebb02809fa63ab8a1e49c4323b8083b/coverage-7.7.0-cp310-cp310-win_amd64.whl", hash = "sha256:a2454b12a3f12cc4698f3508912e6225ec63682e2ca5a96f80a2b93cef9e63f3", size = 214219 }, + { url = "https://files.pythonhosted.org/packages/e8/ec/9e0c9358a3bd56b1ddbf266b889ea9d51ee29e58fb72712d5600663fa806/coverage-7.7.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:a0a207c87a9f743c8072d059b4711f8d13c456eb42dac778a7d2e5d4f3c253a7", size = 210722 }, + { url = "https://files.pythonhosted.org/packages/be/bd/7b47a4302423a13960ee30682900d7ca20cee15c978b1d9ea9594d59d352/coverage-7.7.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:2d673e3add00048215c2cc507f1228a7523fd8bf34f279ac98334c9b07bd2656", size = 211154 }, + { url = "https://files.pythonhosted.org/packages/c6/7c/ae54d9022440196bf9f3fad535388678a3db186980ff58a4956ddeb849a2/coverage-7.7.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f81fe93dc1b8e5673f33443c0786c14b77e36f1025973b85e07c70353e46882b", size = 243787 }, + { url = "https://files.pythonhosted.org/packages/2d/21/913a2a2d89a2221f4410fbea4ff84e64ddf4367a4b9eb2c328bd01a1a401/coverage-7.7.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d8c7524779003d59948c51b4fcbf1ca4e27c26a7d75984f63488f3625c328b9b", size = 241473 }, + { url = "https://files.pythonhosted.org/packages/40/f1/5ae36fffd542fb86ab3b2d5e012af0840265f3dd001ad0ffabe9e4dbdcf6/coverage-7.7.0-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4c124025430249118d018dcedc8b7426f39373527c845093132196f2a483b6dd", size = 243259 }, + { url = "https://files.pythonhosted.org/packages/47/1b/abc87bad7f606a4df321bd8300413fe13700099a163e7d63453c7c70c1b2/coverage-7.7.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:e7f559c36d5cdc448ee13e7e56ed7b6b5d44a40a511d584d388a0f5d940977ba", size = 242904 }, + { url = "https://files.pythonhosted.org/packages/e0/b3/ff0cf15f5709996727dda2fa00af6f4da92ea3e16168400346f2f742341a/coverage-7.7.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:37cbc7b0d93dfd133e33c7ec01123fbb90401dce174c3b6661d8d36fb1e30608", size = 241079 }, + { url = "https://files.pythonhosted.org/packages/05/c9/fcad82aad05b1eb8040e6c25ae7a1303716cc05718d4dd326e0fab31aa14/coverage-7.7.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:7d2a65876274acf544703e943c010b60bd79404e3623a1e5d52b64a6e2728de5", size = 241617 }, + { url = "https://files.pythonhosted.org/packages/59/9f/d1efe149afa5c3a459c08bf04f7e6917ef4ee8e3440df5c3e87d6b972870/coverage-7.7.0-cp311-cp311-win32.whl", hash = "sha256:f5a2f71d6a91238e7628f23538c26aa464d390cbdedf12ee2a7a0fb92a24482a", size = 213372 }, + { url = "https://files.pythonhosted.org/packages/88/d2/4b58f03e399185b01fb3168d4b870882de9c7a10e273f99c8f25ec690302/coverage-7.7.0-cp311-cp311-win_amd64.whl", hash = "sha256:ae8006772c6b0fa53c33747913473e064985dac4d65f77fd2fdc6474e7cd54e4", size = 214285 }, + { url = "https://files.pythonhosted.org/packages/b7/47/f7b870caa26082ff8033be074ac61dc175a6b0c965adf7b910f92a6d7cfe/coverage-7.7.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:056d3017ed67e7ddf266e6f57378ece543755a4c9231e997789ab3bd11392c94", size = 210907 }, + { url = "https://files.pythonhosted.org/packages/ea/eb/40b39bdc6c1da403257f0fcb2c1b2fd81ff9f66c13abbe3862f42780e1c1/coverage-7.7.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:33c1394d8407e2771547583b66a85d07ed441ff8fae5a4adb4237ad39ece60db", size = 211162 }, + { url = "https://files.pythonhosted.org/packages/53/08/42a2db41b4646d6261122773e222dd7105e2306526f2d7846de6fee808ec/coverage-7.7.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4fbb7a0c3c21908520149d7751cf5b74eb9b38b54d62997b1e9b3ac19a8ee2fe", size = 245223 }, + { url = "https://files.pythonhosted.org/packages/78/2a/0ceb328a7e67e8639d5c7800b8161d4b5f489073ac8d5ac33b11eadee218/coverage-7.7.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:bb356e7ae7c2da13f404bf8f75be90f743c6df8d4607022e759f5d7d89fe83f8", size = 242114 }, + { url = "https://files.pythonhosted.org/packages/ba/68/42b13b849d40af1581830ff06c60f4ec84649764f4a58d5c6e20ae11cbd4/coverage-7.7.0-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bce730d484038e97f27ea2dbe5d392ec5c2261f28c319a3bb266f6b213650135", size = 244371 }, + { url = "https://files.pythonhosted.org/packages/68/66/ab7c3b9fdbeb8bdd322f5b67b1886463834dba2014a534caba60fb0075ea/coverage-7.7.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:aa4dff57fc21a575672176d5ab0ef15a927199e775c5e8a3d75162ab2b0c7705", size = 244134 }, + { url = "https://files.pythonhosted.org/packages/01/74/b833d299a479681957d6b238e16a0725586e1d56ec1e43658f3184550bb0/coverage-7.7.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:b667b91f4f714b17af2a18e220015c941d1cf8b07c17f2160033dbe1e64149f0", size = 242353 }, + { url = "https://files.pythonhosted.org/packages/f9/c5/0ed656d65da39bbab8e8fc367dc3d465a7501fea0f2b1caccfb4f6361c9f/coverage-7.7.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:693d921621a0c8043bfdc61f7d4df5ea6d22165fe8b807cac21eb80dd94e4bbd", size = 243543 }, + { url = "https://files.pythonhosted.org/packages/87/b5/142bcff3828e4cce5d4c9ddc9222de1664464263acca09638e4eb0dbda7c/coverage-7.7.0-cp312-cp312-win32.whl", hash = "sha256:52fc89602cde411a4196c8c6894afb384f2125f34c031774f82a4f2608c59d7d", size = 213543 }, + { url = "https://files.pythonhosted.org/packages/29/74/99d226985def03284bad6a9aff27a1079a8881ec7523b5980b00a5260527/coverage-7.7.0-cp312-cp312-win_amd64.whl", hash = "sha256:0ce8cf59e09d31a4915ff4c3b94c6514af4c84b22c4cc8ad7c3c546a86150a92", size = 214344 }, + { url = "https://files.pythonhosted.org/packages/45/2f/df6235ec963b9eb6b6b2f3c24f70448f1ffa13b9a481c155a6caff176395/coverage-7.7.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:4545485fef7a8a2d8f30e6f79ce719eb154aab7e44217eb444c1d38239af2072", size = 210934 }, + { url = "https://files.pythonhosted.org/packages/f3/85/ff19510bf642e334845318ddb73a550d2b17082831fa9ae053ce72288be7/coverage-7.7.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:1393e5aa9441dafb0162c36c8506c648b89aea9565b31f6bfa351e66c11bcd82", size = 211212 }, + { url = "https://files.pythonhosted.org/packages/2d/6a/af6582a419550d35eacc3e1bf9f4a936dda0ae559632a0bc4e3aef694ac8/coverage-7.7.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:316f29cc3392fa3912493ee4c83afa4a0e2db04ff69600711f8c03997c39baaa", size = 244727 }, + { url = "https://files.pythonhosted.org/packages/55/62/7c49526111c91f3d7d27e111c22c8d08722f5b661c3f031b625b4d7bc4d9/coverage-7.7.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e1ffde1d6bc2a92f9c9207d1ad808550873748ac2d4d923c815b866baa343b3f", size = 241768 }, + { url = "https://files.pythonhosted.org/packages/62/4b/2dc27700782be9795cbbbe98394dd19ef74815d78d5027ed894972cd1b4a/coverage-7.7.0-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:416e2a8845eaff288f97eaf76ab40367deafb9073ffc47bf2a583f26b05e5265", size = 243790 }, + { url = "https://files.pythonhosted.org/packages/d3/11/9cc1ae56d3015edca69437f3121c2b44de309f6828980b29e4cc9b13246d/coverage-7.7.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:5efdeff5f353ed3352c04e6b318ab05c6ce9249c25ed3c2090c6e9cadda1e3b2", size = 243861 }, + { url = "https://files.pythonhosted.org/packages/db/e4/2398ed93edcf42ff43002d91c37be11514d825cec382606654fd44f4b8fa/coverage-7.7.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:57f3bd0d29bf2bd9325c0ff9cc532a175110c4bf8f412c05b2405fd35745266d", size = 241942 }, + { url = "https://files.pythonhosted.org/packages/ec/fe/b6bd35b17a2b8d26bdb21d5ea4351a837ec01edf552655e833629af05b90/coverage-7.7.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:3ab7090f04b12dc6469882ce81244572779d3a4b67eea1c96fb9ecc8c607ef39", size = 243228 }, + { url = "https://files.pythonhosted.org/packages/6d/06/d8701bae1e5d865edeb00a6c2a71bd7659ca6af349789271c6fd16a57909/coverage-7.7.0-cp313-cp313-win32.whl", hash = "sha256:180e3fc68ee4dc5af8b33b6ca4e3bb8aa1abe25eedcb958ba5cff7123071af68", size = 213572 }, + { url = "https://files.pythonhosted.org/packages/d7/c1/7e67780bfcaed6bed20100c9e1b2645e3414577b4bdad169578325249045/coverage-7.7.0-cp313-cp313-win_amd64.whl", hash = "sha256:55143aa13c49491f5606f05b49ed88663446dce3a4d3c5d77baa4e36a16d3573", size = 214372 }, + { url = "https://files.pythonhosted.org/packages/ed/25/50b0447442a415ad3da33093c589d9ef945dd6933225f1ce0ac97476397e/coverage-7.7.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:cc41374d2f27d81d6558f8a24e5c114580ffefc197fd43eabd7058182f743322", size = 211774 }, + { url = "https://files.pythonhosted.org/packages/13/cc/3daddc707e934d3c0aafaa4a9b217f53fcf4133d4e40cc6ae63aa51243b8/coverage-7.7.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:89078312f06237417adda7c021c33f80f7a6d2db8572a5f6c330d89b080061ce", size = 211995 }, + { url = "https://files.pythonhosted.org/packages/98/99/c92f43355d3d67f6bf8c946a350f2174e18f9ea7c8a1e36c9eb84ab7d20b/coverage-7.7.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5b2f144444879363ea8834cd7b6869d79ac796cb8f864b0cfdde50296cd95816", size = 256226 }, + { url = "https://files.pythonhosted.org/packages/25/62/65f0f33c08e0a1632f1e487b9c2d252e8bad6a77a942836043972b0ba6d2/coverage-7.7.0-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:60e6347d1ed882b1159ffea172cb8466ee46c665af4ca397edbf10ff53e9ffaf", size = 251937 }, + { url = "https://files.pythonhosted.org/packages/b2/10/99a9565aaeb159aade178c6509c8324a9c9e825b01f02242a37c2a8869f8/coverage-7.7.0-cp313-cp313t-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cb203c0afffaf1a8f5b9659a013f8f16a1b2cad3a80a8733ceedc968c0cf4c57", size = 254276 }, + { url = "https://files.pythonhosted.org/packages/a7/12/206196edbf0b82250b11bf5c252fe25ebaa2b7c8d66edb0c194e7b3403fe/coverage-7.7.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:ad0edaa97cb983d9f2ff48cadddc3e1fb09f24aa558abeb4dc9a0dbacd12cbb4", size = 255366 }, + { url = "https://files.pythonhosted.org/packages/a5/82/a2abb8d4cdd99c6a443ab6682c0eee5797490a2113a45ffaa8b6b31c5dcc/coverage-7.7.0-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:c5f8a5364fc37b2f172c26a038bc7ec4885f429de4a05fc10fdcb53fb5834c5c", size = 253536 }, + { url = "https://files.pythonhosted.org/packages/4d/7d/3747e000e60ad5dd8157bd978f99979967d56cb35c55235980c85305db86/coverage-7.7.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:c4e09534037933bf6eb31d804e72c52ec23219b32c1730f9152feabbd7499463", size = 254344 }, + { url = "https://files.pythonhosted.org/packages/45/56/7c33f8a6de1b3b079374d2ae490ccf76fb7c094a23f72d10f071989fc3ef/coverage-7.7.0-cp313-cp313t-win32.whl", hash = "sha256:1b336d06af14f8da5b1f391e8dec03634daf54dfcb4d1c4fb6d04c09d83cef90", size = 214284 }, + { url = "https://files.pythonhosted.org/packages/95/ab/657bfa6171800a67bd1c005402f06d6b78610820ef1364ea4f85b04bbb5b/coverage-7.7.0-cp313-cp313t-win_amd64.whl", hash = "sha256:b54a1ee4c6f1905a436cbaa04b26626d27925a41cbc3a337e2d3ff7038187f07", size = 215445 }, + { url = "https://files.pythonhosted.org/packages/d1/42/0e77be6f2fafe7f3de88ddf9f8d9a0d8e9a75f9517081d261d31439908c7/coverage-7.7.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:1c8fbce80b2b8bf135d105aa8f5b36eae0c57d702a1cc3ebdea2a6f03f6cdde5", size = 210604 }, + { url = "https://files.pythonhosted.org/packages/0e/62/a82adc7818545fca3987367c6b20f239645678438f7da5827a4960bcbe7f/coverage-7.7.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:d9710521f07f526de30ccdead67e6b236fe996d214e1a7fba8b36e2ba2cd8261", size = 211031 }, + { url = "https://files.pythonhosted.org/packages/a6/50/a98b418fcaf531b2829b2a06f47f8c5cbc0dcce4a9aa63c5f30bf47d1a92/coverage-7.7.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7789e700f33f2b133adae582c9f437523cd5db8de845774988a58c360fc88253", size = 239791 }, + { url = "https://files.pythonhosted.org/packages/58/f7/0a8f891fce6f389b1062a520aff130fa6974433efeb549dd19cbdccc76b3/coverage-7.7.0-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b8c36093aca722db73633cf2359026ed7782a239eb1c6db2abcff876012dc4cf", size = 237718 }, + { url = "https://files.pythonhosted.org/packages/a9/8f/362c91661e6c43ff86b65b15bbb60ad1ad4924e9d1e35a0d5f08eb3337c4/coverage-7.7.0-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c075d167a6ec99b798c1fdf6e391a1d5a2d054caffe9593ba0f97e3df2c04f0e", size = 238820 }, + { url = "https://files.pythonhosted.org/packages/dd/4b/56520dba6f38ad59e96cdeb8c7eafa47781576d2baabdfa10f8c1813b37b/coverage-7.7.0-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:d013c07061751ae81861cae6ec3a4fe04e84781b11fd4b6b4201590234b25c7b", size = 238595 }, + { url = "https://files.pythonhosted.org/packages/4d/e6/acfae468bd1f9b691b29d42f93bfd7080c05021103f03580934c066a3844/coverage-7.7.0-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:104bf640f408f4e115b85110047c7f27377e1a8b7ba86f7db4fa47aa49dc9a8e", size = 236820 }, + { url = "https://files.pythonhosted.org/packages/22/4f/9b65332326b0c5b7de197a52e766e2bd547beec6948e1d5c4063289e3281/coverage-7.7.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:39abcacd1ed54e2c33c54bdc488b310e8ef6705833f7148b6eb9a547199d375d", size = 237800 }, + { url = "https://files.pythonhosted.org/packages/bb/99/1c2214678731517d91774b75ed5c0f72feefee3270c232c286b314518d7d/coverage-7.7.0-cp39-cp39-win32.whl", hash = "sha256:8e336b56301774ace6be0017ff85c3566c556d938359b61b840796a0202f805c", size = 213341 }, + { url = "https://files.pythonhosted.org/packages/21/30/4d9ae5544f839da30e42e03850d1dfe4ab184d6307ed971e70178760a68d/coverage-7.7.0-cp39-cp39-win_amd64.whl", hash = "sha256:8c938c6ae59be67ac19a7204e079efc94b38222cd7d0269f96e45e18cddeaa59", size = 214227 }, + { url = "https://files.pythonhosted.org/packages/cb/69/6a5eac32d2e8721274ef75df1b9fd6a8f7e8231e41ff7bc5501f19835f25/coverage-7.7.0-pp39.pp310.pp311-none-any.whl", hash = "sha256:3b0e6e54591ae0d7427def8a4d40fca99df6b899d10354bab73cd5609807261c", size = 202813 }, + { url = "https://files.pythonhosted.org/packages/2a/ac/60f409a448e5b0e9b8539716f683568aa5848c1be903cdbbc805a552cdf8/coverage-7.7.0-py3-none-any.whl", hash = "sha256:708f0a1105ef2b11c79ed54ed31f17e6325ac936501fc373f24be3e6a578146a", size = 202803 }, +] + +[package.optional-dependencies] +toml = [ + { name = "tomli", version = "2.2.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.9' and python_full_version <= '3.11'" }, +] + +[[package]] +name = "cycler" +version = "0.11.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine != 'aarch64' and platform_machine != 'arm64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'aarch64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'arm64'", + "python_full_version < '3.7.1'", +] +sdist = { url = "https://files.pythonhosted.org/packages/34/45/a7caaacbfc2fa60bee42effc4bcc7d7c6dbe9c349500e04f65a861c15eb9/cycler-0.11.0.tar.gz", hash = "sha256:9c87405839a19696e837b3b818fed3f5f69f16f1eec1a1ad77e043dcea9c772f", size = 18784 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5c/f9/695d6bedebd747e5eb0fe8fad57b72fdf25411273a39791cde838d5a8f51/cycler-0.11.0-py3-none-any.whl", hash = "sha256:3a27e95f763a428a739d2add979fa7494c912a32c17c4c38c4d5f082cad165a3", size = 6389 }, +] + +[[package]] +name = "cycler" +version = "0.12.1" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", + "python_full_version == '3.10.*'", + "python_full_version == '3.9.*'", + "python_full_version == '3.8.*'", +] +sdist = { url = "https://files.pythonhosted.org/packages/a9/95/a3dbbb5028f35eafb79008e7522a75244477d2838f38cbb722248dabc2a8/cycler-0.12.1.tar.gz", hash = "sha256:88bb128f02ba341da8ef447245a9e138fae777f6a23943da4540077d3601eb1c", size = 7615 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e7/05/c19819d5e3d95294a6f5947fb9b9629efb316b96de511b418c53d245aae6/cycler-0.12.1-py3-none-any.whl", hash = "sha256:85cef7cff222d8644161529808465972e51340599459b8ac3ccbac5a854e0d30", size = 8321 }, +] + +[[package]] +name = "debugpy" +version = "1.7.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine != 'aarch64' and platform_machine != 'arm64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'aarch64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'arm64'", + "python_full_version < '3.7.1'", +] +sdist = { url = "https://files.pythonhosted.org/packages/e3/98/8bdf6816618a6d2244d1abc7003e6c299fa20179bc336ff8ebb7020a4a82/debugpy-1.7.0.zip", hash = "sha256:676911c710e85567b17172db934a71319ed9d995104610ce23fd74a07f66e6f6", size = 4825018 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/76/46/feff47030c3e77b58f244149dc5544dbcf5fc90e16ded5158e93e8e0b5b1/debugpy-1.7.0-cp310-cp310-macosx_11_0_x86_64.whl", hash = "sha256:17ad9a681aca1704c55b9a5edcb495fa8f599e4655c9872b7f9cf3dc25890d48", size = 2057086 }, + { url = "https://files.pythonhosted.org/packages/76/a2/8986aa5e771ae5a2d5226d181978b7a00f753a0153bcc21619dafda9a51a/debugpy-1.7.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1285920a3f9a75f5d1acf59ab1b9da9ae6eb9a05884cd7674f95170c9cafa4de", size = 3341611 }, + { url = "https://files.pythonhosted.org/packages/ad/25/679b15b484fb9c722322413f478cd0543c131f5ce11ee533aec9f0913722/debugpy-1.7.0-cp310-cp310-win32.whl", hash = "sha256:a6f43a681c5025db1f1c0568069d1d1bad306a02e7c36144912b26d9c90e4724", size = 4974295 }, + { url = "https://files.pythonhosted.org/packages/eb/d4/3bf9a117ced0b05e7b02a70237c28c15ad64326f4e5a1dbe39e739919615/debugpy-1.7.0-cp310-cp310-win_amd64.whl", hash = "sha256:9e9571d831ad3c75b5fb6f3efcb71c471cf2a74ba84af6ac1c79ce00683bed4b", size = 5000883 }, + { url = "https://files.pythonhosted.org/packages/bd/a3/5e37ce13c7dd850b72a52be544a058ed49606ebbbf8b95b2ba3c1db5620a/debugpy-1.7.0-cp311-cp311-macosx_11_0_universal2.whl", hash = "sha256:538765a41198aa88cc089295b39c7322dd598f9ef1d52eaae12145c63bf9430a", size = 2126470 }, + { url = "https://files.pythonhosted.org/packages/b4/fc/087324d46dab8e21e084ce2cf670fa7e524ab5e7691692438e4987bd3ecb/debugpy-1.7.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c7e8cf91f8f3f9b5fad844dd88427b85d398bda1e2a0cd65d5a21312fcbc0c6f", size = 2986071 }, + { url = "https://files.pythonhosted.org/packages/52/59/3591e9f709b7ee4d3a926a8903a395669cd0e0279204a94b6acccf6ed6ee/debugpy-1.7.0-cp311-cp311-win32.whl", hash = "sha256:18a69f8e142a716310dd0af6d7db08992aed99e2606108732efde101e7c65e2a", size = 4913550 }, + { url = "https://files.pythonhosted.org/packages/51/59/84ebd58d3e9de33a54ca8aa4532e03906e5458092dafe240264c2937a99b/debugpy-1.7.0-cp311-cp311-win_amd64.whl", hash = "sha256:7515a5ba5ee9bfe956685909c5f28734c1cecd4ee813523363acfe3ca824883a", size = 4928089 }, + { url = "https://files.pythonhosted.org/packages/08/af/59a20d895aa81b941b07bfe13053b381d3f931d87f994ef0ec18ad72d190/debugpy-1.7.0-cp37-cp37m-macosx_11_0_x86_64.whl", hash = "sha256:bc8da67ade39d9e75608cdb8601d07e63a4e85966e0572c981f14e2cf42bcdef", size = 2044575 }, + { url = "https://files.pythonhosted.org/packages/2c/fa/26a39f5134c8b9133b006fd88214394cb019f81bb507feb75222e910aa11/debugpy-1.7.0-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a5036e918c6ba8fc4c4f1fd0207d81db634431a02f0dc2ba51b12fd793c8c9de", size = 3241015 }, + { url = "https://files.pythonhosted.org/packages/77/fc/991aba0a514afe0b0a9c00b95ee9b3adffb7208d83e2809391faba3e5c80/debugpy-1.7.0-cp37-cp37m-win32.whl", hash = "sha256:d5be95b3946a4d7b388e45068c7b75036ac5a610f41014aee6cafcd5506423ad", size = 4977447 }, + { url = "https://files.pythonhosted.org/packages/8e/c9/e69ae08c310850abd15c051eb77effc9a72239db15e4e8cae40e2c4b8db8/debugpy-1.7.0-cp37-cp37m-win_amd64.whl", hash = "sha256:0e90314a078d4e3f009520c8387aba8f74c3034645daa7a332a3d1bb81335756", size = 5002713 }, + { url = "https://files.pythonhosted.org/packages/fd/be/ca3075fd11ff929bf6dbe782de3ccd1d524b6ad27f0b4becfe1efadfada7/debugpy-1.7.0-cp38-cp38-macosx_11_0_x86_64.whl", hash = "sha256:1565fd904f9571c430adca597771255cff4f92171486fced6f765dcbdfc8ec8d", size = 2056282 }, + { url = "https://files.pythonhosted.org/packages/25/b1/a8f253148b1d2e382e0b8313e273ba8e75618101698bcd89b2aaf6abd809/debugpy-1.7.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6516f36a2e95b3be27f171f12b641e443863f4ad5255d0fdcea6ae0be29bb912", size = 3462208 }, + { url = "https://files.pythonhosted.org/packages/81/b1/3d1ccaeb637bfcb3f813eed1926ab8826ae1cebd69ef12fc6722b1a62ee4/debugpy-1.7.0-cp38-cp38-win32.whl", hash = "sha256:2b0e489613bc066051439df04c56777ec184b957d6810cb65f235083aef7a0dc", size = 4985477 }, + { url = "https://files.pythonhosted.org/packages/e3/c0/59c542c4fe544664b008c10d3b566a644751c7ee3e453df327311331a5d0/debugpy-1.7.0-cp38-cp38-win_amd64.whl", hash = "sha256:7bf0b4bbd841b2397b6a8de15da9227f1164f6d43ceee971c50194eaed930a9d", size = 5015295 }, + { url = "https://files.pythonhosted.org/packages/a0/1c/5dc5bb67dab8298c23d1a3a53f529b831c00ac9371da422da7889a99156b/debugpy-1.7.0-cp39-cp39-macosx_11_0_x86_64.whl", hash = "sha256:ad22e1095b9977af432465c1e09132ba176e18df3834b1efcab1a449346b350b", size = 2066454 }, + { url = "https://files.pythonhosted.org/packages/ed/46/0de1be589e1ee6ebdae07f8bc497551e6436fac0f20dda6618262dd82ec0/debugpy-1.7.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f625e427f21423e5874139db529e18cb2966bdfcc1cb87a195538c5b34d163d1", size = 3408236 }, + { url = "https://files.pythonhosted.org/packages/f5/e9/1c7288b60d63ad605f9d9800701b6cfe482feed9960fd5235f2e5482aff9/debugpy-1.7.0-cp39-cp39-win32.whl", hash = "sha256:18bca8429d6632e2d3435055416d2d88f0309cc39709f4f6355c8d412cc61f24", size = 4984107 }, + { url = "https://files.pythonhosted.org/packages/51/77/638b52f9bc962e3a6b04988351ee0b19148d1d6f42dbac528fbc2c259a83/debugpy-1.7.0-cp39-cp39-win_amd64.whl", hash = "sha256:dc8a12ac8b97ef3d6973c6679a093138c7c9b03eb685f0e253269a195f651559", size = 5012265 }, + { url = "https://files.pythonhosted.org/packages/39/2f/c8a8cfac6c7fa3d9e163a6bf46e6d27d027b7a1331028e99a6ef7fd3699d/debugpy-1.7.0-py2.py3-none-any.whl", hash = "sha256:f6de2e6f24f62969e0f0ef682d78c98161c4dca29e9fb05df4d2989005005502", size = 5036917 }, +] + +[[package]] +name = "debugpy" +version = "1.8.13" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", + "python_full_version == '3.10.*'", + "python_full_version == '3.9.*'", + "python_full_version == '3.8.*'", +] +sdist = { url = "https://files.pythonhosted.org/packages/51/d4/f35f539e11c9344652f362c22413ec5078f677ac71229dc9b4f6f85ccaa3/debugpy-1.8.13.tar.gz", hash = "sha256:837e7bef95bdefba426ae38b9a94821ebdc5bea55627879cd48165c90b9e50ce", size = 1641193 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3f/32/901c7204cceb3262fdf38f4c25c9a46372c11661e8490e9ea702bc4ff448/debugpy-1.8.13-cp310-cp310-macosx_14_0_x86_64.whl", hash = "sha256:06859f68e817966723ffe046b896b1bd75c665996a77313370336ee9e1de3e90", size = 2076250 }, + { url = "https://files.pythonhosted.org/packages/95/10/77fe746851c8d84838a807da60c7bd0ac8627a6107d6917dd3293bf8628c/debugpy-1.8.13-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cb56c2db69fb8df3168bc857d7b7d2494fed295dfdbde9a45f27b4b152f37520", size = 3560883 }, + { url = "https://files.pythonhosted.org/packages/a1/ef/28f8db2070e453dda0e49b356e339d0b4e1d38058d4c4ea9e88cdc8ee8e7/debugpy-1.8.13-cp310-cp310-win32.whl", hash = "sha256:46abe0b821cad751fc1fb9f860fb2e68d75e2c5d360986d0136cd1db8cad4428", size = 5180149 }, + { url = "https://files.pythonhosted.org/packages/89/16/1d53a80caf5862627d3eaffb217d4079d7e4a1df6729a2d5153733661efd/debugpy-1.8.13-cp310-cp310-win_amd64.whl", hash = "sha256:dc7b77f5d32674686a5f06955e4b18c0e41fb5a605f5b33cf225790f114cfeec", size = 5212540 }, + { url = "https://files.pythonhosted.org/packages/31/90/dd2fcad8364f0964f476537481985198ce6e879760281ad1cec289f1aa71/debugpy-1.8.13-cp311-cp311-macosx_14_0_universal2.whl", hash = "sha256:eee02b2ed52a563126c97bf04194af48f2fe1f68bb522a312b05935798e922ff", size = 2174802 }, + { url = "https://files.pythonhosted.org/packages/5c/c9/06ff65f15eb30dbdafd45d1575770b842ce3869ad5580a77f4e5590f1be7/debugpy-1.8.13-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4caca674206e97c85c034c1efab4483f33971d4e02e73081265ecb612af65377", size = 3133620 }, + { url = "https://files.pythonhosted.org/packages/3b/49/798a4092bde16a4650f17ac5f2301d4d37e1972d65462fb25c80a83b4790/debugpy-1.8.13-cp311-cp311-win32.whl", hash = "sha256:7d9a05efc6973b5aaf076d779cf3a6bbb1199e059a17738a2aa9d27a53bcc888", size = 5104764 }, + { url = "https://files.pythonhosted.org/packages/cd/d5/3684d7561c8ba2797305cf8259619acccb8d6ebe2117bb33a6897c235eee/debugpy-1.8.13-cp311-cp311-win_amd64.whl", hash = "sha256:62f9b4a861c256f37e163ada8cf5a81f4c8d5148fc17ee31fb46813bd658cdcc", size = 5129670 }, + { url = "https://files.pythonhosted.org/packages/79/ad/dff929b6b5403feaab0af0e5bb460fd723f9c62538b718a9af819b8fff20/debugpy-1.8.13-cp312-cp312-macosx_14_0_universal2.whl", hash = "sha256:2b8de94c5c78aa0d0ed79023eb27c7c56a64c68217d881bee2ffbcb13951d0c1", size = 2501004 }, + { url = "https://files.pythonhosted.org/packages/d6/4f/b7d42e6679f0bb525888c278b0c0d2b6dff26ed42795230bb46eaae4f9b3/debugpy-1.8.13-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:887d54276cefbe7290a754424b077e41efa405a3e07122d8897de54709dbe522", size = 4222346 }, + { url = "https://files.pythonhosted.org/packages/ec/18/d9b3e88e85d41f68f77235112adc31012a784e45a3fcdbb039777d570a0f/debugpy-1.8.13-cp312-cp312-win32.whl", hash = "sha256:3872ce5453b17837ef47fb9f3edc25085ff998ce63543f45ba7af41e7f7d370f", size = 5226639 }, + { url = "https://files.pythonhosted.org/packages/c9/f7/0df18a4f530ed3cc06f0060f548efe9e3316102101e311739d906f5650be/debugpy-1.8.13-cp312-cp312-win_amd64.whl", hash = "sha256:63ca7670563c320503fea26ac688988d9d6b9c6a12abc8a8cf2e7dd8e5f6b6ea", size = 5268735 }, + { url = "https://files.pythonhosted.org/packages/b1/db/ae7cd645c1826aae557cebccbc448f0cc9a818d364efb88f8d80e7a03f41/debugpy-1.8.13-cp313-cp313-macosx_14_0_universal2.whl", hash = "sha256:31abc9618be4edad0b3e3a85277bc9ab51a2d9f708ead0d99ffb5bb750e18503", size = 2485416 }, + { url = "https://files.pythonhosted.org/packages/ec/ed/db4b10ff3b5bb30fe41d9e86444a08bb6448e4d8265e7768450b8408dd36/debugpy-1.8.13-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a0bd87557f97bced5513a74088af0b84982b6ccb2e254b9312e29e8a5c4270eb", size = 4218784 }, + { url = "https://files.pythonhosted.org/packages/82/82/ed81852a8d94086f51664d032d83c7f87cd2b087c6ea70dabec7c1ba813d/debugpy-1.8.13-cp313-cp313-win32.whl", hash = "sha256:5268ae7fdca75f526d04465931cb0bd24577477ff50e8bb03dab90983f4ebd02", size = 5226270 }, + { url = "https://files.pythonhosted.org/packages/15/63/aa92fb341a78ec40f1c414ec7a7885c2ee17032eee00d12cee0cdc502af4/debugpy-1.8.13-cp313-cp313-win_amd64.whl", hash = "sha256:79ce4ed40966c4c1631d0131606b055a5a2f8e430e3f7bf8fd3744b09943e8e8", size = 5268621 }, + { url = "https://files.pythonhosted.org/packages/c8/2b/be2c8186cca5ae78a2b3d2b36fc0f3b9da70057397e1c7b53218d84c2144/debugpy-1.8.13-cp38-cp38-macosx_14_0_x86_64.whl", hash = "sha256:acf39a6e98630959763f9669feddee540745dfc45ad28dbc9bd1f9cd60639391", size = 2076953 }, + { url = "https://files.pythonhosted.org/packages/84/c2/555d66812a4b34501bbfcc946e6e5a9cee6860ee3954a17b1a8c36b7a4a8/debugpy-1.8.13-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:924464d87e7d905eb0d79fb70846558910e906d9ee309b60c4fe597a2e802590", size = 3632712 }, + { url = "https://files.pythonhosted.org/packages/d5/3f/2edf5a3d2c49f9410fe68c4d080849e0434368699a1d5666e771af751502/debugpy-1.8.13-cp38-cp38-win32.whl", hash = "sha256:3dae443739c6b604802da9f3e09b0f45ddf1cf23c99161f3a1a8039f61a8bb89", size = 5184405 }, + { url = "https://files.pythonhosted.org/packages/7c/be/944679cd9549d21608038dfe4ad6186656394ddbaabb1feef5d5de6004bf/debugpy-1.8.13-cp38-cp38-win_amd64.whl", hash = "sha256:ed93c3155fc1f888ab2b43626182174e457fc31b7781cd1845629303790b8ad1", size = 5217987 }, + { url = "https://files.pythonhosted.org/packages/6a/f8/19d41febacbbe1c386bbf7f01ef8ba94b3e9e44315fc5b17cfddda718ef8/debugpy-1.8.13-cp39-cp39-macosx_14_0_x86_64.whl", hash = "sha256:6fab771639332bd8ceb769aacf454a30d14d7a964f2012bf9c4e04c60f16e85b", size = 2077436 }, + { url = "https://files.pythonhosted.org/packages/c4/a5/93ee84dd7e238a8709d9f36481977fd3f21929378122d3c960e568fdc1ec/debugpy-1.8.13-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:32b6857f8263a969ce2ca098f228e5cc0604d277447ec05911a8c46cf3e7e307", size = 3556117 }, + { url = "https://files.pythonhosted.org/packages/93/c7/94dfd470bd386f968f2d89ae63cc633c1edaada6b21b7afca167a4e79152/debugpy-1.8.13-cp39-cp39-win32.whl", hash = "sha256:f14d2c4efa1809da125ca62df41050d9c7cd9cb9e380a2685d1e453c4d450ccb", size = 5180906 }, + { url = "https://files.pythonhosted.org/packages/4a/39/503e29394ed90c5a85fac9f36539aefd470caae8f23f9ffc9f067954d3f4/debugpy-1.8.13-cp39-cp39-win_amd64.whl", hash = "sha256:ea869fe405880327497e6945c09365922c79d2a1eed4c3ae04d77ac7ae34b2b5", size = 5213365 }, + { url = "https://files.pythonhosted.org/packages/37/4f/0b65410a08b6452bfd3f7ed6f3610f1a31fb127f46836e82d31797065dcb/debugpy-1.8.13-py2.py3-none-any.whl", hash = "sha256:d4ba115cdd0e3a70942bd562adba9ec8c651fe69ddde2298a1be296fc331906f", size = 5229306 }, +] + +[[package]] +name = "decorator" +version = "5.1.1" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine != 'aarch64' and platform_machine != 'arm64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'aarch64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'arm64'", + "python_full_version < '3.7.1'", +] +sdist = { url = "https://files.pythonhosted.org/packages/66/0c/8d907af351aa16b42caae42f9d6aa37b900c67308052d10fdce809f8d952/decorator-5.1.1.tar.gz", hash = "sha256:637996211036b6385ef91435e4fae22989472f9d571faba8927ba8253acbc330", size = 35016 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d5/50/83c593b07763e1161326b3b8c6686f0f4b0f24d5526546bee538c89837d6/decorator-5.1.1-py3-none-any.whl", hash = "sha256:b8c3f85900b9dc423225913c5aace94729fe1fa9763b38939a95226f02d37186", size = 9073 }, +] + +[[package]] +name = "decorator" +version = "5.2.1" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", + "python_full_version == '3.10.*'", + "python_full_version == '3.9.*'", + "python_full_version == '3.8.*'", +] +sdist = { url = "https://files.pythonhosted.org/packages/43/fa/6d96a0978d19e17b68d634497769987b16c8f4cd0a7a05048bec693caa6b/decorator-5.2.1.tar.gz", hash = "sha256:65f266143752f734b0a7cc83c46f4618af75b8c5911b00ccb61d0ac9b6da0360", size = 56711 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4e/8c/f3147f5c4b73e7550fe5f9352eaa956ae838d5c51eb58e7a25b9f3e2643b/decorator-5.2.1-py3-none-any.whl", hash = "sha256:d316bb415a2d9e2d2b3abcc4084c6502fc09240e292cd76a76afc106a1c8e04a", size = 9190 }, +] + +[[package]] +name = "defusedxml" +version = "0.7.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/0f/d5/c66da9b79e5bdb124974bfe172b4daf3c984ebd9c2a06e2b8a4dc7331c72/defusedxml-0.7.1.tar.gz", hash = "sha256:1bb3032db185915b62d7c6209c5a8792be6a32ab2fedacc84e01b52c51aa3e69", size = 75520 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/07/6c/aa3f2f849e01cb6a001cd8554a88d4c77c5c1a31c95bdf1cf9301e6d9ef4/defusedxml-0.7.1-py2.py3-none-any.whl", hash = "sha256:a352e7e428770286cc899e2542b6cdaedb2b4953ff269a210103ec58f6198a61", size = 25604 }, +] + +[[package]] +name = "docutils" +version = "0.19" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine != 'aarch64' and platform_machine != 'arm64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'aarch64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'arm64'", + "python_full_version < '3.7.1'", +] +sdist = { url = "https://files.pythonhosted.org/packages/6b/5c/330ea8d383eb2ce973df34d1239b3b21e91cd8c865d21ff82902d952f91f/docutils-0.19.tar.gz", hash = "sha256:33995a6753c30b7f577febfc2c50411fec6aac7f7ffeb7c4cfe5991072dcf9e6", size = 2056383 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/93/69/e391bd51bc08ed9141ecd899a0ddb61ab6465309f1eb470905c0c8868081/docutils-0.19-py3-none-any.whl", hash = "sha256:5e1de4d849fee02c63b040a4a3fd567f4ab104defd8a5511fbbc24a8a017efbc", size = 570472 }, +] + +[[package]] +name = "docutils" +version = "0.20.1" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version == '3.8.*'", +] +sdist = { url = "https://files.pythonhosted.org/packages/1f/53/a5da4f2c5739cf66290fac1431ee52aff6851c7c8ffd8264f13affd7bcdd/docutils-0.20.1.tar.gz", hash = "sha256:f08a4e276c3a1583a86dce3e34aba3fe04d02bba2dd51ed16106244e8a923e3b", size = 2058365 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/26/87/f238c0670b94533ac0353a4e2a1a771a0cc73277b88bff23d3ae35a256c1/docutils-0.20.1-py3-none-any.whl", hash = "sha256:96f387a2c5562db4476f09f13bbab2192e764cac08ebbf3a34a95d9b1e4a59d6", size = 572666 }, +] + +[[package]] +name = "docutils" +version = "0.21.2" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", + "python_full_version == '3.10.*'", + "python_full_version == '3.9.*'", +] +sdist = { url = "https://files.pythonhosted.org/packages/ae/ed/aefcc8cd0ba62a0560c3c18c33925362d46c6075480bfa4df87b28e169a9/docutils-0.21.2.tar.gz", hash = "sha256:3a6b18732edf182daa3cd12775bbb338cf5691468f91eeeb109deff6ebfa986f", size = 2204444 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8f/d7/9322c609343d929e75e7e5e6255e614fcc67572cfd083959cdef3b7aad79/docutils-0.21.2-py3-none-any.whl", hash = "sha256:dafca5b9e384f0e419294eb4d2ff9fa826435bf15f15b7bd45723e8ad76811b2", size = 587408 }, +] + +[[package]] +name = "entrypoints" +version = "0.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ea/8d/a7121ffe5f402dc015277d2d31eb82d2187334503a011c18f2e78ecbb9b2/entrypoints-0.4.tar.gz", hash = "sha256:b706eddaa9218a19ebcd67b56818f05bb27589b1ca9e8d797b74affad4ccacd4", size = 13974 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/35/a8/365059bbcd4572cbc41de17fd5b682be5868b218c3c5479071865cab9078/entrypoints-0.4-py3-none-any.whl", hash = "sha256:f174b5ff827504fd3cd97cc3f8649f3693f51538c7e4bdf3ef002c8429d42f9f", size = 5294 }, +] + +[[package]] +name = "exceptiongroup" +version = "1.2.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/09/35/2495c4ac46b980e4ca1f6ad6db102322ef3ad2410b79fdde159a4b0f3b92/exceptiongroup-1.2.2.tar.gz", hash = "sha256:47c2edf7c6738fafb49fd34290706d1a1a2f4d1c6df275526b62cbb4aa5393cc", size = 28883 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/02/cc/b7e31358aac6ed1ef2bb790a9746ac2c69bcb3c8588b41616914eb106eaf/exceptiongroup-1.2.2-py3-none-any.whl", hash = "sha256:3111b9d131c238bec2f8f516e123e14ba243563fb135d3fe885990585aa7795b", size = 16453 }, +] + +[[package]] +name = "executing" +version = "2.2.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/91/50/a9d80c47ff289c611ff12e63f7c5d13942c65d68125160cefd768c73e6e4/executing-2.2.0.tar.gz", hash = "sha256:5d108c028108fe2551d1a7b2e8b713341e2cb4fc0aa7dcf966fa4327a5226755", size = 978693 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7b/8f/c4d9bafc34ad7ad5d8dc16dd1347ee0e507a52c3adb6bfa8887e1c6a26ba/executing-2.2.0-py2.py3-none-any.whl", hash = "sha256:11387150cad388d62750327a53d3339fad4888b39a6fe233c3afbb54ecffd3aa", size = 26702 }, +] + +[[package]] +name = "fastjsonschema" +version = "2.21.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/8b/50/4b769ce1ac4071a1ef6d86b1a3fb56cdc3a37615e8c5519e1af96cdac366/fastjsonschema-2.21.1.tar.gz", hash = "sha256:794d4f0a58f848961ba16af7b9c85a3e88cd360df008c59aac6fc5ae9323b5d4", size = 373939 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/90/2b/0817a2b257fe88725c25589d89aec060581aabf668707a8d03b2e9e0cb2a/fastjsonschema-2.21.1-py3-none-any.whl", hash = "sha256:c9e5b7e908310918cf494a434eeb31384dd84a98b57a30bcb1f535015b554667", size = 23924 }, +] + +[[package]] +name = "fonttools" +version = "4.38.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine != 'aarch64' and platform_machine != 'arm64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'aarch64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'arm64'", + "python_full_version < '3.7.1'", +] +sdist = { url = "https://files.pythonhosted.org/packages/55/5c/a4a25cf6db42d113d8f626901bb156b2f7cf7c7564a6bbc7b5cd6f7cb484/fonttools-4.38.0.zip", hash = "sha256:2bb244009f9bf3fa100fc3ead6aeb99febe5985fa20afbfbaa2f8946c2fbdaf1", size = 5071980 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e3/d9/e9bae85e84737e76ebbcbea13607236da0c0699baed0ae4f1151b728a608/fonttools-4.38.0-py3-none-any.whl", hash = "sha256:820466f43c8be8c3009aef8b87e785014133508f0de64ec469e4efb643ae54fb", size = 965361 }, +] + +[[package]] +name = "fonttools" +version = "4.56.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", + "python_full_version == '3.10.*'", + "python_full_version == '3.9.*'", + "python_full_version == '3.8.*'", +] +sdist = { url = "https://files.pythonhosted.org/packages/1c/8c/9ffa2a555af0e5e5d0e2ed7fdd8c9bef474ed676995bb4c57c9cd0014248/fonttools-4.56.0.tar.gz", hash = "sha256:a114d1567e1a1586b7e9e7fc2ff686ca542a82769a296cef131e4c4af51e58f4", size = 3462892 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1e/5e/6ac30c2cc6a29454260f13c9c6422fc509b7982c13cd4597041260d8f482/fonttools-4.56.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:331954d002dbf5e704c7f3756028e21db07097c19722569983ba4d74df014000", size = 2752190 }, + { url = "https://files.pythonhosted.org/packages/92/3a/ac382a8396d1b420ee45eeb0f65b614a9ca7abbb23a1b17524054f0f2200/fonttools-4.56.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:8d1613abd5af2f93c05867b3a3759a56e8bf97eb79b1da76b2bc10892f96ff16", size = 2280624 }, + { url = "https://files.pythonhosted.org/packages/8a/ae/00b58bfe20e9ff7fbc3dda38f5d127913942b5e252288ea9583099a31bf5/fonttools-4.56.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:705837eae384fe21cee5e5746fd4f4b2f06f87544fa60f60740007e0aa600311", size = 4562074 }, + { url = "https://files.pythonhosted.org/packages/46/d0/0004ca8f6a200252e5bd6982ed99b5fe58c4c59efaf5f516621c4cd8f703/fonttools-4.56.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bc871904a53a9d4d908673c6faa15689874af1c7c5ac403a8e12d967ebd0c0dc", size = 4604747 }, + { url = "https://files.pythonhosted.org/packages/45/ea/c8862bd3e09d143ef8ed8268ec8a7d477828f960954889e65288ac050b08/fonttools-4.56.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:38b947de71748bab150259ee05a775e8a0635891568e9fdb3cdd7d0e0004e62f", size = 4559025 }, + { url = "https://files.pythonhosted.org/packages/8f/75/bb88a9552ec1de31a414066257bfd9f40f4ada00074f7a3799ea39b5741f/fonttools-4.56.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:86b2a1013ef7a64d2e94606632683f07712045ed86d937c11ef4dde97319c086", size = 4728482 }, + { url = "https://files.pythonhosted.org/packages/2a/5f/80a2b640df1e1bb7d459d62c8b3f37fe83fd413897e549106d4ebe6371f5/fonttools-4.56.0-cp310-cp310-win32.whl", hash = "sha256:133bedb9a5c6376ad43e6518b7e2cd2f866a05b1998f14842631d5feb36b5786", size = 2155557 }, + { url = "https://files.pythonhosted.org/packages/8f/85/0904f9dbe51ac70d878d3242a8583b9453a09105c3ed19c6301247fd0d3a/fonttools-4.56.0-cp310-cp310-win_amd64.whl", hash = "sha256:17f39313b649037f6c800209984a11fc256a6137cbe5487091c6c7187cae4685", size = 2200017 }, + { url = "https://files.pythonhosted.org/packages/35/56/a2f3e777d48fcae7ecd29de4d96352d84e5ea9871e5f3fc88241521572cf/fonttools-4.56.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:7ef04bc7827adb7532be3d14462390dd71287644516af3f1e67f1e6ff9c6d6df", size = 2753325 }, + { url = "https://files.pythonhosted.org/packages/71/85/d483e9c4e5ed586b183bf037a353e8d766366b54fd15519b30e6178a6a6e/fonttools-4.56.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:ffda9b8cd9cb8b301cae2602ec62375b59e2e2108a117746f12215145e3f786c", size = 2281554 }, + { url = "https://files.pythonhosted.org/packages/09/67/060473b832b2fade03c127019794df6dc02d9bc66fa4210b8e0d8a99d1e5/fonttools-4.56.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e2e993e8db36306cc3f1734edc8ea67906c55f98683d6fd34c3fc5593fdbba4c", size = 4869260 }, + { url = "https://files.pythonhosted.org/packages/28/e9/47c02d5a7027e8ed841ab6a10ca00c93dadd5f16742f1af1fa3f9978adf4/fonttools-4.56.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:003548eadd674175510773f73fb2060bb46adb77c94854af3e0cc5bc70260049", size = 4898508 }, + { url = "https://files.pythonhosted.org/packages/bf/8a/221d456d1afb8ca043cfd078f59f187ee5d0a580f4b49351b9ce95121f57/fonttools-4.56.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:bd9825822e7bb243f285013e653f6741954d8147427aaa0324a862cdbf4cbf62", size = 4877700 }, + { url = "https://files.pythonhosted.org/packages/a4/8c/e503863adf7a6aeff7b960e2f66fa44dd0c29a7a8b79765b2821950d7b05/fonttools-4.56.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:b23d30a2c0b992fb1c4f8ac9bfde44b5586d23457759b6cf9a787f1a35179ee0", size = 5045817 }, + { url = "https://files.pythonhosted.org/packages/2b/50/79ba3b7e42f4eaa70b82b9e79155f0f6797858dc8a97862428b6852c6aee/fonttools-4.56.0-cp311-cp311-win32.whl", hash = "sha256:47b5e4680002ae1756d3ae3b6114e20aaee6cc5c69d1e5911f5ffffd3ee46c6b", size = 2154426 }, + { url = "https://files.pythonhosted.org/packages/3b/90/4926e653041c4116ecd43e50e3c79f5daae6dcafc58ceb64bc4f71dd4924/fonttools-4.56.0-cp311-cp311-win_amd64.whl", hash = "sha256:14a3e3e6b211660db54ca1ef7006401e4a694e53ffd4553ab9bc87ead01d0f05", size = 2200937 }, + { url = "https://files.pythonhosted.org/packages/39/32/71cfd6877999576a11824a7fe7bc0bb57c5c72b1f4536fa56a3e39552643/fonttools-4.56.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:d6f195c14c01bd057bc9b4f70756b510e009c83c5ea67b25ced3e2c38e6ee6e9", size = 2747757 }, + { url = "https://files.pythonhosted.org/packages/15/52/d9f716b072c5061a0b915dd4c387f74bef44c68c069e2195c753905bd9b7/fonttools-4.56.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:fa760e5fe8b50cbc2d71884a1eff2ed2b95a005f02dda2fa431560db0ddd927f", size = 2279007 }, + { url = "https://files.pythonhosted.org/packages/d1/97/f1b3a8afa9a0d814a092a25cd42f59ccb98a0bb7a295e6e02fc9ba744214/fonttools-4.56.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d54a45d30251f1d729e69e5b675f9a08b7da413391a1227781e2a297fa37f6d2", size = 4783991 }, + { url = "https://files.pythonhosted.org/packages/95/70/2a781bedc1c45a0c61d29c56425609b22ed7f971da5d7e5df2679488741b/fonttools-4.56.0-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:661a8995d11e6e4914a44ca7d52d1286e2d9b154f685a4d1f69add8418961563", size = 4855109 }, + { url = "https://files.pythonhosted.org/packages/0c/02/a2597858e61a5e3fb6a14d5f6be9e6eb4eaf090da56ad70cedcbdd201685/fonttools-4.56.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:9d94449ad0a5f2a8bf5d2f8d71d65088aee48adbe45f3c5f8e00e3ad861ed81a", size = 4762496 }, + { url = "https://files.pythonhosted.org/packages/f2/00/aaf00100d6078fdc73f7352b44589804af9dc12b182a2540b16002152ba4/fonttools-4.56.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:f59746f7953f69cc3290ce2f971ab01056e55ddd0fb8b792c31a8acd7fee2d28", size = 4990094 }, + { url = "https://files.pythonhosted.org/packages/bf/dc/3ff1db522460db60cf3adaf1b64e0c72b43406717d139786d3fa1eb20709/fonttools-4.56.0-cp312-cp312-win32.whl", hash = "sha256:bce60f9a977c9d3d51de475af3f3581d9b36952e1f8fc19a1f2254f1dda7ce9c", size = 2142888 }, + { url = "https://files.pythonhosted.org/packages/6f/e3/5a181a85777f7809076e51f7422e0dc77eb04676c40ec8bf6a49d390d1ff/fonttools-4.56.0-cp312-cp312-win_amd64.whl", hash = "sha256:300c310bb725b2bdb4f5fc7e148e190bd69f01925c7ab437b9c0ca3e1c7cd9ba", size = 2189734 }, + { url = "https://files.pythonhosted.org/packages/a5/55/f06b48d48e0b4ec3a3489efafe9bd4d81b6e0802ac51026e3ee4634e89ba/fonttools-4.56.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:f20e2c0dfab82983a90f3d00703ac0960412036153e5023eed2b4641d7d5e692", size = 2735127 }, + { url = "https://files.pythonhosted.org/packages/59/db/d2c7c9b6dd5cbd46f183e650a47403ffb88fca17484eb7c4b1cd88f9e513/fonttools-4.56.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f36a0868f47b7566237640c026c65a86d09a3d9ca5df1cd039e30a1da73098a0", size = 2272519 }, + { url = "https://files.pythonhosted.org/packages/4d/a2/da62d779c34a0e0c06415f02eab7fa3466de5d46df459c0275a255cefc65/fonttools-4.56.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:62b4c6802fa28e14dba010e75190e0e6228513573f1eeae57b11aa1a39b7e5b1", size = 4762423 }, + { url = "https://files.pythonhosted.org/packages/be/6a/fd4018e0448c8a5e12138906411282c5eab51a598493f080a9f0960e658f/fonttools-4.56.0-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a05d1f07eb0a7d755fbe01fee1fd255c3a4d3730130cf1bfefb682d18fd2fcea", size = 4834442 }, + { url = "https://files.pythonhosted.org/packages/6d/63/fa1dec8efb35bc11ef9c39b2d74754b45d48a3ccb2cf78c0109c0af639e8/fonttools-4.56.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:0073b62c3438cf0058488c002ea90489e8801d3a7af5ce5f7c05c105bee815c3", size = 4742800 }, + { url = "https://files.pythonhosted.org/packages/dd/f4/963247ae8c73ccc4cf2929e7162f595c81dbe17997d1d0ea77da24a217c9/fonttools-4.56.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e2cad98c94833465bcf28f51c248aaf07ca022efc6a3eba750ad9c1e0256d278", size = 4963746 }, + { url = "https://files.pythonhosted.org/packages/ea/e0/46f9600c39c644b54e4420f941f75fa200d9288c9ae171e5d80918b8cbb9/fonttools-4.56.0-cp313-cp313-win32.whl", hash = "sha256:d0cb73ccf7f6d7ca8d0bc7ea8ac0a5b84969a41c56ac3ac3422a24df2680546f", size = 2140927 }, + { url = "https://files.pythonhosted.org/packages/27/6d/3edda54f98a550a0473f032d8050315fbc8f1b76a0d9f3879b72ebb2cdd6/fonttools-4.56.0-cp313-cp313-win_amd64.whl", hash = "sha256:62cc1253827d1e500fde9dbe981219fea4eb000fd63402283472d38e7d8aa1c6", size = 2186709 }, + { url = "https://files.pythonhosted.org/packages/72/2d/762488c56a2bba2fa4d459233d971c2122bf1ed1ec5d9edfee7d58963ef5/fonttools-4.56.0-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:3fd3fccb7b9adaaecfa79ad51b759f2123e1aba97f857936ce044d4f029abd71", size = 2749891 }, + { url = "https://files.pythonhosted.org/packages/5a/64/4d4a46959e4bfd62210eee4c5c3259ec62c6eca437fa2e3e795ac0bde94f/fonttools-4.56.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:193b86e9f769320bc98ffdb42accafb5d0c8c49bd62884f1c0702bc598b3f0a2", size = 2279311 }, + { url = "https://files.pythonhosted.org/packages/5e/cd/0531711a900bb89cc757259c21fd67cc3cb4de260b3c4c1390dbfa463b01/fonttools-4.56.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6e81c1cc80c1d8bf071356cc3e0e25071fbba1c75afc48d41b26048980b3c771", size = 4643308 }, + { url = "https://files.pythonhosted.org/packages/e0/c1/a3b9221b623eead07a4f2fd105b9183a2f70461deae14fac0f4c65872d04/fonttools-4.56.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e9270505a19361e81eecdbc2c251ad1e1a9a9c2ad75fa022ccdee533f55535dc", size = 4687400 }, + { url = "https://files.pythonhosted.org/packages/67/14/67f5c0b695e4043b566e04b1f78e4f749cdd1bab6370f8056791e1c57314/fonttools-4.56.0-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:53f5e9767978a4daf46f28e09dbeb7d010319924ae622f7b56174b777258e5ba", size = 4665170 }, + { url = "https://files.pythonhosted.org/packages/3c/fe/c8bfbe682def287eca26052e5232ca293ea0f9a6a3051dab2cb65e4ef401/fonttools-4.56.0-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:9da650cb29bc098b8cfd15ef09009c914b35c7986c8fa9f08b51108b7bc393b4", size = 4844223 }, + { url = "https://files.pythonhosted.org/packages/9c/c1/2133e0a2558c94fefb3d655b3ca782f4310aa86ee8da0e12274cf6dc91c2/fonttools-4.56.0-cp38-cp38-win32.whl", hash = "sha256:965d0209e6dbdb9416100123b6709cb13f5232e2d52d17ed37f9df0cc31e2b35", size = 1480341 }, + { url = "https://files.pythonhosted.org/packages/e9/73/e0285a1cd25da20f1403a6dea54c116a6ccae6063f209a39793977dad03a/fonttools-4.56.0-cp38-cp38-win_amd64.whl", hash = "sha256:654ac4583e2d7c62aebc6fc6a4c6736f078f50300e18aa105d87ce8925cfac31", size = 1525378 }, + { url = "https://files.pythonhosted.org/packages/c2/a0/c62b7f219f74f0e9c4b7662c269b360f5c380cf7dfabaff06e114acc5576/fonttools-4.56.0-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:ca7962e8e5fc047cc4e59389959843aafbf7445b6c08c20d883e60ced46370a5", size = 2754871 }, + { url = "https://files.pythonhosted.org/packages/22/aa/2ce61705c48c4dc7953bec95f7cfa29e528294a06e7d38f2c674343425ca/fonttools-4.56.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:a1af375734018951c31c0737d04a9d5fd0a353a0253db5fbed2ccd44eac62d8c", size = 2281885 }, + { url = "https://files.pythonhosted.org/packages/81/68/508c1e84050b950918b1345ee22def98291b2e58890b0f3c2d0cfc4fee6b/fonttools-4.56.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:442ad4122468d0e47d83bc59d0e91b474593a8c813839e1872e47c7a0cb53b10", size = 4567663 }, + { url = "https://files.pythonhosted.org/packages/56/af/78b2c901949ca37c02ba4eec88020479e929b7d1126af30ee9d7e44b4c4c/fonttools-4.56.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3cf4f8d2a30b454ac682e12c61831dcb174950c406011418e739de592bbf8f76", size = 4612654 }, + { url = "https://files.pythonhosted.org/packages/cb/fb/156bd9760b6d42be3d821f0ac3edccf8daf97b0e4fe539c569b6593f4b6a/fonttools-4.56.0-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:96a4271f63a615bcb902b9f56de00ea225d6896052c49f20d0c91e9f43529a29", size = 4561135 }, + { url = "https://files.pythonhosted.org/packages/c4/e9/c6c433b8ea306ba402aa1d53349237d78c1d21ec11bb69cc6d8442533d5b/fonttools-4.56.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:6c1d38642ca2dddc7ae992ef5d026e5061a84f10ff2b906be5680ab089f55bb8", size = 4731430 }, + { url = "https://files.pythonhosted.org/packages/00/41/4c199ca2c6d25edced1cdd6a3d32b2471c1e85dc7fbb2145e73805cf2a38/fonttools-4.56.0-cp39-cp39-win32.whl", hash = "sha256:2d351275f73ebdd81dd5b09a8b8dac7a30f29a279d41e1c1192aedf1b6dced40", size = 2156113 }, + { url = "https://files.pythonhosted.org/packages/00/8f/430abf16726cd627e176df92c452f239fcc488fac1e23c9ab57bb7ad6976/fonttools-4.56.0-cp39-cp39-win_amd64.whl", hash = "sha256:d6ca96d1b61a707ba01a43318c9c40aaf11a5a568d1e61146fafa6ab20890793", size = 2200538 }, + { url = "https://files.pythonhosted.org/packages/bf/ff/44934a031ce5a39125415eb405b9efb76fe7f9586b75291d66ae5cbfc4e6/fonttools-4.56.0-py3-none-any.whl", hash = "sha256:1088182f68c303b50ca4dc0c82d42083d176cba37af1937e1a976a31149d4d14", size = 1089800 }, +] + +[[package]] +name = "griffe" +version = "1.6.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama", marker = "python_full_version >= '3.9'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/2f/f2/b00eb72b853ecb5bf31dd47857cdf6767e380ca24ec2910d43b3fa7cc500/griffe-1.6.2.tar.gz", hash = "sha256:3a46fa7bd83280909b63c12b9a975732a927dd97809efe5b7972290b606c5d91", size = 392836 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4e/bc/bd8b7de5e748e078b6be648e76b47189a9182b1ac1eb7791ff7969f39f27/griffe-1.6.2-py3-none-any.whl", hash = "sha256:6399f7e663150e4278a312a8e8a14d2f3d7bd86e2ef2f8056a1058e38579c2ee", size = 128638 }, +] + +[[package]] +name = "hypothesis" +version = "6.79.4" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine != 'aarch64' and platform_machine != 'arm64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'aarch64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'arm64'", + "python_full_version < '3.7.1'", +] +dependencies = [ + { name = "attrs", version = "24.2.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, + { name = "exceptiongroup", marker = "python_full_version < '3.8'" }, + { name = "sortedcontainers", marker = "python_full_version < '3.8'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ef/f6/7e45292d294dc5a093335361f9b5f2783775b20ac2569e5f0bdd75abf8c7/hypothesis-6.79.4.tar.gz", hash = "sha256:e9a9ff3dc3f3eebbf214d6852882ac96ad72023f0e9770139fd3d3c1b87673e2", size = 355439 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/60/9e/fb74dda9518f58f7efb14d4381fc545c190f377bb78712825b40ee600905/hypothesis-6.79.4-py3-none-any.whl", hash = "sha256:5ce05bc70aa4f20114effaf3375dc8b51d09a04026a0cf89d4514fc0b69f6304", size = 417669 }, +] + +[[package]] +name = "hypothesis" +version = "6.113.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version == '3.8.*'", +] +dependencies = [ + { name = "attrs", version = "25.3.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.8.*'" }, + { name = "exceptiongroup", marker = "python_full_version == '3.8.*'" }, + { name = "sortedcontainers", marker = "python_full_version == '3.8.*'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/28/32/6513cd7256f38c19a6c8a1d5ce9792bcd35c7f11651989994731f0e97672/hypothesis-6.113.0.tar.gz", hash = "sha256:5556ac66fdf72a4ccd5d237810f7cf6bdcd00534a4485015ef881af26e20f7c7", size = 408897 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/14/fa/4acb477b86a94571958bd337eae5baf334d21b8c98a04b594d0dad381ba8/hypothesis-6.113.0-py3-none-any.whl", hash = "sha256:d539180eb2bb71ed28a23dfe94e67c851f9b09f3ccc4125afad43f17e32e2bad", size = 469790 }, +] + +[[package]] +name = "hypothesis" +version = "6.129.4" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", + "python_full_version == '3.10.*'", + "python_full_version == '3.9.*'", +] +dependencies = [ + { name = "attrs", version = "25.3.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.9'" }, + { name = "exceptiongroup", marker = "python_full_version >= '3.9' and python_full_version < '3.11'" }, + { name = "sortedcontainers", marker = "python_full_version >= '3.9'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/bb/98/0051e770d36f7e0a55bcfa3590790448d57ed2f355da9adbb957b1f545d9/hypothesis-6.129.4.tar.gz", hash = "sha256:e9fd66c25b8f0aa6395ce6728360892c3af22529cc16cae7512a4672776d4781", size = 425235 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8d/7c/7266143385cbd19c839f9b61cc660d74c5ce2626fea41d8b215ccc5cfba3/hypothesis-6.129.4-py3-none-any.whl", hash = "sha256:45a31fe2b936688b2954f375c7f87e9dfefa4f2cddfa31cdeba15d77600e1286", size = 489542 }, +] + +[[package]] +name = "idna" +version = "3.10" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f1/70/7703c29685631f5a7590aa73f1f1d3fa9a380e654b86af429e0934a32f7d/idna-3.10.tar.gz", hash = "sha256:12f65c9b470abda6dc35cf8e63cc574b1c52b11df2c86030af0ac09b01b13ea9", size = 190490 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/76/c6/c88e154df9c4e1a2a66ccf0005a88dfb2650c1dffb6f5ce603dfbd452ce3/idna-3.10-py3-none-any.whl", hash = "sha256:946d195a0d259cbba61165e88e65941f16e9b36ea6ddb97f00452bae8b1287d3", size = 70442 }, +] + +[[package]] +name = "imagesize" +version = "1.4.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a7/84/62473fb57d61e31fef6e36d64a179c8781605429fd927b5dd608c997be31/imagesize-1.4.1.tar.gz", hash = "sha256:69150444affb9cb0d5cc5a92b3676f0b2fb7cd9ae39e947a5e11a36b4497cd4a", size = 1280026 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ff/62/85c4c919272577931d407be5ba5d71c20f0b616d31a0befe0ae45bb79abd/imagesize-1.4.1-py2.py3-none-any.whl", hash = "sha256:0d8d18d08f840c19d0ee7ca1fd82490fdc3729b7ac93f49870406ddde8ef8d8b", size = 8769 }, +] + +[[package]] +name = "importlib-metadata" +version = "6.7.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine != 'aarch64' and platform_machine != 'arm64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'aarch64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'arm64'", + "python_full_version < '3.7.1'", +] +dependencies = [ + { name = "typing-extensions", version = "4.7.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, + { name = "zipp", version = "3.15.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a3/82/f6e29c8d5c098b6be61460371c2c5591f4a335923639edec43b3830650a4/importlib_metadata-6.7.0.tar.gz", hash = "sha256:1aaf550d4f73e5d6783e7acb77aec43d49da8017410afae93822cc9cca98c4d4", size = 53569 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ff/94/64287b38c7de4c90683630338cf28f129decbba0a44f0c6db35a873c73c4/importlib_metadata-6.7.0-py3-none-any.whl", hash = "sha256:cb52082e659e97afc5dac71e79de97d8681de3aa07ff18578330904a9d18e5b5", size = 22934 }, +] + +[[package]] +name = "importlib-metadata" +version = "8.5.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version == '3.8.*'", +] +dependencies = [ + { name = "zipp", version = "3.20.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.8.*'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/cd/12/33e59336dca5be0c398a7482335911a33aa0e20776128f038019f1a95f1b/importlib_metadata-8.5.0.tar.gz", hash = "sha256:71522656f0abace1d072b9e5481a48f07c138e00f079c38c8f883823f9c26bd7", size = 55304 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a0/d9/a1e041c5e7caa9a05c925f4bdbdfb7f006d1f74996af53467bc394c97be7/importlib_metadata-8.5.0-py3-none-any.whl", hash = "sha256:45e54197d28b7a7f1559e60b95e7c567032b602131fbd588f1497f47880aa68b", size = 26514 }, +] + +[[package]] +name = "importlib-metadata" +version = "8.6.1" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", + "python_full_version == '3.10.*'", + "python_full_version == '3.9.*'", +] +dependencies = [ + { name = "zipp", version = "3.21.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.9'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/33/08/c1395a292bb23fd03bdf572a1357c5a733d3eecbab877641ceacab23db6e/importlib_metadata-8.6.1.tar.gz", hash = "sha256:310b41d755445d74569f993ccfc22838295d9fe005425094fad953d7f15c8580", size = 55767 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/79/9d/0fb148dc4d6fa4a7dd1d8378168d9b4cd8d4560a6fbf6f0121c5fc34eb68/importlib_metadata-8.6.1-py3-none-any.whl", hash = "sha256:02a89390c1e15fdfdc0d7c6b25cb3e62650d0494005c97d6f148bf5b9787525e", size = 26971 }, +] + +[[package]] +name = "importlib-resources" +version = "5.12.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine != 'aarch64' and platform_machine != 'arm64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'aarch64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'arm64'", + "python_full_version < '3.7.1'", +] +dependencies = [ + { name = "zipp", version = "3.15.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/4e/a2/3cab1de83f95dd15297c15bdc04d50902391d707247cada1f021bbfe2149/importlib_resources-5.12.0.tar.gz", hash = "sha256:4be82589bf5c1d7999aedf2a45159d10cb3ca4f19b2271f8792bc8e6da7b22f6", size = 39894 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/38/71/c13ea695a4393639830bf96baea956538ba7a9d06fcce7cef10bfff20f72/importlib_resources-5.12.0-py3-none-any.whl", hash = "sha256:7b1deeebbf351c7578e09bf2f63fa2ce8b5ffec296e0d349139d43cca061a81a", size = 36211 }, +] + +[[package]] +name = "importlib-resources" +version = "6.4.5" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version == '3.8.*'", +] +dependencies = [ + { name = "zipp", version = "3.20.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.8.*'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/98/be/f3e8c6081b684f176b761e6a2fef02a0be939740ed6f54109a2951d806f3/importlib_resources-6.4.5.tar.gz", hash = "sha256:980862a1d16c9e147a59603677fa2aa5fd82b87f223b6cb870695bcfce830065", size = 43372 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e1/6a/4604f9ae2fa62ef47b9de2fa5ad599589d28c9fd1d335f32759813dfa91e/importlib_resources-6.4.5-py3-none-any.whl", hash = "sha256:ac29d5f956f01d5e4bb63102a5a19957f1b9175e45649977264a1416783bb717", size = 36115 }, +] + +[[package]] +name = "importlib-resources" +version = "6.5.2" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", + "python_full_version == '3.10.*'", + "python_full_version == '3.9.*'", +] +dependencies = [ + { name = "zipp", version = "3.21.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/cf/8c/f834fbf984f691b4f7ff60f50b514cc3de5cc08abfc3295564dd89c5e2e7/importlib_resources-6.5.2.tar.gz", hash = "sha256:185f87adef5bcc288449d98fb4fba07cea78bc036455dd44c5fc4a2fe78fed2c", size = 44693 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a4/ed/1f1afb2e9e7f38a545d628f864d562a5ae64fe6f7a10e28ffb9b185b4e89/importlib_resources-6.5.2-py3-none-any.whl", hash = "sha256:789cfdc3ed28c78b67a06acb8126751ced69a3d5f79c095a98298cd8a760ccec", size = 37461 }, +] + +[[package]] +name = "iniconfig" +version = "2.0.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine != 'aarch64' and platform_machine != 'arm64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'aarch64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'arm64'", + "python_full_version < '3.7.1'", +] +sdist = { url = "https://files.pythonhosted.org/packages/d7/4b/cbd8e699e64a6f16ca3a8220661b5f83792b3017d0f79807cb8708d33913/iniconfig-2.0.0.tar.gz", hash = "sha256:2d91e135bf72d31a410b17c16da610a82cb55f6b0477d1a902134b24a455b8b3", size = 4646 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ef/a6/62565a6e1cf69e10f5727360368e451d4b7f58beeac6173dc9db836a5b46/iniconfig-2.0.0-py3-none-any.whl", hash = "sha256:b6a85871a79d2e3b22d2d1b94ac2824226a63c6b741c88f7ae975f18b6778374", size = 5892 }, +] + +[[package]] +name = "iniconfig" +version = "2.1.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", + "python_full_version == '3.10.*'", + "python_full_version == '3.9.*'", + "python_full_version == '3.8.*'", +] +sdist = { url = "https://files.pythonhosted.org/packages/f2/97/ebf4da567aa6827c909642694d71c9fcf53e5b504f2d96afea02718862f3/iniconfig-2.1.0.tar.gz", hash = "sha256:3abbd2e30b36733fee78f9c7f7308f2d0050e88f0087fd25c2645f63c773e1c7", size = 4793 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2c/e1/e6716421ea10d38022b952c159d5161ca1193197fb744506875fbb87ea7b/iniconfig-2.1.0-py3-none-any.whl", hash = "sha256:9deba5723312380e77435581c6bf4935c94cbfab9b1ed33ef8d238ea168eb760", size = 6050 }, +] + +[[package]] +name = "ipykernel" +version = "6.16.2" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine != 'aarch64' and platform_machine != 'arm64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'aarch64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'arm64'", + "python_full_version < '3.7.1'", +] +dependencies = [ + { name = "appnope", marker = "python_full_version < '3.8' and sys_platform == 'darwin'" }, + { name = "debugpy", version = "1.7.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, + { name = "ipython", version = "7.34.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, + { name = "jupyter-client", version = "7.4.9", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, + { name = "matplotlib-inline", version = "0.1.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, + { name = "nest-asyncio", marker = "python_full_version < '3.8'" }, + { name = "packaging", version = "24.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, + { name = "psutil", marker = "python_full_version < '3.8'" }, + { name = "pyzmq", version = "26.2.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, + { name = "tornado", version = "6.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, + { name = "traitlets", version = "5.9.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/4f/ca/22431cf8ffa45438a5ab7d5e0ada45037b3622478ef45b231f29783a93a9/ipykernel-6.16.2.tar.gz", hash = "sha256:463f3d87a92e99969b1605cb7a5b4d7b36b7145a0e72d06e65918a6ddefbe630", size = 136606 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/95/46/505364588f6145f5edd29c1506b1964dd397a668c49f8bb42deffb6a0168/ipykernel-6.16.2-py3-none-any.whl", hash = "sha256:67daf93e5b52456cd8eea87a8b59405d2bb80ae411864a1ea206c3631d8179af", size = 138541 }, +] + +[[package]] +name = "ipykernel" +version = "6.29.5" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", + "python_full_version == '3.10.*'", + "python_full_version == '3.9.*'", + "python_full_version == '3.8.*'", +] +dependencies = [ + { name = "appnope", marker = "python_full_version >= '3.8' and sys_platform == 'darwin'" }, + { name = "comm", marker = "python_full_version >= '3.8'" }, + { name = "debugpy", version = "1.8.13", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.8'" }, + { name = "ipython", version = "8.12.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.8.*'" }, + { name = "ipython", version = "8.18.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*'" }, + { name = "ipython", version = "8.34.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.10.*'" }, + { name = "ipython", version = "9.0.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, + { name = "jupyter-client", version = "8.6.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.8'" }, + { name = "jupyter-core", version = "5.7.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.8'" }, + { name = "matplotlib-inline", version = "0.1.7", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.8'" }, + { name = "nest-asyncio", marker = "python_full_version >= '3.8'" }, + { name = "packaging", version = "24.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.8'" }, + { name = "psutil", marker = "python_full_version >= '3.8'" }, + { name = "pyzmq", version = "26.3.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.8'" }, + { name = "tornado", version = "6.4.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.8'" }, + { name = "traitlets", version = "5.14.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.8'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/e9/5c/67594cb0c7055dc50814b21731c22a601101ea3b1b50a9a1b090e11f5d0f/ipykernel-6.29.5.tar.gz", hash = "sha256:f093a22c4a40f8828f8e330a9c297cb93dcab13bd9678ded6de8e5cf81c56215", size = 163367 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/94/5c/368ae6c01c7628438358e6d337c19b05425727fbb221d2a3c4303c372f42/ipykernel-6.29.5-py3-none-any.whl", hash = "sha256:afdb66ba5aa354b09b91379bac28ae4afebbb30e8b39510c9690afb7a10421b5", size = 117173 }, +] + +[[package]] +name = "ipython" +version = "7.34.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine != 'aarch64' and platform_machine != 'arm64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'aarch64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'arm64'", + "python_full_version < '3.7.1'", +] +dependencies = [ + { name = "appnope", marker = "python_full_version < '3.8' and sys_platform == 'darwin'" }, + { name = "backcall", marker = "python_full_version < '3.8'" }, + { name = "colorama", marker = "python_full_version < '3.8' and sys_platform == 'win32'" }, + { name = "decorator", version = "5.1.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, + { name = "jedi", marker = "python_full_version < '3.8'" }, + { name = "matplotlib-inline", version = "0.1.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, + { name = "pexpect", marker = "python_full_version < '3.8' and sys_platform != 'win32'" }, + { name = "pickleshare", marker = "python_full_version < '3.8'" }, + { name = "prompt-toolkit", version = "3.0.48", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, + { name = "pygments", version = "2.17.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, + { name = "setuptools", marker = "python_full_version < '3.8'" }, + { name = "traitlets", version = "5.9.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/db/6c/3fcf0b8ee46656796099ac4b7b72497af5f090da3e43fd305f2a24c73915/ipython-7.34.0.tar.gz", hash = "sha256:af3bdb46aa292bce5615b1b2ebc76c2080c5f77f54bda2ec72461317273e7cd6", size = 5158632 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7c/6a/1f1365f4bf9fcb349fcaa5b61edfcefa721aa13ff37c5631296b12fab8e5/ipython-7.34.0-py3-none-any.whl", hash = "sha256:c175d2440a1caff76116eb719d40538fbb316e214eda85c5515c303aacbfb23e", size = 793790 }, +] + +[[package]] +name = "ipython" +version = "8.12.3" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version == '3.8.*'", +] +dependencies = [ + { name = "appnope", marker = "python_full_version == '3.8.*' and sys_platform == 'darwin'" }, + { name = "backcall", marker = "python_full_version == '3.8.*'" }, + { name = "colorama", marker = "python_full_version == '3.8.*' and sys_platform == 'win32'" }, + { name = "decorator", version = "5.2.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.8.*'" }, + { name = "jedi", marker = "python_full_version == '3.8.*'" }, + { name = "matplotlib-inline", version = "0.1.7", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.8.*'" }, + { name = "pexpect", marker = "python_full_version == '3.8.*' and sys_platform != 'win32'" }, + { name = "pickleshare", marker = "python_full_version == '3.8.*'" }, + { name = "prompt-toolkit", version = "3.0.50", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.8.*'" }, + { name = "pygments", version = "2.19.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.8.*'" }, + { name = "stack-data", marker = "python_full_version == '3.8.*'" }, + { name = "traitlets", version = "5.14.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.8.*'" }, + { name = "typing-extensions", version = "4.12.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.8.*'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/9e/6a/44ef299b1762f5a73841e87fae8a73a8cc8aee538d6dc8c77a5afe1fd2ce/ipython-8.12.3.tar.gz", hash = "sha256:3910c4b54543c2ad73d06579aa771041b7d5707b033bd488669b4cf544e3b363", size = 5470171 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8d/97/8fe103906cd81bc42d3b0175b5534a9f67dccae47d6451131cf8d0d70bb2/ipython-8.12.3-py3-none-any.whl", hash = "sha256:b0340d46a933d27c657b211a329d0be23793c36595acf9e6ef4164bc01a1804c", size = 798307 }, +] + +[[package]] +name = "ipython" +version = "8.18.1" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version == '3.9.*'", +] +dependencies = [ + { name = "colorama", marker = "python_full_version == '3.9.*' and sys_platform == 'win32'" }, + { name = "decorator", version = "5.2.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*'" }, + { name = "exceptiongroup", marker = "python_full_version == '3.9.*'" }, + { name = "jedi", marker = "python_full_version == '3.9.*'" }, + { name = "matplotlib-inline", version = "0.1.7", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*'" }, + { name = "pexpect", marker = "python_full_version == '3.9.*' and sys_platform != 'win32'" }, + { name = "prompt-toolkit", version = "3.0.50", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*'" }, + { name = "pygments", version = "2.19.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*'" }, + { name = "stack-data", marker = "python_full_version == '3.9.*'" }, + { name = "traitlets", version = "5.14.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*'" }, + { name = "typing-extensions", version = "4.12.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b1/b9/3ba6c45a6df813c09a48bac313c22ff83efa26cbb55011218d925a46e2ad/ipython-8.18.1.tar.gz", hash = "sha256:ca6f079bb33457c66e233e4580ebfc4128855b4cf6370dddd73842a9563e8a27", size = 5486330 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/47/6b/d9fdcdef2eb6a23f391251fde8781c38d42acd82abe84d054cb74f7863b0/ipython-8.18.1-py3-none-any.whl", hash = "sha256:e8267419d72d81955ec1177f8a29aaa90ac80ad647499201119e2f05e99aa397", size = 808161 }, +] + +[[package]] +name = "ipython" +version = "8.34.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version == '3.10.*'", +] +dependencies = [ + { name = "colorama", marker = "python_full_version == '3.10.*' and sys_platform == 'win32'" }, + { name = "decorator", version = "5.2.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.10.*'" }, + { name = "exceptiongroup", marker = "python_full_version == '3.10.*'" }, + { name = "jedi", marker = "python_full_version == '3.10.*'" }, + { name = "matplotlib-inline", version = "0.1.7", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.10.*'" }, + { name = "pexpect", marker = "python_full_version == '3.10.*' and sys_platform != 'emscripten' and sys_platform != 'win32'" }, + { name = "prompt-toolkit", version = "3.0.50", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.10.*'" }, + { name = "pygments", version = "2.19.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.10.*'" }, + { name = "stack-data", marker = "python_full_version == '3.10.*'" }, + { name = "traitlets", version = "5.14.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.10.*'" }, + { name = "typing-extensions", version = "4.12.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.10.*'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/13/18/1a60aa62e9d272fcd7e658a89e1c148da10e1a5d38edcbcd834b52ca7492/ipython-8.34.0.tar.gz", hash = "sha256:c31d658e754673ecc6514583e7dda8069e47136eb62458816b7d1e6625948b5a", size = 5508477 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/04/78/45615356bb973904856808183ae2a5fba1f360e9d682314d79766f4b88f2/ipython-8.34.0-py3-none-any.whl", hash = "sha256:0419883fa46e0baa182c5d50ebb8d6b49df1889fdb70750ad6d8cfe678eda6e3", size = 826731 }, +] + +[[package]] +name = "ipython" +version = "9.0.2" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", +] +dependencies = [ + { name = "colorama", marker = "python_full_version >= '3.11' and sys_platform == 'win32'" }, + { name = "decorator", version = "5.2.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, + { name = "ipython-pygments-lexers", marker = "python_full_version >= '3.11'" }, + { name = "jedi", marker = "python_full_version >= '3.11'" }, + { name = "matplotlib-inline", version = "0.1.7", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, + { name = "pexpect", marker = "python_full_version >= '3.11' and sys_platform != 'emscripten' and sys_platform != 'win32'" }, + { name = "prompt-toolkit", version = "3.0.50", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, + { name = "pygments", version = "2.19.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, + { name = "stack-data", marker = "python_full_version >= '3.11'" }, + { name = "traitlets", version = "5.14.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, + { name = "typing-extensions", version = "4.12.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.11.*'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/7d/ce/012a0f40ca58a966f87a6e894d6828e2817657cbdf522b02a5d3a87d92ce/ipython-9.0.2.tar.gz", hash = "sha256:ec7b479e3e5656bf4f58c652c120494df1820f4f28f522fb7ca09e213c2aab52", size = 4366102 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/20/3a/917cb9e72f4e1a4ea13c862533205ae1319bd664119189ee5cc9e4e95ebf/ipython-9.0.2-py3-none-any.whl", hash = "sha256:143ef3ea6fb1e1bffb4c74b114051de653ffb7737a3f7ab1670e657ca6ae8c44", size = 600524 }, +] + +[[package]] +name = "ipython-pygments-lexers" +version = "1.1.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pygments", version = "2.19.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ef/4c/5dd1d8af08107f88c7f741ead7a40854b8ac24ddf9ae850afbcf698aa552/ipython_pygments_lexers-1.1.1.tar.gz", hash = "sha256:09c0138009e56b6854f9535736f4171d855c8c08a563a0dcd8022f78355c7e81", size = 8393 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d9/33/1f075bf72b0b747cb3288d011319aaf64083cf2efef8354174e3ed4540e2/ipython_pygments_lexers-1.1.1-py3-none-any.whl", hash = "sha256:a9462224a505ade19a605f71f8fa63c2048833ce50abc86768a0d81d876dc81c", size = 8074 }, +] + +[[package]] +name = "jedi" +version = "0.19.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "parso" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/72/3a/79a912fbd4d8dd6fbb02bf69afd3bb72cf0c729bb3063c6f4498603db17a/jedi-0.19.2.tar.gz", hash = "sha256:4770dc3de41bde3966b02eb84fbcf557fb33cce26ad23da12c742fb50ecb11f0", size = 1231287 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c0/5a/9cac0c82afec3d09ccd97c8b6502d48f165f9124db81b4bcb90b4af974ee/jedi-0.19.2-py2.py3-none-any.whl", hash = "sha256:a8ef22bde8490f57fe5c7681a3c83cb58874daf72b4784de3cce5b6ef6edb5b9", size = 1572278 }, +] + +[[package]] +name = "jinja2" +version = "3.1.6" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "markupsafe", version = "2.1.5", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.9'" }, + { name = "markupsafe", version = "3.0.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.9'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/df/bf/f7da0350254c0ed7c72f3e33cef02e048281fec7ecec5f032d4aac52226b/jinja2-3.1.6.tar.gz", hash = "sha256:0137fb05990d35f1275a587e9aee6d56da821fc83491a0fb838183be43f66d6d", size = 245115 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/62/a1/3d680cbfd5f4b8f15abc1d571870c5fc3e594bb582bc3b64ea099db13e56/jinja2-3.1.6-py3-none-any.whl", hash = "sha256:85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67", size = 134899 }, +] + +[[package]] +name = "jsonschema" +version = "4.17.3" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine != 'aarch64' and platform_machine != 'arm64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'aarch64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'arm64'", + "python_full_version < '3.7.1'", +] +dependencies = [ + { name = "attrs", version = "24.2.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, + { name = "importlib-metadata", version = "6.7.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, + { name = "importlib-resources", version = "5.12.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, + { name = "pkgutil-resolve-name", marker = "python_full_version < '3.8'" }, + { name = "pyrsistent", marker = "python_full_version < '3.8'" }, + { name = "typing-extensions", version = "4.7.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/36/3d/ca032d5ac064dff543aa13c984737795ac81abc9fb130cd2fcff17cfabc7/jsonschema-4.17.3.tar.gz", hash = "sha256:0f864437ab8b6076ba6707453ef8f98a6a0d512a80e93f8abdb676f737ecb60d", size = 297785 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c1/97/c698bd9350f307daad79dd740806e1a59becd693bd11443a0f531e3229b3/jsonschema-4.17.3-py3-none-any.whl", hash = "sha256:a870ad254da1a8ca84b6a2905cac29d265f805acc57af304784962a2aa6508f6", size = 90379 }, +] + +[[package]] +name = "jsonschema" +version = "4.23.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", + "python_full_version == '3.10.*'", + "python_full_version == '3.9.*'", + "python_full_version == '3.8.*'", +] +dependencies = [ + { name = "attrs", version = "25.3.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.8'" }, + { name = "importlib-resources", version = "6.4.5", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.8.*'" }, + { name = "jsonschema-specifications", version = "2023.12.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.8.*'" }, + { name = "jsonschema-specifications", version = "2024.10.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.9'" }, + { name = "pkgutil-resolve-name", marker = "python_full_version == '3.8.*'" }, + { name = "referencing", version = "0.35.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.8.*'" }, + { name = "referencing", version = "0.36.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.9'" }, + { name = "rpds-py", version = "0.20.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.8.*'" }, + { name = "rpds-py", version = "0.23.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.9'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/38/2e/03362ee4034a4c917f697890ccd4aec0800ccf9ded7f511971c75451deec/jsonschema-4.23.0.tar.gz", hash = "sha256:d71497fef26351a33265337fa77ffeb82423f3ea21283cd9467bb03999266bc4", size = 325778 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/69/4a/4f9dbeb84e8850557c02365a0eee0649abe5eb1d84af92a25731c6c0f922/jsonschema-4.23.0-py3-none-any.whl", hash = "sha256:fbadb6f8b144a8f8cf9f0b89ba94501d143e50411a1278633f56a7acf7fd5566", size = 88462 }, +] + +[[package]] +name = "jsonschema-specifications" +version = "2023.12.1" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version == '3.8.*'", +] +dependencies = [ + { name = "importlib-resources", version = "6.4.5", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.8.*'" }, + { name = "referencing", version = "0.35.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.8.*'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/f8/b9/cc0cc592e7c195fb8a650c1d5990b10175cf13b4c97465c72ec841de9e4b/jsonschema_specifications-2023.12.1.tar.gz", hash = "sha256:48a76787b3e70f5ed53f1160d2b81f586e4ca6d1548c5de7085d1682674764cc", size = 13983 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ee/07/44bd408781594c4d0a027666ef27fab1e441b109dc3b76b4f836f8fd04fe/jsonschema_specifications-2023.12.1-py3-none-any.whl", hash = "sha256:87e4fdf3a94858b8a2ba2778d9ba57d8a9cafca7c7489c46ba0d30a8bc6a9c3c", size = 18482 }, +] + +[[package]] +name = "jsonschema-specifications" +version = "2024.10.1" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", + "python_full_version == '3.10.*'", + "python_full_version == '3.9.*'", +] +dependencies = [ + { name = "referencing", version = "0.36.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.9'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/10/db/58f950c996c793472e336ff3655b13fbcf1e3b359dcf52dcf3ed3b52c352/jsonschema_specifications-2024.10.1.tar.gz", hash = "sha256:0f38b83639958ce1152d02a7f062902c41c8fd20d558b0c34344292d417ae272", size = 15561 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d1/0f/8910b19ac0670a0f80ce1008e5e751c4a57e14d2c4c13a482aa6079fa9d6/jsonschema_specifications-2024.10.1-py3-none-any.whl", hash = "sha256:a09a0680616357d9a0ecf05c12ad234479f549239d0f5b55f3deea67475da9bf", size = 18459 }, +] + +[[package]] +name = "jupyter-client" +version = "7.4.9" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine != 'aarch64' and platform_machine != 'arm64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'aarch64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'arm64'", + "python_full_version < '3.7.1'", +] +dependencies = [ + { name = "entrypoints", marker = "python_full_version < '3.8'" }, + { name = "jupyter-core", version = "4.12.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, + { name = "nest-asyncio", marker = "python_full_version < '3.8'" }, + { name = "python-dateutil", marker = "python_full_version < '3.8'" }, + { name = "pyzmq", version = "26.2.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, + { name = "tornado", version = "6.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, + { name = "traitlets", version = "5.9.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/1e/33/71778cdd2c69445bcd3bb6029da2e43cc9b5cbbeef4f4982ef3aaf396650/jupyter_client-7.4.9.tar.gz", hash = "sha256:52be28e04171f07aed8f20e1616a5a552ab9fee9cbbe6c1896ae170c3880d392", size = 329115 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fd/a7/ef3b7c8b9d6730a21febdd0809084e4cea6d2a7e43892436adecdd0acbd4/jupyter_client-7.4.9-py3-none-any.whl", hash = "sha256:214668aaea208195f4c13d28eb272ba79f945fc0cf3f11c7092c20b2ca1980e7", size = 133492 }, +] + +[[package]] +name = "jupyter-client" +version = "8.6.3" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", + "python_full_version == '3.10.*'", + "python_full_version == '3.9.*'", + "python_full_version == '3.8.*'", +] +dependencies = [ + { name = "importlib-metadata", version = "8.5.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.8.*'" }, + { name = "importlib-metadata", version = "8.6.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*'" }, + { name = "jupyter-core", version = "5.7.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.8'" }, + { name = "python-dateutil", marker = "python_full_version >= '3.8'" }, + { name = "pyzmq", version = "26.3.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.8'" }, + { name = "tornado", version = "6.4.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.8'" }, + { name = "traitlets", version = "5.14.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.8'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/71/22/bf9f12fdaeae18019a468b68952a60fe6dbab5d67cd2a103cac7659b41ca/jupyter_client-8.6.3.tar.gz", hash = "sha256:35b3a0947c4a6e9d589eb97d7d4cd5e90f910ee73101611f01283732bd6d9419", size = 342019 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/11/85/b0394e0b6fcccd2c1eeefc230978a6f8cb0c5df1e4cd3e7625735a0d7d1e/jupyter_client-8.6.3-py3-none-any.whl", hash = "sha256:e8a19cc986cc45905ac3362915f410f3af85424b4c0905e94fa5f2cb08e8f23f", size = 106105 }, +] + +[[package]] +name = "jupyter-core" +version = "4.12.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine != 'aarch64' and platform_machine != 'arm64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'aarch64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'arm64'", + "python_full_version < '3.7.1'", +] +dependencies = [ + { name = "pywin32", marker = "python_full_version < '3.8' and platform_python_implementation != 'PyPy' and sys_platform == 'win32'" }, + { name = "traitlets", version = "5.9.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/8b/d9/0d18cbe8d0d2eb165dd0b42266f0e5e31b1f80c3a48031fbef1077c34521/jupyter_core-4.12.0.tar.gz", hash = "sha256:87f39d7642412ae8a52291cc68e71ac01dfa2c735df2701f8108251d51b4f460", size = 74760 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/02/8f/0e0ad6804c0a021a27410ec997626a7a955c20916454d0205f16eb83de4b/jupyter_core-4.12.0-py3-none-any.whl", hash = "sha256:a54672c539333258495579f6964144924e0aa7b07f7069947bef76d7ea5cb4c1", size = 89940 }, +] + +[[package]] +name = "jupyter-core" +version = "5.7.2" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", + "python_full_version == '3.10.*'", + "python_full_version == '3.9.*'", + "python_full_version == '3.8.*'", +] +dependencies = [ + { name = "platformdirs", version = "4.3.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.8.*'" }, + { name = "platformdirs", version = "4.3.7", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.9'" }, + { name = "pywin32", marker = "python_full_version >= '3.8' and platform_python_implementation != 'PyPy' and sys_platform == 'win32'" }, + { name = "traitlets", version = "5.14.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.8'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/00/11/b56381fa6c3f4cc5d2cf54a7dbf98ad9aa0b339ef7a601d6053538b079a7/jupyter_core-5.7.2.tar.gz", hash = "sha256:aa5f8d32bbf6b431ac830496da7392035d6f61b4f54872f15c4bd2a9c3f536d9", size = 87629 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c9/fb/108ecd1fe961941959ad0ee4e12ee7b8b1477247f30b1fdfd83ceaf017f0/jupyter_core-5.7.2-py3-none-any.whl", hash = "sha256:4f7315d2f6b4bcf2e3e7cb6e46772eba760ae459cd1f59d29eb57b0a01bd7409", size = 28965 }, +] + +[[package]] +name = "jupyterlab-pygments" +version = "0.2.2" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine != 'aarch64' and platform_machine != 'arm64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'aarch64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'arm64'", + "python_full_version < '3.7.1'", +] +sdist = { url = "https://files.pythonhosted.org/packages/69/8e/8ae01f052013ee578b297499d16fcfafb892927d8e41c1a0054d2f99a569/jupyterlab_pygments-0.2.2.tar.gz", hash = "sha256:7405d7fde60819d905a9fa8ce89e4cd830e318cdad22a0030f7a901da705585d", size = 132378 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c0/7e/c3d1df3ae9b41686e664051daedbd70eea2e1d2bd9d9c33e7e1455bc9f96/jupyterlab_pygments-0.2.2-py2.py3-none-any.whl", hash = "sha256:2405800db07c9f770863bcf8049a529c3dd4d3e28536638bd7c1c01d2748309f", size = 21953 }, +] + +[[package]] +name = "jupyterlab-pygments" +version = "0.3.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", + "python_full_version == '3.10.*'", + "python_full_version == '3.9.*'", + "python_full_version == '3.8.*'", +] +sdist = { url = "https://files.pythonhosted.org/packages/90/51/9187be60d989df97f5f0aba133fa54e7300f17616e065d1ada7d7646b6d6/jupyterlab_pygments-0.3.0.tar.gz", hash = "sha256:721aca4d9029252b11cfa9d185e5b5af4d54772bb8072f9b7036f4170054d35d", size = 512900 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b1/dd/ead9d8ea85bf202d90cc513b533f9c363121c7792674f78e0d8a854b63b4/jupyterlab_pygments-0.3.0-py3-none-any.whl", hash = "sha256:841a89020971da1d8693f1a99997aefc5dc424bb1b251fd6322462a1b8842780", size = 15884 }, +] + +[[package]] +name = "kiwisolver" +version = "1.4.5" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine != 'aarch64' and platform_machine != 'arm64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'aarch64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'arm64'", + "python_full_version < '3.7.1'", +] +dependencies = [ + { name = "typing-extensions", version = "4.7.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b9/2d/226779e405724344fc678fcc025b812587617ea1a48b9442628b688e85ea/kiwisolver-1.4.5.tar.gz", hash = "sha256:e57e563a57fb22a142da34f38acc2fc1a5c864bc29ca1517a88abc963e60d6ec", size = 97552 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f1/56/cb02dcefdaab40df636b91e703b172966b444605a0ea313549f3ffc05bd3/kiwisolver-1.4.5-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:05703cf211d585109fcd72207a31bb170a0f22144d68298dc5e61b3c946518af", size = 127397 }, + { url = "https://files.pythonhosted.org/packages/0e/c1/d084f8edb26533a191415d5173157080837341f9a06af9dd1a75f727abb4/kiwisolver-1.4.5-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:146d14bebb7f1dc4d5fbf74f8a6cb15ac42baadee8912eb84ac0b3b2a3dc6ac3", size = 68125 }, + { url = "https://files.pythonhosted.org/packages/23/11/6fb190bae4b279d712a834e7b1da89f6dcff6791132f7399aa28a57c3565/kiwisolver-1.4.5-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:6ef7afcd2d281494c0a9101d5c571970708ad911d028137cd558f02b851c08b4", size = 66211 }, + { url = "https://files.pythonhosted.org/packages/b3/13/5e9e52feb33e9e063f76b2c5eb09cb977f5bba622df3210081bfb26ec9a3/kiwisolver-1.4.5-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:9eaa8b117dc8337728e834b9c6e2611f10c79e38f65157c4c38e9400286f5cb1", size = 1637145 }, + { url = "https://files.pythonhosted.org/packages/6f/40/4ab1fdb57fced80ce5903f04ae1aed7c1d5939dda4fd0c0aa526c12fe28a/kiwisolver-1.4.5-cp310-cp310-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:ec20916e7b4cbfb1f12380e46486ec4bcbaa91a9c448b97023fde0d5bbf9e4ff", size = 1617849 }, + { url = "https://files.pythonhosted.org/packages/49/ca/61ef43bd0832c7253b370735b0c38972c140c8774889b884372a629a8189/kiwisolver-1.4.5-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:39b42c68602539407884cf70d6a480a469b93b81b7701378ba5e2328660c847a", size = 1400921 }, + { url = "https://files.pythonhosted.org/packages/68/6f/854f6a845c00b4257482468e08d8bc386f4929ee499206142378ba234419/kiwisolver-1.4.5-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:aa12042de0171fad672b6c59df69106d20d5596e4f87b5e8f76df757a7c399aa", size = 1513009 }, + { url = "https://files.pythonhosted.org/packages/50/65/76f303377167d12eb7a9b423d6771b39fe5c4373e4a42f075805b1f581ae/kiwisolver-1.4.5-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2a40773c71d7ccdd3798f6489aaac9eee213d566850a9533f8d26332d626b82c", size = 1444819 }, + { url = "https://files.pythonhosted.org/packages/7e/ee/98cdf9dde129551467138b6e18cc1cc901e75ecc7ffb898c6f49609f33b1/kiwisolver-1.4.5-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:19df6e621f6d8b4b9c4d45f40a66839294ff2bb235e64d2178f7522d9170ac5b", size = 1817054 }, + { url = "https://files.pythonhosted.org/packages/e6/5b/ab569016ec4abc7b496f6cb8a3ab511372c99feb6a23d948cda97e0db6da/kiwisolver-1.4.5-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:83d78376d0d4fd884e2c114d0621624b73d2aba4e2788182d286309ebdeed770", size = 1918613 }, + { url = "https://files.pythonhosted.org/packages/93/ac/39b9f99d2474b1ac7af1ddfe5756ddf9b6a8f24c5f3a32cd4c010317fc6b/kiwisolver-1.4.5-cp310-cp310-musllinux_1_1_ppc64le.whl", hash = "sha256:e391b1f0a8a5a10ab3b9bb6afcfd74f2175f24f8975fb87ecae700d1503cdee0", size = 1872650 }, + { url = "https://files.pythonhosted.org/packages/40/5b/be568548266516b114d1776120281ea9236c732fb6032a1f8f3b1e5e921c/kiwisolver-1.4.5-cp310-cp310-musllinux_1_1_s390x.whl", hash = "sha256:852542f9481f4a62dbb5dd99e8ab7aedfeb8fb6342349a181d4036877410f525", size = 1827415 }, + { url = "https://files.pythonhosted.org/packages/d4/80/c0c13d2a17a12937a19ef378bf35e94399fd171ed6ec05bcee0f038e1eaf/kiwisolver-1.4.5-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:59edc41b24031bc25108e210c0def6f6c2191210492a972d585a06ff246bb79b", size = 1838094 }, + { url = "https://files.pythonhosted.org/packages/70/d1/5ab93ee00ca5af708929cc12fbe665b6f1ed4ad58088e70dc00e87e0d107/kiwisolver-1.4.5-cp310-cp310-win32.whl", hash = "sha256:a6aa6315319a052b4ee378aa171959c898a6183f15c1e541821c5c59beaa0238", size = 46585 }, + { url = "https://files.pythonhosted.org/packages/4a/a1/8a9c9be45c642fa12954855d8b3a02d9fd8551165a558835a19508fec2e6/kiwisolver-1.4.5-cp310-cp310-win_amd64.whl", hash = "sha256:d0ef46024e6a3d79c01ff13801cb19d0cad7fd859b15037aec74315540acc276", size = 56095 }, + { url = "https://files.pythonhosted.org/packages/2a/eb/9e099ad7c47c279995d2d20474e1821100a5f10f847739bd65b1c1f02442/kiwisolver-1.4.5-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:11863aa14a51fd6ec28688d76f1735f8f69ab1fabf388851a595d0721af042f5", size = 127403 }, + { url = "https://files.pythonhosted.org/packages/a6/94/695922e71288855fc7cace3bdb52edda9d7e50edba77abb0c9d7abb51e96/kiwisolver-1.4.5-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:8ab3919a9997ab7ef2fbbed0cc99bb28d3c13e6d4b1ad36e97e482558a91be90", size = 68156 }, + { url = "https://files.pythonhosted.org/packages/4a/fe/23d7fa78f7c66086d196406beb1fb2eaf629dd7adc01c3453033303d17fa/kiwisolver-1.4.5-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:fcc700eadbbccbf6bc1bcb9dbe0786b4b1cb91ca0dcda336eef5c2beed37b797", size = 66166 }, + { url = "https://files.pythonhosted.org/packages/f1/68/f472bf16c9141bb1bea5c0b8c66c68fc1ccb048efdbd8f0872b92125724e/kiwisolver-1.4.5-cp311-cp311-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:dfdd7c0b105af050eb3d64997809dc21da247cf44e63dc73ff0fd20b96be55a9", size = 1334300 }, + { url = "https://files.pythonhosted.org/packages/8d/26/b4569d1f29751fca22ee915b4ebfef5974f4ef239b3335fc072882bd62d9/kiwisolver-1.4.5-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:76c6a5964640638cdeaa0c359382e5703e9293030fe730018ca06bc2010c4437", size = 1426579 }, + { url = "https://files.pythonhosted.org/packages/f3/a3/804fc7c8bf233806ec0321c9da35971578620f2ab4fafe67d76100b3ce52/kiwisolver-1.4.5-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:bbea0db94288e29afcc4c28afbf3a7ccaf2d7e027489c449cf7e8f83c6346eb9", size = 1541360 }, + { url = "https://files.pythonhosted.org/packages/07/ef/286e1d26524854f6fbd6540e8364d67a8857d61038ac743e11edc42fe217/kiwisolver-1.4.5-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ceec1a6bc6cab1d6ff5d06592a91a692f90ec7505d6463a88a52cc0eb58545da", size = 1470091 }, + { url = "https://files.pythonhosted.org/packages/17/ba/17a706b232308e65f57deeccae503c268292e6a091313f6ce833a23093ea/kiwisolver-1.4.5-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:040c1aebeda72197ef477a906782b5ab0d387642e93bda547336b8957c61022e", size = 1426259 }, + { url = "https://files.pythonhosted.org/packages/d0/f3/a0925611c9d6c2f37c5935a39203cadec6883aa914e013b46c84c4c2e641/kiwisolver-1.4.5-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:f91de7223d4c7b793867797bacd1ee53bfe7359bd70d27b7b58a04efbb9436c8", size = 1847516 }, + { url = "https://files.pythonhosted.org/packages/da/85/82d59bb8f7c4c9bb2785138b72462cb1b161668f8230c58bbb28c0403cd5/kiwisolver-1.4.5-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:faae4860798c31530dd184046a900e652c95513796ef51a12bc086710c2eec4d", size = 1946228 }, + { url = "https://files.pythonhosted.org/packages/34/3c/6a37f444c0233993881e5db3a6a1775925d4d9d2f2609bb325bb1348ed94/kiwisolver-1.4.5-cp311-cp311-musllinux_1_1_ppc64le.whl", hash = "sha256:b0157420efcb803e71d1b28e2c287518b8808b7cf1ab8af36718fd0a2c453eb0", size = 1901716 }, + { url = "https://files.pythonhosted.org/packages/cd/7e/180425790efc00adfd47db14e1e341cb4826516982334129012b971121a6/kiwisolver-1.4.5-cp311-cp311-musllinux_1_1_s390x.whl", hash = "sha256:06f54715b7737c2fecdbf140d1afb11a33d59508a47bf11bb38ecf21dc9ab79f", size = 1852871 }, + { url = "https://files.pythonhosted.org/packages/1b/9a/13c68b2edb1fa74321e60893a9a5829788e135138e68060cf44e2d92d2c3/kiwisolver-1.4.5-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:fdb7adb641a0d13bdcd4ef48e062363d8a9ad4a182ac7647ec88f695e719ae9f", size = 1870265 }, + { url = "https://files.pythonhosted.org/packages/9f/0a/fa56a0fdee5da2b4c79899c0f6bd1aefb29d9438c2d66430e78793571c6b/kiwisolver-1.4.5-cp311-cp311-win32.whl", hash = "sha256:bb86433b1cfe686da83ce32a9d3a8dd308e85c76b60896d58f082136f10bffac", size = 46649 }, + { url = "https://files.pythonhosted.org/packages/1e/37/d3c2d4ba2719059a0f12730947bbe1ad5ee8bff89e8c35319dcb2c9ddb4c/kiwisolver-1.4.5-cp311-cp311-win_amd64.whl", hash = "sha256:6c08e1312a9cf1074d17b17728d3dfce2a5125b2d791527f33ffbe805200a355", size = 56116 }, + { url = "https://files.pythonhosted.org/packages/f3/7a/debbce859be1a2711eb8437818107137192007b88d17b5cfdb556f457b42/kiwisolver-1.4.5-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:32d5cf40c4f7c7b3ca500f8985eb3fb3a7dfc023215e876f207956b5ea26632a", size = 125484 }, + { url = "https://files.pythonhosted.org/packages/2d/e0/bf8df75ba93b9e035cc6757dd5dcaf63084fdc1c846ae134e818bd7e0f03/kiwisolver-1.4.5-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:f846c260f483d1fd217fe5ed7c173fb109efa6b1fc8381c8b7552c5781756192", size = 67332 }, + { url = "https://files.pythonhosted.org/packages/26/61/58bb691f6880588be3a4801d199bd776032ece07203faf3e4a8b377f7d9b/kiwisolver-1.4.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:5ff5cf3571589b6d13bfbfd6bcd7a3f659e42f96b5fd1c4830c4cf21d4f5ef45", size = 64987 }, + { url = "https://files.pythonhosted.org/packages/8e/a3/96ac5413068b237c006f54dd8d70114e8756d70e3da7613c5aef20627e22/kiwisolver-1.4.5-cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7269d9e5f1084a653d575c7ec012ff57f0c042258bf5db0954bf551c158466e7", size = 1370613 }, + { url = "https://files.pythonhosted.org/packages/4d/12/f48539e6e17068b59c7f12f4d6214b973431b8e3ac83af525cafd27cebec/kiwisolver-1.4.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:da802a19d6e15dffe4b0c24b38b3af68e6c1a68e6e1d8f30148c83864f3881db", size = 1463183 }, + { url = "https://files.pythonhosted.org/packages/f3/70/26c99be8eb034cc8e3f62e0760af1fbdc97a842a7cbc252f7978507d41c2/kiwisolver-1.4.5-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3aba7311af82e335dd1e36ffff68aaca609ca6290c2cb6d821a39aa075d8e3ff", size = 1581248 }, + { url = "https://files.pythonhosted.org/packages/17/f6/f75f20e543639b09b2de7fc864274a5a9b96cda167a6210a1d9d19306b9d/kiwisolver-1.4.5-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:763773d53f07244148ccac5b084da5adb90bfaee39c197554f01b286cf869228", size = 1508815 }, + { url = "https://files.pythonhosted.org/packages/e3/d5/bc0f22ac108743062ab703f8d6d71c9c7b077b8839fa358700bfb81770b8/kiwisolver-1.4.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2270953c0d8cdab5d422bee7d2007f043473f9d2999631c86a223c9db56cbd16", size = 1466042 }, + { url = "https://files.pythonhosted.org/packages/75/18/98142500f21d6838bcab49ec919414a1f0c6d049d21ddadf139124db6a70/kiwisolver-1.4.5-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:d099e745a512f7e3bbe7249ca835f4d357c586d78d79ae8f1dcd4d8adeb9bda9", size = 1885159 }, + { url = "https://files.pythonhosted.org/packages/21/49/a241eff9e0ee013368c1d17957f9d345b0957493c3a43d82ebb558c90b0a/kiwisolver-1.4.5-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:74db36e14a7d1ce0986fa104f7d5637aea5c82ca6326ed0ec5694280942d1162", size = 1981694 }, + { url = "https://files.pythonhosted.org/packages/90/90/9490c3de4788123041b1d600d64434f1eed809a2ce9f688075a22166b289/kiwisolver-1.4.5-cp312-cp312-musllinux_1_1_ppc64le.whl", hash = "sha256:7e5bab140c309cb3a6ce373a9e71eb7e4873c70c2dda01df6820474f9889d6d4", size = 1941579 }, + { url = "https://files.pythonhosted.org/packages/b7/bb/a0cc488ef2aa92d7d304318c8549d3ec8dfe6dd3c2c67a44e3922b77bc4f/kiwisolver-1.4.5-cp312-cp312-musllinux_1_1_s390x.whl", hash = "sha256:0f114aa76dc1b8f636d077979c0ac22e7cd8f3493abbab152f20eb8d3cda71f3", size = 1888168 }, + { url = "https://files.pythonhosted.org/packages/4f/e9/9c0de8e45fef3d63f85eed3b1757f9aa511065942866331ef8b99421f433/kiwisolver-1.4.5-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:88a2df29d4724b9237fc0c6eaf2a1adae0cdc0b3e9f4d8e7dc54b16812d2d81a", size = 1908464 }, + { url = "https://files.pythonhosted.org/packages/a3/60/4f0fd50b08f5be536ea0cef518ac7255d9dab43ca40f3b93b60e3ddf80dd/kiwisolver-1.4.5-cp312-cp312-win32.whl", hash = "sha256:72d40b33e834371fd330fb1472ca19d9b8327acb79a5821d4008391db8e29f20", size = 46473 }, + { url = "https://files.pythonhosted.org/packages/63/50/2746566bdf4a6a842d117367d05c90cfb87ac04e9e2845aa1fa21f071362/kiwisolver-1.4.5-cp312-cp312-win_amd64.whl", hash = "sha256:2c5674c4e74d939b9d91dda0fae10597ac7521768fec9e399c70a1f27e2ea2d9", size = 56004 }, + { url = "https://files.pythonhosted.org/packages/90/54/d173ef7c814476f23471781768804356494363a824e312a1bd0fef50344c/kiwisolver-1.4.5-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:3a2b053a0ab7a3960c98725cfb0bf5b48ba82f64ec95fe06f1d06c99b552e130", size = 67465 }, + { url = "https://files.pythonhosted.org/packages/5e/37/d7753af11a6b4b8d22585525db06c1c01166a22c33afc43166d497c45f32/kiwisolver-1.4.5-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3cd32d6c13807e5c66a7cbb79f90b553642f296ae4518a60d8d76243b0ad2898", size = 1398679 }, + { url = "https://files.pythonhosted.org/packages/fe/65/73ac820664dd1e71276d8eff0d60f5a150d45d241cd1d88aed05a7754b17/kiwisolver-1.4.5-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:59ec7b7c7e1a61061850d53aaf8e93db63dce0c936db1fda2658b70e4a1be709", size = 1509715 }, + { url = "https://files.pythonhosted.org/packages/ff/f2/1c442ed10b35846b152c66ac7b7a71ba71034c398b606181c4c0cc8cbffc/kiwisolver-1.4.5-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:da4cfb373035def307905d05041c1d06d8936452fe89d464743ae7fb8371078b", size = 1442772 }, + { url = "https://files.pythonhosted.org/packages/a1/38/2aedab05bd1e5b38dd470b5aeb0789f9e2f8f4bac47ee2c5beaea0ef8478/kiwisolver-1.4.5-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2400873bccc260b6ae184b2b8a4fec0e4082d30648eadb7c3d9a13405d861e89", size = 1108140 }, + { url = "https://files.pythonhosted.org/packages/f9/77/e3046bf19720b22e3e0b7c12e28f6f2c0c18a213fb91a56cea640862270f/kiwisolver-1.4.5-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:1b04139c4236a0f3aff534479b58f6f849a8b351e1314826c2d230849ed48985", size = 1148389 }, + { url = "https://files.pythonhosted.org/packages/7f/e8/91989c0f30ffe4f94f8b8667740b8af66363229c08d43246f3c97761eb2e/kiwisolver-1.4.5-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:4e66e81a5779b65ac21764c295087de82235597a2293d18d943f8e9e32746265", size = 1828589 }, + { url = "https://files.pythonhosted.org/packages/a9/45/1934f450a68fd3daaa4741d57fd11f6bceda20c4433ff2f6d8fa70c74182/kiwisolver-1.4.5-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:7931d8f1f67c4be9ba1dd9c451fb0eeca1a25b89e4d3f89e828fe12a519b782a", size = 1934260 }, + { url = "https://files.pythonhosted.org/packages/5e/51/806f3db7094c39e8fe44b2a725392f70e7601eee7ac93c72dd20421bbe72/kiwisolver-1.4.5-cp37-cp37m-musllinux_1_1_ppc64le.whl", hash = "sha256:b3f7e75f3015df442238cca659f8baa5f42ce2a8582727981cbfa15fee0ee205", size = 1883323 }, + { url = "https://files.pythonhosted.org/packages/2b/70/63df980a3cbf125919353cfcce094e34426867464ea387abb7102c38f9ec/kiwisolver-1.4.5-cp37-cp37m-musllinux_1_1_s390x.whl", hash = "sha256:bbf1d63eef84b2e8c89011b7f2235b1e0bf7dacc11cac9431fc6468e99ac77fb", size = 1838388 }, + { url = "https://files.pythonhosted.org/packages/47/52/75489f9fee2f01b81ea1975fd92c20f58e1cc964b78d2b9e493e077faf5e/kiwisolver-1.4.5-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:4c380469bd3f970ef677bf2bcba2b6b0b4d5c75e7a020fb863ef75084efad66f", size = 1844428 }, + { url = "https://files.pythonhosted.org/packages/a6/fc/d036c3832de1b30fbf27ca61b483f737b02d6f1f85b1fcedb3861fd96efa/kiwisolver-1.4.5-cp37-cp37m-win32.whl", hash = "sha256:9408acf3270c4b6baad483865191e3e582b638b1654a007c62e3efe96f09a9a3", size = 47910 }, + { url = "https://files.pythonhosted.org/packages/27/b5/c548a1f1cef3fb9af3f59d6fc4259aa17c48403680c33435ca675aae2b30/kiwisolver-1.4.5-cp37-cp37m-win_amd64.whl", hash = "sha256:5b94529f9b2591b7af5f3e0e730a4e0a41ea174af35a4fd067775f9bdfeee01a", size = 55797 }, + { url = "https://files.pythonhosted.org/packages/e0/39/ba38e5634e4e21c5f738d55879fbc7eee91a70d7cc52903e15e9168296bc/kiwisolver-1.4.5-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:11c7de8f692fc99816e8ac50d1d1aef4f75126eefc33ac79aac02c099fd3db71", size = 127208 }, + { url = "https://files.pythonhosted.org/packages/ca/78/2bff6dbedc619a614871005c32f106f24c3366e1025afff0fdfc2b56b7c8/kiwisolver-1.4.5-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:53abb58632235cd154176ced1ae8f0d29a6657aa1aa9decf50b899b755bc2b93", size = 68043 }, + { url = "https://files.pythonhosted.org/packages/2e/db/501d8e0452e025e3ae7140439efab43789eb251e5cd8ed962297d565a301/kiwisolver-1.4.5-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:88b9f257ca61b838b6f8094a62418421f87ac2a1069f7e896c36a7d86b5d4c29", size = 66043 }, + { url = "https://files.pythonhosted.org/packages/10/15/0c225864a00eb3dbd3d04b6465f331dc12a6e80673449166457b9566036d/kiwisolver-1.4.5-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3195782b26fc03aa9c6913d5bad5aeb864bdc372924c093b0f1cebad603dd712", size = 1387275 }, + { url = "https://files.pythonhosted.org/packages/58/23/58fc9e035eeac6c9e2ad7a2965e178aaf75a274193face124632c42e206f/kiwisolver-1.4.5-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:fc579bf0f502e54926519451b920e875f433aceb4624a3646b3252b5caa9e0b6", size = 1500591 }, + { url = "https://files.pythonhosted.org/packages/91/7f/bffd5437533de5cc95c384413cb210a026038908e209fed73e0dd3ba4363/kiwisolver-1.4.5-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5a580c91d686376f0f7c295357595c5a026e6cbc3d77b7c36e290201e7c11ecb", size = 1431728 }, + { url = "https://files.pythonhosted.org/packages/39/65/3341d1ba7d357985732b04d676e72206b231afa8f6318cf851dc5b35447e/kiwisolver-1.4.5-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:cfe6ab8da05c01ba6fbea630377b5da2cd9bcbc6338510116b01c1bc939a2c18", size = 1125852 }, + { url = "https://files.pythonhosted.org/packages/d2/55/7021ffcc8cb26a520bb051aa0a3d08daf200cde945e5863d5768161e2d3d/kiwisolver-1.4.5-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:d2e5a98f0ec99beb3c10e13b387f8db39106d53993f498b295f0c914328b1333", size = 1180026 }, + { url = "https://files.pythonhosted.org/packages/c2/e3/de457b232f8d2a1bf22aceb9fb6ac44e4461719ecdfedcfb851824b09b49/kiwisolver-1.4.5-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:a51a263952b1429e429ff236d2f5a21c5125437861baeed77f5e1cc2d2c7c6da", size = 1814216 }, + { url = "https://files.pythonhosted.org/packages/19/8e/6390f247f83b2b4b9598c41ff81eb2356be627c72988bac7dc389e717b0c/kiwisolver-1.4.5-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:3edd2fa14e68c9be82c5b16689e8d63d89fe927e56debd6e1dbce7a26a17f81b", size = 1913943 }, + { url = "https://files.pythonhosted.org/packages/70/6b/3713b38105dd071bec0c69221baf3e493b335f7157bef7743312f1b5e4cf/kiwisolver-1.4.5-cp38-cp38-musllinux_1_1_ppc64le.whl", hash = "sha256:74d1b44c6cfc897df648cc9fdaa09bc3e7679926e6f96df05775d4fb3946571c", size = 1870507 }, + { url = "https://files.pythonhosted.org/packages/17/2b/aa1499f50c9d36b31663a3605e9888c662631a1e37c6f2501ae174e0950a/kiwisolver-1.4.5-cp38-cp38-musllinux_1_1_s390x.whl", hash = "sha256:76d9289ed3f7501012e05abb8358bbb129149dbd173f1f57a1bf1c22d19ab7cc", size = 1824249 }, + { url = "https://files.pythonhosted.org/packages/64/62/193cd7b7c2e26300857d3661697fd4e599858e21434cf6e35369e7884c94/kiwisolver-1.4.5-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:92dea1ffe3714fa8eb6a314d2b3c773208d865a0e0d35e713ec54eea08a66250", size = 1834838 }, + { url = "https://files.pythonhosted.org/packages/1c/e1/597068727a76cbaf6aadb28882eb4d0ac48fed2e00a37e9f6cbbca5c24df/kiwisolver-1.4.5-cp38-cp38-win32.whl", hash = "sha256:5c90ae8c8d32e472be041e76f9d2f2dbff4d0b0be8bd4041770eddb18cf49a4e", size = 46886 }, + { url = "https://files.pythonhosted.org/packages/1e/93/9dc4ca136063707f12eb56f4c8c294a940dd23f8512834573b201df83f88/kiwisolver-1.4.5-cp38-cp38-win_amd64.whl", hash = "sha256:c7940c1dc63eb37a67721b10d703247552416f719c4188c54e04334321351ced", size = 56197 }, + { url = "https://files.pythonhosted.org/packages/d5/2b/f0b6f9e8c657e493b5d9f43e9e786e2d4b3665f4f24e8b575044d6de33b9/kiwisolver-1.4.5-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:9407b6a5f0d675e8a827ad8742e1d6b49d9c1a1da5d952a67d50ef5f4170b18d", size = 127375 }, + { url = "https://files.pythonhosted.org/packages/ef/da/e887802f34afb5806f139c71e6d5f20a9f33b2fccd7f9de771094f66ca5e/kiwisolver-1.4.5-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:15568384086b6df3c65353820a4473575dbad192e35010f622c6ce3eebd57af9", size = 68124 }, + { url = "https://files.pythonhosted.org/packages/89/a8/3b7e14121bea4438b87630557645bb7648b17b54acaa39b93f4bf7f8d33e/kiwisolver-1.4.5-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:0dc9db8e79f0036e8173c466d21ef18e1befc02de8bf8aa8dc0813a6dc8a7046", size = 66167 }, + { url = "https://files.pythonhosted.org/packages/ae/ca/5fdda20d677a19a789b490b9aa4542a6ce1842acb92e6e24ba2294cc9ffa/kiwisolver-1.4.5-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:cdc8a402aaee9a798b50d8b827d7ecf75edc5fb35ea0f91f213ff927c15f4ff0", size = 1627002 }, + { url = "https://files.pythonhosted.org/packages/c0/a8/841594f11d0b88d8aeb26991bc4dac38baa909dc58d0c4262a4f7893bcbf/kiwisolver-1.4.5-cp39-cp39-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:6c3bd3cde54cafb87d74d8db50b909705c62b17c2099b8f2e25b461882e544ff", size = 1607093 }, + { url = "https://files.pythonhosted.org/packages/a8/04/b16d356c54db98d6f1002e7485997d47e8bfd416fe60c3a4139d256e1617/kiwisolver-1.4.5-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:955e8513d07a283056b1396e9a57ceddbd272d9252c14f154d450d227606eb54", size = 1391911 }, + { url = "https://files.pythonhosted.org/packages/0b/59/e8b4264849c57fc823ddfbd2a029c9e1ca9f24fad82ea874b7a767132653/kiwisolver-1.4.5-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:346f5343b9e3f00b8db8ba359350eb124b98c99efd0b408728ac6ebf38173958", size = 1504791 }, + { url = "https://files.pythonhosted.org/packages/d7/4c/c1c861e7b4c6b4a67312942e155368aa228e7fd692fc217d92b0f6d388ff/kiwisolver-1.4.5-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b9098e0049e88c6a24ff64545cdfc50807818ba6c1b739cae221bbbcbc58aad3", size = 1437028 }, + { url = "https://files.pythonhosted.org/packages/85/de/f3230420b9995ddd389139ac250f73954b098e85300eac79decdd2c72b97/kiwisolver-1.4.5-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:00bd361b903dc4bbf4eb165f24d1acbee754fce22ded24c3d56eec268658a5cf", size = 1808774 }, + { url = "https://files.pythonhosted.org/packages/57/5c/6fe2f73eec0040031abd172a45af2471f4c3bd880ed4461b6d6e721d790f/kiwisolver-1.4.5-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:7b8b454bac16428b22560d0a1cf0a09875339cab69df61d7805bf48919415901", size = 1909458 }, + { url = "https://files.pythonhosted.org/packages/71/8f/3030eb363dc1b1f64d5411544c95d86079817cda39f4e973247615161660/kiwisolver-1.4.5-cp39-cp39-musllinux_1_1_ppc64le.whl", hash = "sha256:f1d072c2eb0ad60d4c183f3fb44ac6f73fb7a8f16a2694a91f988275cbf352f9", size = 1864345 }, + { url = "https://files.pythonhosted.org/packages/bb/24/c3616cc9078f2e3b6bfccb51afb8fa8ae0a4796c646cd2756c00a93b652c/kiwisolver-1.4.5-cp39-cp39-musllinux_1_1_s390x.whl", hash = "sha256:31a82d498054cac9f6d0b53d02bb85811185bcb477d4b60144f915f3b3126342", size = 1820451 }, + { url = "https://files.pythonhosted.org/packages/08/b0/a818e5376b5718d3571412e2e0381e68df8bd88f12cab2418cc9122f6d1f/kiwisolver-1.4.5-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:6512cb89e334e4700febbffaaa52761b65b4f5a3cf33f960213d5656cea36a77", size = 1830580 }, + { url = "https://files.pythonhosted.org/packages/33/2a/3e559e086890220dcb6fc5e7812e94353a6ebc94470df6b3c02ce812a151/kiwisolver-1.4.5-cp39-cp39-win32.whl", hash = "sha256:9db8ea4c388fdb0f780fe91346fd438657ea602d58348753d9fb265ce1bca67f", size = 46896 }, + { url = "https://files.pythonhosted.org/packages/ca/c1/1f986c8119c0c57c2bd71d1941da23332c38ee2c90117e46dff4358b70f7/kiwisolver-1.4.5-cp39-cp39-win_amd64.whl", hash = "sha256:59415f46a37f7f2efeec758353dd2eae1b07640d8ca0f0c42548ec4125492635", size = 56201 }, + { url = "https://files.pythonhosted.org/packages/c9/b6/aad80b6e1e9640743ef2c8b6d2e10135692365176909f33f5e1400ec3a52/kiwisolver-1.4.5-pp37-pypy37_pp73-macosx_10_9_x86_64.whl", hash = "sha256:5c7b3b3a728dc6faf3fc372ef24f21d1e3cee2ac3e9596691d746e5a536de920", size = 58249 }, + { url = "https://files.pythonhosted.org/packages/65/1b/e498d7850c94f8690087295a81959bce1c5ac4807f19da7cbef921630c77/kiwisolver-1.4.5-pp37-pypy37_pp73-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:620ced262a86244e2be10a676b646f29c34537d0d9cc8eb26c08f53d98013390", size = 103601 }, + { url = "https://files.pythonhosted.org/packages/9c/dd/c72f9b75ed53a3293366990a90a9dd597f33e18b15fde0d78ca12939a84a/kiwisolver-1.4.5-pp37-pypy37_pp73-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:378a214a1e3bbf5ac4a8708304318b4f890da88c9e6a07699c4ae7174c09a68d", size = 95306 }, + { url = "https://files.pythonhosted.org/packages/07/ad/d586def32f28baf92e66abb31fb409390f692f286cb1f01058517b8fa152/kiwisolver-1.4.5-pp37-pypy37_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:aaf7be1207676ac608a50cd08f102f6742dbfc70e8d60c4db1c6897f62f71523", size = 78531 }, + { url = "https://files.pythonhosted.org/packages/63/61/3646d578ebf8550ae381cf965786beeedc1bb7ea092cdfbee2c489fd68a5/kiwisolver-1.4.5-pp37-pypy37_pp73-win_amd64.whl", hash = "sha256:ba55dce0a9b8ff59495ddd050a0225d58bd0983d09f87cfe2b6aec4f2c1234e4", size = 56153 }, + { url = "https://files.pythonhosted.org/packages/d5/ec/43f8ce87157cf7f38de2fef6451f38fc6dc452a072721d6e8f6650962c88/kiwisolver-1.4.5-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:fd32ea360bcbb92d28933fc05ed09bffcb1704ba3fc7942e81db0fd4f81a7892", size = 58978 }, + { url = "https://files.pythonhosted.org/packages/51/95/9e875695f51531ecf07a8a744f619d24fc1e5e78d0a6f31422bb1cc34f7a/kiwisolver-1.4.5-pp38-pypy38_pp73-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:5e7139af55d1688f8b960ee9ad5adafc4ac17c1c473fe07133ac092310d76544", size = 103602 }, + { url = "https://files.pythonhosted.org/packages/67/aa/8db40b241238c4d58bafc5a0be2ad2a8f5c9060ae887165ae53920c8e617/kiwisolver-1.4.5-pp38-pypy38_pp73-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:dced8146011d2bc2e883f9bd68618b8247387f4bbec46d7392b3c3b032640126", size = 95304 }, + { url = "https://files.pythonhosted.org/packages/56/0c/c7ebefc36b064d1ed08b3bb42e1aea85f75bcddcde903372c245f26990fc/kiwisolver-1.4.5-pp38-pypy38_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c9bf3325c47b11b2e51bca0824ea217c7cd84491d8ac4eefd1e409705ef092bd", size = 78235 }, + { url = "https://files.pythonhosted.org/packages/9c/ce/3d3f4df2702a188107fd47a960a4671720b0cb3b68e7382217687ec9551a/kiwisolver-1.4.5-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:5794cf59533bc3f1b1c821f7206a3617999db9fbefc345360aafe2e067514929", size = 56414 }, + { url = "https://files.pythonhosted.org/packages/31/57/a12b06f802834b0baee6d50a77cb7e73b730b8aa6f4794898cd53a4a80d7/kiwisolver-1.4.5-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:e368f200bbc2e4f905b8e71eb38b3c04333bddaa6a2464a6355487b02bb7fb09", size = 58285 }, + { url = "https://files.pythonhosted.org/packages/c7/47/19b88813ad3377cf25a42e83459fc36160da24ec788fa37f1f0a8776d171/kiwisolver-1.4.5-pp39-pypy39_pp73-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e5d706eba36b4c4d5bc6c6377bb6568098765e990cfc21ee16d13963fab7b3e7", size = 84358 }, + { url = "https://files.pythonhosted.org/packages/83/5b/799c1b0b12ad72b9bc17ba304f090385cc113e4e99816efae163b7d8b6c6/kiwisolver-1.4.5-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:85267bd1aa8880a9c88a8cb71e18d3d64d2751a790e6ca6c27b8ccc724bcd5ad", size = 80817 }, + { url = "https://files.pythonhosted.org/packages/2d/bc/b34ba1b2525c3f2380b21fcf72ad2b7468a998544e48da1a175e0b4bd031/kiwisolver-1.4.5-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:210ef2c3a1f03272649aff1ef992df2e724748918c4bc2d5a90352849eb40bea", size = 80022 }, + { url = "https://files.pythonhosted.org/packages/9b/9e/976aaa9a957e2bdcbd7cfd63dba83d8f422ee709c2d2314206e8b64555ee/kiwisolver-1.4.5-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:11d011a7574eb3b82bcc9c1a1d35c1d7075677fdd15de527d91b46bd35e935ee", size = 56008 }, +] + +[[package]] +name = "kiwisolver" +version = "1.4.7" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version == '3.9.*'", + "python_full_version == '3.8.*'", +] +sdist = { url = "https://files.pythonhosted.org/packages/85/4d/2255e1c76304cbd60b48cee302b66d1dde4468dc5b1160e4b7cb43778f2a/kiwisolver-1.4.7.tar.gz", hash = "sha256:9893ff81bd7107f7b685d3017cc6583daadb4fc26e4a888350df530e41980a60", size = 97286 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/97/14/fc943dd65268a96347472b4fbe5dcc2f6f55034516f80576cd0dd3a8930f/kiwisolver-1.4.7-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:8a9c83f75223d5e48b0bc9cb1bf2776cf01563e00ade8775ffe13b0b6e1af3a6", size = 122440 }, + { url = "https://files.pythonhosted.org/packages/1e/46/e68fed66236b69dd02fcdb506218c05ac0e39745d696d22709498896875d/kiwisolver-1.4.7-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:58370b1ffbd35407444d57057b57da5d6549d2d854fa30249771775c63b5fe17", size = 65758 }, + { url = "https://files.pythonhosted.org/packages/ef/fa/65de49c85838681fc9cb05de2a68067a683717321e01ddafb5b8024286f0/kiwisolver-1.4.7-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:aa0abdf853e09aff551db11fce173e2177d00786c688203f52c87ad7fcd91ef9", size = 64311 }, + { url = "https://files.pythonhosted.org/packages/42/9c/cc8d90f6ef550f65443bad5872ffa68f3dee36de4974768628bea7c14979/kiwisolver-1.4.7-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:8d53103597a252fb3ab8b5845af04c7a26d5e7ea8122303dd7a021176a87e8b9", size = 1637109 }, + { url = "https://files.pythonhosted.org/packages/55/91/0a57ce324caf2ff5403edab71c508dd8f648094b18cfbb4c8cc0fde4a6ac/kiwisolver-1.4.7-cp310-cp310-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:88f17c5ffa8e9462fb79f62746428dd57b46eb931698e42e990ad63103f35e6c", size = 1617814 }, + { url = "https://files.pythonhosted.org/packages/12/5d/c36140313f2510e20207708adf36ae4919416d697ee0236b0ddfb6fd1050/kiwisolver-1.4.7-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:88a9ca9c710d598fd75ee5de59d5bda2684d9db36a9f50b6125eaea3969c2599", size = 1400881 }, + { url = "https://files.pythonhosted.org/packages/56/d0/786e524f9ed648324a466ca8df86298780ef2b29c25313d9a4f16992d3cf/kiwisolver-1.4.7-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f4d742cb7af1c28303a51b7a27aaee540e71bb8e24f68c736f6f2ffc82f2bf05", size = 1512972 }, + { url = "https://files.pythonhosted.org/packages/67/5a/77851f2f201e6141d63c10a0708e996a1363efaf9e1609ad0441b343763b/kiwisolver-1.4.7-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e28c7fea2196bf4c2f8d46a0415c77a1c480cc0724722f23d7410ffe9842c407", size = 1444787 }, + { url = "https://files.pythonhosted.org/packages/06/5f/1f5eaab84355885e224a6fc8d73089e8713dc7e91c121f00b9a1c58a2195/kiwisolver-1.4.7-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:e968b84db54f9d42046cf154e02911e39c0435c9801681e3fc9ce8a3c4130278", size = 2199212 }, + { url = "https://files.pythonhosted.org/packages/b5/28/9152a3bfe976a0ae21d445415defc9d1cd8614b2910b7614b30b27a47270/kiwisolver-1.4.7-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:0c18ec74c0472de033e1bebb2911c3c310eef5649133dd0bedf2a169a1b269e5", size = 2346399 }, + { url = "https://files.pythonhosted.org/packages/26/f6/453d1904c52ac3b400f4d5e240ac5fec25263716723e44be65f4d7149d13/kiwisolver-1.4.7-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:8f0ea6da6d393d8b2e187e6a5e3fb81f5862010a40c3945e2c6d12ae45cfb2ad", size = 2308688 }, + { url = "https://files.pythonhosted.org/packages/5a/9a/d4968499441b9ae187e81745e3277a8b4d7c60840a52dc9d535a7909fac3/kiwisolver-1.4.7-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:f106407dda69ae456dd1227966bf445b157ccc80ba0dff3802bb63f30b74e895", size = 2445493 }, + { url = "https://files.pythonhosted.org/packages/07/c9/032267192e7828520dacb64dfdb1d74f292765f179e467c1cba97687f17d/kiwisolver-1.4.7-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:84ec80df401cfee1457063732d90022f93951944b5b58975d34ab56bb150dfb3", size = 2262191 }, + { url = "https://files.pythonhosted.org/packages/6c/ad/db0aedb638a58b2951da46ddaeecf204be8b4f5454df020d850c7fa8dca8/kiwisolver-1.4.7-cp310-cp310-win32.whl", hash = "sha256:71bb308552200fb2c195e35ef05de12f0c878c07fc91c270eb3d6e41698c3bcc", size = 46644 }, + { url = "https://files.pythonhosted.org/packages/12/ca/d0f7b7ffbb0be1e7c2258b53554efec1fd652921f10d7d85045aff93ab61/kiwisolver-1.4.7-cp310-cp310-win_amd64.whl", hash = "sha256:44756f9fd339de0fb6ee4f8c1696cfd19b2422e0d70b4cefc1cc7f1f64045a8c", size = 55877 }, + { url = "https://files.pythonhosted.org/packages/97/6c/cfcc128672f47a3e3c0d918ecb67830600078b025bfc32d858f2e2d5c6a4/kiwisolver-1.4.7-cp310-cp310-win_arm64.whl", hash = "sha256:78a42513018c41c2ffd262eb676442315cbfe3c44eed82385c2ed043bc63210a", size = 48347 }, + { url = "https://files.pythonhosted.org/packages/e9/44/77429fa0a58f941d6e1c58da9efe08597d2e86bf2b2cce6626834f49d07b/kiwisolver-1.4.7-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:d2b0e12a42fb4e72d509fc994713d099cbb15ebf1103545e8a45f14da2dfca54", size = 122442 }, + { url = "https://files.pythonhosted.org/packages/e5/20/8c75caed8f2462d63c7fd65e16c832b8f76cda331ac9e615e914ee80bac9/kiwisolver-1.4.7-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:2a8781ac3edc42ea4b90bc23e7d37b665d89423818e26eb6df90698aa2287c95", size = 65762 }, + { url = "https://files.pythonhosted.org/packages/f4/98/fe010f15dc7230f45bc4cf367b012d651367fd203caaa992fd1f5963560e/kiwisolver-1.4.7-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:46707a10836894b559e04b0fd143e343945c97fd170d69a2d26d640b4e297935", size = 64319 }, + { url = "https://files.pythonhosted.org/packages/8b/1b/b5d618f4e58c0675654c1e5051bcf42c776703edb21c02b8c74135541f60/kiwisolver-1.4.7-cp311-cp311-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ef97b8df011141c9b0f6caf23b29379f87dd13183c978a30a3c546d2c47314cb", size = 1334260 }, + { url = "https://files.pythonhosted.org/packages/b8/01/946852b13057a162a8c32c4c8d2e9ed79f0bb5d86569a40c0b5fb103e373/kiwisolver-1.4.7-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3ab58c12a2cd0fc769089e6d38466c46d7f76aced0a1f54c77652446733d2d02", size = 1426589 }, + { url = "https://files.pythonhosted.org/packages/70/d1/c9f96df26b459e15cf8a965304e6e6f4eb291e0f7a9460b4ad97b047561e/kiwisolver-1.4.7-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:803b8e1459341c1bb56d1c5c010406d5edec8a0713a0945851290a7930679b51", size = 1541080 }, + { url = "https://files.pythonhosted.org/packages/d3/73/2686990eb8b02d05f3de759d6a23a4ee7d491e659007dd4c075fede4b5d0/kiwisolver-1.4.7-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f9a9e8a507420fe35992ee9ecb302dab68550dedc0da9e2880dd88071c5fb052", size = 1470049 }, + { url = "https://files.pythonhosted.org/packages/a7/4b/2db7af3ed3af7c35f388d5f53c28e155cd402a55432d800c543dc6deb731/kiwisolver-1.4.7-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:18077b53dc3bb490e330669a99920c5e6a496889ae8c63b58fbc57c3d7f33a18", size = 1426376 }, + { url = "https://files.pythonhosted.org/packages/05/83/2857317d04ea46dc5d115f0df7e676997bbd968ced8e2bd6f7f19cfc8d7f/kiwisolver-1.4.7-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:6af936f79086a89b3680a280c47ea90b4df7047b5bdf3aa5c524bbedddb9e545", size = 2222231 }, + { url = "https://files.pythonhosted.org/packages/0d/b5/866f86f5897cd4ab6d25d22e403404766a123f138bd6a02ecb2cdde52c18/kiwisolver-1.4.7-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:3abc5b19d24af4b77d1598a585b8a719beb8569a71568b66f4ebe1fb0449460b", size = 2368634 }, + { url = "https://files.pythonhosted.org/packages/c1/ee/73de8385403faba55f782a41260210528fe3273d0cddcf6d51648202d6d0/kiwisolver-1.4.7-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:933d4de052939d90afbe6e9d5273ae05fb836cc86c15b686edd4b3560cc0ee36", size = 2329024 }, + { url = "https://files.pythonhosted.org/packages/a1/e7/cd101d8cd2cdfaa42dc06c433df17c8303d31129c9fdd16c0ea37672af91/kiwisolver-1.4.7-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:65e720d2ab2b53f1f72fb5da5fb477455905ce2c88aaa671ff0a447c2c80e8e3", size = 2468484 }, + { url = "https://files.pythonhosted.org/packages/e1/72/84f09d45a10bc57a40bb58b81b99d8f22b58b2040c912b7eb97ebf625bf2/kiwisolver-1.4.7-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:3bf1ed55088f214ba6427484c59553123fdd9b218a42bbc8c6496d6754b1e523", size = 2284078 }, + { url = "https://files.pythonhosted.org/packages/d2/d4/71828f32b956612dc36efd7be1788980cb1e66bfb3706e6dec9acad9b4f9/kiwisolver-1.4.7-cp311-cp311-win32.whl", hash = "sha256:4c00336b9dd5ad96d0a558fd18a8b6f711b7449acce4c157e7343ba92dd0cf3d", size = 46645 }, + { url = "https://files.pythonhosted.org/packages/a1/65/d43e9a20aabcf2e798ad1aff6c143ae3a42cf506754bcb6a7ed8259c8425/kiwisolver-1.4.7-cp311-cp311-win_amd64.whl", hash = "sha256:929e294c1ac1e9f615c62a4e4313ca1823ba37326c164ec720a803287c4c499b", size = 56022 }, + { url = "https://files.pythonhosted.org/packages/35/b3/9f75a2e06f1b4ca00b2b192bc2b739334127d27f1d0625627ff8479302ba/kiwisolver-1.4.7-cp311-cp311-win_arm64.whl", hash = "sha256:e33e8fbd440c917106b237ef1a2f1449dfbb9b6f6e1ce17c94cd6a1e0d438376", size = 48536 }, + { url = "https://files.pythonhosted.org/packages/97/9c/0a11c714cf8b6ef91001c8212c4ef207f772dd84540104952c45c1f0a249/kiwisolver-1.4.7-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:5360cc32706dab3931f738d3079652d20982511f7c0ac5711483e6eab08efff2", size = 121808 }, + { url = "https://files.pythonhosted.org/packages/f2/d8/0fe8c5f5d35878ddd135f44f2af0e4e1d379e1c7b0716f97cdcb88d4fd27/kiwisolver-1.4.7-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:942216596dc64ddb25adb215c3c783215b23626f8d84e8eff8d6d45c3f29f75a", size = 65531 }, + { url = "https://files.pythonhosted.org/packages/80/c5/57fa58276dfdfa612241d640a64ca2f76adc6ffcebdbd135b4ef60095098/kiwisolver-1.4.7-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:48b571ecd8bae15702e4f22d3ff6a0f13e54d3d00cd25216d5e7f658242065ee", size = 63894 }, + { url = "https://files.pythonhosted.org/packages/8b/e9/26d3edd4c4ad1c5b891d8747a4f81b1b0aba9fb9721de6600a4adc09773b/kiwisolver-1.4.7-cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ad42ba922c67c5f219097b28fae965e10045ddf145d2928bfac2eb2e17673640", size = 1369296 }, + { url = "https://files.pythonhosted.org/packages/b6/67/3f4850b5e6cffb75ec40577ddf54f7b82b15269cc5097ff2e968ee32ea7d/kiwisolver-1.4.7-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:612a10bdae23404a72941a0fc8fa2660c6ea1217c4ce0dbcab8a8f6543ea9e7f", size = 1461450 }, + { url = "https://files.pythonhosted.org/packages/52/be/86cbb9c9a315e98a8dc6b1d23c43cffd91d97d49318854f9c37b0e41cd68/kiwisolver-1.4.7-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9e838bba3a3bac0fe06d849d29772eb1afb9745a59710762e4ba3f4cb8424483", size = 1579168 }, + { url = "https://files.pythonhosted.org/packages/0f/00/65061acf64bd5fd34c1f4ae53f20b43b0a017a541f242a60b135b9d1e301/kiwisolver-1.4.7-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:22f499f6157236c19f4bbbd472fa55b063db77a16cd74d49afe28992dff8c258", size = 1507308 }, + { url = "https://files.pythonhosted.org/packages/21/e4/c0b6746fd2eb62fe702118b3ca0cb384ce95e1261cfada58ff693aeec08a/kiwisolver-1.4.7-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:693902d433cf585133699972b6d7c42a8b9f8f826ebcaf0132ff55200afc599e", size = 1464186 }, + { url = "https://files.pythonhosted.org/packages/0a/0f/529d0a9fffb4d514f2782c829b0b4b371f7f441d61aa55f1de1c614c4ef3/kiwisolver-1.4.7-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:4e77f2126c3e0b0d055f44513ed349038ac180371ed9b52fe96a32aa071a5107", size = 2247877 }, + { url = "https://files.pythonhosted.org/packages/d1/e1/66603ad779258843036d45adcbe1af0d1a889a07af4635f8b4ec7dccda35/kiwisolver-1.4.7-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:657a05857bda581c3656bfc3b20e353c232e9193eb167766ad2dc58b56504948", size = 2404204 }, + { url = "https://files.pythonhosted.org/packages/8d/61/de5fb1ca7ad1f9ab7970e340a5b833d735df24689047de6ae71ab9d8d0e7/kiwisolver-1.4.7-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:4bfa75a048c056a411f9705856abfc872558e33c055d80af6a380e3658766038", size = 2352461 }, + { url = "https://files.pythonhosted.org/packages/ba/d2/0edc00a852e369827f7e05fd008275f550353f1f9bcd55db9363d779fc63/kiwisolver-1.4.7-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:34ea1de54beef1c104422d210c47c7d2a4999bdecf42c7b5718fbe59a4cac383", size = 2501358 }, + { url = "https://files.pythonhosted.org/packages/84/15/adc15a483506aec6986c01fb7f237c3aec4d9ed4ac10b756e98a76835933/kiwisolver-1.4.7-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:90da3b5f694b85231cf93586dad5e90e2d71b9428f9aad96952c99055582f520", size = 2314119 }, + { url = "https://files.pythonhosted.org/packages/36/08/3a5bb2c53c89660863a5aa1ee236912269f2af8762af04a2e11df851d7b2/kiwisolver-1.4.7-cp312-cp312-win32.whl", hash = "sha256:18e0cca3e008e17fe9b164b55735a325140a5a35faad8de92dd80265cd5eb80b", size = 46367 }, + { url = "https://files.pythonhosted.org/packages/19/93/c05f0a6d825c643779fc3c70876bff1ac221f0e31e6f701f0e9578690d70/kiwisolver-1.4.7-cp312-cp312-win_amd64.whl", hash = "sha256:58cb20602b18f86f83a5c87d3ee1c766a79c0d452f8def86d925e6c60fbf7bfb", size = 55884 }, + { url = "https://files.pythonhosted.org/packages/d2/f9/3828d8f21b6de4279f0667fb50a9f5215e6fe57d5ec0d61905914f5b6099/kiwisolver-1.4.7-cp312-cp312-win_arm64.whl", hash = "sha256:f5a8b53bdc0b3961f8b6125e198617c40aeed638b387913bf1ce78afb1b0be2a", size = 48528 }, + { url = "https://files.pythonhosted.org/packages/c4/06/7da99b04259b0f18b557a4effd1b9c901a747f7fdd84cf834ccf520cb0b2/kiwisolver-1.4.7-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:2e6039dcbe79a8e0f044f1c39db1986a1b8071051efba3ee4d74f5b365f5226e", size = 121913 }, + { url = "https://files.pythonhosted.org/packages/97/f5/b8a370d1aa593c17882af0a6f6755aaecd643640c0ed72dcfd2eafc388b9/kiwisolver-1.4.7-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:a1ecf0ac1c518487d9d23b1cd7139a6a65bc460cd101ab01f1be82ecf09794b6", size = 65627 }, + { url = "https://files.pythonhosted.org/packages/2a/fc/6c0374f7503522539e2d4d1b497f5ebad3f8ed07ab51aed2af988dd0fb65/kiwisolver-1.4.7-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:7ab9ccab2b5bd5702ab0803676a580fffa2aa178c2badc5557a84cc943fcf750", size = 63888 }, + { url = "https://files.pythonhosted.org/packages/bf/3e/0b7172793d0f41cae5c923492da89a2ffcd1adf764c16159ca047463ebd3/kiwisolver-1.4.7-cp313-cp313-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f816dd2277f8d63d79f9c8473a79fe54047bc0467754962840782c575522224d", size = 1369145 }, + { url = "https://files.pythonhosted.org/packages/77/92/47d050d6f6aced2d634258123f2688fbfef8ded3c5baf2c79d94d91f1f58/kiwisolver-1.4.7-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cf8bcc23ceb5a1b624572a1623b9f79d2c3b337c8c455405ef231933a10da379", size = 1461448 }, + { url = "https://files.pythonhosted.org/packages/9c/1b/8f80b18e20b3b294546a1adb41701e79ae21915f4175f311a90d042301cf/kiwisolver-1.4.7-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:dea0bf229319828467d7fca8c7c189780aa9ff679c94539eed7532ebe33ed37c", size = 1578750 }, + { url = "https://files.pythonhosted.org/packages/a4/fe/fe8e72f3be0a844f257cadd72689c0848c6d5c51bc1d60429e2d14ad776e/kiwisolver-1.4.7-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7c06a4c7cf15ec739ce0e5971b26c93638730090add60e183530d70848ebdd34", size = 1507175 }, + { url = "https://files.pythonhosted.org/packages/39/fa/cdc0b6105d90eadc3bee525fecc9179e2b41e1ce0293caaf49cb631a6aaf/kiwisolver-1.4.7-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:913983ad2deb14e66d83c28b632fd35ba2b825031f2fa4ca29675e665dfecbe1", size = 1463963 }, + { url = "https://files.pythonhosted.org/packages/6e/5c/0c03c4e542720c6177d4f408e56d1c8315899db72d46261a4e15b8b33a41/kiwisolver-1.4.7-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:5337ec7809bcd0f424c6b705ecf97941c46279cf5ed92311782c7c9c2026f07f", size = 2248220 }, + { url = "https://files.pythonhosted.org/packages/3d/ee/55ef86d5a574f4e767df7da3a3a7ff4954c996e12d4fbe9c408170cd7dcc/kiwisolver-1.4.7-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:4c26ed10c4f6fa6ddb329a5120ba3b6db349ca192ae211e882970bfc9d91420b", size = 2404463 }, + { url = "https://files.pythonhosted.org/packages/0f/6d/73ad36170b4bff4825dc588acf4f3e6319cb97cd1fb3eb04d9faa6b6f212/kiwisolver-1.4.7-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:c619b101e6de2222c1fcb0531e1b17bbffbe54294bfba43ea0d411d428618c27", size = 2352842 }, + { url = "https://files.pythonhosted.org/packages/0b/16/fa531ff9199d3b6473bb4d0f47416cdb08d556c03b8bc1cccf04e756b56d/kiwisolver-1.4.7-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:073a36c8273647592ea332e816e75ef8da5c303236ec0167196793eb1e34657a", size = 2501635 }, + { url = "https://files.pythonhosted.org/packages/78/7e/aa9422e78419db0cbe75fb86d8e72b433818f2e62e2e394992d23d23a583/kiwisolver-1.4.7-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:3ce6b2b0231bda412463e152fc18335ba32faf4e8c23a754ad50ffa70e4091ee", size = 2314556 }, + { url = "https://files.pythonhosted.org/packages/a8/b2/15f7f556df0a6e5b3772a1e076a9d9f6c538ce5f05bd590eca8106508e06/kiwisolver-1.4.7-cp313-cp313-win32.whl", hash = "sha256:f4c9aee212bc89d4e13f58be11a56cc8036cabad119259d12ace14b34476fd07", size = 46364 }, + { url = "https://files.pythonhosted.org/packages/0b/db/32e897e43a330eee8e4770bfd2737a9584b23e33587a0812b8e20aac38f7/kiwisolver-1.4.7-cp313-cp313-win_amd64.whl", hash = "sha256:8a3ec5aa8e38fc4c8af308917ce12c536f1c88452ce554027e55b22cbbfbff76", size = 55887 }, + { url = "https://files.pythonhosted.org/packages/c8/a4/df2bdca5270ca85fd25253049eb6708d4127be2ed0e5c2650217450b59e9/kiwisolver-1.4.7-cp313-cp313-win_arm64.whl", hash = "sha256:76c8094ac20ec259471ac53e774623eb62e6e1f56cd8690c67ce6ce4fcb05650", size = 48530 }, + { url = "https://files.pythonhosted.org/packages/57/d6/620247574d9e26fe24384087879e8399e309f0051782f95238090afa6ccc/kiwisolver-1.4.7-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:5d5abf8f8ec1f4e22882273c423e16cae834c36856cac348cfbfa68e01c40f3a", size = 122325 }, + { url = "https://files.pythonhosted.org/packages/bd/c6/572ad7d73dbd898cffa9050ffd7ff7e78a055a1d9b7accd6b4d1f50ec858/kiwisolver-1.4.7-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:aeb3531b196ef6f11776c21674dba836aeea9d5bd1cf630f869e3d90b16cfade", size = 65679 }, + { url = "https://files.pythonhosted.org/packages/14/a7/bb8ab10e12cc8764f4da0245d72dee4731cc720bdec0f085d5e9c6005b98/kiwisolver-1.4.7-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:b7d755065e4e866a8086c9bdada157133ff466476a2ad7861828e17b6026e22c", size = 64267 }, + { url = "https://files.pythonhosted.org/packages/54/a4/3b5a2542429e182a4df0528214e76803f79d016110f5e67c414a0357cd7d/kiwisolver-1.4.7-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:08471d4d86cbaec61f86b217dd938a83d85e03785f51121e791a6e6689a3be95", size = 1387236 }, + { url = "https://files.pythonhosted.org/packages/a6/d7/bc3005e906c1673953a3e31ee4f828157d5e07a62778d835dd937d624ea0/kiwisolver-1.4.7-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:7bbfcb7165ce3d54a3dfbe731e470f65739c4c1f85bb1018ee912bae139e263b", size = 1500555 }, + { url = "https://files.pythonhosted.org/packages/09/a7/87cb30741f13b7af08446795dca6003491755805edc9c321fe996c1320b8/kiwisolver-1.4.7-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5d34eb8494bea691a1a450141ebb5385e4b69d38bb8403b5146ad279f4b30fa3", size = 1431684 }, + { url = "https://files.pythonhosted.org/packages/37/a4/1e4e2d8cdaa42c73d523413498445247e615334e39401ae49dae74885429/kiwisolver-1.4.7-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:9242795d174daa40105c1d86aba618e8eab7bf96ba8c3ee614da8302a9f95503", size = 1125811 }, + { url = "https://files.pythonhosted.org/packages/76/36/ae40d7a3171e06f55ac77fe5536079e7be1d8be2a8210e08975c7f9b4d54/kiwisolver-1.4.7-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:a0f64a48bb81af7450e641e3fe0b0394d7381e342805479178b3d335d60ca7cf", size = 1179987 }, + { url = "https://files.pythonhosted.org/packages/d8/5d/6e4894b9fdf836d8bd095729dff123bbbe6ad0346289287b45c800fae656/kiwisolver-1.4.7-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:8e045731a5416357638d1700927529e2b8ab304811671f665b225f8bf8d8f933", size = 2186817 }, + { url = "https://files.pythonhosted.org/packages/f0/2d/603079b2c2fd62890be0b0ebfc8bb6dda8a5253ca0758885596565b0dfc1/kiwisolver-1.4.7-cp38-cp38-musllinux_1_2_i686.whl", hash = "sha256:4322872d5772cae7369f8351da1edf255a604ea7087fe295411397d0cfd9655e", size = 2332538 }, + { url = "https://files.pythonhosted.org/packages/bb/2a/9a28279c865c38a27960db38b07179143aafc94877945c209bfc553d9dd3/kiwisolver-1.4.7-cp38-cp38-musllinux_1_2_ppc64le.whl", hash = "sha256:e1631290ee9271dffe3062d2634c3ecac02c83890ada077d225e081aca8aab89", size = 2293890 }, + { url = "https://files.pythonhosted.org/packages/1a/4d/4da8967f3bf13c764984b8fbae330683ee5fbd555b4a5624ad2b9decc0ab/kiwisolver-1.4.7-cp38-cp38-musllinux_1_2_s390x.whl", hash = "sha256:edcfc407e4eb17e037bca59be0e85a2031a2ac87e4fed26d3e9df88b4165f92d", size = 2434677 }, + { url = "https://files.pythonhosted.org/packages/08/e9/a97a2b6b74dd850fa5974309367e025c06093a143befe9b962d0baebb4f0/kiwisolver-1.4.7-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:4d05d81ecb47d11e7f8932bd8b61b720bf0b41199358f3f5e36d38e28f0532c5", size = 2250339 }, + { url = "https://files.pythonhosted.org/packages/8a/e7/55507a387ba1766e69f5e13a79e1aefabdafe0532bee5d1972dfc42b3d16/kiwisolver-1.4.7-cp38-cp38-win32.whl", hash = "sha256:b38ac83d5f04b15e515fd86f312479d950d05ce2368d5413d46c088dda7de90a", size = 46932 }, + { url = "https://files.pythonhosted.org/packages/52/77/7e04cca2ff1dc6ee6b7654cebe233de72b7a3ec5616501b6f3144fb70740/kiwisolver-1.4.7-cp38-cp38-win_amd64.whl", hash = "sha256:d83db7cde68459fc803052a55ace60bea2bae361fc3b7a6d5da07e11954e4b09", size = 55836 }, + { url = "https://files.pythonhosted.org/packages/11/88/37ea0ea64512997b13d69772db8dcdc3bfca5442cda3a5e4bb943652ee3e/kiwisolver-1.4.7-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:3f9362ecfca44c863569d3d3c033dbe8ba452ff8eed6f6b5806382741a1334bd", size = 122449 }, + { url = "https://files.pythonhosted.org/packages/4e/45/5a5c46078362cb3882dcacad687c503089263c017ca1241e0483857791eb/kiwisolver-1.4.7-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:e8df2eb9b2bac43ef8b082e06f750350fbbaf2887534a5be97f6cf07b19d9583", size = 65757 }, + { url = "https://files.pythonhosted.org/packages/8a/be/a6ae58978772f685d48dd2e84460937761c53c4bbd84e42b0336473d9775/kiwisolver-1.4.7-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:f32d6edbc638cde7652bd690c3e728b25332acbadd7cad670cc4a02558d9c417", size = 64312 }, + { url = "https://files.pythonhosted.org/packages/f4/04/18ef6f452d311e1e1eb180c9bf5589187fa1f042db877e6fe443ef10099c/kiwisolver-1.4.7-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:e2e6c39bd7b9372b0be21456caab138e8e69cc0fc1190a9dfa92bd45a1e6e904", size = 1626966 }, + { url = "https://files.pythonhosted.org/packages/21/b1/40655f6c3fa11ce740e8a964fa8e4c0479c87d6a7944b95af799c7a55dfe/kiwisolver-1.4.7-cp39-cp39-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:dda56c24d869b1193fcc763f1284b9126550eaf84b88bbc7256e15028f19188a", size = 1607044 }, + { url = "https://files.pythonhosted.org/packages/fd/93/af67dbcfb9b3323bbd2c2db1385a7139d8f77630e4a37bb945b57188eb2d/kiwisolver-1.4.7-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:79849239c39b5e1fd906556c474d9b0439ea6792b637511f3fe3a41158d89ca8", size = 1391879 }, + { url = "https://files.pythonhosted.org/packages/40/6f/d60770ef98e77b365d96061d090c0cd9e23418121c55fff188fa4bdf0b54/kiwisolver-1.4.7-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5e3bc157fed2a4c02ec468de4ecd12a6e22818d4f09cde2c31ee3226ffbefab2", size = 1504751 }, + { url = "https://files.pythonhosted.org/packages/fa/3a/5f38667d313e983c432f3fcd86932177519ed8790c724e07d77d1de0188a/kiwisolver-1.4.7-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3da53da805b71e41053dc670f9a820d1157aae77b6b944e08024d17bcd51ef88", size = 1436990 }, + { url = "https://files.pythonhosted.org/packages/cb/3b/1520301a47326e6a6043b502647e42892be33b3f051e9791cc8bb43f1a32/kiwisolver-1.4.7-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:8705f17dfeb43139a692298cb6637ee2e59c0194538153e83e9ee0c75c2eddde", size = 2191122 }, + { url = "https://files.pythonhosted.org/packages/cf/c4/eb52da300c166239a2233f1f9c4a1b767dfab98fae27681bfb7ea4873cb6/kiwisolver-1.4.7-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:82a5c2f4b87c26bb1a0ef3d16b5c4753434633b83d365cc0ddf2770c93829e3c", size = 2338126 }, + { url = "https://files.pythonhosted.org/packages/1a/cb/42b92fd5eadd708dd9107c089e817945500685f3437ce1fd387efebc6d6e/kiwisolver-1.4.7-cp39-cp39-musllinux_1_2_ppc64le.whl", hash = "sha256:ce8be0466f4c0d585cdb6c1e2ed07232221df101a4c6f28821d2aa754ca2d9e2", size = 2298313 }, + { url = "https://files.pythonhosted.org/packages/4f/eb/be25aa791fe5fc75a8b1e0c965e00f942496bc04635c9aae8035f6b76dcd/kiwisolver-1.4.7-cp39-cp39-musllinux_1_2_s390x.whl", hash = "sha256:409afdfe1e2e90e6ee7fc896f3df9a7fec8e793e58bfa0d052c8a82f99c37abb", size = 2437784 }, + { url = "https://files.pythonhosted.org/packages/c5/22/30a66be7f3368d76ff95689e1c2e28d382383952964ab15330a15d8bfd03/kiwisolver-1.4.7-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:5b9c3f4ee0b9a439d2415012bd1b1cc2df59e4d6a9939f4d669241d30b414327", size = 2253988 }, + { url = "https://files.pythonhosted.org/packages/35/d3/5f2ecb94b5211c8a04f218a76133cc8d6d153b0f9cd0b45fad79907f0689/kiwisolver-1.4.7-cp39-cp39-win32.whl", hash = "sha256:a79ae34384df2b615eefca647a2873842ac3b596418032bef9a7283675962644", size = 46980 }, + { url = "https://files.pythonhosted.org/packages/ef/17/cd10d020578764ea91740204edc6b3236ed8106228a46f568d716b11feb2/kiwisolver-1.4.7-cp39-cp39-win_amd64.whl", hash = "sha256:cf0438b42121a66a3a667de17e779330fc0f20b0d97d59d2f2121e182b0505e4", size = 55847 }, + { url = "https://files.pythonhosted.org/packages/91/84/32232502020bd78d1d12be7afde15811c64a95ed1f606c10456db4e4c3ac/kiwisolver-1.4.7-cp39-cp39-win_arm64.whl", hash = "sha256:764202cc7e70f767dab49e8df52c7455e8de0df5d858fa801a11aa0d882ccf3f", size = 48494 }, + { url = "https://files.pythonhosted.org/packages/ac/59/741b79775d67ab67ced9bb38552da688c0305c16e7ee24bba7a2be253fb7/kiwisolver-1.4.7-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:94252291e3fe68001b1dd747b4c0b3be12582839b95ad4d1b641924d68fd4643", size = 59491 }, + { url = "https://files.pythonhosted.org/packages/58/cc/fb239294c29a5656e99e3527f7369b174dd9cc7c3ef2dea7cb3c54a8737b/kiwisolver-1.4.7-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:5b7dfa3b546da08a9f622bb6becdb14b3e24aaa30adba66749d38f3cc7ea9706", size = 57648 }, + { url = "https://files.pythonhosted.org/packages/3b/ef/2f009ac1f7aab9f81efb2d837301d255279d618d27b6015780115ac64bdd/kiwisolver-1.4.7-pp310-pypy310_pp73-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:bd3de6481f4ed8b734da5df134cd5a6a64fe32124fe83dde1e5b5f29fe30b1e6", size = 84257 }, + { url = "https://files.pythonhosted.org/packages/81/e1/c64f50987f85b68b1c52b464bb5bf73e71570c0f7782d626d1eb283ad620/kiwisolver-1.4.7-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a91b5f9f1205845d488c928e8570dcb62b893372f63b8b6e98b863ebd2368ff2", size = 80906 }, + { url = "https://files.pythonhosted.org/packages/fd/71/1687c5c0a0be2cee39a5c9c389e546f9c6e215e46b691d00d9f646892083/kiwisolver-1.4.7-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:40fa14dbd66b8b8f470d5fc79c089a66185619d31645f9b0773b88b19f7223c4", size = 79951 }, + { url = "https://files.pythonhosted.org/packages/ea/8b/d7497df4a1cae9367adf21665dd1f896c2a7aeb8769ad77b662c5e2bcce7/kiwisolver-1.4.7-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:eb542fe7933aa09d8d8f9d9097ef37532a7df6497819d16efe4359890a2f417a", size = 55715 }, + { url = "https://files.pythonhosted.org/packages/64/f3/2403d90821fffe496df16f6996cb328b90b0d80c06d2938a930a7732b4f1/kiwisolver-1.4.7-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:bfa1acfa0c54932d5607e19a2c24646fb4c1ae2694437789129cf099789a3b00", size = 59662 }, + { url = "https://files.pythonhosted.org/packages/fa/7d/8f409736a4a6ac04354fa530ebf46682ddb1539b0bae15f4731ff2c575bc/kiwisolver-1.4.7-pp38-pypy38_pp73-macosx_11_0_arm64.whl", hash = "sha256:eee3ea935c3d227d49b4eb85660ff631556841f6e567f0f7bda972df6c2c9935", size = 57753 }, + { url = "https://files.pythonhosted.org/packages/4c/a5/3937c9abe8eedb1356071739ad437a0b486cbad27d54f4ec4733d24882ac/kiwisolver-1.4.7-pp38-pypy38_pp73-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:f3160309af4396e0ed04db259c3ccbfdc3621b5559b5453075e5de555e1f3a1b", size = 103564 }, + { url = "https://files.pythonhosted.org/packages/b2/18/a5ae23888f010b90d5eb8d196fed30e268056b2ded54d25b38a193bb70e9/kiwisolver-1.4.7-pp38-pypy38_pp73-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:a17f6a29cf8935e587cc8a4dbfc8368c55edc645283db0ce9801016f83526c2d", size = 95264 }, + { url = "https://files.pythonhosted.org/packages/f9/d0/c4240ae86306d4395e9701f1d7e6ddcc6d60c28cb0127139176cfcfc9ebe/kiwisolver-1.4.7-pp38-pypy38_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:10849fb2c1ecbfae45a693c070e0320a91b35dd4bcf58172c023b994283a124d", size = 78197 }, + { url = "https://files.pythonhosted.org/packages/62/db/62423f0ab66813376a35c1e7da488ebdb4e808fcb54b7cec33959717bda1/kiwisolver-1.4.7-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:ac542bf38a8a4be2dc6b15248d36315ccc65f0743f7b1a76688ffb6b5129a5c2", size = 56080 }, + { url = "https://files.pythonhosted.org/packages/d5/df/ce37d9b26f07ab90880923c94d12a6ff4d27447096b4c849bfc4339ccfdf/kiwisolver-1.4.7-pp39-pypy39_pp73-macosx_10_15_x86_64.whl", hash = "sha256:8b01aac285f91ca889c800042c35ad3b239e704b150cfd3382adfc9dcc780e39", size = 58666 }, + { url = "https://files.pythonhosted.org/packages/b0/d3/e4b04f43bc629ac8e186b77b2b1a251cdfa5b7610fa189dc0db622672ce6/kiwisolver-1.4.7-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:48be928f59a1f5c8207154f935334d374e79f2b5d212826307d072595ad76a2e", size = 57088 }, + { url = "https://files.pythonhosted.org/packages/30/1c/752df58e2d339e670a535514d2db4fe8c842ce459776b8080fbe08ebb98e/kiwisolver-1.4.7-pp39-pypy39_pp73-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f37cfe618a117e50d8c240555331160d73d0411422b59b5ee217843d7b693608", size = 84321 }, + { url = "https://files.pythonhosted.org/packages/f0/f8/fe6484e847bc6e238ec9f9828089fb2c0bb53f2f5f3a79351fde5b565e4f/kiwisolver-1.4.7-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:599b5c873c63a1f6ed7eead644a8a380cfbdf5db91dcb6f85707aaab213b1674", size = 80776 }, + { url = "https://files.pythonhosted.org/packages/9b/57/d7163c0379f250ef763aba85330a19feefb5ce6cb541ade853aaba881524/kiwisolver-1.4.7-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:801fa7802e5cfabe3ab0c81a34c323a319b097dfb5004be950482d882f3d7225", size = 79984 }, + { url = "https://files.pythonhosted.org/packages/8c/95/4a103776c265d13b3d2cd24fb0494d4e04ea435a8ef97e1b2c026d43250b/kiwisolver-1.4.7-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:0c6c43471bc764fad4bc99c5c2d6d16a676b1abf844ca7c8702bdae92df01ee0", size = 55811 }, +] + +[[package]] +name = "kiwisolver" +version = "1.4.8" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", + "python_full_version == '3.10.*'", +] +sdist = { url = "https://files.pythonhosted.org/packages/82/59/7c91426a8ac292e1cdd53a63b6d9439abd573c875c3f92c146767dd33faf/kiwisolver-1.4.8.tar.gz", hash = "sha256:23d5f023bdc8c7e54eb65f03ca5d5bb25b601eac4d7f1a042888a1f45237987e", size = 97538 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/47/5f/4d8e9e852d98ecd26cdf8eaf7ed8bc33174033bba5e07001b289f07308fd/kiwisolver-1.4.8-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:88c6f252f6816a73b1f8c904f7bbe02fd67c09a69f7cb8a0eecdbf5ce78e63db", size = 124623 }, + { url = "https://files.pythonhosted.org/packages/1d/70/7f5af2a18a76fe92ea14675f8bd88ce53ee79e37900fa5f1a1d8e0b42998/kiwisolver-1.4.8-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:c72941acb7b67138f35b879bbe85be0f6c6a70cab78fe3ef6db9c024d9223e5b", size = 66720 }, + { url = "https://files.pythonhosted.org/packages/c6/13/e15f804a142353aefd089fadc8f1d985561a15358c97aca27b0979cb0785/kiwisolver-1.4.8-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:ce2cf1e5688edcb727fdf7cd1bbd0b6416758996826a8be1d958f91880d0809d", size = 65413 }, + { url = "https://files.pythonhosted.org/packages/ce/6d/67d36c4d2054e83fb875c6b59d0809d5c530de8148846b1370475eeeece9/kiwisolver-1.4.8-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:c8bf637892dc6e6aad2bc6d4d69d08764166e5e3f69d469e55427b6ac001b19d", size = 1650826 }, + { url = "https://files.pythonhosted.org/packages/de/c6/7b9bb8044e150d4d1558423a1568e4f227193662a02231064e3824f37e0a/kiwisolver-1.4.8-cp310-cp310-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:034d2c891f76bd3edbdb3ea11140d8510dca675443da7304205a2eaa45d8334c", size = 1628231 }, + { url = "https://files.pythonhosted.org/packages/b6/38/ad10d437563063eaaedbe2c3540a71101fc7fb07a7e71f855e93ea4de605/kiwisolver-1.4.8-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d47b28d1dfe0793d5e96bce90835e17edf9a499b53969b03c6c47ea5985844c3", size = 1408938 }, + { url = "https://files.pythonhosted.org/packages/52/ce/c0106b3bd7f9e665c5f5bc1e07cc95b5dabd4e08e3dad42dbe2faad467e7/kiwisolver-1.4.8-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:eb158fe28ca0c29f2260cca8c43005329ad58452c36f0edf298204de32a9a3ed", size = 1422799 }, + { url = "https://files.pythonhosted.org/packages/d0/87/efb704b1d75dc9758087ba374c0f23d3254505edaedd09cf9d247f7878b9/kiwisolver-1.4.8-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d5536185fce131780ebd809f8e623bf4030ce1b161353166c49a3c74c287897f", size = 1354362 }, + { url = "https://files.pythonhosted.org/packages/eb/b3/fd760dc214ec9a8f208b99e42e8f0130ff4b384eca8b29dd0efc62052176/kiwisolver-1.4.8-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:369b75d40abedc1da2c1f4de13f3482cb99e3237b38726710f4a793432b1c5ff", size = 2222695 }, + { url = "https://files.pythonhosted.org/packages/a2/09/a27fb36cca3fc01700687cc45dae7a6a5f8eeb5f657b9f710f788748e10d/kiwisolver-1.4.8-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:641f2ddf9358c80faa22e22eb4c9f54bd3f0e442e038728f500e3b978d00aa7d", size = 2370802 }, + { url = "https://files.pythonhosted.org/packages/3d/c3/ba0a0346db35fe4dc1f2f2cf8b99362fbb922d7562e5f911f7ce7a7b60fa/kiwisolver-1.4.8-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:d561d2d8883e0819445cfe58d7ddd673e4015c3c57261d7bdcd3710d0d14005c", size = 2334646 }, + { url = "https://files.pythonhosted.org/packages/41/52/942cf69e562f5ed253ac67d5c92a693745f0bed3c81f49fc0cbebe4d6b00/kiwisolver-1.4.8-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:1732e065704b47c9afca7ffa272f845300a4eb959276bf6970dc07265e73b605", size = 2467260 }, + { url = "https://files.pythonhosted.org/packages/32/26/2d9668f30d8a494b0411d4d7d4ea1345ba12deb6a75274d58dd6ea01e951/kiwisolver-1.4.8-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:bcb1ebc3547619c3b58a39e2448af089ea2ef44b37988caf432447374941574e", size = 2288633 }, + { url = "https://files.pythonhosted.org/packages/98/99/0dd05071654aa44fe5d5e350729961e7bb535372935a45ac89a8924316e6/kiwisolver-1.4.8-cp310-cp310-win_amd64.whl", hash = "sha256:89c107041f7b27844179ea9c85d6da275aa55ecf28413e87624d033cf1f6b751", size = 71885 }, + { url = "https://files.pythonhosted.org/packages/6c/fc/822e532262a97442989335394d441cd1d0448c2e46d26d3e04efca84df22/kiwisolver-1.4.8-cp310-cp310-win_arm64.whl", hash = "sha256:b5773efa2be9eb9fcf5415ea3ab70fc785d598729fd6057bea38d539ead28271", size = 65175 }, + { url = "https://files.pythonhosted.org/packages/da/ed/c913ee28936c371418cb167b128066ffb20bbf37771eecc2c97edf8a6e4c/kiwisolver-1.4.8-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:a4d3601908c560bdf880f07d94f31d734afd1bb71e96585cace0e38ef44c6d84", size = 124635 }, + { url = "https://files.pythonhosted.org/packages/4c/45/4a7f896f7467aaf5f56ef093d1f329346f3b594e77c6a3c327b2d415f521/kiwisolver-1.4.8-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:856b269c4d28a5c0d5e6c1955ec36ebfd1651ac00e1ce0afa3e28da95293b561", size = 66717 }, + { url = "https://files.pythonhosted.org/packages/5f/b4/c12b3ac0852a3a68f94598d4c8d569f55361beef6159dce4e7b624160da2/kiwisolver-1.4.8-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:c2b9a96e0f326205af81a15718a9073328df1173a2619a68553decb7097fd5d7", size = 65413 }, + { url = "https://files.pythonhosted.org/packages/a9/98/1df4089b1ed23d83d410adfdc5947245c753bddfbe06541c4aae330e9e70/kiwisolver-1.4.8-cp311-cp311-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c5020c83e8553f770cb3b5fc13faac40f17e0b205bd237aebd21d53d733adb03", size = 1343994 }, + { url = "https://files.pythonhosted.org/packages/8d/bf/b4b169b050c8421a7c53ea1ea74e4ef9c335ee9013216c558a047f162d20/kiwisolver-1.4.8-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:dace81d28c787956bfbfbbfd72fdcef014f37d9b48830829e488fdb32b49d954", size = 1434804 }, + { url = "https://files.pythonhosted.org/packages/66/5a/e13bd341fbcf73325ea60fdc8af752addf75c5079867af2e04cc41f34434/kiwisolver-1.4.8-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:11e1022b524bd48ae56c9b4f9296bce77e15a2e42a502cceba602f804b32bb79", size = 1450690 }, + { url = "https://files.pythonhosted.org/packages/9b/4f/5955dcb376ba4a830384cc6fab7d7547bd6759fe75a09564910e9e3bb8ea/kiwisolver-1.4.8-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3b9b4d2892fefc886f30301cdd80debd8bb01ecdf165a449eb6e78f79f0fabd6", size = 1376839 }, + { url = "https://files.pythonhosted.org/packages/3a/97/5edbed69a9d0caa2e4aa616ae7df8127e10f6586940aa683a496c2c280b9/kiwisolver-1.4.8-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3a96c0e790ee875d65e340ab383700e2b4891677b7fcd30a699146f9384a2bb0", size = 1435109 }, + { url = "https://files.pythonhosted.org/packages/13/fc/e756382cb64e556af6c1809a1bbb22c141bbc2445049f2da06b420fe52bf/kiwisolver-1.4.8-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:23454ff084b07ac54ca8be535f4174170c1094a4cff78fbae4f73a4bcc0d4dab", size = 2245269 }, + { url = "https://files.pythonhosted.org/packages/76/15/e59e45829d7f41c776d138245cabae6515cb4eb44b418f6d4109c478b481/kiwisolver-1.4.8-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:87b287251ad6488e95b4f0b4a79a6d04d3ea35fde6340eb38fbd1ca9cd35bbbc", size = 2393468 }, + { url = "https://files.pythonhosted.org/packages/e9/39/483558c2a913ab8384d6e4b66a932406f87c95a6080112433da5ed668559/kiwisolver-1.4.8-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:b21dbe165081142b1232a240fc6383fd32cdd877ca6cc89eab93e5f5883e1c25", size = 2355394 }, + { url = "https://files.pythonhosted.org/packages/01/aa/efad1fbca6570a161d29224f14b082960c7e08268a133fe5dc0f6906820e/kiwisolver-1.4.8-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:768cade2c2df13db52475bd28d3a3fac8c9eff04b0e9e2fda0f3760f20b3f7fc", size = 2490901 }, + { url = "https://files.pythonhosted.org/packages/c9/4f/15988966ba46bcd5ab9d0c8296914436720dd67fca689ae1a75b4ec1c72f/kiwisolver-1.4.8-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:d47cfb2650f0e103d4bf68b0b5804c68da97272c84bb12850d877a95c056bd67", size = 2312306 }, + { url = "https://files.pythonhosted.org/packages/2d/27/bdf1c769c83f74d98cbc34483a972f221440703054894a37d174fba8aa68/kiwisolver-1.4.8-cp311-cp311-win_amd64.whl", hash = "sha256:ed33ca2002a779a2e20eeb06aea7721b6e47f2d4b8a8ece979d8ba9e2a167e34", size = 71966 }, + { url = "https://files.pythonhosted.org/packages/4a/c9/9642ea855604aeb2968a8e145fc662edf61db7632ad2e4fb92424be6b6c0/kiwisolver-1.4.8-cp311-cp311-win_arm64.whl", hash = "sha256:16523b40aab60426ffdebe33ac374457cf62863e330a90a0383639ce14bf44b2", size = 65311 }, + { url = "https://files.pythonhosted.org/packages/fc/aa/cea685c4ab647f349c3bc92d2daf7ae34c8e8cf405a6dcd3a497f58a2ac3/kiwisolver-1.4.8-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:d6af5e8815fd02997cb6ad9bbed0ee1e60014438ee1a5c2444c96f87b8843502", size = 124152 }, + { url = "https://files.pythonhosted.org/packages/c5/0b/8db6d2e2452d60d5ebc4ce4b204feeb16176a851fd42462f66ade6808084/kiwisolver-1.4.8-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:bade438f86e21d91e0cf5dd7c0ed00cda0f77c8c1616bd83f9fc157fa6760d31", size = 66555 }, + { url = "https://files.pythonhosted.org/packages/60/26/d6a0db6785dd35d3ba5bf2b2df0aedc5af089962c6eb2cbf67a15b81369e/kiwisolver-1.4.8-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:b83dc6769ddbc57613280118fb4ce3cd08899cc3369f7d0e0fab518a7cf37fdb", size = 65067 }, + { url = "https://files.pythonhosted.org/packages/c9/ed/1d97f7e3561e09757a196231edccc1bcf59d55ddccefa2afc9c615abd8e0/kiwisolver-1.4.8-cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:111793b232842991be367ed828076b03d96202c19221b5ebab421ce8bcad016f", size = 1378443 }, + { url = "https://files.pythonhosted.org/packages/29/61/39d30b99954e6b46f760e6289c12fede2ab96a254c443639052d1b573fbc/kiwisolver-1.4.8-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:257af1622860e51b1a9d0ce387bf5c2c4f36a90594cb9514f55b074bcc787cfc", size = 1472728 }, + { url = "https://files.pythonhosted.org/packages/0c/3e/804163b932f7603ef256e4a715e5843a9600802bb23a68b4e08c8c0ff61d/kiwisolver-1.4.8-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:69b5637c3f316cab1ec1c9a12b8c5f4750a4c4b71af9157645bf32830e39c03a", size = 1478388 }, + { url = "https://files.pythonhosted.org/packages/8a/9e/60eaa75169a154700be74f875a4d9961b11ba048bef315fbe89cb6999056/kiwisolver-1.4.8-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:782bb86f245ec18009890e7cb8d13a5ef54dcf2ebe18ed65f795e635a96a1c6a", size = 1413849 }, + { url = "https://files.pythonhosted.org/packages/bc/b3/9458adb9472e61a998c8c4d95cfdfec91c73c53a375b30b1428310f923e4/kiwisolver-1.4.8-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cc978a80a0db3a66d25767b03688f1147a69e6237175c0f4ffffaaedf744055a", size = 1475533 }, + { url = "https://files.pythonhosted.org/packages/e4/7a/0a42d9571e35798de80aef4bb43a9b672aa7f8e58643d7bd1950398ffb0a/kiwisolver-1.4.8-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:36dbbfd34838500a31f52c9786990d00150860e46cd5041386f217101350f0d3", size = 2268898 }, + { url = "https://files.pythonhosted.org/packages/d9/07/1255dc8d80271400126ed8db35a1795b1a2c098ac3a72645075d06fe5c5d/kiwisolver-1.4.8-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:eaa973f1e05131de5ff3569bbba7f5fd07ea0595d3870ed4a526d486fe57fa1b", size = 2425605 }, + { url = "https://files.pythonhosted.org/packages/84/df/5a3b4cf13780ef6f6942df67b138b03b7e79e9f1f08f57c49957d5867f6e/kiwisolver-1.4.8-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:a66f60f8d0c87ab7f59b6fb80e642ebb29fec354a4dfad687ca4092ae69d04f4", size = 2375801 }, + { url = "https://files.pythonhosted.org/packages/8f/10/2348d068e8b0f635c8c86892788dac7a6b5c0cb12356620ab575775aad89/kiwisolver-1.4.8-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:858416b7fb777a53f0c59ca08190ce24e9abbd3cffa18886a5781b8e3e26f65d", size = 2520077 }, + { url = "https://files.pythonhosted.org/packages/32/d8/014b89fee5d4dce157d814303b0fce4d31385a2af4c41fed194b173b81ac/kiwisolver-1.4.8-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:085940635c62697391baafaaeabdf3dd7a6c3643577dde337f4d66eba021b2b8", size = 2338410 }, + { url = "https://files.pythonhosted.org/packages/bd/72/dfff0cc97f2a0776e1c9eb5bef1ddfd45f46246c6533b0191887a427bca5/kiwisolver-1.4.8-cp312-cp312-win_amd64.whl", hash = "sha256:01c3d31902c7db5fb6182832713d3b4122ad9317c2c5877d0539227d96bb2e50", size = 71853 }, + { url = "https://files.pythonhosted.org/packages/dc/85/220d13d914485c0948a00f0b9eb419efaf6da81b7d72e88ce2391f7aed8d/kiwisolver-1.4.8-cp312-cp312-win_arm64.whl", hash = "sha256:a3c44cb68861de93f0c4a8175fbaa691f0aa22550c331fefef02b618a9dcb476", size = 65424 }, + { url = "https://files.pythonhosted.org/packages/79/b3/e62464a652f4f8cd9006e13d07abad844a47df1e6537f73ddfbf1bc997ec/kiwisolver-1.4.8-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:1c8ceb754339793c24aee1c9fb2485b5b1f5bb1c2c214ff13368431e51fc9a09", size = 124156 }, + { url = "https://files.pythonhosted.org/packages/8d/2d/f13d06998b546a2ad4f48607a146e045bbe48030774de29f90bdc573df15/kiwisolver-1.4.8-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:54a62808ac74b5e55a04a408cda6156f986cefbcf0ada13572696b507cc92fa1", size = 66555 }, + { url = "https://files.pythonhosted.org/packages/59/e3/b8bd14b0a54998a9fd1e8da591c60998dc003618cb19a3f94cb233ec1511/kiwisolver-1.4.8-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:68269e60ee4929893aad82666821aaacbd455284124817af45c11e50a4b42e3c", size = 65071 }, + { url = "https://files.pythonhosted.org/packages/f0/1c/6c86f6d85ffe4d0ce04228d976f00674f1df5dc893bf2dd4f1928748f187/kiwisolver-1.4.8-cp313-cp313-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:34d142fba9c464bc3bbfeff15c96eab0e7310343d6aefb62a79d51421fcc5f1b", size = 1378053 }, + { url = "https://files.pythonhosted.org/packages/4e/b9/1c6e9f6dcb103ac5cf87cb695845f5fa71379021500153566d8a8a9fc291/kiwisolver-1.4.8-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3ddc373e0eef45b59197de815b1b28ef89ae3955e7722cc9710fb91cd77b7f47", size = 1472278 }, + { url = "https://files.pythonhosted.org/packages/ee/81/aca1eb176de671f8bda479b11acdc42c132b61a2ac861c883907dde6debb/kiwisolver-1.4.8-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:77e6f57a20b9bd4e1e2cedda4d0b986ebd0216236f0106e55c28aea3d3d69b16", size = 1478139 }, + { url = "https://files.pythonhosted.org/packages/49/f4/e081522473671c97b2687d380e9e4c26f748a86363ce5af48b4a28e48d06/kiwisolver-1.4.8-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:08e77738ed7538f036cd1170cbed942ef749137b1311fa2bbe2a7fda2f6bf3cc", size = 1413517 }, + { url = "https://files.pythonhosted.org/packages/8f/e9/6a7d025d8da8c4931522922cd706105aa32b3291d1add8c5427cdcd66e63/kiwisolver-1.4.8-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a5ce1e481a74b44dd5e92ff03ea0cb371ae7a0268318e202be06c8f04f4f1246", size = 1474952 }, + { url = "https://files.pythonhosted.org/packages/82/13/13fa685ae167bee5d94b415991c4fc7bb0a1b6ebea6e753a87044b209678/kiwisolver-1.4.8-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:fc2ace710ba7c1dfd1a3b42530b62b9ceed115f19a1656adefce7b1782a37794", size = 2269132 }, + { url = "https://files.pythonhosted.org/packages/ef/92/bb7c9395489b99a6cb41d502d3686bac692586db2045adc19e45ee64ed23/kiwisolver-1.4.8-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:3452046c37c7692bd52b0e752b87954ef86ee2224e624ef7ce6cb21e8c41cc1b", size = 2425997 }, + { url = "https://files.pythonhosted.org/packages/ed/12/87f0e9271e2b63d35d0d8524954145837dd1a6c15b62a2d8c1ebe0f182b4/kiwisolver-1.4.8-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:7e9a60b50fe8b2ec6f448fe8d81b07e40141bfced7f896309df271a0b92f80f3", size = 2376060 }, + { url = "https://files.pythonhosted.org/packages/02/6e/c8af39288edbce8bf0fa35dee427b082758a4b71e9c91ef18fa667782138/kiwisolver-1.4.8-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:918139571133f366e8362fa4a297aeba86c7816b7ecf0bc79168080e2bd79957", size = 2520471 }, + { url = "https://files.pythonhosted.org/packages/13/78/df381bc7b26e535c91469f77f16adcd073beb3e2dd25042efd064af82323/kiwisolver-1.4.8-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e063ef9f89885a1d68dd8b2e18f5ead48653176d10a0e324e3b0030e3a69adeb", size = 2338793 }, + { url = "https://files.pythonhosted.org/packages/d0/dc/c1abe38c37c071d0fc71c9a474fd0b9ede05d42f5a458d584619cfd2371a/kiwisolver-1.4.8-cp313-cp313-win_amd64.whl", hash = "sha256:a17b7c4f5b2c51bb68ed379defd608a03954a1845dfed7cc0117f1cc8a9b7fd2", size = 71855 }, + { url = "https://files.pythonhosted.org/packages/a0/b6/21529d595b126ac298fdd90b705d87d4c5693de60023e0efcb4f387ed99e/kiwisolver-1.4.8-cp313-cp313-win_arm64.whl", hash = "sha256:3cd3bc628b25f74aedc6d374d5babf0166a92ff1317f46267f12d2ed54bc1d30", size = 65430 }, + { url = "https://files.pythonhosted.org/packages/34/bd/b89380b7298e3af9b39f49334e3e2a4af0e04819789f04b43d560516c0c8/kiwisolver-1.4.8-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:370fd2df41660ed4e26b8c9d6bbcad668fbe2560462cba151a721d49e5b6628c", size = 126294 }, + { url = "https://files.pythonhosted.org/packages/83/41/5857dc72e5e4148eaac5aa76e0703e594e4465f8ab7ec0fc60e3a9bb8fea/kiwisolver-1.4.8-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:84a2f830d42707de1d191b9490ac186bf7997a9495d4e9072210a1296345f7dc", size = 67736 }, + { url = "https://files.pythonhosted.org/packages/e1/d1/be059b8db56ac270489fb0b3297fd1e53d195ba76e9bbb30e5401fa6b759/kiwisolver-1.4.8-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:7a3ad337add5148cf51ce0b55642dc551c0b9d6248458a757f98796ca7348712", size = 66194 }, + { url = "https://files.pythonhosted.org/packages/e1/83/4b73975f149819eb7dcf9299ed467eba068ecb16439a98990dcb12e63fdd/kiwisolver-1.4.8-cp313-cp313t-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7506488470f41169b86d8c9aeff587293f530a23a23a49d6bc64dab66bedc71e", size = 1465942 }, + { url = "https://files.pythonhosted.org/packages/c7/2c/30a5cdde5102958e602c07466bce058b9d7cb48734aa7a4327261ac8e002/kiwisolver-1.4.8-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2f0121b07b356a22fb0414cec4666bbe36fd6d0d759db3d37228f496ed67c880", size = 1595341 }, + { url = "https://files.pythonhosted.org/packages/ff/9b/1e71db1c000385aa069704f5990574b8244cce854ecd83119c19e83c9586/kiwisolver-1.4.8-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d6d6bd87df62c27d4185de7c511c6248040afae67028a8a22012b010bc7ad062", size = 1598455 }, + { url = "https://files.pythonhosted.org/packages/85/92/c8fec52ddf06231b31cbb779af77e99b8253cd96bd135250b9498144c78b/kiwisolver-1.4.8-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:291331973c64bb9cce50bbe871fb2e675c4331dab4f31abe89f175ad7679a4d7", size = 1522138 }, + { url = "https://files.pythonhosted.org/packages/0b/51/9eb7e2cd07a15d8bdd976f6190c0164f92ce1904e5c0c79198c4972926b7/kiwisolver-1.4.8-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:893f5525bb92d3d735878ec00f781b2de998333659507d29ea4466208df37bed", size = 1582857 }, + { url = "https://files.pythonhosted.org/packages/0f/95/c5a00387a5405e68ba32cc64af65ce881a39b98d73cc394b24143bebc5b8/kiwisolver-1.4.8-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:b47a465040146981dc9db8647981b8cb96366fbc8d452b031e4f8fdffec3f26d", size = 2293129 }, + { url = "https://files.pythonhosted.org/packages/44/83/eeb7af7d706b8347548313fa3a3a15931f404533cc54fe01f39e830dd231/kiwisolver-1.4.8-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:99cea8b9dd34ff80c521aef46a1dddb0dcc0283cf18bde6d756f1e6f31772165", size = 2421538 }, + { url = "https://files.pythonhosted.org/packages/05/f9/27e94c1b3eb29e6933b6986ffc5fa1177d2cd1f0c8efc5f02c91c9ac61de/kiwisolver-1.4.8-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:151dffc4865e5fe6dafce5480fab84f950d14566c480c08a53c663a0020504b6", size = 2390661 }, + { url = "https://files.pythonhosted.org/packages/d9/d4/3c9735faa36ac591a4afcc2980d2691000506050b7a7e80bcfe44048daa7/kiwisolver-1.4.8-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:577facaa411c10421314598b50413aa1ebcf5126f704f1e5d72d7e4e9f020d90", size = 2546710 }, + { url = "https://files.pythonhosted.org/packages/4c/fa/be89a49c640930180657482a74970cdcf6f7072c8d2471e1babe17a222dc/kiwisolver-1.4.8-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:be4816dc51c8a471749d664161b434912eee82f2ea66bd7628bd14583a833e85", size = 2349213 }, + { url = "https://files.pythonhosted.org/packages/1f/f9/ae81c47a43e33b93b0a9819cac6723257f5da2a5a60daf46aa5c7226ea85/kiwisolver-1.4.8-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:e7a019419b7b510f0f7c9dceff8c5eae2392037eae483a7f9162625233802b0a", size = 60403 }, + { url = "https://files.pythonhosted.org/packages/58/ca/f92b5cb6f4ce0c1ebfcfe3e2e42b96917e16f7090e45b21102941924f18f/kiwisolver-1.4.8-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:286b18e86682fd2217a48fc6be6b0f20c1d0ed10958d8dc53453ad58d7be0bf8", size = 58657 }, + { url = "https://files.pythonhosted.org/packages/80/28/ae0240f732f0484d3a4dc885d055653c47144bdf59b670aae0ec3c65a7c8/kiwisolver-1.4.8-pp310-pypy310_pp73-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4191ee8dfd0be1c3666ccbac178c5a05d5f8d689bbe3fc92f3c4abec817f8fe0", size = 84948 }, + { url = "https://files.pythonhosted.org/packages/5d/eb/78d50346c51db22c7203c1611f9b513075f35c4e0e4877c5dde378d66043/kiwisolver-1.4.8-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7cd2785b9391f2873ad46088ed7599a6a71e762e1ea33e87514b1a441ed1da1c", size = 81186 }, + { url = "https://files.pythonhosted.org/packages/43/f8/7259f18c77adca88d5f64f9a522792e178b2691f3748817a8750c2d216ef/kiwisolver-1.4.8-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c07b29089b7ba090b6f1a669f1411f27221c3662b3a1b7010e67b59bb5a6f10b", size = 80279 }, + { url = "https://files.pythonhosted.org/packages/3a/1d/50ad811d1c5dae091e4cf046beba925bcae0a610e79ae4c538f996f63ed5/kiwisolver-1.4.8-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:65ea09a5a3faadd59c2ce96dc7bf0f364986a315949dc6374f04396b0d60e09b", size = 71762 }, +] + +[[package]] +name = "markdown-it-py" +version = "3.0.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "mdurl", marker = "python_full_version >= '3.10'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/38/71/3b932df36c1a044d397a1f92d1cf91ee0a503d91e470cbd670aa66b07ed0/markdown-it-py-3.0.0.tar.gz", hash = "sha256:e3f60a94fa066dc52ec76661e37c851cb232d92f9886b15cb560aaada2df8feb", size = 74596 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/42/d7/1ec15b46af6af88f19b8e5ffea08fa375d433c998b8a7639e76935c14f1f/markdown_it_py-3.0.0-py3-none-any.whl", hash = "sha256:355216845c60bd96232cd8d8c40e8f9765cc86f46880e43a8fd22dc1a1a8cab1", size = 87528 }, +] + +[[package]] +name = "markupsafe" +version = "2.1.5" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version == '3.8.*'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine != 'aarch64' and platform_machine != 'arm64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'aarch64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'arm64'", + "python_full_version < '3.7.1'", +] +sdist = { url = "https://files.pythonhosted.org/packages/87/5b/aae44c6655f3801e81aa3eef09dbbf012431987ba564d7231722f68df02d/MarkupSafe-2.1.5.tar.gz", hash = "sha256:d283d37a890ba4c1ae73ffadf8046435c76e7bc2247bbb63c00bd1a709c6544b", size = 19384 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e4/54/ad5eb37bf9d51800010a74e4665425831a9db4e7c4e0fde4352e391e808e/MarkupSafe-2.1.5-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:a17a92de5231666cfbe003f0e4b9b3a7ae3afb1ec2845aadc2bacc93ff85febc", size = 18206 }, + { url = "https://files.pythonhosted.org/packages/6a/4a/a4d49415e600bacae038c67f9fecc1d5433b9d3c71a4de6f33537b89654c/MarkupSafe-2.1.5-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:72b6be590cc35924b02c78ef34b467da4ba07e4e0f0454a2c5907f473fc50ce5", size = 14079 }, + { url = "https://files.pythonhosted.org/packages/0a/7b/85681ae3c33c385b10ac0f8dd025c30af83c78cec1c37a6aa3b55e67f5ec/MarkupSafe-2.1.5-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e61659ba32cf2cf1481e575d0462554625196a1f2fc06a1c777d3f48e8865d46", size = 26620 }, + { url = "https://files.pythonhosted.org/packages/7c/52/2b1b570f6b8b803cef5ac28fdf78c0da318916c7d2fe9402a84d591b394c/MarkupSafe-2.1.5-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2174c595a0d73a3080ca3257b40096db99799265e1c27cc5a610743acd86d62f", size = 25818 }, + { url = "https://files.pythonhosted.org/packages/29/fe/a36ba8c7ca55621620b2d7c585313efd10729e63ef81e4e61f52330da781/MarkupSafe-2.1.5-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ae2ad8ae6ebee9d2d94b17fb62763125f3f374c25618198f40cbb8b525411900", size = 25493 }, + { url = "https://files.pythonhosted.org/packages/60/ae/9c60231cdfda003434e8bd27282b1f4e197ad5a710c14bee8bea8a9ca4f0/MarkupSafe-2.1.5-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:075202fa5b72c86ad32dc7d0b56024ebdbcf2048c0ba09f1cde31bfdd57bcfff", size = 30630 }, + { url = "https://files.pythonhosted.org/packages/65/dc/1510be4d179869f5dafe071aecb3f1f41b45d37c02329dfba01ff59e5ac5/MarkupSafe-2.1.5-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:598e3276b64aff0e7b3451b72e94fa3c238d452e7ddcd893c3ab324717456bad", size = 29745 }, + { url = "https://files.pythonhosted.org/packages/30/39/8d845dd7d0b0613d86e0ef89549bfb5f61ed781f59af45fc96496e897f3a/MarkupSafe-2.1.5-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:fce659a462a1be54d2ffcacea5e3ba2d74daa74f30f5f143fe0c58636e355fdd", size = 30021 }, + { url = "https://files.pythonhosted.org/packages/c7/5c/356a6f62e4f3c5fbf2602b4771376af22a3b16efa74eb8716fb4e328e01e/MarkupSafe-2.1.5-cp310-cp310-win32.whl", hash = "sha256:d9fad5155d72433c921b782e58892377c44bd6252b5af2f67f16b194987338a4", size = 16659 }, + { url = "https://files.pythonhosted.org/packages/69/48/acbf292615c65f0604a0c6fc402ce6d8c991276e16c80c46a8f758fbd30c/MarkupSafe-2.1.5-cp310-cp310-win_amd64.whl", hash = "sha256:bf50cd79a75d181c9181df03572cdce0fbb75cc353bc350712073108cba98de5", size = 17213 }, + { url = "https://files.pythonhosted.org/packages/11/e7/291e55127bb2ae67c64d66cef01432b5933859dfb7d6949daa721b89d0b3/MarkupSafe-2.1.5-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:629ddd2ca402ae6dbedfceeba9c46d5f7b2a61d9749597d4307f943ef198fc1f", size = 18219 }, + { url = "https://files.pythonhosted.org/packages/6b/cb/aed7a284c00dfa7c0682d14df85ad4955a350a21d2e3b06d8240497359bf/MarkupSafe-2.1.5-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:5b7b716f97b52c5a14bffdf688f971b2d5ef4029127f1ad7a513973cfd818df2", size = 14098 }, + { url = "https://files.pythonhosted.org/packages/1c/cf/35fe557e53709e93feb65575c93927942087e9b97213eabc3fe9d5b25a55/MarkupSafe-2.1.5-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6ec585f69cec0aa07d945b20805be741395e28ac1627333b1c5b0105962ffced", size = 29014 }, + { url = "https://files.pythonhosted.org/packages/97/18/c30da5e7a0e7f4603abfc6780574131221d9148f323752c2755d48abad30/MarkupSafe-2.1.5-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b91c037585eba9095565a3556f611e3cbfaa42ca1e865f7b8015fe5c7336d5a5", size = 28220 }, + { url = "https://files.pythonhosted.org/packages/0c/40/2e73e7d532d030b1e41180807a80d564eda53babaf04d65e15c1cf897e40/MarkupSafe-2.1.5-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7502934a33b54030eaf1194c21c692a534196063db72176b0c4028e140f8f32c", size = 27756 }, + { url = "https://files.pythonhosted.org/packages/18/46/5dca760547e8c59c5311b332f70605d24c99d1303dd9a6e1fc3ed0d73561/MarkupSafe-2.1.5-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:0e397ac966fdf721b2c528cf028494e86172b4feba51d65f81ffd65c63798f3f", size = 33988 }, + { url = "https://files.pythonhosted.org/packages/6d/c5/27febe918ac36397919cd4a67d5579cbbfa8da027fa1238af6285bb368ea/MarkupSafe-2.1.5-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:c061bb86a71b42465156a3ee7bd58c8c2ceacdbeb95d05a99893e08b8467359a", size = 32718 }, + { url = "https://files.pythonhosted.org/packages/f8/81/56e567126a2c2bc2684d6391332e357589a96a76cb9f8e5052d85cb0ead8/MarkupSafe-2.1.5-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:3a57fdd7ce31c7ff06cdfbf31dafa96cc533c21e443d57f5b1ecc6cdc668ec7f", size = 33317 }, + { url = "https://files.pythonhosted.org/packages/00/0b/23f4b2470accb53285c613a3ab9ec19dc944eaf53592cb6d9e2af8aa24cc/MarkupSafe-2.1.5-cp311-cp311-win32.whl", hash = "sha256:397081c1a0bfb5124355710fe79478cdbeb39626492b15d399526ae53422b906", size = 16670 }, + { url = "https://files.pythonhosted.org/packages/b7/a2/c78a06a9ec6d04b3445a949615c4c7ed86a0b2eb68e44e7541b9d57067cc/MarkupSafe-2.1.5-cp311-cp311-win_amd64.whl", hash = "sha256:2b7c57a4dfc4f16f7142221afe5ba4e093e09e728ca65c51f5620c9aaeb9a617", size = 17224 }, + { url = "https://files.pythonhosted.org/packages/53/bd/583bf3e4c8d6a321938c13f49d44024dbe5ed63e0a7ba127e454a66da974/MarkupSafe-2.1.5-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:8dec4936e9c3100156f8a2dc89c4b88d5c435175ff03413b443469c7c8c5f4d1", size = 18215 }, + { url = "https://files.pythonhosted.org/packages/48/d6/e7cd795fc710292c3af3a06d80868ce4b02bfbbf370b7cee11d282815a2a/MarkupSafe-2.1.5-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:3c6b973f22eb18a789b1460b4b91bf04ae3f0c4234a0a6aa6b0a92f6f7b951d4", size = 14069 }, + { url = "https://files.pythonhosted.org/packages/51/b5/5d8ec796e2a08fc814a2c7d2584b55f889a55cf17dd1a90f2beb70744e5c/MarkupSafe-2.1.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ac07bad82163452a6884fe8fa0963fb98c2346ba78d779ec06bd7a6262132aee", size = 29452 }, + { url = "https://files.pythonhosted.org/packages/0a/0d/2454f072fae3b5a137c119abf15465d1771319dfe9e4acbb31722a0fff91/MarkupSafe-2.1.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f5dfb42c4604dddc8e4305050aa6deb084540643ed5804d7455b5df8fe16f5e5", size = 28462 }, + { url = "https://files.pythonhosted.org/packages/2d/75/fd6cb2e68780f72d47e6671840ca517bda5ef663d30ada7616b0462ad1e3/MarkupSafe-2.1.5-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ea3d8a3d18833cf4304cd2fc9cbb1efe188ca9b5efef2bdac7adc20594a0e46b", size = 27869 }, + { url = "https://files.pythonhosted.org/packages/b0/81/147c477391c2750e8fc7705829f7351cf1cd3be64406edcf900dc633feb2/MarkupSafe-2.1.5-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:d050b3361367a06d752db6ead6e7edeb0009be66bc3bae0ee9d97fb326badc2a", size = 33906 }, + { url = "https://files.pythonhosted.org/packages/8b/ff/9a52b71839d7a256b563e85d11050e307121000dcebc97df120176b3ad93/MarkupSafe-2.1.5-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:bec0a414d016ac1a18862a519e54b2fd0fc8bbfd6890376898a6c0891dd82e9f", size = 32296 }, + { url = "https://files.pythonhosted.org/packages/88/07/2dc76aa51b481eb96a4c3198894f38b480490e834479611a4053fbf08623/MarkupSafe-2.1.5-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:58c98fee265677f63a4385256a6d7683ab1832f3ddd1e66fe948d5880c21a169", size = 33038 }, + { url = "https://files.pythonhosted.org/packages/96/0c/620c1fb3661858c0e37eb3cbffd8c6f732a67cd97296f725789679801b31/MarkupSafe-2.1.5-cp312-cp312-win32.whl", hash = "sha256:8590b4ae07a35970728874632fed7bd57b26b0102df2d2b233b6d9d82f6c62ad", size = 16572 }, + { url = "https://files.pythonhosted.org/packages/3f/14/c3554d512d5f9100a95e737502f4a2323a1959f6d0d01e0d0997b35f7b10/MarkupSafe-2.1.5-cp312-cp312-win_amd64.whl", hash = "sha256:823b65d8706e32ad2df51ed89496147a42a2a6e01c13cfb6ffb8b1e92bc910bb", size = 17127 }, + { url = "https://files.pythonhosted.org/packages/a7/88/a940e11827ea1c136a34eca862486178294ae841164475b9ab216b80eb8e/MarkupSafe-2.1.5-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:c8b29db45f8fe46ad280a7294f5c3ec36dbac9491f2d1c17345be8e69cc5928f", size = 13982 }, + { url = "https://files.pythonhosted.org/packages/cb/06/0d28bd178db529c5ac762a625c335a9168a7a23f280b4db9c95e97046145/MarkupSafe-2.1.5-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ec6a563cff360b50eed26f13adc43e61bc0c04d94b8be985e6fb24b81f6dcfdf", size = 26335 }, + { url = "https://files.pythonhosted.org/packages/4a/1d/c4f5016f87ced614eacc7d5fb85b25bcc0ff53e8f058d069fc8cbfdc3c7a/MarkupSafe-2.1.5-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a549b9c31bec33820e885335b451286e2969a2d9e24879f83fe904a5ce59d70a", size = 25557 }, + { url = "https://files.pythonhosted.org/packages/b3/fb/c18b8c9fbe69e347fdbf782c6478f1bc77f19a830588daa224236678339b/MarkupSafe-2.1.5-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4f11aa001c540f62c6166c7726f71f7573b52c68c31f014c25cc7901deea0b52", size = 25245 }, + { url = "https://files.pythonhosted.org/packages/2f/69/30d29adcf9d1d931c75001dd85001adad7374381c9c2086154d9f6445be6/MarkupSafe-2.1.5-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:7b2e5a267c855eea6b4283940daa6e88a285f5f2a67f2220203786dfa59b37e9", size = 31013 }, + { url = "https://files.pythonhosted.org/packages/3a/03/63498d05bd54278b6ca340099e5b52ffb9cdf2ee4f2d9b98246337e21689/MarkupSafe-2.1.5-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:2d2d793e36e230fd32babe143b04cec8a8b3eb8a3122d2aceb4a371e6b09b8df", size = 30178 }, + { url = "https://files.pythonhosted.org/packages/68/79/11b4fe15124692f8673b603433e47abca199a08ecd2a4851bfbdc97dc62d/MarkupSafe-2.1.5-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:ce409136744f6521e39fd8e2a24c53fa18ad67aa5bc7c2cf83645cce5b5c4e50", size = 30429 }, + { url = "https://files.pythonhosted.org/packages/ed/88/408bdbf292eb86f03201c17489acafae8358ba4e120d92358308c15cea7c/MarkupSafe-2.1.5-cp37-cp37m-win32.whl", hash = "sha256:4096e9de5c6fdf43fb4f04c26fb114f61ef0bf2e5604b6ee3019d51b69e8c371", size = 16633 }, + { url = "https://files.pythonhosted.org/packages/6c/4c/3577a52eea1880538c435176bc85e5b3379b7ab442327ccd82118550758f/MarkupSafe-2.1.5-cp37-cp37m-win_amd64.whl", hash = "sha256:4275d846e41ecefa46e2015117a9f491e57a71ddd59bbead77e904dc02b1bed2", size = 17215 }, + { url = "https://files.pythonhosted.org/packages/f8/ff/2c942a82c35a49df5de3a630ce0a8456ac2969691b230e530ac12314364c/MarkupSafe-2.1.5-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:656f7526c69fac7f600bd1f400991cc282b417d17539a1b228617081106feb4a", size = 18192 }, + { url = "https://files.pythonhosted.org/packages/4f/14/6f294b9c4f969d0c801a4615e221c1e084722ea6114ab2114189c5b8cbe0/MarkupSafe-2.1.5-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:97cafb1f3cbcd3fd2b6fbfb99ae11cdb14deea0736fc2b0952ee177f2b813a46", size = 14072 }, + { url = "https://files.pythonhosted.org/packages/81/d4/fd74714ed30a1dedd0b82427c02fa4deec64f173831ec716da11c51a50aa/MarkupSafe-2.1.5-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1f3fbcb7ef1f16e48246f704ab79d79da8a46891e2da03f8783a5b6fa41a9532", size = 26928 }, + { url = "https://files.pythonhosted.org/packages/c7/bd/50319665ce81bb10e90d1cf76f9e1aa269ea6f7fa30ab4521f14d122a3df/MarkupSafe-2.1.5-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fa9db3f79de01457b03d4f01b34cf91bc0048eb2c3846ff26f66687c2f6d16ab", size = 26106 }, + { url = "https://files.pythonhosted.org/packages/4c/6f/f2b0f675635b05f6afd5ea03c094557bdb8622fa8e673387444fe8d8e787/MarkupSafe-2.1.5-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ffee1f21e5ef0d712f9033568f8344d5da8cc2869dbd08d87c84656e6a2d2f68", size = 25781 }, + { url = "https://files.pythonhosted.org/packages/51/e0/393467cf899b34a9d3678e78961c2c8cdf49fb902a959ba54ece01273fb1/MarkupSafe-2.1.5-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:5dedb4db619ba5a2787a94d877bc8ffc0566f92a01c0ef214865e54ecc9ee5e0", size = 30518 }, + { url = "https://files.pythonhosted.org/packages/f6/02/5437e2ad33047290dafced9df741d9efc3e716b75583bbd73a9984f1b6f7/MarkupSafe-2.1.5-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:30b600cf0a7ac9234b2638fbc0fb6158ba5bdcdf46aeb631ead21248b9affbc4", size = 29669 }, + { url = "https://files.pythonhosted.org/packages/0e/7d/968284145ffd9d726183ed6237c77938c021abacde4e073020f920e060b2/MarkupSafe-2.1.5-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:8dd717634f5a044f860435c1d8c16a270ddf0ef8588d4887037c5028b859b0c3", size = 29933 }, + { url = "https://files.pythonhosted.org/packages/bf/f3/ecb00fc8ab02b7beae8699f34db9357ae49d9f21d4d3de6f305f34fa949e/MarkupSafe-2.1.5-cp38-cp38-win32.whl", hash = "sha256:daa4ee5a243f0f20d528d939d06670a298dd39b1ad5f8a72a4275124a7819eff", size = 16656 }, + { url = "https://files.pythonhosted.org/packages/92/21/357205f03514a49b293e214ac39de01fadd0970a6e05e4bf1ddd0ffd0881/MarkupSafe-2.1.5-cp38-cp38-win_amd64.whl", hash = "sha256:619bc166c4f2de5caa5a633b8b7326fbe98e0ccbfacabd87268a2b15ff73a029", size = 17206 }, + { url = "https://files.pythonhosted.org/packages/0f/31/780bb297db036ba7b7bbede5e1d7f1e14d704ad4beb3ce53fb495d22bc62/MarkupSafe-2.1.5-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:7a68b554d356a91cce1236aa7682dc01df0edba8d043fd1ce607c49dd3c1edcf", size = 18193 }, + { url = "https://files.pythonhosted.org/packages/6c/77/d77701bbef72892affe060cdacb7a2ed7fd68dae3b477a8642f15ad3b132/MarkupSafe-2.1.5-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:db0b55e0f3cc0be60c1f19efdde9a637c32740486004f20d1cff53c3c0ece4d2", size = 14073 }, + { url = "https://files.pythonhosted.org/packages/d9/a7/1e558b4f78454c8a3a0199292d96159eb4d091f983bc35ef258314fe7269/MarkupSafe-2.1.5-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3e53af139f8579a6d5f7b76549125f0d94d7e630761a2111bc431fd820e163b8", size = 26486 }, + { url = "https://files.pythonhosted.org/packages/5f/5a/360da85076688755ea0cceb92472923086993e86b5613bbae9fbc14136b0/MarkupSafe-2.1.5-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:17b950fccb810b3293638215058e432159d2b71005c74371d784862b7e4683f3", size = 25685 }, + { url = "https://files.pythonhosted.org/packages/6a/18/ae5a258e3401f9b8312f92b028c54d7026a97ec3ab20bfaddbdfa7d8cce8/MarkupSafe-2.1.5-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4c31f53cdae6ecfa91a77820e8b151dba54ab528ba65dfd235c80b086d68a465", size = 25338 }, + { url = "https://files.pythonhosted.org/packages/0b/cc/48206bd61c5b9d0129f4d75243b156929b04c94c09041321456fd06a876d/MarkupSafe-2.1.5-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:bff1b4290a66b490a2f4719358c0cdcd9bafb6b8f061e45c7a2460866bf50c2e", size = 30439 }, + { url = "https://files.pythonhosted.org/packages/d1/06/a41c112ab9ffdeeb5f77bc3e331fdadf97fa65e52e44ba31880f4e7f983c/MarkupSafe-2.1.5-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:bc1667f8b83f48511b94671e0e441401371dfd0f0a795c7daa4a3cd1dde55bea", size = 29531 }, + { url = "https://files.pythonhosted.org/packages/02/8c/ab9a463301a50dab04d5472e998acbd4080597abc048166ded5c7aa768c8/MarkupSafe-2.1.5-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:5049256f536511ee3f7e1b3f87d1d1209d327e818e6ae1365e8653d7e3abb6a6", size = 29823 }, + { url = "https://files.pythonhosted.org/packages/bc/29/9bc18da763496b055d8e98ce476c8e718dcfd78157e17f555ce6dd7d0895/MarkupSafe-2.1.5-cp39-cp39-win32.whl", hash = "sha256:00e046b6dd71aa03a41079792f8473dc494d564611a8f89bbbd7cb93295ebdcf", size = 16658 }, + { url = "https://files.pythonhosted.org/packages/f6/f8/4da07de16f10551ca1f640c92b5f316f9394088b183c6a57183df6de5ae4/MarkupSafe-2.1.5-cp39-cp39-win_amd64.whl", hash = "sha256:fa173ec60341d6bb97a89f5ea19c85c5643c1e7dedebc22f5181eb73573142c5", size = 17211 }, +] + +[[package]] +name = "markupsafe" +version = "3.0.2" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", + "python_full_version == '3.10.*'", + "python_full_version == '3.9.*'", +] +sdist = { url = "https://files.pythonhosted.org/packages/b2/97/5d42485e71dfc078108a86d6de8fa46db44a1a9295e89c5d6d4a06e23a62/markupsafe-3.0.2.tar.gz", hash = "sha256:ee55d3edf80167e48ea11a923c7386f4669df67d7994554387f84e7d8b0a2bf0", size = 20537 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/04/90/d08277ce111dd22f77149fd1a5d4653eeb3b3eaacbdfcbae5afb2600eebd/MarkupSafe-3.0.2-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:7e94c425039cde14257288fd61dcfb01963e658efbc0ff54f5306b06054700f8", size = 14357 }, + { url = "https://files.pythonhosted.org/packages/04/e1/6e2194baeae0bca1fae6629dc0cbbb968d4d941469cbab11a3872edff374/MarkupSafe-3.0.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:9e2d922824181480953426608b81967de705c3cef4d1af983af849d7bd619158", size = 12393 }, + { url = "https://files.pythonhosted.org/packages/1d/69/35fa85a8ece0a437493dc61ce0bb6d459dcba482c34197e3efc829aa357f/MarkupSafe-3.0.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:38a9ef736c01fccdd6600705b09dc574584b89bea478200c5fbf112a6b0d5579", size = 21732 }, + { url = "https://files.pythonhosted.org/packages/22/35/137da042dfb4720b638d2937c38a9c2df83fe32d20e8c8f3185dbfef05f7/MarkupSafe-3.0.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bbcb445fa71794da8f178f0f6d66789a28d7319071af7a496d4d507ed566270d", size = 20866 }, + { url = "https://files.pythonhosted.org/packages/29/28/6d029a903727a1b62edb51863232152fd335d602def598dade38996887f0/MarkupSafe-3.0.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:57cb5a3cf367aeb1d316576250f65edec5bb3be939e9247ae594b4bcbc317dfb", size = 20964 }, + { url = "https://files.pythonhosted.org/packages/cc/cd/07438f95f83e8bc028279909d9c9bd39e24149b0d60053a97b2bc4f8aa51/MarkupSafe-3.0.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:3809ede931876f5b2ec92eef964286840ed3540dadf803dd570c3b7e13141a3b", size = 21977 }, + { url = "https://files.pythonhosted.org/packages/29/01/84b57395b4cc062f9c4c55ce0df7d3108ca32397299d9df00fedd9117d3d/MarkupSafe-3.0.2-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:e07c3764494e3776c602c1e78e298937c3315ccc9043ead7e685b7f2b8d47b3c", size = 21366 }, + { url = "https://files.pythonhosted.org/packages/bd/6e/61ebf08d8940553afff20d1fb1ba7294b6f8d279df9fd0c0db911b4bbcfd/MarkupSafe-3.0.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:b424c77b206d63d500bcb69fa55ed8d0e6a3774056bdc4839fc9298a7edca171", size = 21091 }, + { url = "https://files.pythonhosted.org/packages/11/23/ffbf53694e8c94ebd1e7e491de185124277964344733c45481f32ede2499/MarkupSafe-3.0.2-cp310-cp310-win32.whl", hash = "sha256:fcabf5ff6eea076f859677f5f0b6b5c1a51e70a376b0579e0eadef8db48c6b50", size = 15065 }, + { url = "https://files.pythonhosted.org/packages/44/06/e7175d06dd6e9172d4a69a72592cb3f7a996a9c396eee29082826449bbc3/MarkupSafe-3.0.2-cp310-cp310-win_amd64.whl", hash = "sha256:6af100e168aa82a50e186c82875a5893c5597a0c1ccdb0d8b40240b1f28b969a", size = 15514 }, + { url = "https://files.pythonhosted.org/packages/6b/28/bbf83e3f76936960b850435576dd5e67034e200469571be53f69174a2dfd/MarkupSafe-3.0.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:9025b4018f3a1314059769c7bf15441064b2207cb3f065e6ea1e7359cb46db9d", size = 14353 }, + { url = "https://files.pythonhosted.org/packages/6c/30/316d194b093cde57d448a4c3209f22e3046c5bb2fb0820b118292b334be7/MarkupSafe-3.0.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:93335ca3812df2f366e80509ae119189886b0f3c2b81325d39efdb84a1e2ae93", size = 12392 }, + { url = "https://files.pythonhosted.org/packages/f2/96/9cdafba8445d3a53cae530aaf83c38ec64c4d5427d975c974084af5bc5d2/MarkupSafe-3.0.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2cb8438c3cbb25e220c2ab33bb226559e7afb3baec11c4f218ffa7308603c832", size = 23984 }, + { url = "https://files.pythonhosted.org/packages/f1/a4/aefb044a2cd8d7334c8a47d3fb2c9f328ac48cb349468cc31c20b539305f/MarkupSafe-3.0.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a123e330ef0853c6e822384873bef7507557d8e4a082961e1defa947aa59ba84", size = 23120 }, + { url = "https://files.pythonhosted.org/packages/8d/21/5e4851379f88f3fad1de30361db501300d4f07bcad047d3cb0449fc51f8c/MarkupSafe-3.0.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1e084f686b92e5b83186b07e8a17fc09e38fff551f3602b249881fec658d3eca", size = 23032 }, + { url = "https://files.pythonhosted.org/packages/00/7b/e92c64e079b2d0d7ddf69899c98842f3f9a60a1ae72657c89ce2655c999d/MarkupSafe-3.0.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d8213e09c917a951de9d09ecee036d5c7d36cb6cb7dbaece4c71a60d79fb9798", size = 24057 }, + { url = "https://files.pythonhosted.org/packages/f9/ac/46f960ca323037caa0a10662ef97d0a4728e890334fc156b9f9e52bcc4ca/MarkupSafe-3.0.2-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:5b02fb34468b6aaa40dfc198d813a641e3a63b98c2b05a16b9f80b7ec314185e", size = 23359 }, + { url = "https://files.pythonhosted.org/packages/69/84/83439e16197337b8b14b6a5b9c2105fff81d42c2a7c5b58ac7b62ee2c3b1/MarkupSafe-3.0.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:0bff5e0ae4ef2e1ae4fdf2dfd5b76c75e5c2fa4132d05fc1b0dabcd20c7e28c4", size = 23306 }, + { url = "https://files.pythonhosted.org/packages/9a/34/a15aa69f01e2181ed8d2b685c0d2f6655d5cca2c4db0ddea775e631918cd/MarkupSafe-3.0.2-cp311-cp311-win32.whl", hash = "sha256:6c89876f41da747c8d3677a2b540fb32ef5715f97b66eeb0c6b66f5e3ef6f59d", size = 15094 }, + { url = "https://files.pythonhosted.org/packages/da/b8/3a3bd761922d416f3dc5d00bfbed11f66b1ab89a0c2b6e887240a30b0f6b/MarkupSafe-3.0.2-cp311-cp311-win_amd64.whl", hash = "sha256:70a87b411535ccad5ef2f1df5136506a10775d267e197e4cf531ced10537bd6b", size = 15521 }, + { url = "https://files.pythonhosted.org/packages/22/09/d1f21434c97fc42f09d290cbb6350d44eb12f09cc62c9476effdb33a18aa/MarkupSafe-3.0.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:9778bd8ab0a994ebf6f84c2b949e65736d5575320a17ae8984a77fab08db94cf", size = 14274 }, + { url = "https://files.pythonhosted.org/packages/6b/b0/18f76bba336fa5aecf79d45dcd6c806c280ec44538b3c13671d49099fdd0/MarkupSafe-3.0.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:846ade7b71e3536c4e56b386c2a47adf5741d2d8b94ec9dc3e92e5e1ee1e2225", size = 12348 }, + { url = "https://files.pythonhosted.org/packages/e0/25/dd5c0f6ac1311e9b40f4af06c78efde0f3b5cbf02502f8ef9501294c425b/MarkupSafe-3.0.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1c99d261bd2d5f6b59325c92c73df481e05e57f19837bdca8413b9eac4bd8028", size = 24149 }, + { url = "https://files.pythonhosted.org/packages/f3/f0/89e7aadfb3749d0f52234a0c8c7867877876e0a20b60e2188e9850794c17/MarkupSafe-3.0.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e17c96c14e19278594aa4841ec148115f9c7615a47382ecb6b82bd8fea3ab0c8", size = 23118 }, + { url = "https://files.pythonhosted.org/packages/d5/da/f2eeb64c723f5e3777bc081da884b414671982008c47dcc1873d81f625b6/MarkupSafe-3.0.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:88416bd1e65dcea10bc7569faacb2c20ce071dd1f87539ca2ab364bf6231393c", size = 22993 }, + { url = "https://files.pythonhosted.org/packages/da/0e/1f32af846df486dce7c227fe0f2398dc7e2e51d4a370508281f3c1c5cddc/MarkupSafe-3.0.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:2181e67807fc2fa785d0592dc2d6206c019b9502410671cc905d132a92866557", size = 24178 }, + { url = "https://files.pythonhosted.org/packages/c4/f6/bb3ca0532de8086cbff5f06d137064c8410d10779c4c127e0e47d17c0b71/MarkupSafe-3.0.2-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:52305740fe773d09cffb16f8ed0427942901f00adedac82ec8b67752f58a1b22", size = 23319 }, + { url = "https://files.pythonhosted.org/packages/a2/82/8be4c96ffee03c5b4a034e60a31294daf481e12c7c43ab8e34a1453ee48b/MarkupSafe-3.0.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:ad10d3ded218f1039f11a75f8091880239651b52e9bb592ca27de44eed242a48", size = 23352 }, + { url = "https://files.pythonhosted.org/packages/51/ae/97827349d3fcffee7e184bdf7f41cd6b88d9919c80f0263ba7acd1bbcb18/MarkupSafe-3.0.2-cp312-cp312-win32.whl", hash = "sha256:0f4ca02bea9a23221c0182836703cbf8930c5e9454bacce27e767509fa286a30", size = 15097 }, + { url = "https://files.pythonhosted.org/packages/c1/80/a61f99dc3a936413c3ee4e1eecac96c0da5ed07ad56fd975f1a9da5bc630/MarkupSafe-3.0.2-cp312-cp312-win_amd64.whl", hash = "sha256:8e06879fc22a25ca47312fbe7c8264eb0b662f6db27cb2d3bbbc74b1df4b9b87", size = 15601 }, + { url = "https://files.pythonhosted.org/packages/83/0e/67eb10a7ecc77a0c2bbe2b0235765b98d164d81600746914bebada795e97/MarkupSafe-3.0.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:ba9527cdd4c926ed0760bc301f6728ef34d841f405abf9d4f959c478421e4efd", size = 14274 }, + { url = "https://files.pythonhosted.org/packages/2b/6d/9409f3684d3335375d04e5f05744dfe7e9f120062c9857df4ab490a1031a/MarkupSafe-3.0.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f8b3d067f2e40fe93e1ccdd6b2e1d16c43140e76f02fb1319a05cf2b79d99430", size = 12352 }, + { url = "https://files.pythonhosted.org/packages/d2/f5/6eadfcd3885ea85fe2a7c128315cc1bb7241e1987443d78c8fe712d03091/MarkupSafe-3.0.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:569511d3b58c8791ab4c2e1285575265991e6d8f8700c7be0e88f86cb0672094", size = 24122 }, + { url = "https://files.pythonhosted.org/packages/0c/91/96cf928db8236f1bfab6ce15ad070dfdd02ed88261c2afafd4b43575e9e9/MarkupSafe-3.0.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:15ab75ef81add55874e7ab7055e9c397312385bd9ced94920f2802310c930396", size = 23085 }, + { url = "https://files.pythonhosted.org/packages/c2/cf/c9d56af24d56ea04daae7ac0940232d31d5a8354f2b457c6d856b2057d69/MarkupSafe-3.0.2-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f3818cb119498c0678015754eba762e0d61e5b52d34c8b13d770f0719f7b1d79", size = 22978 }, + { url = "https://files.pythonhosted.org/packages/2a/9f/8619835cd6a711d6272d62abb78c033bda638fdc54c4e7f4272cf1c0962b/MarkupSafe-3.0.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:cdb82a876c47801bb54a690c5ae105a46b392ac6099881cdfb9f6e95e4014c6a", size = 24208 }, + { url = "https://files.pythonhosted.org/packages/f9/bf/176950a1792b2cd2102b8ffeb5133e1ed984547b75db47c25a67d3359f77/MarkupSafe-3.0.2-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:cabc348d87e913db6ab4aa100f01b08f481097838bdddf7c7a84b7575b7309ca", size = 23357 }, + { url = "https://files.pythonhosted.org/packages/ce/4f/9a02c1d335caabe5c4efb90e1b6e8ee944aa245c1aaaab8e8a618987d816/MarkupSafe-3.0.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:444dcda765c8a838eaae23112db52f1efaf750daddb2d9ca300bcae1039adc5c", size = 23344 }, + { url = "https://files.pythonhosted.org/packages/ee/55/c271b57db36f748f0e04a759ace9f8f759ccf22b4960c270c78a394f58be/MarkupSafe-3.0.2-cp313-cp313-win32.whl", hash = "sha256:bcf3e58998965654fdaff38e58584d8937aa3096ab5354d493c77d1fdd66d7a1", size = 15101 }, + { url = "https://files.pythonhosted.org/packages/29/88/07df22d2dd4df40aba9f3e402e6dc1b8ee86297dddbad4872bd5e7b0094f/MarkupSafe-3.0.2-cp313-cp313-win_amd64.whl", hash = "sha256:e6a2a455bd412959b57a172ce6328d2dd1f01cb2135efda2e4576e8a23fa3b0f", size = 15603 }, + { url = "https://files.pythonhosted.org/packages/62/6a/8b89d24db2d32d433dffcd6a8779159da109842434f1dd2f6e71f32f738c/MarkupSafe-3.0.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:b5a6b3ada725cea8a5e634536b1b01c30bcdcd7f9c6fff4151548d5bf6b3a36c", size = 14510 }, + { url = "https://files.pythonhosted.org/packages/7a/06/a10f955f70a2e5a9bf78d11a161029d278eeacbd35ef806c3fd17b13060d/MarkupSafe-3.0.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:a904af0a6162c73e3edcb969eeeb53a63ceeb5d8cf642fade7d39e7963a22ddb", size = 12486 }, + { url = "https://files.pythonhosted.org/packages/34/cf/65d4a571869a1a9078198ca28f39fba5fbb910f952f9dbc5220afff9f5e6/MarkupSafe-3.0.2-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4aa4e5faecf353ed117801a068ebab7b7e09ffb6e1d5e412dc852e0da018126c", size = 25480 }, + { url = "https://files.pythonhosted.org/packages/0c/e3/90e9651924c430b885468b56b3d597cabf6d72be4b24a0acd1fa0e12af67/MarkupSafe-3.0.2-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c0ef13eaeee5b615fb07c9a7dadb38eac06a0608b41570d8ade51c56539e509d", size = 23914 }, + { url = "https://files.pythonhosted.org/packages/66/8c/6c7cf61f95d63bb866db39085150df1f2a5bd3335298f14a66b48e92659c/MarkupSafe-3.0.2-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d16a81a06776313e817c951135cf7340a3e91e8c1ff2fac444cfd75fffa04afe", size = 23796 }, + { url = "https://files.pythonhosted.org/packages/bb/35/cbe9238ec3f47ac9a7c8b3df7a808e7cb50fe149dc7039f5f454b3fba218/MarkupSafe-3.0.2-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:6381026f158fdb7c72a168278597a5e3a5222e83ea18f543112b2662a9b699c5", size = 25473 }, + { url = "https://files.pythonhosted.org/packages/e6/32/7621a4382488aa283cc05e8984a9c219abad3bca087be9ec77e89939ded9/MarkupSafe-3.0.2-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:3d79d162e7be8f996986c064d1c7c817f6df3a77fe3d6859f6f9e7be4b8c213a", size = 24114 }, + { url = "https://files.pythonhosted.org/packages/0d/80/0985960e4b89922cb5a0bac0ed39c5b96cbc1a536a99f30e8c220a996ed9/MarkupSafe-3.0.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:131a3c7689c85f5ad20f9f6fb1b866f402c445b220c19fe4308c0b147ccd2ad9", size = 24098 }, + { url = "https://files.pythonhosted.org/packages/82/78/fedb03c7d5380df2427038ec8d973587e90561b2d90cd472ce9254cf348b/MarkupSafe-3.0.2-cp313-cp313t-win32.whl", hash = "sha256:ba8062ed2cf21c07a9e295d5b8a2a5ce678b913b45fdf68c32d95d6c1291e0b6", size = 15208 }, + { url = "https://files.pythonhosted.org/packages/4f/65/6079a46068dfceaeabb5dcad6d674f5f5c61a6fa5673746f42a9f4c233b3/MarkupSafe-3.0.2-cp313-cp313t-win_amd64.whl", hash = "sha256:e444a31f8db13eb18ada366ab3cf45fd4b31e4db1236a4448f68778c1d1a5a2f", size = 15739 }, + { url = "https://files.pythonhosted.org/packages/a7/ea/9b1530c3fdeeca613faeb0fb5cbcf2389d816072fab72a71b45749ef6062/MarkupSafe-3.0.2-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:eaa0a10b7f72326f1372a713e73c3f739b524b3af41feb43e4921cb529f5929a", size = 14344 }, + { url = "https://files.pythonhosted.org/packages/4b/c2/fbdbfe48848e7112ab05e627e718e854d20192b674952d9042ebd8c9e5de/MarkupSafe-3.0.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:48032821bbdf20f5799ff537c7ac3d1fba0ba032cfc06194faffa8cda8b560ff", size = 12389 }, + { url = "https://files.pythonhosted.org/packages/f0/25/7a7c6e4dbd4f867d95d94ca15449e91e52856f6ed1905d58ef1de5e211d0/MarkupSafe-3.0.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1a9d3f5f0901fdec14d8d2f66ef7d035f2157240a433441719ac9a3fba440b13", size = 21607 }, + { url = "https://files.pythonhosted.org/packages/53/8f/f339c98a178f3c1e545622206b40986a4c3307fe39f70ccd3d9df9a9e425/MarkupSafe-3.0.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:88b49a3b9ff31e19998750c38e030fc7bb937398b1f78cfa599aaef92d693144", size = 20728 }, + { url = "https://files.pythonhosted.org/packages/1a/03/8496a1a78308456dbd50b23a385c69b41f2e9661c67ea1329849a598a8f9/MarkupSafe-3.0.2-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:cfad01eed2c2e0c01fd0ecd2ef42c492f7f93902e39a42fc9ee1692961443a29", size = 20826 }, + { url = "https://files.pythonhosted.org/packages/e6/cf/0a490a4bd363048c3022f2f475c8c05582179bb179defcee4766fb3dcc18/MarkupSafe-3.0.2-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:1225beacc926f536dc82e45f8a4d68502949dc67eea90eab715dea3a21c1b5f0", size = 21843 }, + { url = "https://files.pythonhosted.org/packages/19/a3/34187a78613920dfd3cdf68ef6ce5e99c4f3417f035694074beb8848cd77/MarkupSafe-3.0.2-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:3169b1eefae027567d1ce6ee7cae382c57fe26e82775f460f0b2778beaad66c0", size = 21219 }, + { url = "https://files.pythonhosted.org/packages/17/d8/5811082f85bb88410ad7e452263af048d685669bbbfb7b595e8689152498/MarkupSafe-3.0.2-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:eb7972a85c54febfb25b5c4b4f3af4dcc731994c7da0d8a0b4a6eb0640e1d178", size = 20946 }, + { url = "https://files.pythonhosted.org/packages/7c/31/bd635fb5989440d9365c5e3c47556cfea121c7803f5034ac843e8f37c2f2/MarkupSafe-3.0.2-cp39-cp39-win32.whl", hash = "sha256:8c4e8c3ce11e1f92f6536ff07154f9d49677ebaaafc32db9db4620bc11ed480f", size = 15063 }, + { url = "https://files.pythonhosted.org/packages/b3/73/085399401383ce949f727afec55ec3abd76648d04b9f22e1c0e99cb4bec3/MarkupSafe-3.0.2-cp39-cp39-win_amd64.whl", hash = "sha256:6e296a513ca3d94054c2c881cc913116e90fd030ad1c656b3869762b754f5f8a", size = 15506 }, +] + +[[package]] +name = "matching" +source = { editable = "." } +dependencies = [ + { name = "numpy", version = "1.21.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, + { name = "numpy", version = "1.24.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.8.*'" }, + { name = "numpy", version = "2.0.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*'" }, + { name = "numpy", version = "2.2.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, +] + +[package.optional-dependencies] +dev = [ + { name = "hypothesis", version = "6.79.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, + { name = "hypothesis", version = "6.113.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.8.*'" }, + { name = "hypothesis", version = "6.129.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.9'" }, + { name = "ipython", version = "7.34.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, + { name = "ipython", version = "8.12.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.8.*'" }, + { name = "ipython", version = "8.18.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*'" }, + { name = "ipython", version = "8.34.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.10.*'" }, + { name = "ipython", version = "9.0.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, + { name = "matplotlib", version = "3.5.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, + { name = "matplotlib", version = "3.7.5", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.8.*'" }, + { name = "matplotlib", version = "3.9.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*'" }, + { name = "matplotlib", version = "3.10.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, + { name = "nbsphinx" }, + { name = "nbval" }, + { name = "pandas", version = "1.1.5", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.7.1'" }, + { name = "pandas", version = "1.3.5", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.7.1' and python_full_version < '3.8'" }, + { name = "pandas", version = "2.0.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.8.*'" }, + { name = "pandas", version = "2.2.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.9'" }, + { name = "pytest", version = "7.4.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, + { name = "pytest", version = "8.3.5", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.8'" }, + { name = "pytest-cov", version = "4.1.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, + { name = "pytest-cov", version = "5.0.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.8.*'" }, + { name = "pytest-cov", version = "6.0.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.9'" }, + { name = "pytest-randomly", version = "3.12.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, + { name = "pytest-randomly", version = "3.15.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.8.*'" }, + { name = "pytest-randomly", version = "3.16.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.9'" }, + { name = "pytest-sugar" }, + { name = "pyyaml", version = "6.0.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, + { name = "pyyaml", version = "6.0.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.8'" }, + { name = "quartodoc", marker = "python_full_version >= '3.9'" }, + { name = "ruff" }, +] +docs = [ + { name = "ipython", version = "7.34.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, + { name = "ipython", version = "8.12.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.8.*'" }, + { name = "ipython", version = "8.18.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*'" }, + { name = "ipython", version = "8.34.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.10.*'" }, + { name = "ipython", version = "9.0.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, + { name = "matplotlib", version = "3.5.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, + { name = "matplotlib", version = "3.7.5", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.8.*'" }, + { name = "matplotlib", version = "3.9.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*'" }, + { name = "matplotlib", version = "3.10.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, + { name = "nbsphinx" }, + { name = "pandas", version = "1.1.5", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.7.1'" }, + { name = "pandas", version = "1.3.5", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.7.1' and python_full_version < '3.8'" }, + { name = "pandas", version = "2.0.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.8.*'" }, + { name = "pandas", version = "2.2.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.9'" }, + { name = "pyyaml", version = "6.0.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, + { name = "pyyaml", version = "6.0.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.8'" }, + { name = "quartodoc", marker = "python_full_version >= '3.9'" }, +] +test = [ + { name = "hypothesis", version = "6.79.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, + { name = "hypothesis", version = "6.113.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.8.*'" }, + { name = "hypothesis", version = "6.129.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.9'" }, + { name = "nbval" }, + { name = "pytest", version = "7.4.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, + { name = "pytest", version = "8.3.5", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.8'" }, + { name = "pytest-cov", version = "4.1.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, + { name = "pytest-cov", version = "5.0.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.8.*'" }, + { name = "pytest-cov", version = "6.0.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.9'" }, + { name = "pytest-randomly", version = "3.12.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, + { name = "pytest-randomly", version = "3.15.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.8.*'" }, + { name = "pytest-randomly", version = "3.16.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.9'" }, +] + +[package.metadata] +requires-dist = [ + { name = "hypothesis", marker = "extra == 'test'", specifier = ">=6.31.6" }, + { name = "ipython", marker = "extra == 'docs'", specifier = ">=7.10" }, + { name = "matching", extras = ["docs", "test"], marker = "extra == 'dev'" }, + { name = "matplotlib", marker = "extra == 'docs'", specifier = ">=3" }, + { name = "nbsphinx", marker = "extra == 'docs'", specifier = ">=0.8.8" }, + { name = "nbval", marker = "extra == 'test'", specifier = ">=0.10.0" }, + { name = "numpy", specifier = ">=1.19.2" }, + { name = "pandas", marker = "extra == 'docs'", specifier = ">=1.1.5" }, + { name = "pytest", marker = "extra == 'test'", specifier = ">=6.2.5" }, + { name = "pytest-cov", marker = "extra == 'test'", specifier = ">=3.0.0" }, + { name = "pytest-randomly", marker = "extra == 'test'", specifier = ">=3.10" }, + { name = "pytest-sugar", marker = "extra == 'dev'", specifier = ">=1.0.0" }, + { name = "pyyaml", marker = "extra == 'docs'", specifier = ">=6" }, + { name = "quartodoc", marker = "python_full_version >= '3.9' and extra == 'docs'", specifier = ">=0.5.0" }, + { name = "ruff", marker = "extra == 'dev'", specifier = ">=0.11.1" }, +] + +[[package]] +name = "matplotlib" +version = "3.5.3" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine != 'aarch64' and platform_machine != 'arm64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'aarch64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'arm64'", + "python_full_version < '3.7.1'", +] +dependencies = [ + { name = "cycler", version = "0.11.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, + { name = "fonttools", version = "4.38.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, + { name = "kiwisolver", version = "1.4.5", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, + { name = "numpy", version = "1.21.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, + { name = "packaging", version = "24.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, + { name = "pillow", version = "9.5.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, + { name = "pyparsing", version = "3.1.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, + { name = "python-dateutil", marker = "python_full_version < '3.8'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/02/81/e8276ec6ca005b3b2bfaaad0ea47dbb3a0e389ec8ab87d08e3ccbe4b2742/matplotlib-3.5.3.tar.gz", hash = "sha256:339cac48b80ddbc8bfd05daae0a3a73414651a8596904c2a881cfd1edb65f26c", size = 35236343 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/60/f6/81c99d3413c18b4810256ac5bca0401c0804e69ea98b448e2c644b745bbb/matplotlib-3.5.3-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:a206a1b762b39398efea838f528b3a6d60cdb26fe9d58b48265787e29cd1d693", size = 8084049 }, + { url = "https://files.pythonhosted.org/packages/2d/4a/3262e792d1db92939f820c8fae5ac298b201769e12bb11c89de33ac7bae2/matplotlib-3.5.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:cd45a6f3e93a780185f70f05cf2a383daed13c3489233faad83e81720f7ede24", size = 7267192 }, + { url = "https://files.pythonhosted.org/packages/61/1a/584f2e77e2f88239d66314dab14839a199424319df242c783b84ae23ae41/matplotlib-3.5.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:d62880e1f60e5a30a2a8484432bcb3a5056969dc97258d7326ad465feb7ae069", size = 7164043 }, + { url = "https://files.pythonhosted.org/packages/7b/10/70a26ba757ebab35cc8016502ec14c4e51b939a1c62aff5c9b9731417ad1/matplotlib-3.5.3-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9ab29589cef03bc88acfa3a1490359000c18186fc30374d8aa77d33cc4a51a4a", size = 11655924 }, + { url = "https://files.pythonhosted.org/packages/c9/99/81f70f1c7a5f61997faacd7756faac6f41d1bda514cb0e29bd4b0d817ff1/matplotlib-3.5.3-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:2886cc009f40e2984c083687251821f305d811d38e3df8ded414265e4583f0c5", size = 11756382 }, + { url = "https://files.pythonhosted.org/packages/e5/ca/3ed0e1de9df496392a4c9d75b0c78f82fe5758c66bb875903cf7a9402f0b/matplotlib-3.5.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c995f7d9568f18b5db131ab124c64e51b6820a92d10246d4f2b3f3a66698a15b", size = 11872330 }, + { url = "https://files.pythonhosted.org/packages/fd/7e/ecd6784f82baa01ef7859f8093be02b0913bda487b5bdc4da23c14041f9c/matplotlib-3.5.3-cp310-cp310-win32.whl", hash = "sha256:6bb93a0492d68461bd458eba878f52fdc8ac7bdb6c4acdfe43dba684787838c2", size = 7070877 }, + { url = "https://files.pythonhosted.org/packages/90/81/b73cb7d615a70a01bd349b8e85a7648c51f3a6346695354c1ce569db6d8f/matplotlib-3.5.3-cp310-cp310-win_amd64.whl", hash = "sha256:2e6d184ebe291b9e8f7e78bbab7987d269c38ea3e062eace1fe7d898042ef804", size = 7199098 }, + { url = "https://files.pythonhosted.org/packages/41/6a/b9b170360c408c1cf1515b608fccd7e3e1f4e0b378f6713c2a552a4dab8c/matplotlib-3.5.3-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:6ea6aef5c4338e58d8d376068e28f80a24f54e69f09479d1c90b7172bad9f25b", size = 7265223 }, + { url = "https://files.pythonhosted.org/packages/b4/d1/398124bc31d31b57a8a660be90bf5498b703f636c4a33a7180e7e59c3deb/matplotlib-3.5.3-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:839d47b8ead7ad9669aaacdbc03f29656dc21f0d41a6fea2d473d856c39c8b1c", size = 11633619 }, + { url = "https://files.pythonhosted.org/packages/3d/4e/da8fa069f42ea32858a556b1979c587071d5e82a2b38bf86c24a41c4ec63/matplotlib-3.5.3-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:3b4fa56159dc3c7f9250df88f653f085068bcd32dcd38e479bba58909254af7f", size = 10939456 }, + { url = "https://files.pythonhosted.org/packages/ad/62/7b662284352867a86acfb636761ba351723fc3a235efd8397578d903413d/matplotlib-3.5.3-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:94ff86af56a3869a4ae26a9637a849effd7643858a1a04dd5ee50e9ab75069a7", size = 11240309 }, + { url = "https://files.pythonhosted.org/packages/0a/0e/17a2f293bf37f3ba92600cb2f6bf4a7fd21e96d2101531ddab7e157776ab/matplotlib-3.5.3-cp37-cp37m-win32.whl", hash = "sha256:35a8ad4dddebd51f94c5d24bec689ec0ec66173bf614374a1244c6241c1595e0", size = 7073222 }, + { url = "https://files.pythonhosted.org/packages/df/3f/6093a23565d0f50ce433f56223fcc34af6c912cd4331dc582ba29d9b5a17/matplotlib-3.5.3-cp37-cp37m-win_amd64.whl", hash = "sha256:43e9d3fa077bf0cc95ded13d331d2156f9973dce17c6f0c8b49ccd57af94dbd9", size = 7202999 }, + { url = "https://files.pythonhosted.org/packages/dd/3e/15aefbbc4e7c9a4a16700f83e1a69020087c88935c447980e9aeabf67262/matplotlib-3.5.3-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:22227c976ad4dc8c5a5057540421f0d8708c6560744ad2ad638d48e2984e1dbc", size = 8083830 }, + { url = "https://files.pythonhosted.org/packages/cc/00/cdffb0622cbf31a8a33428f77f8fe22a1509a8be417f40089174c19639f8/matplotlib-3.5.3-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:bf618a825deb6205f015df6dfe6167a5d9b351203b03fab82043ae1d30f16511", size = 7267146 }, + { url = "https://files.pythonhosted.org/packages/e1/9c/8330c19f49359b0729cb1b4cbc6a45d29bb2a7526f8318f4e59050e89574/matplotlib-3.5.3-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:9befa5954cdbc085e37d974ff6053da269474177921dd61facdad8023c4aeb51", size = 7163439 }, + { url = "https://files.pythonhosted.org/packages/69/2a/6cf748ea590bcdc8a35fc9eff57505cae78f4c15035010c10cbe8bb3fae9/matplotlib-3.5.3-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f3840c280ebc87a48488a46f760ea1c0c0c83fcf7abbe2e6baf99d033fd35fd8", size = 11677535 }, + { url = "https://files.pythonhosted.org/packages/e8/f7/12fdec2c9cdd06a406f1ba4f08b5fe94bbefc800a4c6e5fa3feda0dc1d16/matplotlib-3.5.3-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:dacddf5bfcec60e3f26ec5c0ae3d0274853a258b6c3fc5ef2f06a8eb23e042be", size = 10958456 }, + { url = "https://files.pythonhosted.org/packages/a7/57/c9b314e3c1fe451017e62b9d485c107db1f7b4fed70dc2e13c7acdc57137/matplotlib-3.5.3-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:b428076a55fb1c084c76cb93e68006f27d247169f056412607c5c88828d08f88", size = 11266085 }, + { url = "https://files.pythonhosted.org/packages/2d/19/dc36a8cfa795ceda35b823b3dd13c64258b4ae84a35acd9998efd58d347c/matplotlib-3.5.3-cp38-cp38-win32.whl", hash = "sha256:874df7505ba820e0400e7091199decf3ff1fde0583652120c50cd60d5820ca9a", size = 7072159 }, + { url = "https://files.pythonhosted.org/packages/a5/0c/e1d675e4f20ddc72497d422344317c227ecdd9e2bd95f4a1c53eeb2cd8e0/matplotlib-3.5.3-cp38-cp38-win_amd64.whl", hash = "sha256:b28de401d928890187c589036857a270a032961411934bdac4cf12dde3d43094", size = 7200980 }, + { url = "https://files.pythonhosted.org/packages/b6/7b/fd9dc05a486bf3d5a32da454b100269e5afaff3a477f319d6ceefa48e167/matplotlib-3.5.3-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:3211ba82b9f1518d346f6309df137b50c3dc4421b4ed4815d1d7eadc617f45a1", size = 8084059 }, + { url = "https://files.pythonhosted.org/packages/40/24/a79cbea0d0b6ca64011bfc30cd18069885308e1f1e65772dfc3a15752221/matplotlib-3.5.3-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:6fe807e8a22620b4cd95cfbc795ba310dc80151d43b037257250faf0bfcd82bc", size = 7267173 }, + { url = "https://files.pythonhosted.org/packages/ec/13/78e0de82272ee6a24e5cf13469234accfc07cf08638477e8c516573b2a3e/matplotlib-3.5.3-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:5c096363b206a3caf43773abebdbb5a23ea13faef71d701b21a9c27fdcef72f4", size = 7164021 }, + { url = "https://files.pythonhosted.org/packages/d6/d3/cda19d3864fff82d83604841c0f972cfa7bbd9c759595c854202ad3e97fa/matplotlib-3.5.3-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0bcdfcb0f976e1bac6721d7d457c17be23cf7501f977b6a38f9d38a3762841f7", size = 11653182 }, + { url = "https://files.pythonhosted.org/packages/83/5c/0424da282a8deb4daa6aa530be3f66c9fe8b6eb8236400b06babb6461a99/matplotlib-3.5.3-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:1e64ac9be9da6bfff0a732e62116484b93b02a0b4d4b19934fb4f8e7ad26ad6a", size = 10940208 }, + { url = "https://files.pythonhosted.org/packages/7f/88/bedb044b6df42c5e68d71df6f4ca9283c98cc4c563af4655d0128a210dfe/matplotlib-3.5.3-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:73dd93dc35c85dece610cca8358003bf0760d7986f70b223e2306b4ea6d1406b", size = 11244308 }, + { url = "https://files.pythonhosted.org/packages/9e/c8/0cdbaeea02ba50bc9390d9d38d809391d9a477fd571e6e3d8b1f8cfe0a2c/matplotlib-3.5.3-cp39-cp39-win32.whl", hash = "sha256:879c7e5fce4939c6aa04581dfe08d57eb6102a71f2e202e3314d5fbc072fd5a0", size = 7070839 }, + { url = "https://files.pythonhosted.org/packages/a8/6e/0ee4fdc167173d29d45d2296ed0a1f00ccbe7410a2d10d696970eb0312a0/matplotlib-3.5.3-cp39-cp39-win_amd64.whl", hash = "sha256:ab8d26f07fe64f6f6736d635cce7bfd7f625320490ed5bfc347f2cdb4fae0e56", size = 7199118 }, + { url = "https://files.pythonhosted.org/packages/29/a1/5a02f43ecc29738867f461df5749fb5ac7fa4c701aed911287266f4e6dfe/matplotlib-3.5.3-pp37-pypy37_pp73-macosx_10_9_x86_64.whl", hash = "sha256:99482b83ebf4eb6d5fc6813d7aacdefdd480f0d9c0b52dcf9f1cc3b2c4b3361a", size = 7224078 }, + { url = "https://files.pythonhosted.org/packages/66/c4/70c5d5a4c45a5f642f3609b8b87ef18233e38e08081169a76d19988fe83f/matplotlib-3.5.3-pp37-pypy37_pp73-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:f814504e459c68118bf2246a530ed953ebd18213dc20e3da524174d84ed010b2", size = 7389127 }, + { url = "https://files.pythonhosted.org/packages/bf/f6/d0206285a0fc5ef590b5fe940a231cebbe49375c6edd8fd04eaf0489e83c/matplotlib-3.5.3-pp37-pypy37_pp73-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:57f1b4e69f438a99bb64d7f2c340db1b096b41ebaa515cf61ea72624279220ce", size = 7355065 }, + { url = "https://files.pythonhosted.org/packages/fd/1c/5c3c71e38a408f2034ae08db6b71e7d1010f9461ab05d8b30b136a77b3e1/matplotlib-3.5.3-pp37-pypy37_pp73-win_amd64.whl", hash = "sha256:d2484b350bf3d32cae43f85dcfc89b3ed7bd2bcd781ef351f93eb6fb2cc483f9", size = 7195698 }, +] + +[[package]] +name = "matplotlib" +version = "3.7.5" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version == '3.8.*'", +] +dependencies = [ + { name = "contourpy", version = "1.1.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.8.*'" }, + { name = "cycler", version = "0.12.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.8.*'" }, + { name = "fonttools", version = "4.56.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.8.*'" }, + { name = "importlib-resources", version = "6.4.5", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.8.*'" }, + { name = "kiwisolver", version = "1.4.7", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.8.*'" }, + { name = "numpy", version = "1.24.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.8.*'" }, + { name = "packaging", version = "24.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.8.*'" }, + { name = "pillow", version = "10.4.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.8.*'" }, + { name = "pyparsing", version = "3.1.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.8.*'" }, + { name = "python-dateutil", marker = "python_full_version == '3.8.*'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b6/f0/3836719cc3982fbba3b840d18a59db1d0ee9ac7986f24e8c0a092851b67b/matplotlib-3.7.5.tar.gz", hash = "sha256:1e5c971558ebc811aa07f54c7b7c677d78aa518ef4c390e14673a09e0860184a", size = 38098611 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f5/b0/3808e86c41e5d97822d77e89d7f3cb0890725845c050d87ec53732a8b150/matplotlib-3.7.5-cp310-cp310-macosx_10_12_universal2.whl", hash = "sha256:4a87b69cb1cb20943010f63feb0b2901c17a3b435f75349fd9865713bfa63925", size = 8322924 }, + { url = "https://files.pythonhosted.org/packages/5b/05/726623be56391ba1740331ad9f1cd30e1adec61c179ddac134957a6dc2e7/matplotlib-3.7.5-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:d3ce45010fefb028359accebb852ca0c21bd77ec0f281952831d235228f15810", size = 7438436 }, + { url = "https://files.pythonhosted.org/packages/15/83/89cdef49ef1e320060ec951ba33c132df211561d866c3ed144c81fd110b2/matplotlib-3.7.5-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:fbea1e762b28400393d71be1a02144aa16692a3c4c676ba0178ce83fc2928fdd", size = 7341849 }, + { url = "https://files.pythonhosted.org/packages/94/29/39fc4acdc296dd86e09cecb65c14966e1cf18e0f091b9cbd9bd3f0c19ee4/matplotlib-3.7.5-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ec0e1adc0ad70ba8227e957551e25a9d2995e319c29f94a97575bb90fa1d4469", size = 11354141 }, + { url = "https://files.pythonhosted.org/packages/54/36/44c5eeb0d83ae1e3ed34d264d7adee947c4fd56c4a9464ce822de094995a/matplotlib-3.7.5-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6738c89a635ced486c8a20e20111d33f6398a9cbebce1ced59c211e12cd61455", size = 11457668 }, + { url = "https://files.pythonhosted.org/packages/b7/e2/f68aeaedf0ef57cbb793637ee82e62e64ea26cee908db0fe4f8e24d502c0/matplotlib-3.7.5-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1210b7919b4ed94b5573870f316bca26de3e3b07ffdb563e79327dc0e6bba515", size = 11580088 }, + { url = "https://files.pythonhosted.org/packages/d9/f7/7c88d34afc38943aa5e4e04d27fc9da5289a48c264c0d794f60c9cda0949/matplotlib-3.7.5-cp310-cp310-win32.whl", hash = "sha256:068ebcc59c072781d9dcdb82f0d3f1458271c2de7ca9c78f5bd672141091e9e1", size = 7339332 }, + { url = "https://files.pythonhosted.org/packages/91/99/e5f6f7c9438279581c4a2308d264fe24dc98bb80e3b2719f797227e54ddc/matplotlib-3.7.5-cp310-cp310-win_amd64.whl", hash = "sha256:f098ffbaab9df1e3ef04e5a5586a1e6b1791380698e84938d8640961c79b1fc0", size = 7506405 }, + { url = "https://files.pythonhosted.org/packages/5e/c6/45d0485e59d70b7a6a81eade5d0aed548b42cc65658c0ce0f813b9249165/matplotlib-3.7.5-cp311-cp311-macosx_10_12_universal2.whl", hash = "sha256:f65342c147572673f02a4abec2d5a23ad9c3898167df9b47c149f32ce61ca078", size = 8325506 }, + { url = "https://files.pythonhosted.org/packages/0e/0a/83bd8589f3597745f624fbcc7da1140088b2f4160ca51c71553c561d0df5/matplotlib-3.7.5-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:4ddf7fc0e0dc553891a117aa083039088d8a07686d4c93fb8a810adca68810af", size = 7439905 }, + { url = "https://files.pythonhosted.org/packages/84/c1/a7705b24f8f9b4d7ceea0002c13bae50cf9423f299f56d8c47a5cd2627d2/matplotlib-3.7.5-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:0ccb830fc29442360d91be48527809f23a5dcaee8da5f4d9b2d5b867c1b087b8", size = 7342895 }, + { url = "https://files.pythonhosted.org/packages/94/6e/55d7d8310c96a7459c883aa4be3f5a9338a108278484cbd5c95d480d1cef/matplotlib-3.7.5-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:efc6bb28178e844d1f408dd4d6341ee8a2e906fc9e0fa3dae497da4e0cab775d", size = 11358830 }, + { url = "https://files.pythonhosted.org/packages/55/57/3b36afe104216db1cf2f3889c394b403ea87eda77c4815227c9524462ba8/matplotlib-3.7.5-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3b15c4c2d374f249f324f46e883340d494c01768dd5287f8bc00b65b625ab56c", size = 11462575 }, + { url = "https://files.pythonhosted.org/packages/f3/0b/fabcf5f66b12fab5c4110d06a6c0fed875c7e63bc446403f58f9dadc9999/matplotlib-3.7.5-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3d028555421912307845e59e3de328260b26d055c5dac9b182cc9783854e98fb", size = 11584280 }, + { url = "https://files.pythonhosted.org/packages/47/a9/1ad7df27a9da70b62109584632f83fe6ef45774701199c44d5777107c240/matplotlib-3.7.5-cp311-cp311-win32.whl", hash = "sha256:fe184b4625b4052fa88ef350b815559dd90cc6cc8e97b62f966e1ca84074aafa", size = 7340429 }, + { url = "https://files.pythonhosted.org/packages/e3/b1/1b6c34b89173d6c206dc5a4028e8518b4dfee3569c13bdc0c88d0486cae7/matplotlib-3.7.5-cp311-cp311-win_amd64.whl", hash = "sha256:084f1f0f2f1010868c6f1f50b4e1c6f2fb201c58475494f1e5b66fed66093647", size = 7507112 }, + { url = "https://files.pythonhosted.org/packages/75/dc/4e341a3ef36f3e7321aec0741317f12c7a23264be708a97972bf018c34af/matplotlib-3.7.5-cp312-cp312-macosx_10_12_universal2.whl", hash = "sha256:34bceb9d8ddb142055ff27cd7135f539f2f01be2ce0bafbace4117abe58f8fe4", size = 8323797 }, + { url = "https://files.pythonhosted.org/packages/af/83/bbb482d678362ceb68cc59ec4fc705dde636025969361dac77be868541ef/matplotlib-3.7.5-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:c5a2134162273eb8cdfd320ae907bf84d171de948e62180fa372a3ca7cf0f433", size = 7439549 }, + { url = "https://files.pythonhosted.org/packages/1a/ee/e49a92d9e369b2b9e4373894171cb4e641771cd7f81bde1d8b6fb8c60842/matplotlib-3.7.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:039ad54683a814002ff37bf7981aa1faa40b91f4ff84149beb53d1eb64617980", size = 7341788 }, + { url = "https://files.pythonhosted.org/packages/48/79/89cb2fc5ddcfc3d440a739df04dbe6e4e72b1153d1ebd32b45d42eb71d27/matplotlib-3.7.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4d742ccd1b09e863b4ca58291728db645b51dab343eebb08d5d4b31b308296ce", size = 11356329 }, + { url = "https://files.pythonhosted.org/packages/ff/25/84f181cdae5c9eba6fd1c2c35642aec47233425fe3b0d6fccdb323fb36e0/matplotlib-3.7.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:743b1c488ca6a2bc7f56079d282e44d236bf375968bfd1b7ba701fd4d0fa32d6", size = 11577813 }, + { url = "https://files.pythonhosted.org/packages/9f/24/b2db065d40e58033b3350222fb8bbb0ffcb834029df9c1f9349dd9c7dd45/matplotlib-3.7.5-cp312-cp312-win_amd64.whl", hash = "sha256:fbf730fca3e1f23713bc1fae0a57db386e39dc81ea57dc305c67f628c1d7a342", size = 7507667 }, + { url = "https://files.pythonhosted.org/packages/e3/72/50a38c8fd5dc845b06f8e71c9da802db44b81baabf4af8be78bb8a5622ea/matplotlib-3.7.5-cp38-cp38-macosx_10_12_universal2.whl", hash = "sha256:cfff9b838531698ee40e40ea1a8a9dc2c01edb400b27d38de6ba44c1f9a8e3d2", size = 8322659 }, + { url = "https://files.pythonhosted.org/packages/b1/ea/129163dcd21db6da5d559a8160c4a74c1dc5f96ac246a3d4248b43c7648d/matplotlib-3.7.5-cp38-cp38-macosx_10_12_x86_64.whl", hash = "sha256:1dbcca4508bca7847fe2d64a05b237a3dcaec1f959aedb756d5b1c67b770c5ee", size = 7438408 }, + { url = "https://files.pythonhosted.org/packages/aa/59/4d13e5b6298b1ca5525eea8c68d3806ae93ab6d0bb17ca9846aa3156b92b/matplotlib-3.7.5-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:4cdf4ef46c2a1609a50411b66940b31778db1e4b73d4ecc2eaa40bd588979b13", size = 7341782 }, + { url = "https://files.pythonhosted.org/packages/9e/c4/f562df04b08487731743511ff274ae5d31dce2ff3e5621f8b070d20ab54a/matplotlib-3.7.5-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:167200ccfefd1674b60e957186dfd9baf58b324562ad1a28e5d0a6b3bea77905", size = 9196487 }, + { url = "https://files.pythonhosted.org/packages/30/33/cc27211d2ffeee4fd7402dca137b6e8a83f6dcae3d4be8d0ad5068555561/matplotlib-3.7.5-cp38-cp38-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:53e64522934df6e1818b25fd48cf3b645b11740d78e6ef765fbb5fa5ce080d02", size = 9213051 }, + { url = "https://files.pythonhosted.org/packages/9b/9d/8bd37c86b79312c9dbcfa379dec32303f9b38e8456e0829d7e666a0e0a05/matplotlib-3.7.5-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d3e3bc79b2d7d615067bd010caff9243ead1fc95cf735c16e4b2583173f717eb", size = 11370807 }, + { url = "https://files.pythonhosted.org/packages/c0/1e/b24a07a849c8d458f1b3724f49029f0dedf748bdedb4d5f69491314838b6/matplotlib-3.7.5-cp38-cp38-win32.whl", hash = "sha256:6b641b48c6819726ed47c55835cdd330e53747d4efff574109fd79b2d8a13748", size = 7340461 }, + { url = "https://files.pythonhosted.org/packages/16/51/58b0b9de42fe1e665736d9286f88b5f1556a0e22bed8a71f468231761083/matplotlib-3.7.5-cp38-cp38-win_amd64.whl", hash = "sha256:f0b60993ed3488b4532ec6b697059897891927cbfc2b8d458a891b60ec03d9d7", size = 7507471 }, + { url = "https://files.pythonhosted.org/packages/0d/00/17487e9e8949ca623af87f6c8767408efe7530b7e1f4d6897fa7fa940834/matplotlib-3.7.5-cp39-cp39-macosx_10_12_universal2.whl", hash = "sha256:090964d0afaff9c90e4d8de7836757e72ecfb252fb02884016d809239f715651", size = 8323175 }, + { url = "https://files.pythonhosted.org/packages/6a/84/be0acd521fa9d6697657cf35878153f8009a42b4b75237aebc302559a8a9/matplotlib-3.7.5-cp39-cp39-macosx_10_12_x86_64.whl", hash = "sha256:9fc6fcfbc55cd719bc0bfa60bde248eb68cf43876d4c22864603bdd23962ba25", size = 7438737 }, + { url = "https://files.pythonhosted.org/packages/17/39/175f36a6d68d0cf47a4fecbae9728048355df23c9feca8688f1476b198e6/matplotlib-3.7.5-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:5e7cc3078b019bb863752b8b60e8b269423000f1603cb2299608231996bd9d54", size = 7341916 }, + { url = "https://files.pythonhosted.org/packages/36/c0/9a1c2a79f85c15d41b60877cbc333694ed80605e5c97a33880c4ecfd5bf1/matplotlib-3.7.5-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1e4e9a868e8163abaaa8259842d85f949a919e1ead17644fb77a60427c90473c", size = 11352264 }, + { url = "https://files.pythonhosted.org/packages/a6/39/b0204e0e7a899b0676733366a55ccafa723799b719bc7f2e85e5ecde26a0/matplotlib-3.7.5-cp39-cp39-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:fa7ebc995a7d747dacf0a717d0eb3aa0f0c6a0e9ea88b0194d3a3cd241a1500f", size = 11454722 }, + { url = "https://files.pythonhosted.org/packages/d8/39/64dd1d36c79e72e614977db338d180cf204cf658927c05a8ef2d47feb4c0/matplotlib-3.7.5-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3785bfd83b05fc0e0c2ae4c4a90034fe693ef96c679634756c50fe6efcc09856", size = 11576343 }, + { url = "https://files.pythonhosted.org/packages/31/b4/e77bc11394d858bdf15e356980fceb4ac9604b0fa8212ef3ca4f1dc166b8/matplotlib-3.7.5-cp39-cp39-win32.whl", hash = "sha256:29b058738c104d0ca8806395f1c9089dfe4d4f0f78ea765c6c704469f3fffc81", size = 7340455 }, + { url = "https://files.pythonhosted.org/packages/4a/84/081820c596b9555ecffc6819ee71f847f2fbb0d7c70a42c1eeaa54edf3e0/matplotlib-3.7.5-cp39-cp39-win_amd64.whl", hash = "sha256:fd4028d570fa4b31b7b165d4a685942ae9cdc669f33741e388c01857d9723eab", size = 7507711 }, + { url = "https://files.pythonhosted.org/packages/27/6c/1bb10f3d6f337b9faa2e96a251bd87ba5fed85a608df95eb4d69acc109f0/matplotlib-3.7.5-pp38-pypy38_pp73-macosx_10_12_x86_64.whl", hash = "sha256:2a9a3f4d6a7f88a62a6a18c7e6a84aedcaf4faf0708b4ca46d87b19f1b526f88", size = 7397285 }, + { url = "https://files.pythonhosted.org/packages/b2/36/66cfea213e9ba91cda9e257542c249ed235d49021af71c2e8007107d7d4c/matplotlib-3.7.5-pp38-pypy38_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b9b3fd853d4a7f008a938df909b96db0b454225f935d3917520305b90680579c", size = 7552612 }, + { url = "https://files.pythonhosted.org/packages/77/df/16655199bf984c37c6a816b854bc032b56aef521aadc04f27928422f3c91/matplotlib-3.7.5-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f0ad550da9f160737d7890217c5eeed4337d07e83ca1b2ca6535078f354e7675", size = 7515564 }, + { url = "https://files.pythonhosted.org/packages/5b/c8/3534c3705a677b71abb6be33609ba129fdeae2ea4e76b2fd3ab62c86fab3/matplotlib-3.7.5-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:20da7924a08306a861b3f2d1da0d1aa9a6678e480cf8eacffe18b565af2813e7", size = 7521336 }, + { url = "https://files.pythonhosted.org/packages/20/a0/c5c0d410798b387ed3a177a5a7eba21055dd9c41d4b15bd0861241a5a60e/matplotlib-3.7.5-pp39-pypy39_pp73-macosx_10_12_x86_64.whl", hash = "sha256:b45c9798ea6bb920cb77eb7306409756a7fab9db9b463e462618e0559aecb30e", size = 7397931 }, + { url = "https://files.pythonhosted.org/packages/c3/2f/9e9509727d4c7d1b8e2c88e9330a97d54a1dd20bd316a0c8d2f8b38c4513/matplotlib-3.7.5-pp39-pypy39_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a99866267da1e561c7776fe12bf4442174b79aac1a47bd7e627c7e4d077ebd83", size = 7553224 }, + { url = "https://files.pythonhosted.org/packages/89/0c/5f3e403dcf5c23799c92b0139dd00e41caf23983e9281f5bfeba3065e7d2/matplotlib-3.7.5-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2b6aa62adb6c268fc87d80f963aca39c64615c31830b02697743c95590ce3fbb", size = 7513250 }, + { url = "https://files.pythonhosted.org/packages/87/e0/03eba0a8c3775ef910dbb3a287114a64c47abbcaeab2543c59957f155a86/matplotlib-3.7.5-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:e530ab6a0afd082d2e9c17eb1eb064a63c5b09bb607b2b74fa41adbe3e162286", size = 7521729 }, +] + +[[package]] +name = "matplotlib" +version = "3.9.4" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version == '3.9.*'", +] +dependencies = [ + { name = "contourpy", version = "1.3.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*'" }, + { name = "cycler", version = "0.12.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*'" }, + { name = "fonttools", version = "4.56.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*'" }, + { name = "importlib-resources", version = "6.5.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*'" }, + { name = "kiwisolver", version = "1.4.7", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*'" }, + { name = "numpy", version = "2.0.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*'" }, + { name = "packaging", version = "24.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*'" }, + { name = "pillow", version = "11.1.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*'" }, + { name = "pyparsing", version = "3.2.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*'" }, + { name = "python-dateutil", marker = "python_full_version == '3.9.*'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/df/17/1747b4154034befd0ed33b52538f5eb7752d05bb51c5e2a31470c3bc7d52/matplotlib-3.9.4.tar.gz", hash = "sha256:1e00e8be7393cbdc6fedfa8a6fba02cf3e83814b285db1c60b906a023ba41bc3", size = 36106529 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7e/94/27d2e2c30d54b56c7b764acc1874a909e34d1965a427fc7092bb6a588b63/matplotlib-3.9.4-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:c5fdd7abfb706dfa8d307af64a87f1a862879ec3cd8d0ec8637458f0885b9c50", size = 7885089 }, + { url = "https://files.pythonhosted.org/packages/c6/25/828273307e40a68eb8e9df832b6b2aaad075864fdc1de4b1b81e40b09e48/matplotlib-3.9.4-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:d89bc4e85e40a71d1477780366c27fb7c6494d293e1617788986f74e2a03d7ff", size = 7770600 }, + { url = "https://files.pythonhosted.org/packages/f2/65/f841a422ec994da5123368d76b126acf4fc02ea7459b6e37c4891b555b83/matplotlib-3.9.4-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ddf9f3c26aae695c5daafbf6b94e4c1a30d6cd617ba594bbbded3b33a1fcfa26", size = 8200138 }, + { url = "https://files.pythonhosted.org/packages/07/06/272aca07a38804d93b6050813de41ca7ab0e29ba7a9dd098e12037c919a9/matplotlib-3.9.4-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:18ebcf248030173b59a868fda1fe42397253f6698995b55e81e1f57431d85e50", size = 8312711 }, + { url = "https://files.pythonhosted.org/packages/98/37/f13e23b233c526b7e27ad61be0a771894a079e0f7494a10d8d81557e0e9a/matplotlib-3.9.4-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:974896ec43c672ec23f3f8c648981e8bc880ee163146e0312a9b8def2fac66f5", size = 9090622 }, + { url = "https://files.pythonhosted.org/packages/4f/8c/b1f5bd2bd70e60f93b1b54c4d5ba7a992312021d0ddddf572f9a1a6d9348/matplotlib-3.9.4-cp310-cp310-win_amd64.whl", hash = "sha256:4598c394ae9711cec135639374e70871fa36b56afae17bdf032a345be552a88d", size = 7828211 }, + { url = "https://files.pythonhosted.org/packages/74/4b/65be7959a8fa118a3929b49a842de5b78bb55475236fcf64f3e308ff74a0/matplotlib-3.9.4-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:d4dd29641d9fb8bc4492420c5480398dd40a09afd73aebe4eb9d0071a05fbe0c", size = 7894430 }, + { url = "https://files.pythonhosted.org/packages/e9/18/80f70d91896e0a517b4a051c3fd540daa131630fd75e02e250365353b253/matplotlib-3.9.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:30e5b22e8bcfb95442bf7d48b0d7f3bdf4a450cbf68986ea45fca3d11ae9d099", size = 7780045 }, + { url = "https://files.pythonhosted.org/packages/a2/73/ccb381026e3238c5c25c3609ba4157b2d1a617ec98d65a8b4ee4e1e74d02/matplotlib-3.9.4-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2bb0030d1d447fd56dcc23b4c64a26e44e898f0416276cac1ebc25522e0ac249", size = 8209906 }, + { url = "https://files.pythonhosted.org/packages/ab/33/1648da77b74741c89f5ea95cbf42a291b4b364f2660b316318811404ed97/matplotlib-3.9.4-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:aca90ed222ac3565d2752b83dbb27627480d27662671e4d39da72e97f657a423", size = 8322873 }, + { url = "https://files.pythonhosted.org/packages/57/d3/8447ba78bc6593c9044c372d1609f8ea10fb1e071e7a9e0747bea74fc16c/matplotlib-3.9.4-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:a181b2aa2906c608fcae72f977a4a2d76e385578939891b91c2550c39ecf361e", size = 9099566 }, + { url = "https://files.pythonhosted.org/packages/23/e1/4f0e237bf349c02ff9d1b6e7109f1a17f745263809b9714a8576dc17752b/matplotlib-3.9.4-cp311-cp311-win_amd64.whl", hash = "sha256:1f6882828231eca17f501c4dcd98a05abb3f03d157fbc0769c6911fe08b6cfd3", size = 7838065 }, + { url = "https://files.pythonhosted.org/packages/1a/2b/c918bf6c19d6445d1cefe3d2e42cb740fb997e14ab19d4daeb6a7ab8a157/matplotlib-3.9.4-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:dfc48d67e6661378a21c2983200a654b72b5c5cdbd5d2cf6e5e1ece860f0cc70", size = 7891131 }, + { url = "https://files.pythonhosted.org/packages/c1/e5/b4e8fc601ca302afeeabf45f30e706a445c7979a180e3a978b78b2b681a4/matplotlib-3.9.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:47aef0fab8332d02d68e786eba8113ffd6f862182ea2999379dec9e237b7e483", size = 7776365 }, + { url = "https://files.pythonhosted.org/packages/99/06/b991886c506506476e5d83625c5970c656a491b9f80161458fed94597808/matplotlib-3.9.4-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fba1f52c6b7dc764097f52fd9ab627b90db452c9feb653a59945de16752e965f", size = 8200707 }, + { url = "https://files.pythonhosted.org/packages/c3/e2/556b627498cb27e61026f2d1ba86a78ad1b836fef0996bef5440e8bc9559/matplotlib-3.9.4-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:173ac3748acaac21afcc3fa1633924609ba1b87749006bc25051c52c422a5d00", size = 8313761 }, + { url = "https://files.pythonhosted.org/packages/58/ff/165af33ec766ff818306ea88e91f9f60d2a6ed543be1eb122a98acbf3b0d/matplotlib-3.9.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:320edea0cadc07007765e33f878b13b3738ffa9745c5f707705692df70ffe0e0", size = 9095284 }, + { url = "https://files.pythonhosted.org/packages/9f/8b/3d0c7a002db3b1ed702731c2a9a06d78d035f1f2fb0fb936a8e43cc1e9f4/matplotlib-3.9.4-cp312-cp312-win_amd64.whl", hash = "sha256:a4a4cfc82330b27042a7169533da7991e8789d180dd5b3daeaee57d75cd5a03b", size = 7841160 }, + { url = "https://files.pythonhosted.org/packages/49/b1/999f89a7556d101b23a2f0b54f1b6e140d73f56804da1398f2f0bc0924bc/matplotlib-3.9.4-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:37eeffeeca3c940985b80f5b9a7b95ea35671e0e7405001f249848d2b62351b6", size = 7891499 }, + { url = "https://files.pythonhosted.org/packages/87/7b/06a32b13a684977653396a1bfcd34d4e7539c5d55c8cbfaa8ae04d47e4a9/matplotlib-3.9.4-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:3e7465ac859ee4abcb0d836137cd8414e7bb7ad330d905abced457217d4f0f45", size = 7776802 }, + { url = "https://files.pythonhosted.org/packages/65/87/ac498451aff739e515891bbb92e566f3c7ef31891aaa878402a71f9b0910/matplotlib-3.9.4-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f4c12302c34afa0cf061bea23b331e747e5e554b0fa595c96e01c7b75bc3b858", size = 8200802 }, + { url = "https://files.pythonhosted.org/packages/f8/6b/9eb761c00e1cb838f6c92e5f25dcda3f56a87a52f6cb8fdfa561e6cf6a13/matplotlib-3.9.4-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2b8c97917f21b75e72108b97707ba3d48f171541a74aa2a56df7a40626bafc64", size = 8313880 }, + { url = "https://files.pythonhosted.org/packages/d7/a2/c8eaa600e2085eec7e38cbbcc58a30fc78f8224939d31d3152bdafc01fd1/matplotlib-3.9.4-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:0229803bd7e19271b03cb09f27db76c918c467aa4ce2ae168171bc67c3f508df", size = 9094637 }, + { url = "https://files.pythonhosted.org/packages/71/1f/c6e1daea55b7bfeb3d84c6cb1abc449f6a02b181e7e2a5e4db34c3afb793/matplotlib-3.9.4-cp313-cp313-win_amd64.whl", hash = "sha256:7c0d8ef442ebf56ff5e206f8083d08252ee738e04f3dc88ea882853a05488799", size = 7841311 }, + { url = "https://files.pythonhosted.org/packages/c0/3a/2757d3f7d388b14dd48f5a83bea65b6d69f000e86b8f28f74d86e0d375bd/matplotlib-3.9.4-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:a04c3b00066a688834356d196136349cb32f5e1003c55ac419e91585168b88fb", size = 7919989 }, + { url = "https://files.pythonhosted.org/packages/24/28/f5077c79a4f521589a37fe1062d6a6ea3534e068213f7357e7cfffc2e17a/matplotlib-3.9.4-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:04c519587f6c210626741a1e9a68eefc05966ede24205db8982841826af5871a", size = 7809417 }, + { url = "https://files.pythonhosted.org/packages/36/c8/c523fd2963156692916a8eb7d4069084cf729359f7955cf09075deddfeaf/matplotlib-3.9.4-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:308afbf1a228b8b525fcd5cec17f246bbbb63b175a3ef6eb7b4d33287ca0cf0c", size = 8226258 }, + { url = "https://files.pythonhosted.org/packages/f6/88/499bf4b8fa9349b6f5c0cf4cead0ebe5da9d67769129f1b5651e5ac51fbc/matplotlib-3.9.4-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ddb3b02246ddcffd3ce98e88fed5b238bc5faff10dbbaa42090ea13241d15764", size = 8335849 }, + { url = "https://files.pythonhosted.org/packages/b8/9f/20a4156b9726188646a030774ee337d5ff695a965be45ce4dbcb9312c170/matplotlib-3.9.4-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:8a75287e9cb9eee48cb79ec1d806f75b29c0fde978cb7223a1f4c5848d696041", size = 9102152 }, + { url = "https://files.pythonhosted.org/packages/10/11/237f9c3a4e8d810b1759b67ff2da7c32c04f9c80aa475e7beb36ed43a8fb/matplotlib-3.9.4-cp313-cp313t-win_amd64.whl", hash = "sha256:488deb7af140f0ba86da003e66e10d55ff915e152c78b4b66d231638400b1965", size = 7896987 }, + { url = "https://files.pythonhosted.org/packages/56/eb/501b465c9fef28f158e414ea3a417913dc2ac748564c7ed41535f23445b4/matplotlib-3.9.4-cp39-cp39-macosx_10_12_x86_64.whl", hash = "sha256:3c3724d89a387ddf78ff88d2a30ca78ac2b4c89cf37f2db4bd453c34799e933c", size = 7885919 }, + { url = "https://files.pythonhosted.org/packages/da/36/236fbd868b6c91309a5206bd90c3f881f4f44b2d997cd1d6239ef652f878/matplotlib-3.9.4-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:d5f0a8430ffe23d7e32cfd86445864ccad141797f7d25b7c41759a5b5d17cfd7", size = 7771486 }, + { url = "https://files.pythonhosted.org/packages/e0/4b/105caf2d54d5ed11d9f4335398f5103001a03515f2126c936a752ccf1461/matplotlib-3.9.4-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6bb0141a21aef3b64b633dc4d16cbd5fc538b727e4958be82a0e1c92a234160e", size = 8201838 }, + { url = "https://files.pythonhosted.org/packages/5d/a7/bb01188fb4013d34d274caf44a2f8091255b0497438e8b6c0a7c1710c692/matplotlib-3.9.4-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:57aa235109e9eed52e2c2949db17da185383fa71083c00c6c143a60e07e0888c", size = 8314492 }, + { url = "https://files.pythonhosted.org/packages/33/19/02e1a37f7141fc605b193e927d0a9cdf9dc124a20b9e68793f4ffea19695/matplotlib-3.9.4-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:b18c600061477ccfdd1e6fd050c33d8be82431700f3452b297a56d9ed7037abb", size = 9092500 }, + { url = "https://files.pythonhosted.org/packages/57/68/c2feb4667adbf882ffa4b3e0ac9967f848980d9f8b5bebd86644aa67ce6a/matplotlib-3.9.4-cp39-cp39-win_amd64.whl", hash = "sha256:ef5f2d1b67d2d2145ff75e10f8c008bfbf71d45137c4b648c87193e7dd053eac", size = 7822962 }, + { url = "https://files.pythonhosted.org/packages/0c/22/2ef6a364cd3f565442b0b055e0599744f1e4314ec7326cdaaa48a4d864d7/matplotlib-3.9.4-pp39-pypy39_pp73-macosx_10_15_x86_64.whl", hash = "sha256:44e0ed786d769d85bc787b0606a53f2d8d2d1d3c8a2608237365e9121c1a338c", size = 7877995 }, + { url = "https://files.pythonhosted.org/packages/87/b8/2737456e566e9f4d94ae76b8aa0d953d9acb847714f9a7ad80184474f5be/matplotlib-3.9.4-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:09debb9ce941eb23ecdbe7eab972b1c3e0276dcf01688073faff7b0f61d6c6ca", size = 7769300 }, + { url = "https://files.pythonhosted.org/packages/b2/1f/e709c6ec7b5321e6568769baa288c7178e60a93a9da9e682b39450da0e29/matplotlib-3.9.4-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bcc53cf157a657bfd03afab14774d54ba73aa84d42cfe2480c91bd94873952db", size = 8313423 }, + { url = "https://files.pythonhosted.org/packages/5e/b6/5a1f868782cd13f053a679984e222007ecff654a9bfbac6b27a65f4eeb05/matplotlib-3.9.4-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:ad45da51be7ad02387801fd154ef74d942f49fe3fcd26a64c94842ba7ec0d865", size = 7854624 }, +] + +[[package]] +name = "matplotlib" +version = "3.10.1" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", + "python_full_version == '3.10.*'", +] +dependencies = [ + { name = "contourpy", version = "1.3.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, + { name = "cycler", version = "0.12.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, + { name = "fonttools", version = "4.56.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, + { name = "kiwisolver", version = "1.4.8", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, + { name = "numpy", version = "2.2.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, + { name = "packaging", version = "24.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, + { name = "pillow", version = "11.1.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, + { name = "pyparsing", version = "3.2.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, + { name = "python-dateutil", marker = "python_full_version >= '3.10'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/2f/08/b89867ecea2e305f408fbb417139a8dd941ecf7b23a2e02157c36da546f0/matplotlib-3.10.1.tar.gz", hash = "sha256:e8d2d0e3881b129268585bf4765ad3ee73a4591d77b9a18c214ac7e3a79fb2ba", size = 36743335 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ee/b1/f70e27cf1cd76ce2a5e1aa5579d05afe3236052c6d9b9a96325bc823a17e/matplotlib-3.10.1-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:ff2ae14910be903f4a24afdbb6d7d3a6c44da210fc7d42790b87aeac92238a16", size = 8163654 }, + { url = "https://files.pythonhosted.org/packages/26/af/5ec3d4636106718bb62503a03297125d4514f98fe818461bd9e6b9d116e4/matplotlib-3.10.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:0721a3fd3d5756ed593220a8b86808a36c5031fce489adb5b31ee6dbb47dd5b2", size = 8037943 }, + { url = "https://files.pythonhosted.org/packages/a1/3d/07f9003a71b698b848c9925d05979ffa94a75cd25d1a587202f0bb58aa81/matplotlib-3.10.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d0673b4b8f131890eb3a1ad058d6e065fb3c6e71f160089b65f8515373394698", size = 8449510 }, + { url = "https://files.pythonhosted.org/packages/12/87/9472d4513ff83b7cd864311821793ab72234fa201ab77310ec1b585d27e2/matplotlib-3.10.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8e875b95ac59a7908978fe307ecdbdd9a26af7fa0f33f474a27fcf8c99f64a19", size = 8586585 }, + { url = "https://files.pythonhosted.org/packages/31/9e/fe74d237d2963adae8608faeb21f778cf246dbbf4746cef87cffbc82c4b6/matplotlib-3.10.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:2589659ea30726284c6c91037216f64a506a9822f8e50592d48ac16a2f29e044", size = 9397911 }, + { url = "https://files.pythonhosted.org/packages/b6/1b/025d3e59e8a4281ab463162ad7d072575354a1916aba81b6a11507dfc524/matplotlib-3.10.1-cp310-cp310-win_amd64.whl", hash = "sha256:a97ff127f295817bc34517255c9db6e71de8eddaab7f837b7d341dee9f2f587f", size = 8052998 }, + { url = "https://files.pythonhosted.org/packages/a5/14/a1b840075be247bb1834b22c1e1d558740b0f618fe3a823740181ca557a1/matplotlib-3.10.1-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:057206ff2d6ab82ff3e94ebd94463d084760ca682ed5f150817b859372ec4401", size = 8174669 }, + { url = "https://files.pythonhosted.org/packages/0a/e4/300b08e3e08f9c98b0d5635f42edabf2f7a1d634e64cb0318a71a44ff720/matplotlib-3.10.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:a144867dd6bf8ba8cb5fc81a158b645037e11b3e5cf8a50bd5f9917cb863adfe", size = 8047996 }, + { url = "https://files.pythonhosted.org/packages/75/f9/8d99ff5a2498a5f1ccf919fb46fb945109623c6108216f10f96428f388bc/matplotlib-3.10.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:56c5d9fcd9879aa8040f196a235e2dcbdf7dd03ab5b07c0696f80bc6cf04bedd", size = 8461612 }, + { url = "https://files.pythonhosted.org/packages/40/b8/53fa08a5eaf78d3a7213fd6da1feec4bae14a81d9805e567013811ff0e85/matplotlib-3.10.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0f69dc9713e4ad2fb21a1c30e37bd445d496524257dfda40ff4a8efb3604ab5c", size = 8602258 }, + { url = "https://files.pythonhosted.org/packages/40/87/4397d2ce808467af86684a622dd112664553e81752ea8bf61bdd89d24a41/matplotlib-3.10.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:4c59af3e8aca75d7744b68e8e78a669e91ccbcf1ac35d0102a7b1b46883f1dd7", size = 9408896 }, + { url = "https://files.pythonhosted.org/packages/d7/68/0d03098b3feb786cbd494df0aac15b571effda7f7cbdec267e8a8d398c16/matplotlib-3.10.1-cp311-cp311-win_amd64.whl", hash = "sha256:11b65088c6f3dae784bc72e8d039a2580186285f87448babb9ddb2ad0082993a", size = 8061281 }, + { url = "https://files.pythonhosted.org/packages/7c/1d/5e0dc3b59c034e43de16f94deb68f4ad8a96b3ea00f4b37c160b7474928e/matplotlib-3.10.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:66e907a06e68cb6cfd652c193311d61a12b54f56809cafbed9736ce5ad92f107", size = 8175488 }, + { url = "https://files.pythonhosted.org/packages/7a/81/dae7e14042e74da658c3336ab9799128e09a1ee03964f2d89630b5d12106/matplotlib-3.10.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:e9b4bb156abb8fa5e5b2b460196f7db7264fc6d62678c03457979e7d5254b7be", size = 8046264 }, + { url = "https://files.pythonhosted.org/packages/21/c4/22516775dcde10fc9c9571d155f90710761b028fc44f660508106c363c97/matplotlib-3.10.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1985ad3d97f51307a2cbfc801a930f120def19ba22864182dacef55277102ba6", size = 8452048 }, + { url = "https://files.pythonhosted.org/packages/63/23/c0615001f67ce7c96b3051d856baedc0c818a2ed84570b9bf9bde200f85d/matplotlib-3.10.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c96f2c2f825d1257e437a1482c5a2cf4fee15db4261bd6fc0750f81ba2b4ba3d", size = 8597111 }, + { url = "https://files.pythonhosted.org/packages/ca/c0/a07939a82aed77770514348f4568177d7dadab9787ebc618a616fe3d665e/matplotlib-3.10.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:35e87384ee9e488d8dd5a2dd7baf471178d38b90618d8ea147aced4ab59c9bea", size = 9402771 }, + { url = "https://files.pythonhosted.org/packages/a6/b6/a9405484fb40746fdc6ae4502b16a9d6e53282ba5baaf9ebe2da579f68c4/matplotlib-3.10.1-cp312-cp312-win_amd64.whl", hash = "sha256:cfd414bce89cc78a7e1d25202e979b3f1af799e416010a20ab2b5ebb3a02425c", size = 8063742 }, + { url = "https://files.pythonhosted.org/packages/60/73/6770ff5e5523d00f3bc584acb6031e29ee5c8adc2336b16cd1d003675fe0/matplotlib-3.10.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:c42eee41e1b60fd83ee3292ed83a97a5f2a8239b10c26715d8a6172226988d7b", size = 8176112 }, + { url = "https://files.pythonhosted.org/packages/08/97/b0ca5da0ed54a3f6599c3ab568bdda65269bc27c21a2c97868c1625e4554/matplotlib-3.10.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:4f0647b17b667ae745c13721602b540f7aadb2a32c5b96e924cd4fea5dcb90f1", size = 8046931 }, + { url = "https://files.pythonhosted.org/packages/df/9a/1acbdc3b165d4ce2dcd2b1a6d4ffb46a7220ceee960c922c3d50d8514067/matplotlib-3.10.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:aa3854b5f9473564ef40a41bc922be978fab217776e9ae1545c9b3a5cf2092a3", size = 8453422 }, + { url = "https://files.pythonhosted.org/packages/51/d0/2bc4368abf766203e548dc7ab57cf7e9c621f1a3c72b516cc7715347b179/matplotlib-3.10.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7e496c01441be4c7d5f96d4e40f7fca06e20dcb40e44c8daa2e740e1757ad9e6", size = 8596819 }, + { url = "https://files.pythonhosted.org/packages/ab/1b/8b350f8a1746c37ab69dda7d7528d1fc696efb06db6ade9727b7887be16d/matplotlib-3.10.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:5d45d3f5245be5b469843450617dcad9af75ca50568acf59997bed9311131a0b", size = 9402782 }, + { url = "https://files.pythonhosted.org/packages/89/06/f570373d24d93503988ba8d04f213a372fa1ce48381c5eb15da985728498/matplotlib-3.10.1-cp313-cp313-win_amd64.whl", hash = "sha256:8e8e25b1209161d20dfe93037c8a7f7ca796ec9aa326e6e4588d8c4a5dd1e473", size = 8063812 }, + { url = "https://files.pythonhosted.org/packages/fc/e0/8c811a925b5a7ad75135f0e5af46408b78af88bbb02a1df775100ef9bfef/matplotlib-3.10.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:19b06241ad89c3ae9469e07d77efa87041eac65d78df4fcf9cac318028009b01", size = 8214021 }, + { url = "https://files.pythonhosted.org/packages/4a/34/319ec2139f68ba26da9d00fce2ff9f27679fb799a6c8e7358539801fd629/matplotlib-3.10.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:01e63101ebb3014e6e9f80d9cf9ee361a8599ddca2c3e166c563628b39305dbb", size = 8090782 }, + { url = "https://files.pythonhosted.org/packages/77/ea/9812124ab9a99df5b2eec1110e9b2edc0b8f77039abf4c56e0a376e84a29/matplotlib-3.10.1-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3f06bad951eea6422ac4e8bdebcf3a70c59ea0a03338c5d2b109f57b64eb3972", size = 8478901 }, + { url = "https://files.pythonhosted.org/packages/c9/db/b05bf463689134789b06dea85828f8ebe506fa1e37593f723b65b86c9582/matplotlib-3.10.1-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a3dfb036f34873b46978f55e240cff7a239f6c4409eac62d8145bad3fc6ba5a3", size = 8613864 }, + { url = "https://files.pythonhosted.org/packages/c2/04/41ccec4409f3023a7576df3b5c025f1a8c8b81fbfe922ecfd837ac36e081/matplotlib-3.10.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:dc6ab14a7ab3b4d813b88ba957fc05c79493a037f54e246162033591e770de6f", size = 9409487 }, + { url = "https://files.pythonhosted.org/packages/ac/c2/0d5aae823bdcc42cc99327ecdd4d28585e15ccd5218c453b7bcd827f3421/matplotlib-3.10.1-cp313-cp313t-win_amd64.whl", hash = "sha256:bc411ebd5889a78dabbc457b3fa153203e22248bfa6eedc6797be5df0164dbf9", size = 8134832 }, + { url = "https://files.pythonhosted.org/packages/c8/f6/10adb696d8cbeed2ab4c2e26ecf1c80dd3847bbf3891f4a0c362e0e08a5a/matplotlib-3.10.1-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:648406f1899f9a818cef8c0231b44dcfc4ff36f167101c3fd1c9151f24220fdc", size = 8158685 }, + { url = "https://files.pythonhosted.org/packages/3f/84/0603d917406072763e7f9bb37747d3d74d7ecd4b943a8c947cc3ae1cf7af/matplotlib-3.10.1-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:02582304e352f40520727984a5a18f37e8187861f954fea9be7ef06569cf85b4", size = 8035491 }, + { url = "https://files.pythonhosted.org/packages/fd/7d/6a8b31dd07ed856b3eae001c9129670ef75c4698fa1c2a6ac9f00a4a7054/matplotlib-3.10.1-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d3809916157ba871bcdd33d3493acd7fe3037db5daa917ca6e77975a94cef779", size = 8590087 }, +] + +[[package]] +name = "matplotlib-inline" +version = "0.1.6" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine != 'aarch64' and platform_machine != 'arm64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'aarch64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'arm64'", + "python_full_version < '3.7.1'", +] +dependencies = [ + { name = "traitlets", version = "5.9.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/d9/50/3af8c0362f26108e54d58c7f38784a3bdae6b9a450bab48ee8482d737f44/matplotlib-inline-0.1.6.tar.gz", hash = "sha256:f887e5f10ba98e8d2b150ddcf4702c1e5f8b3a20005eb0f74bfdbd360ee6f304", size = 7790 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f2/51/c34d7a1d528efaae3d8ddb18ef45a41f284eacf9e514523b191b7d0872cc/matplotlib_inline-0.1.6-py3-none-any.whl", hash = "sha256:f1f41aab5328aa5aaea9b16d083b128102f8712542f819fe7e6a420ff581b311", size = 9408 }, +] + +[[package]] +name = "matplotlib-inline" +version = "0.1.7" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", + "python_full_version == '3.10.*'", + "python_full_version == '3.9.*'", + "python_full_version == '3.8.*'", +] +dependencies = [ + { name = "traitlets", version = "5.14.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.8'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/99/5b/a36a337438a14116b16480db471ad061c36c3694df7c2084a0da7ba538b7/matplotlib_inline-0.1.7.tar.gz", hash = "sha256:8423b23ec666be3d16e16b60bdd8ac4e86e840ebd1dd11a30b9f117f2fa0ab90", size = 8159 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8f/8e/9ad090d3553c280a8060fbf6e24dc1c0c29704ee7d1c372f0c174aa59285/matplotlib_inline-0.1.7-py3-none-any.whl", hash = "sha256:df192d39a4ff8f21b1895d72e6a13f5fcc5099f00fa84384e0ea28c2cc0653ca", size = 9899 }, +] + +[[package]] +name = "mdurl" +version = "0.1.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d6/54/cfe61301667036ec958cb99bd3efefba235e65cdeb9c84d24a8293ba1d90/mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba", size = 8729 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8", size = 9979 }, +] + +[[package]] +name = "mistune" +version = "3.0.2" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine != 'aarch64' and platform_machine != 'arm64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'aarch64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'arm64'", + "python_full_version < '3.7.1'", +] +sdist = { url = "https://files.pythonhosted.org/packages/ef/c8/f0173fe3bf85fd891aee2e7bcd8207dfe26c2c683d727c5a6cc3aec7b628/mistune-3.0.2.tar.gz", hash = "sha256:fc7f93ded930c92394ef2cb6f04a8aabab4117a91449e72dcc8dfa646a508be8", size = 90840 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f0/74/c95adcdf032956d9ef6c89a9b8a5152bf73915f8c633f3e3d88d06bd699c/mistune-3.0.2-py3-none-any.whl", hash = "sha256:71481854c30fdbc938963d3605b72501f5c10a9320ecd412c121c163a1c7d205", size = 47958 }, +] + +[[package]] +name = "mistune" +version = "3.1.3" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", + "python_full_version == '3.10.*'", + "python_full_version == '3.9.*'", + "python_full_version == '3.8.*'", +] +dependencies = [ + { name = "typing-extensions", version = "4.12.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.8' and python_full_version < '3.11'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/c4/79/bda47f7dd7c3c55770478d6d02c9960c430b0cf1773b72366ff89126ea31/mistune-3.1.3.tar.gz", hash = "sha256:a7035c21782b2becb6be62f8f25d3df81ccb4d6fa477a6525b15af06539f02a0", size = 94347 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/01/4d/23c4e4f09da849e127e9f123241946c23c1e30f45a88366879e064211815/mistune-3.1.3-py3-none-any.whl", hash = "sha256:1a32314113cff28aa6432e99e522677c8587fd83e3d51c29b82a52409c842bd9", size = 53410 }, +] + +[[package]] +name = "mypy-extensions" +version = "1.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/98/a4/1ab47638b92648243faf97a5aeb6ea83059cc3624972ab6b8d2316078d3f/mypy_extensions-1.0.0.tar.gz", hash = "sha256:75dbf8955dc00442a438fc4d0666508a9a97b6bd41aa2f0ffe9d2f2725af0782", size = 4433 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2a/e2/5d3f6ada4297caebe1a2add3b126fe800c96f56dbe5d1988a2cbe0b267aa/mypy_extensions-1.0.0-py3-none-any.whl", hash = "sha256:4392f6c0eb8a5668a69e23d168ffa70f0be9ccfd32b5cc2d26a34ae5b844552d", size = 4695 }, +] + +[[package]] +name = "nbclient" +version = "0.7.4" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine != 'aarch64' and platform_machine != 'arm64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'aarch64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'arm64'", + "python_full_version < '3.7.1'", +] +dependencies = [ + { name = "jupyter-client", version = "7.4.9", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, + { name = "jupyter-core", version = "4.12.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, + { name = "nbformat", version = "5.8.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, + { name = "traitlets", version = "5.9.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/c8/ee/b9351110fbbc8229863cbc54454f1db91f7836c730018d674a188ede5efd/nbclient-0.7.4.tar.gz", hash = "sha256:d447f0e5a4cfe79d462459aec1b3dc5c2e9152597262be8ee27f7d4c02566a0d", size = 60682 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f3/97/d35da363d1df4a68f1b3d44335f80235487d7ca77d1f606b0c3523118f34/nbclient-0.7.4-py3-none-any.whl", hash = "sha256:c817c0768c5ff0d60e468e017613e6eae27b6fa31e43f905addd2d24df60c125", size = 73120 }, +] + +[[package]] +name = "nbclient" +version = "0.10.1" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version == '3.8.*'", +] +dependencies = [ + { name = "jupyter-client", version = "8.6.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.8.*'" }, + { name = "jupyter-core", version = "5.7.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.8.*'" }, + { name = "nbformat", version = "5.10.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.8.*'" }, + { name = "traitlets", version = "5.14.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.8.*'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/06/db/25929926860ba8a3f6123d2d0a235e558e0e4be7b46e9db063a7dfefa0a2/nbclient-0.10.1.tar.gz", hash = "sha256:3e93e348ab27e712acd46fccd809139e356eb9a31aab641d1a7991a6eb4e6f68", size = 62273 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/26/1a/ed6d1299b1a00c1af4a033fdee565f533926d819e084caf0d2832f6f87c6/nbclient-0.10.1-py3-none-any.whl", hash = "sha256:949019b9240d66897e442888cfb618f69ef23dc71c01cb5fced8499c2cfc084d", size = 25344 }, +] + +[[package]] +name = "nbclient" +version = "0.10.2" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", + "python_full_version == '3.10.*'", + "python_full_version == '3.9.*'", +] +dependencies = [ + { name = "jupyter-client", version = "8.6.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.9'" }, + { name = "jupyter-core", version = "5.7.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.9'" }, + { name = "nbformat", version = "5.10.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.9'" }, + { name = "traitlets", version = "5.14.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.9'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/87/66/7ffd18d58eae90d5721f9f39212327695b749e23ad44b3881744eaf4d9e8/nbclient-0.10.2.tar.gz", hash = "sha256:90b7fc6b810630db87a6d0c2250b1f0ab4cf4d3c27a299b0cde78a4ed3fd9193", size = 62424 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/34/6d/e7fa07f03a4a7b221d94b4d586edb754a9b0dc3c9e2c93353e9fa4e0d117/nbclient-0.10.2-py3-none-any.whl", hash = "sha256:4ffee11e788b4a27fabeb7955547e4318a5298f34342a4bfd01f2e1faaeadc3d", size = 25434 }, +] + +[[package]] +name = "nbconvert" +version = "7.6.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine != 'aarch64' and platform_machine != 'arm64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'aarch64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'arm64'", + "python_full_version < '3.7.1'", +] +dependencies = [ + { name = "beautifulsoup4", marker = "python_full_version < '3.8'" }, + { name = "bleach", version = "6.0.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, + { name = "defusedxml", marker = "python_full_version < '3.8'" }, + { name = "importlib-metadata", version = "6.7.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, + { name = "jinja2", marker = "python_full_version < '3.8'" }, + { name = "jupyter-core", version = "4.12.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, + { name = "jupyterlab-pygments", version = "0.2.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, + { name = "markupsafe", version = "2.1.5", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, + { name = "mistune", version = "3.0.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, + { name = "nbclient", version = "0.7.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, + { name = "nbformat", version = "5.8.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, + { name = "packaging", version = "24.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, + { name = "pandocfilters", marker = "python_full_version < '3.8'" }, + { name = "pygments", version = "2.17.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, + { name = "tinycss2", version = "1.2.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, + { name = "traitlets", version = "5.9.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/e7/0b/b214dd940274564cc610d6c66d98750ca0e8d59281f300451654f4542284/nbconvert-7.6.0.tar.gz", hash = "sha256:24fcf27efdef2b51d7f090cc5ce5a9b178766a55be513c4ebab08c91899ab550", size = 886726 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7d/65/bd0ed8fc533ad31742f2dc629523257ade468dea860d8ebb6faa1448d709/nbconvert-7.6.0-py3-none-any.whl", hash = "sha256:5a445c6794b0791984bc5436608fe2c066cb43c83920c7bc91bde3b765e9a264", size = 290376 }, +] + +[[package]] +name = "nbconvert" +version = "7.16.6" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", + "python_full_version == '3.10.*'", + "python_full_version == '3.9.*'", + "python_full_version == '3.8.*'", +] +dependencies = [ + { name = "beautifulsoup4", marker = "python_full_version >= '3.8'" }, + { name = "bleach", version = "6.1.0", source = { registry = "https://pypi.org/simple" }, extra = ["css"], marker = "python_full_version == '3.8.*'" }, + { name = "bleach", version = "6.2.0", source = { registry = "https://pypi.org/simple" }, extra = ["css"], marker = "python_full_version >= '3.9'" }, + { name = "defusedxml", marker = "python_full_version >= '3.8'" }, + { name = "importlib-metadata", version = "8.5.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.8.*'" }, + { name = "importlib-metadata", version = "8.6.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*'" }, + { name = "jinja2", marker = "python_full_version >= '3.8'" }, + { name = "jupyter-core", version = "5.7.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.8'" }, + { name = "jupyterlab-pygments", version = "0.3.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.8'" }, + { name = "markupsafe", version = "2.1.5", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.8.*'" }, + { name = "markupsafe", version = "3.0.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.9'" }, + { name = "mistune", version = "3.1.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.8'" }, + { name = "nbclient", version = "0.10.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.8.*'" }, + { name = "nbclient", version = "0.10.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.9'" }, + { name = "nbformat", version = "5.10.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.8'" }, + { name = "packaging", version = "24.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.8'" }, + { name = "pandocfilters", marker = "python_full_version >= '3.8'" }, + { name = "pygments", version = "2.19.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.8'" }, + { name = "traitlets", version = "5.14.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.8'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a3/59/f28e15fc47ffb73af68a8d9b47367a8630d76e97ae85ad18271b9db96fdf/nbconvert-7.16.6.tar.gz", hash = "sha256:576a7e37c6480da7b8465eefa66c17844243816ce1ccc372633c6b71c3c0f582", size = 857715 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cc/9a/cd673b2f773a12c992f41309ef81b99da1690426bd2f96957a7ade0d3ed7/nbconvert-7.16.6-py3-none-any.whl", hash = "sha256:1375a7b67e0c2883678c48e506dc320febb57685e5ee67faa51b18a90f3a712b", size = 258525 }, +] + +[[package]] +name = "nbformat" +version = "5.8.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine != 'aarch64' and platform_machine != 'arm64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'aarch64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'arm64'", + "python_full_version < '3.7.1'", +] +dependencies = [ + { name = "fastjsonschema", marker = "python_full_version < '3.8'" }, + { name = "importlib-metadata", version = "6.7.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, + { name = "jsonschema", version = "4.17.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, + { name = "jupyter-core", version = "4.12.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, + { name = "traitlets", version = "5.9.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/08/b7/8b964e977438037b57de31d312d67046e215295899107576e3708b0ea223/nbformat-5.8.0.tar.gz", hash = "sha256:46dac64c781f1c34dfd8acba16547024110348f9fc7eab0f31981c2a3dc48d1f", size = 140655 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1d/f6/38f4694b5035306a8c2685e9e6ea7bf46ea344c03422d7131442ac9677c1/nbformat-5.8.0-py3-none-any.whl", hash = "sha256:d910082bd3e0bffcf07eabf3683ed7dda0727a326c446eeb2922abe102e65162", size = 77369 }, +] + +[[package]] +name = "nbformat" +version = "5.10.4" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", + "python_full_version == '3.10.*'", + "python_full_version == '3.9.*'", + "python_full_version == '3.8.*'", +] +dependencies = [ + { name = "fastjsonschema", marker = "python_full_version >= '3.8'" }, + { name = "jsonschema", version = "4.23.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.8'" }, + { name = "jupyter-core", version = "5.7.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.8'" }, + { name = "traitlets", version = "5.14.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.8'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/6d/fd/91545e604bc3dad7dca9ed03284086039b294c6b3d75c0d2fa45f9e9caf3/nbformat-5.10.4.tar.gz", hash = "sha256:322168b14f937a5d11362988ecac2a4952d3d8e3a2cbeb2319584631226d5b3a", size = 142749 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a9/82/0340caa499416c78e5d8f5f05947ae4bc3cba53c9f038ab6e9ed964e22f1/nbformat-5.10.4-py3-none-any.whl", hash = "sha256:3b48d6c8fbca4b299bf3982ea7db1af21580e4fec269ad087b9e81588891200b", size = 78454 }, +] + +[[package]] +name = "nbsphinx" +version = "0.9.7" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "docutils", version = "0.19", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, + { name = "docutils", version = "0.20.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.8.*'" }, + { name = "docutils", version = "0.21.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.9'" }, + { name = "jinja2" }, + { name = "nbconvert", version = "7.6.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, + { name = "nbconvert", version = "7.16.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.8'" }, + { name = "nbformat", version = "5.8.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, + { name = "nbformat", version = "5.10.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.8'" }, + { name = "sphinx", version = "5.3.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, + { name = "sphinx", version = "7.1.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.8.*'" }, + { name = "sphinx", version = "7.4.7", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*'" }, + { name = "sphinx", version = "8.1.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, + { name = "traitlets", version = "5.9.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, + { name = "traitlets", version = "5.14.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.8'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/1e/84/b1856b7651ac34e965aa567a158714c7f3bd42a1b1ce76bf423ffb99872c/nbsphinx-0.9.7.tar.gz", hash = "sha256:abd298a686d55fa894ef697c51d44f24e53aa312dadae38e82920f250a5456fe", size = 180479 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/49/2d/8c8e635bcc6757573d311bb3c5445426382f280da32b8cd6d82d501ef4a4/nbsphinx-0.9.7-py3-none-any.whl", hash = "sha256:7292c3767fea29e405c60743eee5393682a83982ab202ff98f5eb2db02629da8", size = 31660 }, +] + +[[package]] +name = "nbval" +version = "0.11.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "coverage", version = "7.2.7", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, + { name = "coverage", version = "7.6.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.8.*'" }, + { name = "coverage", version = "7.7.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.9'" }, + { name = "ipykernel", version = "6.16.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, + { name = "ipykernel", version = "6.29.5", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.8'" }, + { name = "jupyter-client", version = "7.4.9", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, + { name = "jupyter-client", version = "8.6.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.8'" }, + { name = "nbformat", version = "5.8.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, + { name = "nbformat", version = "5.10.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.8'" }, + { name = "pytest", version = "7.4.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, + { name = "pytest", version = "8.3.5", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.8'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/28/be/22bd64d09e0cb53258f83b6fc455f05f18a78e3e5c109ccb6af42f1f49a2/nbval-0.11.0.tar.gz", hash = "sha256:77c95797607b0a968babd2597ee3494102d25c3ad37435debbdac0e46e379094", size = 62718 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2c/5c/eb1e3ce54c4e94c7734b3831756c63f21badb3de91a98d77b9e23c0ca76a/nbval-0.11.0-py2.py3-none-any.whl", hash = "sha256:307aecc866c9a1e8a13bb5bbb008a702bacfda2394dff6fe504a3108a58042a0", size = 24013 }, +] + +[[package]] +name = "nest-asyncio" +version = "1.6.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/83/f8/51569ac65d696c8ecbee95938f89d4abf00f47d58d48f6fbabfe8f0baefe/nest_asyncio-1.6.0.tar.gz", hash = "sha256:6f172d5449aca15afd6c646851f4e31e02c598d553a667e38cafa997cfec55fe", size = 7418 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a0/c4/c2971a3ba4c6103a3d10c4b0f24f461ddc027f0f09763220cf35ca1401b3/nest_asyncio-1.6.0-py3-none-any.whl", hash = "sha256:87af6efd6b5e897c81050477ef65c62e2b2f35d51703cae01aff2905b1852e1c", size = 5195 }, +] + +[[package]] +name = "numpy" +version = "1.21.6" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine != 'aarch64' and platform_machine != 'arm64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'aarch64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'arm64'", + "python_full_version < '3.7.1'", +] +sdist = { url = "https://files.pythonhosted.org/packages/45/b7/de7b8e67f2232c26af57c205aaad29fe17754f793404f59c8a730c7a191a/numpy-1.21.6.zip", hash = "sha256:ecb55251139706669fdec2ff073c98ef8e9a84473e51e716211b41aa0f18e656", size = 10274544 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ff/c6/05ae3c7f75b596e1bb3d78131c331eada9376a03d1af9801bd40e4675023/numpy-1.21.6-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:8737609c3bbdd48e380d463134a35ffad3b22dc56295eff6f79fd85bd0eeeb25", size = 27203123 }, + { url = "https://files.pythonhosted.org/packages/4a/72/a3379f83172f1431d7949138373e3a24beed68184c9362dab1b4d465be26/numpy-1.21.6-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:fdffbfb6832cd0b300995a2b08b8f6fa9f6e856d562800fea9182316d99c4e8e", size = 16965603 }, + { url = "https://files.pythonhosted.org/packages/26/e7/4a6f579af8186372b03e8480e47df309520d91cfead8759b64dd5ac62688/numpy-1.21.6-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:3820724272f9913b597ccd13a467cc492a0da6b05df26ea09e78b171a0bb9da6", size = 12364595 }, + { url = "https://files.pythonhosted.org/packages/57/ba/d8cbdfd507b541bb247beff24d9d7304ac8ffc379cf585701187d45d4512/numpy-1.21.6-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f17e562de9edf691a42ddb1eb4a5541c20dd3f9e65b09ded2beb0799c0cf29bb", size = 13019278 }, + { url = "https://files.pythonhosted.org/packages/6f/7b/036000a55680e6c7eb81502b0aa27ce0ed65d4d8805613909967d9f8baf6/numpy-1.21.6-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5f30427731561ce75d7048ac254dbe47a2ba576229250fb60f0fb74db96501a1", size = 15906004 }, + { url = "https://files.pythonhosted.org/packages/b0/77/ff8bbe56ff6cbbdbdb8a641c67cee61e29b2e8bfbb18732c2e1d2961fe4d/numpy-1.21.6-cp310-cp310-win32.whl", hash = "sha256:d4bf4d43077db55589ffc9009c0ba0a94fa4908b9586d6ccce2e0b164c86303c", size = 11706182 }, + { url = "https://files.pythonhosted.org/packages/ec/03/93702ca9c4bd61791e46c80ff1f24943febb2317484cf7e8207688bbbd95/numpy-1.21.6-cp310-cp310-win_amd64.whl", hash = "sha256:d136337ae3cc69aa5e447e78d8e1514be8c3ec9b54264e680cf0b4bd9011574f", size = 14008913 }, + { url = "https://files.pythonhosted.org/packages/32/dd/43d8b2b2ebf424f6555271a4c9f5b50dc3cc0aafa66c72b4d36863f71358/numpy-1.21.6-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:6aaf96c7f8cebc220cdfc03f1d5a31952f027dda050e5a703a0d1c396075e3e7", size = 16894122 }, + { url = "https://files.pythonhosted.org/packages/06/78/b184f13f5461812a17a90b380d70a93fa3532460f0af9d72b0d93d8bc4ff/numpy-1.21.6-cp37-cp37m-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:67c261d6c0a9981820c3a149d255a76918278a6b03b6a036800359aba1256d46", size = 13670697 }, + { url = "https://files.pythonhosted.org/packages/6d/ad/ff3b21ebfe79a4d25b4a4f8e5cf9fd44a204adb6b33c09010f566f51027a/numpy-1.21.6-cp37-cp37m-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:a6be4cb0ef3b8c9250c19cc122267263093eee7edd4e3fa75395dfda8c17a8e2", size = 15702369 }, + { url = "https://files.pythonhosted.org/packages/b7/0d/86662f93102e42545cdf031da4fddf0ace9030ec67478932a628afc5973b/numpy-1.21.6-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7c4068a8c44014b2d55f3c3f574c376b2494ca9cc73d2f1bd692382b6dffe3db", size = 12974170 }, + { url = "https://files.pythonhosted.org/packages/cd/eb/f6f3258e7b0e0cc5c327778312bf4ee4978c8514aa28e97119ee206f6e60/numpy-1.21.6-cp37-cp37m-win32.whl", hash = "sha256:7c7e5fa88d9ff656e067876e4736379cc962d185d5cd808014a8a928d529ef4e", size = 11680505 }, + { url = "https://files.pythonhosted.org/packages/97/9f/da37cc4a188a1d5d203d65ab28d6504e17594b5342e0c1dc5610ee6f4535/numpy-1.21.6-cp37-cp37m-win_amd64.whl", hash = "sha256:bcb238c9c96c00d3085b264e5c1a1207672577b93fa666c3b14a45240b14123a", size = 13969236 }, + { url = "https://files.pythonhosted.org/packages/b5/e2/b2df1f664d644e690b40179fc0a07c163c6decf986c7adee8a85a094e8ce/numpy-1.21.6-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:82691fda7c3f77c90e62da69ae60b5ac08e87e775b09813559f8901a88266552", size = 27127297 }, + { url = "https://files.pythonhosted.org/packages/5b/d4/be63d2bed7d10f443dee42469623326b6bc51c9e5cd096ebb7227bca456f/numpy-1.21.6-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:643843bcc1c50526b3a71cd2ee561cf0d8773f062c8cbaf9ffac9fdf573f83ab", size = 16926225 }, + { url = "https://files.pythonhosted.org/packages/0d/21/036363516c06737135ee58741e9c0af4899348ce3c5f5e04379240edd090/numpy-1.21.6-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:357768c2e4451ac241465157a3e929b265dfac85d9214074985b1786244f2ef3", size = 12329630 }, + { url = "https://files.pythonhosted.org/packages/6a/52/a1dcf14b8e81d49c14112663290ee2ed545bd04988170138284a613bd926/numpy-1.21.6-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:9f411b2c3f3d76bba0865b35a425157c5dcf54937f82bbeb3d3c180789dd66a6", size = 13719672 }, + { url = "https://files.pythonhosted.org/packages/d5/43/e88bb1fb7d040ae8e0e06e749341b13f57701aab11fe9d71c99af6202c5c/numpy-1.21.6-cp38-cp38-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:4aa48afdce4660b0076a00d80afa54e8a97cd49f457d68a4342d188a09451c1a", size = 15749422 }, + { url = "https://files.pythonhosted.org/packages/86/c7/3f68d0a8dcc9458879c614707e6ffaf64a108664cfbba9702d3ba7ca4c82/numpy-1.21.6-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d6a96eef20f639e6a97d23e57dd0c1b1069a7b4fd7027482a4c5c451cd7732f4", size = 13026205 }, + { url = "https://files.pythonhosted.org/packages/6f/47/453023bd298f8b0be092d8a8bdd4b21f87a8c639ecb724a94cd75e23d216/numpy-1.21.6-cp38-cp38-win32.whl", hash = "sha256:5c3c8def4230e1b959671eb959083661b4a0d2e9af93ee339c7dada6759a9470", size = 11707551 }, + { url = "https://files.pythonhosted.org/packages/48/5f/db4550e1c68206814a577ebd92c0dd082f3628fd7fc96725d44a521b0c92/numpy-1.21.6-cp38-cp38-win_amd64.whl", hash = "sha256:bf2ec4b75d0e9356edea834d1de42b31fe11f726a81dfb2c2112bc1eaa508fcf", size = 14009785 }, + { url = "https://files.pythonhosted.org/packages/83/eb/a6a0d7fc8e718776c5c710692ea027607104710cba813c4b869182179334/numpy-1.21.6-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:4391bd07606be175aafd267ef9bea87cf1b8210c787666ce82073b05f202add1", size = 27202394 }, + { url = "https://files.pythonhosted.org/packages/4c/62/07402945bd5d5cf515a5f0cbc7263abf02ec0ddf3b19fbdc4af7537cd4d0/numpy-1.21.6-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:67f21981ba2f9d7ba9ade60c9e8cbaa8cf8e9ae51673934480e45cf55e953673", size = 16965163 }, + { url = "https://files.pythonhosted.org/packages/44/56/041e886b4a8da813b7ec297c270fb3582d2ae8b7f33e106eb5c7a5e9184c/numpy-1.21.6-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:ee5ec40fdd06d62fe5d4084bef4fd50fd4bb6bfd2bf519365f569dc470163ab0", size = 12364236 }, + { url = "https://files.pythonhosted.org/packages/61/f4/f01a8989e53a437ad660ab86c91514bec3d5067393e4a844b259f5a103de/numpy-1.21.6-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:1dbe1c91269f880e364526649a52eff93ac30035507ae980d2fed33aaee633ac", size = 13721583 }, + { url = "https://files.pythonhosted.org/packages/e7/f2/0bdcf2c40ef144cbbc9e0947eea831a145a98b0e5f8438fc09cf7fda0b35/numpy-1.21.6-cp39-cp39-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:d9caa9d5e682102453d96a0ee10c7241b72859b01a941a397fd965f23b3e016b", size = 15734025 }, + { url = "https://files.pythonhosted.org/packages/76/7f/830cf169eede1b855538f962e3a70c31755db6423652695b813ed04ff54e/numpy-1.21.6-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:58459d3bad03343ac4b1b42ed14d571b8743dc80ccbf27444f266729df1d6f5b", size = 13020515 }, + { url = "https://files.pythonhosted.org/packages/1b/b5/7178d5a22427a9195ac69d6ec150415734f7a7a19d1142f82b89ead1dac4/numpy-1.21.6-cp39-cp39-win32.whl", hash = "sha256:7f5ae4f304257569ef3b948810816bc87c9146e8c446053539947eedeaa32786", size = 11706846 }, + { url = "https://files.pythonhosted.org/packages/4d/04/bcd62448f2e772bc90a73ba21bacaa19817ae9905ae639969462862bd071/numpy-1.21.6-cp39-cp39-win_amd64.whl", hash = "sha256:e31f0bb5928b793169b87e3d1e070f2342b22d5245c755e2b81caa29756246c3", size = 14008965 }, + { url = "https://files.pythonhosted.org/packages/2e/5a/6f3e280a10de48395053a559bfcb3b2221b74b57d062c1d6307fc965f549/numpy-1.21.6-pp37-pypy37_pp73-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:dd1c8f6bd65d07d3810b90d02eba7997e32abbdf1277a481d698969e921a3be0", size = 15159527 }, +] + +[[package]] +name = "numpy" +version = "1.24.4" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version == '3.8.*'", +] +sdist = { url = "https://files.pythonhosted.org/packages/a4/9b/027bec52c633f6556dba6b722d9a0befb40498b9ceddd29cbe67a45a127c/numpy-1.24.4.tar.gz", hash = "sha256:80f5e3a4e498641401868df4208b74581206afbee7cf7b8329daae82676d9463", size = 10911229 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/6b/80/6cdfb3e275d95155a34659163b83c09e3a3ff9f1456880bec6cc63d71083/numpy-1.24.4-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:c0bfb52d2169d58c1cdb8cc1f16989101639b34c7d3ce60ed70b19c63eba0b64", size = 19789140 }, + { url = "https://files.pythonhosted.org/packages/64/5f/3f01d753e2175cfade1013eea08db99ba1ee4bdb147ebcf3623b75d12aa7/numpy-1.24.4-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:ed094d4f0c177b1b8e7aa9cba7d6ceed51c0e569a5318ac0ca9a090680a6a1b1", size = 13854297 }, + { url = "https://files.pythonhosted.org/packages/5a/b3/2f9c21d799fa07053ffa151faccdceeb69beec5a010576b8991f614021f7/numpy-1.24.4-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:79fc682a374c4a8ed08b331bef9c5f582585d1048fa6d80bc6c35bc384eee9b4", size = 13995611 }, + { url = "https://files.pythonhosted.org/packages/10/be/ae5bf4737cb79ba437879915791f6f26d92583c738d7d960ad94e5c36adf/numpy-1.24.4-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7ffe43c74893dbf38c2b0a1f5428760a1a9c98285553c89e12d70a96a7f3a4d6", size = 17282357 }, + { url = "https://files.pythonhosted.org/packages/c0/64/908c1087be6285f40e4b3e79454552a701664a079321cff519d8c7051d06/numpy-1.24.4-cp310-cp310-win32.whl", hash = "sha256:4c21decb6ea94057331e111a5bed9a79d335658c27ce2adb580fb4d54f2ad9bc", size = 12429222 }, + { url = "https://files.pythonhosted.org/packages/22/55/3d5a7c1142e0d9329ad27cece17933b0e2ab4e54ddc5c1861fbfeb3f7693/numpy-1.24.4-cp310-cp310-win_amd64.whl", hash = "sha256:b4bea75e47d9586d31e892a7401f76e909712a0fd510f58f5337bea9572c571e", size = 14841514 }, + { url = "https://files.pythonhosted.org/packages/a9/cc/5ed2280a27e5dab12994c884f1f4d8c3bd4d885d02ae9e52a9d213a6a5e2/numpy-1.24.4-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:f136bab9c2cfd8da131132c2cf6cc27331dd6fae65f95f69dcd4ae3c3639c810", size = 19775508 }, + { url = "https://files.pythonhosted.org/packages/c0/bc/77635c657a3668cf652806210b8662e1aff84b818a55ba88257abf6637a8/numpy-1.24.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:e2926dac25b313635e4d6cf4dc4e51c8c0ebfed60b801c799ffc4c32bf3d1254", size = 13840033 }, + { url = "https://files.pythonhosted.org/packages/a7/4c/96cdaa34f54c05e97c1c50f39f98d608f96f0677a6589e64e53104e22904/numpy-1.24.4-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:222e40d0e2548690405b0b3c7b21d1169117391c2e82c378467ef9ab4c8f0da7", size = 13991951 }, + { url = "https://files.pythonhosted.org/packages/22/97/dfb1a31bb46686f09e68ea6ac5c63fdee0d22d7b23b8f3f7ea07712869ef/numpy-1.24.4-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7215847ce88a85ce39baf9e89070cb860c98fdddacbaa6c0da3ffb31b3350bd5", size = 17278923 }, + { url = "https://files.pythonhosted.org/packages/35/e2/76a11e54139654a324d107da1d98f99e7aa2a7ef97cfd7c631fba7dbde71/numpy-1.24.4-cp311-cp311-win32.whl", hash = "sha256:4979217d7de511a8d57f4b4b5b2b965f707768440c17cb70fbf254c4b225238d", size = 12422446 }, + { url = "https://files.pythonhosted.org/packages/d8/ec/ebef2f7d7c28503f958f0f8b992e7ce606fb74f9e891199329d5f5f87404/numpy-1.24.4-cp311-cp311-win_amd64.whl", hash = "sha256:b7b1fc9864d7d39e28f41d089bfd6353cb5f27ecd9905348c24187a768c79694", size = 14834466 }, + { url = "https://files.pythonhosted.org/packages/11/10/943cfb579f1a02909ff96464c69893b1d25be3731b5d3652c2e0cf1281ea/numpy-1.24.4-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:1452241c290f3e2a312c137a9999cdbf63f78864d63c79039bda65ee86943f61", size = 19780722 }, + { url = "https://files.pythonhosted.org/packages/a7/ae/f53b7b265fdc701e663fbb322a8e9d4b14d9cb7b2385f45ddfabfc4327e4/numpy-1.24.4-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:04640dab83f7c6c85abf9cd729c5b65f1ebd0ccf9de90b270cd61935eef0197f", size = 13843102 }, + { url = "https://files.pythonhosted.org/packages/25/6f/2586a50ad72e8dbb1d8381f837008a0321a3516dfd7cb57fc8cf7e4bb06b/numpy-1.24.4-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a5425b114831d1e77e4b5d812b69d11d962e104095a5b9c3b641a218abcc050e", size = 14039616 }, + { url = "https://files.pythonhosted.org/packages/98/5d/5738903efe0ecb73e51eb44feafba32bdba2081263d40c5043568ff60faf/numpy-1.24.4-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dd80e219fd4c71fc3699fc1dadac5dcf4fd882bfc6f7ec53d30fa197b8ee22dc", size = 17316263 }, + { url = "https://files.pythonhosted.org/packages/d1/57/8d328f0b91c733aa9aa7ee540dbc49b58796c862b4fbcb1146c701e888da/numpy-1.24.4-cp38-cp38-win32.whl", hash = "sha256:4602244f345453db537be5314d3983dbf5834a9701b7723ec28923e2889e0bb2", size = 12455660 }, + { url = "https://files.pythonhosted.org/packages/69/65/0d47953afa0ad569d12de5f65d964321c208492064c38fe3b0b9744f8d44/numpy-1.24.4-cp38-cp38-win_amd64.whl", hash = "sha256:692f2e0f55794943c5bfff12b3f56f99af76f902fc47487bdfe97856de51a706", size = 14868112 }, + { url = "https://files.pythonhosted.org/packages/9a/cd/d5b0402b801c8a8b56b04c1e85c6165efab298d2f0ab741c2406516ede3a/numpy-1.24.4-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:2541312fbf09977f3b3ad449c4e5f4bb55d0dbf79226d7724211acc905049400", size = 19816549 }, + { url = "https://files.pythonhosted.org/packages/14/27/638aaa446f39113a3ed38b37a66243e21b38110d021bfcb940c383e120f2/numpy-1.24.4-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:9667575fb6d13c95f1b36aca12c5ee3356bf001b714fc354eb5465ce1609e62f", size = 13879950 }, + { url = "https://files.pythonhosted.org/packages/8f/27/91894916e50627476cff1a4e4363ab6179d01077d71b9afed41d9e1f18bf/numpy-1.24.4-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f3a86ed21e4f87050382c7bc96571755193c4c1392490744ac73d660e8f564a9", size = 14030228 }, + { url = "https://files.pythonhosted.org/packages/7a/7c/d7b2a0417af6428440c0ad7cb9799073e507b1a465f827d058b826236964/numpy-1.24.4-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d11efb4dbecbdf22508d55e48d9c8384db795e1b7b51ea735289ff96613ff74d", size = 17311170 }, + { url = "https://files.pythonhosted.org/packages/18/9d/e02ace5d7dfccee796c37b995c63322674daf88ae2f4a4724c5dd0afcc91/numpy-1.24.4-cp39-cp39-win32.whl", hash = "sha256:6620c0acd41dbcb368610bb2f4d83145674040025e5536954782467100aa8835", size = 12454918 }, + { url = "https://files.pythonhosted.org/packages/63/38/6cc19d6b8bfa1d1a459daf2b3fe325453153ca7019976274b6f33d8b5663/numpy-1.24.4-cp39-cp39-win_amd64.whl", hash = "sha256:befe2bf740fd8373cf56149a5c23a0f601e82869598d41f8e188a0e9869926f8", size = 14867441 }, + { url = "https://files.pythonhosted.org/packages/a4/fd/8dff40e25e937c94257455c237b9b6bf5a30d42dd1cc11555533be099492/numpy-1.24.4-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:31f13e25b4e304632a4619d0e0777662c2ffea99fcae2029556b17d8ff958aef", size = 19156590 }, + { url = "https://files.pythonhosted.org/packages/42/e7/4bf953c6e05df90c6d351af69966384fed8e988d0e8c54dad7103b59f3ba/numpy-1.24.4-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:95f7ac6540e95bc440ad77f56e520da5bf877f87dca58bd095288dce8940532a", size = 16705744 }, + { url = "https://files.pythonhosted.org/packages/fc/dd/9106005eb477d022b60b3817ed5937a43dad8fd1f20b0610ea8a32fcb407/numpy-1.24.4-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:e98f220aa76ca2a977fe435f5b04d7b3470c0a2e6312907b37ba6068f26787f2", size = 14734290 }, +] + +[[package]] +name = "numpy" +version = "2.0.2" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version == '3.9.*'", +] +sdist = { url = "https://files.pythonhosted.org/packages/a9/75/10dd1f8116a8b796cb2c737b674e02d02e80454bda953fa7e65d8c12b016/numpy-2.0.2.tar.gz", hash = "sha256:883c987dee1880e2a864ab0dc9892292582510604156762362d9326444636e78", size = 18902015 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/21/91/3495b3237510f79f5d81f2508f9f13fea78ebfdf07538fc7444badda173d/numpy-2.0.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:51129a29dbe56f9ca83438b706e2e69a39892b5eda6cedcb6b0c9fdc9b0d3ece", size = 21165245 }, + { url = "https://files.pythonhosted.org/packages/05/33/26178c7d437a87082d11019292dce6d3fe6f0e9026b7b2309cbf3e489b1d/numpy-2.0.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:f15975dfec0cf2239224d80e32c3170b1d168335eaedee69da84fbe9f1f9cd04", size = 13738540 }, + { url = "https://files.pythonhosted.org/packages/ec/31/cc46e13bf07644efc7a4bf68df2df5fb2a1a88d0cd0da9ddc84dc0033e51/numpy-2.0.2-cp310-cp310-macosx_14_0_arm64.whl", hash = "sha256:8c5713284ce4e282544c68d1c3b2c7161d38c256d2eefc93c1d683cf47683e66", size = 5300623 }, + { url = "https://files.pythonhosted.org/packages/6e/16/7bfcebf27bb4f9d7ec67332ffebee4d1bf085c84246552d52dbb548600e7/numpy-2.0.2-cp310-cp310-macosx_14_0_x86_64.whl", hash = "sha256:becfae3ddd30736fe1889a37f1f580e245ba79a5855bff5f2a29cb3ccc22dd7b", size = 6901774 }, + { url = "https://files.pythonhosted.org/packages/f9/a3/561c531c0e8bf082c5bef509d00d56f82e0ea7e1e3e3a7fc8fa78742a6e5/numpy-2.0.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2da5960c3cf0df7eafefd806d4e612c5e19358de82cb3c343631188991566ccd", size = 13907081 }, + { url = "https://files.pythonhosted.org/packages/fa/66/f7177ab331876200ac7563a580140643d1179c8b4b6a6b0fc9838de2a9b8/numpy-2.0.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:496f71341824ed9f3d2fd36cf3ac57ae2e0165c143b55c3a035ee219413f3318", size = 19523451 }, + { url = "https://files.pythonhosted.org/packages/25/7f/0b209498009ad6453e4efc2c65bcdf0ae08a182b2b7877d7ab38a92dc542/numpy-2.0.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:a61ec659f68ae254e4d237816e33171497e978140353c0c2038d46e63282d0c8", size = 19927572 }, + { url = "https://files.pythonhosted.org/packages/3e/df/2619393b1e1b565cd2d4c4403bdd979621e2c4dea1f8532754b2598ed63b/numpy-2.0.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:d731a1c6116ba289c1e9ee714b08a8ff882944d4ad631fd411106a30f083c326", size = 14400722 }, + { url = "https://files.pythonhosted.org/packages/22/ad/77e921b9f256d5da36424ffb711ae79ca3f451ff8489eeca544d0701d74a/numpy-2.0.2-cp310-cp310-win32.whl", hash = "sha256:984d96121c9f9616cd33fbd0618b7f08e0cfc9600a7ee1d6fd9b239186d19d97", size = 6472170 }, + { url = "https://files.pythonhosted.org/packages/10/05/3442317535028bc29cf0c0dd4c191a4481e8376e9f0db6bcf29703cadae6/numpy-2.0.2-cp310-cp310-win_amd64.whl", hash = "sha256:c7b0be4ef08607dd04da4092faee0b86607f111d5ae68036f16cc787e250a131", size = 15905558 }, + { url = "https://files.pythonhosted.org/packages/8b/cf/034500fb83041aa0286e0fb16e7c76e5c8b67c0711bb6e9e9737a717d5fe/numpy-2.0.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:49ca4decb342d66018b01932139c0961a8f9ddc7589611158cb3c27cbcf76448", size = 21169137 }, + { url = "https://files.pythonhosted.org/packages/4a/d9/32de45561811a4b87fbdee23b5797394e3d1504b4a7cf40c10199848893e/numpy-2.0.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:11a76c372d1d37437857280aa142086476136a8c0f373b2e648ab2c8f18fb195", size = 13703552 }, + { url = "https://files.pythonhosted.org/packages/c1/ca/2f384720020c7b244d22508cb7ab23d95f179fcfff33c31a6eeba8d6c512/numpy-2.0.2-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:807ec44583fd708a21d4a11d94aedf2f4f3c3719035c76a2bbe1fe8e217bdc57", size = 5298957 }, + { url = "https://files.pythonhosted.org/packages/0e/78/a3e4f9fb6aa4e6fdca0c5428e8ba039408514388cf62d89651aade838269/numpy-2.0.2-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:8cafab480740e22f8d833acefed5cc87ce276f4ece12fdaa2e8903db2f82897a", size = 6905573 }, + { url = "https://files.pythonhosted.org/packages/a0/72/cfc3a1beb2caf4efc9d0b38a15fe34025230da27e1c08cc2eb9bfb1c7231/numpy-2.0.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a15f476a45e6e5a3a79d8a14e62161d27ad897381fecfa4a09ed5322f2085669", size = 13914330 }, + { url = "https://files.pythonhosted.org/packages/ba/a8/c17acf65a931ce551fee11b72e8de63bf7e8a6f0e21add4c937c83563538/numpy-2.0.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:13e689d772146140a252c3a28501da66dfecd77490b498b168b501835041f951", size = 19534895 }, + { url = "https://files.pythonhosted.org/packages/ba/86/8767f3d54f6ae0165749f84648da9dcc8cd78ab65d415494962c86fac80f/numpy-2.0.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:9ea91dfb7c3d1c56a0e55657c0afb38cf1eeae4544c208dc465c3c9f3a7c09f9", size = 19937253 }, + { url = "https://files.pythonhosted.org/packages/df/87/f76450e6e1c14e5bb1eae6836478b1028e096fd02e85c1c37674606ab752/numpy-2.0.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:c1c9307701fec8f3f7a1e6711f9089c06e6284b3afbbcd259f7791282d660a15", size = 14414074 }, + { url = "https://files.pythonhosted.org/packages/5c/ca/0f0f328e1e59f73754f06e1adfb909de43726d4f24c6a3f8805f34f2b0fa/numpy-2.0.2-cp311-cp311-win32.whl", hash = "sha256:a392a68bd329eafac5817e5aefeb39038c48b671afd242710b451e76090e81f4", size = 6470640 }, + { url = "https://files.pythonhosted.org/packages/eb/57/3a3f14d3a759dcf9bf6e9eda905794726b758819df4663f217d658a58695/numpy-2.0.2-cp311-cp311-win_amd64.whl", hash = "sha256:286cd40ce2b7d652a6f22efdfc6d1edf879440e53e76a75955bc0c826c7e64dc", size = 15910230 }, + { url = "https://files.pythonhosted.org/packages/45/40/2e117be60ec50d98fa08c2f8c48e09b3edea93cfcabd5a9ff6925d54b1c2/numpy-2.0.2-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:df55d490dea7934f330006d0f81e8551ba6010a5bf035a249ef61a94f21c500b", size = 20895803 }, + { url = "https://files.pythonhosted.org/packages/46/92/1b8b8dee833f53cef3e0a3f69b2374467789e0bb7399689582314df02651/numpy-2.0.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8df823f570d9adf0978347d1f926b2a867d5608f434a7cff7f7908c6570dcf5e", size = 13471835 }, + { url = "https://files.pythonhosted.org/packages/7f/19/e2793bde475f1edaea6945be141aef6c8b4c669b90c90a300a8954d08f0a/numpy-2.0.2-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:9a92ae5c14811e390f3767053ff54eaee3bf84576d99a2456391401323f4ec2c", size = 5038499 }, + { url = "https://files.pythonhosted.org/packages/e3/ff/ddf6dac2ff0dd50a7327bcdba45cb0264d0e96bb44d33324853f781a8f3c/numpy-2.0.2-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:a842d573724391493a97a62ebbb8e731f8a5dcc5d285dfc99141ca15a3302d0c", size = 6633497 }, + { url = "https://files.pythonhosted.org/packages/72/21/67f36eac8e2d2cd652a2e69595a54128297cdcb1ff3931cfc87838874bd4/numpy-2.0.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c05e238064fc0610c840d1cf6a13bf63d7e391717d247f1bf0318172e759e692", size = 13621158 }, + { url = "https://files.pythonhosted.org/packages/39/68/e9f1126d757653496dbc096cb429014347a36b228f5a991dae2c6b6cfd40/numpy-2.0.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0123ffdaa88fa4ab64835dcbde75dcdf89c453c922f18dced6e27c90d1d0ec5a", size = 19236173 }, + { url = "https://files.pythonhosted.org/packages/d1/e9/1f5333281e4ebf483ba1c888b1d61ba7e78d7e910fdd8e6499667041cc35/numpy-2.0.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:96a55f64139912d61de9137f11bf39a55ec8faec288c75a54f93dfd39f7eb40c", size = 19634174 }, + { url = "https://files.pythonhosted.org/packages/71/af/a469674070c8d8408384e3012e064299f7a2de540738a8e414dcfd639996/numpy-2.0.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:ec9852fb39354b5a45a80bdab5ac02dd02b15f44b3804e9f00c556bf24b4bded", size = 14099701 }, + { url = "https://files.pythonhosted.org/packages/d0/3d/08ea9f239d0e0e939b6ca52ad403c84a2bce1bde301a8eb4888c1c1543f1/numpy-2.0.2-cp312-cp312-win32.whl", hash = "sha256:671bec6496f83202ed2d3c8fdc486a8fc86942f2e69ff0e986140339a63bcbe5", size = 6174313 }, + { url = "https://files.pythonhosted.org/packages/b2/b5/4ac39baebf1fdb2e72585c8352c56d063b6126be9fc95bd2bb5ef5770c20/numpy-2.0.2-cp312-cp312-win_amd64.whl", hash = "sha256:cfd41e13fdc257aa5778496b8caa5e856dc4896d4ccf01841daee1d96465467a", size = 15606179 }, + { url = "https://files.pythonhosted.org/packages/43/c1/41c8f6df3162b0c6ffd4437d729115704bd43363de0090c7f913cfbc2d89/numpy-2.0.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:9059e10581ce4093f735ed23f3b9d283b9d517ff46009ddd485f1747eb22653c", size = 21169942 }, + { url = "https://files.pythonhosted.org/packages/39/bc/fd298f308dcd232b56a4031fd6ddf11c43f9917fbc937e53762f7b5a3bb1/numpy-2.0.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:423e89b23490805d2a5a96fe40ec507407b8ee786d66f7328be214f9679df6dd", size = 13711512 }, + { url = "https://files.pythonhosted.org/packages/96/ff/06d1aa3eeb1c614eda245c1ba4fb88c483bee6520d361641331872ac4b82/numpy-2.0.2-cp39-cp39-macosx_14_0_arm64.whl", hash = "sha256:2b2955fa6f11907cf7a70dab0d0755159bca87755e831e47932367fc8f2f2d0b", size = 5306976 }, + { url = "https://files.pythonhosted.org/packages/2d/98/121996dcfb10a6087a05e54453e28e58694a7db62c5a5a29cee14c6e047b/numpy-2.0.2-cp39-cp39-macosx_14_0_x86_64.whl", hash = "sha256:97032a27bd9d8988b9a97a8c4d2c9f2c15a81f61e2f21404d7e8ef00cb5be729", size = 6906494 }, + { url = "https://files.pythonhosted.org/packages/15/31/9dffc70da6b9bbf7968f6551967fc21156207366272c2a40b4ed6008dc9b/numpy-2.0.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1e795a8be3ddbac43274f18588329c72939870a16cae810c2b73461c40718ab1", size = 13912596 }, + { url = "https://files.pythonhosted.org/packages/b9/14/78635daab4b07c0930c919d451b8bf8c164774e6a3413aed04a6d95758ce/numpy-2.0.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f26b258c385842546006213344c50655ff1555a9338e2e5e02a0756dc3e803dd", size = 19526099 }, + { url = "https://files.pythonhosted.org/packages/26/4c/0eeca4614003077f68bfe7aac8b7496f04221865b3a5e7cb230c9d055afd/numpy-2.0.2-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:5fec9451a7789926bcf7c2b8d187292c9f93ea30284802a0ab3f5be8ab36865d", size = 19932823 }, + { url = "https://files.pythonhosted.org/packages/f1/46/ea25b98b13dccaebddf1a803f8c748680d972e00507cd9bc6dcdb5aa2ac1/numpy-2.0.2-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:9189427407d88ff25ecf8f12469d4d39d35bee1db5d39fc5c168c6f088a6956d", size = 14404424 }, + { url = "https://files.pythonhosted.org/packages/c8/a6/177dd88d95ecf07e722d21008b1b40e681a929eb9e329684d449c36586b2/numpy-2.0.2-cp39-cp39-win32.whl", hash = "sha256:905d16e0c60200656500c95b6b8dca5d109e23cb24abc701d41c02d74c6b3afa", size = 6476809 }, + { url = "https://files.pythonhosted.org/packages/ea/2b/7fc9f4e7ae5b507c1a3a21f0f15ed03e794c1242ea8a242ac158beb56034/numpy-2.0.2-cp39-cp39-win_amd64.whl", hash = "sha256:a3f4ab0caa7f053f6797fcd4e1e25caee367db3112ef2b6ef82d749530768c73", size = 15911314 }, + { url = "https://files.pythonhosted.org/packages/8f/3b/df5a870ac6a3be3a86856ce195ef42eec7ae50d2a202be1f5a4b3b340e14/numpy-2.0.2-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:7f0a0c6f12e07fa94133c8a67404322845220c06a9e80e85999afe727f7438b8", size = 21025288 }, + { url = "https://files.pythonhosted.org/packages/2c/97/51af92f18d6f6f2d9ad8b482a99fb74e142d71372da5d834b3a2747a446e/numpy-2.0.2-pp39-pypy39_pp73-macosx_14_0_x86_64.whl", hash = "sha256:312950fdd060354350ed123c0e25a71327d3711584beaef30cdaa93320c392d4", size = 6762793 }, + { url = "https://files.pythonhosted.org/packages/12/46/de1fbd0c1b5ccaa7f9a005b66761533e2f6a3e560096682683a223631fe9/numpy-2.0.2-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:26df23238872200f63518dd2aa984cfca675d82469535dc7162dc2ee52d9dd5c", size = 19334885 }, + { url = "https://files.pythonhosted.org/packages/cc/dc/d330a6faefd92b446ec0f0dfea4c3207bb1fef3c4771d19cf4543efd2c78/numpy-2.0.2-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:a46288ec55ebbd58947d31d72be2c63cbf839f0a63b49cb755022310792a3385", size = 15828784 }, +] + +[[package]] +name = "numpy" +version = "2.2.4" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", + "python_full_version == '3.10.*'", +] +sdist = { url = "https://files.pythonhosted.org/packages/e1/78/31103410a57bc2c2b93a3597340a8119588571f6a4539067546cb9a0bfac/numpy-2.2.4.tar.gz", hash = "sha256:9ba03692a45d3eef66559efe1d1096c4b9b75c0986b5dff5530c378fb8331d4f", size = 20270701 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/04/89/a79e86e5c1433926ed7d60cb267fb64aa578b6101ab645800fd43b4801de/numpy-2.2.4-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:8146f3550d627252269ac42ae660281d673eb6f8b32f113538e0cc2a9aed42b9", size = 21250661 }, + { url = "https://files.pythonhosted.org/packages/79/c2/f50921beb8afd60ed9589ad880332cfefdb805422210d327fb48f12b7a81/numpy-2.2.4-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:e642d86b8f956098b564a45e6f6ce68a22c2c97a04f5acd3f221f57b8cb850ae", size = 14389926 }, + { url = "https://files.pythonhosted.org/packages/c7/b9/2c4e96130b0b0f97b0ef4a06d6dae3b39d058b21a5e2fa2decd7fd6b1c8f/numpy-2.2.4-cp310-cp310-macosx_14_0_arm64.whl", hash = "sha256:a84eda42bd12edc36eb5b53bbcc9b406820d3353f1994b6cfe453a33ff101775", size = 5428329 }, + { url = "https://files.pythonhosted.org/packages/7f/a5/3d7094aa898f4fc5c84cdfb26beeae780352d43f5d8bdec966c4393d644c/numpy-2.2.4-cp310-cp310-macosx_14_0_x86_64.whl", hash = "sha256:4ba5054787e89c59c593a4169830ab362ac2bee8a969249dc56e5d7d20ff8df9", size = 6963559 }, + { url = "https://files.pythonhosted.org/packages/4c/22/fb1be710a14434c09080dd4a0acc08939f612ec02efcb04b9e210474782d/numpy-2.2.4-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7716e4a9b7af82c06a2543c53ca476fa0b57e4d760481273e09da04b74ee6ee2", size = 14368066 }, + { url = "https://files.pythonhosted.org/packages/c2/07/2e5cc71193e3ef3a219ffcf6ca4858e46ea2be09c026ddd480d596b32867/numpy-2.2.4-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:adf8c1d66f432ce577d0197dceaac2ac00c0759f573f28516246351c58a85020", size = 16417040 }, + { url = "https://files.pythonhosted.org/packages/1a/97/3b1537776ad9a6d1a41813818343745e8dd928a2916d4c9edcd9a8af1dac/numpy-2.2.4-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:218f061d2faa73621fa23d6359442b0fc658d5b9a70801373625d958259eaca3", size = 15879862 }, + { url = "https://files.pythonhosted.org/packages/b0/b7/4472f603dd45ef36ff3d8e84e84fe02d9467c78f92cc121633dce6da307b/numpy-2.2.4-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:df2f57871a96bbc1b69733cd4c51dc33bea66146b8c63cacbfed73eec0883017", size = 18206032 }, + { url = "https://files.pythonhosted.org/packages/0d/bd/6a092963fb82e6c5aa0d0440635827bbb2910da229545473bbb58c537ed3/numpy-2.2.4-cp310-cp310-win32.whl", hash = "sha256:a0258ad1f44f138b791327961caedffbf9612bfa504ab9597157806faa95194a", size = 6608517 }, + { url = "https://files.pythonhosted.org/packages/01/e3/cb04627bc2a1638948bc13e818df26495aa18e20d5be1ed95ab2b10b6847/numpy-2.2.4-cp310-cp310-win_amd64.whl", hash = "sha256:0d54974f9cf14acf49c60f0f7f4084b6579d24d439453d5fc5805d46a165b542", size = 12943498 }, + { url = "https://files.pythonhosted.org/packages/16/fb/09e778ee3a8ea0d4dc8329cca0a9c9e65fed847d08e37eba74cb7ed4b252/numpy-2.2.4-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:e9e0a277bb2eb5d8a7407e14688b85fd8ad628ee4e0c7930415687b6564207a4", size = 21254989 }, + { url = "https://files.pythonhosted.org/packages/a2/0a/1212befdbecab5d80eca3cde47d304cad986ad4eec7d85a42e0b6d2cc2ef/numpy-2.2.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:9eeea959168ea555e556b8188da5fa7831e21d91ce031e95ce23747b7609f8a4", size = 14425910 }, + { url = "https://files.pythonhosted.org/packages/2b/3e/e7247c1d4f15086bb106c8d43c925b0b2ea20270224f5186fa48d4fb5cbd/numpy-2.2.4-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:bd3ad3b0a40e713fc68f99ecfd07124195333f1e689387c180813f0e94309d6f", size = 5426490 }, + { url = "https://files.pythonhosted.org/packages/5d/fa/aa7cd6be51419b894c5787a8a93c3302a1ed4f82d35beb0613ec15bdd0e2/numpy-2.2.4-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:cf28633d64294969c019c6df4ff37f5698e8326db68cc2b66576a51fad634880", size = 6967754 }, + { url = "https://files.pythonhosted.org/packages/d5/ee/96457c943265de9fadeb3d2ffdbab003f7fba13d971084a9876affcda095/numpy-2.2.4-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2fa8fa7697ad1646b5c93de1719965844e004fcad23c91228aca1cf0800044a1", size = 14373079 }, + { url = "https://files.pythonhosted.org/packages/c5/5c/ceefca458559f0ccc7a982319f37ed07b0d7b526964ae6cc61f8ad1b6119/numpy-2.2.4-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f4162988a360a29af158aeb4a2f4f09ffed6a969c9776f8f3bdee9b06a8ab7e5", size = 16428819 }, + { url = "https://files.pythonhosted.org/packages/22/31/9b2ac8eee99e001eb6add9fa27514ef5e9faf176169057a12860af52704c/numpy-2.2.4-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:892c10d6a73e0f14935c31229e03325a7b3093fafd6ce0af704be7f894d95687", size = 15881470 }, + { url = "https://files.pythonhosted.org/packages/f0/dc/8569b5f25ff30484b555ad8a3f537e0225d091abec386c9420cf5f7a2976/numpy-2.2.4-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:db1f1c22173ac1c58db249ae48aa7ead29f534b9a948bc56828337aa84a32ed6", size = 18218144 }, + { url = "https://files.pythonhosted.org/packages/5e/05/463c023a39bdeb9bb43a99e7dee2c664cb68d5bb87d14f92482b9f6011cc/numpy-2.2.4-cp311-cp311-win32.whl", hash = "sha256:ea2bb7e2ae9e37d96835b3576a4fa4b3a97592fbea8ef7c3587078b0068b8f09", size = 6606368 }, + { url = "https://files.pythonhosted.org/packages/8b/72/10c1d2d82101c468a28adc35de6c77b308f288cfd0b88e1070f15b98e00c/numpy-2.2.4-cp311-cp311-win_amd64.whl", hash = "sha256:f7de08cbe5551911886d1ab60de58448c6df0f67d9feb7d1fb21e9875ef95e91", size = 12947526 }, + { url = "https://files.pythonhosted.org/packages/a2/30/182db21d4f2a95904cec1a6f779479ea1ac07c0647f064dea454ec650c42/numpy-2.2.4-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:a7b9084668aa0f64e64bd00d27ba5146ef1c3a8835f3bd912e7a9e01326804c4", size = 20947156 }, + { url = "https://files.pythonhosted.org/packages/24/6d/9483566acfbda6c62c6bc74b6e981c777229d2af93c8eb2469b26ac1b7bc/numpy-2.2.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:dbe512c511956b893d2dacd007d955a3f03d555ae05cfa3ff1c1ff6df8851854", size = 14133092 }, + { url = "https://files.pythonhosted.org/packages/27/f6/dba8a258acbf9d2bed2525cdcbb9493ef9bae5199d7a9cb92ee7e9b2aea6/numpy-2.2.4-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:bb649f8b207ab07caebba230d851b579a3c8711a851d29efe15008e31bb4de24", size = 5163515 }, + { url = "https://files.pythonhosted.org/packages/62/30/82116199d1c249446723c68f2c9da40d7f062551036f50b8c4caa42ae252/numpy-2.2.4-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:f34dc300df798742b3d06515aa2a0aee20941c13579d7a2f2e10af01ae4901ee", size = 6696558 }, + { url = "https://files.pythonhosted.org/packages/0e/b2/54122b3c6df5df3e87582b2e9430f1bdb63af4023c739ba300164c9ae503/numpy-2.2.4-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c3f7ac96b16955634e223b579a3e5798df59007ca43e8d451a0e6a50f6bfdfba", size = 14084742 }, + { url = "https://files.pythonhosted.org/packages/02/e2/e2cbb8d634151aab9528ef7b8bab52ee4ab10e076509285602c2a3a686e0/numpy-2.2.4-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4f92084defa704deadd4e0a5ab1dc52d8ac9e8a8ef617f3fbb853e79b0ea3592", size = 16134051 }, + { url = "https://files.pythonhosted.org/packages/8e/21/efd47800e4affc993e8be50c1b768de038363dd88865920439ef7b422c60/numpy-2.2.4-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:7a4e84a6283b36632e2a5b56e121961f6542ab886bc9e12f8f9818b3c266bfbb", size = 15578972 }, + { url = "https://files.pythonhosted.org/packages/04/1e/f8bb88f6157045dd5d9b27ccf433d016981032690969aa5c19e332b138c0/numpy-2.2.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:11c43995255eb4127115956495f43e9343736edb7fcdb0d973defd9de14cd84f", size = 17898106 }, + { url = "https://files.pythonhosted.org/packages/2b/93/df59a5a3897c1f036ae8ff845e45f4081bb06943039ae28a3c1c7c780f22/numpy-2.2.4-cp312-cp312-win32.whl", hash = "sha256:65ef3468b53269eb5fdb3a5c09508c032b793da03251d5f8722b1194f1790c00", size = 6311190 }, + { url = "https://files.pythonhosted.org/packages/46/69/8c4f928741c2a8efa255fdc7e9097527c6dc4e4df147e3cadc5d9357ce85/numpy-2.2.4-cp312-cp312-win_amd64.whl", hash = "sha256:2aad3c17ed2ff455b8eaafe06bcdae0062a1db77cb99f4b9cbb5f4ecb13c5146", size = 12644305 }, + { url = "https://files.pythonhosted.org/packages/2a/d0/bd5ad792e78017f5decfb2ecc947422a3669a34f775679a76317af671ffc/numpy-2.2.4-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:1cf4e5c6a278d620dee9ddeb487dc6a860f9b199eadeecc567f777daace1e9e7", size = 20933623 }, + { url = "https://files.pythonhosted.org/packages/c3/bc/2b3545766337b95409868f8e62053135bdc7fa2ce630aba983a2aa60b559/numpy-2.2.4-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:1974afec0b479e50438fc3648974268f972e2d908ddb6d7fb634598cdb8260a0", size = 14148681 }, + { url = "https://files.pythonhosted.org/packages/6a/70/67b24d68a56551d43a6ec9fe8c5f91b526d4c1a46a6387b956bf2d64744e/numpy-2.2.4-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:79bd5f0a02aa16808fcbc79a9a376a147cc1045f7dfe44c6e7d53fa8b8a79392", size = 5148759 }, + { url = "https://files.pythonhosted.org/packages/1c/8b/e2fc8a75fcb7be12d90b31477c9356c0cbb44abce7ffb36be39a0017afad/numpy-2.2.4-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:3387dd7232804b341165cedcb90694565a6015433ee076c6754775e85d86f1fc", size = 6683092 }, + { url = "https://files.pythonhosted.org/packages/13/73/41b7b27f169ecf368b52533edb72e56a133f9e86256e809e169362553b49/numpy-2.2.4-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6f527d8fdb0286fd2fd97a2a96c6be17ba4232da346931d967a0630050dfd298", size = 14081422 }, + { url = "https://files.pythonhosted.org/packages/4b/04/e208ff3ae3ddfbafc05910f89546382f15a3f10186b1f56bd99f159689c2/numpy-2.2.4-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bce43e386c16898b91e162e5baaad90c4b06f9dcbe36282490032cec98dc8ae7", size = 16132202 }, + { url = "https://files.pythonhosted.org/packages/fe/bc/2218160574d862d5e55f803d88ddcad88beff94791f9c5f86d67bd8fbf1c/numpy-2.2.4-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:31504f970f563d99f71a3512d0c01a645b692b12a63630d6aafa0939e52361e6", size = 15573131 }, + { url = "https://files.pythonhosted.org/packages/a5/78/97c775bc4f05abc8a8426436b7cb1be806a02a2994b195945600855e3a25/numpy-2.2.4-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:81413336ef121a6ba746892fad881a83351ee3e1e4011f52e97fba79233611fd", size = 17894270 }, + { url = "https://files.pythonhosted.org/packages/b9/eb/38c06217a5f6de27dcb41524ca95a44e395e6a1decdc0c99fec0832ce6ae/numpy-2.2.4-cp313-cp313-win32.whl", hash = "sha256:f486038e44caa08dbd97275a9a35a283a8f1d2f0ee60ac260a1790e76660833c", size = 6308141 }, + { url = "https://files.pythonhosted.org/packages/52/17/d0dd10ab6d125c6d11ffb6dfa3423c3571befab8358d4f85cd4471964fcd/numpy-2.2.4-cp313-cp313-win_amd64.whl", hash = "sha256:207a2b8441cc8b6a2a78c9ddc64d00d20c303d79fba08c577752f080c4007ee3", size = 12636885 }, + { url = "https://files.pythonhosted.org/packages/fa/e2/793288ede17a0fdc921172916efb40f3cbc2aa97e76c5c84aba6dc7e8747/numpy-2.2.4-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:8120575cb4882318c791f839a4fd66161a6fa46f3f0a5e613071aae35b5dd8f8", size = 20961829 }, + { url = "https://files.pythonhosted.org/packages/3a/75/bb4573f6c462afd1ea5cbedcc362fe3e9bdbcc57aefd37c681be1155fbaa/numpy-2.2.4-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:a761ba0fa886a7bb33c6c8f6f20213735cb19642c580a931c625ee377ee8bd39", size = 14161419 }, + { url = "https://files.pythonhosted.org/packages/03/68/07b4cd01090ca46c7a336958b413cdbe75002286295f2addea767b7f16c9/numpy-2.2.4-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:ac0280f1ba4a4bfff363a99a6aceed4f8e123f8a9b234c89140f5e894e452ecd", size = 5196414 }, + { url = "https://files.pythonhosted.org/packages/a5/fd/d4a29478d622fedff5c4b4b4cedfc37a00691079623c0575978d2446db9e/numpy-2.2.4-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:879cf3a9a2b53a4672a168c21375166171bc3932b7e21f622201811c43cdd3b0", size = 6709379 }, + { url = "https://files.pythonhosted.org/packages/41/78/96dddb75bb9be730b87c72f30ffdd62611aba234e4e460576a068c98eff6/numpy-2.2.4-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f05d4198c1bacc9124018109c5fba2f3201dbe7ab6e92ff100494f236209c960", size = 14051725 }, + { url = "https://files.pythonhosted.org/packages/00/06/5306b8199bffac2a29d9119c11f457f6c7d41115a335b78d3f86fad4dbe8/numpy-2.2.4-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e2f085ce2e813a50dfd0e01fbfc0c12bbe5d2063d99f8b29da30e544fb6483b8", size = 16101638 }, + { url = "https://files.pythonhosted.org/packages/fa/03/74c5b631ee1ded596945c12027649e6344614144369fd3ec1aaced782882/numpy-2.2.4-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:92bda934a791c01d6d9d8e038363c50918ef7c40601552a58ac84c9613a665bc", size = 15571717 }, + { url = "https://files.pythonhosted.org/packages/cb/dc/4fc7c0283abe0981e3b89f9b332a134e237dd476b0c018e1e21083310c31/numpy-2.2.4-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:ee4d528022f4c5ff67332469e10efe06a267e32f4067dc76bb7e2cddf3cd25ff", size = 17879998 }, + { url = "https://files.pythonhosted.org/packages/e5/2b/878576190c5cfa29ed896b518cc516aecc7c98a919e20706c12480465f43/numpy-2.2.4-cp313-cp313t-win32.whl", hash = "sha256:05c076d531e9998e7e694c36e8b349969c56eadd2cdcd07242958489d79a7286", size = 6366896 }, + { url = "https://files.pythonhosted.org/packages/3e/05/eb7eec66b95cf697f08c754ef26c3549d03ebd682819f794cb039574a0a6/numpy-2.2.4-cp313-cp313t-win_amd64.whl", hash = "sha256:188dcbca89834cc2e14eb2f106c96d6d46f200fe0200310fc29089657379c58d", size = 12739119 }, + { url = "https://files.pythonhosted.org/packages/b2/5c/f09c33a511aff41a098e6ef3498465d95f6360621034a3d95f47edbc9119/numpy-2.2.4-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:7051ee569db5fbac144335e0f3b9c2337e0c8d5c9fee015f259a5bd70772b7e8", size = 21081956 }, + { url = "https://files.pythonhosted.org/packages/ba/30/74c48b3b6494c4b820b7fa1781d441e94d87a08daa5b35d222f06ba41a6f/numpy-2.2.4-pp310-pypy310_pp73-macosx_14_0_x86_64.whl", hash = "sha256:ab2939cd5bec30a7430cbdb2287b63151b77cf9624de0532d629c9a1c59b1d5c", size = 6827143 }, + { url = "https://files.pythonhosted.org/packages/54/f5/ab0d2f48b490535c7a80e05da4a98902b632369efc04f0e47bb31ca97d8f/numpy-2.2.4-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d0f35b19894a9e08639fd60a1ec1978cb7f5f7f1eace62f38dd36be8aecdef4d", size = 16233350 }, + { url = "https://files.pythonhosted.org/packages/3b/3a/2f6d8c1f8e45d496bca6baaec93208035faeb40d5735c25afac092ec9a12/numpy-2.2.4-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:b4adfbbc64014976d2f91084915ca4e626fbf2057fb81af209c1a6d776d23e3d", size = 12857565 }, +] + +[[package]] +name = "packaging" +version = "24.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine != 'aarch64' and platform_machine != 'arm64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'aarch64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'arm64'", + "python_full_version < '3.7.1'", +] +sdist = { url = "https://files.pythonhosted.org/packages/ee/b5/b43a27ac7472e1818c4bafd44430e69605baefe1f34440593e0332ec8b4d/packaging-24.0.tar.gz", hash = "sha256:eb82c5e3e56209074766e6885bb04b8c38a0c015d0a30036ebe7ece34c9989e9", size = 147882 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/49/df/1fceb2f8900f8639e278b056416d49134fb8d84c5942ffaa01ad34782422/packaging-24.0-py3-none-any.whl", hash = "sha256:2ddfb553fdf02fb784c234c7ba6ccc288296ceabec964ad2eae3777778130bc5", size = 53488 }, +] + +[[package]] +name = "packaging" +version = "24.2" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", + "python_full_version == '3.10.*'", + "python_full_version == '3.9.*'", + "python_full_version == '3.8.*'", +] +sdist = { url = "https://files.pythonhosted.org/packages/d0/63/68dbb6eb2de9cb10ee4c9c14a0148804425e13c4fb20d61cce69f53106da/packaging-24.2.tar.gz", hash = "sha256:c228a6dc5e932d346bc5739379109d49e8853dd8223571c7c5b55260edc0b97f", size = 163950 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/88/ef/eb23f262cca3c0c4eb7ab1933c3b1f03d021f2c48f54763065b6f0e321be/packaging-24.2-py3-none-any.whl", hash = "sha256:09abb1bccd265c01f4a3aa3f7a7db064b36514d2cba19a2f694fe6150451a759", size = 65451 }, +] + +[[package]] +name = "pandas" +version = "1.1.5" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version < '3.7.1'", +] +dependencies = [ + { name = "numpy", version = "1.21.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.7.1'" }, + { name = "python-dateutil", marker = "python_full_version < '3.7.1'" }, + { name = "pytz", marker = "python_full_version < '3.7.1'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/fb/e4/828bb9c2474ff6016e5ce96a78220d485436d5468c23068f4f6c2eb9cff8/pandas-1.1.5.tar.gz", hash = "sha256:f10fc41ee3c75a474d3bdf68d396f10782d013d7f67db99c0efbfd0acb99701b", size = 5229894 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b5/ac/5ec0601ce698235cad8559dfe0ae5ace903a359d617a8c4c033f9879faf8/pandas-1.1.5-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:26fa92d3ac743a149a31b21d6f4337b0594b6302ea5575b37af9ca9611e8981a", size = 9950654 }, + { url = "https://files.pythonhosted.org/packages/12/ce/5da11d852dc0bacce86ec8abe802a6a55bfe20823845b4dc609b0280cf90/pandas-1.1.5-cp37-cp37m-manylinux1_i686.whl", hash = "sha256:c16d59c15d946111d2716856dd5479221c9e4f2f5c7bc2d617f39d870031e086", size = 9095405 }, + { url = "https://files.pythonhosted.org/packages/fd/70/e8eee0cbddf926bf51958c7d6a86bc69167c300fa2ba8e592330a2377d1b/pandas-1.1.5-cp37-cp37m-manylinux1_x86_64.whl", hash = "sha256:3be7a7a0ca71a2640e81d9276f526bca63505850add10206d0da2e8a0a325dae", size = 9528950 }, + { url = "https://files.pythonhosted.org/packages/82/13/44c05005f9eafda56651b9f27c2b89c803d78ca2136e43b72c0e7a5033ee/pandas-1.1.5-cp37-cp37m-manylinux2014_aarch64.whl", hash = "sha256:573fba5b05bf2c69271a32e52399c8de599e4a15ab7cec47d3b9c904125ab788", size = 9439516 }, + { url = "https://files.pythonhosted.org/packages/e1/08/b059d45fc7a14ff9dcfa010324a3e79ff24a333cc0a81ae097accf236213/pandas-1.1.5-cp37-cp37m-win32.whl", hash = "sha256:21b5a2b033380adbdd36b3116faaf9a4663e375325831dac1b519a44f9e439bb", size = 7767532 }, + { url = "https://files.pythonhosted.org/packages/47/17/5c4b04caa8fe1dca2aa940dcc00319aa77c84fbdb71f83869a0900cac660/pandas-1.1.5-cp37-cp37m-win_amd64.whl", hash = "sha256:24c7f8d4aee71bfa6401faeba367dd654f696a77151a8a28bc2013f7ced4af98", size = 8749370 }, + { url = "https://files.pythonhosted.org/packages/d7/ce/fd9ccaf9c328ead3024950f0799d24fb4ad328d3949e21d68e2e2338df07/pandas-1.1.5-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:2860a97cbb25444ffc0088b457da0a79dc79f9c601238a3e0644312fcc14bf11", size = 10091168 }, + { url = "https://files.pythonhosted.org/packages/ec/ae/416c4b26a1cbcc57640733b738189a66f1fc2be568bdc88a0356a5a7e33a/pandas-1.1.5-cp38-cp38-manylinux1_i686.whl", hash = "sha256:5008374ebb990dad9ed48b0f5d0038124c73748f5384cc8c46904dace27082d9", size = 9035568 }, + { url = "https://files.pythonhosted.org/packages/f9/f4/ede7c643939c132b0692a737800747ce5ba0e8068af27730dfda936c9bf1/pandas-1.1.5-cp38-cp38-manylinux1_x86_64.whl", hash = "sha256:2c2f7c670ea4e60318e4b7e474d56447cf0c7d83b3c2a5405a0dbb2600b9c48e", size = 9328954 }, + { url = "https://files.pythonhosted.org/packages/97/7f/865e78beaac43e57b7dd066cc28cd85a2b5687334188dbeca439bf13845b/pandas-1.1.5-cp38-cp38-manylinux2014_aarch64.whl", hash = "sha256:0a643bae4283a37732ddfcecab3f62dd082996021b980f580903f4e8e01b3c5b", size = 9647042 }, + { url = "https://files.pythonhosted.org/packages/f4/b0/63aa0d048e4c3be3f0d2c3851cde44ce644bac3f527f9239df5ca15947d1/pandas-1.1.5-cp38-cp38-win32.whl", hash = "sha256:5447ea7af4005b0daf695a316a423b96374c9c73ffbd4533209c5ddc369e644b", size = 7897350 }, + { url = "https://files.pythonhosted.org/packages/fd/f5/2b5dc56305fcb4bf0c176035ca1a2ed4fc2652362a8eb58f5b0d9bccfe22/pandas-1.1.5-cp38-cp38-win_amd64.whl", hash = "sha256:4c62e94d5d49db116bef1bd5c2486723a292d79409fc9abd51adf9e05329101d", size = 8950447 }, + { url = "https://files.pythonhosted.org/packages/b3/4f/6a2bdef087388a59245976008e0e0b4297659fd9796112d85cce766c3cd1/pandas-1.1.5-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:731568be71fba1e13cae212c362f3d2ca8932e83cb1b85e3f1b4dd77d019254a", size = 10275477 }, + { url = "https://files.pythonhosted.org/packages/69/c1/bf486a9d03e1658bbab5212315dd0df49ddaccaa69f81c0dc17820ede978/pandas-1.1.5-cp39-cp39-manylinux1_i686.whl", hash = "sha256:c61c043aafb69329d0f961b19faa30b1dab709dd34c9388143fc55680059e55a", size = 8965380 }, + { url = "https://files.pythonhosted.org/packages/d0/e1/64f9c1fccd5eebdf177e917e5499b6da266c409b6eba75b93a8cd3b8ccee/pandas-1.1.5-cp39-cp39-manylinux1_x86_64.whl", hash = "sha256:2b1c6cd28a0dfda75c7b5957363333f01d370936e4c6276b7b8e696dd500582a", size = 9310065 }, + { url = "https://files.pythonhosted.org/packages/19/96/6bd84872fcdf082c4a60b2b996a96cce13295da7198f38abd01c92d04bcb/pandas-1.1.5-cp39-cp39-win32.whl", hash = "sha256:c94ff2780a1fd89f190390130d6d36173ca59fcfb3fe0ff596f9a56518191ccb", size = 7868105 }, + { url = "https://files.pythonhosted.org/packages/46/f9/d78955c88e045fa220392cc311e41764f8decf868594b5f92d8fa1d1b39e/pandas-1.1.5-cp39-cp39-win_amd64.whl", hash = "sha256:edda9bacc3843dfbeebaf7a701763e68e741b08fccb889c003b0a52f0ee95782", size = 8936158 }, +] + +[[package]] +name = "pandas" +version = "1.3.5" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine != 'aarch64' and platform_machine != 'arm64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'aarch64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'arm64'", +] +dependencies = [ + { name = "numpy", version = "1.21.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.7.1' and python_full_version < '3.8'" }, + { name = "python-dateutil", marker = "python_full_version >= '3.7.1' and python_full_version < '3.8'" }, + { name = "pytz", marker = "python_full_version >= '3.7.1' and python_full_version < '3.8'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/99/f0/f99700ef327e51d291efdf4a6de29e685c4d198cbf8531541fc84d169e0e/pandas-1.3.5.tar.gz", hash = "sha256:1e4285f5de1012de20ca46b188ccf33521bff61ba5c5ebd78b4fb28e5416a9f1", size = 4736591 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f8/e9/170a5dab5e166610492f74e87b2998e848e920ed137844077c7a04b6c752/pandas-1.3.5-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:62d5b5ce965bae78f12c1c0df0d387899dd4211ec0bdc52822373f13a3a022b9", size = 17688091 }, + { url = "https://files.pythonhosted.org/packages/ba/a2/fb72a79cced335f86a5761d2e44cd750a54fe5eac5a1d239489430c6ef2b/pandas-1.3.5-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:adfeb11be2d54f275142c8ba9bf67acee771b7186a5745249c7d5a06c670136b", size = 11326728 }, + { url = "https://files.pythonhosted.org/packages/fb/77/e1bb0628d38fef6e12914e4bb853231a9b406f355aa72fc3427a2fe21327/pandas-1.3.5-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:60a8c055d58873ad81cae290d974d13dd479b82cbb975c3e1fa2cf1920715296", size = 10282482 }, + { url = "https://files.pythonhosted.org/packages/4a/dd/ff9ff3a3330e4e37d8146e19ef7a33324072dabea7c355afe820b6c38a2d/pandas-1.3.5-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fd541ab09e1f80a2a1760032d665f6e032d8e44055d602d65eeea6e6e85498cb", size = 10901427 }, + { url = "https://files.pythonhosted.org/packages/ff/7a/1ce22f0f009ee31878f717bd5b3221e993a7ebc02391d7a315982c2224dc/pandas-1.3.5-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2651d75b9a167cc8cc572cf787ab512d16e316ae00ba81874b560586fa1325e0", size = 11549648 }, + { url = "https://files.pythonhosted.org/packages/68/a7/96cde70dd2723a9cb79978a390cb3de448a72baafc949ef1fce1e804dbd0/pandas-1.3.5-cp310-cp310-win_amd64.whl", hash = "sha256:aaf183a615ad790801fa3cf2fa450e5b6d23a54684fe386f7e3208f8b9bfbef6", size = 10188149 }, + { url = "https://files.pythonhosted.org/packages/44/d9/fa9cb383b482b574e6926eabc437fe57b59908a7ed940612c8c308471872/pandas-1.3.5-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:344295811e67f8200de2390093aeb3c8309f5648951b684d8db7eee7d1c81fb7", size = 11011237 }, + { url = "https://files.pythonhosted.org/packages/8b/7e/67f85be335fd9de515c4efe90d2d4d4a545e97c713febd2d230b0bd945be/pandas-1.3.5-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:552020bf83b7f9033b57cbae65589c01e7ef1544416122da0c79140c93288f56", size = 10677966 }, + { url = "https://files.pythonhosted.org/packages/3e/0c/23764c4635dcb0a784a787498d56847b90ebf974e65f4ab4053a5d97b1a5/pandas-1.3.5-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5cce0c6bbeb266b0e39e35176ee615ce3585233092f685b6a82362523e59e5b4", size = 11285953 }, + { url = "https://files.pythonhosted.org/packages/1f/09/9f2e2053a6fd149009105a67e129ceab3e140a7915be6cbd4b13612cd3fa/pandas-1.3.5-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7d28a3c65463fd0d0ba8bbb7696b23073efee0510783340a44b08f5e96ffce0c", size = 11380777 }, + { url = "https://files.pythonhosted.org/packages/66/f3/b739d389ba70aeceb8e4eda1d7e7577b4fa44a7351d6d10fc5c6543bdb91/pandas-1.3.5-cp37-cp37m-win32.whl", hash = "sha256:a62949c626dd0ef7de11de34b44c6475db76995c2064e2d99c6498c3dba7fe58", size = 8929395 }, + { url = "https://files.pythonhosted.org/packages/b2/56/f886ed6f1777ffa9d54c6e80231b69db8a1f52dcc33f5967b06a105dcfe0/pandas-1.3.5-cp37-cp37m-win_amd64.whl", hash = "sha256:8025750767e138320b15ca16d70d5cdc1886e8f9cc56652d89735c016cd8aea6", size = 9970412 }, + { url = "https://files.pythonhosted.org/packages/c7/4f/154ccb493f76514a158b881c7c4995c8529b7d041612801eba633c2581bf/pandas-1.3.5-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:fe95bae4e2d579812865db2212bb733144e34d0c6785c0685329e5b60fcb85dd", size = 11179803 }, + { url = "https://files.pythonhosted.org/packages/79/f3/d6ccc0699c540c0f9f6302a553eea1efd9133f2c2a746987a96bcc22c253/pandas-1.3.5-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5f261553a1e9c65b7a310302b9dbac31cf0049a51695c14ebe04e4bfd4a96f02", size = 10896053 }, + { url = "https://files.pythonhosted.org/packages/a2/9b/c4879904ed1706883eb0b126f1f4baa0992dfd61ad2aac7a7af82f01b256/pandas-1.3.5-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8b6dbec5f3e6d5dc80dcfee250e0a2a652b3f28663492f7dab9a24416a48ac39", size = 11533670 }, + { url = "https://files.pythonhosted.org/packages/5e/09/0ea554021747118e47002f99fbbd67fb1e8ed91c564aaab687a338a97177/pandas-1.3.5-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d3bc49af96cd6285030a64779de5b3688633a07eb75c124b0747134a63f4c05f", size = 11632727 }, + { url = "https://files.pythonhosted.org/packages/05/4a/abc3bd95179a45b1f29b1f973acde14bee48fab60bf483fa15e2521e013b/pandas-1.3.5-cp38-cp38-win32.whl", hash = "sha256:b6b87b2fb39e6383ca28e2829cddef1d9fc9e27e55ad91ca9c435572cdba51bf", size = 9082087 }, + { url = "https://files.pythonhosted.org/packages/ba/9c/55bbffd9a2c55360eb2a1da5634f553d39db9df17da037989e2215c941b4/pandas-1.3.5-cp38-cp38-win_amd64.whl", hash = "sha256:a395692046fd8ce1edb4c6295c35184ae0c2bbe787ecbe384251da609e27edcb", size = 10192785 }, + { url = "https://files.pythonhosted.org/packages/f6/56/4bad0852c2c7885c0b86e4344463969e1ffb91439479708e282eb87951c5/pandas-1.3.5-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:bd971a3f08b745a75a86c00b97f3007c2ea175951286cdda6abe543e687e5f2f", size = 11314167 }, + { url = "https://files.pythonhosted.org/packages/c7/8d/e7c3bc1c0f10a6bcb399eae3f570eacda7bdf0044f30659c819bea5d659f/pandas-1.3.5-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:37f06b59e5bc05711a518aa10beaec10942188dccb48918bb5ae602ccbc9f1a0", size = 10916021 }, + { url = "https://files.pythonhosted.org/packages/a3/00/64d407c9ec379a252ba659eb5086ffe5550f83674a43eca680b4a0992eb2/pandas-1.3.5-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2c21778a688d3712d35710501f8001cdbf96eb70a7c587a3d5613573299fdca6", size = 11518536 }, + { url = "https://files.pythonhosted.org/packages/e7/ef/bfac4ddfff7b3817fa75ff8e4defe60c2b534a79ad734ab5ff2634dd9575/pandas-1.3.5-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3345343206546545bc26a05b4602b6a24385b5ec7c75cb6059599e3d56831da2", size = 11634519 }, + { url = "https://files.pythonhosted.org/packages/02/b5/dbe37470c47b3e89c8aa6390ac4fd0baa76fc8b72126def9ddc71b77aeb3/pandas-1.3.5-cp39-cp39-win32.whl", hash = "sha256:c69406a2808ba6cf580c2255bcf260b3f214d2664a3a4197d0e640f573b46fd3", size = 9052239 }, + { url = "https://files.pythonhosted.org/packages/17/81/8c5bdee74f7fb4edd8e58c3388954568a49230a61f6595020e7def31d889/pandas-1.3.5-cp39-cp39-win_amd64.whl", hash = "sha256:32e1a26d5ade11b547721a72f9bfc4bd113396947606e00d5b4a5b79b3dcb006", size = 10177282 }, +] + +[[package]] +name = "pandas" +version = "2.0.3" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version == '3.8.*'", +] +dependencies = [ + { name = "numpy", version = "1.24.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.8.*'" }, + { name = "python-dateutil", marker = "python_full_version == '3.8.*'" }, + { name = "pytz", marker = "python_full_version == '3.8.*'" }, + { name = "tzdata", marker = "python_full_version == '3.8.*'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b1/a7/824332581e258b5aa4f3763ecb2a797e5f9a54269044ba2e50ac19936b32/pandas-2.0.3.tar.gz", hash = "sha256:c02f372a88e0d17f36d3093a644c73cfc1788e876a7c4bcb4020a77512e2043c", size = 5284455 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3c/b2/0d4a5729ce1ce11630c4fc5d5522a33b967b3ca146c210f58efde7c40e99/pandas-2.0.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:e4c7c9f27a4185304c7caf96dc7d91bc60bc162221152de697c98eb0b2648dd8", size = 11760908 }, + { url = "https://files.pythonhosted.org/packages/4a/f6/f620ca62365d83e663a255a41b08d2fc2eaf304e0b8b21bb6d62a7390fe3/pandas-2.0.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:f167beed68918d62bffb6ec64f2e1d8a7d297a038f86d4aed056b9493fca407f", size = 10823486 }, + { url = "https://files.pythonhosted.org/packages/c2/59/cb4234bc9b968c57e81861b306b10cd8170272c57b098b724d3de5eda124/pandas-2.0.3-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ce0c6f76a0f1ba361551f3e6dceaff06bde7514a374aa43e33b588ec10420183", size = 11571897 }, + { url = "https://files.pythonhosted.org/packages/e3/59/35a2892bf09ded9c1bf3804461efe772836a5261ef5dfb4e264ce813ff99/pandas-2.0.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ba619e410a21d8c387a1ea6e8a0e49bb42216474436245718d7f2e88a2f8d7c0", size = 12306421 }, + { url = "https://files.pythonhosted.org/packages/94/71/3a0c25433c54bb29b48e3155b959ac78f4c4f2f06f94d8318aac612cb80f/pandas-2.0.3-cp310-cp310-win32.whl", hash = "sha256:3ef285093b4fe5058eefd756100a367f27029913760773c8bf1d2d8bebe5d210", size = 9540792 }, + { url = "https://files.pythonhosted.org/packages/ed/30/b97456e7063edac0e5a405128065f0cd2033adfe3716fb2256c186bd41d0/pandas-2.0.3-cp310-cp310-win_amd64.whl", hash = "sha256:9ee1a69328d5c36c98d8e74db06f4ad518a1840e8ccb94a4ba86920986bb617e", size = 10664333 }, + { url = "https://files.pythonhosted.org/packages/b3/92/a5e5133421b49e901a12e02a6a7ef3a0130e10d13db8cb657fdd0cba3b90/pandas-2.0.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:b084b91d8d66ab19f5bb3256cbd5ea661848338301940e17f4492b2ce0801fe8", size = 11645672 }, + { url = "https://files.pythonhosted.org/packages/8f/bb/aea1fbeed5b474cb8634364718abe9030d7cc7a30bf51f40bd494bbc89a2/pandas-2.0.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:37673e3bdf1551b95bf5d4ce372b37770f9529743d2498032439371fc7b7eb26", size = 10693229 }, + { url = "https://files.pythonhosted.org/packages/d6/90/e7d387f1a416b14e59290baa7a454a90d719baebbf77433ff1bdcc727800/pandas-2.0.3-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b9cb1e14fdb546396b7e1b923ffaeeac24e4cedd14266c3497216dd4448e4f2d", size = 11581591 }, + { url = "https://files.pythonhosted.org/packages/d0/28/88b81881c056376254618fad622a5e94b5126db8c61157ea1910cd1c040a/pandas-2.0.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d9cd88488cceb7635aebb84809d087468eb33551097d600c6dad13602029c2df", size = 12219370 }, + { url = "https://files.pythonhosted.org/packages/e4/a5/212b9039e25bf8ebb97e417a96660e3dc925dacd3f8653d531b8f7fd9be4/pandas-2.0.3-cp311-cp311-win32.whl", hash = "sha256:694888a81198786f0e164ee3a581df7d505024fbb1f15202fc7db88a71d84ebd", size = 9482935 }, + { url = "https://files.pythonhosted.org/packages/9e/71/756a1be6bee0209d8c0d8c5e3b9fc72c00373f384a4017095ec404aec3ad/pandas-2.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:6a21ab5c89dcbd57f78d0ae16630b090eec626360085a4148693def5452d8a6b", size = 10607692 }, + { url = "https://files.pythonhosted.org/packages/78/a8/07dd10f90ca915ed914853cd57f79bfc22e1ef4384ab56cb4336d2fc1f2a/pandas-2.0.3-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:9e4da0d45e7f34c069fe4d522359df7d23badf83abc1d1cef398895822d11061", size = 11653303 }, + { url = "https://files.pythonhosted.org/packages/53/c3/f8e87361f7fdf42012def602bfa2a593423c729f5cb7c97aed7f51be66ac/pandas-2.0.3-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:32fca2ee1b0d93dd71d979726b12b61faa06aeb93cf77468776287f41ff8fdc5", size = 10710932 }, + { url = "https://files.pythonhosted.org/packages/a7/87/828d50c81ce0f434163bf70b925a0eec6076808e0bca312a79322b141f66/pandas-2.0.3-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:258d3624b3ae734490e4d63c430256e716f488c4fcb7c8e9bde2d3aa46c29089", size = 11684018 }, + { url = "https://files.pythonhosted.org/packages/f8/7f/5b047effafbdd34e52c9e2d7e44f729a0655efafb22198c45cf692cdc157/pandas-2.0.3-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9eae3dc34fa1aa7772dd3fc60270d13ced7346fcbcfee017d3132ec625e23bb0", size = 12353723 }, + { url = "https://files.pythonhosted.org/packages/ea/ae/26a2eda7fa581347d69e51f93892493b2074ef3352ac71033c9f32c52389/pandas-2.0.3-cp38-cp38-win32.whl", hash = "sha256:f3421a7afb1a43f7e38e82e844e2bca9a6d793d66c1a7f9f0ff39a795bbc5e02", size = 9646403 }, + { url = "https://files.pythonhosted.org/packages/c3/6c/ea362eef61f05553aaf1a24b3e96b2d0603f5dc71a3bd35688a24ed88843/pandas-2.0.3-cp38-cp38-win_amd64.whl", hash = "sha256:69d7f3884c95da3a31ef82b7618af5710dba95bb885ffab339aad925c3e8ce78", size = 10777638 }, + { url = "https://files.pythonhosted.org/packages/f8/c7/cfef920b7b457dff6928e824896cb82367650ea127d048ee0b820026db4f/pandas-2.0.3-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:5247fb1ba347c1261cbbf0fcfba4a3121fbb4029d95d9ef4dc45406620b25c8b", size = 11834160 }, + { url = "https://files.pythonhosted.org/packages/6c/1c/689c9d99bc4e5d366a5fd871f0bcdee98a6581e240f96b78d2d08f103774/pandas-2.0.3-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:81af086f4543c9d8bb128328b5d32e9986e0c84d3ee673a2ac6fb57fd14f755e", size = 10862752 }, + { url = "https://files.pythonhosted.org/packages/cc/b8/4d082f41c27c95bf90485d1447b647cc7e5680fea75e315669dc6e4cb398/pandas-2.0.3-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1994c789bf12a7c5098277fb43836ce090f1073858c10f9220998ac74f37c69b", size = 11715852 }, + { url = "https://files.pythonhosted.org/packages/9e/0d/91a9fd2c202f2b1d97a38ab591890f86480ecbb596cbc56d035f6f23fdcc/pandas-2.0.3-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5ec591c48e29226bcbb316e0c1e9423622bc7a4eaf1ef7c3c9fa1a3981f89641", size = 12398496 }, + { url = "https://files.pythonhosted.org/packages/26/7d/d8aa0a2c4f3f5f8ea59fb946c8eafe8f508090ca73e2b08a9af853c1103e/pandas-2.0.3-cp39-cp39-win32.whl", hash = "sha256:04dbdbaf2e4d46ca8da896e1805bc04eb85caa9a82e259e8eed00254d5e0c682", size = 9630766 }, + { url = "https://files.pythonhosted.org/packages/9a/f2/0ad053856debbe90c83de1b4f05915f85fd2146f20faf9daa3b320d36df3/pandas-2.0.3-cp39-cp39-win_amd64.whl", hash = "sha256:1168574b036cd8b93abc746171c9b4f1b83467438a5e45909fed645cf8692dbc", size = 10755902 }, +] + +[[package]] +name = "pandas" +version = "2.2.3" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", + "python_full_version == '3.10.*'", + "python_full_version == '3.9.*'", +] +dependencies = [ + { name = "numpy", version = "2.0.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*'" }, + { name = "numpy", version = "2.2.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, + { name = "python-dateutil", marker = "python_full_version >= '3.9'" }, + { name = "pytz", marker = "python_full_version >= '3.9'" }, + { name = "tzdata", marker = "python_full_version >= '3.9'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/9c/d6/9f8431bacc2e19dca897724cd097b1bb224a6ad5433784a44b587c7c13af/pandas-2.2.3.tar.gz", hash = "sha256:4f18ba62b61d7e192368b84517265a99b4d7ee8912f8708660fb4a366cc82667", size = 4399213 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/aa/70/c853aec59839bceed032d52010ff5f1b8d87dc3114b762e4ba2727661a3b/pandas-2.2.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:1948ddde24197a0f7add2bdc4ca83bf2b1ef84a1bc8ccffd95eda17fd836ecb5", size = 12580827 }, + { url = "https://files.pythonhosted.org/packages/99/f2/c4527768739ffa4469b2b4fff05aa3768a478aed89a2f271a79a40eee984/pandas-2.2.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:381175499d3802cde0eabbaf6324cce0c4f5d52ca6f8c377c29ad442f50f6348", size = 11303897 }, + { url = "https://files.pythonhosted.org/packages/ed/12/86c1747ea27989d7a4064f806ce2bae2c6d575b950be087837bdfcabacc9/pandas-2.2.3-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d9c45366def9a3dd85a6454c0e7908f2b3b8e9c138f5dc38fed7ce720d8453ed", size = 66480908 }, + { url = "https://files.pythonhosted.org/packages/44/50/7db2cd5e6373ae796f0ddad3675268c8d59fb6076e66f0c339d61cea886b/pandas-2.2.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:86976a1c5b25ae3f8ccae3a5306e443569ee3c3faf444dfd0f41cda24667ad57", size = 13064210 }, + { url = "https://files.pythonhosted.org/packages/61/61/a89015a6d5536cb0d6c3ba02cebed51a95538cf83472975275e28ebf7d0c/pandas-2.2.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:b8661b0238a69d7aafe156b7fa86c44b881387509653fdf857bebc5e4008ad42", size = 16754292 }, + { url = "https://files.pythonhosted.org/packages/ce/0d/4cc7b69ce37fac07645a94e1d4b0880b15999494372c1523508511b09e40/pandas-2.2.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:37e0aced3e8f539eccf2e099f65cdb9c8aa85109b0be6e93e2baff94264bdc6f", size = 14416379 }, + { url = "https://files.pythonhosted.org/packages/31/9e/6ebb433de864a6cd45716af52a4d7a8c3c9aaf3a98368e61db9e69e69a9c/pandas-2.2.3-cp310-cp310-win_amd64.whl", hash = "sha256:56534ce0746a58afaf7942ba4863e0ef81c9c50d3f0ae93e9497d6a41a057645", size = 11598471 }, + { url = "https://files.pythonhosted.org/packages/a8/44/d9502bf0ed197ba9bf1103c9867d5904ddcaf869e52329787fc54ed70cc8/pandas-2.2.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:66108071e1b935240e74525006034333f98bcdb87ea116de573a6a0dccb6c039", size = 12602222 }, + { url = "https://files.pythonhosted.org/packages/52/11/9eac327a38834f162b8250aab32a6781339c69afe7574368fffe46387edf/pandas-2.2.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:7c2875855b0ff77b2a64a0365e24455d9990730d6431b9e0ee18ad8acee13dbd", size = 11321274 }, + { url = "https://files.pythonhosted.org/packages/45/fb/c4beeb084718598ba19aa9f5abbc8aed8b42f90930da861fcb1acdb54c3a/pandas-2.2.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:cd8d0c3be0515c12fed0bdbae072551c8b54b7192c7b1fda0ba56059a0179698", size = 15579836 }, + { url = "https://files.pythonhosted.org/packages/cd/5f/4dba1d39bb9c38d574a9a22548c540177f78ea47b32f99c0ff2ec499fac5/pandas-2.2.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c124333816c3a9b03fbeef3a9f230ba9a737e9e5bb4060aa2107a86cc0a497fc", size = 13058505 }, + { url = "https://files.pythonhosted.org/packages/b9/57/708135b90391995361636634df1f1130d03ba456e95bcf576fada459115a/pandas-2.2.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:63cc132e40a2e084cf01adf0775b15ac515ba905d7dcca47e9a251819c575ef3", size = 16744420 }, + { url = "https://files.pythonhosted.org/packages/86/4a/03ed6b7ee323cf30404265c284cee9c65c56a212e0a08d9ee06984ba2240/pandas-2.2.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:29401dbfa9ad77319367d36940cd8a0b3a11aba16063e39632d98b0e931ddf32", size = 14440457 }, + { url = "https://files.pythonhosted.org/packages/ed/8c/87ddf1fcb55d11f9f847e3c69bb1c6f8e46e2f40ab1a2d2abadb2401b007/pandas-2.2.3-cp311-cp311-win_amd64.whl", hash = "sha256:3fc6873a41186404dad67245896a6e440baacc92f5b716ccd1bc9ed2995ab2c5", size = 11617166 }, + { url = "https://files.pythonhosted.org/packages/17/a3/fb2734118db0af37ea7433f57f722c0a56687e14b14690edff0cdb4b7e58/pandas-2.2.3-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:b1d432e8d08679a40e2a6d8b2f9770a5c21793a6f9f47fdd52c5ce1948a5a8a9", size = 12529893 }, + { url = "https://files.pythonhosted.org/packages/e1/0c/ad295fd74bfac85358fd579e271cded3ac969de81f62dd0142c426b9da91/pandas-2.2.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:a5a1595fe639f5988ba6a8e5bc9649af3baf26df3998a0abe56c02609392e0a4", size = 11363475 }, + { url = "https://files.pythonhosted.org/packages/c6/2a/4bba3f03f7d07207481fed47f5b35f556c7441acddc368ec43d6643c5777/pandas-2.2.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:5de54125a92bb4d1c051c0659e6fcb75256bf799a732a87184e5ea503965bce3", size = 15188645 }, + { url = "https://files.pythonhosted.org/packages/38/f8/d8fddee9ed0d0c0f4a2132c1dfcf0e3e53265055da8df952a53e7eaf178c/pandas-2.2.3-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fffb8ae78d8af97f849404f21411c95062db1496aeb3e56f146f0355c9989319", size = 12739445 }, + { url = "https://files.pythonhosted.org/packages/20/e8/45a05d9c39d2cea61ab175dbe6a2de1d05b679e8de2011da4ee190d7e748/pandas-2.2.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:6dfcb5ee8d4d50c06a51c2fffa6cff6272098ad6540aed1a76d15fb9318194d8", size = 16359235 }, + { url = "https://files.pythonhosted.org/packages/1d/99/617d07a6a5e429ff90c90da64d428516605a1ec7d7bea494235e1c3882de/pandas-2.2.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:062309c1b9ea12a50e8ce661145c6aab431b1e99530d3cd60640e255778bd43a", size = 14056756 }, + { url = "https://files.pythonhosted.org/packages/29/d4/1244ab8edf173a10fd601f7e13b9566c1b525c4f365d6bee918e68381889/pandas-2.2.3-cp312-cp312-win_amd64.whl", hash = "sha256:59ef3764d0fe818125a5097d2ae867ca3fa64df032331b7e0917cf5d7bf66b13", size = 11504248 }, + { url = "https://files.pythonhosted.org/packages/64/22/3b8f4e0ed70644e85cfdcd57454686b9057c6c38d2f74fe4b8bc2527214a/pandas-2.2.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f00d1345d84d8c86a63e476bb4955e46458b304b9575dcf71102b5c705320015", size = 12477643 }, + { url = "https://files.pythonhosted.org/packages/e4/93/b3f5d1838500e22c8d793625da672f3eec046b1a99257666c94446969282/pandas-2.2.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:3508d914817e153ad359d7e069d752cdd736a247c322d932eb89e6bc84217f28", size = 11281573 }, + { url = "https://files.pythonhosted.org/packages/f5/94/6c79b07f0e5aab1dcfa35a75f4817f5c4f677931d4234afcd75f0e6a66ca/pandas-2.2.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:22a9d949bfc9a502d320aa04e5d02feab689d61da4e7764b62c30b991c42c5f0", size = 15196085 }, + { url = "https://files.pythonhosted.org/packages/e8/31/aa8da88ca0eadbabd0a639788a6da13bb2ff6edbbb9f29aa786450a30a91/pandas-2.2.3-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f3a255b2c19987fbbe62a9dfd6cff7ff2aa9ccab3fc75218fd4b7530f01efa24", size = 12711809 }, + { url = "https://files.pythonhosted.org/packages/ee/7c/c6dbdb0cb2a4344cacfb8de1c5808ca885b2e4dcfde8008266608f9372af/pandas-2.2.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:800250ecdadb6d9c78eae4990da62743b857b470883fa27f652db8bdde7f6659", size = 16356316 }, + { url = "https://files.pythonhosted.org/packages/57/b7/8b757e7d92023b832869fa8881a992696a0bfe2e26f72c9ae9f255988d42/pandas-2.2.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6374c452ff3ec675a8f46fd9ab25c4ad0ba590b71cf0656f8b6daa5202bca3fb", size = 14022055 }, + { url = "https://files.pythonhosted.org/packages/3b/bc/4b18e2b8c002572c5a441a64826252ce5da2aa738855747247a971988043/pandas-2.2.3-cp313-cp313-win_amd64.whl", hash = "sha256:61c5ad4043f791b61dd4752191d9f07f0ae412515d59ba8f005832a532f8736d", size = 11481175 }, + { url = "https://files.pythonhosted.org/packages/76/a3/a5d88146815e972d40d19247b2c162e88213ef51c7c25993942c39dbf41d/pandas-2.2.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:3b71f27954685ee685317063bf13c7709a7ba74fc996b84fc6821c59b0f06468", size = 12615650 }, + { url = "https://files.pythonhosted.org/packages/9c/8c/f0fd18f6140ddafc0c24122c8a964e48294acc579d47def376fef12bcb4a/pandas-2.2.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:38cf8125c40dae9d5acc10fa66af8ea6fdf760b2714ee482ca691fc66e6fcb18", size = 11290177 }, + { url = "https://files.pythonhosted.org/packages/ed/f9/e995754eab9c0f14c6777401f7eece0943840b7a9fc932221c19d1abee9f/pandas-2.2.3-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:ba96630bc17c875161df3818780af30e43be9b166ce51c9a18c1feae342906c2", size = 14651526 }, + { url = "https://files.pythonhosted.org/packages/25/b0/98d6ae2e1abac4f35230aa756005e8654649d305df9a28b16b9ae4353bff/pandas-2.2.3-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1db71525a1538b30142094edb9adc10be3f3e176748cd7acc2240c2f2e5aa3a4", size = 11871013 }, + { url = "https://files.pythonhosted.org/packages/cc/57/0f72a10f9db6a4628744c8e8f0df4e6e21de01212c7c981d31e50ffc8328/pandas-2.2.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:15c0e1e02e93116177d29ff83e8b1619c93ddc9c49083f237d4312337a61165d", size = 15711620 }, + { url = "https://files.pythonhosted.org/packages/ab/5f/b38085618b950b79d2d9164a711c52b10aefc0ae6833b96f626b7021b2ed/pandas-2.2.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:ad5b65698ab28ed8d7f18790a0dc58005c7629f227be9ecc1072aa74c0c1d43a", size = 13098436 }, + { url = "https://files.pythonhosted.org/packages/ca/8c/8848a4c9b8fdf5a534fe2077af948bf53cd713d77ffbcd7bd15710348fd7/pandas-2.2.3-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:bc6b93f9b966093cb0fd62ff1a7e4c09e6d546ad7c1de191767baffc57628f39", size = 12595535 }, + { url = "https://files.pythonhosted.org/packages/9c/b9/5cead4f63b6d31bdefeb21a679bc5a7f4aaf262ca7e07e2bc1c341b68470/pandas-2.2.3-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:5dbca4c1acd72e8eeef4753eeca07de9b1db4f398669d5994086f788a5d7cc30", size = 11319822 }, + { url = "https://files.pythonhosted.org/packages/31/af/89e35619fb573366fa68dc26dad6ad2c08c17b8004aad6d98f1a31ce4bb3/pandas-2.2.3-cp39-cp39-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:8cd6d7cc958a3910f934ea8dbdf17b2364827bb4dafc38ce6eef6bb3d65ff09c", size = 15625439 }, + { url = "https://files.pythonhosted.org/packages/3d/dd/bed19c2974296661493d7acc4407b1d2db4e2a482197df100f8f965b6225/pandas-2.2.3-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:99df71520d25fade9db7c1076ac94eb994f4d2673ef2aa2e86ee039b6746d20c", size = 13068928 }, + { url = "https://files.pythonhosted.org/packages/31/a3/18508e10a31ea108d746c848b5a05c0711e0278fa0d6f1c52a8ec52b80a5/pandas-2.2.3-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:31d0ced62d4ea3e231a9f228366919a5ea0b07440d9d4dac345376fd8e1477ea", size = 16783266 }, + { url = "https://files.pythonhosted.org/packages/c4/a5/3429bd13d82bebc78f4d78c3945efedef63a7cd0c15c17b2eeb838d1121f/pandas-2.2.3-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:7eee9e7cea6adf3e3d24e304ac6b8300646e2a5d1cd3a3c2abed9101b0846761", size = 14450871 }, + { url = "https://files.pythonhosted.org/packages/2f/49/5c30646e96c684570925b772eac4eb0a8cb0ca590fa978f56c5d3ae73ea1/pandas-2.2.3-cp39-cp39-win_amd64.whl", hash = "sha256:4850ba03528b6dd51d6c5d273c46f183f39a9baf3f0143e566b89450965b105e", size = 11618011 }, +] + +[[package]] +name = "pandocfilters" +version = "1.5.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/70/6f/3dd4940bbe001c06a65f88e36bad298bc7a0de5036115639926b0c5c0458/pandocfilters-1.5.1.tar.gz", hash = "sha256:002b4a555ee4ebc03f8b66307e287fa492e4a77b4ea14d3f934328297bb4939e", size = 8454 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ef/af/4fbc8cab944db5d21b7e2a5b8e9211a03a79852b1157e2c102fcc61ac440/pandocfilters-1.5.1-py2.py3-none-any.whl", hash = "sha256:93be382804a9cdb0a7267585f157e5d1731bbe5545a85b268d6f5fe6232de2bc", size = 8663 }, +] + +[[package]] +name = "parso" +version = "0.8.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/66/94/68e2e17afaa9169cf6412ab0f28623903be73d1b32e208d9e8e541bb086d/parso-0.8.4.tar.gz", hash = "sha256:eb3a7b58240fb99099a345571deecc0f9540ea5f4dd2fe14c2a99d6b281ab92d", size = 400609 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c6/ac/dac4a63f978e4dcb3c6d3a78c4d8e0192a113d288502a1216950c41b1027/parso-0.8.4-py2.py3-none-any.whl", hash = "sha256:a418670a20291dacd2dddc80c377c5c3791378ee1e8d12bffc35420643d43f18", size = 103650 }, +] + +[[package]] +name = "pathspec" +version = "0.12.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ca/bc/f35b8446f4531a7cb215605d100cd88b7ac6f44ab3fc94870c120ab3adbf/pathspec-0.12.1.tar.gz", hash = "sha256:a482d51503a1ab33b1c67a6c3813a26953dbdc71c31dacaef9a838c4e29f5712", size = 51043 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cc/20/ff623b09d963f88bfde16306a54e12ee5ea43e9b597108672ff3a408aad6/pathspec-0.12.1-py3-none-any.whl", hash = "sha256:a0d503e138a4c123b27490a4f7beda6a01c6f288df0e4a8b79c7eb0dc7b4cc08", size = 31191 }, +] + +[[package]] +name = "pexpect" +version = "4.9.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "ptyprocess" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/42/92/cc564bf6381ff43ce1f4d06852fc19a2f11d180f23dc32d9588bee2f149d/pexpect-4.9.0.tar.gz", hash = "sha256:ee7d41123f3c9911050ea2c2dac107568dc43b2d3b0c7557a33212c398ead30f", size = 166450 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9e/c3/059298687310d527a58bb01f3b1965787ee3b40dce76752eda8b44e9a2c5/pexpect-4.9.0-py2.py3-none-any.whl", hash = "sha256:7236d1e080e4936be2dc3e326cec0af72acf9212a7e1d060210e70a47e253523", size = 63772 }, +] + +[[package]] +name = "pickleshare" +version = "0.7.5" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d8/b6/df3c1c9b616e9c0edbc4fbab6ddd09df9535849c64ba51fcb6531c32d4d8/pickleshare-0.7.5.tar.gz", hash = "sha256:87683d47965c1da65cdacaf31c8441d12b8044cdec9aca500cd78fc2c683afca", size = 6161 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9a/41/220f49aaea88bc6fa6cba8d05ecf24676326156c23b991e80b3f2fc24c77/pickleshare-0.7.5-py2.py3-none-any.whl", hash = "sha256:9649af414d74d4df115d5d718f82acb59c9d418196b7b4290ed47a12ce62df56", size = 6877 }, +] + +[[package]] +name = "pillow" +version = "9.5.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine != 'aarch64' and platform_machine != 'arm64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'aarch64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'arm64'", + "python_full_version < '3.7.1'", +] +sdist = { url = "https://files.pythonhosted.org/packages/00/d5/4903f310765e0ff2b8e91ffe55031ac6af77d982f0156061e20a4d1a8b2d/Pillow-9.5.0.tar.gz", hash = "sha256:bf548479d336726d7a0eceb6e767e179fbde37833ae42794602631a070d630f1", size = 50488147 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1b/bc/cff591742feea45f88a3b8a83f7cab4a1dcdb4bcdfc51a06d92f96c81165/Pillow-9.5.0-cp310-cp310-macosx_10_10_x86_64.whl", hash = "sha256:ace6ca218308447b9077c14ea4ef381ba0b67ee78d64046b3f19cf4e1139ad16", size = 3395758 }, + { url = "https://files.pythonhosted.org/packages/38/06/de304914ecd2c911939a28579546bd4d9b6ae0b3c07ce5fe9bd7d100eb34/Pillow-9.5.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:d3d403753c9d5adc04d4694d35cf0391f0f3d57c8e0030aac09d7678fa8030aa", size = 3077111 }, + { url = "https://files.pythonhosted.org/packages/9a/57/7864b6a22acb5f1d4b70af8c92cbd5e3af25f4d5869c24cd8074ca1f3593/Pillow-9.5.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5ba1b81ee69573fe7124881762bb4cd2e4b6ed9dd28c9c60a632902fe8db8b38", size = 3112529 }, + { url = "https://files.pythonhosted.org/packages/62/88/46a35f690ee4f8b08aef5fdb47f63d29c34f6874834155e52bf4456d9566/Pillow-9.5.0-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:fe7e1c262d3392afcf5071df9afa574544f28eac825284596ac6db56e6d11062", size = 3386670 }, + { url = "https://files.pythonhosted.org/packages/59/1d/26a56ed1deae695a8c7d13fb514284ba8b9fd62bab9ebe6d6b474523b8b0/Pillow-9.5.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8f36397bf3f7d7c6a3abdea815ecf6fd14e7fcd4418ab24bae01008d8d8ca15e", size = 3308572 }, + { url = "https://files.pythonhosted.org/packages/d4/36/d22b0fac821a14572fdb9a8015b2bf19ee81eaa560ea25a6772760c86a30/Pillow-9.5.0-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:252a03f1bdddce077eff2354c3861bf437c892fb1832f75ce813ee94347aa9b5", size = 3163999 }, + { url = "https://files.pythonhosted.org/packages/25/6b/d3c35d207c9c0b6c2f855420f62e64ef43d348e8c797ad1c32b9f2106a19/Pillow-9.5.0-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:85ec677246533e27770b0de5cf0f9d6e4ec0c212a1f89dfc941b64b21226009d", size = 3415623 }, + { url = "https://files.pythonhosted.org/packages/7a/6a/a7df39c502caeadd942d8bf97bc2fdfc819fbdc7499a2ab05e7db43611ac/Pillow-9.5.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:b416f03d37d27290cb93597335a2f85ed446731200705b22bb927405320de903", size = 3350658 }, + { url = "https://files.pythonhosted.org/packages/2e/ad/d29c8c48498da680521665b8483beb78a9343269bbd0730970e9396b01f0/Pillow-9.5.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:1781a624c229cb35a2ac31cc4a77e28cafc8900733a864870c49bfeedacd106a", size = 3414574 }, + { url = "https://files.pythonhosted.org/packages/93/54/9d7f01fd3fe4069c88827728646e3c8f1aff0995e8422d841b38f034f39a/Pillow-9.5.0-cp310-cp310-win32.whl", hash = "sha256:8507eda3cd0608a1f94f58c64817e83ec12fa93a9436938b191b80d9e4c0fc44", size = 2211916 }, + { url = "https://files.pythonhosted.org/packages/3e/14/0030e542f2acfea43635e55584c114e6cfd94d342393a5f71f74c172dc35/Pillow-9.5.0-cp310-cp310-win_amd64.whl", hash = "sha256:d3c6b54e304c60c4181da1c9dadf83e4a54fd266a99c70ba646a9baa626819eb", size = 2511474 }, + { url = "https://files.pythonhosted.org/packages/78/a8/3c2d737d856eb9cd8c18e78f6fe0ed08a2805bded74cbb0455584859023b/Pillow-9.5.0-cp311-cp311-macosx_10_10_x86_64.whl", hash = "sha256:7ec6f6ce99dab90b52da21cf0dc519e21095e332ff3b399a357c187b1a5eee32", size = 3395792 }, + { url = "https://files.pythonhosted.org/packages/a9/15/310cde63cb15a091de889ded26281924cf9cfa5c000b36b06bd0c7f50261/Pillow-9.5.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:560737e70cb9c6255d6dcba3de6578a9e2ec4b573659943a5e7e4af13f298f5c", size = 3077092 }, + { url = "https://files.pythonhosted.org/packages/17/66/20db69c0361902a2f6ee2086d3e83c70133e3fb4cb31470e59a8ed37184e/Pillow-9.5.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:96e88745a55b88a7c64fa49bceff363a1a27d9a64e04019c2281049444a571e3", size = 3112543 }, + { url = "https://files.pythonhosted.org/packages/5c/a8/ff526cdec6b56eb20c992e7083f02c8065049ed1e62fbc159390d7a3dd5e/Pillow-9.5.0-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d9c206c29b46cfd343ea7cdfe1232443072bbb270d6a46f59c259460db76779a", size = 3386654 }, + { url = "https://files.pythonhosted.org/packages/3b/70/e9a45a2e9c58c23e023fcda5af9686f5b42c718cc9bc86194e0025cf0ec5/Pillow-9.5.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cfcc2c53c06f2ccb8976fb5c71d448bdd0a07d26d8e07e321c103416444c7ad1", size = 3308566 }, + { url = "https://files.pythonhosted.org/packages/61/a5/ee306d6cc53c9a30c23ba2313b43b67fdf76c611ca5afd0cdd62922cbd3e/Pillow-9.5.0-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:a0f9bb6c80e6efcde93ffc51256d5cfb2155ff8f78292f074f60f9e70b942d99", size = 3164027 }, + { url = "https://files.pythonhosted.org/packages/3d/59/e6bd2c3715ace343d9739276ceed79657fe116923238d102cf731ab463dd/Pillow-9.5.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:8d935f924bbab8f0a9a28404422da8af4904e36d5c33fc6f677e4c4485515625", size = 3415610 }, + { url = "https://files.pythonhosted.org/packages/9a/6d/9beb596ba5a5e61081c843187bcdbb42a5c9a9ef552751b554894247da7a/Pillow-9.5.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:fed1e1cf6a42577953abbe8e6cf2fe2f566daebde7c34724ec8803c4c0cda579", size = 3350704 }, + { url = "https://files.pythonhosted.org/packages/1e/e4/de633d85be3b3c770c554a37a89e8273069bd19c34b15a419c2795600310/Pillow-9.5.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:c1170d6b195555644f0616fd6ed929dfcf6333b8675fcca044ae5ab110ded296", size = 3414604 }, + { url = "https://files.pythonhosted.org/packages/46/a0/e410f655300932308e70e883dd60c0c51e6f74bed138641ea9193e64fd7c/Pillow-9.5.0-cp311-cp311-win32.whl", hash = "sha256:54f7102ad31a3de5666827526e248c3530b3a33539dbda27c6843d19d72644ec", size = 2211929 }, + { url = "https://files.pythonhosted.org/packages/0c/02/7729c8aecbc525b560c7eb283ffa34c6f5a6d0ed6d1339570c65a3e63088/Pillow-9.5.0-cp311-cp311-win_amd64.whl", hash = "sha256:cfa4561277f677ecf651e2b22dc43e8f5368b74a25a8f7d1d4a3a243e573f2d4", size = 2511551 }, + { url = "https://files.pythonhosted.org/packages/b9/8b/d38cc68796be4ac238db327682a1acfbc5deccf64a150aa44ee1efbaafae/Pillow-9.5.0-cp311-cp311-win_arm64.whl", hash = "sha256:965e4a05ef364e7b973dd17fc765f42233415974d773e82144c9bbaaaea5d089", size = 2489206 }, + { url = "https://files.pythonhosted.org/packages/5d/38/b7bcbab3bfe1946ba9cf71c1fa03e541b498069457be49eadcdc229412ef/Pillow-9.5.0-cp312-cp312-win32.whl", hash = "sha256:22baf0c3cf0c7f26e82d6e1adf118027afb325e703922c8dfc1d5d0156bb2eeb", size = 2211914 }, + { url = "https://files.pythonhosted.org/packages/29/8a/f4cf3f32bc554f9260b645ea1151449ac13525796d3d1a42076d75945d8d/Pillow-9.5.0-cp312-cp312-win_amd64.whl", hash = "sha256:432b975c009cf649420615388561c0ce7cc31ce9b2e374db659ee4f7d57a1f8b", size = 2511483 }, + { url = "https://files.pythonhosted.org/packages/ec/7d/01404982db598f271ac7c0d0207860f60ab9288cfacce9872eb567cfbfe3/Pillow-9.5.0-cp37-cp37m-macosx_10_10_x86_64.whl", hash = "sha256:5d4ebf8e1db4441a55c509c4baa7a0587a0210f7cd25fcfe74dbbce7a4bd1906", size = 3394876 }, + { url = "https://files.pythonhosted.org/packages/5b/d9/8599b0e4f750aa3cc43613f57cae5a0dfe841b1a8c8c8bde97e83828cdfd/Pillow-9.5.0-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:375f6e5ee9620a271acb6820b3d1e94ffa8e741c0601db4c0c4d3cb0a9c224bf", size = 3112088 }, + { url = "https://files.pythonhosted.org/packages/b8/c1/2c1daeb1e7c44d477f4f2d92f3316d922c9f8926378afcba424c6d1850aa/Pillow-9.5.0-cp37-cp37m-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:99eb6cafb6ba90e436684e08dad8be1637efb71c4f2180ee6b8f940739406e78", size = 3385803 }, + { url = "https://files.pythonhosted.org/packages/37/95/48565d6beb34deaacda1543b515dab9479b8fa8b9046703fd08ad447ddfe/Pillow-9.5.0-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2dfaaf10b6172697b9bceb9a3bd7b951819d1ca339a5ef294d1f1ac6d7f63270", size = 3307826 }, + { url = "https://files.pythonhosted.org/packages/b0/02/baf83c103657285542bba78978f5f6fb21d419944c2a4c54f950eb84a7bc/Pillow-9.5.0-cp37-cp37m-manylinux_2_28_aarch64.whl", hash = "sha256:763782b2e03e45e2c77d7779875f4432e25121ef002a41829d8868700d119392", size = 3163643 }, + { url = "https://files.pythonhosted.org/packages/2c/a2/2d565cb1d754384a88998b9c86daf803a3a7908577875231eb99b8c7973d/Pillow-9.5.0-cp37-cp37m-manylinux_2_28_x86_64.whl", hash = "sha256:35f6e77122a0c0762268216315bf239cf52b88865bba522999dc38f1c52b9b47", size = 3415119 }, + { url = "https://files.pythonhosted.org/packages/97/d2/f0b4c006c8997aff5277cdde18187c55ce767f9fd32b2dd657c1bf71b570/Pillow-9.5.0-cp37-cp37m-win32.whl", hash = "sha256:aca1c196f407ec7cf04dcbb15d19a43c507a81f7ffc45b690899d6a76ac9fda7", size = 2228447 }, + { url = "https://files.pythonhosted.org/packages/cb/3c/4f3ef1a14e903d7b2bc43672c20f732b874e1e50a9a58ac9a1726ef3773d/Pillow-9.5.0-cp37-cp37m-win_amd64.whl", hash = "sha256:322724c0032af6692456cd6ed554bb85f8149214d97398bb80613b04e33769f6", size = 2536969 }, + { url = "https://files.pythonhosted.org/packages/49/ef/98941488c7491a249692787dc741c97c22d5212a6d85f017519011195cfe/Pillow-9.5.0-cp38-cp38-macosx_10_10_x86_64.whl", hash = "sha256:a0aa9417994d91301056f3d0038af1199eb7adc86e646a36b9e050b06f526597", size = 3395670 }, + { url = "https://files.pythonhosted.org/packages/aa/a5/ba2eeb1a242babb23a21a782356f8b6fe1312b24b69062ee1cb60107fd95/Pillow-9.5.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:f8286396b351785801a976b1e85ea88e937712ee2c3ac653710a4a57a8da5d9c", size = 3077136 }, + { url = "https://files.pythonhosted.org/packages/18/e4/f13369726d14e550f0028265b299f7c8262ccb7fb295df29e4f2fd79e0ab/Pillow-9.5.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c830a02caeb789633863b466b9de10c015bded434deb3ec87c768e53752ad22a", size = 3112507 }, + { url = "https://files.pythonhosted.org/packages/90/00/123c546069abac47bd4ce2e0a78e6ad4040e43294ebbb266a3a21d3616b2/Pillow-9.5.0-cp38-cp38-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:fbd359831c1657d69bb81f0db962905ee05e5e9451913b18b831febfe0519082", size = 3386666 }, + { url = "https://files.pythonhosted.org/packages/1b/dc/2d0919633097a93dcad35a2fb97304f4a9297f746e830a8b441af3db2007/Pillow-9.5.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f8fc330c3370a81bbf3f88557097d1ea26cd8b019d6433aa59f71195f5ddebbf", size = 3308600 }, + { url = "https://files.pythonhosted.org/packages/33/a8/0d37d73387b8ea9cb3ad391a93e65ed9f62a331c0dfed1869891b6efd7a2/Pillow-9.5.0-cp38-cp38-manylinux_2_28_aarch64.whl", hash = "sha256:7002d0797a3e4193c7cdee3198d7c14f92c0836d6b4a3f3046a64bd1ce8df2bf", size = 3163998 }, + { url = "https://files.pythonhosted.org/packages/a6/8b/cca45afbbd58ca032594ea465ded859b9da6d8bc226afe0e60e64bd8872e/Pillow-9.5.0-cp38-cp38-manylinux_2_28_x86_64.whl", hash = "sha256:229e2c79c00e85989a34b5981a2b67aa079fd08c903f0aaead522a1d68d79e51", size = 3415559 }, + { url = "https://files.pythonhosted.org/packages/5d/06/2f319e3244bdd84567ed2d7d405a6e0fd9dd03fc6d7e24794ac1e14d570d/Pillow-9.5.0-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:9adf58f5d64e474bed00d69bcd86ec4bcaa4123bfa70a65ce72e424bfb88ed96", size = 3350681 }, + { url = "https://files.pythonhosted.org/packages/db/5c/ba9e291850f594f89436cdca93d36c6f8610d4fb7833a6c257f4481d4174/Pillow-9.5.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:662da1f3f89a302cc22faa9f14a262c2e3951f9dbc9617609a47521c69dd9f8f", size = 3414578 }, + { url = "https://files.pythonhosted.org/packages/85/4d/d0b5c3610a39f01e380489770b10e2b8644a2188eace45c84e40d439b0dd/Pillow-9.5.0-cp38-cp38-win32.whl", hash = "sha256:6608ff3bf781eee0cd14d0901a2b9cc3d3834516532e3bd673a0a204dc8615fc", size = 2229252 }, + { url = "https://files.pythonhosted.org/packages/c3/ba/c4c2a1411561cd9725979115e7450f1367b44997ae1ff29e5845bce92d52/Pillow-9.5.0-cp38-cp38-win_amd64.whl", hash = "sha256:e49eb4e95ff6fd7c0c402508894b1ef0e01b99a44320ba7d8ecbabefddcc5569", size = 2537784 }, + { url = "https://files.pythonhosted.org/packages/64/46/672289c0ff87733fb93854dedf3a8d65642a25c0bfc88e7f6d722f9161a5/Pillow-9.5.0-cp39-cp39-macosx_10_10_x86_64.whl", hash = "sha256:482877592e927fd263028c105b36272398e3e1be3269efda09f6ba21fd83ec66", size = 3395750 }, + { url = "https://files.pythonhosted.org/packages/a9/70/9259e93534d01f846f7d0501f19bb7d8cc1751741bc20826fc8d3a20fe32/Pillow-9.5.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:3ded42b9ad70e5f1754fb7c2e2d6465a9c842e41d178f262e08b8c85ed8a1d8e", size = 3077133 }, + { url = "https://files.pythonhosted.org/packages/95/62/8a943681db5f6588498ed86aa1568dd31c63f6afdabe50841589fc662c68/Pillow-9.5.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c446d2245ba29820d405315083d55299a796695d747efceb5717a8b450324115", size = 3112534 }, + { url = "https://files.pythonhosted.org/packages/f2/43/0892913d499c8df2c88dee69d59e77de19e0c51754a9be82023880641c09/Pillow-9.5.0-cp39-cp39-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:8aca1152d93dcc27dc55395604dcfc55bed5f25ef4c98716a928bacba90d33a3", size = 3386725 }, + { url = "https://files.pythonhosted.org/packages/ff/fc/48a51c0fe2a00d5def57b9981a1e0f8339b516351da7a51500383d833bc8/Pillow-9.5.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:608488bdcbdb4ba7837461442b90ea6f3079397ddc968c31265c1e056964f1ef", size = 3308605 }, + { url = "https://files.pythonhosted.org/packages/af/b7/f9faf80e3c93b02712c5748f10c75a8948e74eca61ec2408f7e1d4c9dd16/Pillow-9.5.0-cp39-cp39-manylinux_2_28_aarch64.whl", hash = "sha256:60037a8db8750e474af7ffc9faa9b5859e6c6d0a50e55c45576bf28be7419705", size = 3164057 }, + { url = "https://files.pythonhosted.org/packages/3b/2b/57915b8af178e2c20bfd403ffed4521947881f9dbbfbaba48210dc59b9d7/Pillow-9.5.0-cp39-cp39-manylinux_2_28_x86_64.whl", hash = "sha256:07999f5834bdc404c442146942a2ecadd1cb6292f5229f4ed3b31e0a108746b1", size = 3415613 }, + { url = "https://files.pythonhosted.org/packages/e7/2a/f3ed578595f8486ee2cc07434460097d89aedd406a3db849b890ca8ec416/Pillow-9.5.0-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:a127ae76092974abfbfa38ca2d12cbeddcdeac0fb71f9627cc1135bedaf9d51a", size = 3350667 }, + { url = "https://files.pythonhosted.org/packages/28/a2/f2d0d584d45100a5419fd70a1233ade8f12469ffe6e8e3acd40364beaadb/Pillow-9.5.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:489f8389261e5ed43ac8ff7b453162af39c3e8abd730af8363587ba64bb2e865", size = 3414552 }, + { url = "https://files.pythonhosted.org/packages/51/3a/a6701b987007aaa43559b7d8510629845b25686f09a0eb29f8946a62d767/Pillow-9.5.0-cp39-cp39-win32.whl", hash = "sha256:9b1af95c3a967bf1da94f253e56b6286b50af23392a886720f563c547e48e964", size = 2229361 }, + { url = "https://files.pythonhosted.org/packages/69/72/48cc52bff8731cf72bc4101e34dc44807a410c171f921afb582a511da50e/Pillow-9.5.0-cp39-cp39-win_amd64.whl", hash = "sha256:77165c4a5e7d5a284f10a6efaa39a0ae8ba839da344f20b111d62cc932fa4e5d", size = 2538580 }, + { url = "https://files.pythonhosted.org/packages/05/80/40ec3390eb39f128f9c81dfdce6fe419fad1296e816232c2785e74bb6255/Pillow-9.5.0-pp38-pypy38_pp73-macosx_10_10_x86_64.whl", hash = "sha256:833b86a98e0ede388fa29363159c9b1a294b0905b5128baf01db683672f230f5", size = 3350068 }, + { url = "https://files.pythonhosted.org/packages/52/f8/099a6b9de39763b40ed6be5c0aa5b5aed800ecad98535c6c77dfa79484f1/Pillow-9.5.0-pp38-pypy38_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:aaf305d6d40bd9632198c766fb64f0c1a83ca5b667f16c1e79e1661ab5060140", size = 3281820 }, + { url = "https://files.pythonhosted.org/packages/0d/4f/e31e4814b09f15c13d6fe069458a3b32a240ffaeb603b973456de3ea6d2a/Pillow-9.5.0-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0852ddb76d85f127c135b6dd1f0bb88dbb9ee990d2cd9aa9e28526c93e794fba", size = 3222897 }, + { url = "https://files.pythonhosted.org/packages/22/3b/db9837995e3d51ff356e39726e2ec0925850fdfef104996c2767baca4407/Pillow-9.5.0-pp38-pypy38_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:91ec6fe47b5eb5a9968c79ad9ed78c342b1f97a091677ba0e012701add857829", size = 3298302 }, + { url = "https://files.pythonhosted.org/packages/d9/0e/7c6f054022235830dc2c37ec83e947d9ca09b0b0361e1e5e29983da92294/Pillow-9.5.0-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:cb841572862f629b99725ebaec3287fc6d275be9b14443ea746c1dd325053cbd", size = 2537868 }, + { url = "https://files.pythonhosted.org/packages/24/35/92032a00f41bea9bf93f19d48f15daac27d1365c0038fe22dc4e7fc7c8b0/Pillow-9.5.0-pp39-pypy39_pp73-macosx_10_10_x86_64.whl", hash = "sha256:c380b27d041209b849ed246b111b7c166ba36d7933ec6e41175fd15ab9eb1572", size = 3349772 }, + { url = "https://files.pythonhosted.org/packages/50/ce/d39869c22904558ce32e664904cf72f13a9d47703b72392e881d9e7b6082/Pillow-9.5.0-pp39-pypy39_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7c9af5a3b406a50e313467e3565fc99929717f780164fe6fbb7704edba0cebbe", size = 3281583 }, + { url = "https://files.pythonhosted.org/packages/7a/75/4a382d1567efc6f4e3054f693167f8ce2d1ad939c5f6f12aa5c50f74b997/Pillow-9.5.0-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5671583eab84af046a397d6d0ba25343c00cd50bce03787948e0fff01d4fd9b1", size = 3222603 }, + { url = "https://files.pythonhosted.org/packages/51/d2/c10f72c44e000d08e41f822083cf322bb59afa7ed01ae7e3e47875b47600/Pillow-9.5.0-pp39-pypy39_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:84a6f19ce086c1bf894644b43cd129702f781ba5751ca8572f08aa40ef0ab7b7", size = 3298174 }, + { url = "https://files.pythonhosted.org/packages/02/4a/d362f7f44f1e5801c6726f0eaaeaf869d0d43c554b717072b2c5540cefb4/Pillow-9.5.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:1e7723bd90ef94eda669a3c2c19d549874dd5badaeefabefd26053304abe5799", size = 2538628 }, +] + +[[package]] +name = "pillow" +version = "10.4.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version == '3.8.*'", +] +sdist = { url = "https://files.pythonhosted.org/packages/cd/74/ad3d526f3bf7b6d3f408b73fde271ec69dfac8b81341a318ce825f2b3812/pillow-10.4.0.tar.gz", hash = "sha256:166c1cd4d24309b30d61f79f4a9114b7b2313d7450912277855ff5dfd7cd4a06", size = 46555059 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0e/69/a31cccd538ca0b5272be2a38347f8839b97a14be104ea08b0db92f749c74/pillow-10.4.0-cp310-cp310-macosx_10_10_x86_64.whl", hash = "sha256:4d9667937cfa347525b319ae34375c37b9ee6b525440f3ef48542fcf66f2731e", size = 3509271 }, + { url = "https://files.pythonhosted.org/packages/9a/9e/4143b907be8ea0bce215f2ae4f7480027473f8b61fcedfda9d851082a5d2/pillow-10.4.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:543f3dc61c18dafb755773efc89aae60d06b6596a63914107f75459cf984164d", size = 3375658 }, + { url = "https://files.pythonhosted.org/packages/8a/25/1fc45761955f9359b1169aa75e241551e74ac01a09f487adaaf4c3472d11/pillow-10.4.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7928ecbf1ece13956b95d9cbcfc77137652b02763ba384d9ab508099a2eca856", size = 4332075 }, + { url = "https://files.pythonhosted.org/packages/5e/dd/425b95d0151e1d6c951f45051112394f130df3da67363b6bc75dc4c27aba/pillow-10.4.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e4d49b85c4348ea0b31ea63bc75a9f3857869174e2bf17e7aba02945cd218e6f", size = 4444808 }, + { url = "https://files.pythonhosted.org/packages/b1/84/9a15cc5726cbbfe7f9f90bfb11f5d028586595907cd093815ca6644932e3/pillow-10.4.0-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:6c762a5b0997f5659a5ef2266abc1d8851ad7749ad9a6a5506eb23d314e4f46b", size = 4356290 }, + { url = "https://files.pythonhosted.org/packages/b5/5b/6651c288b08df3b8c1e2f8c1152201e0b25d240e22ddade0f1e242fc9fa0/pillow-10.4.0-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:a985e028fc183bf12a77a8bbf36318db4238a3ded7fa9df1b9a133f1cb79f8fc", size = 4525163 }, + { url = "https://files.pythonhosted.org/packages/07/8b/34854bf11a83c248505c8cb0fcf8d3d0b459a2246c8809b967963b6b12ae/pillow-10.4.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:812f7342b0eee081eaec84d91423d1b4650bb9828eb53d8511bcef8ce5aecf1e", size = 4463100 }, + { url = "https://files.pythonhosted.org/packages/78/63/0632aee4e82476d9cbe5200c0cdf9ba41ee04ed77887432845264d81116d/pillow-10.4.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:ac1452d2fbe4978c2eec89fb5a23b8387aba707ac72810d9490118817d9c0b46", size = 4592880 }, + { url = "https://files.pythonhosted.org/packages/df/56/b8663d7520671b4398b9d97e1ed9f583d4afcbefbda3c6188325e8c297bd/pillow-10.4.0-cp310-cp310-win32.whl", hash = "sha256:bcd5e41a859bf2e84fdc42f4edb7d9aba0a13d29a2abadccafad99de3feff984", size = 2235218 }, + { url = "https://files.pythonhosted.org/packages/f4/72/0203e94a91ddb4a9d5238434ae6c1ca10e610e8487036132ea9bf806ca2a/pillow-10.4.0-cp310-cp310-win_amd64.whl", hash = "sha256:ecd85a8d3e79cd7158dec1c9e5808e821feea088e2f69a974db5edf84dc53141", size = 2554487 }, + { url = "https://files.pythonhosted.org/packages/bd/52/7e7e93d7a6e4290543f17dc6f7d3af4bd0b3dd9926e2e8a35ac2282bc5f4/pillow-10.4.0-cp310-cp310-win_arm64.whl", hash = "sha256:ff337c552345e95702c5fde3158acb0625111017d0e5f24bf3acdb9cc16b90d1", size = 2243219 }, + { url = "https://files.pythonhosted.org/packages/a7/62/c9449f9c3043c37f73e7487ec4ef0c03eb9c9afc91a92b977a67b3c0bbc5/pillow-10.4.0-cp311-cp311-macosx_10_10_x86_64.whl", hash = "sha256:0a9ec697746f268507404647e531e92889890a087e03681a3606d9b920fbee3c", size = 3509265 }, + { url = "https://files.pythonhosted.org/packages/f4/5f/491dafc7bbf5a3cc1845dc0430872e8096eb9e2b6f8161509d124594ec2d/pillow-10.4.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:dfe91cb65544a1321e631e696759491ae04a2ea11d36715eca01ce07284738be", size = 3375655 }, + { url = "https://files.pythonhosted.org/packages/73/d5/c4011a76f4207a3c151134cd22a1415741e42fa5ddecec7c0182887deb3d/pillow-10.4.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5dc6761a6efc781e6a1544206f22c80c3af4c8cf461206d46a1e6006e4429ff3", size = 4340304 }, + { url = "https://files.pythonhosted.org/packages/ac/10/c67e20445a707f7a610699bba4fe050583b688d8cd2d202572b257f46600/pillow-10.4.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5e84b6cc6a4a3d76c153a6b19270b3526a5a8ed6b09501d3af891daa2a9de7d6", size = 4452804 }, + { url = "https://files.pythonhosted.org/packages/a9/83/6523837906d1da2b269dee787e31df3b0acb12e3d08f024965a3e7f64665/pillow-10.4.0-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:bbc527b519bd3aa9d7f429d152fea69f9ad37c95f0b02aebddff592688998abe", size = 4365126 }, + { url = "https://files.pythonhosted.org/packages/ba/e5/8c68ff608a4203085158cff5cc2a3c534ec384536d9438c405ed6370d080/pillow-10.4.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:76a911dfe51a36041f2e756b00f96ed84677cdeb75d25c767f296c1c1eda1319", size = 4533541 }, + { url = "https://files.pythonhosted.org/packages/f4/7c/01b8dbdca5bc6785573f4cee96e2358b0918b7b2c7b60d8b6f3abf87a070/pillow-10.4.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:59291fb29317122398786c2d44427bbd1a6d7ff54017075b22be9d21aa59bd8d", size = 4471616 }, + { url = "https://files.pythonhosted.org/packages/c8/57/2899b82394a35a0fbfd352e290945440e3b3785655a03365c0ca8279f351/pillow-10.4.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:416d3a5d0e8cfe4f27f574362435bc9bae57f679a7158e0096ad2beb427b8696", size = 4600802 }, + { url = "https://files.pythonhosted.org/packages/4d/d7/a44f193d4c26e58ee5d2d9db3d4854b2cfb5b5e08d360a5e03fe987c0086/pillow-10.4.0-cp311-cp311-win32.whl", hash = "sha256:7086cc1d5eebb91ad24ded9f58bec6c688e9f0ed7eb3dbbf1e4800280a896496", size = 2235213 }, + { url = "https://files.pythonhosted.org/packages/c1/d0/5866318eec2b801cdb8c82abf190c8343d8a1cd8bf5a0c17444a6f268291/pillow-10.4.0-cp311-cp311-win_amd64.whl", hash = "sha256:cbed61494057c0f83b83eb3a310f0bf774b09513307c434d4366ed64f4128a91", size = 2554498 }, + { url = "https://files.pythonhosted.org/packages/d4/c8/310ac16ac2b97e902d9eb438688de0d961660a87703ad1561fd3dfbd2aa0/pillow-10.4.0-cp311-cp311-win_arm64.whl", hash = "sha256:f5f0c3e969c8f12dd2bb7e0b15d5c468b51e5017e01e2e867335c81903046a22", size = 2243219 }, + { url = "https://files.pythonhosted.org/packages/05/cb/0353013dc30c02a8be34eb91d25e4e4cf594b59e5a55ea1128fde1e5f8ea/pillow-10.4.0-cp312-cp312-macosx_10_10_x86_64.whl", hash = "sha256:673655af3eadf4df6b5457033f086e90299fdd7a47983a13827acf7459c15d94", size = 3509350 }, + { url = "https://files.pythonhosted.org/packages/e7/cf/5c558a0f247e0bf9cec92bff9b46ae6474dd736f6d906315e60e4075f737/pillow-10.4.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:866b6942a92f56300012f5fbac71f2d610312ee65e22f1aa2609e491284e5597", size = 3374980 }, + { url = "https://files.pythonhosted.org/packages/84/48/6e394b86369a4eb68b8a1382c78dc092245af517385c086c5094e3b34428/pillow-10.4.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:29dbdc4207642ea6aad70fbde1a9338753d33fb23ed6956e706936706f52dd80", size = 4343799 }, + { url = "https://files.pythonhosted.org/packages/3b/f3/a8c6c11fa84b59b9df0cd5694492da8c039a24cd159f0f6918690105c3be/pillow-10.4.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bf2342ac639c4cf38799a44950bbc2dfcb685f052b9e262f446482afaf4bffca", size = 4459973 }, + { url = "https://files.pythonhosted.org/packages/7d/1b/c14b4197b80150fb64453585247e6fb2e1d93761fa0fa9cf63b102fde822/pillow-10.4.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:f5b92f4d70791b4a67157321c4e8225d60b119c5cc9aee8ecf153aace4aad4ef", size = 4370054 }, + { url = "https://files.pythonhosted.org/packages/55/77/40daddf677897a923d5d33329acd52a2144d54a9644f2a5422c028c6bf2d/pillow-10.4.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:86dcb5a1eb778d8b25659d5e4341269e8590ad6b4e8b44d9f4b07f8d136c414a", size = 4539484 }, + { url = "https://files.pythonhosted.org/packages/40/54/90de3e4256b1207300fb2b1d7168dd912a2fb4b2401e439ba23c2b2cabde/pillow-10.4.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:780c072c2e11c9b2c7ca37f9a2ee8ba66f44367ac3e5c7832afcfe5104fd6d1b", size = 4477375 }, + { url = "https://files.pythonhosted.org/packages/13/24/1bfba52f44193860918ff7c93d03d95e3f8748ca1de3ceaf11157a14cf16/pillow-10.4.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:37fb69d905be665f68f28a8bba3c6d3223c8efe1edf14cc4cfa06c241f8c81d9", size = 4608773 }, + { url = "https://files.pythonhosted.org/packages/55/04/5e6de6e6120451ec0c24516c41dbaf80cce1b6451f96561235ef2429da2e/pillow-10.4.0-cp312-cp312-win32.whl", hash = "sha256:7dfecdbad5c301d7b5bde160150b4db4c659cee2b69589705b6f8a0c509d9f42", size = 2235690 }, + { url = "https://files.pythonhosted.org/packages/74/0a/d4ce3c44bca8635bd29a2eab5aa181b654a734a29b263ca8efe013beea98/pillow-10.4.0-cp312-cp312-win_amd64.whl", hash = "sha256:1d846aea995ad352d4bdcc847535bd56e0fd88d36829d2c90be880ef1ee4668a", size = 2554951 }, + { url = "https://files.pythonhosted.org/packages/b5/ca/184349ee40f2e92439be9b3502ae6cfc43ac4b50bc4fc6b3de7957563894/pillow-10.4.0-cp312-cp312-win_arm64.whl", hash = "sha256:e553cad5179a66ba15bb18b353a19020e73a7921296a7979c4a2b7f6a5cd57f9", size = 2243427 }, + { url = "https://files.pythonhosted.org/packages/c3/00/706cebe7c2c12a6318aabe5d354836f54adff7156fd9e1bd6c89f4ba0e98/pillow-10.4.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8bc1a764ed8c957a2e9cacf97c8b2b053b70307cf2996aafd70e91a082e70df3", size = 3525685 }, + { url = "https://files.pythonhosted.org/packages/cf/76/f658cbfa49405e5ecbfb9ba42d07074ad9792031267e782d409fd8fe7c69/pillow-10.4.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:6209bb41dc692ddfee4942517c19ee81b86c864b626dbfca272ec0f7cff5d9fb", size = 3374883 }, + { url = "https://files.pythonhosted.org/packages/46/2b/99c28c4379a85e65378211971c0b430d9c7234b1ec4d59b2668f6299e011/pillow-10.4.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bee197b30783295d2eb680b311af15a20a8b24024a19c3a26431ff83eb8d1f70", size = 4339837 }, + { url = "https://files.pythonhosted.org/packages/f1/74/b1ec314f624c0c43711fdf0d8076f82d9d802afd58f1d62c2a86878e8615/pillow-10.4.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1ef61f5dd14c300786318482456481463b9d6b91ebe5ef12f405afbba77ed0be", size = 4455562 }, + { url = "https://files.pythonhosted.org/packages/4a/2a/4b04157cb7b9c74372fa867096a1607e6fedad93a44deeff553ccd307868/pillow-10.4.0-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:297e388da6e248c98bc4a02e018966af0c5f92dfacf5a5ca22fa01cb3179bca0", size = 4366761 }, + { url = "https://files.pythonhosted.org/packages/ac/7b/8f1d815c1a6a268fe90481232c98dd0e5fa8c75e341a75f060037bd5ceae/pillow-10.4.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:e4db64794ccdf6cb83a59d73405f63adbe2a1887012e308828596100a0b2f6cc", size = 4536767 }, + { url = "https://files.pythonhosted.org/packages/e5/77/05fa64d1f45d12c22c314e7b97398ffb28ef2813a485465017b7978b3ce7/pillow-10.4.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:bd2880a07482090a3bcb01f4265f1936a903d70bc740bfcb1fd4e8a2ffe5cf5a", size = 4477989 }, + { url = "https://files.pythonhosted.org/packages/12/63/b0397cfc2caae05c3fb2f4ed1b4fc4fc878f0243510a7a6034ca59726494/pillow-10.4.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:4b35b21b819ac1dbd1233317adeecd63495f6babf21b7b2512d244ff6c6ce309", size = 4610255 }, + { url = "https://files.pythonhosted.org/packages/7b/f9/cfaa5082ca9bc4a6de66ffe1c12c2d90bf09c309a5f52b27759a596900e7/pillow-10.4.0-cp313-cp313-win32.whl", hash = "sha256:551d3fd6e9dc15e4c1eb6fc4ba2b39c0c7933fa113b220057a34f4bb3268a060", size = 2235603 }, + { url = "https://files.pythonhosted.org/packages/01/6a/30ff0eef6e0c0e71e55ded56a38d4859bf9d3634a94a88743897b5f96936/pillow-10.4.0-cp313-cp313-win_amd64.whl", hash = "sha256:030abdbe43ee02e0de642aee345efa443740aa4d828bfe8e2eb11922ea6a21ea", size = 2554972 }, + { url = "https://files.pythonhosted.org/packages/48/2c/2e0a52890f269435eee38b21c8218e102c621fe8d8df8b9dd06fabf879ba/pillow-10.4.0-cp313-cp313-win_arm64.whl", hash = "sha256:5b001114dd152cfd6b23befeb28d7aee43553e2402c9f159807bf55f33af8a8d", size = 2243375 }, + { url = "https://files.pythonhosted.org/packages/56/70/f40009702a477ce87d8d9faaa4de51d6562b3445d7a314accd06e4ffb01d/pillow-10.4.0-cp38-cp38-macosx_10_10_x86_64.whl", hash = "sha256:8d4d5063501b6dd4024b8ac2f04962d661222d120381272deea52e3fc52d3736", size = 3509213 }, + { url = "https://files.pythonhosted.org/packages/10/43/105823d233c5e5d31cea13428f4474ded9d961652307800979a59d6a4276/pillow-10.4.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:7c1ee6f42250df403c5f103cbd2768a28fe1a0ea1f0f03fe151c8741e1469c8b", size = 3375883 }, + { url = "https://files.pythonhosted.org/packages/3c/ad/7850c10bac468a20c918f6a5dbba9ecd106ea1cdc5db3c35e33a60570408/pillow-10.4.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b15e02e9bb4c21e39876698abf233c8c579127986f8207200bc8a8f6bb27acf2", size = 4330810 }, + { url = "https://files.pythonhosted.org/packages/84/4c/69bbed9e436ac22f9ed193a2b64f64d68fcfbc9f4106249dc7ed4889907b/pillow-10.4.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7a8d4bade9952ea9a77d0c3e49cbd8b2890a399422258a77f357b9cc9be8d680", size = 4444341 }, + { url = "https://files.pythonhosted.org/packages/8f/4f/c183c63828a3f37bf09644ce94cbf72d4929b033b109160a5379c2885932/pillow-10.4.0-cp38-cp38-manylinux_2_28_aarch64.whl", hash = "sha256:43efea75eb06b95d1631cb784aa40156177bf9dd5b4b03ff38979e048258bc6b", size = 4356005 }, + { url = "https://files.pythonhosted.org/packages/fb/ad/435fe29865f98a8fbdc64add8875a6e4f8c97749a93577a8919ec6f32c64/pillow-10.4.0-cp38-cp38-manylinux_2_28_x86_64.whl", hash = "sha256:950be4d8ba92aca4b2bb0741285a46bfae3ca699ef913ec8416c1b78eadd64cd", size = 4525201 }, + { url = "https://files.pythonhosted.org/packages/80/74/be8bf8acdfd70e91f905a12ae13cfb2e17c0f1da745c40141e26d0971ff5/pillow-10.4.0-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:d7480af14364494365e89d6fddc510a13e5a2c3584cb19ef65415ca57252fb84", size = 4460635 }, + { url = "https://files.pythonhosted.org/packages/e4/90/763616e66dc9ad59c9b7fb58f863755e7934ef122e52349f62c7742b82d3/pillow-10.4.0-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:73664fe514b34c8f02452ffb73b7a92c6774e39a647087f83d67f010eb9a0cf0", size = 4590283 }, + { url = "https://files.pythonhosted.org/packages/69/66/03002cb5b2c27bb519cba63b9f9aa3709c6f7a5d3b285406c01f03fb77e5/pillow-10.4.0-cp38-cp38-win32.whl", hash = "sha256:e88d5e6ad0d026fba7bdab8c3f225a69f063f116462c49892b0149e21b6c0a0e", size = 2235185 }, + { url = "https://files.pythonhosted.org/packages/f2/75/3cb820b2812405fc7feb3d0deb701ef0c3de93dc02597115e00704591bc9/pillow-10.4.0-cp38-cp38-win_amd64.whl", hash = "sha256:5161eef006d335e46895297f642341111945e2c1c899eb406882a6c61a4357ab", size = 2554594 }, + { url = "https://files.pythonhosted.org/packages/31/85/955fa5400fa8039921f630372cfe5056eed6e1b8e0430ee4507d7de48832/pillow-10.4.0-cp39-cp39-macosx_10_10_x86_64.whl", hash = "sha256:0ae24a547e8b711ccaaf99c9ae3cd975470e1a30caa80a6aaee9a2f19c05701d", size = 3509283 }, + { url = "https://files.pythonhosted.org/packages/23/9c/343827267eb28d41cd82b4180d33b10d868af9077abcec0af9793aa77d2d/pillow-10.4.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:298478fe4f77a4408895605f3482b6cc6222c018b2ce565c2b6b9c354ac3229b", size = 3375691 }, + { url = "https://files.pythonhosted.org/packages/60/a3/7ebbeabcd341eab722896d1a5b59a3df98c4b4d26cf4b0385f8aa94296f7/pillow-10.4.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:134ace6dc392116566980ee7436477d844520a26a4b1bd4053f6f47d096997fd", size = 4328295 }, + { url = "https://files.pythonhosted.org/packages/32/3f/c02268d0c6fb6b3958bdda673c17b315c821d97df29ae6969f20fb49388a/pillow-10.4.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:930044bb7679ab003b14023138b50181899da3f25de50e9dbee23b61b4de2126", size = 4440810 }, + { url = "https://files.pythonhosted.org/packages/67/5d/1c93c8cc35f2fdd3d6cc7e4ad72d203902859a2867de6ad957d9b708eb8d/pillow-10.4.0-cp39-cp39-manylinux_2_28_aarch64.whl", hash = "sha256:c76e5786951e72ed3686e122d14c5d7012f16c8303a674d18cdcd6d89557fc5b", size = 4352283 }, + { url = "https://files.pythonhosted.org/packages/bc/a8/8655557c9c7202b8abbd001f61ff36711cefaf750debcaa1c24d154ef602/pillow-10.4.0-cp39-cp39-manylinux_2_28_x86_64.whl", hash = "sha256:b2724fdb354a868ddf9a880cb84d102da914e99119211ef7ecbdc613b8c96b3c", size = 4521800 }, + { url = "https://files.pythonhosted.org/packages/58/78/6f95797af64d137124f68af1bdaa13b5332da282b86031f6fa70cf368261/pillow-10.4.0-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:dbc6ae66518ab3c5847659e9988c3b60dc94ffb48ef9168656e0019a93dbf8a1", size = 4459177 }, + { url = "https://files.pythonhosted.org/packages/8a/6d/2b3ce34f1c4266d79a78c9a51d1289a33c3c02833fe294ef0dcbb9cba4ed/pillow-10.4.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:06b2f7898047ae93fad74467ec3d28fe84f7831370e3c258afa533f81ef7f3df", size = 4589079 }, + { url = "https://files.pythonhosted.org/packages/e3/e0/456258c74da1ff5bf8ef1eab06a95ca994d8b9ed44c01d45c3f8cbd1db7e/pillow-10.4.0-cp39-cp39-win32.whl", hash = "sha256:7970285ab628a3779aecc35823296a7869f889b8329c16ad5a71e4901a3dc4ef", size = 2235247 }, + { url = "https://files.pythonhosted.org/packages/37/f8/bef952bdb32aa53741f58bf21798642209e994edc3f6598f337f23d5400a/pillow-10.4.0-cp39-cp39-win_amd64.whl", hash = "sha256:961a7293b2457b405967af9c77dcaa43cc1a8cd50d23c532e62d48ab6cdd56f5", size = 2554479 }, + { url = "https://files.pythonhosted.org/packages/bb/8e/805201619cad6651eef5fc1fdef913804baf00053461522fabbc5588ea12/pillow-10.4.0-cp39-cp39-win_arm64.whl", hash = "sha256:32cda9e3d601a52baccb2856b8ea1fc213c90b340c542dcef77140dfa3278a9e", size = 2243226 }, + { url = "https://files.pythonhosted.org/packages/38/30/095d4f55f3a053392f75e2eae45eba3228452783bab3d9a920b951ac495c/pillow-10.4.0-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:5b4815f2e65b30f5fbae9dfffa8636d992d49705723fe86a3661806e069352d4", size = 3493889 }, + { url = "https://files.pythonhosted.org/packages/f3/e8/4ff79788803a5fcd5dc35efdc9386af153569853767bff74540725b45863/pillow-10.4.0-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:8f0aef4ef59694b12cadee839e2ba6afeab89c0f39a3adc02ed51d109117b8da", size = 3346160 }, + { url = "https://files.pythonhosted.org/packages/d7/ac/4184edd511b14f760c73f5bb8a5d6fd85c591c8aff7c2229677a355c4179/pillow-10.4.0-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9f4727572e2918acaa9077c919cbbeb73bd2b3ebcfe033b72f858fc9fbef0026", size = 3435020 }, + { url = "https://files.pythonhosted.org/packages/da/21/1749cd09160149c0a246a81d646e05f35041619ce76f6493d6a96e8d1103/pillow-10.4.0-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ff25afb18123cea58a591ea0244b92eb1e61a1fd497bf6d6384f09bc3262ec3e", size = 3490539 }, + { url = "https://files.pythonhosted.org/packages/b6/f5/f71fe1888b96083b3f6dfa0709101f61fc9e972c0c8d04e9d93ccef2a045/pillow-10.4.0-pp310-pypy310_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:dc3e2db6ba09ffd7d02ae9141cfa0ae23393ee7687248d46a7507b75d610f4f5", size = 3476125 }, + { url = "https://files.pythonhosted.org/packages/96/b9/c0362c54290a31866c3526848583a2f45a535aa9d725fd31e25d318c805f/pillow-10.4.0-pp310-pypy310_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:02a2be69f9c9b8c1e97cf2713e789d4e398c751ecfd9967c18d0ce304efbf885", size = 3579373 }, + { url = "https://files.pythonhosted.org/packages/52/3b/ce7a01026a7cf46e5452afa86f97a5e88ca97f562cafa76570178ab56d8d/pillow-10.4.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:0755ffd4a0c6f267cccbae2e9903d95477ca2f77c4fcf3a3a09570001856c8a5", size = 2554661 }, + { url = "https://files.pythonhosted.org/packages/e1/1f/5a9fcd6ced51633c22481417e11b1b47d723f64fb536dfd67c015eb7f0ab/pillow-10.4.0-pp39-pypy39_pp73-macosx_10_15_x86_64.whl", hash = "sha256:a02364621fe369e06200d4a16558e056fe2805d3468350df3aef21e00d26214b", size = 3493850 }, + { url = "https://files.pythonhosted.org/packages/cb/e6/3ea4755ed5320cb62aa6be2f6de47b058c6550f752dd050e86f694c59798/pillow-10.4.0-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:1b5dea9831a90e9d0721ec417a80d4cbd7022093ac38a568db2dd78363b00908", size = 3346118 }, + { url = "https://files.pythonhosted.org/packages/0a/22/492f9f61e4648422b6ca39268ec8139277a5b34648d28f400faac14e0f48/pillow-10.4.0-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9b885f89040bb8c4a1573566bbb2f44f5c505ef6e74cec7ab9068c900047f04b", size = 3434958 }, + { url = "https://files.pythonhosted.org/packages/f9/19/559a48ad4045704bb0547965b9a9345f5cd461347d977a56d178db28819e/pillow-10.4.0-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:87dd88ded2e6d74d31e1e0a99a726a6765cda32d00ba72dc37f0651f306daaa8", size = 3490340 }, + { url = "https://files.pythonhosted.org/packages/d9/de/cebaca6fb79905b3a1aa0281d238769df3fb2ede34fd7c0caa286575915a/pillow-10.4.0-pp39-pypy39_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:2db98790afc70118bd0255c2eeb465e9767ecf1f3c25f9a1abb8ffc8cfd1fe0a", size = 3476048 }, + { url = "https://files.pythonhosted.org/packages/71/f0/86d5b2f04693b0116a01d75302b0a307800a90d6c351a8aa4f8ae76cd499/pillow-10.4.0-pp39-pypy39_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:f7baece4ce06bade126fb84b8af1c33439a76d8a6fd818970215e0560ca28c27", size = 3579366 }, + { url = "https://files.pythonhosted.org/packages/37/ae/2dbfc38cc4fd14aceea14bc440d5151b21f64c4c3ba3f6f4191610b7ee5d/pillow-10.4.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:cfdd747216947628af7b259d274771d84db2268ca062dd5faf373639d00113a3", size = 2554652 }, +] + +[[package]] +name = "pillow" +version = "11.1.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", + "python_full_version == '3.10.*'", + "python_full_version == '3.9.*'", +] +sdist = { url = "https://files.pythonhosted.org/packages/f3/af/c097e544e7bd278333db77933e535098c259609c4eb3b85381109602fb5b/pillow-11.1.0.tar.gz", hash = "sha256:368da70808b36d73b4b390a8ffac11069f8a5c85f29eff1f1b01bcf3ef5b2a20", size = 46742715 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/50/1c/2dcea34ac3d7bc96a1fd1bd0a6e06a57c67167fec2cff8d95d88229a8817/pillow-11.1.0-cp310-cp310-macosx_10_10_x86_64.whl", hash = "sha256:e1abe69aca89514737465752b4bcaf8016de61b3be1397a8fc260ba33321b3a8", size = 3229983 }, + { url = "https://files.pythonhosted.org/packages/14/ca/6bec3df25e4c88432681de94a3531cc738bd85dea6c7aa6ab6f81ad8bd11/pillow-11.1.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:c640e5a06869c75994624551f45e5506e4256562ead981cce820d5ab39ae2192", size = 3101831 }, + { url = "https://files.pythonhosted.org/packages/d4/2c/668e18e5521e46eb9667b09e501d8e07049eb5bfe39d56be0724a43117e6/pillow-11.1.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a07dba04c5e22824816b2615ad7a7484432d7f540e6fa86af60d2de57b0fcee2", size = 4314074 }, + { url = "https://files.pythonhosted.org/packages/02/80/79f99b714f0fc25f6a8499ecfd1f810df12aec170ea1e32a4f75746051ce/pillow-11.1.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e267b0ed063341f3e60acd25c05200df4193e15a4a5807075cd71225a2386e26", size = 4394933 }, + { url = "https://files.pythonhosted.org/packages/81/aa/8d4ad25dc11fd10a2001d5b8a80fdc0e564ac33b293bdfe04ed387e0fd95/pillow-11.1.0-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:bd165131fd51697e22421d0e467997ad31621b74bfc0b75956608cb2906dda07", size = 4353349 }, + { url = "https://files.pythonhosted.org/packages/84/7a/cd0c3eaf4a28cb2a74bdd19129f7726277a7f30c4f8424cd27a62987d864/pillow-11.1.0-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:abc56501c3fd148d60659aae0af6ddc149660469082859fa7b066a298bde9482", size = 4476532 }, + { url = "https://files.pythonhosted.org/packages/8f/8b/a907fdd3ae8f01c7670dfb1499c53c28e217c338b47a813af8d815e7ce97/pillow-11.1.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:54ce1c9a16a9561b6d6d8cb30089ab1e5eb66918cb47d457bd996ef34182922e", size = 4279789 }, + { url = "https://files.pythonhosted.org/packages/6f/9a/9f139d9e8cccd661c3efbf6898967a9a337eb2e9be2b454ba0a09533100d/pillow-11.1.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:73ddde795ee9b06257dac5ad42fcb07f3b9b813f8c1f7f870f402f4dc54b5269", size = 4413131 }, + { url = "https://files.pythonhosted.org/packages/a8/68/0d8d461f42a3f37432203c8e6df94da10ac8081b6d35af1c203bf3111088/pillow-11.1.0-cp310-cp310-win32.whl", hash = "sha256:3a5fe20a7b66e8135d7fd617b13272626a28278d0e578c98720d9ba4b2439d49", size = 2291213 }, + { url = "https://files.pythonhosted.org/packages/14/81/d0dff759a74ba87715509af9f6cb21fa21d93b02b3316ed43bda83664db9/pillow-11.1.0-cp310-cp310-win_amd64.whl", hash = "sha256:b6123aa4a59d75f06e9dd3dac5bf8bc9aa383121bb3dd9a7a612e05eabc9961a", size = 2625725 }, + { url = "https://files.pythonhosted.org/packages/ce/1f/8d50c096a1d58ef0584ddc37e6f602828515219e9d2428e14ce50f5ecad1/pillow-11.1.0-cp310-cp310-win_arm64.whl", hash = "sha256:a76da0a31da6fcae4210aa94fd779c65c75786bc9af06289cd1c184451ef7a65", size = 2375213 }, + { url = "https://files.pythonhosted.org/packages/dd/d6/2000bfd8d5414fb70cbbe52c8332f2283ff30ed66a9cde42716c8ecbe22c/pillow-11.1.0-cp311-cp311-macosx_10_10_x86_64.whl", hash = "sha256:e06695e0326d05b06833b40b7ef477e475d0b1ba3a6d27da1bb48c23209bf457", size = 3229968 }, + { url = "https://files.pythonhosted.org/packages/d9/45/3fe487010dd9ce0a06adf9b8ff4f273cc0a44536e234b0fad3532a42c15b/pillow-11.1.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:96f82000e12f23e4f29346e42702b6ed9a2f2fea34a740dd5ffffcc8c539eb35", size = 3101806 }, + { url = "https://files.pythonhosted.org/packages/e3/72/776b3629c47d9d5f1c160113158a7a7ad177688d3a1159cd3b62ded5a33a/pillow-11.1.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a3cd561ded2cf2bbae44d4605837221b987c216cff94f49dfeed63488bb228d2", size = 4322283 }, + { url = "https://files.pythonhosted.org/packages/e4/c2/e25199e7e4e71d64eeb869f5b72c7ddec70e0a87926398785ab944d92375/pillow-11.1.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f189805c8be5ca5add39e6f899e6ce2ed824e65fb45f3c28cb2841911da19070", size = 4402945 }, + { url = "https://files.pythonhosted.org/packages/c1/ed/51d6136c9d5911f78632b1b86c45241c712c5a80ed7fa7f9120a5dff1eba/pillow-11.1.0-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:dd0052e9db3474df30433f83a71b9b23bd9e4ef1de13d92df21a52c0303b8ab6", size = 4361228 }, + { url = "https://files.pythonhosted.org/packages/48/a4/fbfe9d5581d7b111b28f1d8c2762dee92e9821bb209af9fa83c940e507a0/pillow-11.1.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:837060a8599b8f5d402e97197d4924f05a2e0d68756998345c829c33186217b1", size = 4484021 }, + { url = "https://files.pythonhosted.org/packages/39/db/0b3c1a5018117f3c1d4df671fb8e47d08937f27519e8614bbe86153b65a5/pillow-11.1.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:aa8dd43daa836b9a8128dbe7d923423e5ad86f50a7a14dc688194b7be5c0dea2", size = 4287449 }, + { url = "https://files.pythonhosted.org/packages/d9/58/bc128da7fea8c89fc85e09f773c4901e95b5936000e6f303222490c052f3/pillow-11.1.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:0a2f91f8a8b367e7a57c6e91cd25af510168091fb89ec5146003e424e1558a96", size = 4419972 }, + { url = "https://files.pythonhosted.org/packages/5f/bb/58f34379bde9fe197f51841c5bbe8830c28bbb6d3801f16a83b8f2ad37df/pillow-11.1.0-cp311-cp311-win32.whl", hash = "sha256:c12fc111ef090845de2bb15009372175d76ac99969bdf31e2ce9b42e4b8cd88f", size = 2291201 }, + { url = "https://files.pythonhosted.org/packages/3a/c6/fce9255272bcf0c39e15abd2f8fd8429a954cf344469eaceb9d0d1366913/pillow-11.1.0-cp311-cp311-win_amd64.whl", hash = "sha256:fbd43429d0d7ed6533b25fc993861b8fd512c42d04514a0dd6337fb3ccf22761", size = 2625686 }, + { url = "https://files.pythonhosted.org/packages/c8/52/8ba066d569d932365509054859f74f2a9abee273edcef5cd75e4bc3e831e/pillow-11.1.0-cp311-cp311-win_arm64.whl", hash = "sha256:f7955ecf5609dee9442cbface754f2c6e541d9e6eda87fad7f7a989b0bdb9d71", size = 2375194 }, + { url = "https://files.pythonhosted.org/packages/95/20/9ce6ed62c91c073fcaa23d216e68289e19d95fb8188b9fb7a63d36771db8/pillow-11.1.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:2062ffb1d36544d42fcaa277b069c88b01bb7298f4efa06731a7fd6cc290b81a", size = 3226818 }, + { url = "https://files.pythonhosted.org/packages/b9/d8/f6004d98579a2596c098d1e30d10b248798cceff82d2b77aa914875bfea1/pillow-11.1.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:a85b653980faad27e88b141348707ceeef8a1186f75ecc600c395dcac19f385b", size = 3101662 }, + { url = "https://files.pythonhosted.org/packages/08/d9/892e705f90051c7a2574d9f24579c9e100c828700d78a63239676f960b74/pillow-11.1.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9409c080586d1f683df3f184f20e36fb647f2e0bc3988094d4fd8c9f4eb1b3b3", size = 4329317 }, + { url = "https://files.pythonhosted.org/packages/8c/aa/7f29711f26680eab0bcd3ecdd6d23ed6bce180d82e3f6380fb7ae35fcf3b/pillow-11.1.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7fdadc077553621911f27ce206ffcbec7d3f8d7b50e0da39f10997e8e2bb7f6a", size = 4412999 }, + { url = "https://files.pythonhosted.org/packages/c8/c4/8f0fe3b9e0f7196f6d0bbb151f9fba323d72a41da068610c4c960b16632a/pillow-11.1.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:93a18841d09bcdd774dcdc308e4537e1f867b3dec059c131fde0327899734aa1", size = 4368819 }, + { url = "https://files.pythonhosted.org/packages/38/0d/84200ed6a871ce386ddc82904bfadc0c6b28b0c0ec78176871a4679e40b3/pillow-11.1.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:9aa9aeddeed452b2f616ff5507459e7bab436916ccb10961c4a382cd3e03f47f", size = 4496081 }, + { url = "https://files.pythonhosted.org/packages/84/9c/9bcd66f714d7e25b64118e3952d52841a4babc6d97b6d28e2261c52045d4/pillow-11.1.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3cdcdb0b896e981678eee140d882b70092dac83ac1cdf6b3a60e2216a73f2b91", size = 4296513 }, + { url = "https://files.pythonhosted.org/packages/db/61/ada2a226e22da011b45f7104c95ebda1b63dcbb0c378ad0f7c2a710f8fd2/pillow-11.1.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:36ba10b9cb413e7c7dfa3e189aba252deee0602c86c309799da5a74009ac7a1c", size = 4431298 }, + { url = "https://files.pythonhosted.org/packages/e7/c4/fc6e86750523f367923522014b821c11ebc5ad402e659d8c9d09b3c9d70c/pillow-11.1.0-cp312-cp312-win32.whl", hash = "sha256:cfd5cd998c2e36a862d0e27b2df63237e67273f2fc78f47445b14e73a810e7e6", size = 2291630 }, + { url = "https://files.pythonhosted.org/packages/08/5c/2104299949b9d504baf3f4d35f73dbd14ef31bbd1ddc2c1b66a5b7dfda44/pillow-11.1.0-cp312-cp312-win_amd64.whl", hash = "sha256:a697cd8ba0383bba3d2d3ada02b34ed268cb548b369943cd349007730c92bddf", size = 2626369 }, + { url = "https://files.pythonhosted.org/packages/37/f3/9b18362206b244167c958984b57c7f70a0289bfb59a530dd8af5f699b910/pillow-11.1.0-cp312-cp312-win_arm64.whl", hash = "sha256:4dd43a78897793f60766563969442020e90eb7847463eca901e41ba186a7d4a5", size = 2375240 }, + { url = "https://files.pythonhosted.org/packages/b3/31/9ca79cafdce364fd5c980cd3416c20ce1bebd235b470d262f9d24d810184/pillow-11.1.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:ae98e14432d458fc3de11a77ccb3ae65ddce70f730e7c76140653048c71bfcbc", size = 3226640 }, + { url = "https://files.pythonhosted.org/packages/ac/0f/ff07ad45a1f172a497aa393b13a9d81a32e1477ef0e869d030e3c1532521/pillow-11.1.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:cc1331b6d5a6e144aeb5e626f4375f5b7ae9934ba620c0ac6b3e43d5e683a0f0", size = 3101437 }, + { url = "https://files.pythonhosted.org/packages/08/2f/9906fca87a68d29ec4530be1f893149e0cb64a86d1f9f70a7cfcdfe8ae44/pillow-11.1.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:758e9d4ef15d3560214cddbc97b8ef3ef86ce04d62ddac17ad39ba87e89bd3b1", size = 4326605 }, + { url = "https://files.pythonhosted.org/packages/b0/0f/f3547ee15b145bc5c8b336401b2d4c9d9da67da9dcb572d7c0d4103d2c69/pillow-11.1.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b523466b1a31d0dcef7c5be1f20b942919b62fd6e9a9be199d035509cbefc0ec", size = 4411173 }, + { url = "https://files.pythonhosted.org/packages/b1/df/bf8176aa5db515c5de584c5e00df9bab0713548fd780c82a86cba2c2fedb/pillow-11.1.0-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:9044b5e4f7083f209c4e35aa5dd54b1dd5b112b108648f5c902ad586d4f945c5", size = 4369145 }, + { url = "https://files.pythonhosted.org/packages/de/7c/7433122d1cfadc740f577cb55526fdc39129a648ac65ce64db2eb7209277/pillow-11.1.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:3764d53e09cdedd91bee65c2527815d315c6b90d7b8b79759cc48d7bf5d4f114", size = 4496340 }, + { url = "https://files.pythonhosted.org/packages/25/46/dd94b93ca6bd555588835f2504bd90c00d5438fe131cf01cfa0c5131a19d/pillow-11.1.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:31eba6bbdd27dde97b0174ddf0297d7a9c3a507a8a1480e1e60ef914fe23d352", size = 4296906 }, + { url = "https://files.pythonhosted.org/packages/a8/28/2f9d32014dfc7753e586db9add35b8a41b7a3b46540e965cb6d6bc607bd2/pillow-11.1.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:b5d658fbd9f0d6eea113aea286b21d3cd4d3fd978157cbf2447a6035916506d3", size = 4431759 }, + { url = "https://files.pythonhosted.org/packages/33/48/19c2cbe7403870fbe8b7737d19eb013f46299cdfe4501573367f6396c775/pillow-11.1.0-cp313-cp313-win32.whl", hash = "sha256:f86d3a7a9af5d826744fabf4afd15b9dfef44fe69a98541f666f66fbb8d3fef9", size = 2291657 }, + { url = "https://files.pythonhosted.org/packages/3b/ad/285c556747d34c399f332ba7c1a595ba245796ef3e22eae190f5364bb62b/pillow-11.1.0-cp313-cp313-win_amd64.whl", hash = "sha256:593c5fd6be85da83656b93ffcccc2312d2d149d251e98588b14fbc288fd8909c", size = 2626304 }, + { url = "https://files.pythonhosted.org/packages/e5/7b/ef35a71163bf36db06e9c8729608f78dedf032fc8313d19bd4be5c2588f3/pillow-11.1.0-cp313-cp313-win_arm64.whl", hash = "sha256:11633d58b6ee5733bde153a8dafd25e505ea3d32e261accd388827ee987baf65", size = 2375117 }, + { url = "https://files.pythonhosted.org/packages/79/30/77f54228401e84d6791354888549b45824ab0ffde659bafa67956303a09f/pillow-11.1.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:70ca5ef3b3b1c4a0812b5c63c57c23b63e53bc38e758b37a951e5bc466449861", size = 3230060 }, + { url = "https://files.pythonhosted.org/packages/ce/b1/56723b74b07dd64c1010fee011951ea9c35a43d8020acd03111f14298225/pillow-11.1.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:8000376f139d4d38d6851eb149b321a52bb8893a88dae8ee7d95840431977081", size = 3106192 }, + { url = "https://files.pythonhosted.org/packages/e1/cd/7bf7180e08f80a4dcc6b4c3a0aa9e0b0ae57168562726a05dc8aa8fa66b0/pillow-11.1.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9ee85f0696a17dd28fbcfceb59f9510aa71934b483d1f5601d1030c3c8304f3c", size = 4446805 }, + { url = "https://files.pythonhosted.org/packages/97/42/87c856ea30c8ed97e8efbe672b58c8304dee0573f8c7cab62ae9e31db6ae/pillow-11.1.0-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:dd0e081319328928531df7a0e63621caf67652c8464303fd102141b785ef9547", size = 4530623 }, + { url = "https://files.pythonhosted.org/packages/ff/41/026879e90c84a88e33fb00cc6bd915ac2743c67e87a18f80270dfe3c2041/pillow-11.1.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:e63e4e5081de46517099dc30abe418122f54531a6ae2ebc8680bcd7096860eab", size = 4465191 }, + { url = "https://files.pythonhosted.org/packages/e5/fb/a7960e838bc5df57a2ce23183bfd2290d97c33028b96bde332a9057834d3/pillow-11.1.0-cp313-cp313t-win32.whl", hash = "sha256:dda60aa465b861324e65a78c9f5cf0f4bc713e4309f83bc387be158b077963d9", size = 2295494 }, + { url = "https://files.pythonhosted.org/packages/d7/6c/6ec83ee2f6f0fda8d4cf89045c6be4b0373ebfc363ba8538f8c999f63fcd/pillow-11.1.0-cp313-cp313t-win_amd64.whl", hash = "sha256:ad5db5781c774ab9a9b2c4302bbf0c1014960a0a7be63278d13ae6fdf88126fe", size = 2631595 }, + { url = "https://files.pythonhosted.org/packages/cf/6c/41c21c6c8af92b9fea313aa47c75de49e2f9a467964ee33eb0135d47eb64/pillow-11.1.0-cp313-cp313t-win_arm64.whl", hash = "sha256:67cd427c68926108778a9005f2a04adbd5e67c442ed21d95389fe1d595458756", size = 2377651 }, + { url = "https://files.pythonhosted.org/packages/9a/1f/9df5ac77491fddd2e36c352d16976dc11fbe6ab842f5df85fd7e31b847b9/pillow-11.1.0-cp39-cp39-macosx_10_10_x86_64.whl", hash = "sha256:bf902d7413c82a1bfa08b06a070876132a5ae6b2388e2712aab3a7cbc02205c6", size = 3229995 }, + { url = "https://files.pythonhosted.org/packages/a6/62/c7b359e924dca274173b04922ac06aa63614f7e934d132f2fe1d852509aa/pillow-11.1.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:c1eec9d950b6fe688edee07138993e54ee4ae634c51443cfb7c1e7613322718e", size = 3101890 }, + { url = "https://files.pythonhosted.org/packages/7b/63/136f21340a434de895b62bcf2c386005a8aa24066c4facd619f5e0e9f283/pillow-11.1.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8e275ee4cb11c262bd108ab2081f750db2a1c0b8c12c1897f27b160c8bd57bbc", size = 4310366 }, + { url = "https://files.pythonhosted.org/packages/f6/46/0bd0ca03d9d1164a7fa33d285ef6d1c438e963d0c8770e4c5b3737ef5abe/pillow-11.1.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4db853948ce4e718f2fc775b75c37ba2efb6aaea41a1a5fc57f0af59eee774b2", size = 4391582 }, + { url = "https://files.pythonhosted.org/packages/0c/55/f182db572b28bd833b8e806f933f782ceb2df64c40e4d8bd3d4226a46eca/pillow-11.1.0-cp39-cp39-manylinux_2_28_aarch64.whl", hash = "sha256:ab8a209b8485d3db694fa97a896d96dd6533d63c22829043fd9de627060beade", size = 4350278 }, + { url = "https://files.pythonhosted.org/packages/75/fb/e330fdbbcbc4744214b5f53b84d9d8a9f4ffbebc2e9c2ac10475386e3296/pillow-11.1.0-cp39-cp39-manylinux_2_28_x86_64.whl", hash = "sha256:54251ef02a2309b5eec99d151ebf5c9904b77976c8abdcbce7891ed22df53884", size = 4471768 }, + { url = "https://files.pythonhosted.org/packages/eb/51/20ee6c4da4448d7a67ffb720a5fcdb965115a78e211a1f58f9845ae15f86/pillow-11.1.0-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:5bb94705aea800051a743aa4874bb1397d4695fb0583ba5e425ee0328757f196", size = 4276549 }, + { url = "https://files.pythonhosted.org/packages/37/f2/a25c0bdaa6d6fd5cc3d4a6f65b5a7ea46e7af58bee00a98efe0a5af79c58/pillow-11.1.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:89dbdb3e6e9594d512780a5a1c42801879628b38e3efc7038094430844e271d8", size = 4409350 }, + { url = "https://files.pythonhosted.org/packages/12/a7/06687947604cd3e47abeea1b78b65d34ffce7feab03cfe0dd985f115dca3/pillow-11.1.0-cp39-cp39-win32.whl", hash = "sha256:e5449ca63da169a2e6068dd0e2fcc8d91f9558aba89ff6d02121ca8ab11e79e5", size = 2291271 }, + { url = "https://files.pythonhosted.org/packages/21/a6/f51d47675940b5c63b08ff0575b3518428b4acb891f88526fa4ee1edab6f/pillow-11.1.0-cp39-cp39-win_amd64.whl", hash = "sha256:3362c6ca227e65c54bf71a5f88b3d4565ff1bcbc63ae72c34b07bbb1cc59a43f", size = 2625783 }, + { url = "https://files.pythonhosted.org/packages/95/56/97750bd33e68648fa432dfadcb8ede7624bd905822d42262d34bcebdd9d7/pillow-11.1.0-cp39-cp39-win_arm64.whl", hash = "sha256:b20be51b37a75cc54c2c55def3fa2c65bb94ba859dde241cd0a4fd302de5ae0a", size = 2375193 }, + { url = "https://files.pythonhosted.org/packages/fa/c5/389961578fb677b8b3244fcd934f720ed25a148b9a5cc81c91bdf59d8588/pillow-11.1.0-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:8c730dc3a83e5ac137fbc92dfcfe1511ce3b2b5d7578315b63dbbb76f7f51d90", size = 3198345 }, + { url = "https://files.pythonhosted.org/packages/c4/fa/803c0e50ffee74d4b965229e816af55276eac1d5806712de86f9371858fd/pillow-11.1.0-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:7d33d2fae0e8b170b6a6c57400e077412240f6f5bb2a342cf1ee512a787942bb", size = 3072938 }, + { url = "https://files.pythonhosted.org/packages/dc/67/2a3a5f8012b5d8c63fe53958ba906c1b1d0482ebed5618057ef4d22f8076/pillow-11.1.0-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a8d65b38173085f24bc07f8b6c505cbb7418009fa1a1fcb111b1f4961814a442", size = 3400049 }, + { url = "https://files.pythonhosted.org/packages/e5/a0/514f0d317446c98c478d1872497eb92e7cde67003fed74f696441e647446/pillow-11.1.0-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:015c6e863faa4779251436db398ae75051469f7c903b043a48f078e437656f83", size = 3422431 }, + { url = "https://files.pythonhosted.org/packages/cd/00/20f40a935514037b7d3f87adfc87d2c538430ea625b63b3af8c3f5578e72/pillow-11.1.0-pp310-pypy310_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:d44ff19eea13ae4acdaaab0179fa68c0c6f2f45d66a4d8ec1eda7d6cecbcc15f", size = 3446208 }, + { url = "https://files.pythonhosted.org/packages/28/3c/7de681727963043e093c72e6c3348411b0185eab3263100d4490234ba2f6/pillow-11.1.0-pp310-pypy310_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:d3d8da4a631471dfaf94c10c85f5277b1f8e42ac42bade1ac67da4b4a7359b73", size = 3509746 }, + { url = "https://files.pythonhosted.org/packages/41/67/936f9814bdd74b2dfd4822f1f7725ab5d8ff4103919a1664eb4874c58b2f/pillow-11.1.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:4637b88343166249fe8aa94e7c4a62a180c4b3898283bb5d3d2fd5fe10d8e4e0", size = 2626353 }, +] + +[[package]] +name = "pkgutil-resolve-name" +version = "1.3.10" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/70/f2/f2891a9dc37398696ddd945012b90ef8d0a034f0012e3f83c3f7a70b0f79/pkgutil_resolve_name-1.3.10.tar.gz", hash = "sha256:357d6c9e6a755653cfd78893817c0853af365dd51ec97f3d358a819373bbd174", size = 5054 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c9/5c/3d4882ba113fd55bdba9326c1e4c62a15e674a2501de4869e6bd6301f87e/pkgutil_resolve_name-1.3.10-py3-none-any.whl", hash = "sha256:ca27cc078d25c5ad71a9de0a7a330146c4e014c2462d9af19c6b828280649c5e", size = 4734 }, +] + +[[package]] +name = "platformdirs" +version = "4.3.6" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version == '3.8.*'", +] +sdist = { url = "https://files.pythonhosted.org/packages/13/fc/128cc9cb8f03208bdbf93d3aa862e16d376844a14f9a0ce5cf4507372de4/platformdirs-4.3.6.tar.gz", hash = "sha256:357fb2acbc885b0419afd3ce3ed34564c13c9b95c89360cd9563f73aa5e2b907", size = 21302 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3c/a6/bc1012356d8ece4d66dd75c4b9fc6c1f6650ddd5991e421177d9f8f671be/platformdirs-4.3.6-py3-none-any.whl", hash = "sha256:73e575e1408ab8103900836b97580d5307456908a03e92031bab39e4554cc3fb", size = 18439 }, +] + +[[package]] +name = "platformdirs" +version = "4.3.7" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", + "python_full_version == '3.10.*'", + "python_full_version == '3.9.*'", +] +sdist = { url = "https://files.pythonhosted.org/packages/b6/2d/7d512a3913d60623e7eb945c6d1b4f0bddf1d0b7ada5225274c87e5b53d1/platformdirs-4.3.7.tar.gz", hash = "sha256:eb437d586b6a0986388f0d6f74aa0cde27b48d0e3d66843640bfb6bdcdb6e351", size = 21291 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/6d/45/59578566b3275b8fd9157885918fcd0c4d74162928a5310926887b856a51/platformdirs-4.3.7-py3-none-any.whl", hash = "sha256:a03875334331946f13c549dbd8f4bac7a13a50a895a0eb1e8c6a8ace80d40a94", size = 18499 }, +] + +[[package]] +name = "pluggy" +version = "1.2.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine != 'aarch64' and platform_machine != 'arm64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'aarch64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'arm64'", + "python_full_version < '3.7.1'", +] +dependencies = [ + { name = "importlib-metadata", version = "6.7.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/8a/42/8f2833655a29c4e9cb52ee8a2be04ceac61bcff4a680fb338cbd3d1e322d/pluggy-1.2.0.tar.gz", hash = "sha256:d12f0c4b579b15f5e054301bb226ee85eeeba08ffec228092f8defbaa3a4c4b3", size = 61613 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/51/32/4a79112b8b87b21450b066e102d6608907f4c885ed7b04c3fdb085d4d6ae/pluggy-1.2.0-py3-none-any.whl", hash = "sha256:c2fd55a7d7a3863cba1a013e4e2414658b1d07b6bc57b3919e0c63c9abb99849", size = 17695 }, +] + +[[package]] +name = "pluggy" +version = "1.5.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", + "python_full_version == '3.10.*'", + "python_full_version == '3.9.*'", + "python_full_version == '3.8.*'", +] +sdist = { url = "https://files.pythonhosted.org/packages/96/2d/02d4312c973c6050a18b314a5ad0b3210edb65a906f868e31c111dede4a6/pluggy-1.5.0.tar.gz", hash = "sha256:2cffa88e94fdc978c4c574f15f9e59b7f4201d439195c3715ca9e2486f1d0cf1", size = 67955 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/88/5f/e351af9a41f866ac3f1fac4ca0613908d9a41741cfcf2228f4ad853b697d/pluggy-1.5.0-py3-none-any.whl", hash = "sha256:44e1ad92c8ca002de6377e165f3e0f1be63266ab4d554740532335b9d75ea669", size = 20556 }, +] + +[[package]] +name = "plum-dispatch" +version = "1.7.4" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version == '3.9.*'", +] +sdist = { url = "https://files.pythonhosted.org/packages/39/4e/f4d6b2bd80a9880989d37773f0f2e3a91a2d5352732e4ebb68b5606bca83/plum-dispatch-1.7.4.tar.gz", hash = "sha256:1c1d15b2842b5fa98405fd3dff6fad4887bdc77b60bd200e209d76ebfe9990fe", size = 56429 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e6/b6/3aaa985591c63da64c7bd8c5f470442a4c00b37ad3ed057f21de14174f83/plum_dispatch-1.7.4-py3-none-any.whl", hash = "sha256:c40dbeab269bbbf972ce0dbc078380da19ebaee1a370a2c564e1814a11bde216", size = 24238 }, +] + +[[package]] +name = "plum-dispatch" +version = "2.5.7" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", + "python_full_version == '3.10.*'", +] +dependencies = [ + { name = "beartype", marker = "python_full_version >= '3.10'" }, + { name = "rich", marker = "python_full_version >= '3.10'" }, + { name = "typing-extensions", version = "4.12.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/f4/46/ab3928e864b0a88a8ae6987b3da3b7ae32fe0a610264f33272139275dab5/plum_dispatch-2.5.7.tar.gz", hash = "sha256:a7908ad5563b93f387e3817eb0412ad40cfbad04bc61d869cf7a76cd58a3895d", size = 35452 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2b/31/21609a9be48e877bc33b089a7f495c853215def5aeb9564a31c210d9d769/plum_dispatch-2.5.7-py3-none-any.whl", hash = "sha256:06471782eea0b3798c1e79dca2af2165bafcfa5eb595540b514ddd81053b1ede", size = 42612 }, +] + +[[package]] +name = "prompt-toolkit" +version = "3.0.48" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine != 'aarch64' and platform_machine != 'arm64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'aarch64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'arm64'", + "python_full_version < '3.7.1'", +] +dependencies = [ + { name = "wcwidth", marker = "python_full_version < '3.8'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/2d/4f/feb5e137aff82f7c7f3248267b97451da3644f6cdc218edfe549fb354127/prompt_toolkit-3.0.48.tar.gz", hash = "sha256:d6623ab0477a80df74e646bdbc93621143f5caf104206aa29294d53de1a03d90", size = 424684 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a9/6a/fd08d94654f7e67c52ca30523a178b3f8ccc4237fce4be90d39c938a831a/prompt_toolkit-3.0.48-py3-none-any.whl", hash = "sha256:f49a827f90062e411f1ce1f854f2aedb3c23353244f8108b89283587397ac10e", size = 386595 }, +] + +[[package]] +name = "prompt-toolkit" +version = "3.0.50" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", + "python_full_version == '3.10.*'", + "python_full_version == '3.9.*'", + "python_full_version == '3.8.*'", +] +dependencies = [ + { name = "wcwidth", marker = "python_full_version >= '3.8'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a1/e1/bd15cb8ffdcfeeb2bdc215de3c3cffca11408d829e4b8416dcfe71ba8854/prompt_toolkit-3.0.50.tar.gz", hash = "sha256:544748f3860a2623ca5cd6d2795e7a14f3d0e1c3c9728359013f79877fc89bab", size = 429087 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e4/ea/d836f008d33151c7a1f62caf3d8dd782e4d15f6a43897f64480c2b8de2ad/prompt_toolkit-3.0.50-py3-none-any.whl", hash = "sha256:9b6427eb19e479d98acff65196a307c555eb567989e6d88ebbb1b509d9779198", size = 387816 }, +] + +[[package]] +name = "psutil" +version = "7.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/2a/80/336820c1ad9286a4ded7e845b2eccfcb27851ab8ac6abece774a6ff4d3de/psutil-7.0.0.tar.gz", hash = "sha256:7be9c3eba38beccb6495ea33afd982a44074b78f28c434a1f51cc07fd315c456", size = 497003 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ed/e6/2d26234410f8b8abdbf891c9da62bee396583f713fb9f3325a4760875d22/psutil-7.0.0-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:101d71dc322e3cffd7cea0650b09b3d08b8e7c4109dd6809fe452dfd00e58b25", size = 238051 }, + { url = "https://files.pythonhosted.org/packages/04/8b/30f930733afe425e3cbfc0e1468a30a18942350c1a8816acfade80c005c4/psutil-7.0.0-cp36-abi3-macosx_11_0_arm64.whl", hash = "sha256:39db632f6bb862eeccf56660871433e111b6ea58f2caea825571951d4b6aa3da", size = 239535 }, + { url = "https://files.pythonhosted.org/packages/2a/ed/d362e84620dd22876b55389248e522338ed1bf134a5edd3b8231d7207f6d/psutil-7.0.0-cp36-abi3-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1fcee592b4c6f146991ca55919ea3d1f8926497a713ed7faaf8225e174581e91", size = 275004 }, + { url = "https://files.pythonhosted.org/packages/bf/b9/b0eb3f3cbcb734d930fdf839431606844a825b23eaf9a6ab371edac8162c/psutil-7.0.0-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4b1388a4f6875d7e2aff5c4ca1cc16c545ed41dd8bb596cefea80111db353a34", size = 277986 }, + { url = "https://files.pythonhosted.org/packages/eb/a2/709e0fe2f093556c17fbafda93ac032257242cabcc7ff3369e2cb76a97aa/psutil-7.0.0-cp36-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a5f098451abc2828f7dc6b58d44b532b22f2088f4999a937557b603ce72b1993", size = 279544 }, + { url = "https://files.pythonhosted.org/packages/50/e6/eecf58810b9d12e6427369784efe814a1eec0f492084ce8eb8f4d89d6d61/psutil-7.0.0-cp37-abi3-win32.whl", hash = "sha256:ba3fcef7523064a6c9da440fc4d6bd07da93ac726b5733c29027d7dc95b39d99", size = 241053 }, + { url = "https://files.pythonhosted.org/packages/50/1b/6921afe68c74868b4c9fa424dad3be35b095e16687989ebbb50ce4fceb7c/psutil-7.0.0-cp37-abi3-win_amd64.whl", hash = "sha256:4cf3d4eb1aa9b348dec30105c55cd9b7d4629285735a102beb4441e38db90553", size = 244885 }, +] + +[[package]] +name = "ptyprocess" +version = "0.7.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/20/e5/16ff212c1e452235a90aeb09066144d0c5a6a8c0834397e03f5224495c4e/ptyprocess-0.7.0.tar.gz", hash = "sha256:5c5d0a3b48ceee0b48485e0c26037c0acd7d29765ca3fbb5cb3831d347423220", size = 70762 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/22/a6/858897256d0deac81a172289110f31629fc4cee19b6f01283303e18c8db3/ptyprocess-0.7.0-py2.py3-none-any.whl", hash = "sha256:4b41f3967fce3af57cc7e94b888626c18bf37a083e3651ca8feeb66d492fef35", size = 13993 }, +] + +[[package]] +name = "pure-eval" +version = "0.2.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/cd/05/0a34433a064256a578f1783a10da6df098ceaa4a57bbeaa96a6c0352786b/pure_eval-0.2.3.tar.gz", hash = "sha256:5f4e983f40564c576c7c8635ae88db5956bb2229d7e9237d03b3c0b0190eaf42", size = 19752 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8e/37/efad0257dc6e593a18957422533ff0f87ede7c9c6ea010a2177d738fb82f/pure_eval-0.2.3-py3-none-any.whl", hash = "sha256:1db8e35b67b3d218d818ae653e27f06c3aa420901fa7b081ca98cbedc874e0d0", size = 11842 }, +] + +[[package]] +name = "pycparser" +version = "2.21" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine != 'aarch64' and platform_machine != 'arm64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'aarch64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'arm64'", + "python_full_version < '3.7.1'", +] +sdist = { url = "https://files.pythonhosted.org/packages/5e/0b/95d387f5f4433cb0f53ff7ad859bd2c6051051cebbb564f139a999ab46de/pycparser-2.21.tar.gz", hash = "sha256:e644fdec12f7872f86c58ff790da456218b10f863970249516d60a5eaca77206", size = 170877 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/62/d5/5f610ebe421e85889f2e55e33b7f9a6795bd982198517d912eb1c76e1a53/pycparser-2.21-py2.py3-none-any.whl", hash = "sha256:8ee45429555515e1f6b185e78100aea234072576aa43ab53aefcae078162fca9", size = 118697 }, +] + +[[package]] +name = "pycparser" +version = "2.22" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", + "python_full_version == '3.10.*'", + "python_full_version == '3.9.*'", + "python_full_version == '3.8.*'", +] +sdist = { url = "https://files.pythonhosted.org/packages/1d/b2/31537cf4b1ca988837256c910a668b553fceb8f069bedc4b1c826024b52c/pycparser-2.22.tar.gz", hash = "sha256:491c8be9c040f5390f5bf44a5b07752bd07f56edf992381b05c701439eec10f6", size = 172736 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/13/a3/a812df4e2dd5696d1f351d58b8fe16a405b234ad2886a0dab9183fb78109/pycparser-2.22-py3-none-any.whl", hash = "sha256:c3702b6d3dd8c7abc1afa565d7e63d53a1d0bd86cdc24edd75470f4de499cfcc", size = 117552 }, +] + +[[package]] +name = "pydantic" +version = "2.10.6" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "annotated-types", marker = "python_full_version >= '3.9'" }, + { name = "pydantic-core", marker = "python_full_version >= '3.9'" }, + { name = "typing-extensions", version = "4.12.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.9'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b7/ae/d5220c5c52b158b1de7ca89fc5edb72f304a70a4c540c84c8844bf4008de/pydantic-2.10.6.tar.gz", hash = "sha256:ca5daa827cce33de7a42be142548b0096bf05a7e7b365aebfa5f8eeec7128236", size = 761681 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f4/3c/8cc1cc84deffa6e25d2d0c688ebb80635dfdbf1dbea3e30c541c8cf4d860/pydantic-2.10.6-py3-none-any.whl", hash = "sha256:427d664bf0b8a2b34ff5dd0f5a18df00591adcee7198fbd71981054cef37b584", size = 431696 }, +] + +[[package]] +name = "pydantic-core" +version = "2.27.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions", version = "4.12.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.9'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/fc/01/f3e5ac5e7c25833db5eb555f7b7ab24cd6f8c322d3a3ad2d67a952dc0abc/pydantic_core-2.27.2.tar.gz", hash = "sha256:eb026e5a4c1fee05726072337ff51d1efb6f59090b7da90d30ea58625b1ffb39", size = 413443 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3a/bc/fed5f74b5d802cf9a03e83f60f18864e90e3aed7223adaca5ffb7a8d8d64/pydantic_core-2.27.2-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:2d367ca20b2f14095a8f4fa1210f5a7b78b8a20009ecced6b12818f455b1e9fa", size = 1895938 }, + { url = "https://files.pythonhosted.org/packages/71/2a/185aff24ce844e39abb8dd680f4e959f0006944f4a8a0ea372d9f9ae2e53/pydantic_core-2.27.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:491a2b73db93fab69731eaee494f320faa4e093dbed776be1a829c2eb222c34c", size = 1815684 }, + { url = "https://files.pythonhosted.org/packages/c3/43/fafabd3d94d159d4f1ed62e383e264f146a17dd4d48453319fd782e7979e/pydantic_core-2.27.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7969e133a6f183be60e9f6f56bfae753585680f3b7307a8e555a948d443cc05a", size = 1829169 }, + { url = "https://files.pythonhosted.org/packages/a2/d1/f2dfe1a2a637ce6800b799aa086d079998959f6f1215eb4497966efd2274/pydantic_core-2.27.2-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:3de9961f2a346257caf0aa508a4da705467f53778e9ef6fe744c038119737ef5", size = 1867227 }, + { url = "https://files.pythonhosted.org/packages/7d/39/e06fcbcc1c785daa3160ccf6c1c38fea31f5754b756e34b65f74e99780b5/pydantic_core-2.27.2-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e2bb4d3e5873c37bb3dd58714d4cd0b0e6238cebc4177ac8fe878f8b3aa8e74c", size = 2037695 }, + { url = "https://files.pythonhosted.org/packages/7a/67/61291ee98e07f0650eb756d44998214231f50751ba7e13f4f325d95249ab/pydantic_core-2.27.2-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:280d219beebb0752699480fe8f1dc61ab6615c2046d76b7ab7ee38858de0a4e7", size = 2741662 }, + { url = "https://files.pythonhosted.org/packages/32/90/3b15e31b88ca39e9e626630b4c4a1f5a0dfd09076366f4219429e6786076/pydantic_core-2.27.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:47956ae78b6422cbd46f772f1746799cbb862de838fd8d1fbd34a82e05b0983a", size = 1993370 }, + { url = "https://files.pythonhosted.org/packages/ff/83/c06d333ee3a67e2e13e07794995c1535565132940715931c1c43bfc85b11/pydantic_core-2.27.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:14d4a5c49d2f009d62a2a7140d3064f686d17a5d1a268bc641954ba181880236", size = 1996813 }, + { url = "https://files.pythonhosted.org/packages/7c/f7/89be1c8deb6e22618a74f0ca0d933fdcb8baa254753b26b25ad3acff8f74/pydantic_core-2.27.2-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:337b443af21d488716f8d0b6164de833e788aa6bd7e3a39c005febc1284f4962", size = 2005287 }, + { url = "https://files.pythonhosted.org/packages/b7/7d/8eb3e23206c00ef7feee17b83a4ffa0a623eb1a9d382e56e4aa46fd15ff2/pydantic_core-2.27.2-cp310-cp310-musllinux_1_1_armv7l.whl", hash = "sha256:03d0f86ea3184a12f41a2d23f7ccb79cdb5a18e06993f8a45baa8dfec746f0e9", size = 2128414 }, + { url = "https://files.pythonhosted.org/packages/4e/99/fe80f3ff8dd71a3ea15763878d464476e6cb0a2db95ff1c5c554133b6b83/pydantic_core-2.27.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:7041c36f5680c6e0f08d922aed302e98b3745d97fe1589db0a3eebf6624523af", size = 2155301 }, + { url = "https://files.pythonhosted.org/packages/2b/a3/e50460b9a5789ca1451b70d4f52546fa9e2b420ba3bfa6100105c0559238/pydantic_core-2.27.2-cp310-cp310-win32.whl", hash = "sha256:50a68f3e3819077be2c98110c1f9dcb3817e93f267ba80a2c05bb4f8799e2ff4", size = 1816685 }, + { url = "https://files.pythonhosted.org/packages/57/4c/a8838731cb0f2c2a39d3535376466de6049034d7b239c0202a64aaa05533/pydantic_core-2.27.2-cp310-cp310-win_amd64.whl", hash = "sha256:e0fd26b16394ead34a424eecf8a31a1f5137094cabe84a1bcb10fa6ba39d3d31", size = 1982876 }, + { url = "https://files.pythonhosted.org/packages/c2/89/f3450af9d09d44eea1f2c369f49e8f181d742f28220f88cc4dfaae91ea6e/pydantic_core-2.27.2-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:8e10c99ef58cfdf2a66fc15d66b16c4a04f62bca39db589ae8cba08bc55331bc", size = 1893421 }, + { url = "https://files.pythonhosted.org/packages/9e/e3/71fe85af2021f3f386da42d291412e5baf6ce7716bd7101ea49c810eda90/pydantic_core-2.27.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:26f32e0adf166a84d0cb63be85c562ca8a6fa8de28e5f0d92250c6b7e9e2aff7", size = 1814998 }, + { url = "https://files.pythonhosted.org/packages/a6/3c/724039e0d848fd69dbf5806894e26479577316c6f0f112bacaf67aa889ac/pydantic_core-2.27.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8c19d1ea0673cd13cc2f872f6c9ab42acc4e4f492a7ca9d3795ce2b112dd7e15", size = 1826167 }, + { url = "https://files.pythonhosted.org/packages/2b/5b/1b29e8c1fb5f3199a9a57c1452004ff39f494bbe9bdbe9a81e18172e40d3/pydantic_core-2.27.2-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:5e68c4446fe0810e959cdff46ab0a41ce2f2c86d227d96dc3847af0ba7def306", size = 1865071 }, + { url = "https://files.pythonhosted.org/packages/89/6c/3985203863d76bb7d7266e36970d7e3b6385148c18a68cc8915fd8c84d57/pydantic_core-2.27.2-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d9640b0059ff4f14d1f37321b94061c6db164fbe49b334b31643e0528d100d99", size = 2036244 }, + { url = "https://files.pythonhosted.org/packages/0e/41/f15316858a246b5d723f7d7f599f79e37493b2e84bfc789e58d88c209f8a/pydantic_core-2.27.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:40d02e7d45c9f8af700f3452f329ead92da4c5f4317ca9b896de7ce7199ea459", size = 2737470 }, + { url = "https://files.pythonhosted.org/packages/a8/7c/b860618c25678bbd6d1d99dbdfdf0510ccb50790099b963ff78a124b754f/pydantic_core-2.27.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1c1fd185014191700554795c99b347d64f2bb637966c4cfc16998a0ca700d048", size = 1992291 }, + { url = "https://files.pythonhosted.org/packages/bf/73/42c3742a391eccbeab39f15213ecda3104ae8682ba3c0c28069fbcb8c10d/pydantic_core-2.27.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d81d2068e1c1228a565af076598f9e7451712700b673de8f502f0334f281387d", size = 1994613 }, + { url = "https://files.pythonhosted.org/packages/94/7a/941e89096d1175d56f59340f3a8ebaf20762fef222c298ea96d36a6328c5/pydantic_core-2.27.2-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:1a4207639fb02ec2dbb76227d7c751a20b1a6b4bc52850568e52260cae64ca3b", size = 2002355 }, + { url = "https://files.pythonhosted.org/packages/6e/95/2359937a73d49e336a5a19848713555605d4d8d6940c3ec6c6c0ca4dcf25/pydantic_core-2.27.2-cp311-cp311-musllinux_1_1_armv7l.whl", hash = "sha256:3de3ce3c9ddc8bbd88f6e0e304dea0e66d843ec9de1b0042b0911c1663ffd474", size = 2126661 }, + { url = "https://files.pythonhosted.org/packages/2b/4c/ca02b7bdb6012a1adef21a50625b14f43ed4d11f1fc237f9d7490aa5078c/pydantic_core-2.27.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:30c5f68ded0c36466acede341551106821043e9afaad516adfb6e8fa80a4e6a6", size = 2153261 }, + { url = "https://files.pythonhosted.org/packages/72/9d/a241db83f973049a1092a079272ffe2e3e82e98561ef6214ab53fe53b1c7/pydantic_core-2.27.2-cp311-cp311-win32.whl", hash = "sha256:c70c26d2c99f78b125a3459f8afe1aed4d9687c24fd677c6a4436bc042e50d6c", size = 1812361 }, + { url = "https://files.pythonhosted.org/packages/e8/ef/013f07248041b74abd48a385e2110aa3a9bbfef0fbd97d4e6d07d2f5b89a/pydantic_core-2.27.2-cp311-cp311-win_amd64.whl", hash = "sha256:08e125dbdc505fa69ca7d9c499639ab6407cfa909214d500897d02afb816e7cc", size = 1982484 }, + { url = "https://files.pythonhosted.org/packages/10/1c/16b3a3e3398fd29dca77cea0a1d998d6bde3902fa2706985191e2313cc76/pydantic_core-2.27.2-cp311-cp311-win_arm64.whl", hash = "sha256:26f0d68d4b235a2bae0c3fc585c585b4ecc51382db0e3ba402a22cbc440915e4", size = 1867102 }, + { url = "https://files.pythonhosted.org/packages/d6/74/51c8a5482ca447871c93e142d9d4a92ead74de6c8dc5e66733e22c9bba89/pydantic_core-2.27.2-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:9e0c8cfefa0ef83b4da9588448b6d8d2a2bf1a53c3f1ae5fca39eb3061e2f0b0", size = 1893127 }, + { url = "https://files.pythonhosted.org/packages/d3/f3/c97e80721735868313c58b89d2de85fa80fe8dfeeed84dc51598b92a135e/pydantic_core-2.27.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:83097677b8e3bd7eaa6775720ec8e0405f1575015a463285a92bfdfe254529ef", size = 1811340 }, + { url = "https://files.pythonhosted.org/packages/9e/91/840ec1375e686dbae1bd80a9e46c26a1e0083e1186abc610efa3d9a36180/pydantic_core-2.27.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:172fce187655fece0c90d90a678424b013f8fbb0ca8b036ac266749c09438cb7", size = 1822900 }, + { url = "https://files.pythonhosted.org/packages/f6/31/4240bc96025035500c18adc149aa6ffdf1a0062a4b525c932065ceb4d868/pydantic_core-2.27.2-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:519f29f5213271eeeeb3093f662ba2fd512b91c5f188f3bb7b27bc5973816934", size = 1869177 }, + { url = "https://files.pythonhosted.org/packages/fa/20/02fbaadb7808be578317015c462655c317a77a7c8f0ef274bc016a784c54/pydantic_core-2.27.2-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:05e3a55d124407fffba0dd6b0c0cd056d10e983ceb4e5dbd10dda135c31071d6", size = 2038046 }, + { url = "https://files.pythonhosted.org/packages/06/86/7f306b904e6c9eccf0668248b3f272090e49c275bc488a7b88b0823444a4/pydantic_core-2.27.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9c3ed807c7b91de05e63930188f19e921d1fe90de6b4f5cd43ee7fcc3525cb8c", size = 2685386 }, + { url = "https://files.pythonhosted.org/packages/8d/f0/49129b27c43396581a635d8710dae54a791b17dfc50c70164866bbf865e3/pydantic_core-2.27.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6fb4aadc0b9a0c063206846d603b92030eb6f03069151a625667f982887153e2", size = 1997060 }, + { url = "https://files.pythonhosted.org/packages/0d/0f/943b4af7cd416c477fd40b187036c4f89b416a33d3cc0ab7b82708a667aa/pydantic_core-2.27.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:28ccb213807e037460326424ceb8b5245acb88f32f3d2777427476e1b32c48c4", size = 2004870 }, + { url = "https://files.pythonhosted.org/packages/35/40/aea70b5b1a63911c53a4c8117c0a828d6790483f858041f47bab0b779f44/pydantic_core-2.27.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:de3cd1899e2c279b140adde9357c4495ed9d47131b4a4eaff9052f23398076b3", size = 1999822 }, + { url = "https://files.pythonhosted.org/packages/f2/b3/807b94fd337d58effc5498fd1a7a4d9d59af4133e83e32ae39a96fddec9d/pydantic_core-2.27.2-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:220f892729375e2d736b97d0e51466252ad84c51857d4d15f5e9692f9ef12be4", size = 2130364 }, + { url = "https://files.pythonhosted.org/packages/fc/df/791c827cd4ee6efd59248dca9369fb35e80a9484462c33c6649a8d02b565/pydantic_core-2.27.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:a0fcd29cd6b4e74fe8ddd2c90330fd8edf2e30cb52acda47f06dd615ae72da57", size = 2158303 }, + { url = "https://files.pythonhosted.org/packages/9b/67/4e197c300976af185b7cef4c02203e175fb127e414125916bf1128b639a9/pydantic_core-2.27.2-cp312-cp312-win32.whl", hash = "sha256:1e2cb691ed9834cd6a8be61228471d0a503731abfb42f82458ff27be7b2186fc", size = 1834064 }, + { url = "https://files.pythonhosted.org/packages/1f/ea/cd7209a889163b8dcca139fe32b9687dd05249161a3edda62860430457a5/pydantic_core-2.27.2-cp312-cp312-win_amd64.whl", hash = "sha256:cc3f1a99a4f4f9dd1de4fe0312c114e740b5ddead65bb4102884b384c15d8bc9", size = 1989046 }, + { url = "https://files.pythonhosted.org/packages/bc/49/c54baab2f4658c26ac633d798dab66b4c3a9bbf47cff5284e9c182f4137a/pydantic_core-2.27.2-cp312-cp312-win_arm64.whl", hash = "sha256:3911ac9284cd8a1792d3cb26a2da18f3ca26c6908cc434a18f730dc0db7bfa3b", size = 1885092 }, + { url = "https://files.pythonhosted.org/packages/41/b1/9bc383f48f8002f99104e3acff6cba1231b29ef76cfa45d1506a5cad1f84/pydantic_core-2.27.2-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:7d14bd329640e63852364c306f4d23eb744e0f8193148d4044dd3dacdaacbd8b", size = 1892709 }, + { url = "https://files.pythonhosted.org/packages/10/6c/e62b8657b834f3eb2961b49ec8e301eb99946245e70bf42c8817350cbefc/pydantic_core-2.27.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:82f91663004eb8ed30ff478d77c4d1179b3563df6cdb15c0817cd1cdaf34d154", size = 1811273 }, + { url = "https://files.pythonhosted.org/packages/ba/15/52cfe49c8c986e081b863b102d6b859d9defc63446b642ccbbb3742bf371/pydantic_core-2.27.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:71b24c7d61131bb83df10cc7e687433609963a944ccf45190cfc21e0887b08c9", size = 1823027 }, + { url = "https://files.pythonhosted.org/packages/b1/1c/b6f402cfc18ec0024120602bdbcebc7bdd5b856528c013bd4d13865ca473/pydantic_core-2.27.2-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:fa8e459d4954f608fa26116118bb67f56b93b209c39b008277ace29937453dc9", size = 1868888 }, + { url = "https://files.pythonhosted.org/packages/bd/7b/8cb75b66ac37bc2975a3b7de99f3c6f355fcc4d89820b61dffa8f1e81677/pydantic_core-2.27.2-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ce8918cbebc8da707ba805b7fd0b382816858728ae7fe19a942080c24e5b7cd1", size = 2037738 }, + { url = "https://files.pythonhosted.org/packages/c8/f1/786d8fe78970a06f61df22cba58e365ce304bf9b9f46cc71c8c424e0c334/pydantic_core-2.27.2-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:eda3f5c2a021bbc5d976107bb302e0131351c2ba54343f8a496dc8783d3d3a6a", size = 2685138 }, + { url = "https://files.pythonhosted.org/packages/a6/74/d12b2cd841d8724dc8ffb13fc5cef86566a53ed358103150209ecd5d1999/pydantic_core-2.27.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bd8086fa684c4775c27f03f062cbb9eaa6e17f064307e86b21b9e0abc9c0f02e", size = 1997025 }, + { url = "https://files.pythonhosted.org/packages/a0/6e/940bcd631bc4d9a06c9539b51f070b66e8f370ed0933f392db6ff350d873/pydantic_core-2.27.2-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:8d9b3388db186ba0c099a6d20f0604a44eabdeef1777ddd94786cdae158729e4", size = 2004633 }, + { url = "https://files.pythonhosted.org/packages/50/cc/a46b34f1708d82498c227d5d80ce615b2dd502ddcfd8376fc14a36655af1/pydantic_core-2.27.2-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:7a66efda2387de898c8f38c0cf7f14fca0b51a8ef0b24bfea5849f1b3c95af27", size = 1999404 }, + { url = "https://files.pythonhosted.org/packages/ca/2d/c365cfa930ed23bc58c41463bae347d1005537dc8db79e998af8ba28d35e/pydantic_core-2.27.2-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:18a101c168e4e092ab40dbc2503bdc0f62010e95d292b27827871dc85450d7ee", size = 2130130 }, + { url = "https://files.pythonhosted.org/packages/f4/d7/eb64d015c350b7cdb371145b54d96c919d4db516817f31cd1c650cae3b21/pydantic_core-2.27.2-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:ba5dd002f88b78a4215ed2f8ddbdf85e8513382820ba15ad5ad8955ce0ca19a1", size = 2157946 }, + { url = "https://files.pythonhosted.org/packages/a4/99/bddde3ddde76c03b65dfd5a66ab436c4e58ffc42927d4ff1198ffbf96f5f/pydantic_core-2.27.2-cp313-cp313-win32.whl", hash = "sha256:1ebaf1d0481914d004a573394f4be3a7616334be70261007e47c2a6fe7e50130", size = 1834387 }, + { url = "https://files.pythonhosted.org/packages/71/47/82b5e846e01b26ac6f1893d3c5f9f3a2eb6ba79be26eef0b759b4fe72946/pydantic_core-2.27.2-cp313-cp313-win_amd64.whl", hash = "sha256:953101387ecf2f5652883208769a79e48db18c6df442568a0b5ccd8c2723abee", size = 1990453 }, + { url = "https://files.pythonhosted.org/packages/51/b2/b2b50d5ecf21acf870190ae5d093602d95f66c9c31f9d5de6062eb329ad1/pydantic_core-2.27.2-cp313-cp313-win_arm64.whl", hash = "sha256:ac4dbfd1691affb8f48c2c13241a2e3b60ff23247cbcf981759c768b6633cf8b", size = 1885186 }, + { url = "https://files.pythonhosted.org/packages/43/53/13e9917fc69c0a4aea06fd63ed6a8d6cda9cf140ca9584d49c1650b0ef5e/pydantic_core-2.27.2-cp38-cp38-macosx_10_12_x86_64.whl", hash = "sha256:d3e8d504bdd3f10835468f29008d72fc8359d95c9c415ce6e767203db6127506", size = 1899595 }, + { url = "https://files.pythonhosted.org/packages/f4/20/26c549249769ed84877f862f7bb93f89a6ee08b4bee1ed8781616b7fbb5e/pydantic_core-2.27.2-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:521eb9b7f036c9b6187f0b47318ab0d7ca14bd87f776240b90b21c1f4f149320", size = 1775010 }, + { url = "https://files.pythonhosted.org/packages/35/eb/8234e05452d92d2b102ffa1b56d801c3567e628fdc63f02080fdfc68fd5e/pydantic_core-2.27.2-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:85210c4d99a0114f5a9481b44560d7d1e35e32cc5634c656bc48e590b669b145", size = 1830727 }, + { url = "https://files.pythonhosted.org/packages/8f/df/59f915c8b929d5f61e5a46accf748a87110ba145156f9326d1a7d28912b2/pydantic_core-2.27.2-cp38-cp38-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:d716e2e30c6f140d7560ef1538953a5cd1a87264c737643d481f2779fc247fe1", size = 1868393 }, + { url = "https://files.pythonhosted.org/packages/d5/52/81cf4071dca654d485c277c581db368b0c95b2b883f4d7b736ab54f72ddf/pydantic_core-2.27.2-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f66d89ba397d92f840f8654756196d93804278457b5fbede59598a1f9f90b228", size = 2040300 }, + { url = "https://files.pythonhosted.org/packages/9c/00/05197ce1614f5c08d7a06e1d39d5d8e704dc81971b2719af134b844e2eaf/pydantic_core-2.27.2-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:669e193c1c576a58f132e3158f9dfa9662969edb1a250c54d8fa52590045f046", size = 2738785 }, + { url = "https://files.pythonhosted.org/packages/f7/a3/5f19bc495793546825ab160e530330c2afcee2281c02b5ffafd0b32ac05e/pydantic_core-2.27.2-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9fdbe7629b996647b99c01b37f11170a57ae675375b14b8c13b8518b8320ced5", size = 1996493 }, + { url = "https://files.pythonhosted.org/packages/ed/e8/e0102c2ec153dc3eed88aea03990e1b06cfbca532916b8a48173245afe60/pydantic_core-2.27.2-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d262606bf386a5ba0b0af3b97f37c83d7011439e3dc1a9298f21efb292e42f1a", size = 1998544 }, + { url = "https://files.pythonhosted.org/packages/fb/a3/4be70845b555bd80aaee9f9812a7cf3df81550bce6dadb3cfee9c5d8421d/pydantic_core-2.27.2-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:cabb9bcb7e0d97f74df8646f34fc76fbf793b7f6dc2438517d7a9e50eee4f14d", size = 2007449 }, + { url = "https://files.pythonhosted.org/packages/e3/9f/b779ed2480ba355c054e6d7ea77792467631d674b13d8257085a4bc7dcda/pydantic_core-2.27.2-cp38-cp38-musllinux_1_1_armv7l.whl", hash = "sha256:d2d63f1215638d28221f664596b1ccb3944f6e25dd18cd3b86b0a4c408d5ebb9", size = 2129460 }, + { url = "https://files.pythonhosted.org/packages/a0/f0/a6ab0681f6e95260c7fbf552874af7302f2ea37b459f9b7f00698f875492/pydantic_core-2.27.2-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:bca101c00bff0adb45a833f8451b9105d9df18accb8743b08107d7ada14bd7da", size = 2159609 }, + { url = "https://files.pythonhosted.org/packages/8a/2b/e1059506795104349712fbca647b18b3f4a7fd541c099e6259717441e1e0/pydantic_core-2.27.2-cp38-cp38-win32.whl", hash = "sha256:f6f8e111843bbb0dee4cb6594cdc73e79b3329b526037ec242a3e49012495b3b", size = 1819886 }, + { url = "https://files.pythonhosted.org/packages/aa/6d/df49c17f024dfc58db0bacc7b03610058018dd2ea2eaf748ccbada4c3d06/pydantic_core-2.27.2-cp38-cp38-win_amd64.whl", hash = "sha256:fd1aea04935a508f62e0d0ef1f5ae968774a32afc306fb8545e06f5ff5cdf3ad", size = 1980773 }, + { url = "https://files.pythonhosted.org/packages/27/97/3aef1ddb65c5ccd6eda9050036c956ff6ecbfe66cb7eb40f280f121a5bb0/pydantic_core-2.27.2-cp39-cp39-macosx_10_12_x86_64.whl", hash = "sha256:c10eb4f1659290b523af58fa7cffb452a61ad6ae5613404519aee4bfbf1df993", size = 1896475 }, + { url = "https://files.pythonhosted.org/packages/ad/d3/5668da70e373c9904ed2f372cb52c0b996426f302e0dee2e65634c92007d/pydantic_core-2.27.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:ef592d4bad47296fb11f96cd7dc898b92e795032b4894dfb4076cfccd43a9308", size = 1772279 }, + { url = "https://files.pythonhosted.org/packages/8a/9e/e44b8cb0edf04a2f0a1f6425a65ee089c1d6f9c4c2dcab0209127b6fdfc2/pydantic_core-2.27.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c61709a844acc6bf0b7dce7daae75195a10aac96a596ea1b776996414791ede4", size = 1829112 }, + { url = "https://files.pythonhosted.org/packages/1c/90/1160d7ac700102effe11616e8119e268770f2a2aa5afb935f3ee6832987d/pydantic_core-2.27.2-cp39-cp39-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:42c5f762659e47fdb7b16956c71598292f60a03aa92f8b6351504359dbdba6cf", size = 1866780 }, + { url = "https://files.pythonhosted.org/packages/ee/33/13983426df09a36d22c15980008f8d9c77674fc319351813b5a2739b70f3/pydantic_core-2.27.2-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4c9775e339e42e79ec99c441d9730fccf07414af63eac2f0e48e08fd38a64d76", size = 2037943 }, + { url = "https://files.pythonhosted.org/packages/01/d7/ced164e376f6747e9158c89988c293cd524ab8d215ae4e185e9929655d5c/pydantic_core-2.27.2-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:57762139821c31847cfb2df63c12f725788bd9f04bc2fb392790959b8f70f118", size = 2740492 }, + { url = "https://files.pythonhosted.org/packages/8b/1f/3dc6e769d5b7461040778816aab2b00422427bcaa4b56cc89e9c653b2605/pydantic_core-2.27.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0d1e85068e818c73e048fe28cfc769040bb1f475524f4745a5dc621f75ac7630", size = 1995714 }, + { url = "https://files.pythonhosted.org/packages/07/d7/a0bd09bc39283530b3f7c27033a814ef254ba3bd0b5cfd040b7abf1fe5da/pydantic_core-2.27.2-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:097830ed52fd9e427942ff3b9bc17fab52913b2f50f2880dc4a5611446606a54", size = 1997163 }, + { url = "https://files.pythonhosted.org/packages/2d/bb/2db4ad1762e1c5699d9b857eeb41959191980de6feb054e70f93085e1bcd/pydantic_core-2.27.2-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:044a50963a614ecfae59bb1eaf7ea7efc4bc62f49ed594e18fa1e5d953c40e9f", size = 2005217 }, + { url = "https://files.pythonhosted.org/packages/53/5f/23a5a3e7b8403f8dd8fc8a6f8b49f6b55c7d715b77dcf1f8ae919eeb5628/pydantic_core-2.27.2-cp39-cp39-musllinux_1_1_armv7l.whl", hash = "sha256:4e0b4220ba5b40d727c7f879eac379b822eee5d8fff418e9d3381ee45b3b0362", size = 2127899 }, + { url = "https://files.pythonhosted.org/packages/c2/ae/aa38bb8dd3d89c2f1d8362dd890ee8f3b967330821d03bbe08fa01ce3766/pydantic_core-2.27.2-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:5e4f4bb20d75e9325cc9696c6802657b58bc1dbbe3022f32cc2b2b632c3fbb96", size = 2155726 }, + { url = "https://files.pythonhosted.org/packages/98/61/4f784608cc9e98f70839187117ce840480f768fed5d386f924074bf6213c/pydantic_core-2.27.2-cp39-cp39-win32.whl", hash = "sha256:cca63613e90d001b9f2f9a9ceb276c308bfa2a43fafb75c8031c4f66039e8c6e", size = 1817219 }, + { url = "https://files.pythonhosted.org/packages/57/82/bb16a68e4a1a858bb3768c2c8f1ff8d8978014e16598f001ea29a25bf1d1/pydantic_core-2.27.2-cp39-cp39-win_amd64.whl", hash = "sha256:77d1bca19b0f7021b3a982e6f903dcd5b2b06076def36a652e3907f596e29f67", size = 1985382 }, + { url = "https://files.pythonhosted.org/packages/46/72/af70981a341500419e67d5cb45abe552a7c74b66326ac8877588488da1ac/pydantic_core-2.27.2-pp310-pypy310_pp73-macosx_10_12_x86_64.whl", hash = "sha256:2bf14caea37e91198329b828eae1618c068dfb8ef17bb33287a7ad4b61ac314e", size = 1891159 }, + { url = "https://files.pythonhosted.org/packages/ad/3d/c5913cccdef93e0a6a95c2d057d2c2cba347815c845cda79ddd3c0f5e17d/pydantic_core-2.27.2-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:b0cb791f5b45307caae8810c2023a184c74605ec3bcbb67d13846c28ff731ff8", size = 1768331 }, + { url = "https://files.pythonhosted.org/packages/f6/f0/a3ae8fbee269e4934f14e2e0e00928f9346c5943174f2811193113e58252/pydantic_core-2.27.2-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:688d3fd9fcb71f41c4c015c023d12a79d1c4c0732ec9eb35d96e3388a120dcf3", size = 1822467 }, + { url = "https://files.pythonhosted.org/packages/d7/7a/7bbf241a04e9f9ea24cd5874354a83526d639b02674648af3f350554276c/pydantic_core-2.27.2-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3d591580c34f4d731592f0e9fe40f9cc1b430d297eecc70b962e93c5c668f15f", size = 1979797 }, + { url = "https://files.pythonhosted.org/packages/4f/5f/4784c6107731f89e0005a92ecb8a2efeafdb55eb992b8e9d0a2be5199335/pydantic_core-2.27.2-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:82f986faf4e644ffc189a7f1aafc86e46ef70372bb153e7001e8afccc6e54133", size = 1987839 }, + { url = "https://files.pythonhosted.org/packages/6d/a7/61246562b651dff00de86a5f01b6e4befb518df314c54dec187a78d81c84/pydantic_core-2.27.2-pp310-pypy310_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:bec317a27290e2537f922639cafd54990551725fc844249e64c523301d0822fc", size = 1998861 }, + { url = "https://files.pythonhosted.org/packages/86/aa/837821ecf0c022bbb74ca132e117c358321e72e7f9702d1b6a03758545e2/pydantic_core-2.27.2-pp310-pypy310_pp73-musllinux_1_1_armv7l.whl", hash = "sha256:0296abcb83a797db256b773f45773da397da75a08f5fcaef41f2044adec05f50", size = 2116582 }, + { url = "https://files.pythonhosted.org/packages/81/b0/5e74656e95623cbaa0a6278d16cf15e10a51f6002e3ec126541e95c29ea3/pydantic_core-2.27.2-pp310-pypy310_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:0d75070718e369e452075a6017fbf187f788e17ed67a3abd47fa934d001863d9", size = 2151985 }, + { url = "https://files.pythonhosted.org/packages/63/37/3e32eeb2a451fddaa3898e2163746b0cffbbdbb4740d38372db0490d67f3/pydantic_core-2.27.2-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:7e17b560be3c98a8e3aa66ce828bdebb9e9ac6ad5466fba92eb74c4c95cb1151", size = 2004715 }, + { url = "https://files.pythonhosted.org/packages/29/0e/dcaea00c9dbd0348b723cae82b0e0c122e0fa2b43fa933e1622fd237a3ee/pydantic_core-2.27.2-pp39-pypy39_pp73-macosx_10_12_x86_64.whl", hash = "sha256:c33939a82924da9ed65dab5a65d427205a73181d8098e79b6b426bdf8ad4e656", size = 1891733 }, + { url = "https://files.pythonhosted.org/packages/86/d3/e797bba8860ce650272bda6383a9d8cad1d1c9a75a640c9d0e848076f85e/pydantic_core-2.27.2-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:00bad2484fa6bda1e216e7345a798bd37c68fb2d97558edd584942aa41b7d278", size = 1768375 }, + { url = "https://files.pythonhosted.org/packages/41/f7/f847b15fb14978ca2b30262548f5fc4872b2724e90f116393eb69008299d/pydantic_core-2.27.2-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c817e2b40aba42bac6f457498dacabc568c3b7a986fc9ba7c8d9d260b71485fb", size = 1822307 }, + { url = "https://files.pythonhosted.org/packages/9c/63/ed80ec8255b587b2f108e514dc03eed1546cd00f0af281e699797f373f38/pydantic_core-2.27.2-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:251136cdad0cb722e93732cb45ca5299fb56e1344a833640bf93b2803f8d1bfd", size = 1979971 }, + { url = "https://files.pythonhosted.org/packages/a9/6d/6d18308a45454a0de0e975d70171cadaf454bc7a0bf86b9c7688e313f0bb/pydantic_core-2.27.2-pp39-pypy39_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d2088237af596f0a524d3afc39ab3b036e8adb054ee57cbb1dcf8e09da5b29cc", size = 1987616 }, + { url = "https://files.pythonhosted.org/packages/82/8a/05f8780f2c1081b800a7ca54c1971e291c2d07d1a50fb23c7e4aef4ed403/pydantic_core-2.27.2-pp39-pypy39_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:d4041c0b966a84b4ae7a09832eb691a35aec90910cd2dbe7a208de59be77965b", size = 1998943 }, + { url = "https://files.pythonhosted.org/packages/5e/3e/fe5b6613d9e4c0038434396b46c5303f5ade871166900b357ada4766c5b7/pydantic_core-2.27.2-pp39-pypy39_pp73-musllinux_1_1_armv7l.whl", hash = "sha256:8083d4e875ebe0b864ffef72a4304827015cff328a1be6e22cc850753bfb122b", size = 2116654 }, + { url = "https://files.pythonhosted.org/packages/db/ad/28869f58938fad8cc84739c4e592989730bfb69b7c90a8fff138dff18e1e/pydantic_core-2.27.2-pp39-pypy39_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:f141ee28a0ad2123b6611b6ceff018039df17f32ada8b534e6aa039545a3efb2", size = 2152292 }, + { url = "https://files.pythonhosted.org/packages/a1/0c/c5c5cd3689c32ed1fe8c5d234b079c12c281c051759770c05b8bed6412b5/pydantic_core-2.27.2-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:7d0c8399fcc1848491f00e0314bd59fb34a9c008761bcb422a057670c3f65e35", size = 2004961 }, +] + +[[package]] +name = "pygments" +version = "2.17.2" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine != 'aarch64' and platform_machine != 'arm64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'aarch64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'arm64'", + "python_full_version < '3.7.1'", +] +sdist = { url = "https://files.pythonhosted.org/packages/55/59/8bccf4157baf25e4aa5a0bb7fa3ba8600907de105ebc22b0c78cfbf6f565/pygments-2.17.2.tar.gz", hash = "sha256:da46cec9fd2de5be3a8a784f434e4c4ab670b4ff54d605c4c2717e9d49c4c367", size = 4827772 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/97/9c/372fef8377a6e340b1704768d20daaded98bf13282b5327beb2e2fe2c7ef/pygments-2.17.2-py3-none-any.whl", hash = "sha256:b27c2826c47d0f3219f29554824c30c5e8945175d888647acd804ddd04af846c", size = 1179756 }, +] + +[[package]] +name = "pygments" +version = "2.19.1" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", + "python_full_version == '3.10.*'", + "python_full_version == '3.9.*'", + "python_full_version == '3.8.*'", +] +sdist = { url = "https://files.pythonhosted.org/packages/7c/2d/c3338d48ea6cc0feb8446d8e6937e1408088a72a39937982cc6111d17f84/pygments-2.19.1.tar.gz", hash = "sha256:61c16d2a8576dc0649d9f39e089b5f02bcd27fba10d8fb4dcc28173f7a45151f", size = 4968581 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8a/0b/9fcc47d19c48b59121088dd6da2488a49d5f72dacf8262e2790a1d2c7d15/pygments-2.19.1-py3-none-any.whl", hash = "sha256:9ea1544ad55cecf4b8242fab6dd35a93bbce657034b0611ee383099054ab6d8c", size = 1225293 }, +] + +[[package]] +name = "pyparsing" +version = "3.1.4" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version == '3.8.*'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine != 'aarch64' and platform_machine != 'arm64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'aarch64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'arm64'", + "python_full_version < '3.7.1'", +] +sdist = { url = "https://files.pythonhosted.org/packages/83/08/13f3bce01b2061f2bbd582c9df82723de943784cf719a35ac886c652043a/pyparsing-3.1.4.tar.gz", hash = "sha256:f86ec8d1a83f11977c9a6ea7598e8c27fc5cddfa5b07ea2241edbbde1d7bc032", size = 900231 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e5/0c/0e3c05b1c87bb6a1c76d281b0f35e78d2d80ac91b5f8f524cebf77f51049/pyparsing-3.1.4-py3-none-any.whl", hash = "sha256:a6a7ee4235a3f944aa1fa2249307708f893fe5717dc603503c6c7969c070fb7c", size = 104100 }, +] + +[[package]] +name = "pyparsing" +version = "3.2.1" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", + "python_full_version == '3.10.*'", + "python_full_version == '3.9.*'", +] +sdist = { url = "https://files.pythonhosted.org/packages/8b/1a/3544f4f299a47911c2ab3710f534e52fea62a633c96806995da5d25be4b2/pyparsing-3.2.1.tar.gz", hash = "sha256:61980854fd66de3a90028d679a954d5f2623e83144b5afe5ee86f43d762e5f0a", size = 1067694 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1c/a7/c8a2d361bf89c0d9577c934ebb7421b25dc84bf3a8e3ac0a40aed9acc547/pyparsing-3.2.1-py3-none-any.whl", hash = "sha256:506ff4f4386c4cec0590ec19e6302d3aedb992fdc02c761e90416f158dacf8e1", size = 107716 }, +] + +[[package]] +name = "pyrsistent" +version = "0.19.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/bf/90/445a7dbd275c654c268f47fa9452152709134f61f09605cf776407055a89/pyrsistent-0.19.3.tar.gz", hash = "sha256:1a2994773706bbb4995c31a97bc94f1418314923bd1048c6d964837040376440", size = 102640 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ed/7b/7d032130a6838b179b46dff1ee88909c11d518a10ec9bc70c4b72c7c2f80/pyrsistent-0.19.3-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:20460ac0ea439a3e79caa1dbd560344b64ed75e85d8703943e0b66c2a6150e4a", size = 82517 }, + { url = "https://files.pythonhosted.org/packages/40/04/f1d7813d4cdb62ed58e75b53e2ef481b47081ab5ad2a104cd284fa507042/pyrsistent-0.19.3-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4c18264cb84b5e68e7085a43723f9e4c1fd1d935ab240ce02c0324a8e01ccb64", size = 117238 }, + { url = "https://files.pythonhosted.org/packages/73/55/1e300772f5c24921a81fc1c8b3de8a06a199c4ebb523d7c5a85f4e74a32e/pyrsistent-0.19.3-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4b774f9288dda8d425adb6544e5903f1fb6c273ab3128a355c6b972b7df39dcf", size = 113755 }, + { url = "https://files.pythonhosted.org/packages/57/3e/50aa661939ba1bfc2cc78817ecb37ecb55aef9eda55a193f8da381a8b7a1/pyrsistent-0.19.3-cp310-cp310-win32.whl", hash = "sha256:5a474fb80f5e0d6c9394d8db0fc19e90fa540b82ee52dba7d246a7791712f74a", size = 60178 }, + { url = "https://files.pythonhosted.org/packages/87/72/e5b2347f136d14f09c8260a2e3a528be94e536d97e6635cc9f22cff2d88c/pyrsistent-0.19.3-cp310-cp310-win_amd64.whl", hash = "sha256:49c32f216c17148695ca0e02a5c521e28a4ee6c5089f97e34fe24163113722da", size = 62716 }, + { url = "https://files.pythonhosted.org/packages/b1/46/3f9cfa75c46b8a55d3a235456bc129a26431a65e4922fc9af66aa4e2db7e/pyrsistent-0.19.3-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:f0774bf48631f3a20471dd7c5989657b639fd2d285b861237ea9e82c36a415a9", size = 82552 }, + { url = "https://files.pythonhosted.org/packages/64/bd/b108e1a288a63871be1cf062176dcd5be922c748f843f316440104a45df3/pyrsistent-0.19.3-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3ab2204234c0ecd8b9368dbd6a53e83c3d4f3cab10ecaf6d0e772f456c442393", size = 119532 }, + { url = "https://files.pythonhosted.org/packages/86/f2/fda71652a6baa0147891296a99b4145572538417609c164450beebcf8ebc/pyrsistent-0.19.3-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e42296a09e83028b3476f7073fcb69ffebac0e66dbbfd1bd847d61f74db30f19", size = 116166 }, + { url = "https://files.pythonhosted.org/packages/de/9e/10c5bf794eec650a3aab1b4fb1f6824f53011d111ddfdce1459dc357408a/pyrsistent-0.19.3-cp311-cp311-win32.whl", hash = "sha256:64220c429e42a7150f4bfd280f6f4bb2850f95956bde93c6fda1b70507af6ef3", size = 60181 }, + { url = "https://files.pythonhosted.org/packages/b2/ea/055a9c1884be7c77dd68d9a7891e7a39c776c86946aa4630f8f9f8e48169/pyrsistent-0.19.3-cp311-cp311-win_amd64.whl", hash = "sha256:016ad1afadf318eb7911baa24b049909f7f3bb2c5b1ed7b6a8f21db21ea3faa8", size = 62714 }, + { url = "https://files.pythonhosted.org/packages/dc/c2/994b3e91f22b040fefbb3058d8622e3b45ab78dd1256599575bf36319b6d/pyrsistent-0.19.3-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:c4db1bd596fefd66b296a3d5d943c94f4fac5bcd13e99bffe2ba6a759d959a28", size = 69827 }, + { url = "https://files.pythonhosted.org/packages/0b/c0/5ba658ab88966a5a709e17739d1da02615b95e8210d52041d147f11da5da/pyrsistent-0.19.3-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:aeda827381f5e5d65cced3024126529ddc4289d944f75e090572c77ceb19adbf", size = 118070 }, + { url = "https://files.pythonhosted.org/packages/86/0e/33b4cde936d247024c26772dae0a7c93d650d8ec7ee1824d2752d3d8883c/pyrsistent-0.19.3-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:42ac0b2f44607eb92ae88609eda931a4f0dfa03038c44c772e07f43e738bcac9", size = 114715 }, + { url = "https://files.pythonhosted.org/packages/09/0a/cf855eb8b1dc98f20e3223c7262068918f22f5ad452a99588cf2e5e70e82/pyrsistent-0.19.3-cp37-cp37m-win32.whl", hash = "sha256:e8f2b814a3dc6225964fa03d8582c6e0b6650d68a232df41e3cc1b66a5d2f8d1", size = 60180 }, + { url = "https://files.pythonhosted.org/packages/d8/95/374840c28274b2d660a49c81aee980543953c9c13bcfc9c8c22fb7737919/pyrsistent-0.19.3-cp37-cp37m-win_amd64.whl", hash = "sha256:c9bb60a40a0ab9aba40a59f68214eed5a29c6274c83b2cc206a359c4a89fa41b", size = 62612 }, + { url = "https://files.pythonhosted.org/packages/59/4b/b6ea0f5c564c40f2c9d05ad3dbe3b8db6a6f1e7153e49eee29674c3c3bbe/pyrsistent-0.19.3-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:a2471f3f8693101975b1ff85ffd19bb7ca7dd7c38f8a81701f67d6b4f97b87d8", size = 82545 }, + { url = "https://files.pythonhosted.org/packages/07/d2/0e72806d668c001d13885e8d7c78fefa5a649c34ad9d77b90eb472096ae7/pyrsistent-0.19.3-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cc5d149f31706762c1f8bda2e8c4f8fead6e80312e3692619a75301d3dbb819a", size = 120978 }, + { url = "https://files.pythonhosted.org/packages/82/5e/037a808341e4464c702eb45e741c69292516d0ac00e64080269a2e98d12d/pyrsistent-0.19.3-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3311cb4237a341aa52ab8448c27e3a9931e2ee09561ad150ba94e4cfd3fc888c", size = 117571 }, + { url = "https://files.pythonhosted.org/packages/4a/91/f8e546cbd5aeecce04a5e9d03c32f329c6b97a5514868c824bbe111cd697/pyrsistent-0.19.3-cp38-cp38-win32.whl", hash = "sha256:f0e7c4b2f77593871e918be000b96c8107da48444d57005b6a6bc61fb4331b2c", size = 60246 }, + { url = "https://files.pythonhosted.org/packages/b1/8d/bbce2d857ecdefb7170a8a37ade1de0f060052236c07693856ac23f3b1ee/pyrsistent-0.19.3-cp38-cp38-win_amd64.whl", hash = "sha256:c147257a92374fde8498491f53ffa8f4822cd70c0d85037e09028e478cababb7", size = 62685 }, + { url = "https://files.pythonhosted.org/packages/d5/bf/6ed2d861e3e94c5e92dbb1399eef672fb6add6e824d8c0f4b55d9cd9e733/pyrsistent-0.19.3-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:b735e538f74ec31378f5a1e3886a26d2ca6351106b4dfde376a26fc32a044edc", size = 82518 }, + { url = "https://files.pythonhosted.org/packages/af/3e/7c94e58ade258179c2e13fb254f040830e97654d76dee8288200d30d575d/pyrsistent-0.19.3-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:99abb85579e2165bd8522f0c0138864da97847875ecbd45f3e7e2af569bfc6f2", size = 117026 }, + { url = "https://files.pythonhosted.org/packages/f4/43/183384edb4d2788374aa7663b82ace4afe4a0c1fbfee064875eb40ada95b/pyrsistent-0.19.3-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3a8cb235fa6d3fd7aae6a4f1429bbb1fec1577d978098da1252f0489937786f3", size = 113581 }, + { url = "https://files.pythonhosted.org/packages/b3/e6/43c7f666703506f8d5c5d2c7bc223346c6fa0e0fe392074c2b5788a577f8/pyrsistent-0.19.3-cp39-cp39-win32.whl", hash = "sha256:c74bed51f9b41c48366a286395c67f4e894374306b197e62810e0fdaf2364da2", size = 60176 }, + { url = "https://files.pythonhosted.org/packages/c3/c7/185e37df78c1e34c14961cbd7c89945e27825b5a41bf455e2df2dd46e18e/pyrsistent-0.19.3-cp39-cp39-win_amd64.whl", hash = "sha256:878433581fc23e906d947a6814336eee031a00e6defba224234169ae3d3d6a98", size = 62710 }, + { url = "https://files.pythonhosted.org/packages/64/de/375aa14daaee107f987da76ca32f7a907fea00fa8b8afb67dc09bec0de91/pyrsistent-0.19.3-py3-none-any.whl", hash = "sha256:ccf0d6bd208f8111179f0c26fdf84ed7c3891982f2edaeae7422575f47e66b64", size = 57505 }, +] + +[[package]] +name = "pytest" +version = "7.4.4" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine != 'aarch64' and platform_machine != 'arm64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'aarch64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'arm64'", + "python_full_version < '3.7.1'", +] +dependencies = [ + { name = "colorama", marker = "python_full_version < '3.8' and sys_platform == 'win32'" }, + { name = "exceptiongroup", marker = "python_full_version < '3.8'" }, + { name = "importlib-metadata", version = "6.7.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, + { name = "iniconfig", version = "2.0.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, + { name = "packaging", version = "24.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, + { name = "pluggy", version = "1.2.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, + { name = "tomli", version = "2.0.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/80/1f/9d8e98e4133ffb16c90f3b405c43e38d3abb715bb5d7a63a5a684f7e46a3/pytest-7.4.4.tar.gz", hash = "sha256:2cf0005922c6ace4a3e2ec8b4080eb0d9753fdc93107415332f50ce9e7994280", size = 1357116 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/51/ff/f6e8b8f39e08547faece4bd80f89d5a8de68a38b2d179cc1c4490ffa3286/pytest-7.4.4-py3-none-any.whl", hash = "sha256:b090cdf5ed60bf4c45261be03239c2c1c22df034fbffe691abe93cd80cea01d8", size = 325287 }, +] + +[[package]] +name = "pytest" +version = "8.3.5" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", + "python_full_version == '3.10.*'", + "python_full_version == '3.9.*'", + "python_full_version == '3.8.*'", +] +dependencies = [ + { name = "colorama", marker = "python_full_version >= '3.8' and sys_platform == 'win32'" }, + { name = "exceptiongroup", marker = "python_full_version >= '3.8' and python_full_version < '3.11'" }, + { name = "iniconfig", version = "2.1.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.8'" }, + { name = "packaging", version = "24.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.8'" }, + { name = "pluggy", version = "1.5.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.8'" }, + { name = "tomli", version = "2.2.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.8' and python_full_version < '3.11'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ae/3c/c9d525a414d506893f0cd8a8d0de7706446213181570cdbd766691164e40/pytest-8.3.5.tar.gz", hash = "sha256:f4efe70cc14e511565ac476b57c279e12a855b11f48f212af1080ef2263d3845", size = 1450891 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/30/3d/64ad57c803f1fa1e963a7946b6e0fea4a70df53c1a7fed304586539c2bac/pytest-8.3.5-py3-none-any.whl", hash = "sha256:c69214aa47deac29fad6c2a4f590b9c4a9fdb16a403176fe154b79c0b4d4d820", size = 343634 }, +] + +[[package]] +name = "pytest-cov" +version = "4.1.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine != 'aarch64' and platform_machine != 'arm64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'aarch64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'arm64'", + "python_full_version < '3.7.1'", +] +dependencies = [ + { name = "coverage", version = "7.2.7", source = { registry = "https://pypi.org/simple" }, extra = ["toml"], marker = "python_full_version < '3.8'" }, + { name = "pytest", version = "7.4.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/7a/15/da3df99fd551507694a9b01f512a2f6cf1254f33601605843c3775f39460/pytest-cov-4.1.0.tar.gz", hash = "sha256:3904b13dfbfec47f003b8e77fd5b589cd11904a21ddf1ab38a64f204d6a10ef6", size = 63245 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a7/4b/8b78d126e275efa2379b1c2e09dc52cf70df16fc3b90613ef82531499d73/pytest_cov-4.1.0-py3-none-any.whl", hash = "sha256:6ba70b9e97e69fcc3fb45bfeab2d0a138fb65c4d0d6a41ef33983ad114be8c3a", size = 21949 }, +] + +[[package]] +name = "pytest-cov" +version = "5.0.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version == '3.8.*'", +] +dependencies = [ + { name = "coverage", version = "7.6.1", source = { registry = "https://pypi.org/simple" }, extra = ["toml"], marker = "python_full_version == '3.8.*'" }, + { name = "pytest", version = "8.3.5", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.8.*'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/74/67/00efc8d11b630c56f15f4ad9c7f9223f1e5ec275aaae3fa9118c6a223ad2/pytest-cov-5.0.0.tar.gz", hash = "sha256:5837b58e9f6ebd335b0f8060eecce69b662415b16dc503883a02f45dfeb14857", size = 63042 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/78/3a/af5b4fa5961d9a1e6237b530eb87dd04aea6eb83da09d2a4073d81b54ccf/pytest_cov-5.0.0-py3-none-any.whl", hash = "sha256:4f0764a1219df53214206bf1feea4633c3b558a2925c8b59f144f682861ce652", size = 21990 }, +] + +[[package]] +name = "pytest-cov" +version = "6.0.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", + "python_full_version == '3.10.*'", + "python_full_version == '3.9.*'", +] +dependencies = [ + { name = "coverage", version = "7.7.0", source = { registry = "https://pypi.org/simple" }, extra = ["toml"], marker = "python_full_version >= '3.9'" }, + { name = "pytest", version = "8.3.5", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.9'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/be/45/9b538de8cef30e17c7b45ef42f538a94889ed6a16f2387a6c89e73220651/pytest-cov-6.0.0.tar.gz", hash = "sha256:fde0b595ca248bb8e2d76f020b465f3b107c9632e6a1d1705f17834c89dcadc0", size = 66945 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/36/3b/48e79f2cd6a61dbbd4807b4ed46cb564b4fd50a76166b1c4ea5c1d9e2371/pytest_cov-6.0.0-py3-none-any.whl", hash = "sha256:eee6f1b9e61008bd34975a4d5bab25801eb31898b032dd55addc93e96fcaaa35", size = 22949 }, +] + +[[package]] +name = "pytest-randomly" +version = "3.12.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine != 'aarch64' and platform_machine != 'arm64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'aarch64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'arm64'", + "python_full_version < '3.7.1'", +] +dependencies = [ + { name = "importlib-metadata", version = "6.7.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, + { name = "pytest", version = "7.4.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/2e/1c/35f9746b7bd794e205f3a70ae0d6e167d2c929342e15de40d9d37f3b675e/pytest-randomly-3.12.0.tar.gz", hash = "sha256:d60c2db71ac319aee0fc6c4110a7597d611a8b94a5590918bfa8583f00caccb2", size = 21487 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3b/de/eafd2b4ef66e7e835f13c9717070ddc939589d6127f65a00cf49092dc3ef/pytest_randomly-3.12.0-py3-none-any.whl", hash = "sha256:f4f2e803daf5d1ba036cc22bf4fe9dbbf99389ec56b00e5cba732fb5c1d07fdd", size = 8478 }, +] + +[[package]] +name = "pytest-randomly" +version = "3.15.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version == '3.8.*'", +] +dependencies = [ + { name = "importlib-metadata", version = "8.5.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.8.*'" }, + { name = "pytest", version = "8.3.5", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.8.*'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/c9/d4/6e924a0b2855736d942703dec88dfc98b4fe0881c8fa849b6b0fbb9182fa/pytest_randomly-3.15.0.tar.gz", hash = "sha256:b908529648667ba5e54723088edd6f82252f540cc340d748d1fa985539687047", size = 21743 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/24/d3/00e575657422055c4ea220b2f80e8cc6026ab7130372b7067444d1b0ac10/pytest_randomly-3.15.0-py3-none-any.whl", hash = "sha256:0516f4344b29f4e9cdae8bce31c4aeebf59d0b9ef05927c33354ff3859eeeca6", size = 8685 }, +] + +[[package]] +name = "pytest-randomly" +version = "3.16.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", + "python_full_version == '3.10.*'", + "python_full_version == '3.9.*'", +] +dependencies = [ + { name = "importlib-metadata", version = "8.6.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*'" }, + { name = "pytest", version = "8.3.5", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.9'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/c0/68/d221ed7f4a2a49a664da721b8e87b52af6dd317af2a6cb51549cf17ac4b8/pytest_randomly-3.16.0.tar.gz", hash = "sha256:11bf4d23a26484de7860d82f726c0629837cf4064b79157bd18ec9d41d7feb26", size = 13367 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/22/70/b31577d7c46d8e2f9baccfed5067dd8475262a2331ffb0bfdf19361c9bde/pytest_randomly-3.16.0-py3-none-any.whl", hash = "sha256:8633d332635a1a0983d3bba19342196807f6afb17c3eef78e02c2f85dade45d6", size = 8396 }, +] + +[[package]] +name = "pytest-sugar" +version = "1.0.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "packaging", version = "24.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, + { name = "packaging", version = "24.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.8'" }, + { name = "pytest", version = "7.4.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, + { name = "pytest", version = "8.3.5", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.8'" }, + { name = "termcolor", version = "2.3.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, + { name = "termcolor", version = "2.4.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.8.*'" }, + { name = "termcolor", version = "2.5.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.9'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/f5/ac/5754f5edd6d508bc6493bc37d74b928f102a5fff82d9a80347e180998f08/pytest-sugar-1.0.0.tar.gz", hash = "sha256:6422e83258f5b0c04ce7c632176c7732cab5fdb909cb39cca5c9139f81276c0a", size = 14992 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/92/fb/889f1b69da2f13691de09a111c16c4766a433382d44aa0ecf221deded44a/pytest_sugar-1.0.0-py3-none-any.whl", hash = "sha256:70ebcd8fc5795dc457ff8b69d266a4e2e8a74ae0c3edc749381c64b5246c8dfd", size = 10171 }, +] + +[[package]] +name = "python-dateutil" +version = "2.9.0.post0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "six" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/66/c0/0c8b6ad9f17a802ee498c46e004a0eb49bc148f2fd230864601a86dcf6db/python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3", size = 342432 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ec/57/56b9bcc3c9c6a792fcbaf139543cee77261f3651ca9da0c93f5c1221264b/python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427", size = 229892 }, +] + +[[package]] +name = "pytz" +version = "2025.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/5f/57/df1c9157c8d5a05117e455d66fd7cf6dbc46974f832b1058ed4856785d8a/pytz-2025.1.tar.gz", hash = "sha256:c2db42be2a2518b28e65f9207c4d05e6ff547d1efa4086469ef855e4ab70178e", size = 319617 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/eb/38/ac33370d784287baa1c3d538978b5e2ea064d4c1b93ffbd12826c190dd10/pytz-2025.1-py2.py3-none-any.whl", hash = "sha256:89dd22dca55b46eac6eda23b2d72721bf1bdfef212645d81513ef5d03038de57", size = 507930 }, +] + +[[package]] +name = "pywin32" +version = "310" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/95/da/a5f38fffbba2fb99aa4aa905480ac4b8e83ca486659ac8c95bce47fb5276/pywin32-310-cp310-cp310-win32.whl", hash = "sha256:6dd97011efc8bf51d6793a82292419eba2c71cf8e7250cfac03bba284454abc1", size = 8848240 }, + { url = "https://files.pythonhosted.org/packages/aa/fe/d873a773324fa565619ba555a82c9dabd677301720f3660a731a5d07e49a/pywin32-310-cp310-cp310-win_amd64.whl", hash = "sha256:c3e78706e4229b915a0821941a84e7ef420bf2b77e08c9dae3c76fd03fd2ae3d", size = 9601854 }, + { url = "https://files.pythonhosted.org/packages/3c/84/1a8e3d7a15490d28a5d816efa229ecb4999cdc51a7c30dd8914f669093b8/pywin32-310-cp310-cp310-win_arm64.whl", hash = "sha256:33babed0cf0c92a6f94cc6cc13546ab24ee13e3e800e61ed87609ab91e4c8213", size = 8522963 }, + { url = "https://files.pythonhosted.org/packages/f7/b1/68aa2986129fb1011dabbe95f0136f44509afaf072b12b8f815905a39f33/pywin32-310-cp311-cp311-win32.whl", hash = "sha256:1e765f9564e83011a63321bb9d27ec456a0ed90d3732c4b2e312b855365ed8bd", size = 8784284 }, + { url = "https://files.pythonhosted.org/packages/b3/bd/d1592635992dd8db5bb8ace0551bc3a769de1ac8850200cfa517e72739fb/pywin32-310-cp311-cp311-win_amd64.whl", hash = "sha256:126298077a9d7c95c53823934f000599f66ec9296b09167810eb24875f32689c", size = 9520748 }, + { url = "https://files.pythonhosted.org/packages/90/b1/ac8b1ffce6603849eb45a91cf126c0fa5431f186c2e768bf56889c46f51c/pywin32-310-cp311-cp311-win_arm64.whl", hash = "sha256:19ec5fc9b1d51c4350be7bb00760ffce46e6c95eaf2f0b2f1150657b1a43c582", size = 8455941 }, + { url = "https://files.pythonhosted.org/packages/6b/ec/4fdbe47932f671d6e348474ea35ed94227fb5df56a7c30cbbb42cd396ed0/pywin32-310-cp312-cp312-win32.whl", hash = "sha256:8a75a5cc3893e83a108c05d82198880704c44bbaee4d06e442e471d3c9ea4f3d", size = 8796239 }, + { url = "https://files.pythonhosted.org/packages/e3/e5/b0627f8bb84e06991bea89ad8153a9e50ace40b2e1195d68e9dff6b03d0f/pywin32-310-cp312-cp312-win_amd64.whl", hash = "sha256:bf5c397c9a9a19a6f62f3fb821fbf36cac08f03770056711f765ec1503972060", size = 9503839 }, + { url = "https://files.pythonhosted.org/packages/1f/32/9ccf53748df72301a89713936645a664ec001abd35ecc8578beda593d37d/pywin32-310-cp312-cp312-win_arm64.whl", hash = "sha256:2349cc906eae872d0663d4d6290d13b90621eaf78964bb1578632ff20e152966", size = 8459470 }, + { url = "https://files.pythonhosted.org/packages/1c/09/9c1b978ffc4ae53999e89c19c77ba882d9fce476729f23ef55211ea1c034/pywin32-310-cp313-cp313-win32.whl", hash = "sha256:5d241a659c496ada3253cd01cfaa779b048e90ce4b2b38cd44168ad555ce74ab", size = 8794384 }, + { url = "https://files.pythonhosted.org/packages/45/3c/b4640f740ffebadd5d34df35fecba0e1cfef8fde9f3e594df91c28ad9b50/pywin32-310-cp313-cp313-win_amd64.whl", hash = "sha256:667827eb3a90208ddbdcc9e860c81bde63a135710e21e4cb3348968e4bd5249e", size = 9503039 }, + { url = "https://files.pythonhosted.org/packages/b4/f4/f785020090fb050e7fb6d34b780f2231f302609dc964672f72bfaeb59a28/pywin32-310-cp313-cp313-win_arm64.whl", hash = "sha256:e308f831de771482b7cf692a1f308f8fca701b2d8f9dde6cc440c7da17e47b33", size = 8458152 }, + { url = "https://files.pythonhosted.org/packages/46/65/9c5b79424e344b976394f2b1bb4bedfa4cd013143b72b301a66e4b8943fe/pywin32-310-cp38-cp38-win32.whl", hash = "sha256:0867beb8addefa2e3979d4084352e4ac6e991ca45373390775f7084cc0209b9c", size = 8853889 }, + { url = "https://files.pythonhosted.org/packages/0c/3b/05f848971b3a44b35cd48ea0c6c648745be8bc5a3fc9f4df6f135c7f1e07/pywin32-310-cp38-cp38-win_amd64.whl", hash = "sha256:30f0a9b3138fb5e07eb4973b7077e1883f558e40c578c6925acc7a94c34eaa36", size = 9609017 }, + { url = "https://files.pythonhosted.org/packages/a2/cd/d09d434630edb6a0c44ad5079611279a67530296cfe0451e003de7f449ff/pywin32-310-cp39-cp39-win32.whl", hash = "sha256:851c8d927af0d879221e616ae1f66145253537bbdd321a77e8ef701b443a9a1a", size = 8848099 }, + { url = "https://files.pythonhosted.org/packages/93/ff/2a8c10315ffbdee7b3883ac0d1667e267ca8b3f6f640d81d43b87a82c0c7/pywin32-310-cp39-cp39-win_amd64.whl", hash = "sha256:96867217335559ac619f00ad70e513c0fcf84b8a3af9fc2bba3b59b97da70475", size = 9602031 }, +] + +[[package]] +name = "pyyaml" +version = "6.0.1" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine != 'aarch64' and platform_machine != 'arm64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'aarch64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'arm64'", + "python_full_version < '3.7.1'", +] +sdist = { url = "https://files.pythonhosted.org/packages/cd/e5/af35f7ea75cf72f2cd079c95ee16797de7cd71f29ea7c68ae5ce7be1eda0/PyYAML-6.0.1.tar.gz", hash = "sha256:bfdf460b1736c775f2ba9f6a92bca30bc2095067b8a9d77876d1fad6cc3b4a43", size = 125201 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/96/06/4beb652c0fe16834032e54f0956443d4cc797fe645527acee59e7deaa0a2/PyYAML-6.0.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:d858aa552c999bc8a8d57426ed01e40bef403cd8ccdd0fc5f6f04a00414cac2a", size = 189447 }, + { url = "https://files.pythonhosted.org/packages/5b/07/10033a403b23405a8fc48975444463d3d10a5c2736b7eb2550b07b367429/PyYAML-6.0.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:fd66fc5d0da6d9815ba2cebeb4205f95818ff4b79c3ebe268e75d961704af52f", size = 169264 }, + { url = "https://files.pythonhosted.org/packages/f1/26/55e4f21db1f72eaef092015d9017c11510e7e6301c62a6cfee91295d13c6/PyYAML-6.0.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:69b023b2b4daa7548bcfbd4aa3da05b3a74b772db9e23b982788168117739938", size = 677003 }, + { url = "https://files.pythonhosted.org/packages/ba/91/090818dfa62e85181f3ae23dd1e8b7ea7f09684864a900cab72d29c57346/PyYAML-6.0.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:81e0b275a9ecc9c0c0c07b4b90ba548307583c125f54d5b6946cfee6360c733d", size = 699070 }, + { url = "https://files.pythonhosted.org/packages/29/61/bf33c6c85c55bc45a29eee3195848ff2d518d84735eb0e2d8cb42e0d285e/PyYAML-6.0.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ba336e390cd8e4d1739f42dfe9bb83a3cc2e80f567d8805e11b46f4a943f5515", size = 705525 }, + { url = "https://files.pythonhosted.org/packages/07/91/45dfd0ef821a7f41d9d0136ea3608bb5b1653e42fd56a7970532cb5c003f/PyYAML-6.0.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:326c013efe8048858a6d312ddd31d56e468118ad4cdeda36c719bf5bb6192290", size = 707514 }, + { url = "https://files.pythonhosted.org/packages/b6/a0/b6700da5d49e9fed49dc3243d3771b598dad07abb37cc32e524607f96adc/PyYAML-6.0.1-cp310-cp310-win32.whl", hash = "sha256:bd4af7373a854424dabd882decdc5579653d7868b8fb26dc7d0e99f823aa5924", size = 130488 }, + { url = "https://files.pythonhosted.org/packages/24/97/9b59b43431f98d01806b288532da38099cc6f2fea0f3d712e21e269c0279/PyYAML-6.0.1-cp310-cp310-win_amd64.whl", hash = "sha256:fd1592b3fdf65fff2ad0004b5e363300ef59ced41c2e6b3a99d4089fa8c5435d", size = 145338 }, + { url = "https://files.pythonhosted.org/packages/ec/0d/26fb23e8863e0aeaac0c64e03fd27367ad2ae3f3cccf3798ee98ce160368/PyYAML-6.0.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:6965a7bc3cf88e5a1c3bd2e0b5c22f8d677dc88a455344035f03399034eb3007", size = 187867 }, + { url = "https://files.pythonhosted.org/packages/28/09/55f715ddbf95a054b764b547f617e22f1d5e45d83905660e9a088078fe67/PyYAML-6.0.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:f003ed9ad21d6a4713f0a9b5a7a0a79e08dd0f221aff4525a2be4c346ee60aab", size = 167530 }, + { url = "https://files.pythonhosted.org/packages/5e/94/7d5ee059dfb92ca9e62f4057dcdec9ac08a9e42679644854dc01177f8145/PyYAML-6.0.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:42f8152b8dbc4fe7d96729ec2b99c7097d656dc1213a3229ca5383f973a5ed6d", size = 732244 }, + { url = "https://files.pythonhosted.org/packages/06/92/e0224aa6ebf9dc54a06a4609da37da40bb08d126f5535d81bff6b417b2ae/PyYAML-6.0.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:062582fca9fabdd2c8b54a3ef1c978d786e0f6b3a1510e0ac93ef59e0ddae2bc", size = 752871 }, + { url = "https://files.pythonhosted.org/packages/7b/5e/efd033ab7199a0b2044dab3b9f7a4f6670e6a52c089de572e928d2873b06/PyYAML-6.0.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d2b04aac4d386b172d5b9692e2d2da8de7bfb6c387fa4f801fbf6fb2e6ba4673", size = 757729 }, + { url = "https://files.pythonhosted.org/packages/03/5c/c4671451b2f1d76ebe352c0945d4cd13500adb5d05f5a51ee296d80152f7/PyYAML-6.0.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:e7d73685e87afe9f3b36c799222440d6cf362062f78be1013661b00c5c6f678b", size = 748528 }, + { url = "https://files.pythonhosted.org/packages/73/9c/766e78d1efc0d1fca637a6b62cea1b4510a7fb93617eb805223294fef681/PyYAML-6.0.1-cp311-cp311-win32.whl", hash = "sha256:1635fd110e8d85d55237ab316b5b011de701ea0f29d07611174a1b42f1444741", size = 130286 }, + { url = "https://files.pythonhosted.org/packages/b3/34/65bb4b2d7908044963ebf614fe0fdb080773fc7030d7e39c8d3eddcd4257/PyYAML-6.0.1-cp311-cp311-win_amd64.whl", hash = "sha256:bf07ee2fef7014951eeb99f56f39c9bb4af143d8aa3c21b1677805985307da34", size = 144699 }, + { url = "https://files.pythonhosted.org/packages/bc/06/1b305bf6aa704343be85444c9d011f626c763abb40c0edc1cad13bfd7f86/PyYAML-6.0.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:855fb52b0dc35af121542a76b9a84f8d1cd886ea97c84703eaa6d88e37a2ad28", size = 178692 }, + { url = "https://files.pythonhosted.org/packages/84/02/404de95ced348b73dd84f70e15a41843d817ff8c1744516bf78358f2ffd2/PyYAML-6.0.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:40df9b996c2b73138957fe23a16a4f0ba614f4c0efce1e9406a184b6d07fa3a9", size = 165622 }, + { url = "https://files.pythonhosted.org/packages/c7/4c/4a2908632fc980da6d918b9de9c1d9d7d7e70b2672b1ad5166ed27841ef7/PyYAML-6.0.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a08c6f0fe150303c1c6b71ebcd7213c2858041a7e01975da3a99aed1e7a378ef", size = 696937 }, + { url = "https://files.pythonhosted.org/packages/b4/33/720548182ffa8344418126017aa1d4ab4aeec9a2275f04ce3f3573d8ace8/PyYAML-6.0.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6c22bec3fbe2524cde73d7ada88f6566758a8f7227bfbf93a408a9d86bcc12a0", size = 724969 }, + { url = "https://files.pythonhosted.org/packages/4f/78/77b40157b6cb5f2d3d31a3d9b2efd1ba3505371f76730d267e8b32cf4b7f/PyYAML-6.0.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:8d4e9c88387b0f5c7d5f281e55304de64cf7f9c0021a3525bd3b1c542da3b0e4", size = 712604 }, + { url = "https://files.pythonhosted.org/packages/2e/97/3e0e089ee85e840f4b15bfa00e4e63d84a3691ababbfea92d6f820ea6f21/PyYAML-6.0.1-cp312-cp312-win32.whl", hash = "sha256:d483d2cdf104e7c9fa60c544d92981f12ad66a457afae824d146093b8c294c54", size = 126098 }, + { url = "https://files.pythonhosted.org/packages/2b/9f/fbade56564ad486809c27b322d0f7e6a89c01f6b4fe208402e90d4443a99/PyYAML-6.0.1-cp312-cp312-win_amd64.whl", hash = "sha256:0d3304d8c0adc42be59c5f8a4d9e3d7379e6955ad754aa9d6ab7a398b59dd1df", size = 138675 }, + { url = "https://files.pythonhosted.org/packages/c7/d1/02baa09d39b1bb1ebaf0d850d106d1bdcb47c91958557f471153c49dc03b/PyYAML-6.0.1-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:b1275ad35a5d18c62a7220633c913e1b42d44b46ee12554e5fd39c70a243d6a3", size = 189627 }, + { url = "https://files.pythonhosted.org/packages/e5/31/ba812efa640a264dbefd258986a5e4e786230cb1ee4a9f54eb28ca01e14a/PyYAML-6.0.1-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:18aeb1bf9a78867dc38b259769503436b7c72f7a1f1f4c93ff9a17de54319b27", size = 658438 }, + { url = "https://files.pythonhosted.org/packages/4d/f1/08f06159739254c8947899c9fc901241614195db15ba8802ff142237664c/PyYAML-6.0.1-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:596106435fa6ad000c2991a98fa58eeb8656ef2325d7e158344fb33864ed87e3", size = 680304 }, + { url = "https://files.pythonhosted.org/packages/d7/8f/db62b0df635b9008fe90aa68424e99cee05e68b398740c8a666a98455589/PyYAML-6.0.1-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:baa90d3f661d43131ca170712d903e6295d1f7a0f595074f151c0aed377c9b9c", size = 670140 }, + { url = "https://files.pythonhosted.org/packages/cc/5c/fcabd17918348c7db2eeeb0575705aaf3f7ab1657f6ce29b2e31737dd5d1/PyYAML-6.0.1-cp37-cp37m-win32.whl", hash = "sha256:9046c58c4395dff28dd494285c82ba00b546adfc7ef001486fbf0324bc174fba", size = 137577 }, + { url = "https://files.pythonhosted.org/packages/1e/ae/964ccb88a938f20ece5754878f182cfbd846924930d02d29d06af8d4c69e/PyYAML-6.0.1-cp37-cp37m-win_amd64.whl", hash = "sha256:4fb147e7a67ef577a588a0e2c17b6db51dda102c71de36f8549b6816a96e1867", size = 153248 }, + { url = "https://files.pythonhosted.org/packages/7f/5d/2779ea035ba1e533c32ed4a249b4e0448f583ba10830b21a3cddafe11a4e/PyYAML-6.0.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:1d4c7e777c441b20e32f52bd377e0c409713e8bb1386e1099c2415f26e479595", size = 191734 }, + { url = "https://files.pythonhosted.org/packages/e1/a1/27bfac14b90adaaccf8c8289f441e9f76d94795ec1e7a8f134d9f2cb3d0b/PyYAML-6.0.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a0cd17c15d3bb3fa06978b4e8958dcdc6e0174ccea823003a106c7d4d7899ac5", size = 723767 }, + { url = "https://files.pythonhosted.org/packages/c1/39/47ed4d65beec9ce07267b014be85ed9c204fa373515355d3efa62d19d892/PyYAML-6.0.1-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:28c119d996beec18c05208a8bd78cbe4007878c6dd15091efb73a30e90539696", size = 749067 }, + { url = "https://files.pythonhosted.org/packages/c8/6b/6600ac24725c7388255b2f5add93f91e58a5d7efaf4af244fdbcc11a541b/PyYAML-6.0.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7e07cbde391ba96ab58e532ff4803f79c4129397514e1413a7dc761ccd755735", size = 736569 }, + { url = "https://files.pythonhosted.org/packages/0d/46/62ae77677e532c0af6c81ddd6f3dbc16bdcc1208b077457354442d220bfb/PyYAML-6.0.1-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:49a183be227561de579b4a36efbb21b3eab9651dd81b1858589f796549873dd6", size = 787738 }, + { url = "https://files.pythonhosted.org/packages/d6/6a/439d1a6f834b9a9db16332ce16c4a96dd0e3970b65fe08cbecd1711eeb77/PyYAML-6.0.1-cp38-cp38-win32.whl", hash = "sha256:184c5108a2aca3c5b3d3bf9395d50893a7ab82a38004c8f61c258d4428e80206", size = 139797 }, + { url = "https://files.pythonhosted.org/packages/29/0f/9782fa5b10152abf033aec56a601177ead85ee03b57781f2d9fced09eefc/PyYAML-6.0.1-cp38-cp38-win_amd64.whl", hash = "sha256:1e2722cc9fbb45d9b87631ac70924c11d3a401b2d7f410cc0e3bbf249f2dca62", size = 157350 }, + { url = "https://files.pythonhosted.org/packages/57/c5/5d09b66b41d549914802f482a2118d925d876dc2a35b2d127694c1345c34/PyYAML-6.0.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:9eb6caa9a297fc2c2fb8862bc5370d0303ddba53ba97e71f08023b6cd73d16a8", size = 197846 }, + { url = "https://files.pythonhosted.org/packages/0e/88/21b2f16cb2123c1e9375f2c93486e35fdc86e63f02e274f0e99c589ef153/PyYAML-6.0.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:c8098ddcc2a85b61647b2590f825f3db38891662cfc2fc776415143f599bb859", size = 174396 }, + { url = "https://files.pythonhosted.org/packages/ac/6c/967d91a8edf98d2b2b01d149bd9e51b8f9fb527c98d80ebb60c6b21d60c4/PyYAML-6.0.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5773183b6446b2c99bb77e77595dd486303b4faab2b086e7b17bc6bef28865f6", size = 731824 }, + { url = "https://files.pythonhosted.org/packages/4a/4b/c71ef18ef83c82f99e6da8332910692af78ea32bd1d1d76c9787dfa36aea/PyYAML-6.0.1-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b786eecbdf8499b9ca1d697215862083bd6d2a99965554781d0d8d1ad31e13a0", size = 754777 }, + { url = "https://files.pythonhosted.org/packages/7d/39/472f2554a0f1e825bd7c5afc11c817cd7a2f3657460f7159f691fbb37c51/PyYAML-6.0.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bc1bf2925a1ecd43da378f4db9e4f799775d6367bdb94671027b73b393a7c42c", size = 738883 }, + { url = "https://files.pythonhosted.org/packages/40/da/a175a35cf5583580e90ac3e2a3dbca90e43011593ae62ce63f79d7b28d92/PyYAML-6.0.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:04ac92ad1925b2cff1db0cfebffb6ffc43457495c9b3c39d3fcae417d7125dc5", size = 750294 }, + { url = "https://files.pythonhosted.org/packages/24/62/7fcc372442ec8ea331da18c24b13710e010c5073ab851ef36bf9dacb283f/PyYAML-6.0.1-cp39-cp39-win32.whl", hash = "sha256:faca3bdcf85b2fc05d06ff3fbc1f83e1391b3e724afa3feba7d13eeab355484c", size = 136936 }, + { url = "https://files.pythonhosted.org/packages/84/4d/82704d1ab9290b03da94e6425f5e87396b999fd7eb8e08f3a92c158402bf/PyYAML-6.0.1-cp39-cp39-win_amd64.whl", hash = "sha256:510c9deebc5c0225e8c96813043e62b680ba2f9c50a08d3724c7f28a747d1486", size = 152751 }, +] + +[[package]] +name = "pyyaml" +version = "6.0.2" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", + "python_full_version == '3.10.*'", + "python_full_version == '3.9.*'", + "python_full_version == '3.8.*'", +] +sdist = { url = "https://files.pythonhosted.org/packages/54/ed/79a089b6be93607fa5cdaedf301d7dfb23af5f25c398d5ead2525b063e17/pyyaml-6.0.2.tar.gz", hash = "sha256:d584d9ec91ad65861cc08d42e834324ef890a082e591037abe114850ff7bbc3e", size = 130631 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9b/95/a3fac87cb7158e231b5a6012e438c647e1a87f09f8e0d123acec8ab8bf71/PyYAML-6.0.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:0a9a2848a5b7feac301353437eb7d5957887edbf81d56e903999a75a3d743086", size = 184199 }, + { url = "https://files.pythonhosted.org/packages/c7/7a/68bd47624dab8fd4afbfd3c48e3b79efe09098ae941de5b58abcbadff5cb/PyYAML-6.0.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:29717114e51c84ddfba879543fb232a6ed60086602313ca38cce623c1d62cfbf", size = 171758 }, + { url = "https://files.pythonhosted.org/packages/49/ee/14c54df452143b9ee9f0f29074d7ca5516a36edb0b4cc40c3f280131656f/PyYAML-6.0.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8824b5a04a04a047e72eea5cec3bc266db09e35de6bdfe34c9436ac5ee27d237", size = 718463 }, + { url = "https://files.pythonhosted.org/packages/4d/61/de363a97476e766574650d742205be468921a7b532aa2499fcd886b62530/PyYAML-6.0.2-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7c36280e6fb8385e520936c3cb3b8042851904eba0e58d277dca80a5cfed590b", size = 719280 }, + { url = "https://files.pythonhosted.org/packages/6b/4e/1523cb902fd98355e2e9ea5e5eb237cbc5f3ad5f3075fa65087aa0ecb669/PyYAML-6.0.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ec031d5d2feb36d1d1a24380e4db6d43695f3748343d99434e6f5f9156aaa2ed", size = 751239 }, + { url = "https://files.pythonhosted.org/packages/b7/33/5504b3a9a4464893c32f118a9cc045190a91637b119a9c881da1cf6b7a72/PyYAML-6.0.2-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:936d68689298c36b53b29f23c6dbb74de12b4ac12ca6cfe0e047bedceea56180", size = 695802 }, + { url = "https://files.pythonhosted.org/packages/5c/20/8347dcabd41ef3a3cdc4f7b7a2aff3d06598c8779faa189cdbf878b626a4/PyYAML-6.0.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:23502f431948090f597378482b4812b0caae32c22213aecf3b55325e049a6c68", size = 720527 }, + { url = "https://files.pythonhosted.org/packages/be/aa/5afe99233fb360d0ff37377145a949ae258aaab831bde4792b32650a4378/PyYAML-6.0.2-cp310-cp310-win32.whl", hash = "sha256:2e99c6826ffa974fe6e27cdb5ed0021786b03fc98e5ee3c5bfe1fd5015f42b99", size = 144052 }, + { url = "https://files.pythonhosted.org/packages/b5/84/0fa4b06f6d6c958d207620fc60005e241ecedceee58931bb20138e1e5776/PyYAML-6.0.2-cp310-cp310-win_amd64.whl", hash = "sha256:a4d3091415f010369ae4ed1fc6b79def9416358877534caf6a0fdd2146c87a3e", size = 161774 }, + { url = "https://files.pythonhosted.org/packages/f8/aa/7af4e81f7acba21a4c6be026da38fd2b872ca46226673c89a758ebdc4fd2/PyYAML-6.0.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:cc1c1159b3d456576af7a3e4d1ba7e6924cb39de8f67111c735f6fc832082774", size = 184612 }, + { url = "https://files.pythonhosted.org/packages/8b/62/b9faa998fd185f65c1371643678e4d58254add437edb764a08c5a98fb986/PyYAML-6.0.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:1e2120ef853f59c7419231f3bf4e7021f1b936f6ebd222406c3b60212205d2ee", size = 172040 }, + { url = "https://files.pythonhosted.org/packages/ad/0c/c804f5f922a9a6563bab712d8dcc70251e8af811fce4524d57c2c0fd49a4/PyYAML-6.0.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5d225db5a45f21e78dd9358e58a98702a0302f2659a3c6cd320564b75b86f47c", size = 736829 }, + { url = "https://files.pythonhosted.org/packages/51/16/6af8d6a6b210c8e54f1406a6b9481febf9c64a3109c541567e35a49aa2e7/PyYAML-6.0.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5ac9328ec4831237bec75defaf839f7d4564be1e6b25ac710bd1a96321cc8317", size = 764167 }, + { url = "https://files.pythonhosted.org/packages/75/e4/2c27590dfc9992f73aabbeb9241ae20220bd9452df27483b6e56d3975cc5/PyYAML-6.0.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3ad2a3decf9aaba3d29c8f537ac4b243e36bef957511b4766cb0057d32b0be85", size = 762952 }, + { url = "https://files.pythonhosted.org/packages/9b/97/ecc1abf4a823f5ac61941a9c00fe501b02ac3ab0e373c3857f7d4b83e2b6/PyYAML-6.0.2-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:ff3824dc5261f50c9b0dfb3be22b4567a6f938ccce4587b38952d85fd9e9afe4", size = 735301 }, + { url = "https://files.pythonhosted.org/packages/45/73/0f49dacd6e82c9430e46f4a027baa4ca205e8b0a9dce1397f44edc23559d/PyYAML-6.0.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:797b4f722ffa07cc8d62053e4cff1486fa6dc094105d13fea7b1de7d8bf71c9e", size = 756638 }, + { url = "https://files.pythonhosted.org/packages/22/5f/956f0f9fc65223a58fbc14459bf34b4cc48dec52e00535c79b8db361aabd/PyYAML-6.0.2-cp311-cp311-win32.whl", hash = "sha256:11d8f3dd2b9c1207dcaf2ee0bbbfd5991f571186ec9cc78427ba5bd32afae4b5", size = 143850 }, + { url = "https://files.pythonhosted.org/packages/ed/23/8da0bbe2ab9dcdd11f4f4557ccaf95c10b9811b13ecced089d43ce59c3c8/PyYAML-6.0.2-cp311-cp311-win_amd64.whl", hash = "sha256:e10ce637b18caea04431ce14fabcf5c64a1c61ec9c56b071a4b7ca131ca52d44", size = 161980 }, + { url = "https://files.pythonhosted.org/packages/86/0c/c581167fc46d6d6d7ddcfb8c843a4de25bdd27e4466938109ca68492292c/PyYAML-6.0.2-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:c70c95198c015b85feafc136515252a261a84561b7b1d51e3384e0655ddf25ab", size = 183873 }, + { url = "https://files.pythonhosted.org/packages/a8/0c/38374f5bb272c051e2a69281d71cba6fdb983413e6758b84482905e29a5d/PyYAML-6.0.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ce826d6ef20b1bc864f0a68340c8b3287705cae2f8b4b1d932177dcc76721725", size = 173302 }, + { url = "https://files.pythonhosted.org/packages/c3/93/9916574aa8c00aa06bbac729972eb1071d002b8e158bd0e83a3b9a20a1f7/PyYAML-6.0.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1f71ea527786de97d1a0cc0eacd1defc0985dcf6b3f17bb77dcfc8c34bec4dc5", size = 739154 }, + { url = "https://files.pythonhosted.org/packages/95/0f/b8938f1cbd09739c6da569d172531567dbcc9789e0029aa070856f123984/PyYAML-6.0.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9b22676e8097e9e22e36d6b7bda33190d0d400f345f23d4065d48f4ca7ae0425", size = 766223 }, + { url = "https://files.pythonhosted.org/packages/b9/2b/614b4752f2e127db5cc206abc23a8c19678e92b23c3db30fc86ab731d3bd/PyYAML-6.0.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:80bab7bfc629882493af4aa31a4cfa43a4c57c83813253626916b8c7ada83476", size = 767542 }, + { url = "https://files.pythonhosted.org/packages/d4/00/dd137d5bcc7efea1836d6264f049359861cf548469d18da90cd8216cf05f/PyYAML-6.0.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:0833f8694549e586547b576dcfaba4a6b55b9e96098b36cdc7ebefe667dfed48", size = 731164 }, + { url = "https://files.pythonhosted.org/packages/c9/1f/4f998c900485e5c0ef43838363ba4a9723ac0ad73a9dc42068b12aaba4e4/PyYAML-6.0.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:8b9c7197f7cb2738065c481a0461e50ad02f18c78cd75775628afb4d7137fb3b", size = 756611 }, + { url = "https://files.pythonhosted.org/packages/df/d1/f5a275fdb252768b7a11ec63585bc38d0e87c9e05668a139fea92b80634c/PyYAML-6.0.2-cp312-cp312-win32.whl", hash = "sha256:ef6107725bd54b262d6dedcc2af448a266975032bc85ef0172c5f059da6325b4", size = 140591 }, + { url = "https://files.pythonhosted.org/packages/0c/e8/4f648c598b17c3d06e8753d7d13d57542b30d56e6c2dedf9c331ae56312e/PyYAML-6.0.2-cp312-cp312-win_amd64.whl", hash = "sha256:7e7401d0de89a9a855c839bc697c079a4af81cf878373abd7dc625847d25cbd8", size = 156338 }, + { url = "https://files.pythonhosted.org/packages/ef/e3/3af305b830494fa85d95f6d95ef7fa73f2ee1cc8ef5b495c7c3269fb835f/PyYAML-6.0.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:efdca5630322a10774e8e98e1af481aad470dd62c3170801852d752aa7a783ba", size = 181309 }, + { url = "https://files.pythonhosted.org/packages/45/9f/3b1c20a0b7a3200524eb0076cc027a970d320bd3a6592873c85c92a08731/PyYAML-6.0.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:50187695423ffe49e2deacb8cd10510bc361faac997de9efef88badc3bb9e2d1", size = 171679 }, + { url = "https://files.pythonhosted.org/packages/7c/9a/337322f27005c33bcb656c655fa78325b730324c78620e8328ae28b64d0c/PyYAML-6.0.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0ffe8360bab4910ef1b9e87fb812d8bc0a308b0d0eef8c8f44e0254ab3b07133", size = 733428 }, + { url = "https://files.pythonhosted.org/packages/a3/69/864fbe19e6c18ea3cc196cbe5d392175b4cf3d5d0ac1403ec3f2d237ebb5/PyYAML-6.0.2-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:17e311b6c678207928d649faa7cb0d7b4c26a0ba73d41e99c4fff6b6c3276484", size = 763361 }, + { url = "https://files.pythonhosted.org/packages/04/24/b7721e4845c2f162d26f50521b825fb061bc0a5afcf9a386840f23ea19fa/PyYAML-6.0.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:70b189594dbe54f75ab3a1acec5f1e3faa7e8cf2f1e08d9b561cb41b845f69d5", size = 759523 }, + { url = "https://files.pythonhosted.org/packages/2b/b2/e3234f59ba06559c6ff63c4e10baea10e5e7df868092bf9ab40e5b9c56b6/PyYAML-6.0.2-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:41e4e3953a79407c794916fa277a82531dd93aad34e29c2a514c2c0c5fe971cc", size = 726660 }, + { url = "https://files.pythonhosted.org/packages/fe/0f/25911a9f080464c59fab9027482f822b86bf0608957a5fcc6eaac85aa515/PyYAML-6.0.2-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:68ccc6023a3400877818152ad9a1033e3db8625d899c72eacb5a668902e4d652", size = 751597 }, + { url = "https://files.pythonhosted.org/packages/14/0d/e2c3b43bbce3cf6bd97c840b46088a3031085179e596d4929729d8d68270/PyYAML-6.0.2-cp313-cp313-win32.whl", hash = "sha256:bc2fa7c6b47d6bc618dd7fb02ef6fdedb1090ec036abab80d4681424b84c1183", size = 140527 }, + { url = "https://files.pythonhosted.org/packages/fa/de/02b54f42487e3d3c6efb3f89428677074ca7bf43aae402517bc7cca949f3/PyYAML-6.0.2-cp313-cp313-win_amd64.whl", hash = "sha256:8388ee1976c416731879ac16da0aff3f63b286ffdd57cdeb95f3f2e085687563", size = 156446 }, + { url = "https://files.pythonhosted.org/packages/74/d9/323a59d506f12f498c2097488d80d16f4cf965cee1791eab58b56b19f47a/PyYAML-6.0.2-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:24471b829b3bf607e04e88d79542a9d48bb037c2267d7927a874e6c205ca7e9a", size = 183218 }, + { url = "https://files.pythonhosted.org/packages/74/cc/20c34d00f04d785f2028737e2e2a8254e1425102e730fee1d6396f832577/PyYAML-6.0.2-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d7fded462629cfa4b685c5416b949ebad6cec74af5e2d42905d41e257e0869f5", size = 728067 }, + { url = "https://files.pythonhosted.org/packages/20/52/551c69ca1501d21c0de51ddafa8c23a0191ef296ff098e98358f69080577/PyYAML-6.0.2-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d84a1718ee396f54f3a086ea0a66d8e552b2ab2017ef8b420e92edbc841c352d", size = 757812 }, + { url = "https://files.pythonhosted.org/packages/fd/7f/2c3697bba5d4aa5cc2afe81826d73dfae5f049458e44732c7a0938baa673/PyYAML-6.0.2-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9056c1ecd25795207ad294bcf39f2db3d845767be0ea6e6a34d856f006006083", size = 746531 }, + { url = "https://files.pythonhosted.org/packages/8c/ab/6226d3df99900e580091bb44258fde77a8433511a86883bd4681ea19a858/PyYAML-6.0.2-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:82d09873e40955485746739bcb8b4586983670466c23382c19cffecbf1fd8706", size = 800820 }, + { url = "https://files.pythonhosted.org/packages/a0/99/a9eb0f3e710c06c5d922026f6736e920d431812ace24aae38228d0d64b04/PyYAML-6.0.2-cp38-cp38-win32.whl", hash = "sha256:43fa96a3ca0d6b1812e01ced1044a003533c47f6ee8aca31724f78e93ccc089a", size = 145514 }, + { url = "https://files.pythonhosted.org/packages/75/8a/ee831ad5fafa4431099aa4e078d4c8efd43cd5e48fbc774641d233b683a9/PyYAML-6.0.2-cp38-cp38-win_amd64.whl", hash = "sha256:01179a4a8559ab5de078078f37e5c1a30d76bb88519906844fd7bdea1b7729ff", size = 162702 }, + { url = "https://files.pythonhosted.org/packages/65/d8/b7a1db13636d7fb7d4ff431593c510c8b8fca920ade06ca8ef20015493c5/PyYAML-6.0.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:688ba32a1cffef67fd2e9398a2efebaea461578b0923624778664cc1c914db5d", size = 184777 }, + { url = "https://files.pythonhosted.org/packages/0a/02/6ec546cd45143fdf9840b2c6be8d875116a64076218b61d68e12548e5839/PyYAML-6.0.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:a8786accb172bd8afb8be14490a16625cbc387036876ab6ba70912730faf8e1f", size = 172318 }, + { url = "https://files.pythonhosted.org/packages/0e/9a/8cc68be846c972bda34f6c2a93abb644fb2476f4dcc924d52175786932c9/PyYAML-6.0.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d8e03406cac8513435335dbab54c0d385e4a49e4945d2909a581c83647ca0290", size = 720891 }, + { url = "https://files.pythonhosted.org/packages/e9/6c/6e1b7f40181bc4805e2e07f4abc10a88ce4648e7e95ff1abe4ae4014a9b2/PyYAML-6.0.2-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f753120cb8181e736c57ef7636e83f31b9c0d1722c516f7e86cf15b7aa57ff12", size = 722614 }, + { url = "https://files.pythonhosted.org/packages/3d/32/e7bd8535d22ea2874cef6a81021ba019474ace0d13a4819c2a4bce79bd6a/PyYAML-6.0.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3b1fdb9dc17f5a7677423d508ab4f243a726dea51fa5e70992e59a7411c89d19", size = 737360 }, + { url = "https://files.pythonhosted.org/packages/d7/12/7322c1e30b9be969670b672573d45479edef72c9a0deac3bb2868f5d7469/PyYAML-6.0.2-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:0b69e4ce7a131fe56b7e4d770c67429700908fc0752af059838b1cfb41960e4e", size = 699006 }, + { url = "https://files.pythonhosted.org/packages/82/72/04fcad41ca56491995076630c3ec1e834be241664c0c09a64c9a2589b507/PyYAML-6.0.2-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:a9f8c2e67970f13b16084e04f134610fd1d374bf477b17ec1599185cf611d725", size = 723577 }, + { url = "https://files.pythonhosted.org/packages/ed/5e/46168b1f2757f1fcd442bc3029cd8767d88a98c9c05770d8b420948743bb/PyYAML-6.0.2-cp39-cp39-win32.whl", hash = "sha256:6395c297d42274772abc367baaa79683958044e5d3835486c16da75d2a694631", size = 144593 }, + { url = "https://files.pythonhosted.org/packages/19/87/5124b1c1f2412bb95c59ec481eaf936cd32f0fe2a7b16b97b81c4c017a6a/PyYAML-6.0.2-cp39-cp39-win_amd64.whl", hash = "sha256:39693e1f8320ae4f43943590b49779ffb98acb81f788220ea932a6b6c51004d8", size = 162312 }, +] + +[[package]] +name = "pyzmq" +version = "26.2.1" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine != 'aarch64' and platform_machine != 'arm64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'aarch64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'arm64'", + "python_full_version < '3.7.1'", +] +dependencies = [ + { name = "cffi", version = "1.15.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8' and implementation_name == 'pypy'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/5a/e3/8d0382cb59feb111c252b54e8728257416a38ffcb2243c4e4775a3c990fe/pyzmq-26.2.1.tar.gz", hash = "sha256:17d72a74e5e9ff3829deb72897a175333d3ef5b5413948cae3cf7ebf0b02ecca", size = 278433 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/70/3d/c2d9d46c033d1b51692ea49a22439f7f66d91d5c938e8b5c56ed7a2151c2/pyzmq-26.2.1-cp310-cp310-macosx_10_15_universal2.whl", hash = "sha256:f39d1227e8256d19899d953e6e19ed2ccb689102e6d85e024da5acf410f301eb", size = 1345451 }, + { url = "https://files.pythonhosted.org/packages/0e/df/4754a8abcdeef280651f9bb51446c47659910940b392a66acff7c37f5cef/pyzmq-26.2.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:a23948554c692df95daed595fdd3b76b420a4939d7a8a28d6d7dea9711878641", size = 942766 }, + { url = "https://files.pythonhosted.org/packages/74/da/e6053a3b13c912eded6c2cdeee22ff3a4c33820d17f9eb24c7b6e957ffe7/pyzmq-26.2.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:95f5728b367a042df146cec4340d75359ec6237beebf4a8f5cf74657c65b9257", size = 678488 }, + { url = "https://files.pythonhosted.org/packages/9e/50/614934145244142401ca174ca81071777ab93aa88173973ba0154f491e09/pyzmq-26.2.1-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:95f7b01b3f275504011cf4cf21c6b885c8d627ce0867a7e83af1382ebab7b3ff", size = 917115 }, + { url = "https://files.pythonhosted.org/packages/80/2b/ebeb7bc4fc8e9e61650b2e09581597355a4341d413fa9b2947d7a6558119/pyzmq-26.2.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:80a00370a2ef2159c310e662c7c0f2d030f437f35f478bb8b2f70abd07e26b24", size = 874162 }, + { url = "https://files.pythonhosted.org/packages/79/48/93210621c331ad16313dc2849801411fbae10d91d878853933f2a85df8e7/pyzmq-26.2.1-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:8531ed35dfd1dd2af95f5d02afd6545e8650eedbf8c3d244a554cf47d8924459", size = 874180 }, + { url = "https://files.pythonhosted.org/packages/f0/8b/40924b4d8e33bfdd54c1970fb50f327e39b90b902f897cf09b30b2e9ac48/pyzmq-26.2.1-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:cdb69710e462a38e6039cf17259d328f86383a06c20482cc154327968712273c", size = 1208139 }, + { url = "https://files.pythonhosted.org/packages/c8/b2/82d6675fc89bd965eae13c45002c792d33f06824589844b03f8ea8fc6d86/pyzmq-26.2.1-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:e7eeaef81530d0b74ad0d29eec9997f1c9230c2f27242b8d17e0ee67662c8f6e", size = 1520666 }, + { url = "https://files.pythonhosted.org/packages/9d/e2/5ff15f2d3f920dcc559d477bd9bb3faacd6d79fcf7c5448e585c78f84849/pyzmq-26.2.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:361edfa350e3be1f987e592e834594422338d7174364763b7d3de5b0995b16f3", size = 1420056 }, + { url = "https://files.pythonhosted.org/packages/40/a2/f9bbeccf7f75aa0d8963e224e5730abcefbf742e1f2ae9ea60fd9d6ff72b/pyzmq-26.2.1-cp310-cp310-win32.whl", hash = "sha256:637536c07d2fb6a354988b2dd1d00d02eb5dd443f4bbee021ba30881af1c28aa", size = 583874 }, + { url = "https://files.pythonhosted.org/packages/56/b1/44f513135843272f0e12f5aebf4af35839e2a88eb45411f2c8c010d8c856/pyzmq-26.2.1-cp310-cp310-win_amd64.whl", hash = "sha256:45fad32448fd214fbe60030aa92f97e64a7140b624290834cc9b27b3a11f9473", size = 647367 }, + { url = "https://files.pythonhosted.org/packages/27/9c/1bef14a37b02d651a462811bbdb1390b61cd4a5b5e95cbd7cc2d60ef848c/pyzmq-26.2.1-cp310-cp310-win_arm64.whl", hash = "sha256:d9da0289d8201c8a29fd158aaa0dfe2f2e14a181fd45e2dc1fbf969a62c1d594", size = 561784 }, + { url = "https://files.pythonhosted.org/packages/b9/03/5ecc46a6ed5971299f5c03e016ca637802d8660e44392bea774fb7797405/pyzmq-26.2.1-cp311-cp311-macosx_10_15_universal2.whl", hash = "sha256:c059883840e634a21c5b31d9b9a0e2b48f991b94d60a811092bc37992715146a", size = 1346032 }, + { url = "https://files.pythonhosted.org/packages/40/51/48fec8f990ee644f461ff14c8fe5caa341b0b9b3a0ad7544f8ef17d6f528/pyzmq-26.2.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:ed038a921df836d2f538e509a59cb638df3e70ca0fcd70d0bf389dfcdf784d2a", size = 943324 }, + { url = "https://files.pythonhosted.org/packages/c1/f4/f322b389727c687845e38470b48d7a43c18a83f26d4d5084603c6c3f79ca/pyzmq-26.2.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9027a7fcf690f1a3635dc9e55e38a0d6602dbbc0548935d08d46d2e7ec91f454", size = 678418 }, + { url = "https://files.pythonhosted.org/packages/a8/df/2834e3202533bd05032d83e02db7ac09fa1be853bbef59974f2b2e3a8557/pyzmq-26.2.1-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6d75fcb00a1537f8b0c0bb05322bc7e35966148ffc3e0362f0369e44a4a1de99", size = 915466 }, + { url = "https://files.pythonhosted.org/packages/b5/e2/45c0f6e122b562cb8c6c45c0dcac1160a4e2207385ef9b13463e74f93031/pyzmq-26.2.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f0019cc804ac667fb8c8eaecdb66e6d4a68acf2e155d5c7d6381a5645bd93ae4", size = 873347 }, + { url = "https://files.pythonhosted.org/packages/de/b9/3e0fbddf8b87454e914501d368171466a12550c70355b3844115947d68ea/pyzmq-26.2.1-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:f19dae58b616ac56b96f2e2290f2d18730a898a171f447f491cc059b073ca1fa", size = 874545 }, + { url = "https://files.pythonhosted.org/packages/1f/1c/1ee41d6e10b2127263b1994bc53b9e74ece015b0d2c0a30e0afaf69b78b2/pyzmq-26.2.1-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:f5eeeb82feec1fc5cbafa5ee9022e87ffdb3a8c48afa035b356fcd20fc7f533f", size = 1208630 }, + { url = "https://files.pythonhosted.org/packages/3d/a9/50228465c625851a06aeee97c74f253631f509213f979166e83796299c60/pyzmq-26.2.1-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:000760e374d6f9d1a3478a42ed0c98604de68c9e94507e5452951e598ebecfba", size = 1519568 }, + { url = "https://files.pythonhosted.org/packages/c6/f2/6360b619e69da78863c2108beb5196ae8b955fe1e161c0b886b95dc6b1ac/pyzmq-26.2.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:817fcd3344d2a0b28622722b98500ae9c8bfee0f825b8450932ff19c0b15bebd", size = 1419677 }, + { url = "https://files.pythonhosted.org/packages/da/d5/f179da989168f5dfd1be8103ef508ade1d38a8078dda4f10ebae3131a490/pyzmq-26.2.1-cp311-cp311-win32.whl", hash = "sha256:88812b3b257f80444a986b3596e5ea5c4d4ed4276d2b85c153a6fbc5ca457ae7", size = 582682 }, + { url = "https://files.pythonhosted.org/packages/60/50/e5b2e9de3ffab73ff92bee736216cf209381081fa6ab6ba96427777d98b1/pyzmq-26.2.1-cp311-cp311-win_amd64.whl", hash = "sha256:ef29630fde6022471d287c15c0a2484aba188adbfb978702624ba7a54ddfa6c1", size = 648128 }, + { url = "https://files.pythonhosted.org/packages/d9/fe/7bb93476dd8405b0fc9cab1fd921a08bd22d5e3016aa6daea1a78d54129b/pyzmq-26.2.1-cp311-cp311-win_arm64.whl", hash = "sha256:f32718ee37c07932cc336096dc7403525301fd626349b6eff8470fe0f996d8d7", size = 562465 }, + { url = "https://files.pythonhosted.org/packages/9c/b9/260a74786f162c7f521f5f891584a51d5a42fd15f5dcaa5c9226b2865fcc/pyzmq-26.2.1-cp312-cp312-macosx_10_15_universal2.whl", hash = "sha256:a6549ecb0041dafa55b5932dcbb6c68293e0bd5980b5b99f5ebb05f9a3b8a8f3", size = 1348495 }, + { url = "https://files.pythonhosted.org/packages/bf/73/8a0757e4b68f5a8ccb90ddadbb76c6a5f880266cdb18be38c99bcdc17aaa/pyzmq-26.2.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:0250c94561f388db51fd0213cdccbd0b9ef50fd3c57ce1ac937bf3034d92d72e", size = 945035 }, + { url = "https://files.pythonhosted.org/packages/cf/de/f02ec973cd33155bb772bae33ace774acc7cc71b87b25c4829068bec35de/pyzmq-26.2.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:36ee4297d9e4b34b5dc1dd7ab5d5ea2cbba8511517ef44104d2915a917a56dc8", size = 671213 }, + { url = "https://files.pythonhosted.org/packages/d1/80/8fc583085f85ac91682744efc916888dd9f11f9f75a31aef1b78a5486c6c/pyzmq-26.2.1-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c2a9cb17fd83b7a3a3009901aca828feaf20aa2451a8a487b035455a86549c09", size = 908750 }, + { url = "https://files.pythonhosted.org/packages/c3/25/0b4824596f261a3cc512ab152448b383047ff5f143a6906a36876415981c/pyzmq-26.2.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:786dd8a81b969c2081b31b17b326d3a499ddd1856e06d6d79ad41011a25148da", size = 865416 }, + { url = "https://files.pythonhosted.org/packages/a1/d1/6fda77a034d02034367b040973fd3861d945a5347e607bd2e98c99f20599/pyzmq-26.2.1-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:2d88ba221a07fc2c5581565f1d0fe8038c15711ae79b80d9462e080a1ac30435", size = 865922 }, + { url = "https://files.pythonhosted.org/packages/ad/81/48f7fd8a71c427412e739ce576fc1ee14f3dc34527ca9b0076e471676183/pyzmq-26.2.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:1c84c1297ff9f1cd2440da4d57237cb74be21fdfe7d01a10810acba04e79371a", size = 1201526 }, + { url = "https://files.pythonhosted.org/packages/c7/d8/818f15c6ef36b5450e435cbb0d3a51599fc884a5d2b27b46b9c00af68ef1/pyzmq-26.2.1-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:46d4ebafc27081a7f73a0f151d0c38d4291656aa134344ec1f3d0199ebfbb6d4", size = 1512808 }, + { url = "https://files.pythonhosted.org/packages/d9/c4/b3edb7d0ae82ad6fb1a8cdb191a4113c427a01e85139906f3b655b07f4f8/pyzmq-26.2.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:91e2bfb8e9a29f709d51b208dd5f441dc98eb412c8fe75c24ea464734ccdb48e", size = 1411836 }, + { url = "https://files.pythonhosted.org/packages/69/1c/151e3d42048f02cc5cd6dfc241d9d36b38375b4dee2e728acb5c353a6d52/pyzmq-26.2.1-cp312-cp312-win32.whl", hash = "sha256:4a98898fdce380c51cc3e38ebc9aa33ae1e078193f4dc641c047f88b8c690c9a", size = 581378 }, + { url = "https://files.pythonhosted.org/packages/b6/b9/d59a7462848aaab7277fddb253ae134a570520115d80afa85e952287e6bc/pyzmq-26.2.1-cp312-cp312-win_amd64.whl", hash = "sha256:a0741edbd0adfe5f30bba6c5223b78c131b5aa4a00a223d631e5ef36e26e6d13", size = 643737 }, + { url = "https://files.pythonhosted.org/packages/55/09/f37e707937cce328944c1d57e5e50ab905011d35252a0745c4f7e5822a76/pyzmq-26.2.1-cp312-cp312-win_arm64.whl", hash = "sha256:e5e33b1491555843ba98d5209439500556ef55b6ab635f3a01148545498355e5", size = 558303 }, + { url = "https://files.pythonhosted.org/packages/4f/2e/fa7a91ce349975971d6aa925b4c7e1a05abaae99b97ade5ace758160c43d/pyzmq-26.2.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:099b56ef464bc355b14381f13355542e452619abb4c1e57a534b15a106bf8e23", size = 942331 }, + { url = "https://files.pythonhosted.org/packages/64/2b/1f10b34b6dc7ff4b40f668ea25ba9b8093ce61d874c784b90229b367707b/pyzmq-26.2.1-cp313-cp313-macosx_10_15_universal2.whl", hash = "sha256:651726f37fcbce9f8dd2a6dab0f024807929780621890a4dc0c75432636871be", size = 1345831 }, + { url = "https://files.pythonhosted.org/packages/4c/8d/34884cbd4a8ec050841b5fb58d37af136766a9f95b0b2634c2971deb09da/pyzmq-26.2.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:57dd4d91b38fa4348e237a9388b4423b24ce9c1695bbd4ba5a3eada491e09399", size = 670773 }, + { url = "https://files.pythonhosted.org/packages/0f/f4/d4becfcf9e416ad2564f18a6653f7c6aa917da08df5c3760edb0baa1c863/pyzmq-26.2.1-cp313-cp313-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d51a7bfe01a48e1064131f3416a5439872c533d756396be2b39e3977b41430f9", size = 908836 }, + { url = "https://files.pythonhosted.org/packages/07/fa/ab105f1b86b85cb2e821239f1d0900fccd66192a91d97ee04661b5436b4d/pyzmq-26.2.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c7154d228502e18f30f150b7ce94f0789d6b689f75261b623f0fdc1eec642aab", size = 865369 }, + { url = "https://files.pythonhosted.org/packages/c9/48/15d5f415504572dd4b92b52db5de7a5befc76bb75340ba9f36f71306a66d/pyzmq-26.2.1-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:f1f31661a80cc46aba381bed475a9135b213ba23ca7ff6797251af31510920ce", size = 865676 }, + { url = "https://files.pythonhosted.org/packages/7e/35/2d91bcc7ccbb56043dd4d2c1763f24a8de5f05e06a134f767a7fb38e149c/pyzmq-26.2.1-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:290c96f479504439b6129a94cefd67a174b68ace8a8e3f551b2239a64cfa131a", size = 1201457 }, + { url = "https://files.pythonhosted.org/packages/6d/bb/aa7c5119307a5762b8dca6c9db73e3ab4bccf32b15d7c4f376271ff72b2b/pyzmq-26.2.1-cp313-cp313-musllinux_1_1_i686.whl", hash = "sha256:f2c307fbe86e18ab3c885b7e01de942145f539165c3360e2af0f094dd440acd9", size = 1513035 }, + { url = "https://files.pythonhosted.org/packages/4f/4c/527e6650c2fccec7750b783301329c8a8716d59423818afb67282304ce5a/pyzmq-26.2.1-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:b314268e716487bfb86fcd6f84ebbe3e5bec5fac75fdf42bc7d90fdb33f618ad", size = 1411881 }, + { url = "https://files.pythonhosted.org/packages/89/9f/e4412ea1b3e220acc21777a5edba8885856403d29c6999aaf00a9459eb03/pyzmq-26.2.1-cp313-cp313-win32.whl", hash = "sha256:edb550616f567cd5603b53bb52a5f842c0171b78852e6fc7e392b02c2a1504bb", size = 581354 }, + { url = "https://files.pythonhosted.org/packages/55/cd/f89dd3e9fc2da0d1619a82c4afb600c86b52bc72d7584953d460bc8d5027/pyzmq-26.2.1-cp313-cp313-win_amd64.whl", hash = "sha256:100a826a029c8ef3d77a1d4c97cbd6e867057b5806a7276f2bac1179f893d3bf", size = 643560 }, + { url = "https://files.pythonhosted.org/packages/a7/99/5de4f8912860013f1116f818a0047659bc20d71d1bc1d48f874bdc2d7b9c/pyzmq-26.2.1-cp313-cp313-win_arm64.whl", hash = "sha256:6991ee6c43e0480deb1b45d0c7c2bac124a6540cba7db4c36345e8e092da47ce", size = 558037 }, + { url = "https://files.pythonhosted.org/packages/06/0b/63b6d7a2f07a77dbc9768c6302ae2d7518bed0c6cee515669ca0d8ec743e/pyzmq-26.2.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:25e720dba5b3a3bb2ad0ad5d33440babd1b03438a7a5220511d0c8fa677e102e", size = 938580 }, + { url = "https://files.pythonhosted.org/packages/85/38/e5e2c3ffa23ea5f95f1c904014385a55902a11a67cd43c10edf61a653467/pyzmq-26.2.1-cp313-cp313t-macosx_10_15_universal2.whl", hash = "sha256:9ec6abfb701437142ce9544bd6a236addaf803a32628d2260eb3dbd9a60e2891", size = 1339670 }, + { url = "https://files.pythonhosted.org/packages/d2/87/da5519ed7f8b31e4beee8f57311ec02926822fe23a95120877354cd80144/pyzmq-26.2.1-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2e1eb9d2bfdf5b4e21165b553a81b2c3bd5be06eeddcc4e08e9692156d21f1f6", size = 660983 }, + { url = "https://files.pythonhosted.org/packages/f6/e8/1ca6a2d59562e04d326a026c9e3f791a6f1a276ebde29da478843a566fdb/pyzmq-26.2.1-cp313-cp313t-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:90dc731d8e3e91bcd456aa7407d2eba7ac6f7860e89f3766baabb521f2c1de4a", size = 896509 }, + { url = "https://files.pythonhosted.org/packages/5c/e5/0b4688f7c74bea7e4f1e920da973fcd7d20175f4f1181cb9b692429c6bb9/pyzmq-26.2.1-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0b6a93d684278ad865fc0b9e89fe33f6ea72d36da0e842143891278ff7fd89c3", size = 853196 }, + { url = "https://files.pythonhosted.org/packages/8f/35/c17241da01195001828319e98517683dad0ac4df6fcba68763d61b630390/pyzmq-26.2.1-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:c1bb37849e2294d519117dd99b613c5177934e5c04a5bb05dd573fa42026567e", size = 855133 }, + { url = "https://files.pythonhosted.org/packages/d2/14/268ee49bbecc3f72e225addeac7f0e2bd5808747b78c7bf7f87ed9f9d5a8/pyzmq-26.2.1-cp313-cp313t-musllinux_1_1_aarch64.whl", hash = "sha256:632a09c6d8af17b678d84df442e9c3ad8e4949c109e48a72f805b22506c4afa7", size = 1191612 }, + { url = "https://files.pythonhosted.org/packages/5e/02/6394498620b1b4349b95c534f3ebc3aef95f39afbdced5ed7ee315c49c14/pyzmq-26.2.1-cp313-cp313t-musllinux_1_1_i686.whl", hash = "sha256:fc409c18884eaf9ddde516d53af4f2db64a8bc7d81b1a0c274b8aa4e929958e8", size = 1500824 }, + { url = "https://files.pythonhosted.org/packages/17/fc/b79f0b72891cbb9917698add0fede71dfb64e83fa3481a02ed0e78c34be7/pyzmq-26.2.1-cp313-cp313t-musllinux_1_1_x86_64.whl", hash = "sha256:17f88622b848805d3f6427ce1ad5a2aa3cf61f12a97e684dab2979802024d460", size = 1399943 }, + { url = "https://files.pythonhosted.org/packages/a9/e5/642c57d4db61fa6e40b95414f25a7826f32b84db6b4c344f58b9596ed825/pyzmq-26.2.1-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:3ef584f13820d2629326fe20cc04069c21c5557d84c26e277cfa6235e523b10f", size = 941711 }, + { url = "https://files.pythonhosted.org/packages/b6/94/60a9d6a8182b1eef8b0b0c4c87bf4e81374bead08d44a8519440df3e3084/pyzmq-26.2.1-cp37-cp37m-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:160194d1034902937359c26ccfa4e276abffc94937e73add99d9471e9f555dd6", size = 911485 }, + { url = "https://files.pythonhosted.org/packages/c0/db/9e88ba9a2565deb576b52a1003dcd7f3cb72e8db55ed6ba1c89bd4c7c49d/pyzmq-26.2.1-cp37-cp37m-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:574b285150afdbf0a0424dddf7ef9a0d183988eb8d22feacb7160f7515e032cb", size = 863954 }, + { url = "https://files.pythonhosted.org/packages/da/57/0db10804ee30d07e0155c0736e10b931ffa74f6aa9b6b9973b20dfac30dd/pyzmq-26.2.1-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:44dba28c34ce527cf687156c81f82bf1e51f047838d5964f6840fd87dfecf9fe", size = 678705 }, + { url = "https://files.pythonhosted.org/packages/56/3e/c4ccf4e214a05e0bf0bdc2f8ecbcf6b4a5e3134b5da520842bd5b8fdd2aa/pyzmq-26.2.1-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:9fbdb90b85c7624c304f72ec7854659a3bd901e1c0ffb2363163779181edeb68", size = 1210814 }, + { url = "https://files.pythonhosted.org/packages/f9/34/5cfbc17413b1356496b5c5342e35a0b2287678c2cf339f6dd29c2595b2a4/pyzmq-26.2.1-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:a7ad34a2921e8f76716dc7205c9bf46a53817e22b9eec2e8a3e08ee4f4a72468", size = 1521430 }, + { url = "https://files.pythonhosted.org/packages/24/e7/95087841fa493883683527b6b48ce0e37a98fa8832b0f2f5080f102f34d1/pyzmq-26.2.1-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:866c12b7c90dd3a86983df7855c6f12f9407c8684db6aa3890fc8027462bda82", size = 1420747 }, + { url = "https://files.pythonhosted.org/packages/29/c1/24243cdcc4bdfa377ee852c3fac35e52ebdbf101e41416a344d51a280055/pyzmq-26.2.1-cp37-cp37m-win32.whl", hash = "sha256:eeb37f65350d5c5870517f02f8bbb2ac0fbec7b416c0f4875219fef305a89a45", size = 582773 }, + { url = "https://files.pythonhosted.org/packages/a2/ce/6f3592b84ba9b8d99e60ff791224e27c3945653816596615135f5b1ce9c1/pyzmq-26.2.1-cp37-cp37m-win_amd64.whl", hash = "sha256:4eb3197f694dfb0ee6af29ef14a35f30ae94ff67c02076eef8125e2d98963cd0", size = 646070 }, + { url = "https://files.pythonhosted.org/packages/d2/bb/fe5b78f58dd7846a8a5255d74c3aa475ed6450c68338554222a929695b29/pyzmq-26.2.1-cp38-cp38-macosx_10_15_universal2.whl", hash = "sha256:36d4e7307db7c847fe37413f333027d31c11d5e6b3bacbb5022661ac635942ba", size = 1345877 }, + { url = "https://files.pythonhosted.org/packages/cd/74/b77cab27649917e8a7304c0a4b57f138a092177106a680cccc541189af40/pyzmq-26.2.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:1c6ae0e95d0a4b0cfe30f648a18e764352d5415279bdf34424decb33e79935b8", size = 942846 }, + { url = "https://files.pythonhosted.org/packages/8c/18/aae170eb81d5b4d65082ffc7a115487d5985e0733d053b67a2320cf9065e/pyzmq-26.2.1-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:5b4fc44f5360784cc02392f14235049665caaf7c0fe0b04d313e763d3338e463", size = 913016 }, + { url = "https://files.pythonhosted.org/packages/6c/15/d333cb6d96b3740b5b3fba6ff48fb9076266a85da140b02d435429d93779/pyzmq-26.2.1-cp38-cp38-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:51431f6b2750eb9b9d2b2952d3cc9b15d0215e1b8f37b7a3239744d9b487325d", size = 867683 }, + { url = "https://files.pythonhosted.org/packages/2b/21/bf8e5e27abc0b08416544fc4563d45052ba9219b794d76c83b7e5e026f8e/pyzmq-26.2.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bdbc78ae2065042de48a65f1421b8af6b76a0386bb487b41955818c3c1ce7bed", size = 679167 }, + { url = "https://files.pythonhosted.org/packages/7d/e1/79b567380a967cd525bac814a68585a8cdd5c5ba5bff3c890d3ed559e55c/pyzmq-26.2.1-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:d14f50d61a89b0925e4d97a0beba6053eb98c426c5815d949a43544f05a0c7ec", size = 1212285 }, + { url = "https://files.pythonhosted.org/packages/a5/c1/339456da6fded90d05c7930686bed1ae6cb5d42fcdb4619ee959cb81eb18/pyzmq-26.2.1-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:004837cb958988c75d8042f5dac19a881f3d9b3b75b2f574055e22573745f841", size = 1521549 }, + { url = "https://files.pythonhosted.org/packages/b2/26/4b1d9ce3152658535c43b4dc8d0d107c534ba3ef0cf9d4e46b1f87f46e6e/pyzmq-26.2.1-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:0b2007f28ce1b8acebdf4812c1aab997a22e57d6a73b5f318b708ef9bcabbe95", size = 1422824 }, + { url = "https://files.pythonhosted.org/packages/b5/1a/eea539099f165c9e9a496eeadc181091022a8e401554eaa7a1e8eb056235/pyzmq-26.2.1-cp38-cp38-win32.whl", hash = "sha256:269c14904da971cb5f013100d1aaedb27c0a246728c341d5d61ddd03f463f2f3", size = 583745 }, + { url = "https://files.pythonhosted.org/packages/95/74/7dddec65ba0df90489a16221ca4db4616bf4b0aac42650d3708b54007286/pyzmq-26.2.1-cp38-cp38-win_amd64.whl", hash = "sha256:31fff709fef3b991cfe7189d2cfe0c413a1d0e82800a182cfa0c2e3668cd450f", size = 648270 }, + { url = "https://files.pythonhosted.org/packages/8d/a4/42e404040ccb3f65bd3b40e368dc96fb04b8e7eea1ecd3ac2ef0e70c51f3/pyzmq-26.2.1-cp39-cp39-macosx_10_15_universal2.whl", hash = "sha256:a4bffcadfd40660f26d1b3315a6029fd4f8f5bf31a74160b151f5c577b2dc81b", size = 1346647 }, + { url = "https://files.pythonhosted.org/packages/d5/d9/045ee93500e3f8cbd2a7b30a9533cba7b857b51b3bb4ec44fa61eb6d36ef/pyzmq-26.2.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:e76ad4729c2f1cf74b6eb1bdd05f6aba6175999340bd51e6caee49a435a13bf5", size = 943305 }, + { url = "https://files.pythonhosted.org/packages/5c/3b/9437cae0bfd3889dc7741ed9c132dc09c2a1fcae05a2e1b1af41a23a77a2/pyzmq-26.2.1-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:8b0f5bab40a16e708e78a0c6ee2425d27e1a5d8135c7a203b4e977cee37eb4aa", size = 913424 }, + { url = "https://files.pythonhosted.org/packages/5c/16/f1f0e36c9c15247901379b45bd3f7cc15f540b62c9c34c28e735550014b4/pyzmq-26.2.1-cp39-cp39-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:e8e47050412f0ad3a9b2287779758073cbf10e460d9f345002d4779e43bb0136", size = 867471 }, + { url = "https://files.pythonhosted.org/packages/70/68/3a0dd3b6386d725ffb98378cd046e15333fbcc1e2b3b48dbcda73259a752/pyzmq-26.2.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7f18ce33f422d119b13c1363ed4cce245b342b2c5cbbb76753eabf6aa6f69c7d", size = 679051 }, + { url = "https://files.pythonhosted.org/packages/46/9a/0c57cd9c0aae885a096f0c7ebd658f6c7fda49973e484bf7f1c47288beae/pyzmq-26.2.1-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:ceb0d78b7ef106708a7e2c2914afe68efffc0051dc6a731b0dbacd8b4aee6d68", size = 1208959 }, + { url = "https://files.pythonhosted.org/packages/61/f7/22dcf86ab2a4d458a300698972212be327a66e35785649e9f4bad2260f1c/pyzmq-26.2.1-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:7ebdd96bd637fd426d60e86a29ec14b8c1ab64b8d972f6a020baf08a30d1cf46", size = 1521237 }, + { url = "https://files.pythonhosted.org/packages/b4/20/854bb34ac377efbe15d791d6e0bf991d8127cc6d471cd9a2666a13b4f3ba/pyzmq-26.2.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:03719e424150c6395b9513f53a5faadcc1ce4b92abdf68987f55900462ac7eec", size = 1420720 }, + { url = "https://files.pythonhosted.org/packages/6d/e3/07816d8b50a506f6f59d0023b8fefa109d5549a874b9d250137e85dc4305/pyzmq-26.2.1-cp39-cp39-win32.whl", hash = "sha256:ef5479fac31df4b304e96400fc67ff08231873ee3537544aa08c30f9d22fce38", size = 584311 }, + { url = "https://files.pythonhosted.org/packages/9f/78/eeb040669d0ac1fc3c061c8053e96a49e5c612041f462b026ad154001ac1/pyzmq-26.2.1-cp39-cp39-win_amd64.whl", hash = "sha256:f92a002462154c176dac63a8f1f6582ab56eb394ef4914d65a9417f5d9fde218", size = 647856 }, + { url = "https://files.pythonhosted.org/packages/2c/c9/55eb55eda712573ca759e17b9018a2f9dbc4dd34bc7c862c36d574a40b1f/pyzmq-26.2.1-cp39-cp39-win_arm64.whl", hash = "sha256:1fd4b3efc6f62199886440d5e27dd3ccbcb98dfddf330e7396f1ff421bfbb3c2", size = 562372 }, + { url = "https://files.pythonhosted.org/packages/65/d1/e630a75cfb2534574a1258fda54d02f13cf80b576d4ce6d2aa478dc67829/pyzmq-26.2.1-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:380816d298aed32b1a97b4973a4865ef3be402a2e760204509b52b6de79d755d", size = 847743 }, + { url = "https://files.pythonhosted.org/packages/27/df/f94a711b4f6c4b41e227f9a938103f52acf4c2e949d91cbc682495a48155/pyzmq-26.2.1-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:97cbb368fd0debdbeb6ba5966aa28e9a1ae3396c7386d15569a6ca4be4572b99", size = 570991 }, + { url = "https://files.pythonhosted.org/packages/bf/08/0c6f97fb3c9dbfa23382f0efaf8f9aa1396a08a3358974eaae3ee659ed5c/pyzmq-26.2.1-pp310-pypy310_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:abf7b5942c6b0dafcc2823ddd9154f419147e24f8df5b41ca8ea40a6db90615c", size = 799664 }, + { url = "https://files.pythonhosted.org/packages/05/14/f4d4fd8bb8988c667845734dd756e9ee65b9a17a010d5f288dfca14a572d/pyzmq-26.2.1-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3fe6e28a8856aea808715f7a4fc11f682b9d29cac5d6262dd8fe4f98edc12d53", size = 758156 }, + { url = "https://files.pythonhosted.org/packages/e3/fe/72e7e166bda3885810bee7b23049133e142f7c80c295bae02c562caeea16/pyzmq-26.2.1-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:bd8fdee945b877aa3bffc6a5a8816deb048dab0544f9df3731ecd0e54d8c84c9", size = 556563 }, + { url = "https://files.pythonhosted.org/packages/f2/a9/ece8fdac952d121f29571361514d398aa8f40fd6134a9d7154dac51a5b65/pyzmq-26.2.1-pp37-pypy37_pp73-macosx_10_9_x86_64.whl", hash = "sha256:ee7152f32c88e0e1b5b17beb9f0e2b14454235795ef68c0c120b6d3d23d12833", size = 847717 }, + { url = "https://files.pythonhosted.org/packages/96/f1/0e73524e54d59f48219379c63e62108ec384d3e88b9b00ffd529582b330a/pyzmq-26.2.1-pp37-pypy37_pp73-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:baa1da72aecf6a490b51fba7a51f1ce298a1e0e86d0daef8265c8f8f9848eb77", size = 807440 }, + { url = "https://files.pythonhosted.org/packages/cb/89/f20b9f8a0f3dbeee68986107805d49883b41b397e820e088297a5cb6f8ff/pyzmq-26.2.1-pp37-pypy37_pp73-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:49135bb327fca159262d8fd14aa1f4a919fe071b04ed08db4c7c37d2f0647162", size = 762211 }, + { url = "https://files.pythonhosted.org/packages/19/65/6b1b3db9334819fdb224d309bb71474d57ff523c317c51a9b2edd9db5253/pyzmq-26.2.1-pp37-pypy37_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8bacc1a10c150d58e8a9ee2b2037a70f8d903107e0f0b6e079bf494f2d09c091", size = 570985 }, + { url = "https://files.pythonhosted.org/packages/54/c1/67e1df44d421c357503140dd3497317fa641f1c3f683b7b2e24909012221/pyzmq-26.2.1-pp37-pypy37_pp73-win_amd64.whl", hash = "sha256:09dac387ce62d69bec3f06d51610ca1d660e7849eb45f68e38e7f5cf1f49cbcb", size = 556557 }, + { url = "https://files.pythonhosted.org/packages/c9/e9/892d0c9654a7ec5ea0b06b40f87b3f255d1440d8b5500dc9bf4b7079de95/pyzmq-26.2.1-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:70b3a46ecd9296e725ccafc17d732bfc3cdab850b54bd913f843a0a54dfb2c04", size = 847718 }, + { url = "https://files.pythonhosted.org/packages/b1/4f/1e820f2706df3940f1a1bcbc072515ac5346f2c0e20c300623cf968eb35a/pyzmq-26.2.1-pp38-pypy38_pp73-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:59660e15c797a3b7a571c39f8e0b62a1f385f98ae277dfe95ca7eaf05b5a0f12", size = 807438 }, + { url = "https://files.pythonhosted.org/packages/ff/ce/a575e9dedc47a83425faa7be99154bf206b3924c5acb0f76212f45933d2d/pyzmq-26.2.1-pp38-pypy38_pp73-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:0f50db737d688e96ad2a083ad2b453e22865e7e19c7f17d17df416e91ddf67eb", size = 762214 }, + { url = "https://files.pythonhosted.org/packages/ed/89/641e79c58155d8093e4f9acce823121d2402b5ed8a6bf1b5f3c47a2586fa/pyzmq-26.2.1-pp38-pypy38_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a003200b6cd64e89b5725ff7e284a93ab24fd54bbac8b4fa46b1ed57be693c27", size = 570989 }, + { url = "https://files.pythonhosted.org/packages/3a/b2/439341a8304f4a99027a4170349638e9ff0063bbc97bbf2104d53b7e13b3/pyzmq-26.2.1-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:f9ba5def063243793dec6603ad1392f735255cbc7202a3a484c14f99ec290705", size = 556559 }, + { url = "https://files.pythonhosted.org/packages/d9/6b/f27dfd4b7b3d6a8bd39ab1469fb8f8685c597d6772cbf3b39b1c4d798eee/pyzmq-26.2.1-pp39-pypy39_pp73-macosx_10_15_x86_64.whl", hash = "sha256:1238c2448c58b9c8d6565579393148414a42488a5f916b3f322742e561f6ae0d", size = 847735 }, + { url = "https://files.pythonhosted.org/packages/f5/1f/fe0698f36c619bc960e97efe9a8ece412a7dc4c80e0bd603cde81731c6ca/pyzmq-26.2.1-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8eddb3784aed95d07065bcf94d07e8c04024fdb6b2386f08c197dfe6b3528fda", size = 570986 }, + { url = "https://files.pythonhosted.org/packages/91/2e/f7f6c00d16db2b1936f3cd3b8362c391e40dd16a646b92ebf2f3b28206ee/pyzmq-26.2.1-pp39-pypy39_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f0f19c2097fffb1d5b07893d75c9ee693e9cbc809235cf3f2267f0ef6b015f24", size = 799658 }, + { url = "https://files.pythonhosted.org/packages/50/98/aa114911fcb65645099d6db5694a49975ef442f2c34532ea5365b6ec6da8/pyzmq-26.2.1-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0995fd3530f2e89d6b69a2202e340bbada3191014352af978fa795cb7a446331", size = 758151 }, + { url = "https://files.pythonhosted.org/packages/53/58/9909ad7a3112999a30464c5c92937c9eec5f5e6905a1eee45fd99788ce56/pyzmq-26.2.1-pp39-pypy39_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:7c6160fe513654e65665332740f63de29ce0d165e053c0c14a161fa60dd0da01", size = 756685 }, + { url = "https://files.pythonhosted.org/packages/01/28/1c0f44e609b91a1168aaf4ac38511645fd725593b41cd54ef06744d502ff/pyzmq-26.2.1-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:8ec8e3aea6146b761d6c57fcf8f81fcb19f187afecc19bf1701a48db9617a217", size = 556558 }, +] + +[[package]] +name = "pyzmq" +version = "26.3.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", + "python_full_version == '3.10.*'", + "python_full_version == '3.9.*'", + "python_full_version == '3.8.*'", +] +dependencies = [ + { name = "cffi", version = "1.17.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.8' and implementation_name == 'pypy'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/3a/ed/c3876f3b3e8beba336214ce44e1efa1792dd537027cef24192ac2b077d7c/pyzmq-26.3.0.tar.gz", hash = "sha256:f1cd68b8236faab78138a8fc703f7ca0ad431b17a3fcac696358600d4e6243b3", size = 276733 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/41/a8/cc21dcd6f0f96dbd636fcaab345f9664cd54e6577a21a74694202479d3fa/pyzmq-26.3.0-cp310-cp310-macosx_10_15_universal2.whl", hash = "sha256:1586944f4736515af5c6d3a5b150c7e8ca2a2d6e46b23057320584d6f2438f4a", size = 1345312 }, + { url = "https://files.pythonhosted.org/packages/0b/6d/7e0e52798697536d572a105849c4ab621ca00511674b6ce694cb05e437fc/pyzmq-26.3.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:aa7efc695d1fc9f72d91bf9b6c6fe2d7e1b4193836ec530a98faf7d7a7577a58", size = 678336 }, + { url = "https://files.pythonhosted.org/packages/91/86/8914875e2341a40da460feaa9cace727e50a6b640a20ac36186686bde7d9/pyzmq-26.3.0-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:bd84441e4021cec6e4dd040550386cd9c9ea1d9418ea1a8002dbb7b576026b2b", size = 916965 }, + { url = "https://files.pythonhosted.org/packages/9a/59/72b390b31ed0cc825881435f21baaae9d57e263aba526fa833863b90d667/pyzmq-26.3.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9176856f36c34a8aa5c0b35ddf52a5d5cd8abeece57c2cd904cfddae3fd9acd3", size = 874003 }, + { url = "https://files.pythonhosted.org/packages/97/d4/4dd152dbbaac35d4e1fe8e8fd26d73640fcd84ec9c3915b545692df1ffb7/pyzmq-26.3.0-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:49334faa749d55b77f084389a80654bf2e68ab5191c0235066f0140c1b670d64", size = 867989 }, + { url = "https://files.pythonhosted.org/packages/a4/22/1c5dc761dff13981d27d8225aedb19e70ce9149d16cf0c97c7547570e986/pyzmq-26.3.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:fd30fc80fe96efb06bea21667c5793bbd65c0dc793187feb39b8f96990680b00", size = 1207989 }, + { url = "https://files.pythonhosted.org/packages/03/89/227ffb9e30b3fbe8196e7c97704345feb750b468e852ab64b0d19fa89e1a/pyzmq-26.3.0-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:b2eddfbbfb473a62c3a251bb737a6d58d91907f6e1d95791431ebe556f47d916", size = 1520523 }, + { url = "https://files.pythonhosted.org/packages/29/d3/e9b99b8404b6a470762cb947bc342e462a853a22ce0b0f2982c65a9b698f/pyzmq-26.3.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:70b3acb9ad729a53d4e751dace35404a024f188aad406013454216aba5485b4e", size = 1419912 }, + { url = "https://files.pythonhosted.org/packages/bb/69/074e2cde8135cae9452778e644ea5c91493bc536367d956005fe83072f63/pyzmq-26.3.0-cp310-cp310-win32.whl", hash = "sha256:c1bd75d692cd7c6d862a98013bfdf06702783b75cffbf5dae06d718fecefe8f2", size = 583733 }, + { url = "https://files.pythonhosted.org/packages/00/f0/55e57d40f6e21877e96507c0c2dd7e32afffc37b0dde7b834df1170cd749/pyzmq-26.3.0-cp310-cp310-win_amd64.whl", hash = "sha256:d7165bcda0dbf203e5ad04d79955d223d84b2263df4db92f525ba370b03a12ab", size = 647229 }, + { url = "https://files.pythonhosted.org/packages/38/1d/6e935b5f06d674c931540b29932a0dd5e1b9d29d047c2764a9c8c6f3ce08/pyzmq-26.3.0-cp310-cp310-win_arm64.whl", hash = "sha256:e34a63f71d2ecffb3c643909ad2d488251afeb5ef3635602b3448e609611a7ed", size = 561038 }, + { url = "https://files.pythonhosted.org/packages/22/75/774e9a4a4291864dd37a03a7bfaf46a82d61cd36c16edd33a5739ad49be3/pyzmq-26.3.0-cp311-cp311-macosx_10_15_universal2.whl", hash = "sha256:2833602d9d42c94b9d0d2a44d2b382d3d3a4485be018ba19dddc401a464c617a", size = 1345893 }, + { url = "https://files.pythonhosted.org/packages/ca/51/d3eedd2bd46ef851bea528d8a2688a5091183b27fc238801fcac70e80dbb/pyzmq-26.3.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d8270d104ec7caa0bdac246d31d48d94472033ceab5ba142881704350b28159c", size = 678261 }, + { url = "https://files.pythonhosted.org/packages/de/5e/521d7c6613769dcc3ed5e44e7082938b6dab27fffe02755784e54e98e17b/pyzmq-26.3.0-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c208a977843d18d3bd185f323e4eaa912eb4869cb230947dc6edd8a27a4e558a", size = 915311 }, + { url = "https://files.pythonhosted.org/packages/78/db/3be86dd82adc638a2eb07c3028c1747ead49a71d7d334980b007f593fd9f/pyzmq-26.3.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eddc2be28a379c218e0d92e4a432805dcb0ca5870156a90b54c03cd9799f9f8a", size = 873193 }, + { url = "https://files.pythonhosted.org/packages/63/1a/81a31920d5113113ccd50271649dd2d0cfcfe46925d8f8a196fe560ed0e6/pyzmq-26.3.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:c0b519fa2159c42272f8a244354a0e110d65175647e5185b04008ec00df9f079", size = 867648 }, + { url = "https://files.pythonhosted.org/packages/55/79/bbf57979ff2d89b5465d7205db08de7222d2560edc11272eb054c5a68cb5/pyzmq-26.3.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:1595533de3a80bf8363372c20bafa963ec4bf9f2b8f539b1d9a5017f430b84c9", size = 1208475 }, + { url = "https://files.pythonhosted.org/packages/50/fc/1246dfc4b165e7ff97ac3c4117bdd3747e03ebb62269f71f65e216bfac8b/pyzmq-26.3.0-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:bbef99eb8d18ba9a40f00e8836b8040cdcf0f2fa649684cf7a66339599919d21", size = 1519428 }, + { url = "https://files.pythonhosted.org/packages/5f/9a/143aacb6b372b0e2d812aec73a06fc5df3e169a361d4302226f8563954c6/pyzmq-26.3.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:979486d444ca3c469cd1c7f6a619ce48ff08b3b595d451937db543754bfacb65", size = 1419530 }, + { url = "https://files.pythonhosted.org/packages/47/f7/b437e77d496089e17e77866eb126dd97ea47041b58e53892f57e82869198/pyzmq-26.3.0-cp311-cp311-win32.whl", hash = "sha256:4b127cfe10b4c56e4285b69fd4b38ea1d368099ea4273d8fb349163fce3cd598", size = 582538 }, + { url = "https://files.pythonhosted.org/packages/a1/2c/99a01a2d7865aaf44e47c2182cbdbc15da1f2e4cfee92dc8e1fb5114f993/pyzmq-26.3.0-cp311-cp311-win_amd64.whl", hash = "sha256:cf736cc1298ef15280d9fcf7a25c09b05af016656856dc6fe5626fd8912658dd", size = 647989 }, + { url = "https://files.pythonhosted.org/packages/60/b3/36ac1cb8fafeadff09935f4bdc1232e511af8f8893d6cebc7ceb93c6753a/pyzmq-26.3.0-cp311-cp311-win_arm64.whl", hash = "sha256:2dc46ec09f5d36f606ac8393303149e69d17121beee13c8dac25e2a2078e31c4", size = 561533 }, + { url = "https://files.pythonhosted.org/packages/7b/03/7170c3814bb9106c1bca67700c731aaf1cd990fd2f0097c754acb600330e/pyzmq-26.3.0-cp312-cp312-macosx_10_15_universal2.whl", hash = "sha256:c80653332c6136da7f4d4e143975e74ac0fa14f851f716d90583bc19e8945cea", size = 1348354 }, + { url = "https://files.pythonhosted.org/packages/74/f3/908b17f9111cdc764aef1de3d36026a2984c46ed90c3c2c85f28b66142f0/pyzmq-26.3.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6e317ee1d4528a03506cb1c282cd9db73660a35b3564096de37de7350e7d87a7", size = 671056 }, + { url = "https://files.pythonhosted.org/packages/02/ad/afcb8484b65ceacd1609f709c2caeed31bd6c49261a7507cd5c175cc105f/pyzmq-26.3.0-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:943a22ebb3daacb45f76a9bcca9a7b74e7d94608c0c0505da30af900b998ca8d", size = 908597 }, + { url = "https://files.pythonhosted.org/packages/a1/b5/4eeeae0aaaa6ef0c74cfa8b2273b53382bd858df6d99485f2fc8211e7002/pyzmq-26.3.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3fc9e71490d989144981ea21ef4fdfaa7b6aa84aff9632d91c736441ce2f6b00", size = 865260 }, + { url = "https://files.pythonhosted.org/packages/74/6a/63db856e93e3a3c3dc98a1de28a902cf1b21c7b0d3856cd5931d7cfd30af/pyzmq-26.3.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:e281a8071a06888575a4eb523c4deeefdcd2f5fe4a2d47e02ac8bf3a5b49f695", size = 859916 }, + { url = "https://files.pythonhosted.org/packages/e1/ce/d522c9b46ee3746d4b98c81969c568c2c6296e931a65f2c87104b645654c/pyzmq-26.3.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:be77efd735bb1064605be8dec6e721141c1421ef0b115ef54e493a64e50e9a52", size = 1201368 }, + { url = "https://files.pythonhosted.org/packages/5a/56/29dcd3647a39e933eb489fda261a1e2700a59d4a9432889a85166e15651c/pyzmq-26.3.0-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:7a4ac2ffa34f1212dd586af90f4ba894e424f0cabb3a49cdcff944925640f6ac", size = 1512663 }, + { url = "https://files.pythonhosted.org/packages/6b/36/7c570698127a43398ed1b1832dada59496e633115016addbce5eda9938a6/pyzmq-26.3.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:ba698c7c252af83b6bba9775035263f0df5f807f0404019916d4b71af8161f66", size = 1411693 }, + { url = "https://files.pythonhosted.org/packages/de/54/51d39bef85a7cdbca36227f7defdbfcdc5011b8361a3bfc0e8df431f5a5d/pyzmq-26.3.0-cp312-cp312-win32.whl", hash = "sha256:214038aaa88e801e54c2ef0cfdb2e6df27eb05f67b477380a452b595c5ecfa37", size = 581244 }, + { url = "https://files.pythonhosted.org/packages/f2/6a/9512b11a1d0c5648534f03d5ab0c3222f55dc9c192029c1cb00a0ca044e2/pyzmq-26.3.0-cp312-cp312-win_amd64.whl", hash = "sha256:bad7fe0372e505442482ca3ccbc0d6f38dae81b1650f57a0aa6bbee18e7df495", size = 643559 }, + { url = "https://files.pythonhosted.org/packages/27/9f/faf5c9cf91b61eeb82a5e919d024d3ac28a795c92cce817be264ccd757d3/pyzmq-26.3.0-cp312-cp312-win_arm64.whl", hash = "sha256:b7b578d604e79e99aa39495becea013fd043fa9f36e4b490efa951f3d847a24d", size = 557664 }, + { url = "https://files.pythonhosted.org/packages/37/16/97b8c5107bfccb39120e611671a452c9ff6e8626fb3f8d4c15afd652b6ae/pyzmq-26.3.0-cp313-cp313-macosx_10_15_universal2.whl", hash = "sha256:fa85953df84beb7b8b73cb3ec3f5d92b62687a09a8e71525c6734e020edf56fd", size = 1345691 }, + { url = "https://files.pythonhosted.org/packages/a5/61/d5572d95040c0bb5b31eed5b23f3f0f992d94e4e0de0cea62e3c7f3a85c1/pyzmq-26.3.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:209d09f0ab6ddbcebe64630d1e6ca940687e736f443c265ae15bc4bfad833597", size = 670622 }, + { url = "https://files.pythonhosted.org/packages/1c/0c/f0235d27388aacf4ed8bcc1d574f6f2f629da0a20610faa0a8e9d363c2b0/pyzmq-26.3.0-cp313-cp313-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d35cc1086f1d4f907df85c6cceb2245cb39a04f69c3f375993363216134d76d4", size = 908683 }, + { url = "https://files.pythonhosted.org/packages/cb/52/664828f9586c396b857eec088d208230463e3dc991a24df6adbad98fbaa3/pyzmq-26.3.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b380e9087078ba91e45fb18cdd0c25275ffaa045cf63c947be0ddae6186bc9d9", size = 865212 }, + { url = "https://files.pythonhosted.org/packages/2b/14/213b2967030b7d7aecc32dd453830f98799b3cbf2b10a40232e9f22a6520/pyzmq-26.3.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:6d64e74143587efe7c9522bb74d1448128fdf9897cc9b6d8b9927490922fd558", size = 860068 }, + { url = "https://files.pythonhosted.org/packages/aa/e5/ff50c8fade69d1c0469652832c626d1910668697642c10cb0e1b6183ef9a/pyzmq-26.3.0-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:efba4f53ac7752eea6d8ca38a4ddac579e6e742fba78d1e99c12c95cd2acfc64", size = 1201303 }, + { url = "https://files.pythonhosted.org/packages/9a/e2/fff5e483be95ccc11a05781323e001e63ec15daec1d0f6f08de72ca534db/pyzmq-26.3.0-cp313-cp313-musllinux_1_1_i686.whl", hash = "sha256:9b0137a1c40da3b7989839f9b78a44de642cdd1ce20dcef341de174c8d04aa53", size = 1512892 }, + { url = "https://files.pythonhosted.org/packages/21/75/cc44d276e43136e5692e487c3c019f816e11ed445261e434217c28cc98c4/pyzmq-26.3.0-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:a995404bd3982c089e57b428c74edd5bfc3b0616b3dbcd6a8e270f1ee2110f36", size = 1411736 }, + { url = "https://files.pythonhosted.org/packages/ee/1c/d070cbc9a7961fe772641c51bb3798d88cb1f8e20ca718407363462624cf/pyzmq-26.3.0-cp313-cp313-win32.whl", hash = "sha256:240b1634b9e530ef6a277d95cbca1a6922f44dfddc5f0a3cd6c722a8de867f14", size = 581214 }, + { url = "https://files.pythonhosted.org/packages/38/d3/91082f1151ff5b54e0bed40eb1a26f418530ab07ecaec4dbb83e3d9fa9a9/pyzmq-26.3.0-cp313-cp313-win_amd64.whl", hash = "sha256:fe67291775ea4c2883764ba467eb389c29c308c56b86c1e19e49c9e1ed0cbeca", size = 643412 }, + { url = "https://files.pythonhosted.org/packages/e0/cf/dabe68dfdf3e67bea6152eeec4b251cf899ee5b853cfb5c97e4719f9e6e9/pyzmq-26.3.0-cp313-cp313-win_arm64.whl", hash = "sha256:73ca9ae9a9011b714cf7650450cd9c8b61a135180b708904f1f0a05004543dce", size = 557444 }, + { url = "https://files.pythonhosted.org/packages/c0/56/e7576ac71c1566da4f4ec586351462a2bb202143fb074bf56df8fe85dcc3/pyzmq-26.3.0-cp313-cp313t-macosx_10_15_universal2.whl", hash = "sha256:fea7efbd7e49af9d7e5ed6c506dfc7de3d1a628790bd3a35fd0e3c904dc7d464", size = 1340288 }, + { url = "https://files.pythonhosted.org/packages/f1/ab/0bca97e94d420b5908968bc479e51c3686a9f80d8893450eefcd673b1b1d/pyzmq-26.3.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c4430c7cba23bb0e2ee203eee7851c1654167d956fc6d4b3a87909ccaf3c5825", size = 662462 }, + { url = "https://files.pythonhosted.org/packages/ee/be/99e89b55863808da322ac3ab52d8e135dcf2241094aaa468bfe2923d5194/pyzmq-26.3.0-cp313-cp313t-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:016d89bee8c7d566fad75516b4e53ec7c81018c062d4c51cd061badf9539be52", size = 896464 }, + { url = "https://files.pythonhosted.org/packages/38/d4/a4be06a313c8d6a5fe1d92975db30aca85f502e867fca392532e06a28c3c/pyzmq-26.3.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:04bfe59852d76d56736bfd10ac1d49d421ab8ed11030b4a0332900691507f557", size = 853432 }, + { url = "https://files.pythonhosted.org/packages/12/e6/e608b4c34106bbf5b3b382662ea90a43b2e23df0aa9c1f0fd4e21168d523/pyzmq-26.3.0-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:1fe05bd0d633a0f672bb28cb8b4743358d196792e1caf04973b7898a0d70b046", size = 845884 }, + { url = "https://files.pythonhosted.org/packages/c3/a9/d5e6355308ba529d9cd3576ee8bb3b2e2b726571748f515fbb8559401f5b/pyzmq-26.3.0-cp313-cp313t-musllinux_1_1_aarch64.whl", hash = "sha256:2aa1a9f236d5b835fb8642f27de95f9edcfd276c4bc1b6ffc84f27c6fb2e2981", size = 1191454 }, + { url = "https://files.pythonhosted.org/packages/6a/9a/a21dc6c73ac242e425709c1e0049368d8f5db5de7c1102a45f93f5c492b3/pyzmq-26.3.0-cp313-cp313t-musllinux_1_1_i686.whl", hash = "sha256:21399b31753bf321043ea60c360ed5052cc7be20739785b1dff1820f819e35b3", size = 1500397 }, + { url = "https://files.pythonhosted.org/packages/87/88/0236056156da0278c9ca2e2562463643597808b5bbd6c34009ba217e7e92/pyzmq-26.3.0-cp313-cp313t-musllinux_1_1_x86_64.whl", hash = "sha256:d015efcd96aca8882057e7e6f06224f79eecd22cad193d3e6a0a91ec67590d1f", size = 1398401 }, + { url = "https://files.pythonhosted.org/packages/54/1a/6ca6e1b0543c04cf6424962603ceb041c172fd4a82cbb897ce4ba55c82e3/pyzmq-26.3.0-cp38-cp38-macosx_10_15_universal2.whl", hash = "sha256:18183cc3851b995fdc7e5f03d03b8a4e1b12b0f79dff1ec1da75069af6357a05", size = 1345726 }, + { url = "https://files.pythonhosted.org/packages/7d/34/58acebfaa6d27263f6ca2d645953cf5dfbc4ed27b9a21aaabb5b9c11fc11/pyzmq-26.3.0-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:da87e977f92d930a3683e10ba2b38bcc59adfc25896827e0b9d78b208b7757a6", size = 912878 }, + { url = "https://files.pythonhosted.org/packages/d8/b3/b3e7cfcb2b1d133e336dc65a417f7a5e779f9d6749d156e7c0e6851e1274/pyzmq-26.3.0-cp38-cp38-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:cf6db401f4957afbf372a4730c6d5b2a234393af723983cbf4bcd13d54c71e1a", size = 867535 }, + { url = "https://files.pythonhosted.org/packages/ec/7c/b49b6acf30b7b16726520ede567fd32325a769d975788cb665b57bde700e/pyzmq-26.3.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:03caa2ffd64252122139d50ec92987f89616b9b92c9ba72920b40e92709d5e26", size = 679017 }, + { url = "https://files.pythonhosted.org/packages/0e/0d/42a2a36287a9005b7746344d1634e1441eec761610f3231a0606e8b57cec/pyzmq-26.3.0-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:fbf206e5329e20937fa19bd41cf3af06d5967f8f7e86b59d783b26b40ced755c", size = 1212128 }, + { url = "https://files.pythonhosted.org/packages/1c/09/6bb8f31de78536ddd707f1069234e7282b45cf580d39262736a44c303dbf/pyzmq-26.3.0-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:6fb539a6382a048308b409d8c66d79bf636eda1b24f70c78f2a1fd16e92b037b", size = 1521409 }, + { url = "https://files.pythonhosted.org/packages/8e/f0/8436f501f403ab8051f3d53c3848a2f797e866ec1a2bdf26f609904497a6/pyzmq-26.3.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:7897b8c8bbbb2bd8cad887bffcb07aede71ef1e45383bd4d6ac049bf0af312a4", size = 1422681 }, + { url = "https://files.pythonhosted.org/packages/10/6e/27ff3b1a0b18de39ccb672074c8c49b0162b186cdbc55e9b88bca0ee0541/pyzmq-26.3.0-cp38-cp38-win32.whl", hash = "sha256:91dead2daca698ae52ce70ee2adbb94ddd9b5f96877565fd40aa4efd18ecc6a3", size = 583604 }, + { url = "https://files.pythonhosted.org/packages/d2/78/687a2d84de4552298df032d61c1fb3fbac579e8b8d8bf8b4aa4b8e76525d/pyzmq-26.3.0-cp38-cp38-win_amd64.whl", hash = "sha256:8c088e009a6d6b9f563336adb906e3a8d3fd64db129acc8d8fd0e9fe22b2dac8", size = 648130 }, + { url = "https://files.pythonhosted.org/packages/98/53/870b45d284f8be945a05ea3b70b56fe92538f13305d75362a39256e0c57b/pyzmq-26.3.0-cp39-cp39-macosx_10_15_universal2.whl", hash = "sha256:2eaed0d911fb3280981d5495978152fab6afd9fe217fd16f411523665089cef1", size = 1346508 }, + { url = "https://files.pythonhosted.org/packages/6b/d4/622e418729762c4957ec87639105e15398a919a2068a18a4c2ea17caa504/pyzmq-26.3.0-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:7998b60ef1c105846fb3bfca494769fde3bba6160902e7cd27a8df8257890ee9", size = 913284 }, + { url = "https://files.pythonhosted.org/packages/9a/63/a4b7f92a50821996ecd3520c5360fdc70df37918dd5c813ebbecad7bd56f/pyzmq-26.3.0-cp39-cp39-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:96c0006a8d1d00e46cb44c8e8d7316d4a232f3d8f2ed43179d4578dbcb0829b6", size = 867321 }, + { url = "https://files.pythonhosted.org/packages/30/41/5b22f376e25b3dfbb8bc9c145a1a8cd8418ecc5e310a18402bff16dfb018/pyzmq-26.3.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5e17cc198dc50a25a0f245e6b1e56f692df2acec3ccae82d1f60c34bfb72bbec", size = 678889 }, + { url = "https://files.pythonhosted.org/packages/64/50/4f727469fb52230449f28b6d6a027c1e5c107b46c60c9e90b3ed3c7e492d/pyzmq-26.3.0-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:92a30840f4f2a31f7049d0a7de5fc69dd03b19bd5d8e7fed8d0bde49ce49b589", size = 1208802 }, + { url = "https://files.pythonhosted.org/packages/26/9d/290f43cb3953f1f74834470447baa849f6224296986f1e2d774bdcce26e1/pyzmq-26.3.0-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:f52eba83272a26b444f4b8fc79f2e2c83f91d706d693836c9f7ccb16e6713c31", size = 1521092 }, + { url = "https://files.pythonhosted.org/packages/aa/b5/261749d5b9a9fd9a32eb4eebddce0e46e720d14f4565b55d62bc004bcae9/pyzmq-26.3.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:952085a09ff32115794629ba47f8940896d7842afdef1283332109d38222479d", size = 1420582 }, + { url = "https://files.pythonhosted.org/packages/b8/d5/65e00583641b1060b21d350716eb9539a626a665a87921710a7e3ebde592/pyzmq-26.3.0-cp39-cp39-win32.whl", hash = "sha256:0240289e33e3fbae44a5db73e54e955399179332a6b1d47c764a4983ec1524c3", size = 584172 }, + { url = "https://files.pythonhosted.org/packages/71/23/c51f63a78bf5a039be26eccda1d2040b83553189daf82378c71a33f60caa/pyzmq-26.3.0-cp39-cp39-win_amd64.whl", hash = "sha256:b2db7c82f08b8ce44c0b9d1153ce63907491972a7581e8b6adea71817f119df8", size = 647715 }, + { url = "https://files.pythonhosted.org/packages/27/67/aae0809e3806f8bbcf679dbf1874f7e0efb5d957cfbb66e907c4f45d79b9/pyzmq-26.3.0-cp39-cp39-win_arm64.whl", hash = "sha256:2d3459b6311463c96abcb97808ee0a1abb0d932833edb6aa81c30d622fd4a12d", size = 561557 }, + { url = "https://files.pythonhosted.org/packages/7e/ec/2e02dde6b1a436b02a6c0e3cb64c779bf6e76cc41c12131f29d9b10a088f/pyzmq-26.3.0-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:ad03f4252d9041b0635c37528dfa3f44b39f46024ae28c8567f7423676ee409b", size = 835672 }, + { url = "https://files.pythonhosted.org/packages/22/ee/30c2c3f162912cff31af2b9d87295533d16f867e7621bd6f9ed62d9cc807/pyzmq-26.3.0-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0f3dfb68cf7bf4cfdf34283a75848e077c5defa4907506327282afe92780084d", size = 570837 }, + { url = "https://files.pythonhosted.org/packages/51/a5/5aead624f5f1033dab9bdaf3e2bc692a8042fcb59355c919a2c042061780/pyzmq-26.3.0-pp310-pypy310_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:356ec0e39c5a9cda872b65aca1fd8a5d296ffdadf8e2442b70ff32e73ef597b1", size = 799508 }, + { url = "https://files.pythonhosted.org/packages/ca/8a/dcc0a24cfed80cc004abcba710077147ec9178a12865914e73a60a70cb62/pyzmq-26.3.0-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:749d671b0eec8e738bbf0b361168369d8c682b94fcd458c20741dc4d69ef5278", size = 758001 }, + { url = "https://files.pythonhosted.org/packages/1a/74/f18e63540340f5c740396eb6408d154a84e9f0e9e1ae931b192bf2aa7425/pyzmq-26.3.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:f950f17ae608e0786298340163cac25a4c5543ef25362dd5ddb6dcb10b547be9", size = 556425 }, + { url = "https://files.pythonhosted.org/packages/f4/c6/e36b2a2ff6534cb1d1f6b3fb37901ac54675caf7b2e1239613aa40d1d217/pyzmq-26.3.0-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:b4fc9903a73c25be9d5fe45c87faababcf3879445efa16140146b08fccfac017", size = 835670 }, + { url = "https://files.pythonhosted.org/packages/1d/b9/8059c5af94b245068e7f7379c08c7e409ec854139d6021aecf2c111d8547/pyzmq-26.3.0-pp311-pypy311_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c15b69af22030960ac63567e98ad8221cddf5d720d9cf03d85021dfd452324ef", size = 570838 }, + { url = "https://files.pythonhosted.org/packages/80/a4/f0a4266ff2d94a87f7c32895b1716f9ac0edc0471d518462beeb0a9a94b5/pyzmq-26.3.0-pp311-pypy311_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:2cf9ab0dff4dbaa2e893eb608373c97eb908e53b7d9793ad00ccbd082c0ee12f", size = 799507 }, + { url = "https://files.pythonhosted.org/packages/78/14/3d7d459f496fab8e487b23423ccba57abf7153a4fde0c3e000500fa02ff8/pyzmq-26.3.0-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3ec332675f6a138db57aad93ae6387953763f85419bdbd18e914cb279ee1c451", size = 758002 }, + { url = "https://files.pythonhosted.org/packages/22/65/cc1f0e1db1290770285430e36d51767e620487523e6a04094be637e55698/pyzmq-26.3.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:eb96568a22fe070590942cd4780950e2172e00fb033a8b76e47692583b1bd97c", size = 556425 }, + { url = "https://files.pythonhosted.org/packages/8d/be/64d4ec9ba83b3be79e4f9200e2b0fa35b6d2874a80db59beb1e71c2baca2/pyzmq-26.3.0-pp38-pypy38_pp73-macosx_10_15_x86_64.whl", hash = "sha256:009a38241c76184cb004c869e82a99f0aee32eda412c1eb44df5820324a01d25", size = 835654 }, + { url = "https://files.pythonhosted.org/packages/cb/d1/d7ada20be537d485a3bdda2fd3bbe62a132a8356b609aee190e3382f09c8/pyzmq-26.3.0-pp38-pypy38_pp73-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:4c22a12713707467abedc6d75529dd365180c4c2a1511268972c6e1d472bd63e", size = 807293 }, + { url = "https://files.pythonhosted.org/packages/b5/cf/805cff77edc18f09ffa20814355d79fbe0e860b067aafa3e3326edaf457c/pyzmq-26.3.0-pp38-pypy38_pp73-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:1614fcd116275d24f2346ffca4047a741c546ad9d561cbf7813f11226ca4ed2c", size = 762066 }, + { url = "https://files.pythonhosted.org/packages/f2/b6/719b4b63d5f1dcd219b8b3209c301cc9a78dec6b1c3dc0c1c777547ed45c/pyzmq-26.3.0-pp38-pypy38_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4e2cafe7e9c7fed690e8ecf65af119f9c482923b5075a78f6f7629c63e1b4b1d", size = 570834 }, + { url = "https://files.pythonhosted.org/packages/5b/0e/e4cd451f8c759ae248fd9c4779dd2e75919b9286c574d8031f7fea0957c5/pyzmq-26.3.0-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:14e0b81753424bd374075df6cc30b87f2c99e5f022501d97eff66544ca578941", size = 556419 }, + { url = "https://files.pythonhosted.org/packages/31/dc/d35ccb541761f9e55d07a3e42f126b28fed86bb9e0e7682cabef0641f552/pyzmq-26.3.0-pp39-pypy39_pp73-macosx_10_15_x86_64.whl", hash = "sha256:21c6ddb98557a77cfe3366af0c5600fb222a1b2de5f90d9cd052b324e0c295e8", size = 835669 }, + { url = "https://files.pythonhosted.org/packages/c8/45/78c3b0f048c7da7bab68884304e7535e453daf19ac09ab12639e52aadd27/pyzmq-26.3.0-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1fc81d5d60c9d40e692de14b8d884d43cf67562402b931681f0ccb3ce6b19875", size = 570834 }, + { url = "https://files.pythonhosted.org/packages/95/07/b23e5158ef143f06f07d29f1e76f5378b929c77b10f117ba2369fb5298a5/pyzmq-26.3.0-pp39-pypy39_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:52b064fafef772d0f5dbf52d4c39f092be7bc62d9a602fe6e82082e001326de3", size = 799504 }, + { url = "https://files.pythonhosted.org/packages/a0/47/a7d1b2b1f1cade45833a49c0ba7bc9455ad8c796ef56652c6b43522750eb/pyzmq-26.3.0-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b72206eb041f780451c61e1e89dbc3705f3d66aaaa14ee320d4f55864b13358a", size = 757996 }, + { url = "https://files.pythonhosted.org/packages/0d/0f/ac17e43312dd2d3a127962378320480371433907db1335df11b0b63ac314/pyzmq-26.3.0-pp39-pypy39_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:8ab78dc21c7b1e13053086bcf0b4246440b43b5409904b73bfd1156654ece8a1", size = 746636 }, + { url = "https://files.pythonhosted.org/packages/3a/7c/2acf02fd523163d4d5a9d528ecd4a5764de05a4dc9162f33de7385d3109c/pyzmq-26.3.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:0b42403ad7d1194dca9574cd3c56691c345f4601fa2d0a33434f35142baec7ac", size = 556417 }, +] + +[[package]] +name = "quartodoc" +version = "0.9.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "black", marker = "python_full_version >= '3.9'" }, + { name = "click", marker = "python_full_version >= '3.9'" }, + { name = "griffe", marker = "python_full_version >= '3.9'" }, + { name = "importlib-metadata", version = "8.6.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.9'" }, + { name = "importlib-resources", version = "6.5.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.9'" }, + { name = "plum-dispatch", version = "1.7.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*'" }, + { name = "plum-dispatch", version = "2.5.7", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, + { name = "pydantic", marker = "python_full_version >= '3.9'" }, + { name = "pyyaml", version = "6.0.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.9'" }, + { name = "requests", version = "2.32.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.9'" }, + { name = "sphobjinv", marker = "python_full_version >= '3.9'" }, + { name = "tabulate", marker = "python_full_version >= '3.9'" }, + { name = "typing-extensions", version = "4.12.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.9'" }, + { name = "watchdog", marker = "python_full_version >= '3.9'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/f4/ad/1bdc6745d0d0527da0a2f30a235850873e98442a2c1afdd67ac7e164e0c4/quartodoc-0.9.1.tar.gz", hash = "sha256:418d9ff0f2d4481a87e926e3a3e5bc31efbe556c7f36912aa0a3f716c0eafa9c", size = 772465 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0e/47/de4c28e2002653226de3e34c9a3e989619796e5f0fe771284c570a016cec/quartodoc-0.9.1-py3-none-any.whl", hash = "sha256:78345002f75f086be6e1b1ccf3b4e3ada2fa3affb8a8fc0dbdb37890a5da03fa", size = 84275 }, +] + +[[package]] +name = "referencing" +version = "0.35.1" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version == '3.8.*'", +] +dependencies = [ + { name = "attrs", version = "25.3.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.8.*'" }, + { name = "rpds-py", version = "0.20.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.8.*'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/99/5b/73ca1f8e72fff6fa52119dbd185f73a907b1989428917b24cff660129b6d/referencing-0.35.1.tar.gz", hash = "sha256:25b42124a6c8b632a425174f24087783efb348a6f1e0008e63cd4466fedf703c", size = 62991 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b7/59/2056f61236782a2c86b33906c025d4f4a0b17be0161b63b70fd9e8775d36/referencing-0.35.1-py3-none-any.whl", hash = "sha256:eda6d3234d62814d1c64e305c1331c9a3a6132da475ab6382eaa997b21ee75de", size = 26684 }, +] + +[[package]] +name = "referencing" +version = "0.36.2" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", + "python_full_version == '3.10.*'", + "python_full_version == '3.9.*'", +] +dependencies = [ + { name = "attrs", version = "25.3.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.9'" }, + { name = "rpds-py", version = "0.23.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.9'" }, + { name = "typing-extensions", version = "4.12.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.9' and python_full_version < '3.13'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/2f/db/98b5c277be99dd18bfd91dd04e1b759cad18d1a338188c936e92f921c7e2/referencing-0.36.2.tar.gz", hash = "sha256:df2e89862cd09deabbdba16944cc3f10feb6b3e6f18e902f7cc25609a34775aa", size = 74744 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c1/b1/3baf80dc6d2b7bc27a95a67752d0208e410351e3feb4eb78de5f77454d8d/referencing-0.36.2-py3-none-any.whl", hash = "sha256:e8699adbbf8b5c7de96d8ffa0eb5c158b3beafce084968e2ea8bb08c6794dcd0", size = 26775 }, +] + +[[package]] +name = "requests" +version = "2.31.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine != 'aarch64' and platform_machine != 'arm64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'aarch64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'arm64'", + "python_full_version < '3.7.1'", +] +dependencies = [ + { name = "certifi", marker = "python_full_version < '3.8'" }, + { name = "charset-normalizer", marker = "python_full_version < '3.8'" }, + { name = "idna", marker = "python_full_version < '3.8'" }, + { name = "urllib3", version = "2.0.7", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/9d/be/10918a2eac4ae9f02f6cfe6414b7a155ccd8f7f9d4380d62fd5b955065c3/requests-2.31.0.tar.gz", hash = "sha256:942c5a758f98d790eaed1a29cb6eefc7ffb0d1cf7af05c3d2791656dbd6ad1e1", size = 110794 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/70/8e/0e2d847013cb52cd35b38c009bb167a1a26b2ce6cd6965bf26b47bc0bf44/requests-2.31.0-py3-none-any.whl", hash = "sha256:58cd2187c01e70e6e26505bca751777aa9f2ee0b7f4300988b709f44e013003f", size = 62574 }, +] + +[[package]] +name = "requests" +version = "2.32.3" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", + "python_full_version == '3.10.*'", + "python_full_version == '3.9.*'", + "python_full_version == '3.8.*'", +] +dependencies = [ + { name = "certifi", marker = "python_full_version >= '3.8'" }, + { name = "charset-normalizer", marker = "python_full_version >= '3.8'" }, + { name = "idna", marker = "python_full_version >= '3.8'" }, + { name = "urllib3", version = "2.2.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.8.*'" }, + { name = "urllib3", version = "2.3.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.9'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/63/70/2bf7780ad2d390a8d301ad0b550f1581eadbd9a20f896afe06353c2a2913/requests-2.32.3.tar.gz", hash = "sha256:55365417734eb18255590a9ff9eb97e9e1da868d4ccd6402399eaf68af20a760", size = 131218 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f9/9b/335f9764261e915ed497fcdeb11df5dfd6f7bf257d4a6a2a686d80da4d54/requests-2.32.3-py3-none-any.whl", hash = "sha256:70761cfe03c773ceb22aa2f671b4757976145175cdfca038c02654d061d6dcc6", size = 64928 }, +] + +[[package]] +name = "rich" +version = "13.9.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "markdown-it-py", marker = "python_full_version >= '3.10'" }, + { name = "pygments", version = "2.19.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, + { name = "typing-extensions", version = "4.12.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.10.*'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ab/3a/0316b28d0761c6734d6bc14e770d85506c986c85ffb239e688eeaab2c2bc/rich-13.9.4.tar.gz", hash = "sha256:439594978a49a09530cff7ebc4b5c7103ef57baf48d5ea3184f21d9a2befa098", size = 223149 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/19/71/39c7c0d87f8d4e6c020a393182060eaefeeae6c01dab6a84ec346f2567df/rich-13.9.4-py3-none-any.whl", hash = "sha256:6049d5e6ec054bf2779ab3358186963bac2ea89175919d699e378b99738c2a90", size = 242424 }, +] + +[[package]] +name = "rpds-py" +version = "0.20.1" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version == '3.8.*'", +] +sdist = { url = "https://files.pythonhosted.org/packages/25/cb/8e919951f55d109d658f81c9b49d0cc3b48637c50792c5d2e77032b8c5da/rpds_py-0.20.1.tar.gz", hash = "sha256:e1791c4aabd117653530dccd24108fa03cc6baf21f58b950d0a73c3b3b29a350", size = 25931 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ae/0e/d7e7e9280988a7bc56fd326042baca27f4f55fad27dc8aa64e5e0e894e5d/rpds_py-0.20.1-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:a649dfd735fff086e8a9d0503a9f0c7d01b7912a333c7ae77e1515c08c146dad", size = 327335 }, + { url = "https://files.pythonhosted.org/packages/4c/72/027185f213d53ae66765c575229829b202fbacf3d55fe2bd9ff4e29bb157/rpds_py-0.20.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:f16bc1334853e91ddaaa1217045dd7be166170beec337576818461268a3de67f", size = 318250 }, + { url = "https://files.pythonhosted.org/packages/2b/e7/b4eb3e6ff541c83d3b46f45f855547e412ab60c45bef64520fafb00b9b42/rpds_py-0.20.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:14511a539afee6f9ab492b543060c7491c99924314977a55c98bfa2ee29ce78c", size = 361206 }, + { url = "https://files.pythonhosted.org/packages/e7/80/cb9a4b4cad31bcaa37f38dae7a8be861f767eb2ca4f07a146b5ffcfbee09/rpds_py-0.20.1-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:3ccb8ac2d3c71cda472b75af42818981bdacf48d2e21c36331b50b4f16930163", size = 369921 }, + { url = "https://files.pythonhosted.org/packages/95/1b/463b11e7039e18f9e778568dbf7338c29bbc1f8996381115201c668eb8c8/rpds_py-0.20.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c142b88039b92e7e0cb2552e8967077e3179b22359e945574f5e2764c3953dcf", size = 403673 }, + { url = "https://files.pythonhosted.org/packages/86/98/1ef4028e9d5b76470bf7f8f2459be07ac5c9621270a2a5e093f8d8a8cc2c/rpds_py-0.20.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f19169781dddae7478a32301b499b2858bc52fc45a112955e798ee307e294977", size = 430267 }, + { url = "https://files.pythonhosted.org/packages/25/8e/41d7e3e6d3a4a6c94375020477705a3fbb6515717901ab8f94821cf0a0d9/rpds_py-0.20.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:13c56de6518e14b9bf6edde23c4c39dac5b48dcf04160ea7bce8fca8397cdf86", size = 360569 }, + { url = "https://files.pythonhosted.org/packages/4f/6a/8839340464d4e1bbfaf0482e9d9165a2309c2c17427e4dcb72ce3e5cc5d6/rpds_py-0.20.1-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:925d176a549f4832c6f69fa6026071294ab5910e82a0fe6c6228fce17b0706bd", size = 382584 }, + { url = "https://files.pythonhosted.org/packages/64/96/7a7f938d3796a6a3ec08ed0e8a5ecd436fbd516a3684ab1fa22d46d6f6cc/rpds_py-0.20.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:78f0b6877bfce7a3d1ff150391354a410c55d3cdce386f862926a4958ad5ab7e", size = 546560 }, + { url = "https://files.pythonhosted.org/packages/15/c7/19fb4f1247a3c90a99eca62909bf76ee988f9b663e47878a673d9854ec5c/rpds_py-0.20.1-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:3dd645e2b0dcb0fd05bf58e2e54c13875847687d0b71941ad2e757e5d89d4356", size = 549359 }, + { url = "https://files.pythonhosted.org/packages/d2/4c/445eb597a39a883368ea2f341dd6e48a9d9681b12ebf32f38a827b30529b/rpds_py-0.20.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:4f676e21db2f8c72ff0936f895271e7a700aa1f8d31b40e4e43442ba94973899", size = 527567 }, + { url = "https://files.pythonhosted.org/packages/4f/71/4c44643bffbcb37311fc7fe221bcf139c8d660bc78f746dd3a05741372c8/rpds_py-0.20.1-cp310-none-win32.whl", hash = "sha256:648386ddd1e19b4a6abab69139b002bc49ebf065b596119f8f37c38e9ecee8ff", size = 200412 }, + { url = "https://files.pythonhosted.org/packages/f4/33/9d0529d74099e090ec9ab15eb0a049c56cca599eaaca71bfedbdbca656a9/rpds_py-0.20.1-cp310-none-win_amd64.whl", hash = "sha256:d9ecb51120de61e4604650666d1f2b68444d46ae18fd492245a08f53ad2b7711", size = 218563 }, + { url = "https://files.pythonhosted.org/packages/a0/2e/a6ded84019a05b8f23e0fe6a632f62ae438a8c5e5932d3dfc90c73418414/rpds_py-0.20.1-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:762703bdd2b30983c1d9e62b4c88664df4a8a4d5ec0e9253b0231171f18f6d75", size = 327194 }, + { url = "https://files.pythonhosted.org/packages/68/11/d3f84c69de2b2086be3d6bd5e9d172825c096b13842ab7e5f8f39f06035b/rpds_py-0.20.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:0b581f47257a9fce535c4567782a8976002d6b8afa2c39ff616edf87cbeff712", size = 318126 }, + { url = "https://files.pythonhosted.org/packages/18/c0/13f1bce9c901511e5e4c0b77a99dbb946bb9a177ca88c6b480e9cb53e304/rpds_py-0.20.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:842c19a6ce894493563c3bd00d81d5100e8e57d70209e84d5491940fdb8b9e3a", size = 361119 }, + { url = "https://files.pythonhosted.org/packages/06/31/3bd721575671f22a37476c2d7b9e34bfa5185bdcee09f7fedde3b29f3adb/rpds_py-0.20.1-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:42cbde7789f5c0bcd6816cb29808e36c01b960fb5d29f11e052215aa85497c93", size = 369532 }, + { url = "https://files.pythonhosted.org/packages/20/22/3eeb0385f33251b4fd0f728e6a3801dc8acc05e714eb7867cefe635bf4ab/rpds_py-0.20.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6c8e9340ce5a52f95fa7d3b552b35c7e8f3874d74a03a8a69279fd5fca5dc751", size = 403703 }, + { url = "https://files.pythonhosted.org/packages/10/e1/8dde6174e7ac5b9acd3269afca2e17719bc7e5088c68f44874d2ad9e4560/rpds_py-0.20.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8ba6f89cac95c0900d932c9efb7f0fb6ca47f6687feec41abcb1bd5e2bd45535", size = 429868 }, + { url = "https://files.pythonhosted.org/packages/19/51/a3cc1a5238acfc2582033e8934d034301f9d4931b9bf7c7ccfabc4ca0880/rpds_py-0.20.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4a916087371afd9648e1962e67403c53f9c49ca47b9680adbeef79da3a7811b0", size = 360539 }, + { url = "https://files.pythonhosted.org/packages/cd/8c/3c87471a44bd4114e2b0aec90f298f6caaac4e8db6af904d5dd2279f5c61/rpds_py-0.20.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:200a23239781f46149e6a415f1e870c5ef1e712939fe8fa63035cd053ac2638e", size = 382467 }, + { url = "https://files.pythonhosted.org/packages/d0/9b/95073fe3e0f130e6d561e106818b6568ef1f2df3352e7f162ab912da837c/rpds_py-0.20.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:58b1d5dd591973d426cbb2da5e27ba0339209832b2f3315928c9790e13f159e8", size = 546669 }, + { url = "https://files.pythonhosted.org/packages/de/4c/7ab3669e02bb06fedebcfd64d361b7168ba39dfdf385e4109440f2e7927b/rpds_py-0.20.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:6b73c67850ca7cae0f6c56f71e356d7e9fa25958d3e18a64927c2d930859b8e4", size = 549304 }, + { url = "https://files.pythonhosted.org/packages/f1/e8/ad5da336cd42adbdafe0ecd40dcecdae01fd3d703c621c7637615a008d3a/rpds_py-0.20.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:d8761c3c891cc51e90bc9926d6d2f59b27beaf86c74622c8979380a29cc23ac3", size = 527637 }, + { url = "https://files.pythonhosted.org/packages/02/f1/1b47b9e5b941c2659c9b7e4ef41b6f07385a6500c638fa10c066e4616ecb/rpds_py-0.20.1-cp311-none-win32.whl", hash = "sha256:cd945871335a639275eee904caef90041568ce3b42f402c6959b460d25ae8732", size = 200488 }, + { url = "https://files.pythonhosted.org/packages/85/f6/c751c1adfa31610055acfa1cc667cf2c2d7011a73070679c448cf5856905/rpds_py-0.20.1-cp311-none-win_amd64.whl", hash = "sha256:7e21b7031e17c6b0e445f42ccc77f79a97e2687023c5746bfb7a9e45e0921b84", size = 218475 }, + { url = "https://files.pythonhosted.org/packages/e7/10/4e8dcc08b58a548098dbcee67a4888751a25be7a6dde0a83d4300df48bfa/rpds_py-0.20.1-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:36785be22066966a27348444b40389f8444671630063edfb1a2eb04318721e17", size = 329749 }, + { url = "https://files.pythonhosted.org/packages/d2/e4/61144f3790e12fd89e6153d77f7915ad26779735fef8ee9c099cba6dfb4a/rpds_py-0.20.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:142c0a5124d9bd0e2976089484af5c74f47bd3298f2ed651ef54ea728d2ea42c", size = 321032 }, + { url = "https://files.pythonhosted.org/packages/fa/e0/99205aabbf3be29ef6c58ef9b08feed51ba6532fdd47461245cb58dd9897/rpds_py-0.20.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:dbddc10776ca7ebf2a299c41a4dde8ea0d8e3547bfd731cb87af2e8f5bf8962d", size = 363931 }, + { url = "https://files.pythonhosted.org/packages/ac/bd/bce2dddb518b13a7e77eed4be234c9af0c9c6d403d01c5e6ae8eb447ab62/rpds_py-0.20.1-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:15a842bb369e00295392e7ce192de9dcbf136954614124a667f9f9f17d6a216f", size = 373343 }, + { url = "https://files.pythonhosted.org/packages/43/15/112b7c553066cb91264691ba7fb119579c440a0ae889da222fa6fc0d411a/rpds_py-0.20.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:be5ef2f1fc586a7372bfc355986226484e06d1dc4f9402539872c8bb99e34b01", size = 406304 }, + { url = "https://files.pythonhosted.org/packages/af/8d/2da52aef8ae5494a382b0c0025ba5b68f2952db0f2a4c7534580e8ca83cc/rpds_py-0.20.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:dbcf360c9e3399b056a238523146ea77eeb2a596ce263b8814c900263e46031a", size = 423022 }, + { url = "https://files.pythonhosted.org/packages/c8/1b/f23015cb293927c93bdb4b94a48bfe77ad9d57359c75db51f0ff0cf482ff/rpds_py-0.20.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ecd27a66740ffd621d20b9a2f2b5ee4129a56e27bfb9458a3bcc2e45794c96cb", size = 364937 }, + { url = "https://files.pythonhosted.org/packages/7b/8b/6da8636b2ea2e2f709e56656e663b6a71ecd9a9f9d9dc21488aade122026/rpds_py-0.20.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d0b937b2a1988f184a3e9e577adaa8aede21ec0b38320d6009e02bd026db04fa", size = 386301 }, + { url = "https://files.pythonhosted.org/packages/20/af/2ae192797bffd0d6d558145b5a36e7245346ff3e44f6ddcb82f0eb8512d4/rpds_py-0.20.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:6889469bfdc1eddf489729b471303739bf04555bb151fe8875931f8564309afc", size = 549452 }, + { url = "https://files.pythonhosted.org/packages/07/dd/9f6520712a5108cd7d407c9db44a3d59011b385c58e320d58ebf67757a9e/rpds_py-0.20.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:19b73643c802f4eaf13d97f7855d0fb527fbc92ab7013c4ad0e13a6ae0ed23bd", size = 554370 }, + { url = "https://files.pythonhosted.org/packages/5e/0e/b1bdc7ea0db0946d640ab8965146099093391bb5d265832994c47461e3c5/rpds_py-0.20.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3c6afcf2338e7f374e8edc765c79fbcb4061d02b15dd5f8f314a4af2bdc7feb5", size = 530940 }, + { url = "https://files.pythonhosted.org/packages/ae/d3/ffe907084299484fab60a7955f7c0e8a295c04249090218c59437010f9f4/rpds_py-0.20.1-cp312-none-win32.whl", hash = "sha256:dc73505153798c6f74854aba69cc75953888cf9866465196889c7cdd351e720c", size = 203164 }, + { url = "https://files.pythonhosted.org/packages/1f/ba/9cbb57423c4bfbd81c473913bebaed151ad4158ee2590a4e4b3e70238b48/rpds_py-0.20.1-cp312-none-win_amd64.whl", hash = "sha256:8bbe951244a838a51289ee53a6bae3a07f26d4e179b96fc7ddd3301caf0518eb", size = 220750 }, + { url = "https://files.pythonhosted.org/packages/b5/01/fee2e1d1274c92fff04aa47d805a28d62c2aa971d1f49f5baea1c6e670d9/rpds_py-0.20.1-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:6ca91093a4a8da4afae7fe6a222c3b53ee4eef433ebfee4d54978a103435159e", size = 329359 }, + { url = "https://files.pythonhosted.org/packages/b0/cf/4aeffb02b7090029d7aeecbffb9a10e1c80f6f56d7e9a30e15481dc4099c/rpds_py-0.20.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:b9c2fe36d1f758b28121bef29ed1dee9b7a2453e997528e7d1ac99b94892527c", size = 320543 }, + { url = "https://files.pythonhosted.org/packages/17/69/85cf3429e9ccda684ba63ff36b5866d5f9451e921cc99819341e19880334/rpds_py-0.20.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f009c69bc8c53db5dfab72ac760895dc1f2bc1b62ab7408b253c8d1ec52459fc", size = 363107 }, + { url = "https://files.pythonhosted.org/packages/ef/de/7df88dea9c3eeb832196d23b41f0f6fc5f9a2ee9b2080bbb1db8731ead9c/rpds_py-0.20.1-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:6740a3e8d43a32629bb9b009017ea5b9e713b7210ba48ac8d4cb6d99d86c8ee8", size = 372027 }, + { url = "https://files.pythonhosted.org/packages/d1/b8/88675399d2038580743c570a809c43a900e7090edc6553f8ffb66b23c965/rpds_py-0.20.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:32b922e13d4c0080d03e7b62991ad7f5007d9cd74e239c4b16bc85ae8b70252d", size = 405031 }, + { url = "https://files.pythonhosted.org/packages/e1/aa/cca639f6d17caf00bab51bdc70fcc0bdda3063e5662665c4fdf60443c474/rpds_py-0.20.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:fe00a9057d100e69b4ae4a094203a708d65b0f345ed546fdef86498bf5390982", size = 422271 }, + { url = "https://files.pythonhosted.org/packages/c4/07/bf8a949d2ec4626c285579c9d6b356c692325f1a4126e947736b416e1fc4/rpds_py-0.20.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:49fe9b04b6fa685bd39237d45fad89ba19e9163a1ccaa16611a812e682913496", size = 363625 }, + { url = "https://files.pythonhosted.org/packages/11/f0/06675c6a58d6ce34547879138810eb9aab0c10e5607ea6c2e4dc56b703c8/rpds_py-0.20.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:aa7ac11e294304e615b43f8c441fee5d40094275ed7311f3420d805fde9b07b4", size = 385906 }, + { url = "https://files.pythonhosted.org/packages/bf/ac/2d1f50374eb8e41030fad4e87f81751e1c39e3b5d4bee8c5618830d8a6ac/rpds_py-0.20.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:6aa97af1558a9bef4025f8f5d8c60d712e0a3b13a2fe875511defc6ee77a1ab7", size = 549021 }, + { url = "https://files.pythonhosted.org/packages/f7/d4/a7d70a7cc71df772eeadf4bce05e32e780a9fe44a511a5b091c7a85cb767/rpds_py-0.20.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:483b29f6f7ffa6af845107d4efe2e3fa8fb2693de8657bc1849f674296ff6a5a", size = 553800 }, + { url = "https://files.pythonhosted.org/packages/87/81/dc30bc449ccba63ad23a0f6633486d4e0e6955f45f3715a130dacabd6ad0/rpds_py-0.20.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:37fe0f12aebb6a0e3e17bb4cd356b1286d2d18d2e93b2d39fe647138458b4bcb", size = 531076 }, + { url = "https://files.pythonhosted.org/packages/50/80/fb62ab48f3b5cfe704ead6ad372da1922ddaa76397055e02eb507054c979/rpds_py-0.20.1-cp313-none-win32.whl", hash = "sha256:a624cc00ef2158e04188df5e3016385b9353638139a06fb77057b3498f794782", size = 202804 }, + { url = "https://files.pythonhosted.org/packages/d9/30/a3391e76d0b3313f33bdedd394a519decae3a953d2943e3dabf80ae32447/rpds_py-0.20.1-cp313-none-win_amd64.whl", hash = "sha256:b71b8666eeea69d6363248822078c075bac6ed135faa9216aa85f295ff009b1e", size = 220502 }, + { url = "https://files.pythonhosted.org/packages/53/ef/b1883734ea0cd9996de793cdc38c32a28143b04911d1e570090acd8a9162/rpds_py-0.20.1-cp38-cp38-macosx_10_12_x86_64.whl", hash = "sha256:5b48e790e0355865197ad0aca8cde3d8ede347831e1959e158369eb3493d2191", size = 327757 }, + { url = "https://files.pythonhosted.org/packages/54/63/47d34dc4ddb3da73e78e10c9009dcf8edc42d355a221351c05c822c2a50b/rpds_py-0.20.1-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:3e310838a5801795207c66c73ea903deda321e6146d6f282e85fa7e3e4854804", size = 318785 }, + { url = "https://files.pythonhosted.org/packages/f7/e1/d6323be4afbe3013f28725553b7bfa80b3f013f91678af258f579f8ea8f9/rpds_py-0.20.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2249280b870e6a42c0d972339e9cc22ee98730a99cd7f2f727549af80dd5a963", size = 361511 }, + { url = "https://files.pythonhosted.org/packages/ab/d3/c40e4d9ecd571f0f50fe69bc53fe608d7b2c49b30738b480044990260838/rpds_py-0.20.1-cp38-cp38-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e79059d67bea28b53d255c1437b25391653263f0e69cd7dec170d778fdbca95e", size = 370201 }, + { url = "https://files.pythonhosted.org/packages/f1/b6/96a4a9977a8a06c2c49d90aa571346aff1642abf15066a39a0b4817bf049/rpds_py-0.20.1-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:2b431c777c9653e569986ecf69ff4a5dba281cded16043d348bf9ba505486f36", size = 403866 }, + { url = "https://files.pythonhosted.org/packages/cd/8f/702b52287949314b498a311f92b5ee0ba30c702a27e0e6b560e2da43b8d5/rpds_py-0.20.1-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:da584ff96ec95e97925174eb8237e32f626e7a1a97888cdd27ee2f1f24dd0ad8", size = 430163 }, + { url = "https://files.pythonhosted.org/packages/c4/ce/af016c81fda833bf125b20d1677d816f230cad2ab189f46bcbfea3c7a375/rpds_py-0.20.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:02a0629ec053fc013808a85178524e3cb63a61dbc35b22499870194a63578fb9", size = 360776 }, + { url = "https://files.pythonhosted.org/packages/08/a7/988e179c9bef55821abe41762228d65077e0570ca75c9efbcd1bc6e263b4/rpds_py-0.20.1-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:fbf15aff64a163db29a91ed0868af181d6f68ec1a3a7d5afcfe4501252840bad", size = 383008 }, + { url = "https://files.pythonhosted.org/packages/96/b0/e4077f7f1b9622112ae83254aedfb691490278793299bc06dcf54ec8c8e4/rpds_py-0.20.1-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:07924c1b938798797d60c6308fa8ad3b3f0201802f82e4a2c41bb3fafb44cc28", size = 546371 }, + { url = "https://files.pythonhosted.org/packages/e4/5e/1d4dd08ec0352cfe516ea93ea1993c2f656f893c87dafcd9312bd07f65f7/rpds_py-0.20.1-cp38-cp38-musllinux_1_2_i686.whl", hash = "sha256:4a5a844f68776a7715ecb30843b453f07ac89bad393431efbf7accca3ef599c1", size = 549809 }, + { url = "https://files.pythonhosted.org/packages/57/ac/a716b4729ff23ec034b7d2ff76a86e6f0753c4098401bdfdf55b2efe90e6/rpds_py-0.20.1-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:518d2ca43c358929bf08f9079b617f1c2ca6e8848f83c1225c88caeac46e6cbc", size = 528492 }, + { url = "https://files.pythonhosted.org/packages/e0/ed/a0b58a9ecef79918169eacdabd14eb4c5c86ce71184ed56b80c6eb425828/rpds_py-0.20.1-cp38-none-win32.whl", hash = "sha256:3aea7eed3e55119635a74bbeb80b35e776bafccb70d97e8ff838816c124539f1", size = 200512 }, + { url = "https://files.pythonhosted.org/packages/5f/c3/222e25124283afc76c473fcd2c547e82ec57683fa31cb4d6c6eb44e5d57a/rpds_py-0.20.1-cp38-none-win_amd64.whl", hash = "sha256:7dca7081e9a0c3b6490a145593f6fe3173a94197f2cb9891183ef75e9d64c425", size = 218627 }, + { url = "https://files.pythonhosted.org/packages/d6/87/e7e0fcbfdc0d0e261534bcc885f6ae6253095b972e32f8b8b1278c78a2a9/rpds_py-0.20.1-cp39-cp39-macosx_10_12_x86_64.whl", hash = "sha256:b41b6321805c472f66990c2849e152aff7bc359eb92f781e3f606609eac877ad", size = 327867 }, + { url = "https://files.pythonhosted.org/packages/93/a0/17836b7961fc82586e9b818abdee2a27e2e605a602bb8c0d43f02092f8c2/rpds_py-0.20.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:0a90c373ea2975519b58dece25853dbcb9779b05cc46b4819cb1917e3b3215b6", size = 318893 }, + { url = "https://files.pythonhosted.org/packages/dc/03/deb81d8ea3a8b974e7b03cfe8c8c26616ef8f4980dd430d8dd0a2f1b4d8e/rpds_py-0.20.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:16d4477bcb9fbbd7b5b0e4a5d9b493e42026c0bf1f06f723a9353f5153e75d30", size = 361664 }, + { url = "https://files.pythonhosted.org/packages/16/49/d9938603731745c7b6babff97ca61ff3eb4619e7128b5ab0111ad4e91d6d/rpds_py-0.20.1-cp39-cp39-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:84b8382a90539910b53a6307f7c35697bc7e6ffb25d9c1d4e998a13e842a5e83", size = 369796 }, + { url = "https://files.pythonhosted.org/packages/87/d2/480b36c69cdc373853401b6aab6a281cf60f6d72b1545d82c0d23d9dd77c/rpds_py-0.20.1-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4888e117dd41b9d34194d9e31631af70d3d526efc363085e3089ab1a62c32ed1", size = 403860 }, + { url = "https://files.pythonhosted.org/packages/31/7c/f6d909cb57761293308dbef14f1663d84376f2e231892a10aafc57b42037/rpds_py-0.20.1-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5265505b3d61a0f56618c9b941dc54dc334dc6e660f1592d112cd103d914a6db", size = 430793 }, + { url = "https://files.pythonhosted.org/packages/d4/62/c9bd294c4b5f84d9cc2c387b548ae53096ad7e71ac5b02b6310e9dc85aa4/rpds_py-0.20.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e75ba609dba23f2c95b776efb9dd3f0b78a76a151e96f96cc5b6b1b0004de66f", size = 360927 }, + { url = "https://files.pythonhosted.org/packages/c1/a7/15d927d83a44da8307a432b1cac06284b6657706d099a98cc99fec34ad51/rpds_py-0.20.1-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:1791ff70bc975b098fe6ecf04356a10e9e2bd7dc21fa7351c1742fdeb9b4966f", size = 382660 }, + { url = "https://files.pythonhosted.org/packages/4c/28/0630719c18456238bb07d59c4302fed50a13aa8035ec23dbfa80d116f9bc/rpds_py-0.20.1-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:d126b52e4a473d40232ec2052a8b232270ed1f8c9571aaf33f73a14cc298c24f", size = 546888 }, + { url = "https://files.pythonhosted.org/packages/b9/75/3c9bda11b9c15d680b315f898af23825159314d4b56568f24b53ace8afcd/rpds_py-0.20.1-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:c14937af98c4cc362a1d4374806204dd51b1e12dded1ae30645c298e5a5c4cb1", size = 550088 }, + { url = "https://files.pythonhosted.org/packages/70/f1/8fe7d04c194218171220a412057429defa9e2da785de0777c4d39309337e/rpds_py-0.20.1-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:3d089d0b88996df627693639d123c8158cff41c0651f646cd8fd292c7da90eaf", size = 528270 }, + { url = "https://files.pythonhosted.org/packages/d6/62/41b0020f4b00af042b008e679dbe25a2f5bce655139a81f8b812f9068e52/rpds_py-0.20.1-cp39-none-win32.whl", hash = "sha256:653647b8838cf83b2e7e6a0364f49af96deec64d2a6578324db58380cff82aca", size = 200658 }, + { url = "https://files.pythonhosted.org/packages/05/01/e64bb8889f2dcc951e53de33d8b8070456397ae4e10edc35e6cb9908f5c8/rpds_py-0.20.1-cp39-none-win_amd64.whl", hash = "sha256:fa41a64ac5b08b292906e248549ab48b69c5428f3987b09689ab2441f267d04d", size = 218883 }, + { url = "https://files.pythonhosted.org/packages/b6/fa/7959429e69569d0f6e7d27f80451402da0409349dd2b07f6bcbdd5fad2d3/rpds_py-0.20.1-pp310-pypy310_pp73-macosx_10_12_x86_64.whl", hash = "sha256:7a07ced2b22f0cf0b55a6a510078174c31b6d8544f3bc00c2bcee52b3d613f74", size = 328209 }, + { url = "https://files.pythonhosted.org/packages/25/97/5dfdb091c30267ff404d2fd9e70c7a6d6ffc65ca77fffe9456e13b719066/rpds_py-0.20.1-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:68cb0a499f2c4a088fd2f521453e22ed3527154136a855c62e148b7883b99f9a", size = 319499 }, + { url = "https://files.pythonhosted.org/packages/7c/98/cf2608722400f5f9bb4c82aa5ac09026f3ac2ebea9d4059d3533589ed0b6/rpds_py-0.20.1-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fa3060d885657abc549b2a0f8e1b79699290e5d83845141717c6c90c2df38311", size = 361795 }, + { url = "https://files.pythonhosted.org/packages/89/de/0e13dd43c785c60e63933e96fbddda0b019df6862f4d3019bb49c3861131/rpds_py-0.20.1-pp310-pypy310_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:95f3b65d2392e1c5cec27cff08fdc0080270d5a1a4b2ea1d51d5f4a2620ff08d", size = 370604 }, + { url = "https://files.pythonhosted.org/packages/8a/fc/fe3c83c77f82b8059eeec4e998064913d66212b69b3653df48f58ad33d3d/rpds_py-0.20.1-pp310-pypy310_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:2cc3712a4b0b76a1d45a9302dd2f53ff339614b1c29603a911318f2357b04dd2", size = 404177 }, + { url = "https://files.pythonhosted.org/packages/94/30/5189518bfb80a41f664daf32b46645c7fbdcc89028a0f1bfa82e806e0fbb/rpds_py-0.20.1-pp310-pypy310_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5d4eea0761e37485c9b81400437adb11c40e13ef513375bbd6973e34100aeb06", size = 430108 }, + { url = "https://files.pythonhosted.org/packages/67/0e/6f069feaff5c298375cd8c55e00ecd9bd79c792ce0893d39448dc0097857/rpds_py-0.20.1-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7f5179583d7a6cdb981151dd349786cbc318bab54963a192692d945dd3f6435d", size = 361184 }, + { url = "https://files.pythonhosted.org/packages/27/9f/ce3e2ae36f392c3ef1988c06e9e0b4c74f64267dad7c223003c34da11adb/rpds_py-0.20.1-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2fbb0ffc754490aff6dabbf28064be47f0f9ca0b9755976f945214965b3ace7e", size = 384140 }, + { url = "https://files.pythonhosted.org/packages/5f/d5/89d44504d0bc7a1135062cb520a17903ff002f458371b8d9160af3b71e52/rpds_py-0.20.1-pp310-pypy310_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:a94e52537a0e0a85429eda9e49f272ada715506d3b2431f64b8a3e34eb5f3e75", size = 546589 }, + { url = "https://files.pythonhosted.org/packages/8f/8f/e1c2db4fcca3947d9a28ec9553700b4dc8038f0eff575f579e75885b0661/rpds_py-0.20.1-pp310-pypy310_pp73-musllinux_1_2_i686.whl", hash = "sha256:92b68b79c0da2a980b1c4197e56ac3dd0c8a149b4603747c4378914a68706979", size = 550059 }, + { url = "https://files.pythonhosted.org/packages/67/29/00a9e986df36721b5def82fff60995c1ee8827a7d909a6ec8929fb4cc668/rpds_py-0.20.1-pp310-pypy310_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:93da1d3db08a827eda74356f9f58884adb254e59b6664f64cc04cdff2cc19b0d", size = 529131 }, + { url = "https://files.pythonhosted.org/packages/a3/32/95364440560ec476b19c6a2704259e710c223bf767632ebaa72cc2a1760f/rpds_py-0.20.1-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:754bbed1a4ca48479e9d4182a561d001bbf81543876cdded6f695ec3d465846b", size = 219677 }, + { url = "https://files.pythonhosted.org/packages/ed/bf/ad8492e972c90a3d48a38e2b5095c51a8399d5b57e83f2d5d1649490f72b/rpds_py-0.20.1-pp39-pypy39_pp73-macosx_10_12_x86_64.whl", hash = "sha256:ca449520e7484534a2a44faf629362cae62b660601432d04c482283c47eaebab", size = 328046 }, + { url = "https://files.pythonhosted.org/packages/75/fd/84f42386165d6d555acb76c6d39c90b10c9dcf25116daf4f48a0a9d6867a/rpds_py-0.20.1-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:9c4cb04a16b0f199a8c9bf807269b2f63b7b5b11425e4a6bd44bd6961d28282c", size = 319306 }, + { url = "https://files.pythonhosted.org/packages/6c/8a/abcd5119a0573f9588ad71a3fde3c07ddd1d1393cfee15a6ba7495c256f1/rpds_py-0.20.1-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bb63804105143c7e24cee7db89e37cb3f3941f8e80c4379a0b355c52a52b6780", size = 362558 }, + { url = "https://files.pythonhosted.org/packages/9d/65/1c2bb10afd4bd32800227a658ae9097bc1d08a4e5048a57a9bd2efdf6306/rpds_py-0.20.1-pp39-pypy39_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:55cd1fa4ecfa6d9f14fbd97ac24803e6f73e897c738f771a9fe038f2f11ff07c", size = 370811 }, + { url = "https://files.pythonhosted.org/packages/6c/ee/f4bab2b9e51ced30351cfd210647885391463ae682028c79760e7db28e4e/rpds_py-0.20.1-pp39-pypy39_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:0f8f741b6292c86059ed175d80eefa80997125b7c478fb8769fd9ac8943a16c0", size = 404660 }, + { url = "https://files.pythonhosted.org/packages/48/0f/9d04d0939682f0c97be827fc51ff986555ffb573e6781bd5132441f0ce25/rpds_py-0.20.1-pp39-pypy39_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:0fc212779bf8411667234b3cdd34d53de6c2b8b8b958e1e12cb473a5f367c338", size = 430490 }, + { url = "https://files.pythonhosted.org/packages/0d/f2/e9b90fd8416d59941b6a12f2c2e1d898b63fd092f5a7a6f98236cb865764/rpds_py-0.20.1-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0ad56edabcdb428c2e33bbf24f255fe2b43253b7d13a2cdbf05de955217313e6", size = 361448 }, + { url = "https://files.pythonhosted.org/packages/0b/83/1cc776dce7bedb17d6f4ea62eafccee8a57a4678f4fac414ab69fb9b6b0b/rpds_py-0.20.1-pp39-pypy39_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:0a3a1e9ee9728b2c1734f65d6a1d376c6f2f6fdcc13bb007a08cc4b1ff576dc5", size = 383681 }, + { url = "https://files.pythonhosted.org/packages/17/5c/e0cdd6b0a8373fdef3667af2778dd9ff3abf1bbb9c7bd92c603c91440eb0/rpds_py-0.20.1-pp39-pypy39_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:e13de156137b7095442b288e72f33503a469aa1980ed856b43c353ac86390519", size = 546203 }, + { url = "https://files.pythonhosted.org/packages/1b/a8/81fc9cbc01e7ef6d10652aedc1de4e8473934773e2808ba49094e03575df/rpds_py-0.20.1-pp39-pypy39_pp73-musllinux_1_2_i686.whl", hash = "sha256:07f59760ef99f31422c49038964b31c4dfcfeb5d2384ebfc71058a7c9adae2d2", size = 549855 }, + { url = "https://files.pythonhosted.org/packages/b3/87/99648693d3c1bbce088119bc61ecaab62e5f9c713894edc604ffeca5ae88/rpds_py-0.20.1-pp39-pypy39_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:59240685e7da61fb78f65a9f07f8108e36a83317c53f7b276b4175dc44151684", size = 528625 }, + { url = "https://files.pythonhosted.org/packages/05/c3/10c68a08849f1fa45d205e54141fa75d316013e3d701ef01770ee1220bb8/rpds_py-0.20.1-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:83cba698cfb3c2c5a7c3c6bac12fe6c6a51aae69513726be6411076185a8b24a", size = 219991 }, +] + +[[package]] +name = "rpds-py" +version = "0.23.1" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", + "python_full_version == '3.10.*'", + "python_full_version == '3.9.*'", +] +sdist = { url = "https://files.pythonhosted.org/packages/0a/79/2ce611b18c4fd83d9e3aecb5cba93e1917c050f556db39842889fa69b79f/rpds_py-0.23.1.tar.gz", hash = "sha256:7f3240dcfa14d198dba24b8b9cb3b108c06b68d45b7babd9eefc1038fdf7e707", size = 26806 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/34/fe/e5326459863bd525122f4e9c80ac8d7c6cfa171b7518d04cc27c12c209b0/rpds_py-0.23.1-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:2a54027554ce9b129fc3d633c92fa33b30de9f08bc61b32c053dc9b537266fed", size = 372123 }, + { url = "https://files.pythonhosted.org/packages/f9/db/f10a3795f7a89fb27594934012d21c61019bbeb516c5bdcfbbe9e9e617a7/rpds_py-0.23.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:b5ef909a37e9738d146519657a1aab4584018746a18f71c692f2f22168ece40c", size = 356778 }, + { url = "https://files.pythonhosted.org/packages/21/27/0d3678ad7f432fa86f8fac5f5fc6496a4d2da85682a710d605219be20063/rpds_py-0.23.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3ee9d6f0b38efb22ad94c3b68ffebe4c47865cdf4b17f6806d6c674e1feb4246", size = 385775 }, + { url = "https://files.pythonhosted.org/packages/99/a0/1786defa125b2ad228027f22dff26312ce7d1fee3c7c3c2682f403db2062/rpds_py-0.23.1-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f7356a6da0562190558c4fcc14f0281db191cdf4cb96e7604c06acfcee96df15", size = 391181 }, + { url = "https://files.pythonhosted.org/packages/f1/5c/1240934050a7ffd020a915486d0cc4c7f6e7a2442a77aedf13664db55d36/rpds_py-0.23.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9441af1d25aed96901f97ad83d5c3e35e6cd21a25ca5e4916c82d7dd0490a4fa", size = 444607 }, + { url = "https://files.pythonhosted.org/packages/b7/1b/cee6905b47817fd0a377716dbe4df35295de46df46ee2ff704538cc371b0/rpds_py-0.23.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3d8abf7896a91fb97e7977d1aadfcc2c80415d6dc2f1d0fca5b8d0df247248f3", size = 445550 }, + { url = "https://files.pythonhosted.org/packages/54/f7/f0821ca34032892d7a67fcd5042f50074ff2de64e771e10df01085c88d47/rpds_py-0.23.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1b08027489ba8fedde72ddd233a5ea411b85a6ed78175f40285bd401bde7466d", size = 386148 }, + { url = "https://files.pythonhosted.org/packages/eb/ef/2afe53bc857c4bcba336acfd2629883a5746e7291023e017ac7fc98d85aa/rpds_py-0.23.1-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:fee513135b5a58f3bb6d89e48326cd5aa308e4bcdf2f7d59f67c861ada482bf8", size = 416780 }, + { url = "https://files.pythonhosted.org/packages/ae/9a/38d2236cf669789b8a3e1a014c9b6a8d7b8925b952c92e7839ae2749f9ac/rpds_py-0.23.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:35d5631ce0af26318dba0ae0ac941c534453e42f569011585cb323b7774502a5", size = 558265 }, + { url = "https://files.pythonhosted.org/packages/e6/0a/f2705530c42578f20ed0b5b90135eecb30eef6e2ba73e7ba69087fad2dba/rpds_py-0.23.1-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:a20cb698c4a59c534c6701b1c24a968ff2768b18ea2991f886bd8985ce17a89f", size = 585270 }, + { url = "https://files.pythonhosted.org/packages/29/4e/3b597dc84ed82c3d757ac9aa620de224a94e06d2e102069795ae7e81c015/rpds_py-0.23.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:5e9c206a1abc27e0588cf8b7c8246e51f1a16a103734f7750830a1ccb63f557a", size = 553850 }, + { url = "https://files.pythonhosted.org/packages/00/cc/6498b6f79e4375e6737247661e52a2d18f6accf4910e0c8da978674b4241/rpds_py-0.23.1-cp310-cp310-win32.whl", hash = "sha256:d9f75a06ecc68f159d5d7603b734e1ff6daa9497a929150f794013aa9f6e3f12", size = 220660 }, + { url = "https://files.pythonhosted.org/packages/17/2b/08db023d23e8c7032c99d8d2a70d32e450a868ab73d16e3ff5290308a665/rpds_py-0.23.1-cp310-cp310-win_amd64.whl", hash = "sha256:f35eff113ad430b5272bbfc18ba111c66ff525828f24898b4e146eb479a2cdda", size = 232551 }, + { url = "https://files.pythonhosted.org/packages/1c/67/6e5d4234bb9dee062ffca2a5f3c7cd38716317d6760ec235b175eed4de2c/rpds_py-0.23.1-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:b79f5ced71efd70414a9a80bbbfaa7160da307723166f09b69773153bf17c590", size = 372264 }, + { url = "https://files.pythonhosted.org/packages/a7/0a/3dedb2daee8e783622427f5064e2d112751d8276ee73aa5409f000a132f4/rpds_py-0.23.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:c9e799dac1ffbe7b10c1fd42fe4cd51371a549c6e108249bde9cd1200e8f59b4", size = 356883 }, + { url = "https://files.pythonhosted.org/packages/ed/fc/e1acef44f9c24b05fe5434b235f165a63a52959ac655e3f7a55726cee1a4/rpds_py-0.23.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:721f9c4011b443b6e84505fc00cc7aadc9d1743f1c988e4c89353e19c4a968ee", size = 385624 }, + { url = "https://files.pythonhosted.org/packages/97/0a/a05951f6465d01622720c03ef6ef31adfbe865653e05ed7c45837492f25e/rpds_py-0.23.1-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f88626e3f5e57432e6191cd0c5d6d6b319b635e70b40be2ffba713053e5147dd", size = 391500 }, + { url = "https://files.pythonhosted.org/packages/ea/2e/cca0583ec0690ea441dceae23c0673b99755710ea22f40bccf1e78f41481/rpds_py-0.23.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:285019078537949cecd0190f3690a0b0125ff743d6a53dfeb7a4e6787af154f5", size = 444869 }, + { url = "https://files.pythonhosted.org/packages/cc/e6/95cda68b33a6d814d1e96b0e406d231ed16629101460d1740e92f03365e6/rpds_py-0.23.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b92f5654157de1379c509b15acec9d12ecf6e3bc1996571b6cb82a4302060447", size = 444930 }, + { url = "https://files.pythonhosted.org/packages/5f/a7/e94cdb73411ae9c11414d3c7c9a6ad75d22ad4a8d094fb45a345ba9e3018/rpds_py-0.23.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e768267cbe051dd8d1c5305ba690bb153204a09bf2e3de3ae530de955f5b5580", size = 386254 }, + { url = "https://files.pythonhosted.org/packages/dd/c5/a4a943d90a39e85efd1e04b1ad5129936786f9a9aa27bb7be8fc5d9d50c9/rpds_py-0.23.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:c5334a71f7dc1160382d45997e29f2637c02f8a26af41073189d79b95d3321f1", size = 417090 }, + { url = "https://files.pythonhosted.org/packages/0c/a0/80d0013b12428d1fce0ab4e71829400b0a32caec12733c79e6109f843342/rpds_py-0.23.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d6adb81564af0cd428910f83fa7da46ce9ad47c56c0b22b50872bc4515d91966", size = 557639 }, + { url = "https://files.pythonhosted.org/packages/a6/92/ec2e6980afb964a2cd7a99cbdef1f6c01116abe94b42cbe336ac93dd11c2/rpds_py-0.23.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:cafa48f2133d4daa028473ede7d81cd1b9f9e6925e9e4003ebdf77010ee02f35", size = 584572 }, + { url = "https://files.pythonhosted.org/packages/3d/ce/75b6054db34a390789a82523790717b27c1bd735e453abb429a87c4f0f26/rpds_py-0.23.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:0fced9fd4a07a1ded1bac7e961ddd9753dd5d8b755ba8e05acba54a21f5f1522", size = 553028 }, + { url = "https://files.pythonhosted.org/packages/cc/24/f45abe0418c06a5cba0f846e967aa27bac765acd927aabd857c21319b8cc/rpds_py-0.23.1-cp311-cp311-win32.whl", hash = "sha256:243241c95174b5fb7204c04595852fe3943cc41f47aa14c3828bc18cd9d3b2d6", size = 220862 }, + { url = "https://files.pythonhosted.org/packages/2d/a6/3c0880e8bbfc36451ef30dc416266f6d2934705e468db5d21c8ba0ab6400/rpds_py-0.23.1-cp311-cp311-win_amd64.whl", hash = "sha256:11dd60b2ffddba85715d8a66bb39b95ddbe389ad2cfcf42c833f1bcde0878eaf", size = 232953 }, + { url = "https://files.pythonhosted.org/packages/f3/8c/d17efccb9f5b9137ddea706664aebae694384ae1d5997c0202093e37185a/rpds_py-0.23.1-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:3902df19540e9af4cc0c3ae75974c65d2c156b9257e91f5101a51f99136d834c", size = 364369 }, + { url = "https://files.pythonhosted.org/packages/6e/c0/ab030f696b5c573107115a88d8d73d80f03309e60952b64c584c70c659af/rpds_py-0.23.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:66f8d2a17e5838dd6fb9be6baaba8e75ae2f5fa6b6b755d597184bfcd3cb0eba", size = 349965 }, + { url = "https://files.pythonhosted.org/packages/b3/55/b40170f5a079c4fb0b6a82b299689e66e744edca3c3375a8b160fb797660/rpds_py-0.23.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:112b8774b0b4ee22368fec42749b94366bd9b536f8f74c3d4175d4395f5cbd31", size = 389064 }, + { url = "https://files.pythonhosted.org/packages/ab/1c/b03a912c59ec7c1e16b26e587b9dfa8ddff3b07851e781e8c46e908a365a/rpds_py-0.23.1-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e0df046f2266e8586cf09d00588302a32923eb6386ced0ca5c9deade6af9a149", size = 397741 }, + { url = "https://files.pythonhosted.org/packages/52/6f/151b90792b62fb6f87099bcc9044c626881fdd54e31bf98541f830b15cea/rpds_py-0.23.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:0f3288930b947cbebe767f84cf618d2cbe0b13be476e749da0e6a009f986248c", size = 448784 }, + { url = "https://files.pythonhosted.org/packages/71/2a/6de67c0c97ec7857e0e9e5cd7c52405af931b303eb1e5b9eff6c50fd9a2e/rpds_py-0.23.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ce473a2351c018b06dd8d30d5da8ab5a0831056cc53b2006e2a8028172c37ce5", size = 440203 }, + { url = "https://files.pythonhosted.org/packages/db/5e/e759cd1c276d98a4b1f464b17a9bf66c65d29f8f85754e27e1467feaa7c3/rpds_py-0.23.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d550d7e9e7d8676b183b37d65b5cd8de13676a738973d330b59dc8312df9c5dc", size = 391611 }, + { url = "https://files.pythonhosted.org/packages/1c/1e/2900358efcc0d9408c7289769cba4c0974d9db314aa884028ed7f7364f61/rpds_py-0.23.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:e14f86b871ea74c3fddc9a40e947d6a5d09def5adc2076ee61fb910a9014fb35", size = 423306 }, + { url = "https://files.pythonhosted.org/packages/23/07/6c177e6d059f5d39689352d6c69a926ee4805ffdb6f06203570234d3d8f7/rpds_py-0.23.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:1bf5be5ba34e19be579ae873da515a2836a2166d8d7ee43be6ff909eda42b72b", size = 562323 }, + { url = "https://files.pythonhosted.org/packages/70/e4/f9097fd1c02b516fff9850792161eb9fc20a2fd54762f3c69eae0bdb67cb/rpds_py-0.23.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:d7031d493c4465dbc8d40bd6cafefef4bd472b17db0ab94c53e7909ee781b9ef", size = 588351 }, + { url = "https://files.pythonhosted.org/packages/87/39/5db3c6f326bfbe4576ae2af6435bd7555867d20ae690c786ff33659f293b/rpds_py-0.23.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:55ff4151cfd4bc635e51cfb1c59ac9f7196b256b12e3a57deb9e5742e65941ad", size = 557252 }, + { url = "https://files.pythonhosted.org/packages/fd/14/2d5ad292f144fa79bafb78d2eb5b8a3a91c358b6065443cb9c49b5d1fedf/rpds_py-0.23.1-cp312-cp312-win32.whl", hash = "sha256:a9d3b728f5a5873d84cba997b9d617c6090ca5721caaa691f3b1a78c60adc057", size = 222181 }, + { url = "https://files.pythonhosted.org/packages/a3/4f/0fce63e0f5cdd658e71e21abd17ac1bc9312741ebb8b3f74eeed2ebdf771/rpds_py-0.23.1-cp312-cp312-win_amd64.whl", hash = "sha256:b03a8d50b137ee758e4c73638b10747b7c39988eb8e6cd11abb7084266455165", size = 237426 }, + { url = "https://files.pythonhosted.org/packages/13/9d/b8b2c0edffb0bed15be17b6d5ab06216f2f47f9ee49259c7e96a3ad4ca42/rpds_py-0.23.1-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:4caafd1a22e5eaa3732acb7672a497123354bef79a9d7ceed43387d25025e935", size = 363672 }, + { url = "https://files.pythonhosted.org/packages/bd/c2/5056fa29e6894144d7ba4c938b9b0445f75836b87d2dd00ed4999dc45a8c/rpds_py-0.23.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:178f8a60fc24511c0eb756af741c476b87b610dba83270fce1e5a430204566a4", size = 349602 }, + { url = "https://files.pythonhosted.org/packages/b0/bc/33779a1bb0ee32d8d706b173825aab75c628521d23ce72a7c1e6a6852f86/rpds_py-0.23.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c632419c3870507ca20a37c8f8f5352317aca097639e524ad129f58c125c61c6", size = 388746 }, + { url = "https://files.pythonhosted.org/packages/62/0b/71db3e36b7780a619698ec82a9c87ab44ad7ca7f5480913e8a59ff76f050/rpds_py-0.23.1-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:698a79d295626ee292d1730bc2ef6e70a3ab135b1d79ada8fde3ed0047b65a10", size = 397076 }, + { url = "https://files.pythonhosted.org/packages/bb/2e/494398f613edf77ba10a916b1ddea2acce42ab0e3b62e2c70ffc0757ce00/rpds_py-0.23.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:271fa2184cf28bdded86bb6217c8e08d3a169fe0bbe9be5e8d96e8476b707122", size = 448399 }, + { url = "https://files.pythonhosted.org/packages/dd/53/4bd7f5779b1f463243ee5fdc83da04dd58a08f86e639dbffa7a35f969a84/rpds_py-0.23.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b91cceb5add79ee563bd1f70b30896bd63bc5f78a11c1f00a1e931729ca4f1f4", size = 439764 }, + { url = "https://files.pythonhosted.org/packages/f6/55/b3c18c04a460d951bf8e91f2abf46ce5b6426fb69784166a6a25827cb90a/rpds_py-0.23.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f3a6cb95074777f1ecda2ca4fa7717caa9ee6e534f42b7575a8f0d4cb0c24013", size = 390662 }, + { url = "https://files.pythonhosted.org/packages/2a/65/cc463044a3cbd616029b2aa87a651cdee8288d2fdd7780b2244845e934c1/rpds_py-0.23.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:50fb62f8d8364978478b12d5f03bf028c6bc2af04082479299139dc26edf4c64", size = 422680 }, + { url = "https://files.pythonhosted.org/packages/fa/8e/1fa52990c7836d72e8d70cd7753f2362c72fbb0a49c1462e8c60e7176d0b/rpds_py-0.23.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:c8f7e90b948dc9dcfff8003f1ea3af08b29c062f681c05fd798e36daa3f7e3e8", size = 561792 }, + { url = "https://files.pythonhosted.org/packages/57/b8/fe3b612979b1a29d0c77f8585903d8b3a292604b26d4b300e228b8ac6360/rpds_py-0.23.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:5b98b6c953e5c2bda51ab4d5b4f172617d462eebc7f4bfdc7c7e6b423f6da957", size = 588127 }, + { url = "https://files.pythonhosted.org/packages/44/2d/fde474de516bbc4b9b230f43c98e7f8acc5da7fc50ceed8e7af27553d346/rpds_py-0.23.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:2893d778d4671ee627bac4037a075168b2673c57186fb1a57e993465dbd79a93", size = 556981 }, + { url = "https://files.pythonhosted.org/packages/18/57/767deeb27b81370bbab8f74ef6e68d26c4ea99018f3c71a570e506fede85/rpds_py-0.23.1-cp313-cp313-win32.whl", hash = "sha256:2cfa07c346a7ad07019c33fb9a63cf3acb1f5363c33bc73014e20d9fe8b01cdd", size = 221936 }, + { url = "https://files.pythonhosted.org/packages/7d/6c/3474cfdd3cafe243f97ab8474ea8949236eb2a1a341ca55e75ce00cd03da/rpds_py-0.23.1-cp313-cp313-win_amd64.whl", hash = "sha256:3aaf141d39f45322e44fc2c742e4b8b4098ead5317e5f884770c8df0c332da70", size = 237145 }, + { url = "https://files.pythonhosted.org/packages/ec/77/e985064c624230f61efa0423759bb066da56ebe40c654f8b5ba225bd5d63/rpds_py-0.23.1-cp313-cp313t-macosx_10_12_x86_64.whl", hash = "sha256:759462b2d0aa5a04be5b3e37fb8183615f47014ae6b116e17036b131985cb731", size = 359623 }, + { url = "https://files.pythonhosted.org/packages/62/d9/a33dcbf62b29e40559e012d525bae7d516757cf042cc9234bd34ca4b6aeb/rpds_py-0.23.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:3e9212f52074fc9d72cf242a84063787ab8e21e0950d4d6709886fb62bcb91d5", size = 345900 }, + { url = "https://files.pythonhosted.org/packages/92/eb/f81a4be6397861adb2cb868bb6a28a33292c2dcac567d1dc575226055e55/rpds_py-0.23.1-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9e9f3a3ac919406bc0414bbbd76c6af99253c507150191ea79fab42fdb35982a", size = 386426 }, + { url = "https://files.pythonhosted.org/packages/09/47/1f810c9b5e83be005341201b5389f1d240dfa440346ea7189f9b3fd6961d/rpds_py-0.23.1-cp313-cp313t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:c04ca91dda8a61584165825907f5c967ca09e9c65fe8966ee753a3f2b019fe1e", size = 392314 }, + { url = "https://files.pythonhosted.org/packages/83/bd/bc95831432fd6c46ed8001f01af26de0763a059d6d7e6d69e3c5bf02917a/rpds_py-0.23.1-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4ab923167cfd945abb9b51a407407cf19f5bee35001221f2911dc85ffd35ff4f", size = 447706 }, + { url = "https://files.pythonhosted.org/packages/19/3e/567c04c226b1802dc6dc82cad3d53e1fa0a773258571c74ac5d8fbde97ed/rpds_py-0.23.1-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ed6f011bedca8585787e5082cce081bac3d30f54520097b2411351b3574e1219", size = 437060 }, + { url = "https://files.pythonhosted.org/packages/fe/77/a77d2c6afe27ae7d0d55fc32f6841502648070dc8d549fcc1e6d47ff8975/rpds_py-0.23.1-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6959bb9928c5c999aba4a3f5a6799d571ddc2c59ff49917ecf55be2bbb4e3722", size = 389347 }, + { url = "https://files.pythonhosted.org/packages/3f/47/6b256ff20a74cfebeac790ab05586e0ac91f88e331125d4740a6c86fc26f/rpds_py-0.23.1-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:1ed7de3c86721b4e83ac440751329ec6a1102229aa18163f84c75b06b525ad7e", size = 415554 }, + { url = "https://files.pythonhosted.org/packages/fc/29/d4572469a245bc9fc81e35166dca19fc5298d5c43e1a6dd64bf145045193/rpds_py-0.23.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:5fb89edee2fa237584e532fbf78f0ddd1e49a47c7c8cfa153ab4849dc72a35e6", size = 557418 }, + { url = "https://files.pythonhosted.org/packages/9c/0a/68cf7228895b1a3f6f39f51b15830e62456795e61193d2c8b87fd48c60db/rpds_py-0.23.1-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:7e5413d2e2d86025e73f05510ad23dad5950ab8417b7fc6beaad99be8077138b", size = 583033 }, + { url = "https://files.pythonhosted.org/packages/14/18/017ab41dcd6649ad5db7d00155b4c212b31ab05bd857d5ba73a1617984eb/rpds_py-0.23.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:d31ed4987d72aabdf521eddfb6a72988703c091cfc0064330b9e5f8d6a042ff5", size = 554880 }, + { url = "https://files.pythonhosted.org/packages/2e/dd/17de89431268da8819d8d51ce67beac28d9b22fccf437bc5d6d2bcd1acdb/rpds_py-0.23.1-cp313-cp313t-win32.whl", hash = "sha256:f3429fb8e15b20961efca8c8b21432623d85db2228cc73fe22756c6637aa39e7", size = 219743 }, + { url = "https://files.pythonhosted.org/packages/68/15/6d22d07e063ce5e9bfbd96db9ec2fbb4693591b4503e3a76996639474d02/rpds_py-0.23.1-cp313-cp313t-win_amd64.whl", hash = "sha256:d6f6512a90bd5cd9030a6237f5346f046c6f0e40af98657568fa45695d4de59d", size = 235415 }, + { url = "https://files.pythonhosted.org/packages/f8/a1/d3fb6a8de191f09fb88eacd1505ae1cab6ffc1c2b57ef62db6632e9b6216/rpds_py-0.23.1-cp39-cp39-macosx_10_12_x86_64.whl", hash = "sha256:09cd7dbcb673eb60518231e02874df66ec1296c01a4fcd733875755c02014b19", size = 372686 }, + { url = "https://files.pythonhosted.org/packages/b5/3a/bb96c8164aadfb2c9d7290e553e78e9816fcf3e22dcddc98bc1b83974c8e/rpds_py-0.23.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:c6760211eee3a76316cf328f5a8bd695b47b1626d21c8a27fb3b2473a884d597", size = 357098 }, + { url = "https://files.pythonhosted.org/packages/30/21/3de5d944f630a9fa6acf68191652e34e708041085770d426635c04dd60e3/rpds_py-0.23.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:72e680c1518733b73c994361e4b06441b92e973ef7d9449feec72e8ee4f713da", size = 386304 }, + { url = "https://files.pythonhosted.org/packages/f1/a5/d554cd53e865a45e41bea61b3ff91a12e50b7422f4a273d980c02a261b42/rpds_py-0.23.1-cp39-cp39-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ae28144c1daa61366205d32abd8c90372790ff79fc60c1a8ad7fd3c8553a600e", size = 391585 }, + { url = "https://files.pythonhosted.org/packages/72/5a/c53b507def60692e8c32fbafaa7ceb3cac81c5ab80f876ae6c8426be147d/rpds_py-0.23.1-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c698d123ce5d8f2d0cd17f73336615f6a2e3bdcedac07a1291bb4d8e7d82a05a", size = 445275 }, + { url = "https://files.pythonhosted.org/packages/05/15/1d68c0ad769a4bfb6cd2d1bff71bd2f4cbdf277d9b86c97f66f6fd107611/rpds_py-0.23.1-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:98b257ae1e83f81fb947a363a274c4eb66640212516becaff7bef09a5dceacaa", size = 445722 }, + { url = "https://files.pythonhosted.org/packages/5a/4b/21fabed47908f85084b845bd49cd9706071a8ec970cdfe72aca8364c9369/rpds_py-0.23.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5c9ff044eb07c8468594d12602291c635da292308c8c619244e30698e7fc455a", size = 386605 }, + { url = "https://files.pythonhosted.org/packages/bd/fe/6d949043b7daad8b730436fcd8524231653e6cd95d55b806666f7ef62b64/rpds_py-0.23.1-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:7938c7b0599a05246d704b3f5e01be91a93b411d0d6cc62275f025293b8a11ce", size = 417475 }, + { url = "https://files.pythonhosted.org/packages/4d/24/082e670e7d18cee2be04bbfa881e30b4c9ce1c139769d6ea0a8fd4aefdd0/rpds_py-0.23.1-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:e9cb79ecedfc156c0692257ac7ed415243b6c35dd969baa461a6888fc79f2f07", size = 559004 }, + { url = "https://files.pythonhosted.org/packages/51/48/ef27d68d569c3bde34f8be76352a391619d1fd2fc40f7cb8972b8fc5e54b/rpds_py-0.23.1-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:7b77e07233925bd33fc0022b8537774423e4c6680b6436316c5075e79b6384f4", size = 585260 }, + { url = "https://files.pythonhosted.org/packages/1b/6c/9599de109f16033f499542ba5792d6ebf2df0fd23124bd522351860c5c03/rpds_py-0.23.1-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:a970bfaf130c29a679b1d0a6e0f867483cea455ab1535fb427566a475078f27f", size = 555057 }, + { url = "https://files.pythonhosted.org/packages/cc/34/1dadb0b9ecbc7ce72f1d8666b70c5cd4891ff9af03d7e59f80018421ca3c/rpds_py-0.23.1-cp39-cp39-win32.whl", hash = "sha256:4233df01a250b3984465faed12ad472f035b7cd5240ea3f7c76b7a7016084495", size = 220756 }, + { url = "https://files.pythonhosted.org/packages/b3/cb/a01607dc98b438245a2fff09981fe2814234c0722d5ea22ddfa8eb5802ba/rpds_py-0.23.1-cp39-cp39-win_amd64.whl", hash = "sha256:c617d7453a80e29d9973b926983b1e700a9377dbe021faa36041c78537d7b08c", size = 232693 }, + { url = "https://files.pythonhosted.org/packages/95/a9/6fafd35fc6bac05f59bcbc800b57cef877911ff1c015397c519fec888642/rpds_py-0.23.1-pp310-pypy310_pp73-macosx_10_12_x86_64.whl", hash = "sha256:c1f8afa346ccd59e4e5630d5abb67aba6a9812fddf764fd7eb11f382a345f8cc", size = 373463 }, + { url = "https://files.pythonhosted.org/packages/5b/ac/44f00029b8fbe0903a19e9a87a9b86063bf8700df2cc58868373d378418c/rpds_py-0.23.1-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:fad784a31869747df4ac968a351e070c06ca377549e4ace94775aaa3ab33ee06", size = 358400 }, + { url = "https://files.pythonhosted.org/packages/5e/9c/3da199346c68d785f10dccab123b74c8c5f73be3f742c9e33d1116e07931/rpds_py-0.23.1-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b5a96fcac2f18e5a0a23a75cd27ce2656c66c11c127b0318e508aab436b77428", size = 386815 }, + { url = "https://files.pythonhosted.org/packages/d3/45/8f6533c33c0d33da8c2c8b2fb8f2ee90b23c05c679b86b0ac6aee4653749/rpds_py-0.23.1-pp310-pypy310_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:3e77febf227a1dc3220159355dba68faa13f8dca9335d97504abf428469fb18b", size = 392974 }, + { url = "https://files.pythonhosted.org/packages/ca/56/6a9ac1bf0455ba07385d8fe98c571c519b4f2000cff6581487bf9fab9272/rpds_py-0.23.1-pp310-pypy310_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:26bb3e8de93443d55e2e748e9fd87deb5f8075ca7bc0502cfc8be8687d69a2ec", size = 446019 }, + { url = "https://files.pythonhosted.org/packages/f4/83/5d9a3f9731cdccf49088bcc4ce821a5cf50bd1737cdad83e9959a7b9054d/rpds_py-0.23.1-pp310-pypy310_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:db7707dde9143a67b8812c7e66aeb2d843fe33cc8e374170f4d2c50bd8f2472d", size = 445811 }, + { url = "https://files.pythonhosted.org/packages/44/50/f2e0a98c62fc1fe68b176caca587714dc5c8bb2c3d1dd1eeb2bd4cc787ac/rpds_py-0.23.1-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1eedaaccc9bb66581d4ae7c50e15856e335e57ef2734dbc5fd8ba3e2a4ab3cb6", size = 388070 }, + { url = "https://files.pythonhosted.org/packages/f2/d0/4981878f8f157e6dbea01d95e0119bf3d6b4c2c884fe64a9e6987f941104/rpds_py-0.23.1-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:28358c54fffadf0ae893f6c1050e8f8853e45df22483b7fff2f6ab6152f5d8bf", size = 419173 }, + { url = "https://files.pythonhosted.org/packages/ce/13/fc971c470da96b270d2f64fedee987351bd935dc3016932a5cdcb1a88a2a/rpds_py-0.23.1-pp310-pypy310_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:633462ef7e61d839171bf206551d5ab42b30b71cac8f10a64a662536e057fdef", size = 559048 }, + { url = "https://files.pythonhosted.org/packages/42/02/be91e1de139ec8b4f9fec4192fd779ba48af281cfc762c0ca4c15b945484/rpds_py-0.23.1-pp310-pypy310_pp73-musllinux_1_2_i686.whl", hash = "sha256:a98f510d86f689fcb486dc59e6e363af04151e5260ad1bdddb5625c10f1e95f8", size = 584773 }, + { url = "https://files.pythonhosted.org/packages/27/28/3af8a1956df3edc41d884267d766dc096496dafc83f02f764a475eca0b4a/rpds_py-0.23.1-pp310-pypy310_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:e0397dd0b3955c61ef9b22838144aa4bef6f0796ba5cc8edfc64d468b93798b4", size = 555153 }, + { url = "https://files.pythonhosted.org/packages/5e/bb/e45f51c4e1327dea3c72b846c6de129eebacb7a6cb309af7af35d0578c80/rpds_py-0.23.1-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:75307599f0d25bf6937248e5ac4e3bde5ea72ae6618623b86146ccc7845ed00b", size = 233827 }, + { url = "https://files.pythonhosted.org/packages/b8/b5/7bf30fe885b6a6610a0ba984d40b7b70e1965ed9534a9fdeb53b12831dec/rpds_py-0.23.1-pp39-pypy39_pp73-macosx_10_12_x86_64.whl", hash = "sha256:3614d280bf7aab0d3721b5ce0e73434acb90a2c993121b6e81a1c15c665298ac", size = 373265 }, + { url = "https://files.pythonhosted.org/packages/40/b9/bdd81417fcaca7e0b204c38adfdf6de1c2662fdec447990081ff4eb204e8/rpds_py-0.23.1-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:e5963ea87f88bddf7edd59644a35a0feecf75f8985430124c253612d4f7d27ae", size = 358335 }, + { url = "https://files.pythonhosted.org/packages/75/cc/0878cf297fb06a031f0127dce5e692c5a89f1cdb0554187049bf2a4fc214/rpds_py-0.23.1-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ad76f44f70aac3a54ceb1813ca630c53415da3a24fd93c570b2dfb4856591017", size = 386969 }, + { url = "https://files.pythonhosted.org/packages/db/51/3be68a7e632d5bb4bfa539b0c0c6d590c1caea358d51331926d7b3102e2f/rpds_py-0.23.1-pp39-pypy39_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:2c6ae11e6e93728d86aafc51ced98b1658a0080a7dd9417d24bfb955bb09c3c2", size = 393101 }, + { url = "https://files.pythonhosted.org/packages/a9/30/3abe08087d86a9a8e23b5ebe2055de301a54542c7572a91e7af891626849/rpds_py-0.23.1-pp39-pypy39_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:fc869af5cba24d45fb0399b0cfdbcefcf6910bf4dee5d74036a57cf5264b3ff4", size = 446061 }, + { url = "https://files.pythonhosted.org/packages/08/a0/b6b0b100f8b7872d5f18b27d24687b61559d791491434d0976c986bb8c88/rpds_py-0.23.1-pp39-pypy39_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c76b32eb2ab650a29e423525e84eb197c45504b1c1e6e17b6cc91fcfeb1a4b1d", size = 445614 }, + { url = "https://files.pythonhosted.org/packages/d2/e4/451efd1fd8ffb9ae0b08cc2390ad7a1d2bb7049a78bd851c90ceb18fc265/rpds_py-0.23.1-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4263320ed887ed843f85beba67f8b2d1483b5947f2dc73a8b068924558bfeace", size = 387943 }, + { url = "https://files.pythonhosted.org/packages/8b/8e/805a4e6df48419cfa4433e8d4ec9596c02036bbc1b0d4a943aff828dd0cf/rpds_py-0.23.1-pp39-pypy39_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:7f9682a8f71acdf59fd554b82b1c12f517118ee72c0f3944eda461606dfe7eb9", size = 418552 }, + { url = "https://files.pythonhosted.org/packages/11/2e/807df78a7de1fc16d31f9c48d8620d99356a69728f6d5625f48e7183cd5c/rpds_py-0.23.1-pp39-pypy39_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:754fba3084b70162a6b91efceee8a3f06b19e43dac3f71841662053c0584209a", size = 559194 }, + { url = "https://files.pythonhosted.org/packages/3f/46/d5ba680221182cac547053f824f1aa99f4011b9429d526992e742926ea5a/rpds_py-0.23.1-pp39-pypy39_pp73-musllinux_1_2_i686.whl", hash = "sha256:a1c66e71ecfd2a4acf0e4bd75e7a3605afa8f9b28a3b497e4ba962719df2be57", size = 585645 }, + { url = "https://files.pythonhosted.org/packages/46/14/905045ee7234ebf8c0362862b89376a5708709ad748d20bc5bb68b111407/rpds_py-0.23.1-pp39-pypy39_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:8d67beb6002441faef8251c45e24994de32c4c8686f7356a1f601ad7c466f7c3", size = 554521 }, + { url = "https://files.pythonhosted.org/packages/22/40/67897b5b04d2741e256b0010bd825c9e6a30562f99fd6def038e8c0d0a97/rpds_py-0.23.1-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:a1e17d8dc8e57d8e0fd21f8f0f0a5211b3fa258b2e444c2053471ef93fe25a00", size = 233543 }, +] + +[[package]] +name = "ruff" +version = "0.11.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a0/ab/be73f46695c350147ffbfd98d42f34bfe370e6b4146bb0bfdc5b3c636fc7/ruff-0.11.1.tar.gz", hash = "sha256:f2e209a283c9fa423e268cad015ec4fb249178608f755fb67491ff175ecbffbf", size = 3850423 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/de/09/fa72b32fb7a1f670c8d3cb925910447c496117850c6aa1601365ad11cd00/ruff-0.11.1-py3-none-linux_armv6l.whl", hash = "sha256:9c833671aaefcbe280aa54da387264402ffbb1e513ff3420c9c7265ea56d6c5c", size = 10114855 }, + { url = "https://files.pythonhosted.org/packages/fa/c2/544da7ee0bf0a28117218065ccac69683d8d7a885544e6c84076cf72351b/ruff-0.11.1-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:a5a57cd457764228c73066b832040728b02a3837c53c8a781a960b68129c4e0b", size = 10870287 }, + { url = "https://files.pythonhosted.org/packages/ee/56/0d1c0a3f3ab644e813f365c7eee5d0f9b75e755c5642400cd6ad7070f730/ruff-0.11.1-py3-none-macosx_11_0_arm64.whl", hash = "sha256:da91da0d42e70cd8bda8e6687fab2afd28513a3cc9434539f4149610e63baf8f", size = 10223642 }, + { url = "https://files.pythonhosted.org/packages/d6/7c/88f06c23018ca02b8b0f78b62e4c701faa2ef6413d9f5e82277bc094d2e9/ruff-0.11.1-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:429a2e533e3a0dba2ba7e0608a736e728150aa9b6d179245aa11a1339baa968b", size = 10384382 }, + { url = "https://files.pythonhosted.org/packages/67/55/15d2a355e4c64a712938df4c650d7239128865981eb8314a49782a53ef45/ruff-0.11.1-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:6bbcc2984a4d5cbc0f7b10409e74a00a043be45d813e5e81eb58e707455df7f1", size = 9965192 }, + { url = "https://files.pythonhosted.org/packages/39/e8/4312a514fac213e90e5b45120339dbaa95a396f4cf3ab740e757fed4fa35/ruff-0.11.1-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:88d9c283ebc88faa5bc23fa33f399b6d47a93f5980c92edcddf1f2127aa376b3", size = 11563312 }, + { url = "https://files.pythonhosted.org/packages/69/ff/4da09bea58e1d784f45169fd281643422727a1c0776802cd6d4b42a0037d/ruff-0.11.1-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:1f2b03d504516d6b22065ce7fac2564dac15d79a6a776452dabfdd7673a45b07", size = 12223815 }, + { url = "https://files.pythonhosted.org/packages/ec/ba/7e3550f1478a53c4f7efcb0c31a03256eb032a871026da61324ad06dcd0b/ruff-0.11.1-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:52b95a9071f5ad8552af890bd814c6a04daf5b27297ac1054e3667016f3ab739", size = 11662551 }, + { url = "https://files.pythonhosted.org/packages/7d/69/7e2f1c8a0c76de18f9c054382d31c6d5f9b55a3e476b2630fefe289d31a6/ruff-0.11.1-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:28e2d89e7ba8a1525cdb50bc86c07aba35e7bbeef86dad93781b14ad94dc732c", size = 13792940 }, + { url = "https://files.pythonhosted.org/packages/02/4b/14f54bbf8f8dd03cb9a8a0294e7de1dc41f3be1806af07b8a104761db597/ruff-0.11.1-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e76be5a98dc6c29d85dfa72eb419e8d9276ee96ccf5c33f2b6828001907dcb17", size = 11328700 }, + { url = "https://files.pythonhosted.org/packages/f5/0c/40c1ba7e9a8c2c7325267c214746b80da1b54fb7e70a9265608213f4b2fb/ruff-0.11.1-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:441f94c44fe250691c92382ef84f40acef290766fb3e819a9035e83eadd4dbbe", size = 10272650 }, + { url = "https://files.pythonhosted.org/packages/a3/27/f86b786e0153c5b52768370f395086c4523dee1af37757a8ef73779b9fbd/ruff-0.11.1-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:62882a4cc7c0a48c2f34189bd4c7ba45f3d0efb990e02413eeb180aa042a39ca", size = 9973454 }, + { url = "https://files.pythonhosted.org/packages/ab/46/47bf0c7ee80b0476226865d724ee7682323a2cb20aa5d134b8a665f58793/ruff-0.11.1-py3-none-musllinux_1_2_i686.whl", hash = "sha256:111dbad1706d8200a7138237b4766b45ba7ee45cc8299c02102f4327624f86a2", size = 10975303 }, + { url = "https://files.pythonhosted.org/packages/9d/9d/deea8ece99f31aef07f378f83b5571baca74dff0d28fec720e54b171b862/ruff-0.11.1-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:e2df41763d7a9fd438b6b7bde7b75eb3a92ef2f4682ed2d8e4b997b5f0c76ca9", size = 11402605 }, + { url = "https://files.pythonhosted.org/packages/b8/8c/f11e21f4a5ce0858c35745d43e9a5abd870ed33e151ada23c124bf433e71/ruff-0.11.1-py3-none-win32.whl", hash = "sha256:e17b85919d461583aa7e0171bb4f419a6545b261ca080984db49b1f8dced1d4b", size = 10335500 }, + { url = "https://files.pythonhosted.org/packages/21/c9/ac2784bad48c7a8702d2f13851b69b2a08534b59657ee2b724f42aaaf861/ruff-0.11.1-py3-none-win_amd64.whl", hash = "sha256:caa872941b876f7ad73abc60144f9a7f6efb575e4f91c4fc1517f0339bcea01e", size = 11365097 }, + { url = "https://files.pythonhosted.org/packages/9e/7d/f37251c102cf155cdf664322f1f362f4fd8fe1eb6870e9154255d3cbf0d8/ruff-0.11.1-py3-none-win_arm64.whl", hash = "sha256:7aa939fa57ef6770d18bd5cf0d6de77198dd762a559bd0d4a8763bdae4c8cc16", size = 10510306 }, +] + +[[package]] +name = "setuptools" +version = "68.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/dc/98/5f896af066c128669229ff1aa81553ac14cfb3e5e74b6b44594132b8540e/setuptools-68.0.0.tar.gz", hash = "sha256:baf1fdb41c6da4cd2eae722e135500da913332ab3f2f5c7d33af9b492acb5235", size = 2194111 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c7/42/be1c7bbdd83e1bfb160c94b9cafd8e25efc7400346cf7ccdbdb452c467fa/setuptools-68.0.0-py3-none-any.whl", hash = "sha256:11e52c67415a381d10d6b462ced9cfb97066179f0e871399e006c4ab101fc85f", size = 804037 }, +] + +[[package]] +name = "six" +version = "1.17.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/94/e7/b2c673351809dca68a0e064b6af791aa332cf192da575fd474ed7d6f16a2/six-1.17.0.tar.gz", hash = "sha256:ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81", size = 34031 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274", size = 11050 }, +] + +[[package]] +name = "snowballstemmer" +version = "2.2.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/44/7b/af302bebf22c749c56c9c3e8ae13190b5b5db37a33d9068652e8f73b7089/snowballstemmer-2.2.0.tar.gz", hash = "sha256:09b16deb8547d3412ad7b590689584cd0fe25ec8db3be37788be3810cbf19cb1", size = 86699 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ed/dc/c02e01294f7265e63a7315fe086dd1df7dacb9f840a804da846b96d01b96/snowballstemmer-2.2.0-py2.py3-none-any.whl", hash = "sha256:c8e1716e83cc398ae16824e5572ae04e0d9fc2c6b985fb0f900f5f0c96ecba1a", size = 93002 }, +] + +[[package]] +name = "sortedcontainers" +version = "2.4.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e8/c4/ba2f8066cceb6f23394729afe52f3bf7adec04bf9ed2c820b39e19299111/sortedcontainers-2.4.0.tar.gz", hash = "sha256:25caa5a06cc30b6b83d11423433f65d1f9d76c4c6a0c90e3379eaa43b9bfdb88", size = 30594 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/32/46/9cb0e58b2deb7f82b84065f37f3bffeb12413f947f9388e4cac22c4621ce/sortedcontainers-2.4.0-py2.py3-none-any.whl", hash = "sha256:a163dcaede0f1c021485e957a39245190e74249897e2ae4b2aa38595db237ee0", size = 29575 }, +] + +[[package]] +name = "soupsieve" +version = "2.4.1" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine != 'aarch64' and platform_machine != 'arm64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'aarch64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'arm64'", + "python_full_version < '3.7.1'", +] +sdist = { url = "https://files.pythonhosted.org/packages/47/9e/780779233a615777fbdf75a4dee2af7a345f4bf74b42d4a5f836800b9d91/soupsieve-2.4.1.tar.gz", hash = "sha256:89d12b2d5dfcd2c9e8c22326da9d9aa9cb3dfab0a83a024f05704076ee8d35ea", size = 101278 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/49/37/673d6490efc51ec46d198c75903d99de59baffdd47aea3d071b80a9e4e89/soupsieve-2.4.1-py3-none-any.whl", hash = "sha256:1c1bfee6819544a3447586c889157365a27e10d88cde3ad3da0cf0ddf646feb8", size = 36379 }, +] + +[[package]] +name = "soupsieve" +version = "2.6" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", + "python_full_version == '3.10.*'", + "python_full_version == '3.9.*'", + "python_full_version == '3.8.*'", +] +sdist = { url = "https://files.pythonhosted.org/packages/d7/ce/fbaeed4f9fb8b2daa961f90591662df6a86c1abf25c548329a86920aedfb/soupsieve-2.6.tar.gz", hash = "sha256:e2e68417777af359ec65daac1057404a3c8a5455bb8abc36f1a9866ab1a51abb", size = 101569 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d1/c2/fe97d779f3ef3b15f05c94a2f1e3d21732574ed441687474db9d342a7315/soupsieve-2.6-py3-none-any.whl", hash = "sha256:e72c4ff06e4fb6e4b5a9f0f55fe6e81514581fca1515028625d0f299c602ccc9", size = 36186 }, +] + +[[package]] +name = "sphinx" +version = "5.3.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine != 'aarch64' and platform_machine != 'arm64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'aarch64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'arm64'", + "python_full_version < '3.7.1'", +] +dependencies = [ + { name = "alabaster", version = "0.7.13", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, + { name = "babel", version = "2.14.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, + { name = "colorama", marker = "python_full_version < '3.8' and sys_platform == 'win32'" }, + { name = "docutils", version = "0.19", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, + { name = "imagesize", marker = "python_full_version < '3.8'" }, + { name = "importlib-metadata", version = "6.7.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, + { name = "jinja2", marker = "python_full_version < '3.8'" }, + { name = "packaging", version = "24.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, + { name = "pygments", version = "2.17.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, + { name = "requests", version = "2.31.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, + { name = "snowballstemmer", marker = "python_full_version < '3.8'" }, + { name = "sphinxcontrib-applehelp", version = "1.0.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, + { name = "sphinxcontrib-devhelp", version = "1.0.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, + { name = "sphinxcontrib-htmlhelp", version = "2.0.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, + { name = "sphinxcontrib-jsmath", marker = "python_full_version < '3.8'" }, + { name = "sphinxcontrib-qthelp", version = "1.0.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, + { name = "sphinxcontrib-serializinghtml", version = "1.1.5", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.8'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/af/b2/02a43597980903483fe5eb081ee8e0ba2bb62ea43a70499484343795f3bf/Sphinx-5.3.0.tar.gz", hash = "sha256:51026de0a9ff9fc13c05d74913ad66047e104f56a129ff73e174eb5c3ee794b5", size = 6811365 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/67/a7/01dd6fd9653c056258d65032aa09a615b5d7b07dd840845a9f41a8860fbc/sphinx-5.3.0-py3-none-any.whl", hash = "sha256:060ca5c9f7ba57a08a1219e547b269fadf125ae25b06b9fa7f66768efb652d6d", size = 3183160 }, +] + +[[package]] +name = "sphinx" +version = "7.1.2" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version == '3.8.*'", +] +dependencies = [ + { name = "alabaster", version = "0.7.13", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.8.*'" }, + { name = "babel", version = "2.17.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.8.*'" }, + { name = "colorama", marker = "python_full_version == '3.8.*' and sys_platform == 'win32'" }, + { name = "docutils", version = "0.20.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.8.*'" }, + { name = "imagesize", marker = "python_full_version == '3.8.*'" }, + { name = "importlib-metadata", version = "8.5.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.8.*'" }, + { name = "jinja2", marker = "python_full_version == '3.8.*'" }, + { name = "packaging", version = "24.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.8.*'" }, + { name = "pygments", version = "2.19.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.8.*'" }, + { name = "requests", version = "2.32.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.8.*'" }, + { name = "snowballstemmer", marker = "python_full_version == '3.8.*'" }, + { name = "sphinxcontrib-applehelp", version = "1.0.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.8.*'" }, + { name = "sphinxcontrib-devhelp", version = "1.0.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.8.*'" }, + { name = "sphinxcontrib-htmlhelp", version = "2.0.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.8.*'" }, + { name = "sphinxcontrib-jsmath", marker = "python_full_version == '3.8.*'" }, + { name = "sphinxcontrib-qthelp", version = "1.0.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.8.*'" }, + { name = "sphinxcontrib-serializinghtml", version = "1.1.5", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.8.*'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/dc/01/688bdf9282241dca09fe6e3a1110eda399fa9b10d0672db609e37c2e7a39/sphinx-7.1.2.tar.gz", hash = "sha256:780f4d32f1d7d1126576e0e5ecc19dc32ab76cd24e950228dcf7b1f6d3d9e22f", size = 6828258 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/48/17/325cf6a257d84751a48ae90752b3d8fe0be8f9535b6253add61c49d0d9bc/sphinx-7.1.2-py3-none-any.whl", hash = "sha256:d170a81825b2fcacb6dfd5a0d7f578a053e45d3f2b153fecc948c37344eb4cbe", size = 3169543 }, +] + +[[package]] +name = "sphinx" +version = "7.4.7" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version == '3.9.*'", +] +dependencies = [ + { name = "alabaster", version = "0.7.16", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*'" }, + { name = "babel", version = "2.17.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*'" }, + { name = "colorama", marker = "python_full_version == '3.9.*' and sys_platform == 'win32'" }, + { name = "docutils", version = "0.21.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*'" }, + { name = "imagesize", marker = "python_full_version == '3.9.*'" }, + { name = "importlib-metadata", version = "8.6.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*'" }, + { name = "jinja2", marker = "python_full_version == '3.9.*'" }, + { name = "packaging", version = "24.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*'" }, + { name = "pygments", version = "2.19.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*'" }, + { name = "requests", version = "2.32.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*'" }, + { name = "snowballstemmer", marker = "python_full_version == '3.9.*'" }, + { name = "sphinxcontrib-applehelp", version = "2.0.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*'" }, + { name = "sphinxcontrib-devhelp", version = "2.0.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*'" }, + { name = "sphinxcontrib-htmlhelp", version = "2.1.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*'" }, + { name = "sphinxcontrib-jsmath", marker = "python_full_version == '3.9.*'" }, + { name = "sphinxcontrib-qthelp", version = "2.0.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*'" }, + { name = "sphinxcontrib-serializinghtml", version = "2.0.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*'" }, + { name = "tomli", version = "2.2.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/5b/be/50e50cb4f2eff47df05673d361095cafd95521d2a22521b920c67a372dcb/sphinx-7.4.7.tar.gz", hash = "sha256:242f92a7ea7e6c5b406fdc2615413890ba9f699114a9c09192d7dfead2ee9cfe", size = 8067911 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0d/ef/153f6803c5d5f8917dbb7f7fcf6d34a871ede3296fa89c2c703f5f8a6c8e/sphinx-7.4.7-py3-none-any.whl", hash = "sha256:c2419e2135d11f1951cd994d6eb18a1835bd8fdd8429f9ca375dc1f3281bd239", size = 3401624 }, +] + +[[package]] +name = "sphinx" +version = "8.1.3" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", + "python_full_version == '3.10.*'", +] +dependencies = [ + { name = "alabaster", version = "1.0.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, + { name = "babel", version = "2.17.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, + { name = "colorama", marker = "python_full_version >= '3.10' and sys_platform == 'win32'" }, + { name = "docutils", version = "0.21.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, + { name = "imagesize", marker = "python_full_version >= '3.10'" }, + { name = "jinja2", marker = "python_full_version >= '3.10'" }, + { name = "packaging", version = "24.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, + { name = "pygments", version = "2.19.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, + { name = "requests", version = "2.32.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, + { name = "snowballstemmer", marker = "python_full_version >= '3.10'" }, + { name = "sphinxcontrib-applehelp", version = "2.0.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, + { name = "sphinxcontrib-devhelp", version = "2.0.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, + { name = "sphinxcontrib-htmlhelp", version = "2.1.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, + { name = "sphinxcontrib-jsmath", marker = "python_full_version >= '3.10'" }, + { name = "sphinxcontrib-qthelp", version = "2.0.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, + { name = "sphinxcontrib-serializinghtml", version = "2.0.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, + { name = "tomli", version = "2.2.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.10.*'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/6f/6d/be0b61178fe2cdcb67e2a92fc9ebb488e3c51c4f74a36a7824c0adf23425/sphinx-8.1.3.tar.gz", hash = "sha256:43c1911eecb0d3e161ad78611bc905d1ad0e523e4ddc202a58a821773dc4c927", size = 8184611 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/26/60/1ddff83a56d33aaf6f10ec8ce84b4c007d9368b21008876fceda7e7381ef/sphinx-8.1.3-py3-none-any.whl", hash = "sha256:09719015511837b76bf6e03e42eb7595ac8c2e41eeb9c29c5b755c6b677992a2", size = 3487125 }, +] + +[[package]] +name = "sphinxcontrib-applehelp" +version = "1.0.2" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine != 'aarch64' and platform_machine != 'arm64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'aarch64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'arm64'", + "python_full_version < '3.7.1'", +] +sdist = { url = "https://files.pythonhosted.org/packages/9f/01/ad9d4ebbceddbed9979ab4a89ddb78c9760e74e6757b1880f1b2760e8295/sphinxcontrib-applehelp-1.0.2.tar.gz", hash = "sha256:a072735ec80e7675e3f432fcae8610ecf509c5f1869d17e2eecff44389cdbc58", size = 24548 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/dc/47/86022665a9433d89a66f5911b558ddff69861766807ba685de2e324bd6ed/sphinxcontrib_applehelp-1.0.2-py2.py3-none-any.whl", hash = "sha256:806111e5e962be97c29ec4c1e7fe277bfd19e9652fb1a4392105b43e01af885a", size = 121180 }, +] + +[[package]] +name = "sphinxcontrib-applehelp" +version = "1.0.4" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version == '3.8.*'", +] +sdist = { url = "https://files.pythonhosted.org/packages/32/df/45e827f4d7e7fcc84e853bcef1d836effd762d63ccb86f43ede4e98b478c/sphinxcontrib-applehelp-1.0.4.tar.gz", hash = "sha256:828f867945bbe39817c210a1abfd1bc4895c8b73fcaade56d45357a348a07d7e", size = 24766 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/06/c1/5e2cafbd03105ce50d8500f9b4e8a6e8d02e22d0475b574c3b3e9451a15f/sphinxcontrib_applehelp-1.0.4-py3-none-any.whl", hash = "sha256:29d341f67fb0f6f586b23ad80e072c8e6ad0b48417db2bde114a4c9746feb228", size = 120601 }, +] + +[[package]] +name = "sphinxcontrib-applehelp" +version = "2.0.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", + "python_full_version == '3.10.*'", + "python_full_version == '3.9.*'", +] +sdist = { url = "https://files.pythonhosted.org/packages/ba/6e/b837e84a1a704953c62ef8776d45c3e8d759876b4a84fe14eba2859106fe/sphinxcontrib_applehelp-2.0.0.tar.gz", hash = "sha256:2f29ef331735ce958efa4734873f084941970894c6090408b079c61b2e1c06d1", size = 20053 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5d/85/9ebeae2f76e9e77b952f4b274c27238156eae7979c5421fba91a28f4970d/sphinxcontrib_applehelp-2.0.0-py3-none-any.whl", hash = "sha256:4cd3f0ec4ac5dd9c17ec65e9ab272c9b867ea77425228e68ecf08d6b28ddbdb5", size = 119300 }, +] + +[[package]] +name = "sphinxcontrib-devhelp" +version = "1.0.2" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version == '3.8.*'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine != 'aarch64' and platform_machine != 'arm64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'aarch64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'arm64'", + "python_full_version < '3.7.1'", +] +sdist = { url = "https://files.pythonhosted.org/packages/98/33/dc28393f16385f722c893cb55539c641c9aaec8d1bc1c15b69ce0ac2dbb3/sphinxcontrib-devhelp-1.0.2.tar.gz", hash = "sha256:ff7f1afa7b9642e7060379360a67e9c41e8f3121f2ce9164266f61b9f4b338e4", size = 17398 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c5/09/5de5ed43a521387f18bdf5f5af31d099605c992fd25372b2b9b825ce48ee/sphinxcontrib_devhelp-1.0.2-py2.py3-none-any.whl", hash = "sha256:8165223f9a335cc1af7ffe1ed31d2871f325254c0423bc0c4c7cd1c1e4734a2e", size = 84690 }, +] + +[[package]] +name = "sphinxcontrib-devhelp" +version = "2.0.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", + "python_full_version == '3.10.*'", + "python_full_version == '3.9.*'", +] +sdist = { url = "https://files.pythonhosted.org/packages/f6/d2/5beee64d3e4e747f316bae86b55943f51e82bb86ecd325883ef65741e7da/sphinxcontrib_devhelp-2.0.0.tar.gz", hash = "sha256:411f5d96d445d1d73bb5d52133377b4248ec79db5c793ce7dbe59e074b4dd1ad", size = 12967 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/35/7a/987e583882f985fe4d7323774889ec58049171828b58c2217e7f79cdf44e/sphinxcontrib_devhelp-2.0.0-py3-none-any.whl", hash = "sha256:aefb8b83854e4b0998877524d1029fd3e6879210422ee3780459e28a1f03a8a2", size = 82530 }, +] + +[[package]] +name = "sphinxcontrib-htmlhelp" +version = "2.0.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine != 'aarch64' and platform_machine != 'arm64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'aarch64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'arm64'", + "python_full_version < '3.7.1'", +] +sdist = { url = "https://files.pythonhosted.org/packages/eb/85/93464ac9bd43d248e7c74573d58a791d48c475230bcf000df2b2700b9027/sphinxcontrib-htmlhelp-2.0.0.tar.gz", hash = "sha256:f5f8bb2d0d629f398bf47d0d69c07bc13b65f75a81ad9e2f71a63d4b7a2f6db2", size = 28144 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/63/40/c854ef09500e25f6432dcbad0f37df87fd7046d376272292d8654cc71c95/sphinxcontrib_htmlhelp-2.0.0-py2.py3-none-any.whl", hash = "sha256:d412243dfb797ae3ec2b59eca0e52dac12e75a241bf0e4eb861e450d06c6ed07", size = 100451 }, +] + +[[package]] +name = "sphinxcontrib-htmlhelp" +version = "2.0.1" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version == '3.8.*'", +] +sdist = { url = "https://files.pythonhosted.org/packages/b3/47/64cff68ea3aa450c373301e5bebfbb9fce0a3e70aca245fcadd4af06cd75/sphinxcontrib-htmlhelp-2.0.1.tar.gz", hash = "sha256:0cbdd302815330058422b98a113195c9249825d681e18f11e8b1f78a2f11efff", size = 27967 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/6e/ee/a1f5e39046cbb5f8bc8fba87d1ddf1c6643fbc9194e58d26e606de4b9074/sphinxcontrib_htmlhelp-2.0.1-py3-none-any.whl", hash = "sha256:c38cb46dccf316c79de6e5515e1770414b797162b23cd3d06e67020e1d2a6903", size = 99833 }, +] + +[[package]] +name = "sphinxcontrib-htmlhelp" +version = "2.1.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", + "python_full_version == '3.10.*'", + "python_full_version == '3.9.*'", +] +sdist = { url = "https://files.pythonhosted.org/packages/43/93/983afd9aa001e5201eab16b5a444ed5b9b0a7a010541e0ddfbbfd0b2470c/sphinxcontrib_htmlhelp-2.1.0.tar.gz", hash = "sha256:c9e2916ace8aad64cc13a0d233ee22317f2b9025b9cf3295249fa985cc7082e9", size = 22617 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0a/7b/18a8c0bcec9182c05a0b3ec2a776bba4ead82750a55ff798e8d406dae604/sphinxcontrib_htmlhelp-2.1.0-py3-none-any.whl", hash = "sha256:166759820b47002d22914d64a075ce08f4c46818e17cfc9470a9786b759b19f8", size = 98705 }, +] + +[[package]] +name = "sphinxcontrib-jsmath" +version = "1.0.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/b2/e8/9ed3830aeed71f17c026a07a5097edcf44b692850ef215b161b8ad875729/sphinxcontrib-jsmath-1.0.1.tar.gz", hash = "sha256:a9925e4a4587247ed2191a22df5f6970656cb8ca2bd6284309578f2153e0c4b8", size = 5787 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c2/42/4c8646762ee83602e3fb3fbe774c2fac12f317deb0b5dbeeedd2d3ba4b77/sphinxcontrib_jsmath-1.0.1-py2.py3-none-any.whl", hash = "sha256:2ec2eaebfb78f3f2078e73666b1415417a116cc848b72e5172e596c871103178", size = 5071 }, +] + +[[package]] +name = "sphinxcontrib-qthelp" +version = "1.0.3" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version == '3.8.*'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine != 'aarch64' and platform_machine != 'arm64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'aarch64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'arm64'", + "python_full_version < '3.7.1'", +] +sdist = { url = "https://files.pythonhosted.org/packages/b1/8e/c4846e59f38a5f2b4a0e3b27af38f2fcf904d4bfd82095bf92de0b114ebd/sphinxcontrib-qthelp-1.0.3.tar.gz", hash = "sha256:4c33767ee058b70dba89a6fc5c1892c0d57a54be67ddd3e7875a18d14cba5a72", size = 21658 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2b/14/05f9206cf4e9cfca1afb5fd224c7cd434dcc3a433d6d9e4e0264d29c6cdb/sphinxcontrib_qthelp-1.0.3-py2.py3-none-any.whl", hash = "sha256:bd9fc24bcb748a8d51fd4ecaade681350aa63009a347a8c14e637895444dfab6", size = 90609 }, +] + +[[package]] +name = "sphinxcontrib-qthelp" +version = "2.0.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", + "python_full_version == '3.10.*'", + "python_full_version == '3.9.*'", +] +sdist = { url = "https://files.pythonhosted.org/packages/68/bc/9104308fc285eb3e0b31b67688235db556cd5b0ef31d96f30e45f2e51cae/sphinxcontrib_qthelp-2.0.0.tar.gz", hash = "sha256:4fe7d0ac8fc171045be623aba3e2a8f613f8682731f9153bb2e40ece16b9bbab", size = 17165 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/27/83/859ecdd180cacc13b1f7e857abf8582a64552ea7a061057a6c716e790fce/sphinxcontrib_qthelp-2.0.0-py3-none-any.whl", hash = "sha256:b18a828cdba941ccd6ee8445dbe72ffa3ef8cbe7505d8cd1fa0d42d3f2d5f3eb", size = 88743 }, +] + +[[package]] +name = "sphinxcontrib-serializinghtml" +version = "1.1.5" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version == '3.8.*'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine != 'aarch64' and platform_machine != 'arm64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'aarch64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'arm64'", + "python_full_version < '3.7.1'", +] +sdist = { url = "https://files.pythonhosted.org/packages/b5/72/835d6fadb9e5d02304cf39b18f93d227cd93abd3c41ebf58e6853eeb1455/sphinxcontrib-serializinghtml-1.1.5.tar.gz", hash = "sha256:aa5f6de5dfdf809ef505c4895e51ef5c9eac17d0f287933eb49ec495280b6952", size = 21019 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c6/77/5464ec50dd0f1c1037e3c93249b040c8fc8078fdda97530eeb02424b6eea/sphinxcontrib_serializinghtml-1.1.5-py2.py3-none-any.whl", hash = "sha256:352a9a00ae864471d3a7ead8d7d79f5fc0b57e8b3f95e9867eb9eb28999b92fd", size = 94021 }, +] + +[[package]] +name = "sphinxcontrib-serializinghtml" +version = "2.0.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", + "python_full_version == '3.10.*'", + "python_full_version == '3.9.*'", +] +sdist = { url = "https://files.pythonhosted.org/packages/3b/44/6716b257b0aa6bfd51a1b31665d1c205fb12cb5ad56de752dfa15657de2f/sphinxcontrib_serializinghtml-2.0.0.tar.gz", hash = "sha256:e9d912827f872c029017a53f0ef2180b327c3f7fd23c87229f7a8e8b70031d4d", size = 16080 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/52/a7/d2782e4e3f77c8450f727ba74a8f12756d5ba823d81b941f1b04da9d033a/sphinxcontrib_serializinghtml-2.0.0-py3-none-any.whl", hash = "sha256:6e2cb0eef194e10c27ec0023bfeb25badbbb5868244cf5bc5bdc04e4464bf331", size = 92072 }, +] + +[[package]] +name = "sphobjinv" +version = "2.3.1.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "attrs", version = "25.3.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.9'" }, + { name = "certifi", marker = "python_full_version >= '3.9'" }, + { name = "jsonschema", version = "4.23.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.9'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/8c/5e/cf2c54fcc6cc999f64d3a34edeee1ca69d6e1f8aee40772c5f3f036296dc/sphobjinv-2.3.1.2.tar.gz", hash = "sha256:1c874a368460851352d45c92afa172b5c42653b47e2e70d78d61dac93308aa9d", size = 268026 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9c/4d/103e541e2533df159e1070cd4372b447a0b689e08a49d271b7b950e21f92/sphobjinv-2.3.1.2-py3-none-any.whl", hash = "sha256:66478d1787d28ef3ebeeedad57c592fdea04cf10eeed0df56307c85ab4eee789", size = 50820 }, +] + +[[package]] +name = "stack-data" +version = "0.6.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "asttokens", marker = "python_full_version >= '3.8'" }, + { name = "executing", marker = "python_full_version >= '3.8'" }, + { name = "pure-eval", marker = "python_full_version >= '3.8'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/28/e3/55dcc2cfbc3ca9c29519eb6884dd1415ecb53b0e934862d3559ddcb7e20b/stack_data-0.6.3.tar.gz", hash = "sha256:836a778de4fec4dcd1dcd89ed8abff8a221f58308462e1c4aa2a3cf30148f0b9", size = 44707 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f1/7b/ce1eafaf1a76852e2ec9b22edecf1daa58175c090266e9f6c64afcd81d91/stack_data-0.6.3-py3-none-any.whl", hash = "sha256:d5558e0c25a4cb0853cddad3d77da9891a08cb85dd9f9f91b9f8cd66e511e695", size = 24521 }, +] + +[[package]] +name = "tabulate" +version = "0.9.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ec/fe/802052aecb21e3797b8f7902564ab6ea0d60ff8ca23952079064155d1ae1/tabulate-0.9.0.tar.gz", hash = "sha256:0095b12bf5966de529c0feb1fa08671671b3368eec77d7ef7ab114be2c068b3c", size = 81090 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/40/44/4a5f08c96eb108af5cb50b41f76142f0afa346dfa99d5296fe7202a11854/tabulate-0.9.0-py3-none-any.whl", hash = "sha256:024ca478df22e9340661486f85298cff5f6dcdba14f3813e8830015b9ed1948f", size = 35252 }, +] + +[[package]] +name = "termcolor" +version = "2.3.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine != 'aarch64' and platform_machine != 'arm64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'aarch64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'arm64'", + "python_full_version < '3.7.1'", +] +sdist = { url = "https://files.pythonhosted.org/packages/b8/85/147a0529b4e80b6b9d021ca8db3a820fcac53ec7374b87073d004aaf444c/termcolor-2.3.0.tar.gz", hash = "sha256:b5b08f68937f138fe92f6c089b99f1e2da0ae56c52b78bf7075fd95420fd9a5a", size = 12163 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/67/e1/434566ffce04448192369c1a282931cf4ae593e91907558eaecd2e9f2801/termcolor-2.3.0-py3-none-any.whl", hash = "sha256:3afb05607b89aed0ffe25202399ee0867ad4d3cb4180d98aaf8eefa6a5f7d475", size = 6872 }, +] + +[[package]] +name = "termcolor" +version = "2.4.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version == '3.8.*'", +] +sdist = { url = "https://files.pythonhosted.org/packages/10/56/d7d66a84f96d804155f6ff2873d065368b25a07222a6fd51c4f24ef6d764/termcolor-2.4.0.tar.gz", hash = "sha256:aab9e56047c8ac41ed798fa36d892a37aca6b3e9159f3e0c24bc64a9b3ac7b7a", size = 12664 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d9/5f/8c716e47b3a50cbd7c146f45881e11d9414def768b7cd9c5e6650ec2a80a/termcolor-2.4.0-py3-none-any.whl", hash = "sha256:9297c0df9c99445c2412e832e882a7884038a25617c60cea2ad69488d4040d63", size = 7719 }, +] + +[[package]] +name = "termcolor" +version = "2.5.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", + "python_full_version == '3.10.*'", + "python_full_version == '3.9.*'", +] +sdist = { url = "https://files.pythonhosted.org/packages/37/72/88311445fd44c455c7d553e61f95412cf89054308a1aa2434ab835075fc5/termcolor-2.5.0.tar.gz", hash = "sha256:998d8d27da6d48442e8e1f016119076b690d962507531df4890fcd2db2ef8a6f", size = 13057 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7f/be/df630c387a0a054815d60be6a97eb4e8f17385d5d6fe660e1c02750062b4/termcolor-2.5.0-py3-none-any.whl", hash = "sha256:37b17b5fc1e604945c2642c872a3764b5d547a48009871aea3edd3afa180afb8", size = 7755 }, +] + +[[package]] +name = "tinycss2" +version = "1.2.1" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version == '3.8.*'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine != 'aarch64' and platform_machine != 'arm64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'aarch64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'arm64'", + "python_full_version < '3.7.1'", +] +dependencies = [ + { name = "webencodings", marker = "python_full_version < '3.9'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/75/be/24179dfaa1d742c9365cbd0e3f0edc5d3aa3abad415a2327c5a6ff8ca077/tinycss2-1.2.1.tar.gz", hash = "sha256:8cff3a8f066c2ec677c06dbc7b45619804a6938478d9d73c284b29d14ecb0627", size = 65957 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/da/99/fd23634d6962c2791fb8cb6ccae1f05dcbfc39bce36bba8b1c9a8d92eae8/tinycss2-1.2.1-py3-none-any.whl", hash = "sha256:2b80a96d41e7c3914b8cda8bc7f705a4d9c49275616e886103dd839dfc847847", size = 21824 }, +] + +[[package]] +name = "tinycss2" +version = "1.4.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", + "python_full_version == '3.10.*'", + "python_full_version == '3.9.*'", +] +dependencies = [ + { name = "webencodings", marker = "python_full_version >= '3.9'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/7a/fd/7a5ee21fd08ff70d3d33a5781c255cbe779659bd03278feb98b19ee550f4/tinycss2-1.4.0.tar.gz", hash = "sha256:10c0972f6fc0fbee87c3edb76549357415e94548c1ae10ebccdea16fb404a9b7", size = 87085 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e6/34/ebdc18bae6aa14fbee1a08b63c015c72b64868ff7dae68808ab500c492e2/tinycss2-1.4.0-py3-none-any.whl", hash = "sha256:3a49cf47b7675da0b15d0c6e1df8df4ebd96e9394bb905a5775adb0d884c5289", size = 26610 }, +] + +[[package]] +name = "tomli" +version = "2.0.1" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine != 'aarch64' and platform_machine != 'arm64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'aarch64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'arm64'", + "python_full_version < '3.7.1'", +] +sdist = { url = "https://files.pythonhosted.org/packages/c0/3f/d7af728f075fb08564c5949a9c95e44352e23dee646869fa104a3b2060a3/tomli-2.0.1.tar.gz", hash = "sha256:de526c12914f0c550d15924c62d72abc48d6fe7364aa87328337a31007fe8a4f", size = 15164 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/97/75/10a9ebee3fd790d20926a90a2547f0bf78f371b2f13aa822c759680ca7b9/tomli-2.0.1-py3-none-any.whl", hash = "sha256:939de3e7a6161af0c887ef91b7d41a53e7c5a1ca976325f429cb46ea9bc30ecc", size = 12757 }, +] + +[[package]] +name = "tomli" +version = "2.2.1" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version == '3.11.*'", + "python_full_version == '3.10.*'", + "python_full_version == '3.9.*'", + "python_full_version == '3.8.*'", +] +sdist = { url = "https://files.pythonhosted.org/packages/18/87/302344fed471e44a87289cf4967697d07e532f2421fdaf868a303cbae4ff/tomli-2.2.1.tar.gz", hash = "sha256:cd45e1dc79c835ce60f7404ec8119f2eb06d38b1deba146f07ced3bbc44505ff", size = 17175 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/43/ca/75707e6efa2b37c77dadb324ae7d9571cb424e61ea73fad7c56c2d14527f/tomli-2.2.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:678e4fa69e4575eb77d103de3df8a895e1591b48e740211bd1067378c69e8249", size = 131077 }, + { url = "https://files.pythonhosted.org/packages/c7/16/51ae563a8615d472fdbffc43a3f3d46588c264ac4f024f63f01283becfbb/tomli-2.2.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:023aa114dd824ade0100497eb2318602af309e5a55595f76b626d6d9f3b7b0a6", size = 123429 }, + { url = "https://files.pythonhosted.org/packages/f1/dd/4f6cd1e7b160041db83c694abc78e100473c15d54620083dbd5aae7b990e/tomli-2.2.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ece47d672db52ac607a3d9599a9d48dcb2f2f735c6c2d1f34130085bb12b112a", size = 226067 }, + { url = "https://files.pythonhosted.org/packages/a9/6b/c54ede5dc70d648cc6361eaf429304b02f2871a345bbdd51e993d6cdf550/tomli-2.2.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6972ca9c9cc9f0acaa56a8ca1ff51e7af152a9f87fb64623e31d5c83700080ee", size = 236030 }, + { url = "https://files.pythonhosted.org/packages/1f/47/999514fa49cfaf7a92c805a86c3c43f4215621855d151b61c602abb38091/tomli-2.2.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c954d2250168d28797dd4e3ac5cf812a406cd5a92674ee4c8f123c889786aa8e", size = 240898 }, + { url = "https://files.pythonhosted.org/packages/73/41/0a01279a7ae09ee1573b423318e7934674ce06eb33f50936655071d81a24/tomli-2.2.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:8dd28b3e155b80f4d54beb40a441d366adcfe740969820caf156c019fb5c7ec4", size = 229894 }, + { url = "https://files.pythonhosted.org/packages/55/18/5d8bc5b0a0362311ce4d18830a5d28943667599a60d20118074ea1b01bb7/tomli-2.2.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:e59e304978767a54663af13c07b3d1af22ddee3bb2fb0618ca1593e4f593a106", size = 245319 }, + { url = "https://files.pythonhosted.org/packages/92/a3/7ade0576d17f3cdf5ff44d61390d4b3febb8a9fc2b480c75c47ea048c646/tomli-2.2.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:33580bccab0338d00994d7f16f4c4ec25b776af3ffaac1ed74e0b3fc95e885a8", size = 238273 }, + { url = "https://files.pythonhosted.org/packages/72/6f/fa64ef058ac1446a1e51110c375339b3ec6be245af9d14c87c4a6412dd32/tomli-2.2.1-cp311-cp311-win32.whl", hash = "sha256:465af0e0875402f1d226519c9904f37254b3045fc5084697cefb9bdde1ff99ff", size = 98310 }, + { url = "https://files.pythonhosted.org/packages/6a/1c/4a2dcde4a51b81be3530565e92eda625d94dafb46dbeb15069df4caffc34/tomli-2.2.1-cp311-cp311-win_amd64.whl", hash = "sha256:2d0f2fdd22b02c6d81637a3c95f8cd77f995846af7414c5c4b8d0545afa1bc4b", size = 108309 }, + { url = "https://files.pythonhosted.org/packages/52/e1/f8af4c2fcde17500422858155aeb0d7e93477a0d59a98e56cbfe75070fd0/tomli-2.2.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:4a8f6e44de52d5e6c657c9fe83b562f5f4256d8ebbfe4ff922c495620a7f6cea", size = 132762 }, + { url = "https://files.pythonhosted.org/packages/03/b8/152c68bb84fc00396b83e7bbddd5ec0bd3dd409db4195e2a9b3e398ad2e3/tomli-2.2.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8d57ca8095a641b8237d5b079147646153d22552f1c637fd3ba7f4b0b29167a8", size = 123453 }, + { url = "https://files.pythonhosted.org/packages/c8/d6/fc9267af9166f79ac528ff7e8c55c8181ded34eb4b0e93daa767b8841573/tomli-2.2.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4e340144ad7ae1533cb897d406382b4b6fede8890a03738ff1683af800d54192", size = 233486 }, + { url = "https://files.pythonhosted.org/packages/5c/51/51c3f2884d7bab89af25f678447ea7d297b53b5a3b5730a7cb2ef6069f07/tomli-2.2.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:db2b95f9de79181805df90bedc5a5ab4c165e6ec3fe99f970d0e302f384ad222", size = 242349 }, + { url = "https://files.pythonhosted.org/packages/ab/df/bfa89627d13a5cc22402e441e8a931ef2108403db390ff3345c05253935e/tomli-2.2.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:40741994320b232529c802f8bc86da4e1aa9f413db394617b9a256ae0f9a7f77", size = 252159 }, + { url = "https://files.pythonhosted.org/packages/9e/6e/fa2b916dced65763a5168c6ccb91066f7639bdc88b48adda990db10c8c0b/tomli-2.2.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:400e720fe168c0f8521520190686ef8ef033fb19fc493da09779e592861b78c6", size = 237243 }, + { url = "https://files.pythonhosted.org/packages/b4/04/885d3b1f650e1153cbb93a6a9782c58a972b94ea4483ae4ac5cedd5e4a09/tomli-2.2.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:02abe224de6ae62c19f090f68da4e27b10af2b93213d36cf44e6e1c5abd19fdd", size = 259645 }, + { url = "https://files.pythonhosted.org/packages/9c/de/6b432d66e986e501586da298e28ebeefd3edc2c780f3ad73d22566034239/tomli-2.2.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:b82ebccc8c8a36f2094e969560a1b836758481f3dc360ce9a3277c65f374285e", size = 244584 }, + { url = "https://files.pythonhosted.org/packages/1c/9a/47c0449b98e6e7d1be6cbac02f93dd79003234ddc4aaab6ba07a9a7482e2/tomli-2.2.1-cp312-cp312-win32.whl", hash = "sha256:889f80ef92701b9dbb224e49ec87c645ce5df3fa2cc548664eb8a25e03127a98", size = 98875 }, + { url = "https://files.pythonhosted.org/packages/ef/60/9b9638f081c6f1261e2688bd487625cd1e660d0a85bd469e91d8db969734/tomli-2.2.1-cp312-cp312-win_amd64.whl", hash = "sha256:7fc04e92e1d624a4a63c76474610238576942d6b8950a2d7f908a340494e67e4", size = 109418 }, + { url = "https://files.pythonhosted.org/packages/04/90/2ee5f2e0362cb8a0b6499dc44f4d7d48f8fff06d28ba46e6f1eaa61a1388/tomli-2.2.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f4039b9cbc3048b2416cc57ab3bda989a6fcf9b36cf8937f01a6e731b64f80d7", size = 132708 }, + { url = "https://files.pythonhosted.org/packages/c0/ec/46b4108816de6b385141f082ba99e315501ccd0a2ea23db4a100dd3990ea/tomli-2.2.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:286f0ca2ffeeb5b9bd4fcc8d6c330534323ec51b2f52da063b11c502da16f30c", size = 123582 }, + { url = "https://files.pythonhosted.org/packages/a0/bd/b470466d0137b37b68d24556c38a0cc819e8febe392d5b199dcd7f578365/tomli-2.2.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a92ef1a44547e894e2a17d24e7557a5e85a9e1d0048b0b5e7541f76c5032cb13", size = 232543 }, + { url = "https://files.pythonhosted.org/packages/d9/e5/82e80ff3b751373f7cead2815bcbe2d51c895b3c990686741a8e56ec42ab/tomli-2.2.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9316dc65bed1684c9a98ee68759ceaed29d229e985297003e494aa825ebb0281", size = 241691 }, + { url = "https://files.pythonhosted.org/packages/05/7e/2a110bc2713557d6a1bfb06af23dd01e7dde52b6ee7dadc589868f9abfac/tomli-2.2.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e85e99945e688e32d5a35c1ff38ed0b3f41f43fad8df0bdf79f72b2ba7bc5272", size = 251170 }, + { url = "https://files.pythonhosted.org/packages/64/7b/22d713946efe00e0adbcdfd6d1aa119ae03fd0b60ebed51ebb3fa9f5a2e5/tomli-2.2.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ac065718db92ca818f8d6141b5f66369833d4a80a9d74435a268c52bdfa73140", size = 236530 }, + { url = "https://files.pythonhosted.org/packages/38/31/3a76f67da4b0cf37b742ca76beaf819dca0ebef26d78fc794a576e08accf/tomli-2.2.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:d920f33822747519673ee656a4b6ac33e382eca9d331c87770faa3eef562aeb2", size = 258666 }, + { url = "https://files.pythonhosted.org/packages/07/10/5af1293da642aded87e8a988753945d0cf7e00a9452d3911dd3bb354c9e2/tomli-2.2.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:a198f10c4d1b1375d7687bc25294306e551bf1abfa4eace6650070a5c1ae2744", size = 243954 }, + { url = "https://files.pythonhosted.org/packages/5b/b9/1ed31d167be802da0fc95020d04cd27b7d7065cc6fbefdd2f9186f60d7bd/tomli-2.2.1-cp313-cp313-win32.whl", hash = "sha256:d3f5614314d758649ab2ab3a62d4f2004c825922f9e370b29416484086b264ec", size = 98724 }, + { url = "https://files.pythonhosted.org/packages/c7/32/b0963458706accd9afcfeb867c0f9175a741bf7b19cd424230714d722198/tomli-2.2.1-cp313-cp313-win_amd64.whl", hash = "sha256:a38aa0308e754b0e3c67e344754dff64999ff9b513e691d0e786265c93583c69", size = 109383 }, + { url = "https://files.pythonhosted.org/packages/6e/c2/61d3e0f47e2b74ef40a68b9e6ad5984f6241a942f7cd3bbfbdbd03861ea9/tomli-2.2.1-py3-none-any.whl", hash = "sha256:cb55c73c5f4408779d0cf3eef9f762b9c9f147a77de7b258bef0a5628adc85cc", size = 14257 }, +] + +[[package]] +name = "tornado" +version = "6.2" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine != 'aarch64' and platform_machine != 'arm64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'aarch64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'arm64'", + "python_full_version < '3.7.1'", +] +sdist = { url = "https://files.pythonhosted.org/packages/f3/9e/225a41452f2d9418d89be5e32cf824c84fe1e639d350d6e8d49db5b7f73a/tornado-6.2.tar.gz", hash = "sha256:9b630419bde84ec666bfd7ea0a4cb2a8a651c2d5cccdbdd1972a0c859dfc3c13", size = 504849 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fb/bd/074254a55bfc82d7a1886abbd803600ef01cbd76ee66bc30307b2724130b/tornado-6.2-cp37-abi3-macosx_10_9_universal2.whl", hash = "sha256:20f638fd8cc85f3cbae3c732326e96addff0a15e22d80f049e00121651e82e72", size = 421754 }, + { url = "https://files.pythonhosted.org/packages/5c/0c/cbc0a98f7b8ef833bcb13c58d35d09e2c288ae67a35af4c8960b88f99ae9/tornado-6.2-cp37-abi3-macosx_10_9_x86_64.whl", hash = "sha256:87dcafae3e884462f90c90ecc200defe5e580a7fbbb4365eda7c7c1eb809ebc9", size = 419666 }, + { url = "https://files.pythonhosted.org/packages/71/cc/c1342382484d0178a79029109c433e406a60095da1c3605ca966775a70e5/tornado-6.2-cp37-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ba09ef14ca9893954244fd872798b4ccb2367c165946ce2dd7376aebdde8e3ac", size = 424391 }, + { url = "https://files.pythonhosted.org/packages/11/30/ac70f5c5f03cf1cd0ae8199c80382387a9fe57e8f68853d5c9527c0219e5/tornado-6.2-cp37-abi3-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b8150f721c101abdef99073bf66d3903e292d851bee51910839831caba341a75", size = 423771 }, + { url = "https://files.pythonhosted.org/packages/19/bb/b6c3d1668d2b10ad38a584f3a1ec9737984e274f8b708e09fcbb96427f5c/tornado-6.2-cp37-abi3-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d3a2f5999215a3a06a4fc218026cd84c61b8b2b40ac5296a6db1f1451ef04c1e", size = 423970 }, + { url = "https://files.pythonhosted.org/packages/cd/a4/761e45cea12b2af076d36240d464b371ab1231272948cdc49b7d81855c5c/tornado-6.2-cp37-abi3-musllinux_1_1_aarch64.whl", hash = "sha256:5f8c52d219d4995388119af7ccaa0bcec289535747620116a58d830e7c25d8a8", size = 426534 }, + { url = "https://files.pythonhosted.org/packages/60/08/e630a348b34a9ddd640aed67dafc6f0df425d8ac07d2fa60288f38321c69/tornado-6.2-cp37-abi3-musllinux_1_1_i686.whl", hash = "sha256:6fdfabffd8dfcb6cf887428849d30cf19a3ea34c2c248461e1f7d718ad30b66b", size = 426504 }, + { url = "https://files.pythonhosted.org/packages/f9/51/6f63a166d9a3077be100cbb13dcbce434e5654daaaa7003b0a045b9f6edf/tornado-6.2-cp37-abi3-musllinux_1_1_x86_64.whl", hash = "sha256:1d54d13ab8414ed44de07efecb97d4ef7c39f7438cf5e976ccd356bebb1b5fca", size = 426523 }, + { url = "https://files.pythonhosted.org/packages/ec/01/93e63530851ba8ef9685f1a9b91e324b28d28323a6b67400114ea65c5110/tornado-6.2-cp37-abi3-win32.whl", hash = "sha256:5c87076709343557ef8032934ce5f637dbb552efa7b21d08e89ae7619ed0eb23", size = 424877 }, + { url = "https://files.pythonhosted.org/packages/1c/26/cbfa1103e74a02e09dd53291e419da3ad4c5b948f52aea5800e6671b56e0/tornado-6.2-cp37-abi3-win_amd64.whl", hash = "sha256:e5f923aa6a47e133d1cf87d60700889d7eae68988704e20c75fb2d65677a8e4b", size = 425329 }, +] + +[[package]] +name = "tornado" +version = "6.4.2" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", + "python_full_version == '3.10.*'", + "python_full_version == '3.9.*'", + "python_full_version == '3.8.*'", +] +sdist = { url = "https://files.pythonhosted.org/packages/59/45/a0daf161f7d6f36c3ea5fc0c2de619746cc3dd4c76402e9db545bd920f63/tornado-6.4.2.tar.gz", hash = "sha256:92bad5b4746e9879fd7bf1eb21dce4e3fc5128d71601f80005afa39237ad620b", size = 501135 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/26/7e/71f604d8cea1b58f82ba3590290b66da1e72d840aeb37e0d5f7291bd30db/tornado-6.4.2-cp38-abi3-macosx_10_9_universal2.whl", hash = "sha256:e828cce1123e9e44ae2a50a9de3055497ab1d0aeb440c5ac23064d9e44880da1", size = 436299 }, + { url = "https://files.pythonhosted.org/packages/96/44/87543a3b99016d0bf54fdaab30d24bf0af2e848f1d13d34a3a5380aabe16/tornado-6.4.2-cp38-abi3-macosx_10_9_x86_64.whl", hash = "sha256:072ce12ada169c5b00b7d92a99ba089447ccc993ea2143c9ede887e0937aa803", size = 434253 }, + { url = "https://files.pythonhosted.org/packages/cb/fb/fdf679b4ce51bcb7210801ef4f11fdac96e9885daa402861751353beea6e/tornado-6.4.2-cp38-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1a017d239bd1bb0919f72af256a970624241f070496635784d9bf0db640d3fec", size = 437602 }, + { url = "https://files.pythonhosted.org/packages/4f/3b/e31aeffffc22b475a64dbeb273026a21b5b566f74dee48742817626c47dc/tornado-6.4.2-cp38-abi3-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c36e62ce8f63409301537222faffcef7dfc5284f27eec227389f2ad11b09d946", size = 436972 }, + { url = "https://files.pythonhosted.org/packages/22/55/b78a464de78051a30599ceb6983b01d8f732e6f69bf37b4ed07f642ac0fc/tornado-6.4.2-cp38-abi3-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bca9eb02196e789c9cb5c3c7c0f04fb447dc2adffd95265b2c7223a8a615ccbf", size = 437173 }, + { url = "https://files.pythonhosted.org/packages/79/5e/be4fb0d1684eb822c9a62fb18a3e44a06188f78aa466b2ad991d2ee31104/tornado-6.4.2-cp38-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:304463bd0772442ff4d0f5149c6f1c2135a1fae045adf070821c6cdc76980634", size = 437892 }, + { url = "https://files.pythonhosted.org/packages/f5/33/4f91fdd94ea36e1d796147003b490fe60a0215ac5737b6f9c65e160d4fe0/tornado-6.4.2-cp38-abi3-musllinux_1_2_i686.whl", hash = "sha256:c82c46813ba483a385ab2a99caeaedf92585a1f90defb5693351fa7e4ea0bf73", size = 437334 }, + { url = "https://files.pythonhosted.org/packages/2b/ae/c1b22d4524b0e10da2f29a176fb2890386f7bd1f63aacf186444873a88a0/tornado-6.4.2-cp38-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:932d195ca9015956fa502c6b56af9eb06106140d844a335590c1ec7f5277d10c", size = 437261 }, + { url = "https://files.pythonhosted.org/packages/b5/25/36dbd49ab6d179bcfc4c6c093a51795a4f3bed380543a8242ac3517a1751/tornado-6.4.2-cp38-abi3-win32.whl", hash = "sha256:2876cef82e6c5978fde1e0d5b1f919d756968d5b4282418f3146b79b58556482", size = 438463 }, + { url = "https://files.pythonhosted.org/packages/61/cc/58b1adeb1bb46228442081e746fcdbc4540905c87e8add7c277540934edb/tornado-6.4.2-cp38-abi3-win_amd64.whl", hash = "sha256:908b71bf3ff37d81073356a5fadcc660eb10c1476ee6e2725588626ce7e5ca38", size = 438907 }, +] + +[[package]] +name = "traitlets" +version = "5.9.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine != 'aarch64' and platform_machine != 'arm64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'aarch64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'arm64'", + "python_full_version < '3.7.1'", +] +sdist = { url = "https://files.pythonhosted.org/packages/39/c3/205e88f02959712b62008502952707313640369144a7fded4cbc61f48321/traitlets-5.9.0.tar.gz", hash = "sha256:f6cde21a9c68cf756af02035f72d5a723bf607e862e7be33ece505abf4a3bad9", size = 150207 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/77/75/c28e9ef7abec2b7e9ff35aea3e0be6c1aceaf7873c26c95ae1f0d594de71/traitlets-5.9.0-py3-none-any.whl", hash = "sha256:9e6ec080259b9a5940c797d58b613b5e31441c2257b87c2e795c5228ae80d2d8", size = 117376 }, +] + +[[package]] +name = "traitlets" +version = "5.14.3" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", + "python_full_version == '3.10.*'", + "python_full_version == '3.9.*'", + "python_full_version == '3.8.*'", +] +sdist = { url = "https://files.pythonhosted.org/packages/eb/79/72064e6a701c2183016abbbfedaba506d81e30e232a68c9f0d6f6fcd1574/traitlets-5.14.3.tar.gz", hash = "sha256:9ed0579d3502c94b4b3732ac120375cda96f923114522847de4b3bb98b96b6b7", size = 161621 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/00/c0/8f5d070730d7836adc9c9b6408dec68c6ced86b304a9b26a14df072a6e8c/traitlets-5.14.3-py3-none-any.whl", hash = "sha256:b74e89e397b1ed28cc831db7aea759ba6640cb3de13090ca145426688ff1ac4f", size = 85359 }, +] + +[[package]] +name = "typing-extensions" +version = "4.7.1" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine != 'aarch64' and platform_machine != 'arm64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'aarch64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'arm64'", + "python_full_version < '3.7.1'", +] +sdist = { url = "https://files.pythonhosted.org/packages/3c/8b/0111dd7d6c1478bf83baa1cab85c686426c7a6274119aceb2bd9d35395ad/typing_extensions-4.7.1.tar.gz", hash = "sha256:b75ddc264f0ba5615db7ba217daeb99701ad295353c45f9e95963337ceeeffb2", size = 72876 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ec/6b/63cc3df74987c36fe26157ee12e09e8f9db4de771e0f3404263117e75b95/typing_extensions-4.7.1-py3-none-any.whl", hash = "sha256:440d5dd3af93b060174bf433bccd69b0babc3b15b1a8dca43789fd7f61514b36", size = 33232 }, +] + +[[package]] +name = "typing-extensions" +version = "4.12.2" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", + "python_full_version == '3.10.*'", + "python_full_version == '3.9.*'", + "python_full_version == '3.8.*'", +] +sdist = { url = "https://files.pythonhosted.org/packages/df/db/f35a00659bc03fec321ba8bce9420de607a1d37f8342eee1863174c69557/typing_extensions-4.12.2.tar.gz", hash = "sha256:1a7ead55c7e559dd4dee8856e3a88b41225abfe1ce8df57b7c13915fe121ffb8", size = 85321 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/26/9f/ad63fc0248c5379346306f8668cda6e2e2e9c95e01216d2b8ffd9ff037d0/typing_extensions-4.12.2-py3-none-any.whl", hash = "sha256:04e5ca0351e0f3f85c6853954072df659d0d13fac324d0072316b67d7794700d", size = 37438 }, +] + +[[package]] +name = "tzdata" +version = "2025.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/43/0f/fa4723f22942480be4ca9527bbde8d43f6c3f2fe8412f00e7f5f6746bc8b/tzdata-2025.1.tar.gz", hash = "sha256:24894909e88cdb28bd1636c6887801df64cb485bd593f2fd83ef29075a81d694", size = 194950 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0f/dd/84f10e23edd882c6f968c21c2434fe67bd4a528967067515feca9e611e5e/tzdata-2025.1-py2.py3-none-any.whl", hash = "sha256:7e127113816800496f027041c570f50bcd464a020098a3b6b199517772303639", size = 346762 }, +] + +[[package]] +name = "urllib3" +version = "2.0.7" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine != 'aarch64' and platform_machine != 'arm64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'aarch64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'arm64'", + "python_full_version < '3.7.1'", +] +sdist = { url = "https://files.pythonhosted.org/packages/af/47/b215df9f71b4fdba1025fc05a77db2ad243fa0926755a52c5e71659f4e3c/urllib3-2.0.7.tar.gz", hash = "sha256:c97dfde1f7bd43a71c8d2a58e369e9b2bf692d1334ea9f9cae55add7d0dd0f84", size = 282546 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d2/b2/b157855192a68541a91ba7b2bbcb91f1b4faa51f8bae38d8005c034be524/urllib3-2.0.7-py3-none-any.whl", hash = "sha256:fdb6d215c776278489906c2f8916e6e7d4f5a9b602ccbcfdf7f016fc8da0596e", size = 124213 }, +] + +[[package]] +name = "urllib3" +version = "2.2.3" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version == '3.8.*'", +] +sdist = { url = "https://files.pythonhosted.org/packages/ed/63/22ba4ebfe7430b76388e7cd448d5478814d3032121827c12a2cc287e2260/urllib3-2.2.3.tar.gz", hash = "sha256:e7d814a81dad81e6caf2ec9fdedb284ecc9c73076b62654547cc64ccdcae26e9", size = 300677 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ce/d9/5f4c13cecde62396b0d3fe530a50ccea91e7dfc1ccf0e09c228841bb5ba8/urllib3-2.2.3-py3-none-any.whl", hash = "sha256:ca899ca043dcb1bafa3e262d73aa25c465bfb49e0bd9dd5d59f1d0acba2f8fac", size = 126338 }, +] + +[[package]] +name = "urllib3" +version = "2.3.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", + "python_full_version == '3.10.*'", + "python_full_version == '3.9.*'", +] +sdist = { url = "https://files.pythonhosted.org/packages/aa/63/e53da845320b757bf29ef6a9062f5c669fe997973f966045cb019c3f4b66/urllib3-2.3.0.tar.gz", hash = "sha256:f8c5449b3cf0861679ce7e0503c7b44b5ec981bec0d1d3795a07f1ba96f0204d", size = 307268 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c8/19/4ec628951a74043532ca2cf5d97b7b14863931476d117c471e8e2b1eb39f/urllib3-2.3.0-py3-none-any.whl", hash = "sha256:1cee9ad369867bfdbbb48b7dd50374c0967a0bb7710050facf0dd6911440e3df", size = 128369 }, +] + +[[package]] +name = "watchdog" +version = "6.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/db/7d/7f3d619e951c88ed75c6037b246ddcf2d322812ee8ea189be89511721d54/watchdog-6.0.0.tar.gz", hash = "sha256:9ddf7c82fda3ae8e24decda1338ede66e1c99883db93711d8fb941eaa2d8c282", size = 131220 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0c/56/90994d789c61df619bfc5ce2ecdabd5eeff564e1eb47512bd01b5e019569/watchdog-6.0.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:d1cdb490583ebd691c012b3d6dae011000fe42edb7a82ece80965b42abd61f26", size = 96390 }, + { url = "https://files.pythonhosted.org/packages/55/46/9a67ee697342ddf3c6daa97e3a587a56d6c4052f881ed926a849fcf7371c/watchdog-6.0.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:bc64ab3bdb6a04d69d4023b29422170b74681784ffb9463ed4870cf2f3e66112", size = 88389 }, + { url = "https://files.pythonhosted.org/packages/44/65/91b0985747c52064d8701e1075eb96f8c40a79df889e59a399453adfb882/watchdog-6.0.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:c897ac1b55c5a1461e16dae288d22bb2e412ba9807df8397a635d88f671d36c3", size = 89020 }, + { url = "https://files.pythonhosted.org/packages/e0/24/d9be5cd6642a6aa68352ded4b4b10fb0d7889cb7f45814fb92cecd35f101/watchdog-6.0.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:6eb11feb5a0d452ee41f824e271ca311a09e250441c262ca2fd7ebcf2461a06c", size = 96393 }, + { url = "https://files.pythonhosted.org/packages/63/7a/6013b0d8dbc56adca7fdd4f0beed381c59f6752341b12fa0886fa7afc78b/watchdog-6.0.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:ef810fbf7b781a5a593894e4f439773830bdecb885e6880d957d5b9382a960d2", size = 88392 }, + { url = "https://files.pythonhosted.org/packages/d1/40/b75381494851556de56281e053700e46bff5b37bf4c7267e858640af5a7f/watchdog-6.0.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:afd0fe1b2270917c5e23c2a65ce50c2a4abb63daafb0d419fde368e272a76b7c", size = 89019 }, + { url = "https://files.pythonhosted.org/packages/39/ea/3930d07dafc9e286ed356a679aa02d777c06e9bfd1164fa7c19c288a5483/watchdog-6.0.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:bdd4e6f14b8b18c334febb9c4425a878a2ac20efd1e0b231978e7b150f92a948", size = 96471 }, + { url = "https://files.pythonhosted.org/packages/12/87/48361531f70b1f87928b045df868a9fd4e253d9ae087fa4cf3f7113be363/watchdog-6.0.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:c7c15dda13c4eb00d6fb6fc508b3c0ed88b9d5d374056b239c4ad1611125c860", size = 88449 }, + { url = "https://files.pythonhosted.org/packages/5b/7e/8f322f5e600812e6f9a31b75d242631068ca8f4ef0582dd3ae6e72daecc8/watchdog-6.0.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:6f10cb2d5902447c7d0da897e2c6768bca89174d0c6e1e30abec5421af97a5b0", size = 89054 }, + { url = "https://files.pythonhosted.org/packages/68/98/b0345cabdce2041a01293ba483333582891a3bd5769b08eceb0d406056ef/watchdog-6.0.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:490ab2ef84f11129844c23fb14ecf30ef3d8a6abafd3754a6f75ca1e6654136c", size = 96480 }, + { url = "https://files.pythonhosted.org/packages/85/83/cdf13902c626b28eedef7ec4f10745c52aad8a8fe7eb04ed7b1f111ca20e/watchdog-6.0.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:76aae96b00ae814b181bb25b1b98076d5fc84e8a53cd8885a318b42b6d3a5134", size = 88451 }, + { url = "https://files.pythonhosted.org/packages/fe/c4/225c87bae08c8b9ec99030cd48ae9c4eca050a59bf5c2255853e18c87b50/watchdog-6.0.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:a175f755fc2279e0b7312c0035d52e27211a5bc39719dd529625b1930917345b", size = 89057 }, + { url = "https://files.pythonhosted.org/packages/05/52/7223011bb760fce8ddc53416beb65b83a3ea6d7d13738dde75eeb2c89679/watchdog-6.0.0-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:e6f0e77c9417e7cd62af82529b10563db3423625c5fce018430b249bf977f9e8", size = 96390 }, + { url = "https://files.pythonhosted.org/packages/9c/62/d2b21bc4e706d3a9d467561f487c2938cbd881c69f3808c43ac1ec242391/watchdog-6.0.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:90c8e78f3b94014f7aaae121e6b909674df5b46ec24d6bebc45c44c56729af2a", size = 88386 }, + { url = "https://files.pythonhosted.org/packages/ea/22/1c90b20eda9f4132e4603a26296108728a8bfe9584b006bd05dd94548853/watchdog-6.0.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:e7631a77ffb1f7d2eefa4445ebbee491c720a5661ddf6df3498ebecae5ed375c", size = 89017 }, + { url = "https://files.pythonhosted.org/packages/30/ad/d17b5d42e28a8b91f8ed01cb949da092827afb9995d4559fd448d0472763/watchdog-6.0.0-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:c7ac31a19f4545dd92fc25d200694098f42c9a8e391bc00bdd362c5736dbf881", size = 87902 }, + { url = "https://files.pythonhosted.org/packages/5c/ca/c3649991d140ff6ab67bfc85ab42b165ead119c9e12211e08089d763ece5/watchdog-6.0.0-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:9513f27a1a582d9808cf21a07dae516f0fab1cf2d7683a742c498b93eedabb11", size = 88380 }, + { url = "https://files.pythonhosted.org/packages/5b/79/69f2b0e8d3f2afd462029031baafb1b75d11bb62703f0e1022b2e54d49ee/watchdog-6.0.0-pp39-pypy39_pp73-macosx_10_15_x86_64.whl", hash = "sha256:7a0e56874cfbc4b9b05c60c8a1926fedf56324bb08cfbc188969777940aef3aa", size = 87903 }, + { url = "https://files.pythonhosted.org/packages/e2/2b/dc048dd71c2e5f0f7ebc04dd7912981ec45793a03c0dc462438e0591ba5d/watchdog-6.0.0-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:e6439e374fc012255b4ec786ae3c4bc838cd7309a540e5fe0952d03687d8804e", size = 88381 }, + { url = "https://files.pythonhosted.org/packages/a9/c7/ca4bf3e518cb57a686b2feb4f55a1892fd9a3dd13f470fca14e00f80ea36/watchdog-6.0.0-py3-none-manylinux2014_aarch64.whl", hash = "sha256:7607498efa04a3542ae3e05e64da8202e58159aa1fa4acddf7678d34a35d4f13", size = 79079 }, + { url = "https://files.pythonhosted.org/packages/5c/51/d46dc9332f9a647593c947b4b88e2381c8dfc0942d15b8edc0310fa4abb1/watchdog-6.0.0-py3-none-manylinux2014_armv7l.whl", hash = "sha256:9041567ee8953024c83343288ccc458fd0a2d811d6a0fd68c4c22609e3490379", size = 79078 }, + { url = "https://files.pythonhosted.org/packages/d4/57/04edbf5e169cd318d5f07b4766fee38e825d64b6913ca157ca32d1a42267/watchdog-6.0.0-py3-none-manylinux2014_i686.whl", hash = "sha256:82dc3e3143c7e38ec49d61af98d6558288c415eac98486a5c581726e0737c00e", size = 79076 }, + { url = "https://files.pythonhosted.org/packages/ab/cc/da8422b300e13cb187d2203f20b9253e91058aaf7db65b74142013478e66/watchdog-6.0.0-py3-none-manylinux2014_ppc64.whl", hash = "sha256:212ac9b8bf1161dc91bd09c048048a95ca3a4c4f5e5d4a7d1b1a7d5752a7f96f", size = 79077 }, + { url = "https://files.pythonhosted.org/packages/2c/3b/b8964e04ae1a025c44ba8e4291f86e97fac443bca31de8bd98d3263d2fcf/watchdog-6.0.0-py3-none-manylinux2014_ppc64le.whl", hash = "sha256:e3df4cbb9a450c6d49318f6d14f4bbc80d763fa587ba46ec86f99f9e6876bb26", size = 79078 }, + { url = "https://files.pythonhosted.org/packages/62/ae/a696eb424bedff7407801c257d4b1afda455fe40821a2be430e173660e81/watchdog-6.0.0-py3-none-manylinux2014_s390x.whl", hash = "sha256:2cce7cfc2008eb51feb6aab51251fd79b85d9894e98ba847408f662b3395ca3c", size = 79077 }, + { url = "https://files.pythonhosted.org/packages/b5/e8/dbf020b4d98251a9860752a094d09a65e1b436ad181faf929983f697048f/watchdog-6.0.0-py3-none-manylinux2014_x86_64.whl", hash = "sha256:20ffe5b202af80ab4266dcd3e91aae72bf2da48c0d33bdb15c66658e685e94e2", size = 79078 }, + { url = "https://files.pythonhosted.org/packages/07/f6/d0e5b343768e8bcb4cda79f0f2f55051bf26177ecd5651f84c07567461cf/watchdog-6.0.0-py3-none-win32.whl", hash = "sha256:07df1fdd701c5d4c8e55ef6cf55b8f0120fe1aef7ef39a1c6fc6bc2e606d517a", size = 79065 }, + { url = "https://files.pythonhosted.org/packages/db/d9/c495884c6e548fce18a8f40568ff120bc3a4b7b99813081c8ac0c936fa64/watchdog-6.0.0-py3-none-win_amd64.whl", hash = "sha256:cbafb470cf848d93b5d013e2ecb245d4aa1c8fd0504e863ccefa32445359d680", size = 79070 }, + { url = "https://files.pythonhosted.org/packages/33/e8/e40370e6d74ddba47f002a32919d91310d6074130fe4e17dabcafc15cbf1/watchdog-6.0.0-py3-none-win_ia64.whl", hash = "sha256:a1914259fa9e1454315171103c6a30961236f508b9b623eae470268bbcc6a22f", size = 79067 }, +] + +[[package]] +name = "wcwidth" +version = "0.2.13" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/6c/63/53559446a878410fc5a5974feb13d31d78d752eb18aeba59c7fef1af7598/wcwidth-0.2.13.tar.gz", hash = "sha256:72ea0c06399eb286d978fdedb6923a9eb47e1c486ce63e9b4e64fc18303972b5", size = 101301 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fd/84/fd2ba7aafacbad3c4201d395674fc6348826569da3c0937e75505ead3528/wcwidth-0.2.13-py2.py3-none-any.whl", hash = "sha256:3da69048e4540d84af32131829ff948f1e022c1c6bdb8d6102117aac784f6859", size = 34166 }, +] + +[[package]] +name = "webencodings" +version = "0.5.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/0b/02/ae6ceac1baeda530866a85075641cec12989bd8d31af6d5ab4a3e8c92f47/webencodings-0.5.1.tar.gz", hash = "sha256:b36a1c245f2d304965eb4e0a82848379241dc04b865afcc4aab16748587e1923", size = 9721 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f4/24/2a3e3df732393fed8b3ebf2ec078f05546de641fe1b667ee316ec1dcf3b7/webencodings-0.5.1-py2.py3-none-any.whl", hash = "sha256:a0af1213f3c2226497a97e2b3aa01a7e4bee4f403f95be16fc9acd2947514a78", size = 11774 }, +] + +[[package]] +name = "zipp" +version = "3.15.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine != 'aarch64' and platform_machine != 'arm64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'aarch64'", + "python_full_version >= '3.7.1' and python_full_version < '3.8' and platform_machine == 'arm64'", + "python_full_version < '3.7.1'", +] +sdist = { url = "https://files.pythonhosted.org/packages/00/27/f0ac6b846684cecce1ee93d32450c45ab607f65c2e0255f0092032d91f07/zipp-3.15.0.tar.gz", hash = "sha256:112929ad649da941c23de50f356a2b5570c954b65150642bccdd66bf194d224b", size = 18454 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5b/fa/c9e82bbe1af6266adf08afb563905eb87cab83fde00a0a08963510621047/zipp-3.15.0-py3-none-any.whl", hash = "sha256:48904fc76a60e542af151aded95726c1a5c34ed43ab4134b597665c86d7ad556", size = 6758 }, +] + +[[package]] +name = "zipp" +version = "3.20.2" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version == '3.8.*'", +] +sdist = { url = "https://files.pythonhosted.org/packages/54/bf/5c0000c44ebc80123ecbdddba1f5dcd94a5ada602a9c225d84b5aaa55e86/zipp-3.20.2.tar.gz", hash = "sha256:bc9eb26f4506fda01b81bcde0ca78103b6e62f991b381fec825435c836edbc29", size = 24199 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/62/8b/5ba542fa83c90e09eac972fc9baca7a88e7e7ca4b221a89251954019308b/zipp-3.20.2-py3-none-any.whl", hash = "sha256:a817ac80d6cf4b23bf7f2828b7cabf326f15a001bea8b1f9b49631780ba28350", size = 9200 }, +] + +[[package]] +name = "zipp" +version = "3.21.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", + "python_full_version == '3.10.*'", + "python_full_version == '3.9.*'", +] +sdist = { url = "https://files.pythonhosted.org/packages/3f/50/bad581df71744867e9468ebd0bcd6505de3b275e06f202c2cb016e3ff56f/zipp-3.21.0.tar.gz", hash = "sha256:2c9958f6430a2040341a52eb608ed6dd93ef4392e02ffe219417c1b28b5dd1f4", size = 24545 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b7/1a/7e4798e9339adc931158c9d69ecc34f5e6791489d469f5e50ec15e35f458/zipp-3.21.0-py3-none-any.whl", hash = "sha256:ac1bbe05fd2991f160ebce24ffbac5f6d11d83dc90891255885223d42b3cd931", size = 9630 }, +] From 34748c004f30d05542bc4c1431165e7e3f386ba5 Mon Sep 17 00:00:00 2001 From: Henry Wilde Date: Thu, 20 Mar 2025 21:43:33 +0000 Subject: [PATCH 08/26] Clean up README --- README.md | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/README.md b/README.md index 52c0405..2c95764 100644 --- a/README.md +++ b/README.md @@ -21,22 +21,22 @@ In `matching`, we deal with four types of matching game: ## Installation -Matching requires Python 3.5 or above, and relies only on -[NumPy](http://www.numpy.org/) for general use. +Matching requires Python 3.10 or above, and relies only on the scientific stack ([NumPy](http://www.numpy.org/) and +[SciPy](https://scipy.org/)) for general use. The library is most easily installed using `pip`: ```bash - $ python -m pip install matching +$ python -m pip install matching ``` However, if you would like to install it from source then go ahead and clone the GitHub repository: ```bash - $ git clone https://github.com/daffidwilde/matching.git - $ cd matching - $ python -m pip install . +$ git clone https://github.com/daffidwilde/matching.git +$ cd matching +$ python -m pip install . ``` ## Documentation @@ -135,7 +135,7 @@ second: ... for h in range(num_hospitals) ... } >>> capacities = {h: num_hospitals for h in hospital_prefs} ->>> game = HospitalResident.create_from_dictionaries( +>>> game = HospitalResident.from_preferences( ... resident_prefs, hospital_prefs, capacities ... ) >>> _ = game.solve() # 48.6 ms ± 963 µs per loop From 4d79cf4a1a075cb3b836025aa01a1751651193c2 Mon Sep 17 00:00:00 2001 From: Henry Wilde Date: Thu, 20 Mar 2025 21:43:41 +0000 Subject: [PATCH 09/26] Close out example tests (temporarily) --- tests/hospital_resident/_test_examples.py | 84 +++++++++++++++++++++++ 1 file changed, 84 insertions(+) create mode 100644 tests/hospital_resident/_test_examples.py diff --git a/tests/hospital_resident/_test_examples.py b/tests/hospital_resident/_test_examples.py new file mode 100644 index 0000000..43026a3 --- /dev/null +++ b/tests/hospital_resident/_test_examples.py @@ -0,0 +1,84 @@ +"""A collection of example tests for HR.""" + +import json +import os + +from matching.games import HospitalResident + + +def test_readme_example(): + """Test the example formerly used in the README.""" + resident_prefs = { + "A": ["C"], + "S": ["C", "M"], + "D": ["C", "M", "G"], + "J": ["C", "G", "M"], + "L": ["M", "C", "G"], + } + hospital_prefs = { + "M": ["D", "L", "S", "J"], + "C": ["D", "A", "S", "L", "J"], + "G": ["D", "J", "L"], + } + capacities = {hosp: 2 for hosp in hospital_prefs} + + game = HospitalResident.from_preferences(resident_prefs, hospital_prefs, capacities) + matching = game.solve() + + # assert matching == {M: [L, S], C: [D, A], G: [J]} + + +def test_example_in_issue_67(): + """Test the example given in #67.""" + group_prefs = { + "Group 1": ["Intellectual property", "Privacy"], + "Group 2": ["Privacy", "Fairness in AI"], + "Group 3": ["Privacy", "Social media"], + } + topic_hospital_prefs = { + "Fairness in AI": ["Group 2"], + "Intellectual property": ["Group 1"], + "Privacy": ["Group 3", "Group 2", "Group 1"], + "Social media": ["Group 3"], + } + capacities = {t: 2 for t in topic_hospital_prefs} + + game = HospitalResident.from_preferences(group_prefs, topic_hospital_prefs, capacities) + matching = game.solve() + + # assert matching == {I: [G1], P: [G3, G2], F: [], S: []} + + +def test_resident_loses_all_preferences(): + """Test example that forces a resident to be removed.""" + resident_prefs = {"A": ["X"], "B": ["X", "Y"]} + hospital_prefs = {"X": ["B", "A"], "Y": ["B"]} + capacities = {"X": 1, "Y": 1} + + game = HospitalResident.from_preferences(resident_prefs, hospital_prefs, capacities) + matching = game.solve() + + # assert matching == {X: [B], Y: []} + + +def test_example_in_issue_159(): + """ + Test the example given in #159. + + The example in this is particularly large, so we've moved the + dictionaries to a test data directory. + """ + here = os.path.join(os.path.dirname(__file__)) + with open(os.path.join(here, "data", "issue_159.json"), "r") as f: + preferences = json.load(f) + + resident_prefs = {int(res): prefs for res, prefs in preferences["residents"].items()} + hospital_prefs = {int(hos): prefs for hos, prefs in preferences["hospitals"].items()} + capacities = {hospital: 1 for hospital in hospital_prefs} + + game = HospitalResident.from_preferences( + resident_prefs, hospital_prefs, capacities, clean=True + ) + + for player in game.residents + game.hospitals: + assert player.prefs From 7c0fbec3500f8c8a3b35bb0e540c3db6e1880ed1 Mon Sep 17 00:00:00 2001 From: Henry Wilde Date: Fri, 21 Mar 2025 00:53:49 +0000 Subject: [PATCH 10/26] Make a stab at the HR algorithm; break matchings! --- src/matching/__init__.py | 6 +- src/matching/games/hospital_resident.py | 206 +++++++++++++++++++++- src/matching/games/stable_marriage.py | 24 ++- src/matching/matchings.py | 110 ++++++++++++ src/matching/matchings/__init__.py | 6 - src/matching/matchings/multiple.py | 35 ---- src/matching/matchings/single.py | 64 ------- tests/hospital_resident/_test_examples.py | 84 --------- tests/hospital_resident/test_examples.py | 61 ++++--- tests/matchings/test_single.py | 104 ----------- tests/stable_marriage/test_examples.py | 6 +- tests/stable_marriage/test_game.py | 14 +- tests/test_matchings.py | 139 +++++++++------ 13 files changed, 455 insertions(+), 404 deletions(-) create mode 100644 src/matching/matchings.py delete mode 100644 src/matching/matchings/__init__.py delete mode 100644 src/matching/matchings/multiple.py delete mode 100644 src/matching/matchings/single.py delete mode 100644 tests/hospital_resident/_test_examples.py delete mode 100644 tests/matchings/test_single.py diff --git a/src/matching/__init__.py b/src/matching/__init__.py index 538e3ee..efb21ee 100644 --- a/src/matching/__init__.py +++ b/src/matching/__init__.py @@ -7,8 +7,10 @@ warnings.simplefilter("always") +from . import matchings from .base import BaseGame, BaseMatching, BasePlayer -from .matchings import MultipleMatching, SingleMatching +from .matchings import _MultipleMatching as MultipleMatching +from .matchings import _SingleMatching as SingleMatching from .players import Hospital, Player, Project, Supervisor __version__ = "2.0.0" @@ -18,11 +20,11 @@ "BaseMatching", "BasePlayer", "Hospital", - "Matching", "MultipleMatching", "Player", "Project", "SingleMatching", "Supervisor", "__version__", + "matchings", ] diff --git a/src/matching/games/hospital_resident.py b/src/matching/games/hospital_resident.py index 6aaf10d..5e254a0 100644 --- a/src/matching/games/hospital_resident.py +++ b/src/matching/games/hospital_resident.py @@ -2,7 +2,7 @@ import numpy as np -from matching import convert +from matching import convert, matchings class HospitalResident: @@ -62,7 +62,7 @@ def from_utilities(cls, resident_utils, hospital_utils, capacities): Returns ------- - game : HospitalResident + HospitalResident An instance of HR with utilities resolved as rank matrices. """ resident_ranks = convert.utility_to_rank(resident_utils) @@ -90,7 +90,7 @@ def from_preferences(cls, resident_prefs, hospital_prefs, capacities): Returns ------- - game : HospitalResident + HospitalResident An instance of HR with preference lists resolved as rank matrices. """ @@ -115,3 +115,203 @@ def check_input_validity(self): Invalid games can still be solved, but the matching will not be truly stable in the absence of blocking pairs. """ + + def _resident_optimal(self): + """ + Execute the resident-optimal algorithm given some rankings. + + Returns + ------- + dict + Solution mapping hospitals to their matched residents. + """ + resident_ranks = self.resident_ranks + hospital_ranks = self.hospital_ranks + capacities = self.capacities + + matching = {h: [] for h in range(self.num_hospitals)} + free_residents = set(range(self.num_residents)) + + while free_residents: + resident = free_residents.pop() + resident_rank = resident_ranks[resident] + if np.min(resident_rank) == self.num_hospitals: + continue + + hospital = resident_rank.argmin() + hospital_rank = hospital_ranks[hospital] + hospital_matches = matching[hospital] + capacity = capacities[hospital] + + if len(hospital_matches) == capacity: + worst, idx = _get_worst_match(hospital_rank, hospital_matches) + del hospital_matches[idx] + free_residents.add(worst) + + hospital_matches.append(resident) + + if len(hospital_matches) == capacity: + worst, _ = _get_worst_match(hospital_rank, hospital_matches) + successors = np.where(hospital_rank > hospital_rank[worst]) + resident_ranks[successors, hospital] = self.num_hospitals + hospital_rank[successors] = self.num_residents + + return matching + + def _hospital_optimal(self): + """ + Execute the hospital-optimal algorithm given some rankings. + + Returns + ------- + dict + Solution mapping hospitals to their matched residents. + """ + resident_ranks = self.resident_ranks.copy() + hospital_ranks = self.hospital_ranks.copy() + capacities = self.capacities + + matching = {h: [] for h in range(self.num_hospitals)} + free_hospitals = set(range(self.num_hospitals)) + + while free_hospitals: + hospital = free_hospitals.pop() + hospital_rank = hospital_ranks[hospital] + hospital_matches = matching.get(hospital) + options = [ + res if i not in hospital_matches else self.num_residents + for i, res in enumerate(hospital_rank) + ] + + is_at_capacity = len(hospital_matches) == capacities[hospital] + has_no_options = np.min(options) == self.num_residents + has_no_ranking = np.min(hospital_rank) == self.num_residents + if is_at_capacity or has_no_options or has_no_ranking: + continue + + resident = np.argmin(options) + resident_rank = resident_ranks[resident] + + current_match, idx = _get_current_match(resident, matching) + if current_match is not None: + current_match_matches = matching[current_match] + del current_match_matches[idx] + free_hospitals.add(current_match) + + hospital_matches.append(resident) + free_hospitals.add(hospital) + + successors = np.where(resident_rank > resident_rank[hospital]) + hospital_ranks[successors, resident] = self.num_residents + resident_rank[successors] = self.num_hospitals + + return matching + + def _convert_matching_to_preferences(self): + """ + Replace the rank indices with preference terms in a matching. + + This internal function is included for users who wish to create + a matching from a set of preference list dictionaries. + + Attributes + ---------- + HRMatching + The converted matching instance. + """ + converted = {} + residents, hospitals = self._preference_lookup.values() + for hospital, resident_matches in self.matching.items(): + converted[hospitals[hospital]] = [residents[resident] for resident in resident_matches] + + self.matching = matchings.HRMatching(converted, keys="hospitals", values="residents") + + def solve(self, optimal="resident"): + """ + Solve the instance of HR. + + This method uses the adapted Gale-Shapley algorithms introduced + by Alvin Roth in 1984 (https://doi.org/10.1086/261272). The + algorithms find a unique, stable and party-optimal matching for + any valid set of residents and hospitals. + + The optimality of the matching is with respect to one party and + is subsequently the worst stable matching for the other party. + + Parameters + ---------- + optimal : {"resident", "hospital"}, default="resident" + Party for whom to optimise the matching. + + Raises + ------ + ValueError + If `optimal` is anything other than the permitted values. + + Returns + ------- + HRMatching + A dictionary-like object containing the matching. The keys + correspond to the hospitals in the instance, while the + values are lists of the residents matched to them. + """ + if optimal == "resident": + matching = self._resident_optimal() + elif optimal == "hospital": + matching = self._hospital_optimal() + else: + raise ValueError( + f'Invalid choice for `optimal`. Must be "resident" or "hospital", not "{optimal}".' + ) + + self.matching = matchings.HRMatching(matching, keys="hospitals", values="residents") + if self._preference_lookup: + self._convert_matching_to_preferences() + + return self.matching + + +def _get_worst_match(ranking, matches): + """ + Get the worst current match (and its index) for a hospital. + + Parameters + ---------- + ranking : np.ndarray + Hospital ranking to search. + matches : list[int] + Current matches as indices in the ranking. + + Returns + ------- + tuple[int, int] + The worst match and its position in `matches`. + """ + idx = ranking[matches].argmax() + worst = matches[idx] + + return worst, idx + + +def _get_current_match(resident, matching): + """ + Get the current match for a resident (and its position) if any. + + Parameters + ---------- + resident : int + Resident for whom to search. + matching : dict + Mapping of hospitals to their matched residents. + + Returns + ------- + tuple[int, int] | tuple[None, None] + Currently matched hospital or `None` if the resident is free. + """ + for hospital, residents in matching.items(): + for idx, res in enumerate(residents): + if res == resident: + return hospital, idx + + return None, None diff --git a/src/matching/games/stable_marriage.py b/src/matching/games/stable_marriage.py index cdbd97e..23c7207 100644 --- a/src/matching/games/stable_marriage.py +++ b/src/matching/games/stable_marriage.py @@ -4,8 +4,7 @@ import numpy as np -from matching import convert -from matching.matchings import SingleMatching +from matching import convert, matchings class StableMarriage: @@ -60,7 +59,7 @@ def from_utilities(cls, suitor_utils, reviewer_utils): Returns ------- - game : StableMarriage + StableMarriage An instance of SM with utilities resolved as rank matrices. """ @@ -87,7 +86,7 @@ def from_preferences(cls, suitor_prefs, reviewer_prefs): Returns ------- - game : StableMarriage + StableMarriage An instance of SM with preference lists resolved as rank matrices. """ @@ -196,7 +195,7 @@ def _stable_marriage(self): Returns ------- - matching : dict + dict Solution to the game instance. """ @@ -230,7 +229,7 @@ def _convert_matching_to_preferences(self): Attributes ---------- - matching : SingleMatching + SMMatching The converted matching instance. """ @@ -239,9 +238,7 @@ def _convert_matching_to_preferences(self): for reviewer, suitor in self.matching.items(): converted[reviewers[reviewer]] = suitors[suitor] - self.matching = SingleMatching( - converted, valid=self.matching.valid, stable=self.matching.stable - ) + self.matching = matchings.SMMatching(converted) def solve(self, optimal="suitor"): """ @@ -257,9 +254,8 @@ def solve(self, optimal="suitor"): Parameters ---------- - optimal : {"suitor", "reviewer"}, default "suitor" - Party for whom to optimise the matching. Must be one of - `"suitor"` or `"reviewer"`. Default is `"suitor"`. + optimal : {"suitor", "reviewer"}, default="suitor" + Party for whom to optimise the matching. Raises ------ @@ -268,7 +264,7 @@ def solve(self, optimal="suitor"): Returns ------- - matching : SingleMatching + SMMatching A dictionary-like object containing the matching. The keys correspond to the reviewers in the instance, while the values are the suitors. @@ -285,7 +281,7 @@ def solve(self, optimal="suitor"): self._invert_player_sets() keys, values = values, keys - matching = SingleMatching(self._stable_marriage(), keys=keys, values=values) + matching = matchings.SMMatching(self._stable_marriage(), keys=keys, values=values) if optimal == "reviewer": matching = matching.invert() diff --git a/src/matching/matchings.py b/src/matching/matchings.py new file mode 100644 index 0000000..dcaf4b5 --- /dev/null +++ b/src/matching/matchings.py @@ -0,0 +1,110 @@ +"""Module for the matching object classes.""" + +import collections + + +class _BaseMatching(dict): + """ + Dictionary-like object for holding game solutions. For inheritance. + + Parameters + ---------- + dictionary : dict + Dictionary of matched up pairs. + keys : str + Name of the key-side party. Renamed `keys_`. + values : str + Name of the value-side party. Renamed `values_`. + """ + + KEYS = "keys" + VALUES = "values" + + def __init__(self, dictionary=None, *, keys=None, values=None): + super().__init__(dictionary or {}) + + self.keys_ = keys or self.KEYS + self.values_ = values or self.VALUES + + def __repr__(self): + name = self.__class__.__name__ + return f'{name}({super().__repr__()}, keys="{self.keys_}", values="{self.values_}")' + + def __eq__(self, other): + if isinstance(other, _BaseMatching): + return super().__eq__(other) and vars(self) == vars(other) + if isinstance(other, dict): + return super().__eq__(other) + + +class _SingleMatching(_BaseMatching): + """ + Dictionary-like object for solutions to games with singular matches. + + Parameters + ---------- + dictionary : dict + Dictionary of matched up pairs. + keys : str + Name of the key-side party. Renamed `keys_`. + values : str + Name of the value-side party. Renamed `values_`. + """ + + def invert(self): + """ + Invert the keys and values in the dictionary. + + Returns + ------- + inverted : SingleMatching + An inverted matching. + """ + inverted = {val: key for key, val in self.items()} + + return self.__class__(inverted, keys=self.values_, values=self.keys_) + + +class _MultipleMatching(_BaseMatching): + """ + Dictionary-like object for solutions to games with multiple matches. + + Parameters + ---------- + dictionary : dict + Dictionary mapping players to their matches. + keys : str + Name of the key-side party. Renamed `keys_`. + values : str + Name of the value-side party. Renamed `values_`. + """ + + def invert(self): + """ + Invert the keys and list values in the dictionary. + + Returns + ------- + MultipleMatching + An inverted matching. + """ + inverted = collections.defaultdict(list) + for key, values in self.items(): + for value in values: + inverted[value].append(key) + + return self.__class__(dict(inverted), keys=self.values_, values=self.keys_) + + +class SMMatching(_SingleMatching): + """Dictionary-like object for solutions to SM game instances.""" + + KEYS = "reviewers" + VALUES = "suitors" + + +class HRMatching(_MultipleMatching): + """Dictionary-like object for solutions to HR game instances.""" + + KEYS = "hospitals" + VALUES = "residents" diff --git a/src/matching/matchings/__init__.py b/src/matching/matchings/__init__.py deleted file mode 100644 index c7b049e..0000000 --- a/src/matching/matchings/__init__.py +++ /dev/null @@ -1,6 +0,0 @@ -"""Classes for different types of matchings.""" - -from .multiple import MultipleMatching -from .single import SingleMatching - -__all__ = ["MultipleMatching", "SingleMatching"] diff --git a/src/matching/matchings/multiple.py b/src/matching/matchings/multiple.py deleted file mode 100644 index da253c3..0000000 --- a/src/matching/matchings/multiple.py +++ /dev/null @@ -1,35 +0,0 @@ -"""Classes for handling multiple match matchings.""" - -from matching.base import BaseMatching -from matching.players import Player - - -class MultipleMatching(BaseMatching): - """Matching class for games with multiple matches like HR or SA. - - Parameters - ---------- - dictionary - A dictionary comprised of ``Hospital, List[Player]`` pairs. - """ - - def __init__(self, dictionary): - super().__init__(dictionary) - - def __setitem__(self, player, new): - """Set a player's match and match each of them to the player. - - First check if the player is present, and that the new match is - a valid collection of players. - """ - - self._check_player_in_keys(player) - self._check_new_valid_type(new, (list, tuple)) - for other in new: - self._check_new_valid_type(other, Player) - - player.matching = new - for other in new: - other.matching = player - - self._data[player] = new diff --git a/src/matching/matchings/single.py b/src/matching/matchings/single.py deleted file mode 100644 index 6b9ba8e..0000000 --- a/src/matching/matchings/single.py +++ /dev/null @@ -1,64 +0,0 @@ -"""Classes for handling single match matchings.""" - - -class SingleMatching(dict): - """ - Dictionary-like object for solutions to games with singular matches. - - Parameters - ---------- - dictionary : dict - Dictionary of matched up pairs. - keys : str - Name of the key-side party. Renamed `keys_`. - values : str - Name of the value-side party. Renamed `values_`. - valid : bool or None - Validity of the matching. Initialises as `None`. - stable : bool or None - Stability of the matching. Initialises as `None`. - """ - - def __init__( - self, - dictionary=None, - *, - keys="reviewers", - values="suitors", - valid=None, - stable=None, - ): - super().__init__(dictionary or {}) - - self.keys_ = keys - self.values_ = values - self.valid = valid - self.stable = stable - - def __repr__(self): - return ( - f'SingleMatching({super().__repr__()}, keys="{self.keys_}", values="{self.values_}")' - ) - - def __eq__(self, other): - return super().__eq__(other) and vars(self) == vars(other) - - def invert(self): - """ - Invert the keys and values in the dictionary. - - Creates a new matching instance with keys and values reversed, - and passes over the validity and stability attributes. - - Returns - ------- - inverted : SingleMatching - An inverted matching. - """ - return SingleMatching( - {val: key for key, val in self.items()}, - keys=self.values_, - values=self.keys_, - valid=self.valid, - stable=self.stable, - ) diff --git a/tests/hospital_resident/_test_examples.py b/tests/hospital_resident/_test_examples.py deleted file mode 100644 index 43026a3..0000000 --- a/tests/hospital_resident/_test_examples.py +++ /dev/null @@ -1,84 +0,0 @@ -"""A collection of example tests for HR.""" - -import json -import os - -from matching.games import HospitalResident - - -def test_readme_example(): - """Test the example formerly used in the README.""" - resident_prefs = { - "A": ["C"], - "S": ["C", "M"], - "D": ["C", "M", "G"], - "J": ["C", "G", "M"], - "L": ["M", "C", "G"], - } - hospital_prefs = { - "M": ["D", "L", "S", "J"], - "C": ["D", "A", "S", "L", "J"], - "G": ["D", "J", "L"], - } - capacities = {hosp: 2 for hosp in hospital_prefs} - - game = HospitalResident.from_preferences(resident_prefs, hospital_prefs, capacities) - matching = game.solve() - - # assert matching == {M: [L, S], C: [D, A], G: [J]} - - -def test_example_in_issue_67(): - """Test the example given in #67.""" - group_prefs = { - "Group 1": ["Intellectual property", "Privacy"], - "Group 2": ["Privacy", "Fairness in AI"], - "Group 3": ["Privacy", "Social media"], - } - topic_hospital_prefs = { - "Fairness in AI": ["Group 2"], - "Intellectual property": ["Group 1"], - "Privacy": ["Group 3", "Group 2", "Group 1"], - "Social media": ["Group 3"], - } - capacities = {t: 2 for t in topic_hospital_prefs} - - game = HospitalResident.from_preferences(group_prefs, topic_hospital_prefs, capacities) - matching = game.solve() - - # assert matching == {I: [G1], P: [G3, G2], F: [], S: []} - - -def test_resident_loses_all_preferences(): - """Test example that forces a resident to be removed.""" - resident_prefs = {"A": ["X"], "B": ["X", "Y"]} - hospital_prefs = {"X": ["B", "A"], "Y": ["B"]} - capacities = {"X": 1, "Y": 1} - - game = HospitalResident.from_preferences(resident_prefs, hospital_prefs, capacities) - matching = game.solve() - - # assert matching == {X: [B], Y: []} - - -def test_example_in_issue_159(): - """ - Test the example given in #159. - - The example in this is particularly large, so we've moved the - dictionaries to a test data directory. - """ - here = os.path.join(os.path.dirname(__file__)) - with open(os.path.join(here, "data", "issue_159.json"), "r") as f: - preferences = json.load(f) - - resident_prefs = {int(res): prefs for res, prefs in preferences["residents"].items()} - hospital_prefs = {int(hos): prefs for hos, prefs in preferences["hospitals"].items()} - capacities = {hospital: 1 for hospital in hospital_prefs} - - game = HospitalResident.from_preferences( - resident_prefs, hospital_prefs, capacities, clean=True - ) - - for player in game.residents + game.hospitals: - assert player.prefs diff --git a/tests/hospital_resident/test_examples.py b/tests/hospital_resident/test_examples.py index 2b729d5..7a8a86c 100644 --- a/tests/hospital_resident/test_examples.py +++ b/tests/hospital_resident/test_examples.py @@ -7,8 +7,7 @@ def test_readme_example(): - """Test the example used in the repo README.""" - + """Test the example formerly used in the README.""" resident_prefs = { "A": ["C"], "S": ["C", "M"], @@ -16,80 +15,84 @@ def test_readme_example(): "J": ["C", "G", "M"], "L": ["M", "C", "G"], } - hospital_prefs = { "M": ["D", "L", "S", "J"], "C": ["D", "A", "S", "L", "J"], "G": ["D", "J", "L"], } - capacities = {hosp: 2 for hosp in hospital_prefs} - game = HospitalResident.create_from_dictionaries(resident_prefs, hospital_prefs, capacities) - (A, S, D, J, L), (M, C, G) = game.residents, game.hospitals - + game = HospitalResident.from_preferences(resident_prefs, hospital_prefs, capacities) matching = game.solve() - assert matching == {M: [L, S], C: [D, A], G: [J]} + + assert matching == {"M": ["L", "S"], "C": ["A", "D"], "G": ["J"]} def test_example_in_issue_67(): """Test the example given in #67.""" - group_prefs = { "Group 1": ["Intellectual property", "Privacy"], "Group 2": ["Privacy", "Fairness in AI"], "Group 3": ["Privacy", "Social media"], } - topic_hospital_prefs = { "Fairness in AI": ["Group 2"], "Intellectual property": ["Group 1"], "Privacy": ["Group 3", "Group 2", "Group 1"], "Social media": ["Group 3"], } - capacities = {t: 2 for t in topic_hospital_prefs} - game = HospitalResident.create_from_dictionaries(group_prefs, topic_hospital_prefs, capacities) - (G1, G2, G3), (F, I, P, S) = game.residents, game.hospitals - + game = HospitalResident.from_preferences(group_prefs, topic_hospital_prefs, capacities) matching = game.solve() - assert matching == {I: [G1], P: [G3, G2], F: [], S: []} + + assert matching == { + "Fairness in AI": [], + "Intellectual property": ["Group 1"], + "Privacy": ["Group 2", "Group 3"], + "Social media": [], + } def test_resident_loses_all_preferences(): """Test example that forces a resident to be removed.""" - resident_prefs = {"A": ["X"], "B": ["X", "Y"]} hospital_prefs = {"X": ["B", "A"], "Y": ["B"]} capacities = {"X": 1, "Y": 1} - game = HospitalResident.create_from_dictionaries(resident_prefs, hospital_prefs, capacities) - (_, B), (X, Y) = game.residents, game.hospitals - + game = HospitalResident.from_preferences(resident_prefs, hospital_prefs, capacities) matching = game.solve() - assert matching == {X: [B], Y: []} + + assert matching == {"X": ["B"], "Y": []} def test_example_in_issue_159(): - """Test the example given in #159. + """ + Test the example given in #159. The example in this is particularly large, so we've moved the dictionaries to a test data directory. """ - here = os.path.join(os.path.dirname(__file__)) with open(os.path.join(here, "data", "issue_159.json"), "r") as f: preferences = json.load(f) resident_prefs = {int(res): prefs for res, prefs in preferences["residents"].items()} hospital_prefs = {int(hos): prefs for hos, prefs in preferences["hospitals"].items()} - capacities = {hospital: 1 for hospital in hospital_prefs} - game = HospitalResident.create_from_dictionaries( - resident_prefs, hospital_prefs, capacities, clean=True - ) - - for player in game.residents + game.hospitals: - assert player.prefs + game = HospitalResident.from_preferences(resident_prefs, hospital_prefs, capacities) + + for ranking, preferences in zip(game.resident_ranks, resident_prefs.values()): + minimum, limit = min(ranking), game.num_hospitals + if not preferences: + minimum == limit + else: + assert minimum < limit + + for ranking, preferences in zip(game.hospital_ranks, hospital_prefs.values()): + minimum, limit = min(ranking), game.num_residents + if not preferences: + assert minimum == limit + else: + assert minimum < limit diff --git a/tests/matchings/test_single.py b/tests/matchings/test_single.py deleted file mode 100644 index e021a89..0000000 --- a/tests/matchings/test_single.py +++ /dev/null @@ -1,104 +0,0 @@ -"""Unit tests for the SingleMatching class.""" - -from hypothesis import given -from hypothesis import strategies as st - -from matching.matchings import SingleMatching - - -@st.composite -def st_single_params(draw, min_size=2, max_size=5): - """Create a parameter set for a SingleMatching instance.""" - - size = draw(st.integers(min_size, max_size)) - midpoint = size // 2 - players = list(range(size)) - keys, values = players[:midpoint], players[midpoint:] - dictionary = draw(st.sampled_from((None, dict(zip(keys, values))))) - - keys = draw(st.text()) - values = draw(st.text()) - valid = draw(st.sampled_from((None, False, True))) - stable = draw(st.sampled_from((None, False, True))) - - params = dict( - dictionary=dictionary, - keys=keys, - values=values, - valid=valid, - stable=stable, - ) - - return params - - -@st.composite -def st_singles(draw, min_size=2, max_size=5): - """Create a SingleMatching instance.""" - - params = draw(st_single_params(min_size, max_size)) - - return SingleMatching(**params) - - -@given(st_single_params()) -def test_init(params): - """Check that a SingleMatching can be created correctly.""" - - matching = SingleMatching(**params) - - assert isinstance(matching, SingleMatching) - assert isinstance(matching, dict) - - dictionary = params["dictionary"] or {} - assert matching.items() == dictionary.items() - assert vars(matching) == { - "keys_": params["keys"], - "values_": params["values"], - "valid": params["valid"], - "stable": params["stable"], - } - - -@given(st_singles()) -def test_repr(matching): - """Check that the string representation of a matching is correct.""" - - repr_ = repr(matching) - - assert isinstance(repr_, str) - assert repr_.startswith("SingleMatching") - assert str(dict(matching)) in repr_ - assert matching.keys_ in repr_ - assert matching.values_ in repr_ - - -@given(st_single_params()) -def test_eq(params): - """Check the equivalence dunder works as expected.""" - - matching1 = SingleMatching(**params) - matching2 = SingleMatching(**params) - - assert matching1 == matching2 - - if params["dictionary"] is not None: - key = next(iter(params["dictionary"].keys())) - matching2[key] = None - - assert matching1 != matching2 - assert vars(matching1) == vars(matching2) - - -@given(st_singles()) -def test_invert(matching): - """Check the matching inverter works as it should.""" - - inverted = matching.invert() - - assert isinstance(inverted, SingleMatching) - assert set(inverted.items()) == set((val, key) for key, val in matching.items()) - assert inverted.keys_ == matching.values_ - assert inverted.values_ == matching.keys_ - assert inverted.valid == matching.valid - assert inverted.stable == matching.stable diff --git a/tests/stable_marriage/test_examples.py b/tests/stable_marriage/test_examples.py index e5c5fc5..a940104 100644 --- a/tests/stable_marriage/test_examples.py +++ b/tests/stable_marriage/test_examples.py @@ -28,7 +28,7 @@ def test_pride_and_prejudice(): game = StableMarriage.from_preferences(suitor_preferences, reviewer_preferences) matching = game.solve() - assert dict(matching) == {"J": "B", "C": "C", "E": "D", "L": "W"} + assert matching == {"J": "B", "C": "C", "E": "D", "L": "W"} def test_readme_example(): @@ -48,7 +48,7 @@ def test_readme_example(): game = StableMarriage.from_preferences(suitor_preferences, reviewer_preferences) matching = game.solve() - assert dict(matching) == {"E": "A", "D": "B", "F": "C"} + assert matching == {"E": "A", "D": "B", "F": "C"} def test_matchingr_example(): @@ -62,4 +62,4 @@ def test_matchingr_example(): matching = game.solve() - assert dict(matching) == {0: 1, 1: 0} + assert matching == {0: 1, 1: 0} diff --git a/tests/stable_marriage/test_game.py b/tests/stable_marriage/test_game.py index 2319382..d96eb4f 100644 --- a/tests/stable_marriage/test_game.py +++ b/tests/stable_marriage/test_game.py @@ -9,7 +9,7 @@ from hypothesis import strategies as st from matching.games import StableMarriage -from matching.matchings import SingleMatching +from matching.matchings import SMMatching from ..common import mocked_game from .strategies import ( @@ -228,7 +228,7 @@ def test_solve_valid_optimal(ranks, optimal, solution): with ( mock.patch("matching.games.StableMarriage._invert_player_sets") as player_set_inverter, mock.patch("matching.games.StableMarriage._stable_marriage") as stable_marriage, - mock.patch("matching.matchings.SingleMatching.invert") as matching_inverter, + mock.patch("matching.matchings.SMMatching.invert") as matching_inverter, ): stable_marriage.return_value = solution matching_inverter.return_value = "inverted_matching" @@ -245,7 +245,7 @@ def test_solve_valid_optimal(ranks, optimal, solution): ] assert matching == "inverted_matching" else: - assert isinstance(matching, SingleMatching) + assert isinstance(matching, SMMatching) assert dict(matching) == solution @@ -259,7 +259,7 @@ def test_solve_invalid_optimal_raises(ranks, optimal): with ( mock.patch("matching.games.StableMarriage._invert_player_sets") as player_set_inverter, mock.patch("matching.games.StableMarriage._stable_marriage") as stable_marriage, - mock.patch("matching.matchings.SingleMatching.invert") as matching_inverter, + mock.patch("matching.matchings.SMMatching.invert") as matching_inverter, pytest.raises(ValueError, match=match), ): game.solve(optimal) @@ -280,16 +280,14 @@ def test_convert_matching_to_preferences(preference_matchings): warnings.simplefilter("ignore") game = StableMarriage.from_preferences(suitor_prefs, reviewer_prefs) - game.matching = SingleMatching(matching) + game.matching = SMMatching(matching) game._convert_matching_to_preferences() converted = game.matching - assert isinstance(converted, SingleMatching) + assert isinstance(converted, SMMatching) assert converted.keys_ == "reviewers" assert converted.values_ == "suitors" - assert converted.valid is None - assert converted.stable is None assert set(converted.keys()) == set(reviewer_prefs) assert set(converted.values()) == set(suitor_prefs) diff --git a/tests/test_matchings.py b/tests/test_matchings.py index 45fb53f..fe2bc96 100644 --- a/tests/test_matchings.py +++ b/tests/test_matchings.py @@ -1,54 +1,89 @@ -"""Tests for the matching classes.""" +"""Tests for the `matchings` module.""" from hypothesis import given -from hypothesis.strategies import ( - composite, - integers, - lists, - sampled_from, - text, -) - -from matching import MultipleMatching -from matching.players import Hospital, Player - - -@composite -def multiples( - draw, - host_names_from=text(), - player_names_from=text(), - min_hosts=2, - max_hosts=5, - min_players=10, - max_players=20, -): - """A strategy for creating multiple-match matchings from players.""" - - num_hosts = draw(integers(min_value=min_hosts, max_value=max_hosts)) - num_players = draw(integers(min_value=min_players, max_value=max_players)) - - hosts = [Hospital(draw(host_names_from), max_players) for _ in range(num_hosts)] - players = [Player(draw(player_names_from)) for _ in range(num_players)] - - dictionary = {} - for host in hosts: - matches = draw(lists(sampled_from(players), min_size=0, unique=True)) - dictionary[host] = matches - - return dictionary - - -@given(dictionary=multiples()) -def test_multiple_setitem(dictionary): - """Test that a host player in a matching can have a list match.""" - - matching = MultipleMatching(dictionary) - host = list(dictionary.keys())[0] - players = list({player for players in dictionary.values() for player in players})[:-1] - - matching[host] = players - assert matching[host] == players - assert host.matching == players - for player in players: - assert player.matching == host +from hypothesis import strategies as st + +from matching import matchings + + +@st.composite +def st_sm_params(draw, min_size=2, max_size=5): + """Create a parameter set for a SMMatching instance.""" + + size = draw(st.integers(min_size, max_size)) + midpoint = size // 2 + players = list(range(size)) + keys, values = players[:midpoint], players[midpoint:] + dictionary = draw(st.sampled_from((None, dict(zip(keys, values))))) + + keys = draw(st.text(min_size=1)) + values = draw(st.text(min_size=1)) + + params = dict(dictionary=dictionary, keys=keys, values=values) + + return params + + +@st.composite +def st_sms(draw, min_size=2, max_size=5): + """Create a SMMatching instance.""" + + params = draw(st_sm_params(min_size, max_size)) + + return matchings.SMMatching(**params) + + +@given(st_sm_params()) +def test_init(params): + """Check that a SMMatching can be created correctly.""" + + matching = matchings.SMMatching(**params) + + assert isinstance(matching, matchings.SMMatching) + assert isinstance(matching, dict) + + dictionary = params["dictionary"] or {} + assert matching.items() == dictionary.items() + assert vars(matching) == {"keys_": params["keys"], "values_": params["values"]} + + +@given(st_sms()) +def test_repr(matching): + """Check that the string representation of a matching is correct.""" + + repr_ = repr(matching) + + assert isinstance(repr_, str) + assert repr_.startswith("SMMatching") + assert str(dict(matching)) in repr_ + assert matching.keys_ in repr_ + assert matching.values_ in repr_ + + +@given(st_sm_params()) +def test_eq(params): + """Check the equivalence dunder works as expected.""" + + matching1 = matchings.SMMatching(**params) + matching2 = matchings.SMMatching(**params) + + assert matching1 == matching2 + + if params["dictionary"] is not None: + key = next(iter(params["dictionary"].keys())) + matching2[key] = None + + assert matching1 != matching2 + assert vars(matching1) == vars(matching2) + + +@given(st_sms()) +def test_invert(matching): + """Check the matching inverter works as it should.""" + + inverted = matching.invert() + + assert isinstance(inverted, matchings.SMMatching) + assert set(inverted.items()) == set((val, key) for key, val in matching.items()) + assert inverted.keys_ == matching.values_ + assert inverted.values_ == matching.keys_ From 74b50ac3c87725076e05af77c2dd1784de73a297 Mon Sep 17 00:00:00 2001 From: Henry Wilde Date: Thu, 15 May 2025 09:55:33 +0100 Subject: [PATCH 11/26] Write algorithm tests --- tests/hospital_resident/test_algorithm.py | 176 ++++++++++++++++------ tests/stable_marriage/test_algorithm.py | 2 +- 2 files changed, 131 insertions(+), 47 deletions(-) diff --git a/tests/hospital_resident/test_algorithm.py b/tests/hospital_resident/test_algorithm.py index a4923e8..1cd14e8 100644 --- a/tests/hospital_resident/test_algorithm.py +++ b/tests/hospital_resident/test_algorithm.py @@ -1,67 +1,151 @@ -"""Tests for the Hospital-Resident algorithm.""" +"""Unit tests for the Hospital-Resident algorithms.""" import numpy as np from hypothesis import given -from matching.algorithms.hospital_resident import ( - hospital_optimal, - hospital_resident, - resident_optimal, -) +from matching.games import HospitalResident -from .util import players +from ..common import mocked_game +from .strategies import st_ranks_capacities -@given(players_=players()) -def test_hospital_resident(players_): - """Test the algorithm produces a valid solution.""" +def _assert_matching_is_valid_shape(matching, hospital_ranks, resident_ranks, capacities): + """Assert that the matching has the right shape and elements.""" - residents, hospitals = players_ + assert isinstance(matching, dict) - matching = hospital_resident(residents, hospitals) - assert set(hospitals) == set(matching.keys()) + matched_hospitals = set(matching.keys()) + matched_residents = set([r for rs in matching.values() for r in rs]) - matched_residents = {r for rs in matching.values() for r in rs} - for resident in residents: - if resident.matching: - assert resident in matched_residents - else: - assert resident not in matched_residents + assert matched_hospitals <= set(np.unique(resident_ranks)) + assert matched_residents <= set(np.unique(hospital_ranks)) + for hospital, residents in matching.items(): + assert len(residents) <= capacities[hospital] -@given(players_=players()) -def test_resident_optimal(players_): - """Test that the resident-optimal algorithm is resident-optimal.""" - residents, hospitals = players_ +@given(st_ranks_capacities()) +def test_resident_optimal_resident_optimal(ranks_capacities): + """ + Check the resident-optimal algorithm is optimal for residents. - matching = resident_optimal(residents, hospitals) - assert set(hospitals) == set(matching.keys()) + We affirm this by going through the matching and checking that + for each resident, if they prefer a hospital to their current match, + then the hospital prefers their matches to the resident. + """ + resident_ranks, hospital_ranks, capacities = ranks_capacities + game = mocked_game(HospitalResident, *ranks_capacities) - assert all( - [ - r in set(residents) - for r in {r_match for matches in matching.values() for r_match in matches} - ] - ) + matching = game._resident_optimal() - for resident in residents: - if resident.matching: - assert resident.prefs.index(resident.matching) == 0 + _assert_matching_is_valid_shape(matching, hospital_ranks, resident_ranks, capacities) + for hospital, residents in matching.items(): + for resident in residents: + resident_rank = game.resident_ranks[resident] + preferred_hospitals, *_ = np.where(resident_rank < resident_rank[hospital]) + for preferred in preferred_hospitals: + preferred_rank = game.hospital_ranks[preferred] + partners = matching[preferred] + for partner in partners: + assert preferred_rank[resident] > preferred_rank[partner] -@given(players_=players()) -def test_hospital_optimal(players_): - """Test that the hospital-optimal algorithm is hospital-optimal.""" - _, hospitals = players_ +@given(st_ranks_capacities()) +def test_resident_optimal_hospital_pessimal(ranks_capacities): + """ + Check the resident-optimal algorithm is pessimal for hospitals. - matching = hospital_optimal(hospitals) - assert set(hospitals) == set(matching.keys()) + We affirm this by going through the matching and checking that for + each hospital, if they prefer a resident to their worst current + match, then the resident matched to them already or prefers their + match to the hospital. + """ + resident_ranks, hospital_ranks, capacities = ranks_capacities + game = mocked_game(HospitalResident, *ranks_capacities) - for hospital, matches in matching.items(): - old_idx = -np.inf - for resident in matches: - idx = hospital.prefs.index(resident) - assert idx >= old_idx - old_idx = idx + matching = game._resident_optimal() + + _assert_matching_is_valid_shape(matching, hospital_ranks, resident_ranks, capacities) + + for hospital, residents in matching.items(): + if not residents: + continue + + hospital_rank = game.hospital_ranks[hospital] + worst_match = hospital_rank[residents].max() + preferred_residents, *_ = np.where(hospital_rank < worst_match) + for preferred in preferred_residents: + if preferred in residents: + continue + + preferred_rank = game.resident_ranks[preferred] + partner = next((h for h, rs in matching.items() if preferred in rs), None) + if partner is None: + continue + + assert preferred_rank[partner] < preferred_rank[hospital] + + +@given(st_ranks_capacities()) +def test_hospital_optimal_hospital_optimal(ranks_capacities): + """ + Check the hospital-optimal algorithm is optimal for hospitals. + + We affirm this by going through the matching and checking that for + each hospital, if they prefer a resident to their best current + match, then the resident prefers their match to the hospital. + """ + resident_ranks, hospital_ranks, capacities = ranks_capacities + game = mocked_game(HospitalResident, *ranks_capacities) + + matching = game._hospital_optimal() + + _assert_matching_is_valid_shape(matching, hospital_ranks, resident_ranks, capacities) + + for hospital, residents in matching.items(): + if not residents: + continue + + hospital_rank = game.hospital_ranks[hospital] + best_match = hospital_rank[residents].min() + preferred_residents, *_ = np.where(hospital_rank < best_match) + for preferred in preferred_residents: + preferred_rank = game.resident_ranks[preferred] + partner = next((h for h, rs in matching.items() if preferred in rs), None) + if partner is None: + assert False + + assert preferred_rank[partner] < preferred_rank[hospital] + + +@given(st_ranks_capacities()) +def test_hospital_optimal_resident_pessimal(ranks_capacities): + """ + Check the hospital-optimal algorithm is pessimal for residents. + + We affirm this by going through the residents and checking that if + they prefer a hospital to their current match, then the hospital + prefers their worst match to the resident. + """ + resident_ranks, hospital_ranks, capacities = ranks_capacities + game = mocked_game(HospitalResident, *ranks_capacities) + + matching = game._hospital_optimal() + + _assert_matching_is_valid_shape(matching, hospital_ranks, resident_ranks, capacities) + + for resident, resident_rank in enumerate(game.resident_ranks): + hospital = next((h for h, rs in matching.items() if resident in rs), None) + if hospital is None: + continue + + preferred_hospitals, *_ = np.where(resident_rank < resident_rank[hospital]) + for preferred in preferred_hospitals: + preferred_matches = matching[preferred] + if not preferred_matches: + assert False + + preferred_rank = game.hospital_ranks[preferred] + worst_match = preferred_rank[preferred_matches].max() + assert preferred_rank[resident] > worst_match diff --git a/tests/stable_marriage/test_algorithm.py b/tests/stable_marriage/test_algorithm.py index 9002d67..25220bd 100644 --- a/tests/stable_marriage/test_algorithm.py +++ b/tests/stable_marriage/test_algorithm.py @@ -1,4 +1,4 @@ -"""Integration tests for the Stable Marriage Problem algorithm.""" +"""Unit tests for the Stable Marriage algorithm.""" import numpy as np from hypothesis import given From 2b0c4936204424adfc8eb5c9a7e42f2f2f8021ed Mon Sep 17 00:00:00 2001 From: Henry Wilde Date: Thu, 15 May 2025 09:55:55 +0100 Subject: [PATCH 12/26] Write tests for HR solver --- tests/common.py | 14 ++++--- tests/hospital_resident/test_game.py | 56 +++++++++++++++++++++++++++- tests/stable_marriage/strategies.py | 8 ++-- 3 files changed, 68 insertions(+), 10 deletions(-) diff --git a/tests/common.py b/tests/common.py index 624905c..888c2ad 100644 --- a/tests/common.py +++ b/tests/common.py @@ -19,14 +19,16 @@ def mocked_game(game, *args): @st.composite -def st_single_ranks(draw, num_rank: int, len_rank: int): +def st_single_ranks(draw, nrows: int, ncols: int | None = None): """Create a single rank matrix.""" + if ncols is None: + ncols = nrows rank = draw( st.lists( - st.permutations(range(len_rank)), - min_size=num_rank, - max_size=num_rank, + st.permutations(range(ncols)), + min_size=nrows, + max_size=nrows, ) ) @@ -34,8 +36,10 @@ def st_single_ranks(draw, num_rank: int, len_rank: int): @st.composite -def st_single_utilities(draw, nrows: int, ncols: int): +def st_single_utilities(draw, nrows: int, ncols: int | None = None): """Create a single utility matrix.""" + if ncols is None: + ncols = nrows utility = draw( st_numpy.arrays( diff --git a/tests/hospital_resident/test_game.py b/tests/hospital_resident/test_game.py index 2d2e063..7de3b2a 100644 --- a/tests/hospital_resident/test_game.py +++ b/tests/hospital_resident/test_game.py @@ -3,9 +3,11 @@ from unittest import mock import numpy as np +import pytest from hypothesis import given +from hypothesis import strategies as st -from matching.games import HospitalResident +from matching.games import HospitalResident, hospital_resident from ..common import mocked_game from .strategies import ( @@ -114,3 +116,55 @@ def test_from_preferences(preferences_capacities): assert call.args == (preference, sorted(others)) validator.assert_called_once_with() + + +@given(st_ranks_capacities(), st.sampled_from(["resident", "hospital"]), st.booleans()) +def test_solve(ranks_capacities, optimal, preference_lookup): + """ + Check the solver works as it should. + + This method wraps the algorithm functions for the HR game, as well + as the matching-preference conversion function. So, we mock all of + these and check they are called correctly. + """ + resident_ranks, hospital_ranks, capacities = ranks_capacities + game = mocked_game(HospitalResident, *ranks_capacities) + game._preference_lookup = preference_lookup + + with ( + mock.patch.object(game, "_resident_optimal") as mock_resident_optimal, + mock.patch.object(game, "_hospital_optimal") as mock_hospital_optimal, + mock.patch.object(game, "_convert_matching_to_preferences") as mock_convert, + mock.patch.object(hospital_resident.matchings, "HRMatching") as mock_matching, + ): + matching = game.solve(optimal=optimal) + + assert matching == game.matching == mock_matching.return_value + + if optimal == "resident": + mock_resident_optimal.assert_called_once_with() + mock_hospital_optimal.assert_not_called() + mock_matching.assert_called_once_with( + mock_resident_optimal.return_value, keys="hospitals", values="residents" + ) + if optimal == "hospital": + mock_hospital_optimal.assert_called_once_with() + mock_resident_optimal.assert_not_called() + mock_matching.assert_called_once_with( + mock_hospital_optimal.return_value, keys="hospitals", values="residents" + ) + + if preference_lookup: + mock_convert.assert_called_once_with() + else: + mock_convert.assert_not_called() + + +@given(st_ranks_capacities(), st.text(min_size=1)) +def test_solve_raises_with_bad_optimal(ranks_capacities, optimal): + """Check that the solver raises an error with a bad optimal value.""" + resident_ranks, hospital_ranks, capacities = ranks_capacities + game = mocked_game(HospitalResident, *ranks_capacities) + + with pytest.raises(ValueError, match="Invalid choice for `optimal`"): + game.solve(optimal=optimal) diff --git a/tests/stable_marriage/strategies.py b/tests/stable_marriage/strategies.py index 361de3d..a8013bb 100644 --- a/tests/stable_marriage/strategies.py +++ b/tests/stable_marriage/strategies.py @@ -10,8 +10,8 @@ def st_ranks(draw, pmin=1, pmax=5): """Create a set of rankings for a test.""" size = draw(st.integers(pmin, pmax)) - suitor_ranks = draw(st_single_ranks(size, size)) - reviewer_ranks = draw(st_single_ranks(size, size)) + suitor_ranks = draw(st_single_ranks(size)) + reviewer_ranks = draw(st_single_ranks(size)) return suitor_ranks, reviewer_ranks @@ -33,8 +33,8 @@ def st_utilities(draw, pmin=1, pmax=5): """Create a set of utility matrices.""" size = draw(st.integers(pmin, pmax)) - suitor_utility = draw(st_single_utilities(size, size)) - reviewer_utility = draw(st_single_utilities(size, size)) + suitor_utility = draw(st_single_utilities(size)) + reviewer_utility = draw(st_single_utilities(size)) return suitor_utility, reviewer_utility From 8e9617fd1b65ca9d26a3ca136346c21c34b3cfeb Mon Sep 17 00:00:00 2001 From: Henry Wilde Date: Thu, 15 May 2025 09:56:24 +0100 Subject: [PATCH 13/26] Shuffle method order in game classes --- src/matching/games/hospital_resident.py | 164 +++++++++++------------- src/matching/games/stable_marriage.py | 106 +++++++-------- 2 files changed, 125 insertions(+), 145 deletions(-) diff --git a/src/matching/games/hospital_resident.py b/src/matching/games/hospital_resident.py index 5e254a0..feadcba 100644 --- a/src/matching/games/hospital_resident.py +++ b/src/matching/games/hospital_resident.py @@ -116,6 +116,50 @@ def check_input_validity(self): truly stable in the absence of blocking pairs. """ + def solve(self, optimal="resident"): + """ + Solve the instance of HR. + + This method uses the adapted Gale-Shapley algorithms introduced + by Alvin Roth in 1984 (https://doi.org/10.1086/261272). The + algorithms find a unique, stable and party-optimal matching for + any valid set of residents and hospitals. + + The optimality of the matching is with respect to one party and + is subsequently the worst stable matching for the other party. + + Parameters + ---------- + optimal : {"resident", "hospital"}, default="resident" + Party for whom to optimise the matching. + + Raises + ------ + ValueError + If `optimal` is anything other than the permitted values. + + Returns + ------- + HRMatching + A dictionary-like object containing the matching. The keys + correspond to the hospitals in the instance, while the + values are lists of the residents matched to them. + """ + if optimal == "resident": + matching = self._resident_optimal() + elif optimal == "hospital": + matching = self._hospital_optimal() + else: + raise ValueError( + f'Invalid choice for `optimal`. Must be "resident" or "hospital", not "{optimal}".' + ) + + self.matching = matchings.HRMatching(matching, keys="hospitals", values="residents") + if self._preference_lookup: + self._convert_matching_to_preferences() + + return self.matching + def _resident_optimal(self): """ Execute the resident-optimal algorithm given some rankings. @@ -144,14 +188,15 @@ def _resident_optimal(self): capacity = capacities[hospital] if len(hospital_matches) == capacity: - worst, idx = _get_worst_match(hospital_rank, hospital_matches) + idx = hospital_rank[hospital_matches].argmax() + worst = hospital_matches[idx] del hospital_matches[idx] free_residents.add(worst) hospital_matches.append(resident) if len(hospital_matches) == capacity: - worst, _ = _get_worst_match(hospital_rank, hospital_matches) + worst = hospital_matches[hospital_rank[hospital_matches].argmax()] successors = np.where(hospital_rank > hospital_rank[worst]) resident_ranks[successors, hospital] = self.num_hospitals hospital_rank[successors] = self.num_residents @@ -167,6 +212,31 @@ def _hospital_optimal(self): dict Solution mapping hospitals to their matched residents. """ + + def _get_current_match(resident, matching): + """ + Get the current match for a resident (and its index) if any. + + Parameters + ---------- + resident : int + Resident for whom to search. + matching : dict + Mapping of hospitals to their matched residents. + + Returns + ------- + tuple[int, int] | None + Currently matched hospital and its position in the + resident's ranking or `None` if the resident is free. + """ + for hospital, residents in matching.items(): + for idx, res in enumerate(residents): + if res == resident: + return hospital, idx + + return None, None + resident_ranks = self.resident_ranks.copy() hospital_ranks = self.hospital_ranks.copy() capacities = self.capacities @@ -225,93 +295,3 @@ def _convert_matching_to_preferences(self): converted[hospitals[hospital]] = [residents[resident] for resident in resident_matches] self.matching = matchings.HRMatching(converted, keys="hospitals", values="residents") - - def solve(self, optimal="resident"): - """ - Solve the instance of HR. - - This method uses the adapted Gale-Shapley algorithms introduced - by Alvin Roth in 1984 (https://doi.org/10.1086/261272). The - algorithms find a unique, stable and party-optimal matching for - any valid set of residents and hospitals. - - The optimality of the matching is with respect to one party and - is subsequently the worst stable matching for the other party. - - Parameters - ---------- - optimal : {"resident", "hospital"}, default="resident" - Party for whom to optimise the matching. - - Raises - ------ - ValueError - If `optimal` is anything other than the permitted values. - - Returns - ------- - HRMatching - A dictionary-like object containing the matching. The keys - correspond to the hospitals in the instance, while the - values are lists of the residents matched to them. - """ - if optimal == "resident": - matching = self._resident_optimal() - elif optimal == "hospital": - matching = self._hospital_optimal() - else: - raise ValueError( - f'Invalid choice for `optimal`. Must be "resident" or "hospital", not "{optimal}".' - ) - - self.matching = matchings.HRMatching(matching, keys="hospitals", values="residents") - if self._preference_lookup: - self._convert_matching_to_preferences() - - return self.matching - - -def _get_worst_match(ranking, matches): - """ - Get the worst current match (and its index) for a hospital. - - Parameters - ---------- - ranking : np.ndarray - Hospital ranking to search. - matches : list[int] - Current matches as indices in the ranking. - - Returns - ------- - tuple[int, int] - The worst match and its position in `matches`. - """ - idx = ranking[matches].argmax() - worst = matches[idx] - - return worst, idx - - -def _get_current_match(resident, matching): - """ - Get the current match for a resident (and its position) if any. - - Parameters - ---------- - resident : int - Resident for whom to search. - matching : dict - Mapping of hospitals to their matched residents. - - Returns - ------- - tuple[int, int] | tuple[None, None] - Currently matched hospital or `None` if the resident is free. - """ - for hospital, residents in matching.items(): - for idx, res in enumerate(residents): - if res == resident: - return hospital, idx - - return None, None diff --git a/src/matching/games/stable_marriage.py b/src/matching/games/stable_marriage.py index 23c7207..136fa04 100644 --- a/src/matching/games/stable_marriage.py +++ b/src/matching/games/stable_marriage.py @@ -172,6 +172,59 @@ def check_input_validity(self): for reviewer, ranks in enumerate(self.reviewer_ranks): self._check_player_ranks(reviewer, ranks, "reviewer") + def solve(self, optimal="suitor"): + """ + Solve the instance of SM. + + This method uses an extended version of the Gale-Shapley + algorithm that makes use of the inherent structures of SM + instances. The algorithm finds a unique, stable and optimal + matching for any valid set of suitors and reviewers. + + The optimality of the matching is with respect to one party and + is subsequently the worst stable matching for the other party. + + Parameters + ---------- + optimal : {"suitor", "reviewer"}, default="suitor" + Party for whom to optimise the matching. + + Raises + ------ + ValueError + If `optimal` is anything other than the permitted values. + + Returns + ------- + SMMatching + A dictionary-like object containing the matching. The keys + correspond to the reviewers in the instance, while the + values are the suitors. + """ + + if optimal not in ("suitor", "reviewer"): + raise ValueError( + f'Invalid choice for `optimal`. Must be "suitor" or "reviewer", not "{optimal}".' + ) + + keys, values = "reviewers", "suitors" + + if optimal == "reviewer": + self._invert_player_sets() + keys, values = values, keys + + matching = matchings.SMMatching(self._stable_marriage(), keys=keys, values=values) + + if optimal == "reviewer": + matching = matching.invert() + self._invert_player_sets() + + self.matching = matching + if self._preference_lookup: + self._convert_matching_to_preferences() + + return self.matching + def _invert_player_sets(self): """ Invert the attributes associated with each set of players. @@ -239,56 +292,3 @@ def _convert_matching_to_preferences(self): converted[reviewers[reviewer]] = suitors[suitor] self.matching = matchings.SMMatching(converted) - - def solve(self, optimal="suitor"): - """ - Solve the instance of SM. - - This method uses an extended version of the Gale-Shapley - algorithm that makes use of the inherent structures of SM - instances. The algorithm finds a unique, stable and optimal - matching for any valid set of suitors and reviewers. - - The optimality of the matching is with respect to one party and - is subsequently the worst stable matching for the other party. - - Parameters - ---------- - optimal : {"suitor", "reviewer"}, default="suitor" - Party for whom to optimise the matching. - - Raises - ------ - ValueError - If `optimal` is anything other than the permitted values. - - Returns - ------- - SMMatching - A dictionary-like object containing the matching. The keys - correspond to the reviewers in the instance, while the - values are the suitors. - """ - - if optimal not in ("suitor", "reviewer"): - raise ValueError( - f'Invalid choice for `optimal`. Must be "suitor" or "reviewer", not "{optimal}".' - ) - - keys, values = "reviewers", "suitors" - - if optimal == "reviewer": - self._invert_player_sets() - keys, values = values, keys - - matching = matchings.SMMatching(self._stable_marriage(), keys=keys, values=values) - - if optimal == "reviewer": - matching = matching.invert() - self._invert_player_sets() - - self.matching = matching - if self._preference_lookup: - self._convert_matching_to_preferences() - - return self.matching From f8a095ccc6d8f9de3331f6c1959412733912005e Mon Sep 17 00:00:00 2001 From: Henry Wilde Date: Thu, 15 May 2025 10:18:59 +0100 Subject: [PATCH 14/26] Write preference matching converter test; clean up --- tests/hospital_resident/strategies.py | 30 +++++++++++++++++++++++ tests/hospital_resident/test_algorithm.py | 2 +- tests/hospital_resident/test_game.py | 27 ++++++++++++++++++++ 3 files changed, 58 insertions(+), 1 deletion(-) diff --git a/tests/hospital_resident/strategies.py b/tests/hospital_resident/strategies.py index f2b7af3..40f5d23 100644 --- a/tests/hospital_resident/strategies.py +++ b/tests/hospital_resident/strategies.py @@ -65,3 +65,33 @@ def st_preferences_capacities(draw, hmin=1, hmax=3, rmin=1, rmax=5): capacities = dict(zip(hospital_preferences, draw(st_capacities(hsize)))) return resident_preferences, hospital_preferences, capacities + + +@st.composite +def st_preference_matchings(draw, hmin=1, hmax=3, rmin=1, rmax=5): + """Create a set of preferences and a matching to go with them.""" + + resident_preferences, hospital_preferences, capacities = draw( + st_preferences_capacities(hmin, hmax, rmin, rmax) + ) + + matched_residents = draw( + st.lists(st.sampled_from(list(resident_preferences.keys())), unique=True) + ) + resident_matching = {} + spaces = capacities.copy() + for resident in matched_residents: + resident_idx = list(resident_preferences.keys()).index(resident) + hospital = draw(st.sampled_from(resident_preferences[resident])) + hospital_idx = list(hospital_preferences.keys()).index(hospital) + if spaces[hospital]: + resident_matching[resident_idx] = hospital_idx + spaces[hospital] -= 1 + + matching = { + hospital: [r for r in resident_matching if resident_matching[r] == hospital] + for hospital, _ in enumerate(hospital_preferences) + if hospital in resident_matching.values() + } + + return resident_preferences, hospital_preferences, capacities, matching diff --git a/tests/hospital_resident/test_algorithm.py b/tests/hospital_resident/test_algorithm.py index 1cd14e8..424b373 100644 --- a/tests/hospital_resident/test_algorithm.py +++ b/tests/hospital_resident/test_algorithm.py @@ -115,7 +115,7 @@ def test_hospital_optimal_hospital_optimal(ranks_capacities): partner = next((h for h, rs in matching.items() if preferred in rs), None) if partner is None: assert False - + assert preferred_rank[partner] < preferred_rank[hospital] diff --git a/tests/hospital_resident/test_game.py b/tests/hospital_resident/test_game.py index 7de3b2a..2f099bf 100644 --- a/tests/hospital_resident/test_game.py +++ b/tests/hospital_resident/test_game.py @@ -1,5 +1,6 @@ """Unit tests for the HospitalResident class.""" +import warnings from unittest import mock import numpy as np @@ -7,10 +8,12 @@ from hypothesis import given from hypothesis import strategies as st +from matching import matchings from matching.games import HospitalResident, hospital_resident from ..common import mocked_game from .strategies import ( + st_preference_matchings, st_preferences_capacities, st_ranks_capacities, st_utilities_capacities, @@ -168,3 +171,27 @@ def test_solve_raises_with_bad_optimal(ranks_capacities, optimal): with pytest.raises(ValueError, match="Invalid choice for `optimal`"): game.solve(optimal=optimal) + + +@given(st_preference_matchings()) +def test_convert_matching_to_preferences(preference_matchings): + """Test that a matching can use the terms from some preferences.""" + + resident_prefs, hospital_prefs, capacities, matching = preference_matchings + + # the arrays here aren't used anywhere internally, just placeholders + with warnings.catch_warnings(): + warnings.simplefilter("ignore") + game = HospitalResident.from_preferences(resident_prefs, hospital_prefs, capacities) + + game.matching = matchings.HRMatching(matching) + + game._convert_matching_to_preferences() + converted = game.matching + + assert isinstance(converted, matchings.HRMatching) + assert converted.keys_ == "hospitals" + assert converted.values_ == "residents" + + assert set(converted.keys()) <= set(hospital_prefs) + assert set([r for rs in converted.values() for r in rs]) <= set(resident_prefs) From 17caee8ebf98e0673755326796efb96e1041bcf6 Mon Sep 17 00:00:00 2001 From: Henry Wilde Date: Thu, 15 May 2025 11:50:48 +0100 Subject: [PATCH 15/26] Ensure we catch warnings in existing tests --- tests/hospital_resident/test_examples.py | 5 ++++- tests/stable_marriage/test_game.py | 6 +++--- 2 files changed, 7 insertions(+), 4 deletions(-) diff --git a/tests/hospital_resident/test_examples.py b/tests/hospital_resident/test_examples.py index 7a8a86c..373f9ec 100644 --- a/tests/hospital_resident/test_examples.py +++ b/tests/hospital_resident/test_examples.py @@ -2,6 +2,7 @@ import json import os +import warnings from matching.games import HospitalResident @@ -81,7 +82,9 @@ def test_example_in_issue_159(): hospital_prefs = {int(hos): prefs for hos, prefs in preferences["hospitals"].items()} capacities = {hospital: 1 for hospital in hospital_prefs} - game = HospitalResident.from_preferences(resident_prefs, hospital_prefs, capacities) + with warnings.catch_warnings(): + warnings.simplefilter("ignore") + game = HospitalResident.from_preferences(resident_prefs, hospital_prefs, capacities) for ranking, preferences in zip(game.resident_ranks, resident_prefs.values()): minimum, limit = min(ranking), game.num_hospitals diff --git a/tests/stable_marriage/test_game.py b/tests/stable_marriage/test_game.py index d96eb4f..a6e4f8d 100644 --- a/tests/stable_marriage/test_game.py +++ b/tests/stable_marriage/test_game.py @@ -275,9 +275,7 @@ def test_convert_matching_to_preferences(preference_matchings): suitor_prefs, reviewer_prefs, matching = preference_matchings - # the arrays here aren't used anywhere internally, just placeholders - with warnings.catch_warnings(): - warnings.simplefilter("ignore") + with mock.patch.object(StableMarriage, "check_input_validity") as validator: game = StableMarriage.from_preferences(suitor_prefs, reviewer_prefs) game.matching = SMMatching(matching) @@ -291,3 +289,5 @@ def test_convert_matching_to_preferences(preference_matchings): assert set(converted.keys()) == set(reviewer_prefs) assert set(converted.values()) == set(suitor_prefs) + + validator.assert_called_once_with() From e1255b80d344bcc71b3443edc90e635cede4256e Mon Sep 17 00:00:00 2001 From: Henry Wilde Date: Thu, 15 May 2025 11:51:09 +0100 Subject: [PATCH 16/26] Write tests for input validator --- tests/hospital_resident/strategies.py | 20 +++++-- tests/hospital_resident/test_game.py | 86 ++++++++++++++++++++++++++- 2 files changed, 99 insertions(+), 7 deletions(-) diff --git a/tests/hospital_resident/strategies.py b/tests/hospital_resident/strategies.py index 40f5d23..688a979 100644 --- a/tests/hospital_resident/strategies.py +++ b/tests/hospital_resident/strategies.py @@ -17,9 +17,22 @@ def st_sizes(draw, hmin, hmax, rmin, rmax): @st.composite -def st_capacities(draw, size): +def st_ranks(draw, hmin=1, hmax=3, rmin=1, rmax=5): + """Create a set of rankings for a test.""" + + hsize, rsize = draw(st_sizes(hmin, hmax, rmin, rmax)) + + resident_ranks = draw(st_single_ranks(rsize, hsize)) + hospital_ranks = draw(st_single_ranks(hsize, rsize)) + + return resident_ranks, hospital_ranks + + +@st.composite +def st_capacities(draw, hmin=1, hmax=3): """Create a capacity vector.""" + size = draw(st.integers(hmin, hmax)) capacities = draw(st.lists(st.integers(1, 3), min_size=size, max_size=size)) return np.array(capacities) @@ -31,9 +44,8 @@ def st_ranks_capacities(draw, hmin=1, hmax=3, rmin=1, rmax=5): hsize, rsize = draw(st_sizes(hmin, hmax, rmin, rmax)) - resident_ranks = draw(st_single_ranks(rsize, hsize)) - hospital_ranks = draw(st_single_ranks(hsize, rsize)) - capacities = draw(st_capacities(hsize)) + resident_ranks, hospital_ranks = draw(st_ranks(hsize, hsize, rsize, rsize)) + capacities = draw(st_capacities(hsize, hsize)) return resident_ranks, hospital_ranks, capacities diff --git a/tests/hospital_resident/test_game.py b/tests/hospital_resident/test_game.py index 2f099bf..0d4baa0 100644 --- a/tests/hospital_resident/test_game.py +++ b/tests/hospital_resident/test_game.py @@ -121,6 +121,86 @@ def test_from_preferences(preferences_capacities): validator.assert_called_once_with() +@given(st_ranks_capacities()) +def test_check_input_validity(ranks_capacities): + """ + Check that the input validator works as expected. + + This method is not called in the constructor, so we need to call + it manually. We mock the stage functions this method wraps to + check that they are called correctly. + """ + resident_ranks, hospital_ranks, capacities = ranks_capacities + game = mocked_game(HospitalResident, resident_ranks, hospital_ranks, capacities) + + with ( + mock.patch.object(game, "_check_player_ranks") as mock_check_ranks, + mock.patch.object(game, "_check_capacities") as mock_check_capacities, + ): + game.check_input_validity() + + assert mock_check_ranks.call_count == len(resident_ranks) + len(hospital_ranks) + + call_args = mock_check_ranks.call_args_list + for hospital, hospital_rank in enumerate(hospital_ranks): + call = call_args.pop(0) + assert call.kwargs == {} + for arg, item in zip(call.args, (hospital, hospital_rank, resident_ranks, "hospital")): + assert np.equal(arg, item).all() + + for resident, resident_rank in enumerate(resident_ranks): + call = call_args.pop(0) + assert call.kwargs == {} + for arg, item in zip(call.args, (resident, resident_rank, hospital_ranks, "resident")): + assert np.equal(arg, item).all() + + mock_check_capacities.assert_called_once_with() + + +@given(st_ranks_capacities()) +def test_check_player_ranks_no_warning(ranks_capacities): + """Check that the player ranks check can not raise a warning.""" + resident_ranks, hospital_ranks, capacities = ranks_capacities + game = mocked_game(HospitalResident, resident_ranks, hospital_ranks, capacities) + + with warnings.catch_warnings(): + warnings.simplefilter("error") + game._check_player_ranks(0, resident_ranks[0], hospital_ranks, "resident") + + +@given(st_ranks_capacities()) +def test_check_player_ranks_warns(ranks_capacities): + """Check that the player ranks check can raise a warning.""" + resident_ranks, hospital_ranks, capacities = ranks_capacities + game = mocked_game(HospitalResident, resident_ranks, hospital_ranks, capacities) + hospital_ranks[0][-1] = 1000 + + with pytest.warns(UserWarning, match="Hospital 0 has not made a strict"): + game._check_player_ranks(0, hospital_ranks[0], resident_ranks, "hospital") + + +@given(st_ranks_capacities()) +def test_check_capacities_no_warning(ranks_capacities): + """Check that the capacity check can not raise a warning.""" + resident_ranks, hospital_ranks, capacities = ranks_capacities + game = mocked_game(HospitalResident, resident_ranks, hospital_ranks, capacities) + + with warnings.catch_warnings(): + warnings.simplefilter("error") + game._check_capacities() + + +@given(st_ranks_capacities()) +def test_check_capacities_warns(ranks_capacities): + """Check that the capacity check can raise a warning.""" + resident_ranks, hospital_ranks, capacities = ranks_capacities + game = mocked_game(HospitalResident, resident_ranks, hospital_ranks, capacities) + game.capacities[0] = 0 + + with pytest.warns(UserWarning, match="Hospital 0 has a capacity of 0"): + game._check_capacities() + + @given(st_ranks_capacities(), st.sampled_from(["resident", "hospital"]), st.booleans()) def test_solve(ranks_capacities, optimal, preference_lookup): """ @@ -179,9 +259,7 @@ def test_convert_matching_to_preferences(preference_matchings): resident_prefs, hospital_prefs, capacities, matching = preference_matchings - # the arrays here aren't used anywhere internally, just placeholders - with warnings.catch_warnings(): - warnings.simplefilter("ignore") + with mock.patch.object(HospitalResident, "check_input_validity") as validator: game = HospitalResident.from_preferences(resident_prefs, hospital_prefs, capacities) game.matching = matchings.HRMatching(matching) @@ -195,3 +273,5 @@ def test_convert_matching_to_preferences(preference_matchings): assert set(converted.keys()) <= set(hospital_prefs) assert set([r for rs in converted.values() for r in rs]) <= set(resident_prefs) + + validator.assert_called_once_with() From 492922db6cbd24b71cdc28fc2e542116e0bdc0b3 Mon Sep 17 00:00:00 2001 From: Henry Wilde Date: Thu, 15 May 2025 11:51:23 +0100 Subject: [PATCH 17/26] Implement input validator --- src/matching/games/hospital_resident.py | 66 ++++++++++++++++++++++++- src/matching/games/stable_marriage.py | 46 ++++++++--------- 2 files changed, 88 insertions(+), 24 deletions(-) diff --git a/src/matching/games/hospital_resident.py b/src/matching/games/hospital_resident.py index feadcba..53bce7d 100644 --- a/src/matching/games/hospital_resident.py +++ b/src/matching/games/hospital_resident.py @@ -1,5 +1,7 @@ """The HR game class and supporting functions.""" +import warnings + import numpy as np from matching import convert, matchings @@ -98,7 +100,7 @@ def from_preferences(cls, resident_prefs, hospital_prefs, capacities): resident_ranks = convert.preference_to_rank(resident_prefs, hospitals) hospital_ranks = convert.preference_to_rank(hospital_prefs, residents) - capacity_array = np.array([capacities.get(h) for h in hospitals]) + capacity_array = np.array([capacities.get(h, -1) for h in hospitals]) game = cls(resident_ranks, hospital_ranks, capacity_array) game._preference_lookup = { @@ -114,7 +116,69 @@ def check_input_validity(self): Invalid games can still be solved, but the matching will not be truly stable in the absence of blocking pairs. + + Warns + ----- + UserWarning + If (a) any player has not made a strict, exhaustive ranking + of the players who ranked them, or (b) any hospital has an + invalid capacity. + """ + for hospital, ranks in enumerate(self.hospital_ranks): + self._check_player_ranks(hospital, ranks, self.resident_ranks, "hospital") + + for resident, ranks in enumerate(self.resident_ranks): + self._check_player_ranks(resident, ranks, self.hospital_ranks, "resident") + + self._check_capacities() + + @staticmethod + def _check_player_ranks(player, player_ranks, other_ranks, side): + """ + Check whether a player has made a valid ranking. + + Parameters + ---------- + player : int + Player for whom to check the ranks. + player_ranks : np.ndarray + Ranking by the player. + other_ranks : np.ndarray + Rankings of the players on the other side. + side : {"resident", "hospital"} + Side of the matching for the player. + + Warns + ----- + UserWarning + If the player has not made a strict, exhaustive ranking of + the all the players who ranked them. + """ + ranked_player = [other for other, ranks in enumerate(other_ranks) if player in ranks] + same_size = len(ranked_player) == len(player_ranks) + same_elements = set(ranked_player) == set(player_ranks) + if not same_size or not same_elements: + warnings.warn( + f"{side.title()} {player} has not made a strict, exhaustive ranking of " + f"the players who ranked them.", + UserWarning, + ) + + def _check_capacities(self): + """ + Check whether the hospital capacities are valid. + + Warns + ----- + UserWarning + If any hospital has an invalid capacity. """ + for hospital, capacity in enumerate(self.capacities): + if capacity <= 0: + warnings.warn( + f"Hospital {hospital} has a capacity of {capacity}.", + UserWarning, + ) def solve(self, optimal="resident"): """ diff --git a/src/matching/games/stable_marriage.py b/src/matching/games/stable_marriage.py index 136fa04..2bfcc86 100644 --- a/src/matching/games/stable_marriage.py +++ b/src/matching/games/stable_marriage.py @@ -101,6 +101,29 @@ def from_preferences(cls, suitor_prefs, reviewer_prefs): return game + def check_input_validity(self): + """ + Determine whether this game instance is valid or not. + + Invalid games can still be solved, but the matching will not be + truly stable in the absence of blocking pairs. + + Warns + ----- + UserWarning + If (a) the player sets are not the same size; or (b) any + player has not made a strict, exhaustive, and unique ranking + of the players on the other side of the matching. + """ + + self._check_number_of_players() + + for suitor, ranks in enumerate(self.suitor_ranks): + self._check_player_ranks(suitor, ranks, "suitor") + + for reviewer, ranks in enumerate(self.reviewer_ranks): + self._check_player_ranks(reviewer, ranks, "reviewer") + def _check_number_of_players(self): """ Check whether the player sets are the same size. @@ -149,29 +172,6 @@ def _check_player_ranks(self, player, ranks, side): UserWarning, ) - def check_input_validity(self): - """ - Determine whether this game instance is valid or not. - - Invalid games can still be solved, but the matching will not be - truly stable in the absence of blocking pairs. - - Warns - ----- - UserWarning - If (a) the player sets are not the same size; or (b) any - player has not made a strict, exhaustive, and unique ranking - of the players on the other side of the matching. - """ - - self._check_number_of_players() - - for suitor, ranks in enumerate(self.suitor_ranks): - self._check_player_ranks(suitor, ranks, "suitor") - - for reviewer, ranks in enumerate(self.reviewer_ranks): - self._check_player_ranks(reviewer, ranks, "reviewer") - def solve(self, optimal="suitor"): """ Solve the instance of SM. From 5470a7177b3683f73af7b8eca0139d2a97058137 Mon Sep 17 00:00:00 2001 From: Henry Wilde Date: Thu, 15 May 2025 12:05:45 +0100 Subject: [PATCH 18/26] Update HR tutorial --- docs/tutorials/hospital_resident.ipynb | 32 +++++++++++++++----------- 1 file changed, 18 insertions(+), 14 deletions(-) diff --git a/docs/tutorials/hospital_resident.ipynb b/docs/tutorials/hospital_resident.ipynb index 0d268c4..25af594 100644 --- a/docs/tutorials/hospital_resident.ipynb +++ b/docs/tutorials/hospital_resident.ipynb @@ -46,6 +46,7 @@ "outputs": [], "source": [ "import urllib\n", + "import warnings\n", "\n", "import yaml\n", "\n", @@ -126,9 +127,11 @@ "source": [ "from matching.games import HospitalResident\n", "\n", - "game = HospitalResident.create_from_dictionaries(\n", - " resident_preferences, hospital_preferences, hospital_capacities\n", - ")" + "with warnings.catch_warnings():\n", + " warnings.simplefilter(\"ignore\")\n", + " game = HospitalResident.from_preferences(\n", + " resident_preferences, hospital_preferences, hospital_capacities\n", + " )" ] }, { @@ -171,19 +174,20 @@ "name": "stdout", "output_type": "stream", "text": [ - "Dewi Sant (30 / 30): [067, 022, 023, 158, 139, 065, 160, 131, 011, 137, 039, 045, 013, 046, 072, 037, 086, 152, 144, 154, 130, 040, 010, 159, 083, 019, 169, 193, 168, 079]\n", - "Prince Charles (29 / 30): [027, 133, 106, 081, 051, 044, 069, 157, 110, 119, 129, 107, 135, 034, 007, 194, 198, 061, 087, 041, 183, 136, 059, 178, 009, 008, 031, 070, 026]\n", - "Prince of Wales (30 / 30): [143, 128, 048, 175, 078, 132, 151, 030, 124, 138, 088, 004, 199, 173, 017, 097, 064, 025, 112, 181, 171, 196, 111, 035, 185, 156, 140, 001, 197, 177]\n", - "Royal Glamorgan (30 / 30): [073, 118, 096, 089, 014, 126, 142, 053, 021, 018, 104, 015, 147, 153, 033, 113, 146, 076, 123, 042, 117, 024, 029, 000, 016, 134, 058, 166, 075, 174]\n", - "Royal Gwent (27 / 30): [028, 105, 115, 095, 054, 006, 120, 161, 187, 164, 091, 141, 036, 184, 071, 155, 066, 182, 189, 002, 191, 068, 090, 145, 163, 121, 180]\n", - "St. David (30 / 30): [149, 101, 150, 172, 165, 020, 049, 094, 060, 116, 056, 005, 093, 188, 043, 108, 192, 092, 167, 114, 012, 063, 077, 162, 085, 195, 032, 099, 084, 127]\n", - "University (24 / 30): [109, 003, 057, 170, 176, 100, 122, 080, 038, 082, 102, 052, 062, 055, 047, 074, 050, 179, 125, 186, 148, 103, 098, 190]\n" + "Dewi Sant (30 / 30): ['010', '011', '013', '019', '022', '023', '037', '039', '040', '045', '046', '065', '067', '072', '079', '083', '086', '130', '131', '137', '139', '144', '152', '154', '158', '159', '160', '168', '169', '193']\n", + "Prince Charles (29 / 30): ['007', '008', '009', '026', '027', '031', '034', '041', '044', '051', '059', '061', '069', '070', '087', '107', '110', '119', '129', '133', '135', '136', '157', '178', '183', '194', '198', '106', '081']\n", + "Prince of Wales (30 / 30): ['001', '004', '017', '030', '035', '048', '064', '078', '088', '097', '111', '112', '124', '128', '132', '138', '140', '143', '151', '156', '171', '173', '175', '177', '181', '185', '196', '197', '199', '025']\n", + "Royal Glamorgan (30 / 30): ['000', '014', '015', '016', '018', '021', '024', '029', '033', '042', '053', '058', '073', '075', '076', '089', '096', '104', '113', '117', '118', '123', '126', '134', '142', '146', '147', '153', '166', '174']\n", + "Royal Gwent (27 / 30): ['002', '006', '028', '036', '054', '068', '071', '090', '091', '105', '120', '121', '141', '145', '155', '161', '163', '164', '180', '182', '184', '187', '189', '191', '066', '115', '095']\n", + "St. David (30 / 30): ['005', '012', '020', '032', '043', '049', '056', '060', '063', '077', '084', '085', '092', '093', '094', '099', '101', '108', '114', '116', '127', '149', '150', '162', '165', '167', '172', '188', '192', '195']\n", + "University (24 / 30): ['038', '047', '050', '052', '055', '057', '062', '074', '080', '082', '098', '100', '102', '103', '109', '122', '148', '170', '176', '179', '186', '190', '125', '003']\n" ] } ], "source": [ "for hospital, residents in solution.items():\n", - " print(f\"{hospital} ({len(residents)} / {hospital.capacity}): {residents}\")" + " capacity = hospital_capacities[hospital]\n", + " print(f\"{hospital} ({len(residents)} / {capacity}): {residents}\")" ] }, { @@ -217,7 +221,7 @@ "matched_residents = []\n", "for _, residents in solution.items():\n", " for resident in residents:\n", - " matched_residents.append(resident.name)\n", + " matched_residents.append(resident)\n", "\n", "unmatched_residents = set(resident_preferences.keys()).difference(matched_residents)\n", "unmatched_residents" @@ -236,7 +240,7 @@ ], "metadata": { "kernelspec": { - "display_name": "matching", + "display_name": ".venv", "language": "python", "name": "python3" }, @@ -250,7 +254,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.10" + "version": "3.13.1" } }, "nbformat": 4, From 842c9107957bcc86b16c69ac05ee54e87200bca1 Mon Sep 17 00:00:00 2001 From: Henry Wilde Date: Thu, 15 May 2025 12:16:33 +0100 Subject: [PATCH 19/26] Clean up from preferences method --- src/matching/games/hospital_resident.py | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-) diff --git a/src/matching/games/hospital_resident.py b/src/matching/games/hospital_resident.py index 53bce7d..d15831d 100644 --- a/src/matching/games/hospital_resident.py +++ b/src/matching/games/hospital_resident.py @@ -100,13 +100,10 @@ def from_preferences(cls, resident_prefs, hospital_prefs, capacities): resident_ranks = convert.preference_to_rank(resident_prefs, hospitals) hospital_ranks = convert.preference_to_rank(hospital_prefs, residents) - capacity_array = np.array([capacities.get(h, -1) for h in hospitals]) + capacity_array = np.array([capacities.get(h, 0) for h in hospitals]) game = cls(resident_ranks, hospital_ranks, capacity_array) - game._preference_lookup = { - "residents": residents, - "hospitals": hospitals, - } + game._preference_lookup = {"residents": residents, "hospitals": hospitals} return game From 27b640d332a4e1de74e5d67385b906a45586d64c Mon Sep 17 00:00:00 2001 From: Henry Wilde Date: Thu, 15 May 2025 12:28:37 +0100 Subject: [PATCH 20/26] Fix README examples --- README.md | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/README.md b/README.md index 2c95764..b9e8b6c 100644 --- a/README.md +++ b/README.md @@ -95,11 +95,11 @@ largely look and behave like one. It is in fact an instance of the ```python >>> type(matching) - + >>> isinstance(matching, dict) True >>> matching -SingleMatching({'F': 'C', 'D': 'B', 'E': 'A'}, keys="reviewers", values="suitors") +SMMatching({'F': 'C', 'D': 'B', 'E': 'A'}, keys="reviewers", values="suitors") ``` @@ -118,27 +118,27 @@ One of the limitations of this library is the time complexities of the algorithm implementations. In practical terms, the running time of any of the algorithms in Matching is negligible but the theoretic complexity of each has not yet been attained. For example, an instance of HR with -400 applicants and 20 hospitals is solved in less than one tenth of a +400 applicants and 20 hospitals is solved in around one tenth of a second: ```python ->>> from matching.games._old_hospital_resident import HospitalResident +>>> from matching.games import HospitalResident >>> import numpy as np >>> prng = np.random.default_rng(0) >>> num_residents, num_hospitals = 400, 20 >>> resident_prefs = { -... r: np.argsort(prng.random(size=num_hospitals)) +... r: list(np.argsort(prng.random(size=num_hospitals))) ... for r in range(num_residents) ... } >>> hospital_prefs = { -... h: np.argsort(prng.random(size=num_residents)) +... h: list(np.argsort(prng.random(size=num_residents))) ... for h in range(num_hospitals) ... } >>> capacities = {h: num_hospitals for h in hospital_prefs} >>> game = HospitalResident.from_preferences( ... resident_prefs, hospital_prefs, capacities ... ) ->>> _ = game.solve() # 48.6 ms ± 963 µs per loop +>>> _ = game.solve() # 118 ms ± 847 µs per loop ``` From 17d4a4736fea8d993eeb0b51de5bd56dbc2ae172 Mon Sep 17 00:00:00 2001 From: Henry Wilde Date: Thu, 15 May 2025 12:34:14 +0100 Subject: [PATCH 21/26] Update all tutorials and the docs dependencies --- docs/tutorials/stable_marriage.ipynb | 6 +- docs/tutorials/stable_roommates.ipynb | 4 +- docs/tutorials/student_allocation.ipynb | 24 ++++---- pyproject.toml | 1 + uv.lock | 77 ++++++++++++++++++++++++- 5 files changed, 93 insertions(+), 19 deletions(-) diff --git a/docs/tutorials/stable_marriage.ipynb b/docs/tutorials/stable_marriage.ipynb index b4aa2ef..94d7336 100644 --- a/docs/tutorials/stable_marriage.ipynb +++ b/docs/tutorials/stable_marriage.ipynb @@ -99,7 +99,7 @@ { "data": { "text/plain": [ - "SingleMatching({'Lydia': 'Wickham', 'Elizabeth': 'Darcy', 'Jane': 'Bingley', 'Charlotte': 'Collins'}, keys=\"reviewers\", values=\"suitors\")" + "SMMatching({'Lydia': 'Wickham', 'Elizabeth': 'Darcy', 'Jane': 'Bingley', 'Charlotte': 'Collins'}, keys=\"reviewers\", values=\"suitors\")" ] }, "execution_count": 3, @@ -123,7 +123,7 @@ ], "metadata": { "kernelspec": { - "display_name": "matching", + "display_name": ".venv", "language": "python", "name": "python3" }, @@ -137,7 +137,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.10" + "version": "3.13.1" } }, "nbformat": 4, diff --git a/docs/tutorials/stable_roommates.ipynb b/docs/tutorials/stable_roommates.ipynb index e1f3154..e470403 100644 --- a/docs/tutorials/stable_roommates.ipynb +++ b/docs/tutorials/stable_roommates.ipynb @@ -130,7 +130,7 @@ ], "metadata": { "kernelspec": { - "display_name": "matching", + "display_name": ".venv", "language": "python", "name": "python3" }, @@ -144,7 +144,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.10" + "version": "3.13.1" } }, "nbformat": 4, diff --git a/docs/tutorials/student_allocation.ipynb b/docs/tutorials/student_allocation.ipynb index 433acac..25c0c5a 100644 --- a/docs/tutorials/student_allocation.ipynb +++ b/docs/tutorials/student_allocation.ipynb @@ -981,7 +981,7 @@ { "data": { "text/plain": [ - "{A0: [], A1: [190019, 190034], A2: [190017], B0: [], B1: [190091], B2: [], C0: [190003, 190068], C1: [190070], C2: [190079, 190062], D0: [190015, 190039, 190009], D1: [190008, 190056], D2: [], E0: [], E1: [190063, 190022], E2: [], F0: [190011], F1: [190094], G0: [190096], G1: [], G2: [190000, 190045, 190077], H0: [], H1: [190078], H2: [190023, 190098], I0: [190004], I1: [], I2: [], J0: [190021], J1: [190097, 190089, 190061, 190014], J2: [190085, 190090], K0: [190074, 190095], K1: [190024, 190013], K2: [190052, 190006], L0: [190072], M0: [190086, 190053], M1: [190054, 190081, 190075], N0: [190049, 190032], N1: [190046, 190044, 190037, 190057], N2: [190031, 190060], O0: [190016], O1: [], P0: [190047], P1: [190076, 190027], P2: [190093], P3: [190071], Q0: [190001], R0: [190048], R1: [], R2: [], S0: [190069], S1: [190092, 190042, 190084, 190066, 190067], T0: [], T1: [], T2: [190036], U0: [190010, 190002, 190059, 190030], U1: [], U2: [190055], V0: [190073], V1: [], V2: [190018], W0: [190026], W1: [190058], X0: [190088, 190080, 190012], X1: [190028], X2: [190043, 190064, 190020], Y0: [190083, 190007, 190099], Y1: [190065, 190050], Y2: [190033], Z0: [190051], Z1: [190005, 190038]}" + "_MultipleMatching({A0: [], A1: [190019, 190034], A2: [190017], B0: [], B1: [190091], B2: [], C0: [190003, 190068], C1: [190070], C2: [190079, 190062], D0: [190015, 190039, 190009], D1: [190008, 190056], D2: [], E0: [], E1: [190063, 190022], E2: [], F0: [190011], F1: [190094], G0: [190096], G1: [], G2: [190000, 190045, 190077], H0: [], H1: [190078], H2: [190023, 190098], I0: [190004], I1: [], I2: [], J0: [190021], J1: [190097, 190089, 190061, 190014], J2: [190085, 190090], K0: [190074, 190095], K1: [190024, 190013], K2: [190052, 190006], L0: [190072], M0: [190086, 190053], M1: [190054, 190081, 190075], N0: [190049, 190032], N1: [190046, 190044, 190037, 190057], N2: [190031, 190060], O0: [190016], O1: [], P0: [190047], P1: [190076, 190027], P2: [190093], P3: [190071], Q0: [190001], R0: [190048], R1: [], R2: [], S0: [190069], S1: [190092, 190042, 190084, 190066, 190067], T0: [], T1: [], T2: [190036], U0: [190010, 190002, 190059, 190030], U1: [], U2: [190055], V0: [190073], V1: [], V2: [190018], W0: [190026], W1: [190058], X0: [190088, 190080, 190012], X1: [190028], X2: [190043, 190064, 190020], Y0: [190083, 190007, 190099], Y1: [190065, 190050], Y2: [190033], Z0: [190051], Z1: [190005, 190038]}, keys=\"keys\", values=\"values\")" ] }, "execution_count": 23, @@ -1065,7 +1065,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAACAwAAASYCAYAAACeDs3kAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAC4jAAAuIwF4pT92AADDe0lEQVR4nOzdd5RV1fk/4PfSO0hTOmIDC2BBFAtFrFhR7IrYjRpNNH5NTIxJjC3GmGg0VjRBEzGCSsQuKDZEBRFFsDAgKNJ7Z87vDxfz83JnYGYYGMbzPGvNypx9z977vXUM53P3ziRJkgQAAAAAAAAAkCqVyrsAAAAAAAAAAGDLExgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAIByMHLkyMhkMlk/I0eOLO+yKKaFCxfG3XffHf369YuddtopGjZsGJUrV856Pjt37lzeZQIAAMAGVSnvAgAAADaHNWvWxCeffBKfffZZLFiwIBYsWBBr166N2rVrR506daJly5bRtm3baNu2bVSvXr28ywUqkH/84x9xzTXXxOLFi8u7FAAAANgkAgMAAMCPxsqVK2Po0KHx8MMPx5tvvhnLly/faJ+qVavG7rvvHl26dInu3bvHYYcdFo0bN94C1QIV0R/+8Ie4/vrry7sMAAAAKBMCAwAAwI/Cs88+G5deemlMnz69RP1Wr14dY8eOjbFjx8b9998flSpViksvvTT+9re/baZKgYrqgw8+iBtuuCGnPZPJRKtWraJBgwaRyWQK2nfZZZctWB0AAACUnMAAAABQoSVJEpdeemnce++9ZTJefn5+TJs2rUzGAn5c7rjjjsjPz89q++UvfxlXX311NGzYsJyqAgAAgNITGAAAACq0iy++OO6///5Cb2vdunX06tUrdtttt2jSpEnUrl07lixZEvPnz4/PP/88Pvjgg/joo49i5cqVW7hqoKLJz8+PYcOGZbX169cvbrrppnKqCAAAADadwAAAAFBhPf3004WGBfbaa6+47bbbolevXlnLgxdm2bJl8cILL8TQoUNj6NChsXTp0s1VLmTp0aNHJElS3mVQTBMnTozFixdntZ1yyinlVA0AAACUDYEBAACgQkqSJH72s5/ltPft2zcef/zxqF69erHGqVWrVvTt2zf69u0bCxcujIEDB8aMGTPKulyggitsq5JddtmlHCoBAACAsiMwAAAAVEhvv/125OXlZbW1aNEiHnnkkWKHBdZXv379uPLKKze9OOBHZ+HChTlttWvXLodKAAAAoOxUKu8CAAAASuP555/PaTvnnHOibt265VAN8GO3YsWKnLaNbXkCAAAAWzsrDAAAABXS1KlTc9r23nvvcqhk67ZixYoYPXp0fPbZZzF//vyoWrVqNG/ePHbeeefYa6+9NtsFzwULFsSYMWPiu+++i9mzZ8fKlSujcePG0bRp0+jSpUs0a9Zss8z7Q7NmzYr3338/pkyZEgsXLoxMJhONGzeOE044IRo3brzZ59+Svvvuu/joo49i6tSpsWjRoli+fHnUqFEjatWqFdttt120bds2dt5556hTp06ZzLd27dr48MMPY8qUKTF79uxYuHBhNGzYMJo0aRI777xz7LHHHmUyz8b8WJ/jde+fL7/8MhYsWBD5+fnRsGHDOPLII6NNmzbFGmPdczR16tSYPXt2zJ8/P+rVqxdNmjSJnXbaKfbcc8/N9v5ftmxZjB49OmbOnBmzZ8+OpUuXRqNGjaJJkybRuXPn2H777TfLvKWRJEl89dVXMX78+Jg5c2YsWrQo1qxZEzVr1ow6depEy5YtC94/VaqU/T+jffPNNzFmzJiYMmVKLF26NBo2bBjNmzePLl26RPPmzct0ruXLl8fkyZPjs88+izlz5sSiRYuiSpUqsc0220Tjxo2jc+fO0bZt2zKdc31r166NcePGRV5eXsyZMyfmzZsXVapUiXr16kXbtm2jQ4cO0bp16zKbb9q0aTF+/PiYPXt2zJ49OypXrhyNGzeO5s2bx/77719mn4kREatXr46JEyfGhAkTYt68ebFo0aLIZDJRs2bNaNCgQbRu3TratWu32R9jAAAosQQAAKACOuyww5KIyPp58cUXt9j8U6ZMyZl/4MCBpRqre/fuWeN07959o31GjBiRM/+IESMKbv/yyy+TAQMGJLVq1co5b91P69atk+uuuy5ZsmRJqepe37Jly5I///nPyf77759Urly5yHkjItltt92SW265pVRzb+jxys/PTx577LFkv/32SzKZTKFzjxgxIlm5cmXSqFGjrPZOnTpt8mNw880358z3v//9r9BzN/Ycbsz8+fOTP/7xj8muu+66wcd63U/lypWTTp06JVdeeWXy5ptvJvn5+SW+f2PGjElOPfXUZJttttngXM2bN08uuOCC5IsvvijxHElSNs/xpurfv3+xHteifvr377/RMdu0aZN1+/Dhw5PevXsX+f4pzmfMyy+/nJx00klJgwYNNlhfo0aNkrPPPjuZOHHiJj9WSZIkq1evTh544IGkV69eSbVq1TY49w477JD88pe/TObOnVsmc5fGpEmTkp/+9KfJtttuW6zns1atWslBBx2U/PGPf0wmTZq00fE39lwPHTo02X///Yucr1KlSslBBx2UDBkypNT3MT8/P3nzzTeTa665Jtl3332TKlWqbPR+tmzZMrniiiuSqVOnlnrewjzzzDPJcccdl9SvX3+jNbRu3To5//zzkzfeeKNUc02fPj256qqrkvbt229wnqpVqyYHHXRQ8p///KdUn4frvPbaa8kpp5yS1KxZs1ivpcaNGydHH310cv/99yezZ88u9bwAAFBWBAYAAIAK6dhjj835R/j7779/i82/NQcGHn744WJfuFh3ceaVV14pVe3rPPDAA0mzZs1KfFF12223TZ588skSzVXU4zVz5szk4IMP3uic6x6nyy+/POe2sWPHbtLjsMsuu2SN16xZs2TNmjWFnrspgYHBgwcnTZo0KfHj/cOfklwonj17dnLKKacUeYF+QxfkfvrTnyYrVqwo9lxJUnbP8abYkoGBxYsXJyeeeOJGx9zQZ8z48eOTXr16lbjOypUrJxdddFGJn6MfGjp0aLLjjjuWeO569eold999d6nnLY38/Pzk17/+9UZDDRv73NqYop7rpUuXJn379i3RfMcdd1yJLyyPHDkyadWqVanvY5UqVZJf//rXydq1a0vzMBcYMWJEsueee5a6jssvv7zYcy1btiy5+uqrkxo1apR4no4dOyYff/xxie7bvHnzkhNOOGGTPidOOeWUkj6kAABQ5ioFAABABbTddtvltA0ePLgcKtm63HvvvXHuuefG8uXLi91n2rRpcdRRR8Vzzz1X4vlWr14d559/flxwwQXx7bfflrj/d999FyeffHL84Q9/KHHfH5o5c2Z069Yt3njjjWL3GTBgQE7bwIEDS13D22+/HZMmTcpqO/vss6Ny5cqlHrMwDz74YJxyyikxe/bsMh23KF999VV069YtnnjiiUiSpER9V69eHX/729/i0EMPjfnz529SHaV5jiuCpUuXxiGHHBJPPfVUqccYNmxY7L///vHaa6+VuO/atWvjvvvuix49esSsWbNK1DdJkvjtb38bJ5xwQnzxxRclnnvRokVx2WWXxUUXXRRr164tcf/S6N+/f9x4442xatWqLTLfD61cuTKOOOKIGDJkSIn6PfPMM3HIIYfE3Llzi91nypQp8fXXX5e0xAJr1qyJG2+8MY477rhYs2ZNqca48847o3fv3jF27NhS17Fo0aJinTdz5szo0aNH3H777bFixYoSzzN+/Pjo1q1bDB8+vFjnz58/P3r06BFDhw4t8VwAALC1KfvN1wAAALaAbt26xf3335/V9sorr8Rdd90Vl19+eTlVVb7efffd+PWvf11wXKVKlejVq1f07t07WrRoEStXroypU6fGs88+m3MBZ9WqVXHiiSfGyJEjY7/99ivWfPn5+XH88ccXeoGlefPmccghh8See+4ZjRs3jho1asS8efNi7Nix8fzzz8e0adMKzk2SJK6//vpo3LhxXHLJJSW+3/n5+XHyySfHV199VdDWrl276NOnT7Rv3z4aN24cc+fOjSlTpmRdlN1zzz2jc+fOMW7cuIK2xx9/PG6//faoWrVqiet45JFHctoKCyVsikmTJsVll12Wc+G+Zs2a0atXr+jSpUu0adMm6tSpE2vWrIlFixbFt99+G5988kmMGTMm8vLySjTfrFmz4sADDyw0DNKyZcvo27dvdOjQIRo2bBizZs2Kjz76KIYOHZpzYXPUqFHRu3fvePvtt6N69eolvt+lfY43RevWraNTp04Fx/Pmzcu5ANuhQ4eoVq1akf2L48ILL4z33nuv4Lh58+bRp0+f2GOPPaJp06axaNGigvdtYR5//PE466yzIj8/P6u9WrVq0atXr+jatWu0atUq6tevH0uWLIm8vLx49dVX480338w6/913342+ffvGiBEjiv36v+SSS+K+++7LaW/YsGEceuihsffee0fTpk2jVq1asWDBgvjkk0/ihRdeyAnW3H///dGgQYO49dZbizVvaT366KPxr3/9K6e9SZMmcfjhh8cee+wRzZs3j5o1a8by5ctj8eLFMWXKlPjkk0/inXfe2eTQy1VXXRWjRo0qOG7cuHH07ds3OnbsGI0bN445c+bExx9/HEOGDMkJBI0fPz4OP/zweOedd0r1+bTddtvF3nvvHR06dIi2bdtGvXr1olatWrF06dKYNWtWfPzxx/HCCy/khEb+97//xa9+9au47bbbSjTfr371q7j55psLvW3HHXeMww47LHbZZZdo0qRJJEkS8+fPj8mTJ8f7778f7733XolCCt99913st99+MXXq1Jzbdt999+jevXvstttu0aBBg4j4/nPtnXfeieHDh8fixYsLzl28eHGceOKJ8fbbb8eee+65wTl//vOfx/jx43Pad9555+jdu3e0b98+GjVqFNWrV48lS5bEggULYvLkyTFhwoQYPXp0rFy5stj3DwAANrtyXd8AAACglGbNmlXksvvHHHNMMmrUqM06/9a4JcEPl2Hef//9k88++6zI/sOHD09atGiRM0b79u2LvTT59ddfn9O/ZcuWyeDBg4tchj9J/v9e53Xq1MnqW61ateSDDz7Y6LzrP14/3O+9UaNGyT//+c8i96POz8/Pun9//etfc+7DU089Vaz7/0PLli1L6tWrlzVOt27dNtinNFsSnHfeeTl9zjzzzGTWrFnFqvOTTz5Jfve73yUtWrTY6JYE+fn5yZFHHpkzX82aNZM77rijyKXKly1bllxzzTVJpUqVcvpeeeWVxaqzLJ/jsjJw4MCc+zNlypQSjbH+MvU/vF81a9ZM7rzzzmTVqlVF9l++fHnW8YQJE5JatWrlLCX/i1/8YqOvibFjxyZ77713zn26+uqri3VfHn744Zy+DRs2TO67776cOn8oPz8/GTJkSNK0adOc/sOGDSvW3KW1/rYJlStXTm677bZivV7WrFmTvPnmm8mFF16Y7LDDDhs9f/3nunr16gVbelSqVCn5v//7vyIfp+XLlyfXXnttoe+hG264oVj3deDAgUm7du2SG2+8Mfnoo4+K1WfNmjXJoEGDku222y5rzkwmk7z33nvFGiNJkuTJJ58s9G9z586dkxdffHGj/efMmZM88MADSceOHQvd2uOH1q5dW+hWHN26dUvefffdDfadP39+8vOf/zxnq5Xtt98+WbRoUZH9pk2bltOnSZMmybPPPrvR+5YkSbJkyZJk6NChSZ8+fZLTTz+9WH0AAGBzEhgAAAAqrF/84heFXpRY99OiRYtkwIAByf3335+MGzcuWb16dZnNvTUGBtb99OjRY4MX7Nb58ssvk+bNm+f0//3vf7/Rvm+//XbOxaz9998/WbBgQXHucpIkSTJu3Lici+xHHnnkRvut/3it+9l2222TTz75pNjzJ8n3F6bW38v8mGOOKdEYSZIkgwYNyqnngQce2GCf0gQGGjdunHV+r169irxwviGrV69OVq5cucFzHnvssZz6atSokbzyyivFmuO+++7L6Z/JZJIxY8ZstG9ZPsdlZXMEBtb91K5dO3n99ddLNNbatWuT3XffPWec1157rdhjrFy5Mjn00EOzxqhWrVry9ddfb7DflClTcoIKO++880b7/dC0adOSli1bZo2x2267ler1XBwTJkwo9cX39S1dunSj5xT1XEdEcu+99xZrnnvvvTenb9WqVZMvvvhio30XLVpU6sdy6tSpSevWrbPmPe2004rVd9asWUndunVz6j755JNLFeTJy8vb4O233nprzlyXXnppie57YeGXW2+9tcjz77777pzzR44cWez5fqg4ryUAANjcKgUAAEAF9fvf/z7233//Im+fMWNGDBw4MC688MLo3Llz1K1bN7p27Ro//elP47///W989913W7DaLaNRo0bx3//+N2rUqLHRc9u1axePPfZYTvs999wTq1ev3mDfG2+8MWsJ9ObNm8fw4cOjfv36xa61U6dOcc8992S1Pf/88/HRRx8Ve4wfevDBB2PXXXctUZ9GjRrFsccem1NDSV8bAwcOzDquVatWnHLKKSUaY2MWL14cc+bMyWo777zzIpPJlHisKlWqFLmU/jp33HFHTtttt90WhxxySLHmuPDCC+Piiy/OakuSpNBxi6s0z3FFcMstt8TBBx9coj5PPfVUTJgwIatt4MCB0bNnz2KPUa1atXjyySejcePGBW2rVq3a6HP0pz/9KZYtW1ZwXLt27XjhhReiZcuWxZ67VatW8Z///Cer7ZNPPolhw4YVe4yS+OF2FutccMEFpRqrVq1apa7jnHPOyXlfFOXiiy+Oc845J6tt9erVce+99260b926dUv12RDx/XYa6382P/nkk7Fw4cKN9v3LX/6Stcx/RMRBBx0U//73v0u1HUmbNm2KvG3ZsmXxpz/9KautT58+cffdd5fovg8YMCDOP//8rLa//OUvsWrVqkLPX/+1tNNOO0X37t2LPd8PbcprCQAAyorAAAAAUGHVqFEjhg8fHsccc0yxzl+xYkW89957cdddd0W/fv2iWbNm0aNHj3j44Yd/NPsJ33DDDdGoUaNin9+jR4848cQTs9pmzpwZzzzzTJF9JkyYEMOHD89qu+mmmwr2hy6J008/PXbaaaestqeffrrE4/Ts2TOOPvroEveL+P5i0Q+tWbOm0H3OizJt2rR47bXXstpOOumkqFu3bqnqKcr6F+EiokTPdUm8++678cEHH2S17bHHHnHppZeWaJybb745ttlmm6y20oZ1NuU53prtsMMOJX5cIyJuvfXWrOMePXpEv379SjxO/fr144orrshqGzp0aJHnz549Oycg84tf/CK23377Es99wAEH5ARQNjT3ptiS75+i1KxZM+d525hbb701atasmdU2cODAzf4368gjj8wKkqxZsyZGjx69wT5LliyJv//971lt1apVi3/9619RqVLZ/xPkww8/nBWiqlSpUtx1112lGuv666/PChnMnDkz3nnnnULPXf+1tKVfRwAAUNYEBgAAgAqtQYMG8cwzz8Q///nP2HHHHUvUN0mSeP311+O8886LnXfeudBv21ckNWrUiLPOOqvE/S688MKctueff77I8//73/9mHdetW7fU36bPZDJx5JFHZrWNHDmyxOOcd955pZo/IuLwww+P5s2bZ7U98sgjxe7/6KOPRpIkWW3rhxDKQsOGDXO+Nfvmm2+W+TwRES+//HJO20UXXVTii34NGjSI0047Latt9erVW/w53poNGDCgxN8Ez8vLywl0rP8N6ZLo06dPzvhTp04t9Nznnnsuli9fvtnmLs1rozgKu6i7ud4/RTnuuOOiadOmJerTtGnTOP7447Pa5s2bF++9914ZVparUqVKscMOO2S1vfvuuxvs8/rrr8eiRYuy2k455ZQNrhKwKdb/W9SrV69SBVcivl/xYo899shqK+q1uP5r6eOPPy7W6gsAALC1EhgAAAAqvEwmE2eddVZMnDgxhg0bFqeddlrUq1evRGNMmzYtzjzzzBgwYECFXW2gR48eJdoSYJ3evXvnPF4bujD0+uuvZx3vtddexdoCoSjrX+AZO3ZsiccoyTLs66tcuXKcffbZWW2ffPJJjBkzZqN9kySJRx99NKutXbt2pV6eekNq1KgRHTt2zGq7/fbbY8iQIWU+11tvvZXTtv5KFMV18sknF2v8jdmU53hrVpr7tf57MOL7b+uXVmEXWYt6H64/d5s2baJFixZlNndeXl4sWLCg1OMVpUuXLjmBlwsuuCA++eSTMp+rKOtf+C+uvn375rRt7OJ9YSZMmBADBw6Mn/3sZ9G3b9/o3bt3dO3aNTp37lzoz/pbXkybNm2D4xd2gb00IbbiWLlyZc6KB5vyHogo/t+irl27Zh0vXbo0Tj311Jg3b94mzQ8AAOWlSnkXAAAAUFaqVKkSRx99dBx99NGxdu3aGDduXLz55psxZsyYGDt2bEyaNCnWrl27wTEeeeSRWLZsWTzxxBNbqOqys/fee5eqX6VKlaJTp04xatSograJEyfGsmXLcvZXXrt2bc6FqvHjx0fnzp1LNXdE5FxkWbhwYaxevTqqVq1arP7bbrttzgoBJXXOOefELbfcktX2yCOPRJcuXTbYb9SoUfHll1/mjFXavcM3ZsCAAXHllVcWHK9YsSJOPPHE2G+//aJ///5x9NFHl2gf+aJ8+OGHWcctW7aM7bbbrlRj7b333lGpUqXIz88vcvyNKYvneGuUyWRK9d4pLHBR2ovRRfnhUu8bmnvOnDmb9P5fsmRJoXOXZouTDWnYsGEce+yxWVueTJkyJTp16hTHHXdcnHbaaXHYYYeVOGxWEqX9jN5rr71y2tZfYaIoK1eujLvuuisGDhwYn376aanmX2djQY71l/CvVKlS7Lfffps0Z1E++OCDWLFiRVbbww8/XKotbdZZPxBR1Hvg8MMPj2bNmsW3335b0PbCCy9Eu3bt4owzzoiTTjopDjzwwGL/DQMAgPImMAAAAPwoVa5cOfbee++sCzTLli2L0aNHx4gRI+LJJ5+Mzz77rNC+gwcPjgMPPDAuv/zyLVVumdhll11K3bd9+/ZZgYEkSWLOnDnRunXrrPPmzp2bc5Fm/vz5MX/+/FLPXZh58+bFtttuW6xzS7rEd2F22WWX6NatW7z99tsFbf/+97/jjjvuiOrVqxfZb/293CtVqhT9+/ff5HqKcvHFF8fjjz+esxz5u+++G++++25ccsklseOOO8aBBx4Y++yzTxx44IHRsWPHEgUYkiSJuXPnZrV16NCh1DXXqVMnWrVqlbXEfVEX4opSFs/x1qhOnTo5oZzimD59ek7bRx99VBYlFVj/NVDU3EuXLt0sc5d0i5niuP322+ONN97ICimtXbs2hgwZEkOGDInKlSvHnnvuGfvvv3906dIlDj744DJbTr9KlSo5S/wXV7t27aJatWqxatWqgrZZs2ZttN9bb70V/fv3zwk1ldbGlt3/7rvvso7btm0bdevWLZO511fYe+Drr7+Or7/+uszmKOo9ULNmzbj77rvjpJNOytqOZuHChXHPPffEPffcE7Vq1Yr9998/unbtGl27do2DDjoottlmmzKrDQAAypItCQAAgNSoVatW9OzZM37/+9/HxIkT44UXXojddtut0HNvvPHGWLZs2RaucNOUZjuCDfUt7NukRV1AKWvr75G+IWX1jeBzzz0363j+/PnxzDPPFHn+0qVLC91De/2QRVmqXr16PPfcc9G7d+8iz/niiy/ikUceicsuuyw6d+4cjRs3jrPOOiuGDx+e9S3/oixatCjnvE39tvf6F8pKunT35vzWd3kq7f3aEu/Dwt6Dy5cvL9F7syznLgs77LBDvPLKK0Xuc7927dp4//3346677oqzzz472rZtG9tvv31cddVVJV4VY31169bdpJVH1n+tbOzb/iNGjIjDDjuszMICERGrV6/e4O3rv6835wXy8noPrNO3b98YNGhQ1K5du9Dbly1bFq+++mrcdNNNcdxxx0Xjxo1jn332iVtvvbVMQw0AAFAWBAYAAIDUOvzww2PMmDFx5JFH5tw2a9asePbZZ8uhqtIr6sJFafsuXrw4p62sVxIoC1WqlM3ieSeffHLOt73XX0Hgh5588smc5dTXDx1sDo0bN46XXnopnnjiiWItcT5v3rwYNGhQ9OnTJ3bdddd46qmnNnh+Yc/7pry2Cutf2BwbUlbP8damtPervN6HW+P7v6T23HPPmDBhQtx6663RqlWrjZ6fl5cXd9xxR+y9997Ru3fvGDduXKnm3ZLvofnz58cpp5ySE3qrVKlSHHbYYXHzzTfHCy+8EJ988knMmTMnlixZEmvXro0kSbJ+unfvXqIaFy1alHVcp06dEvUvia3htXj66afHpEmT4ic/+clGV1LIz8+PDz74IK699trYYYcd4vzzz4/Zs2dvoUoBAGDDBAYAAIBUq1mzZvznP/+Jxo0b59z26quvlkNFpbd06dIy7VvYBZCaNWvmtJ1yyik5F5o29adt27alvi+lVbdu3TjppJOy2l566aWYMWNGoeevHyZo0KBBnHDCCZutvh/KZDJx8sknx/vvvx+ffvpp3H777XHMMcdEo0aNNthv0qRJcdJJJ8Ull1yStZT2DxX2vG/Ka6uw/ptrmfK0KOx9uHz58jJ9D95www3Fmrdr165l/v7v0aPHZnjU/r9atWrFNddcE1OnTo3XX389fv3rX8fBBx9c6P37oVdffTW6du0ajz76aInn3JLvoZtuuinnYvQ+++wTn332Wbz44otx7bXXxuGHHx677rprNGrUKGrXrh2VKuX+E2FJV3pYfxWE9QNVZamw5+ree+8t09dhXl7eRuto0aJF/P3vf4/vvvsuhgwZEpdddll06tQpKleuXGSf1atXx0MPPRQdO3bc5JUrAACgLAgMAAAAqVevXr0455xzctonTZq0Rebf2DLPxbWx/aVL2rewZegLC1aUdHn5rdn6KwTk5+fHv/71r5zzvvrqqxg1alRW26mnnho1atTYrPUVpkOHDnHVVVfFs88+G3PmzInJkyfHQw89FGeddVahz1dExD/+8Y+46aabCr2tXr16ORcPN7b8+cas379hw4abNF7aldf7sEGDBjmrIlTk938mk4mDDz44/vCHP8Trr78eixYtijFjxsQdd9wRRx11VKEXpVetWhXnnXdevPHGGyWaa/HixUWGdIpj/W/vb2ibkP/85z9Zx61atYpXXnkldtpppxLNWdLndv3A0uZcBWBr+1tUs2bNOOGEE+Kuu+6KcePGxYIFC+Lll1+O3/72t9G1a9dCAxkzZ86MPn36bLGtfgAAoCgCAwAAABGx77775rTNmTOnyPOrVq2a01baC/9ldbFg8uTJpe67fjgik8kUekGmSZMmOftwT506tdTzbm0OPvjgaNeuXVbbI488knPeI488knPxb0tsR1AcO+20U5x77rnxz3/+M2bOnBnDhg2LLl265Jx30003FfoaL+y5nzhxYqnrWbp0aUybNi2rraggA8Wz7bbb5rRtifdhJpOJJk2aZLXNmDEj1qxZs9nn3hKqVKkS++yzT/zsZz+L5557LmbNmhX/+Mc/onnz5lnnrV27Nn7xi1+UaOw1a9bEV199Vaq6pkyZEqtWrcpqa9q0aaHnTpw4MaZPn57V9tOf/jTq169fojlXr16dM87GbLfddlnHeXl5Jd5+pLjK6z1QXHXq1InevXvHDTfcEO+++25MnTo1fvnLX+aEymbOnBm33XZbOVUJAADfExgAAACIKPRiyob2F19/6eWI3G+AFsfq1atzLqaW1gcffFCqfvn5+Tn7cnfo0CFq1aqVc26NGjWiU6dOWW2TJ0+O7777rlRzb20ymUzOahOTJk2Kd955p+A4SZL45z//mXXObrvtVuhF+fJWuXLlOProo+Ptt9+OI488Muu2ZcuWxQsvvFBov7322ivrePr06aV+jj/44IPIz8/Patt7771LNRbf69q1a05bSb/xXlZzL1u2rNSfPVu7OnXqxEUXXRQffvhhtGrVKuu29957L77++usSjVfax6mwfkW9hwqr6aCDDirxnGPHjo0VK1aUqM/++++fdZyfn5/12VmW9tlnn5xv7W+p90BptGzZMm666aZ46aWXcrYreOqpp8qpKgAA+J7AAAAAQEShF0ML+wbjOnXq1Mn5R//SfHv0vffeK/E+0UUZMWJEqbYleOWVV3LCDvvtt1+R5x966KE5bUOGDCnxvFurc845J+dC1MCBAwt+f+2113K+yTpgwIAtUltpValSJW6++eac9vHjxxd6frdu3XLa/vvf/5Zq7ieffLJY41N85fke/LG//wuz7bbbxlVXXZXT/vHHH5donKeffrpU8xf2+Bb1GV3YqiGl2QLkiSeeKHGfHj165LQVtqVLWWjYsGFOaOKzzz6LTz/9dLPMV1YOOuigOOaYY7Lavvzyy1i2bFk5VQQAAAIDAAAAEfH9ReD17bDDDkWen8lkYuedd85qe++990o87/3331/iPkVZsWJFDBo0qMT9HnjggZy29b+N/kPHHXdcTtvtt9/+o1mWvFWrVnHIIYdktQ0ePLgg2LH+FgVVqlSJs846a0uVV2rt27fPaSsqYHL44YfntN1///05KwVszMKFC+Pxxx/PaqtatWr07NmzROOQbdddd83Zj/69994r9HOsrPXp0ycnLPWPf/wjFixYsNnnLk8lef8U5emnn47Zs2eXqM/s2bPjmWeeyWpr2LBhodvoRETUrl07p21D2+sUZsGCBfHwww+XqE9ERPfu3WObbbbJahs8ePBm2yqgsL9Ft9xyy2aZqyyVxWsJAADKksAAAABQIQ0bNiymTJlSJmN9+eWXMXjw4Jz2Pn36bLDf+t9ufP/992Py5MnFnveDDz6If//738U+vzhuuOGGmD9/frHPf+ONN3K+Ob7ddtsVeiFmnQMOOCDnm6RfffVVod/ArajWXzFg4cKFMWTIkFi0aFHOt3379OlT5H7iW5Nvv/02p239/ejX2XfffWOfffbJahs/fnz84x//KNGc1113XcybNy+r7eSTT64Qj9fW7rrrrstpO//883Me77LWpk2bnIDMokWLYsCAAZEkyWaduzyV5P1TlOXLl8e1115boj7XXnttzrfPBwwYENWrVy/0/GbNmuW0vfTSSyWa87LLLitVAKRWrVpx+eWXZ7WtWrUqzjrrrBKHjYrjsssuiwYNGmS1DRo0KIYOHVrmc5Wl9V9LmUwmGjduXE7VAACAwAAAAFBBPffcc7HzzjvHgAED4rPPPiv1ON98802ccMIJORdkmjRpUujS2z9U2Lfwr7766mLNO23atDj55JNj9erVxS+2GObMmRP9+vWLlStXbvTcvLy8OOOMM3LaL7nkkqhateoG+954442RyWSy2v72t7/Fb3/721JfNJwwYUKcffbZJQo8bC4nnHBCzoWogQMHxhNPPFHoxbst4e23346//vWvsXjx4lL1/+tf/5rT1qlTpyLP//nPf57TdvXVVxd7n/CHH3447rnnnqy2TCYTP/vZz4rVnw0788wzc76pPGXKlDjqqKPim2++KdWYixYtittuu22jK5Vcf/31OResn3766bjwwguL9dlTmLy8vLj88stjwoQJpeq/MY888kg89dRTsXbt2hL3Xb16dc5ruVKlSrH77ruXeKyHH344HnzwwWKd+8ADD+R8079q1apxySWXFNlnzz33jDp16mS1/fWvf43p06cXa87f//738dhjjxXr3MJcccUVOZ+do0aNitNOO61Ur40NrU5Qv379+MUvfpHVliRJnH322TmrMpTE888/v8HH+IYbbojRo0eXauyvv/46J9DQoUOHjf7NBQCAzUlgAAAAqLDWrFkTjzzySHTo0CH222+/uPvuuwv9Fmhhli1bFv/4xz9izz33LHQf6j/96U9Ro0aNDY7Rt2/fnOWXhw0bFhdccMEG9yMeMmRI7LfffvHVV19FRGx0nuJaN86rr74ahxxyyAZXO3jxxRfj4IMPzrmI1L59+7jmmms2OtcBBxwQv/3tb3Paf//730evXr1i1KhRxap57ty58eCDD8ahhx4aHTt2jH/961+luqBX1mrUqBGnnXZaVtuIESPiz3/+c1bbtttuu9GVKMrKrFmz4sorr4yWLVvGxRdfHC+99FKxAidLliyJ//u//4s777wzq71+/fpx9NFHF9nvtNNOi6OOOiqrbfny5XHUUUfF3XffXeQ3hlesWBG//OUv44ILLsgJj1x55ZU5K3NQOpUrV44nn3wy6tatm9U+evTo2HPPPeOee+6JFStWbHScNWvWxCuvvBIXXnhhtG7dOv7v//4vZs6cucE+22+/fdx333057Q8++GDst99+8b///a9YwaHFixfH448/Hscff3zsuOOOcffddxer5tIYN25cnHTSSbHjjjvGr3/96/jwww+L1W/q1Klx7LHHxpgxY7Lae/fuHdttt12x569evXpByOqiiy6K6667rsgL6CtXrozrrrsuLr744pzbrrvuug1ul1O1atU4/vjjs9rmz58fhxxySIwfP77Ift98802cfvrpWZ/r9erV29BdKlTDhg3j0UcfzQmUDR48OPbff/945ZVXNjrG/Pnz46GHHopOnToV+nfmh6655pro3bt3VtuSJUvihBNOiAsvvLDg7+zGfP7553HTTTfF7rvvHkcdddQG/4Y9/fTTsd9++8V+++0Xf/3rX2PatGnFmuPtt9+OXr16xaJFi7LazzzzzGL1BwCAzaVKeRcAAABQFkaPHh2jR4+Oyy+/PNq2bRtdu3aNXXfdNRo3bhyNGjWKTCYTixYtiqlTp8ZHH30Ur732WixdurTQsU4++eTo37//RuesUaNG/Pa3v40rr7wyq/3BBx+M5557Lk466aTo3Llz1K1bN+bPnx+fffZZDB8+PCZNmlRw7qmnnhrffvttvP7665t0/yMifvvb38avf/3rWLt2bbz11lux2267Re/eveOQQw6JFi1axKpVqyIvLy+GDRsWH3zwQU7/6tWrx8CBA4sdYLj++uvjs88+i//85z9Z7SNHjoyDDz44dt555+jRo0fstttu0bBhw6hevXosWLAg5s+fH59++ml88MEHMXHixK0iIFCYAQMGxL333ltwnJ+fn/XcRXx/oadKlS37f60XLVoU9913X9x3331Rt27d2GuvvWLPPfeM7bffPho0aBC1a9eOFStWxPTp0+PDDz+MF198sdD9sW+//faoWbPmBucaOHBgdO7cOSuIs3Tp0rj88svjT3/6U/Tt2zc6dOgQDRo0iDlz5sS4ceNi6NChhe6Zvtdee8XNN9+86Q8ABXbfffd47LHHom/fvrFmzZqC9lmzZsWll14a1113XXTv3j26du0aTZs2jfr168fSpUtjwYIFMW3atPjggw9i7NixORcwi6N///4xceLEuPXWW7Pax40bF8ccc0y0bt06evbsGZ06dYpGjRpFrVq1YuHChbFgwYKYPHlyfPDBB/Hxxx/HqlWrNvlxKIm8vLz44x//GH/84x+jWbNmsddee0Xnzp2jefPm0aBBg6hWrVosWbIk8vLy4u23346RI0fmBHOqV6+eEx7amO222y769OkT99xzT+Tn58dNN90UDzzwQJx44onRsWPHaNSoUcydOzfGjx8fQ4YMiVmzZuWMsffee8evfvWrjc71m9/8Jp544omsuidPnhx77rlnHHHEEdGrV69o2bJlrFmzJr799tsYOXJkvPLKK1kBhnPPPTe+/PLLUv1tOvbYY+O6666LG2+8Mat97Nixceihh8ZOO+0Uhx12WOyyyy7RpEmTSJKk4HXx4YcfxjvvvFNQ+5577rnBuapUqRKDBw+Obt26Za02lCRJwQoN++yzTxx88MGx/fbbR8OGDSM/Pz8WLFgQs2fPjvHjx8cHH3wQeXl5Jb6f6/6748orr4xddtklOnfuHHvssUc0adKkYJWFdfdrxIgRhYZUdtppp7jiiitKPDcAAJSpBAAAoAK66KKLkogo85/+/fsna9asKXYda9euTQ455JBSzXXwwQcny5YtS7p3757V3r17943OO2LEiJzxRowYkdx9992lqqVatWrJsGHDSvw8rF27NrnuuuuSTCZTZs/B7NmzNzhnaR6v0tp99903WOuECRNKPXZRz2FRhg4dWmaP8c9+9rNi1/nFF18kO+644ybNd+CBBybz5s0r9pxb8jkuroEDB+bcrylTppRojP79+2f1b9OmTZnU9vrrryfbbbddmb0+/vSnPxV77rvvvjupVq1amc09ZsyYMnlM1nfFFVeUSX3Vq1dPBg8evNH5CnuuV6xYkRx44IGlmrdjx47JnDlzin1///GPf5T6Pvbq1StZsWLFJr8P77jjjqRSpUqb9Hj379+/WHPNmzcv6dOnT5m9Dnfbbbci5+rUqVOZzNGyZctN+hsCAABlxZYEAABAhXTWWWfFGWeckbNXcmm1a9cunnnmmXjkkUeicuXKxe5XqVKlGDZs2AaXdi/MmWeeGS+++OJGv+FdUpdeemk88MADJdrmoFWrVvHcc8+V+D5EfH//b7zxxhg+fHh06tSpxP1/qH79+nH++efn7L9dngYMGFDkbfvuu2/stttuW6yW+vXrb/L2FU2aNImHHnoo7rjjjmL32WGHHeLtt9+Ok08+OWeZ8Y2pWrVqXH755fHyyy/nbN9B2Tn44IPjww8/jDPPPLNEn1/ry2Qy0bNnzzjooIOK3efSSy+NUaNGxYEHHljqeSMiatasGaeeemq0bt16k8YpStOmTUv8+l3f7rvvHq+99lr069evVP2rV68eL7zwQhx33HEl6nfsscfGq6++Go0aNSp2n4suuijuueeeqFatWonmOvfcc2P48OFRvXr1EvUrzM9+9rN48cUXY4899ij1GNtuu22xzttmm21i2LBhceeddxa7T1HatGmzwc/+kmxFUZRjjjkm3n333S36NwQAAIoiMAAAAFRIBxxwQAwaNChmzZoVr776alx//fXRq1evEl1s3nbbbeOMM86I5557LiZNmhTHHntsqWqpWbNmDBs2LJ544ono2LFjkedlMpk48MADY/jw4fGvf/1rky/+FuX888+P8ePHx1lnnbXBQEKrVq3iV7/6VXz66ac5e0CX1BFHHBHjxo2LYcOGRd++faNhw4bF6teuXbu44IIL4r///W98++23JQ47bG5nnnlmVK1atdDbNnRBaXPo2bNnzJ07N55++un4yU9+Ep07dy72xeG99947br/99vj888/j3HPPLfHcTZo0iSeeeCLee++9OOWUUzZ68b9Zs2ZxwQUXxMSJE+Nvf/vbVvWc/lg1a9Ys/vWvf8Xnn38eV155ZXTo0KFY/erWrRtHH3103HnnnTFlypR47bXXomvXriWae999941Ro0bFqFGj4owzzojmzZsXq1/z5s3jrLPOin/+85/x7bffxr///e9o2rRpieYurl/96lfx7bffxkMPPRRnnHFGbL/99sXqV7Vq1TjyyCPjsccei3HjxkW3bt02qY7atWvH008/HU8++WR06dKlyPPW/b146qmn4plnnonGjRuXeK5LLrkkPvzwwzjllFOK/ByLiKhWrVocc8wx8cYbb8RDDz1UJmGBdXr37h0fffRR/Oc//4kjjjgiatWqtdE+O++8c/z0pz+NDz/8MGfLiw3JZDJxxRVXRF5eXtxzzz3Rs2fPYn32VKpUKfbaa6+45pprYuTIkTFlypS46qqrijz/hRdeiE8//TRuv/32OProo4v93NSvXz/69+8fr7/+ejz77LPRokWLYt83AADYnDJJkiTlXQQAAEBZSZIkZsyYEZ9//nlMmzYtFi1aFIsXL45MJhP16tWLunXrRrNmzaJjx46b/C3Eonz99dfxzjvvxKxZs2LBggVRq1at2H777WO//faLZs2alckcI0eOjJ49e2a1jRgxInr06JHVtnz58hg9enR89tlnMW/evKhevXo0a9Ysdtppp9hnn302+Ru3RUmSJD7++OP48ssvY+7cuTF37tzIz8+PunXrRoMGDWKHHXaIDh06lNkKEWm1dOnS+Pzzz+Orr76KmTNnxuLFi2P16tVRp06dqF+/fuy4447RsWPHqF+/fpnOu3bt2nj//fcjLy8vZs+eHYsWLYoGDRpE06ZNY+edd95gcIYt57vvvosPP/ww5syZE3Pnzo0lS5ZE7dq1o169etGiRYto3759tGnTZrN8DkyePDkmTpxY8P5fvXp11K1bN+rVqxfbb799tG/ffrOFA4pr7ty5Be+fOXPmxJIlSyLi+xBFw4YNo0OHDrHbbruV6gL6OeecE48++mjBcZs2bSIvLy/nvOnTp8eYMWMiLy8vli5dGg0bNoxmzZrFvvvuW6YXlJcuXRpvv/12fPXVVzFv3rzIZDLRsGHD2GmnnaJLly5bbGWXlStXxpgxY2L69Okxe/bsWLhwYdSsWTPq168f7dq1i1133bVMvsH/w/nef//9mDFjRsydOzfmz58fVapUibp160bjxo1j5513jl122WWTQ03Tpk2LL7/8MvLy8mLBggWxdOnSqFq1atSrVy+aNm0ae+yxR+y4445RqZLvbgEAsPURGAAAAKiAihsYAGDLK25gAAAAoLyJtQIAAAAAAABACgkMAAAAAAAAAEAKCQwAAAAAAAAAQAoJDAAAAAAAAABACgkMAAAAAAAAAEAKCQwAAAAAAAAAQAoJDAAAAAAAAABACgkMAAAAAAAAAEAKZZIkScq7CAAAAAAAAABgy7LCAAAAAAAAAACkkMAAAAAAAAAAAKSQwAAAAAAAAAAApJDAAAAAAAAAAACkkMAAAAAAAAAAAKSQwAAAAAAAAAAApJDAAAAAAAAAAACkkMAAAAAAAAAAAKSQwAAAAAAAAAAApJDAAAAAAAAAAACkkMAAAAAAAAAAAKRQlfIuADZmwYIF8frrrxcct2rVKqpXr16OFQEAAAAAAACUjZUrV8bXX39dcNy9e/do0KDBFplbYICt3uuvvx7HH398eZcBAAAAAAAAsNk9/fTTcdxxx22RuWxJAAAAAAAAAAApJDAAAAAAAAAAAClkSwK2eq1atco6fvrpp2PHHXcsp2oAAAAAAAAAys4XX3yRtUX7+tdHNyeBAbZ61atXzzrecccdY7fddiunagAAAAAAAAA2n/Wvj25OtiQAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBSqUt4FAOUjc9lj5V0CABGR3H1GeZcAAAAAAEBKWWEAAAAAAAAAAFJIYAAAAAAAAAAAUkhgAAAAAAAAAABSSGAAAAAAAAAAAFJIYAAAAAAAAAAAUkhgAAAAAAAAAABSSGAAAAAAAAAAAFJIYAAAAAAAAAAAUkhgAAAAAAAAAABSSGAAAAAAAAAAAFJIYAAAAAAAAAAAUkhgAAAAAAAAAABSSGAAAAAAAAAAAFJIYAAAAAAAAAAAUkhgAAAAAAAAAABSSGAAAAAAAAAAAFJIYAAAAAAAAAAAUkhgAAAAAAAAAABSSGAAAAAAAAAAAFJIYAAAAAAAAAAAUkhgAAAAAAAAAABSSGAAAAAAAAAAAFJIYAAAAAAAAAAAUkhgAAAAAAAAAABSSGAAAAAAAAAAAFJIYAAAAAAAAAAAUkhgAAAAAAAAAABSSGAAAAAAAAAAAFJIYAAAAAAAAAAAUkhgAAAAAAAAAABSSGAAAAAAAAAAAFJIYAAAAAAAAAAAUkhgAAAAAAAAAABSSGAAAAAAAAAAAFJIYAAAAAAAAAAAUkhgAAAAAAAAAABSSGAAAAAAAAAAAFJIYAAAAAAAAAAAUkhgAAAAAAAAAABSSGAAAAAAAAAAAFJIYAAAAAAAAAAAUkhgAAAAAAAAAABSSGAAAAAAAAAAAFJIYAAAAAAAAAAAUkhgAAAAAAAAAABSSGAAAAAAAAAAAFJIYAAAAAAAAAAAUkhgAAAAAAAAAABSSGAAAAAAAAAAAFJIYAAAAAAAAAAAUkhgAAAAAAAAAABSSGAAAAAAAAAAAFJIYAAAAAAAAAAAUkhgAAAAAAAAAABSSGAAAAAAAAAAAFJIYAAAAAAAAAAAUkhgAAAAAAAAAABSSGAAAAAAAAAAAFJIYAAAAAAAAAAAUkhgAAAAAAAAAABSSGAAAAAAAAAAAFJIYAAAAAAAAAAAUkhgAAAAAAAAAABSSGAAAAAAAAAAAFJIYAAAAAAAAAAAUkhgAAAAAAAAAABSSGAAAAAAAAAAAFJIYAAAAAAAAAAAUkhgAAAAAAAAAABSSGAAAAAAAAAAAFJIYAAAAAAAAAAAUkhgAAAAAAAAAABSSGAAAAAAAAAAAFJIYAAAAAAAAAAAUkhgAAAAAAAAAABSSGAAAAAAAAAAAFJIYAAAAAAAAAAAUkhgAAAAAAAAAABSSGAAAAAAAAAAAFJIYAAAAAAAAAAAUkhgAAAAAAAAAABSSGAAAAAAAAAAAFJIYAAAAAAAAAAAUkhgAAAAAAAAAABSSGAAAAAAAAAAAFJIYAAAAAAAAAAAUkhgAAAAAAAAAABSSGAAAAAAAAAAAFJIYAAAAAAAAAAAUkhgAAAAAAAAAABSSGAAAAAAAAAAAFJIYAAAAAAAAAAAUkhgAAAAAAAAAABSSGAAAAAAAAAAAFJIYAAAAAAAAAAAUkhgAAAAAAAAAABSSGAAAAAAAAAAAFJIYAAAAAAAAAAAUkhgAAAAAAAAAABSqEp5F5B2SZJEXl5efPzxxzF9+vRYsGBBVK9ePbbZZpvYaaedokuXLlGjRo0ynXPx4sXx1ltvxeTJk2PRokVRs2bNaNOmTXTr1i2aN29epnMBAAAAAAAAsHUSGCgH8+fPj6effjpeeOGFeO2112LOnDlFnlu1atXo06dPXHnlldG9e/dNmnfKlClx/fXXx+DBg2PVqlU5t2cymejevXv87ne/i4MPPniT5gIAAAAAAABg62ZLgi3s0ksvje222y7OPffcGDx48AbDAhERq1evjqeffjp69OgR/fv3j0WLFpVq3sGDB8fuu+8egwYNKjQsEPH9agcjR46MHj16xLXXXhtJkpRqLgAAAAAAAAC2flYY2MJGjx5d6AX7ypUrR7NmzWLbbbeN1atXx9SpU2PhwoVZ5/zzn/+Mzz77LF599dWoU6dOsed88skn47TTTov8/Pys9iZNmkSrVq1i1qxZMWPGjIKAQJIkceutt8bKlSvjL3/5SynuJQAAAAAAAABbOysMlKMGDRrET37yk3juuedi/vz58fXXX8f7778fH330UcydOzdGjBgRBx10UFaf9957L84555xiz/Hll1/GgAEDssICnTp1itdeey1mzZoVH3zwQXz99dcxceLE6Nu3b1bfO++8M4YMGbJJ9xEAAAAAAACArZPAQDlo27ZtPPjgg/HNN9/E3//+9zjqqKOibt26WedUrlw5evToESNGjIgLL7ww67annnoqRowYUay5fvOb38TSpUsLjrt06RJvvPFG9OzZM+u8XXbZJf773//mzHXNNdfEmjVrSnL3AAAAAAAAAKgABAa2sN/97ncxadKkOO+886JmzZobPb9y5cpxzz33xD777JPV/uCDD2607yeffBJPPPFEwXG1atXi0UcfjXr16hV6fiaTib/+9a+x0047FbR9+eWXMXDgwI3OBQAAAAAAAEDFIjCwhfXp0yeqVatWoj6VK1eOa665JqvtxRdf3Gi/hx9+OGsrglNPPTU6dOiwwT41atSIa6+9NqutOOEEAAAAAAAAACoWgYEK4qCDDso6njt3bixbtmyDfZ599tms4/POO69Yc51yyilRu3btguMxY8bEN998U8xKAQAAAAAAAKgIBAYqiG222SanbeHChUWeP2nSpPjiiy8KjmvXrh3dunUr1lzrn5skSTz33HMlqBYAAAAAAACArZ3AQAUxY8aMnLZGjRoVef64ceOyjvfdd9+oUqVKsec74IADNjgeAAAAAAAAABWbwEAFMWrUqKzjNm3aRLVq1Yo8f+LEiVnHu+66a4nmW//89ccDAAAAAAAAoGITGKggHn744azjo446aoPnT5o0Keu4VatWJZpv/fPXHw8AAAAAAACAiq34a9RTboYPHx5vvPFGVts555yzwT6zZs3KOm7ZsmWJ5mzRokXW8ezZs0vUvyizZs0q8VhffPFFmcwNAAAAAAAAwP8nMLCVmzdvXlx00UVZbccff3zsu+++G+y3ZMmSrOPatWuXaN71z1+9enWsXLkyqlevXqJx1nfPPffE7373u00aAwAAAAAAAIBNZ0uCrVh+fn6ceeaZMX369IK2+vXrx9/+9reN9l0/MFCjRo0SzV2zZs2NjgkAAAAAAABAxSUwsBX7xS9+Ec8//3xW23333RetWrXaaN8VK1ZkHVerVq1Ecxe2ksDy5ctLNAYAAAAAAAAAWy9bEmyl/va3v8Udd9yR1XbNNdfEKaecUqz+668osGrVqhLNv3Llyo2OWRo/+clPol+/fiXq88UXX8Txxx+/yXMDAAAAAAAA8P8JDGyFHn/88bjyyiuz2s4555y45ZZbij1GnTp1so7XX3FgYwpbTWD9MUujadOm0bRp000eBwAAAAAAAIBNY0uCrcz//ve/6N+/fyRJUtDWt2/fePDBByOTyRR7nPUv7i9durREdax/fpUqVcpkhQEAAAAAAAAAtg4CA1uRESNGRL9+/WLNmjUFbYceemj8+9//jsqVK5dorPW/xT99+vQS9Z8xY0bWcZMmTUrUHwAAAAAAAICtm8DAVmL06NFx7LHHZm0d0K1btxg6dGhUq1atxOPtsssuWcfTpk0rUf/1z2/fvn2JawAAAAAAAABg6yUwsBUYP358HHnkkbFkyZKCtj333DOGDx8etWvXLtWY61/g//TTT0vUf+LEiRscDwAAAAAAAICKTWCgnE2aNCkOPfTQmD9/fkFbhw4d4sUXX4z69euXetzOnTtnHY8ZMyZrq4ONeeuttzY4HgAAAAAAAAAVm8BAOZo6dWr07t07Zs2aVdC2/fbbx8svvxxNmjTZpLHbt28fO+ywQ8Hx0qVL4+233y5W36VLl8Y777xTcJzJZOLoo4/epHoAAAAAAAAA2LoIDJSTb7/9Ng455JCYPn16QVuLFi3i1VdfjRYtWpTJHMcee2zW8UMPPVSsfk888UTW9gj77LNPNG/evExqAgAAAAAAAGDrIDBQDubNmxeHHnpofPnllwVtTZo0iZdffjm23377Mpvn3HPPjUwmU3D8n//8JyZOnLjBPitWrIhbbrklq+28884rs5oAAAAAAAAA2DoIDGxhixcvjiOOOCI++eSTgrYGDRrESy+9FB06dCjTuXbfffc4+eSTC45XrVoV/fv3j0WLFhV6fpIkceWVV8bnn39e0NauXbs499xzy7QuAAAAAAAAAMpflfIuIG2OPfbYGDNmTFbbz3/+85gzZ0688sorJRpr7733jm222WaD59x4440xbNiwWLZsWUREjBkzJg4++OC48847o0ePHgXnTZ48OX75y1/GkCFDsvrfcsstUbVq1RLVBQAAAAAAAMDWT2BgCxs5cmRO2/XXX1+qsUaMGJF10b8wO+64Yzz00ENx+umnR5IkERHx0UcfRc+ePaNJkybRunXrmDVrVkyfPr3g9nUuv/zy6NevX6lqAwAAAAAAAGDrJjCQAqeeemokSRLnnXdeLF++vKB99uzZMXv27EL7XH311XHbbbdtqRIBAAAAAAAA2MIqlXcBbBmnnXZaTJgwIU4//fQNbjFw8MEHx8iRI+NPf/pTZDKZLVghAAAAAAAAAFuSFQa2sPWX/d+S2rVrF4899ljce++98eabb8bnn38eixcvjho1akTr1q3jgAMOiBYtWpRbfQAAAAAAAABsOQIDKVSvXr046qijyrsMAAAAAAAAAMqRLQkAAAAAAAAAIIUEBgAAAAAAAAAghQQGAAAAAAAAACCFBAYAAAAAAAAAIIUEBgAAAAAAAAAghQQGAAAAAAAAACCFBAYAAAAAAAAAIIUEBgAAAAAAAAAghQQGAAAAAAAAACCFBAYAAAAAAAAAIIUEBgAAAAAAAAAghQQGAAAAAAAAACCFBAYAAAAAAAAAIIUEBgAAAAAAAAAghQQGAAAAAAAAACCFBAYAAAAAAAAAIIUEBgAAAAAAAAAghQQGAAAAAAAAACCFBAYAAAAAAAAAIIUEBgAAAAAAAAAghQQGAAAAAAAAACCFBAYAAAAAAAAAIIUEBgAAAAAAAAAghQQGAAAAAAAAACCFBAYAAAAAAAAAIIUEBgAAAAAAAAAghQQGAAAAAAAAACCFBAYAAAAAAAAAIIUEBgAAAAAAAAAghQQGAAAAAAAAACCFBAYAAAAAAAAAIIUEBgAAAAAAAAAghQQGAAAAAAAAACCFBAYAAAAAAAAAIIUEBgAAAAAAAAAghQQGAAAAAAAAACCFBAYAAAAAAAAAIIUEBgAAAAAAAAAghQQGAAAAAAAAACCFBAYAAAAAAAAAIIUEBgAAAAAAAAAghQQGAAAAAAAAACCFBAYAAAAAAAAAIIUEBgAAAAAAAAAghQQGAAAAAAAAACCFBAYAAAAAAAAAIIUEBgAAAAAAAAAghQQGAAAAAAAAACCFBAYAAAAAAAAAIIUEBgAAAAAAAAAghQQGAAAAAAAAACCFBAYAAAAAAAAAIIUEBgAAAAAAAAAghQQGAAAAAAAAACCFBAYAAAAAAAAAIIUEBgAAAAAAAAAghQQGAAAAAAAAACCFBAYAAAAAAAAAIIUEBgAAAAAAAAAghQQGAAAAAAAAACCFBAYAAAAAAAAAIIUEBgAAAAAAAAAghQQGAAAAAAAAACCFBAYAAAAAAAAAIIUEBgAAAAAAAAAghQQGAAAAAAAAACCFBAYAAAAAAAAAIIUEBgAAAAAAAAAghQQGAAAAAAAAACCFBAYAAAAAAAAAIIUEBgAAAAAAAAAghQQGAAAAAAAAACCFBAYAAAAAAAAAIIUEBgAAAAAAAAAghQQGAAAAAAAAACCFBAYAAAAAAAAAIIUEBgAAAAAAAAAghQQGAAAAAAAAACCFBAYAAAAAAAAAIIUEBgAAAAAAAAAghQQGAAAAAAAAACCFBAYAAAAAAAAAIIUEBgAAAAAAAAAghQQGAAAAAAAAACCFBAYAAAAAAAAAIIUEBgAAAAAAAAAghQQGAAAAAAAAACCFBAYAAAAAAAAAIIUEBgAAAAAAAAAghQQGAAAAAAAAACCFBAYAAAAAAAAAIIUEBgAAAAAAAAAghQQGAAAAAAAAACCFBAYAAAAAAAAAIIUEBgAAAAAAAAAghQQGAAAAAAAAACCFBAYAAAAAAAAAIIUEBgAAAAAAAAAghQQGAAAAAAAAACCFBAYAAAAAAAAAIIUEBgAAAAAAAAAghQQGAAAAAAAAACCFBAYAAAAAAAAAIIUEBgAAAAAAAAAghQQGAAAAAAAAACCFBAYAAAAAAAAAIIUEBgAAAAAAAAAghQQGAAAAAAAAACCFBAYAAAAAAAAAIIUEBgAAAAAAAAAghQQGAAAAAAAAACCFBAYAAAAAAAAAIIUEBgAAAAAAAAAghQQGAAAAAAAAACCFBAYAAAAAAAAAIIUEBgAAAAAAAAAghQQGAAAAAAAAACCFBAYAAAAAAAAAIIUEBgAAAAAAAAAghQQGAAAAAAAAACCFBAYAAAAAAAAAIIUEBgAAAAAAAAAghQQGAAAAAAAAACCFBAYAAAAAAAAAIIUEBgAAAAAAAAAghQQGAAAAAAAAACCFBAYAAAAAAAAAIIUEBgAAAAAAAAAghQQGAAAAAAAAACCFBAYAAAAAAAAAIIUEBgAAAAAAAAAghQQGAAAAAAAAACCFBAYAAAAAAAAAIIUEBgAAAAAAAAAghQQGAAAAAAAAACCFBAYAAAAAAAAAIIUEBgAAAAAAAAAghQQGAAAAAAAAACCFBAYAAAAAAAAAIIUEBgAAAAAAAAAghQQGAAAAAAAAACCFBAYAAAAAAAAAIIUEBgAAAAAAAAAghQQGAAAAAAAAACCFBAYAAAAAAAAAIIUEBgAAAAAAAAAghQQGAAAAAAAAACCFBAYAAAAAAAAAIIUEBgAAAAAAAAAghQQGAAAAAAAAACCFBAYAAAAAAAAAIIUEBgAAAAAAAAAghQQGAAAAAAAAACCFBAYAAAAAAAAAIIUEBgAAAAAAAAAghQQGAAAAAAAAACCFBAYAAAAAAAAAIIUEBgAAAAAAAAAghQQGAAAAAAAAACCFqpR3AWk3Y8aMeO+992L06NHx3nvvxfvvvx+LFy8uuL1NmzaRl5dXqrEzmcwm1TZlypRo27btJo0BAAAAAAAAwNZJYKAcvPXWW/HnP/85Ro8eHd988015lwMAAAAAAABACgkMlIMxY8bE0KFDy7sMAAAAAAAAAFJMYGArU6dOnViyZEmZj9uxY8f485//XKI+2223XZnXAQAAAAAAAMDWQWCgHNWtWzf23nvv6NKlS+y7777RpUuXmDJlSvTs2bPM59pmm22id+/eZT4uAAAAAAAAABWTwEA5OOaYY+Kwww6L9u3bR6VKlbJumzJlSjlVBQAAAAAAAECaCAyUgx122KG8SwAAAAAAAAAg5Spt/BQAAAAAAAAA4MdGYAAAAAAAAAAAUkhgAAAAAAAAAABSqEp5F8CW9e2338Y333wTS5cujW222SYaN24czZo1K++yAAAAAAAAANjCBAZS4uOPP4527drFlClTcm7bbrvtonv37nHOOefEEUccsVnrmDVrVsyePbtEfb744ovNVA0AAAAAAABAegkMpMS8efNi3rx5hd42c+bMeOKJJ+KJJ56IPffcMx599NHYY489Nksd99xzT/zud7/bLGMDAAAAAAAAUHyVyrsAti5jx46Nrl27xpNPPlnepQAAAAAAAACwGQkM/Mg1btw4zjnnnBg0aFCMHz8+5s2bF6tXr4758+fHRx99FHfffXd06tQpq8/y5cvjzDPPjDfeeKOcqgYAAAAAAABgc7MlwY/YoEGDol+/flGtWrWc2xo0aBANGjSIjh07xqWXXhr33XdfXHHFFbFy5cqIiFi1alWcfvrp8cUXX0SNGjXKrKaf/OQn0a9fvxL1+eKLL+L4448vsxoAAAAAAAAAEBj4UTvjjDOKfe5FF10UTZo0iX79+kV+fn5ERMyYMSP+/ve/x1VXXVVmNTVt2jSaNm1aZuMBAAAAAAAAUDq2JKBA375946yzzspq+9e//lVO1QAAAAAAAACwOQkMkGX91QTGjx8f3333XTlVAwAAAAAAAMDmIjBAlj322CNry4AkSWLy5MnlWBEAAAAAAAAAm4PAADlatmyZdTx79uxyqgQAAAAAAACAzUVggBxVq1bNOl69enU5VQIAAAAAAADA5iIwQI6ZM2dmHTdp0qScKgEAAAAAAABgcxEYIMv06dNj6tSpWW2tWrUqp2oAAAAAAAAA2FwEBsjy0EMPZR23atUqdtppp3KqBgAAAAAAAIDNRWCAAhMnTow///nPWW3HH398+RQDAAAAAAAAwGZVoQIDp512WowcObK8y9jqjRs3Lv7yl7/EsmXLStTniCOOiMWLFxe01axZM6699trNUSIAAAAAAAAA5axKeRdQEk888UQMHjw42rVrFxdccEGcc8450bRp0/Iuq1TeeuutWL58eU77Rx99lHW8YsWKeOWVVwodo3nz5rHrrrvmtC9YsCB+/vOfxx//+Mfo27dvnHDCCdGlS5do3Lhx1nlJksSECRPigQceiPvvvz9WrlyZdfvNN98czZs3L+ldAwAAAAAAAKACyCRJkpR3EcVVqVKlyGQykSRJZDKZqFKlShxzzDFx/vnnxxFHHFHe5ZVI27ZtY+rUqZs0Rv/+/eORRx7JaR85cmT07Nkzp33bbbeNxo0bR926dWPJkiUxY8aMmD9/fqFjX3XVVXH77bdvUn1l5ZNPPondd9+94HjChAmx2267lWNFPw6Zyx4r7xIAiIjk7jPKuwQAAAAAAMpReV4PrVArDKyzLjSwevXqGDp0aAwdOjRatWoV5513XgwYMCBatmxZ3iVulb777rv47rvvNnhOvXr14p577okzznDxAgAAAAAAAODHrFJ5F1ASTz/9dPTp0ycqVfq+7EwmExHfL60/bdq0uOGGG2L77bePo48+Op599tnIz88vz3LLzR577BG33nprHHHEEdGwYcNi9Wnfvn3cdtttkZeXJywAAAAAAAAAkAIVakuCdb755pt46KGHYuDAgZGXlxcR/3/VgXW/R0Rst912MWDAgDj//POjbdu25VRt+Zs6dWp8/vnnMW3atJg/f34sX748atSoEdtss000a9YsunbtGo0aNSrvMotkS4LNw5YEAFsHWxIAAAAAAKRbeV4PrZCBgR96+eWX4/77749hw4bFqlWrslYdiPg+PJDJZKJXr15x4YUXxvHHHx9VqlTInRhSS2Bg8xAYANg6CAwAAAAAAKRbeV4PrVBbEhTm0EMPjSeffDKmT58et912W+y88845Kw3k5+fHq6++Gqecckq0aNEirrnmmpg0aVJ5lg0AAAAAAAAA5arCBwbWady4cVx99dUxceLEeOONN+LMM8+MGjVqRJIkWasOzJ49O/785z/HrrvuGt27d4/HHnssVq5cWc7VAwAAAAAAAMCW9aMJDPzQgQceGP/85z/jm2++ibvuuis6duyYtepAkiSRJEm8+eabcfbZZ0fz5s3jiiuuiI8//ricKwcAAAAAAACALeNHGRhYp379+nHppZfG2LFjY/To0XHBBRdEnTp1IpPJZAUH5s+fH3fffXd07tw5unXrFo8//nisXr26vMsHAAAAAAAAgM3mRx0Y+KEuXbrEz3/+8zjttNOyVhtY9xPx/ZYFo0ePjrPOOit22GGHuP/++8uzZAAAAAAAAADYbH70gYGVK1fGoEGDonv37rHrrrvGAw88UBAQiIiCVQbWhQjWtU2fPj0uueSSOOCAA+Lbb78tj9IBAAAAAAAAYLP50QYGPv744/jpT38azZs3j/79+8ebb75ZEApYFxCoXbt2XHDBBfHOO+/EQw89FPvvv3/W6gNJksQ777wTPXv2jGXLlpXn3QEAAAAAAACAMvWjCgwsXbo0Hnzwwdhvv/2ic+fO8fe//z3mz5+fs3pAp06d4p577olvvvkm7rvvvujatWsMGDAg3nrrrfjoo4/i9NNPj4goWIng888/j7vuuqtc7hMAAAAAAAAAbA4/isDAmDFj4sILL4xmzZrFRRddFGPGjMlaKSAiokaNGtG/f/945513YuzYsXHxxRdHnTp1csbaY489YtCgQfHKK69E9erVC1YaeOqpp7bofQIAAAAAAACAzalKeRdQWgsXLoxBgwbFAw88EB9//HFERE5IIEmS6NChQ1x00UXRv3//qF+/frHH79mzZ1xwwQUFKwtMmjSpjO8BAAAAAAAAAJSfChcYePPNN+OBBx6I//73v7FixYqskMC61QCqVasWJ554Ylx00UVx0EEHlXquAw88sCAwsGTJkjKpHwAAAAAAAAC2BhUqMNChQ4eYPHlyRGSvJpAkSSRJEjvttFNceOGFcc4550SjRo02eb6GDRsWzAEAAAAAAAAAPyYVKjAwadKkgov364ICVapUieOOOy4uuuiiOOSQQzbLvEmSCA0AAAAAAAAA8KNSoQID6yRJEm3bto0LLrggzj333Nh22203yzx77713jBgxYrOMDQAAAAAAAADlqUIFBipXrhx9+vSJiy++OA4//PDN/q3/Bg0aRPfu3TfrHAAAAAAAAABQHipUYCAvLy9atGhR3mUAAAAAAAAAQIVXqbwLKAlhAQAAAAAAAAAoGxUqMAAAAAAAAAAAlA2BAQAAAAAAAABIoQoVGBg/fny0a9eu4Of1118v1TgjR44sGGOHHXaIyZMnl3GlAAAAAAAAALB1q1CBgXvvvTfy8vIiLy8vatWqFd27dy/VOD169Ijq1asXjHXfffeVcaUAAAAAAAAAsHWrUIGBZ555JiIiMplMnHnmmZs01tlnnx0REUmSxNChQze5NgAAAAAAAACoSCpMYGDixIkxc+bMguPjjjtuk8b7Yf+pU6fGlClTNmk8AAAAAAAAAKhIKkxg4NNPPy34vU6dOtGhQ4dNGq9Dhw5Rp06dguMJEyZs0ngAAAAAAAAAUJFUmMDAjBkzIuL77QhatWq1yeNlMplo3bp1wfG0adM2eUwAAAAAAAAAqCgqTGBgyZIlBb/Xq1evTMasW7duwe+LFy8ukzEBAAAAAAAAoCKoMIGBH17cnz9/fpmMuWDBgoLfq1WrViZjAgAAAAAAAEBFUGECA40bN46IiCRJ4uuvv47Vq1dv0nirVq2Kr7/+uuC4SZMmmzQeAAAAAAAAAFQkFSYwsMMOOxT8vnz58nj99dc3abzXX389li1bVnDcpk2bTRoPAAAAAAAAACqSChMY2GeffaJ+/fqRyWQiIuLmm2/epPFuueWWgt9r164d+++//yaNBwAAAAAAAAAVSYUJDFSqVCmOOuqoSJIkkiSJkSNHxl/+8pdSjXXHHXfEiBEjIpPJRCaTicMPPzyqVq1axhUDAAAAAAAAwNarwgQGIiKuu+66qFSpUmQymUiSJH7xi1/E9ddfH2vXri1W/7Vr18ZvfvObuOaaawrGyGQy8Zvf/GYzVw4AAAAAAAAAW5cKFRjYdddd48ILLyy40J+fnx9//OMfo3379vGXv/wlPvvss0L7ffbZZ3HHHXdE+/bt46abbor8/PyIiMhkMnHeeedFx44dt+TdAAAAAAAAAIByV6W8Cyipv/3tb/HJJ5/EqFGjClYJ+PLLL+Pqq6+Oq6++OmrXrh2NGzeOOnXqxJIlS2LOnDmxdOnSiIhIkiQioqBfjx494u9//3t53h0AAAAAAAAAKBcVaoWBiIgqVarEsGHD4vjjjy9YaWBdACBJkliyZEnk5eXFhAkTIi8vL5YsWVJw2w/PPemkk+KZZ56JKlUqXGYCAAAAAAAAADZZhQsMRETUq1cvhgwZEvfee2+0atUqa+WAon4ivl9hoE2bNvHggw/G4MGDo27duuV5NwAAAAAAAACg3FTor9dfdNFFcf7558eQIUPipZdeilGjRsVXX30Va9asKTinSpUqseOOO8ZBBx0URxxxRBx33HFRqVKFzEkAAAAAAAAAQJmp0IGBiIjKlStHv379ol+/fgVtixcvjsWLF0fdunWtIgAAAAAAAAAAhajwgYHCCAoAAAAAAAAAwIZZmx8AAAAAAAAAUkhgAAAAAAAAAABSSGAAAAAAAAAAAFKoSnkXUFZWr14dCxcujOXLl0eSJCXu37p1681QFQAAAAAAAABsnSpsYGD+/PkxaNCgeP755+PDDz+M2bNnl3qsTCYTa9asKcPqAAAAAAAAAGDrViEDA3feeWf85je/iWXLlkVElGpFAQAAAAAAAABIswoXGLj44ovjgQceKAgJZDKZyGQyQgMAAAAAAAAAUAIVKjDw6KOPxv333x8RURASSJIkttlmm9hjjz2iadOmUbt27XKuEgAAAAAAAAC2fhUqMHD99ddHxP8PC3Tq1CluueWWOPTQQ6NSpUrlXB0AAAAAAAAAVBwVJjAwduzY+PrrryOTyURERLdu3eLll1+OmjVrlnNlAAAAAAAAAFDxVJiv5Y8bNy4iIpIkiYiIu+++W1gAAAAAAAAAAEqpwgQGZs+eXfB78+bNo3PnzuVXDAAAAAAAAABUcBUmMLBuK4JMJhMtWrQo52oAAAAAAAAAoGKrMIGB1q1bF/y+ZMmScqwEAAAAAAAAACq+ChMY6NatW0REJEkSeXl5sWrVqnKuCAAAAAAAAAAqrgoTGGjVqlX07NkzIiKWL18ezz//fDlXBAAAAAAAAAAVV4UJDERE3HLLLVG5cuWIiLjuuutixYoV5VwRAAAAAAAAAFRMFSow0KVLl/jzn/8cSZLExIkT48QTT4zFixeXd1kAAAAAAAAAUOFUqMBARMRPf/rTuPfee6Nq1arxwgsvRMeOHeP++++P+fPnl3dpAAAAAAAAAFBhVCnvAkqiV69eBb83adIkZsyYEVOnTo1LLrkkfvKTn0Tbtm2jadOmUaNGjRKNm8lk4tVXXy3rcgEAAAAAAABgq1WhAgMjR46MTCZTcLzu9yRJIkmS+Oqrr2LKlCklGjNJkqwxAQAAAAAAACANKlRgoCgu+AMAAAAAAABAyVS4wECSJOVdAgAAAAAAAABUeBUqMJCfn1/eJQAAAAAAAADAj0Kl8i4AAAAAAAAAANjyBAYAAAAAAAAAIIUEBgAAAAAAAAAghQQGAAAAAAAAACCFBAYAAAAAAAAAIIWqlHcBm+qLL76IoUOHxqhRo2LixIkxb968WLhwYUREvPTSS9GrV6+cPt9++22sXr06IiJq1qwZTZo02aI1AwAAAAAAAEB5q7CBga+++iquuuqqGDZsWCRJEhFR8L8REZlMpsi+N9xwQzz44IMREdGkSZOYMWNGVK5cefMWDAAAAAAAAABbkQq5JcFTTz0Ve+21Vzz77LORn5+fdduGggLrXHXVVRHxfcBg9uzZ8b///W+z1AkAAAAAAAAAW6sKFxgYPnx4nHrqqbFo0aKCtiRJYtttt40uXbpkrTJQlJ133jkOOOCAguMhQ4ZslloBAAAAAAAAYGtVoQIDs2fPjtNOOy3Wrl0bmUwmkiSJfv36xUcffRTffPNNjB49OiKKt8rAiSeeGBHfhw1eeeWVzVo3AAAAAAAAAGxtKlRg4A9/+EMsXry44Pi2226LJ554IvbYY48Sj9WzZ8+C32fOnBnTpk0rkxoBAAAAAAAAoCKoMIGB/Pz8GDRoUGQymchkMnHSSSfF1VdfXerxdt1116hWrVrB8cSJE8uiTAAAAAAAAACoECpMYODdd9+NBQsWRJIkERHx61//epPGq1KlSrRo0aLg2AoDAAAAAAAAAKRJhQkMfP755wW/N23atFTbEKyvQYMGBb8vXLhwk8cDAAAAAAAAgIqiwgQGZs+eHRERmUwmWrZsWSZjVqlSpeD3NWvWlMmYAAAAAAAAAFARVJjAQKVK/7/U/Pz8Mhlz3rx5Bb9vs802ZTImAAAAAAAAAFQEFSYw0KRJk4iISJIkZs6cucnjLVu2LKZOnRqZTCZrfAAAAAAAAABIgwoTGGjbtm3B7zNnzoypU6du0ngjRoyINWvWRJIkERHRuXPnTRoPAAAAAAAAACqSChMY2G+//aJOnToFKwI88sgjmzTeX/7yl4LfW7duHe3atduk8QAAAAAAAACgIqkwgYGqVavGEUccEUmSRJIkcccdd0ReXl6pxnrwwQfjtddei0wmE5lMJk4++eSyLRYAAAAAAAAAtnIVJjAQEfHb3/42KlWqFJlMJhYvXhyHH354iUMD9913X1x22WWRyWQiSZKoWbNmXH311ZunYAAAAAAAAPh/7N13lJXV2Tfg+9A7Q+8ioAlFsaAoGCkCdsUUSxILiSYq+iYx9opYYmzRGKMplqhJNMEaxYYFQVCwRGyIIH0E6UiHYc73Rxbn8wxtBmbmzPBc11qz1ux99t7PfWZO3nnl+T17A1RQlSow0K1btzj33HMjnU5HKpWKqVOnxt577x1XX311fP7555uN33R8wfz58+Of//xn9O7dO4YOHRrr16/PrHHttddGs2bNyvutAAAAAAAAAEBOVct1ASV15513xtSpU+Pll1+OVCoVq1atit/85jfxm9/8JurWrRsRkQkDnHTSSbFmzZpYs2ZNZv6m19LpdJx00kl2FwAAAAAAAAAgkSrVDgMREVWrVo2nnnoqTjvttMzN/4j/BQFWrlyZ1V68eHGsXr060ul0pNPpzBrpdDrOPvvseOSRR3LyHgAAAAAAAAAg1ypdYCAionbt2vHQQw/Fo48+Gt/+9rczYYBNYYFUKrXZV8T/ggJ77LFHPProo3HvvfdGtWqVboMFAAAAAAAAACgVlfqO+cknnxwnn3xyvPTSS/H888/H2LFjY/LkybFu3brMmGrVqkX79u2jf//+ceSRR8YJJ5wQVapUypwEAAAAAAAAAJSaSh0Y2OSII46II444ItNevXp1LFu2LOrUqRN5eXm5KwwAAAAAAAAAKqhdIjBQVJ06daJOnTq5LgMAAAAAAAAAKix78wMAAAAAAABAAgkMAAAAAAAAAEACCQwAAAAAAAAAQAIJDAAAAAAAAABAAlXLdQEl0bFjxzJZN5VKxRdffFEmawMAAAAAAABARVSpAgMzZ86MVCoV6XS6VNdNpVKluh4AAAAAAAAAVHSVKjCwSWnc4E+n02USPgAAAAAAAACAyqBSBQZ22223EocFVq9eHUuXLo2CgoKI+P9hg0aNGkWDBg1KvUYAAAAAAAAAqAwqVWBg5syZOzRv48aN8cEHH8Rjjz0Wf/nLX2LFihVRpUqVuPfee+PII48s3SIBAAAAAAAAoBKokusCykPVqlWjR48eceutt8aHH34Y++23XyxevDiOP/74ePLJJ3NdHgAAAAAAAACUu0QEBr6pffv28eKLL0bbtm2joKAgTjvttPj8889zXRYAAAAAAAAAlKvEBQYiIpo1axbDhw+PiIi1a9fGJZdckuOKAAAAAAAAAKB8JTIwEBFx4oknRvXq1SOdTsdzzz0XX331Va5LAgAAAAAAAIByk9jAQL169aJjx44REZFOp2Ps2LE5rggAAAAAAAAAyk9iAwMREQ0bNsx8P2vWrBxWAgAAAAAAAADlK9GBgYULF2a+LygoyGElAAAAAAAAAFC+EhsY+OKLL2LGjBmRSqUiIqJp06Y5rggAAAAAAAAAyk8iAwPpdDouuOCCzPcREd26dctlSQAAAAAAAABQrhIXGJg6dWoce+yx8dxzz2XtLnDQQQfluDIAAAAAAAAAKD/Vcl1ASVx33XU7NG/NmjXx1VdfxX//+9/48MMPM/3pdDpSqVRcfvnlmfAAAAAAAAAAACRBpQoMXHvttTt1Y3/T8QOpVCpSqVSk0+k45phj4he/+EVplQgAAAAAAAAAlUKijiT4ZlAglUrF+eefHyNGjIgqVRL1YwAAAAAAAACAyrXDQMT/3yVgR6RSqfjWt74VRx99dJx55pnRtWvXUqwMAAAAAAAAACqPShUYeP3110s8J5VKRa1ataJBgwbRrl27qFu3bhlUBgAAAAAAAACVS6UKDPTt2zfXJQAAAAAAAADALqFKrgsAAAAAAAAAAMqfwAAAAAAAAAAAJJDAAAAAAAAAAAAkkMAAAAAAAAAAACSQwAAAAAAAAAAAJFC1XBdQEtddd11Or3/NNdfk9PoAAAAAAAAAUFoqVWDg2muvjVQqlbPrCwwAAAAAAAAAsKuoVIGBb0qn01vs31KgoCRjt3atXAYVAAAAAAAAAKC0VbrAwDdv/he9iZ9Op4sdDtjWWAAAAAAAAADY1VWqwMDrr78eERFfffVVXHbZZTFr1qzMTf999903+vXrF3vvvXc0adIk6tatG6tWrYrFixfHhx9+GG+88UZ88MEHEfG/8ECHDh3it7/9bTRv3jxXbwcAAAAAAAAAcqZSBQb69u0bH3/8cZx66qnx5ZdfRjqdjkGDBsWtt94a3bt33+78SZMmxcUXXxyvvPJKzJw5My666KJ48cUXo0uXLuVQPQAAAAAAAABUHFVyXUBJLF68OI488sjIz8+PiIirrroqXnrppWKFBSIi9tlnn3j55ZfjyiuvjHQ6HXPmzIkjjjgilixZUpZlAwAAAAAAAECFU6kCA1dccUV8+eWXkUql4nvf+15cd911O7TO9ddfH9/73vciIiI/Pz+uvPLK0iwTAAAAAAAAACq8ShMYWLlyZTz88MOZ9o6GBYrOT6fT8dBDD8WqVat2aj0AAAAAAAAAqEwqTWBg7NixsW7dukilUtG6devo0qXLTq3XtWvXaNu2bURErFu3LsaMGVMaZQIAAAAAAABApVBpAgNTp07NfN+6detSWbNVq1ZbXB8AAAAAAAAAdnWVJjDwzSMDli1bViprfnMdRxIAAAAAAAAAkCSVJjDQtGnTiIhIp9MxY8aMWLRo0U6tt2jRopgxY0akUqms9QEAAAAAAAAgCSpNYKBjx44REZFKpWLjxo3xpz/9aafWu+eee6KgoCDS6XTW+gAAAAAAAACQBJUmMNC3b99o3LhxRPxvl4Ebb7wx3njjjR1aa/To0fGb3/wms7tAo0aNom/fvqVWKwAAAAAAAABUdJUmMFCtWrX42c9+Ful0OlKpVKxbty6OOuqouPPOO2Pjxo3FWmPjxo1xxx13xNFHHx0bNmzIrPXzn/88qlWrVsbvAAAAAAAAAAAqjkoTGIiIGDZsWOyxxx4R8b+jCdauXRsXXnhhdOjQIS655JJ4/vnnY/bs2bFq1apIp9OxatWqmDVrVowcOTIuueSS6NChQ1x00UWxdu3azJqdOnWKa665JldvCQAAAAAAAAByolI9Vl+rVq146aWX4rDDDotZs2ZFKpWKdDodc+fOjdtvvz1uv/32bc5Pp9MREZl57du3jxdffDFq1apVHuUDAAAAAAAAQIVRqXYYiIjo0KFDjB8/Po444ojMkQKpVCoi/hcI2NpXRGSNGzhwYLz55pvRsWPHnL0XAAAAAAAAAMiVShcYiIho1apVvPDCC/HYY4/FQQcdlBUKiIhMiGBTQCDi/4cJDjrooHj00Ufj5ZdfjjZt2uSifAAAAAAAAADIuUp1JEFRJ510Upx00knx2WefxejRo2PixIkxY8aMWLZsWaxcuTLq1q0beXl50bFjxzjwwAOjX79+0aVLl1yXDQAAAAAAAAA5V6kDA5t07tw5OnfuHOecc06uSwEAAAAAAACASqFSHkkAAAAAAAAAAOwcgQEAAAAAAAAASCCBAQAAAAAAAABIoGq5LqA0LFy4MMaOHRuTJ0+OJUuWxPLly6OwsDAuueSS6Ny5c67LAwAAAAAAAIAKp1IHBp555pm4/fbbY9y4cVt8/dRTT91iYOCyyy6LiRMnRkRE+/bt48EHHyzTOgEAAAAAAACgoqmUgYHFixfHkCFD4vnnn4+IiHQ6HRERqVQq6/utOfjgg+OWW27JjLvooouiW7duZVw1AAAAAAAAAFQcVXJdQEktWrQoevXqFc8//3wmHLBJOp3eZlBgk8GDB0e7du0y7X/+85+lXicAAAAAAAAAVGSVKjCQTqfj+OOPj2nTpmX66tWrFxdccEG88MIL8fHHH28WItiSVCoV3//+9zPtl156qUzqBQAAAAAAAICKqlIdSfDwww/H22+/ndlFoHfv3vHEE09EixYtssYVZ5eBY445Ju68885Ip9PxwQcfxIoVK6J+/fplUjcAAAAAAAAAVDSVaoeBW265JSL+t9NAp06d4vnnn98sLFBcPXr0yHyfTqfj008/LZUaAQAAAAAAAKAyqDSBgZkzZ8bkyZMjlUpFKpWK3/zmN9GgQYMdXi8vLy9atWqVaX/++eelUSYAAAAAAAAAVAqVJjAwceLEiPjfbgC1atWK448/fqfXbNy4ceb7pUuX7vR6AAAAAAAAAFBZVJrAwIIFCyIiIpVKRceOHaNGjRo7vWa9evUy369atWqn1wMAAAAAAACAyqJargsorpUrV2a+/+aN/p2xYsWKzPd169YtlTUrurVr18b48ePjs88+i6VLl0aNGjWibdu2cdBBB0XHjh1zXR4AAAAAAAAA5aTSBAaaNGmS+X7JkiWlsmZ+fn7m+6ZNm5bKmjtSw8SJE2PChAkxceLEePfdd7OCDO3bt4+ZM2fu9HUWLlwYw4cPj7/97W9b3U2hR48ecfXVV8fgwYN3+noAAAAAAAAAVGyVJjDQsmXLiIhIp9MxY8aMWL16ddSpU2eH1/vwww9j+fLlmXaHDh12usbiGjduXNx+++0xYcKE+PLLL8v8eqNHj44TTzwxFi1atM1x7733Xpxwwglx+umnx1//+tdSOfYBAAAAAAAAgIqpSq4LKK6DDz44UqlUpFKp2LhxY4wcOXKn1nvwwQcz39etWzd69uy5syUW2zvvvBNPPfVUuYQF3nzzzTj66KM3Cwvk5eXFfvvtF7vvvntUrVo167WHH344fvjDH0Y6nS7z+gAAAAAAAADIjUoTGGjWrFn06NEjcxP7N7/5TWzcuHGH1poyZUr89a9/zQQQDjvssM1umudKvXr1Sm2tpUuXxsknnxxr1qzJ9LVv3z6efvrpWLJkSbz//vsxY8aMmDlzZpx99tlZc5988sm44447Sq0WAAAAAAAAACqWShMYiIg4//zzM99/+OGH8X//938lXmPu3LlxwgknxOrVqzPhg4svvrjUaiyJ+vXrR79+/eLiiy+OESNGxMyZM+PZZ58ttfVvvfXWrF0MOnToEOPHj4/BgwdHKpXK9Ldt2zb+9Kc/xY033pg1/7rrroulS5eWWj0AAAAAAAAAVByVKjBw2mmnRffu3SMiIp1Ox5///Oc47rjjYurUqdudu379+vjzn/8cBxxwQHz++eeZ3QWOOOKIOOSQQ8q69CzHHXdcfPLJJ7Fs2bJ4/fXX45Zbbokf/OAH0b59+1K7xsKFC+MPf/hDVt9f//rXaN269VbnXH755dGnT59Me/ny5XHbbbeVWk0AAAAAAAAAVByVKjCQSqVixIgR0aRJk8wT8s8//3x07tw5evXqldlxYNPOAQ888ECcf/75ceSRR0bTpk1j6NChsWDBgsyYdu3axSOPPFLu76NTp07RtWvXqFKl7H78jz32WKxcuTLT7tOnTwwYMGCbc1KpVAwbNiyr74EHHsj8PAEAAAAAAADYdVTLdQElteeee8azzz4bgwcPjgULFkQqlYp0Oh0TJ06MiRMnZsal0+l49NFHs9oRkRnfrl27eO6556JJkybl/h7KwzPPPJPVPvPMM4s1r3///tGhQ4eYMWNGRETMnz8/3n777ejVq1ep1wgAAAAAAABA7lSqHQY2Oeigg2LSpElxxBFHbPb0+6ajBjbtQPDN/oj/BQeOOOKIePfdd2OvvfYqt5rL08qVK2PMmDFZfYcffnix5qZSqRg4cGBW33PPPVdqtQEAAAAAAABQMVTKwEBERIsWLeKFF16It956K0466aRo0KBBpNPprX7Vrl07jj322HjjjTfihRdeiGbNmuX6LZSZTz75JDZs2JBpd+jQIVq2bFns+YccckhW+4MPPiit0gAAAAAAAACoICrdkQRFHXTQQfHYY49FOp2Ojz76KCZPnhyLFy+OZcuWRZ06daJp06bRoUOH6NmzZ1SvXj3X5ZaLyZMnZ7W7du1aovlFxxddDwAAAAAAAIDKr9IEBjZu3BirVq3KtGvXrp0VAEilUtG9e/fo3r17LsqrUKZMmZLVbteuXYnmFx0/a9asWLt2bdSqVWunawMAAAAAAACgYqg0RxI89NBD0ahRo8zX2LFjc11ShbVgwYKsdtu2bUs0v0WLFlGt2v/PkhQWFsbixYtLpTYAAAAAAAAAKoZKs8PAV199Fel0OiIi8vLy4rDDDstxRRXXypUrs9p169Yt0fxUKhW1a9eOFStWbHXNHbVgwYJYuHBhieZMmzatVK4NAAAAAAAAwP9XaQID9erVi4j/3cxu3759jqup2Ire3N+RowTKKjBwzz33xPDhw0tlLQAAAAAAAAB2XKU5kqBVq1a5LqHSWLt2bVa7Ro0aJV6jZs2aWe01a9bsVE0AAAAAAAAAVCyVJjDQpUuXiIhIp9MxZ86cHFdTsRXdUWD9+vUlXmPdunXbXBMAAAAAAACAyq3SHEnQrVu36NatW3zyySexdOnSmDBhQhx00EG5LqtC2nR8wyZFdxwojqI7ChRdc0cNHTo0TjzxxBLNmTZtWpxwwgmlcn0AAAAAAAAA/qfSBAYiIn7+85/HL3/5y4iIGDZsWLz44os5rqhiKnpzf9WqVSWan06nyyww0Lx582jevHmprAUAAAAAAADAjqs0RxJE/O/p9EMOOSTS6XSMGjUqLrroolyXVCEVvSE/d+7cEs3/6quvoqCgINOuUqVKNG3atFRqAwAAAAAAAKBiqFSBgapVq8azzz4b3/nOdyKdTscdd9wRffr0idGjR+e6tArl29/+dlZ79uzZJZpfdHz79u2jVq1aO10XAAAAAAAAABVHpTqS4LrrrouIiL59+8bUqVPjq6++inHjxsWAAQOiRYsWccABB0SHDh2iQYMGUb169RKtfc0115RFyTnRuXPnrPann35aovmTJ0/e5noAAAAAAAAAVH6VKjBw7bXXRiqVyrRTqVSk0+mIiJg/f36MHDlyh9felQID3bp1i+rVq8eGDRsiImLmzJkxb968aNWqVbHmjxs3Lqu97777lnaJAAAAAAAAAORYpTqSYEtSqVTma0dsChzsSurXrx99+vTJ6hs1alSx5qbT6XjllVey+o477rhSqw0AAAAAAACAiqHSBQbS6XSpfu2qjj/++Kz2/fffX6x5r7/+esyYMSPTbtGiRRx00EGlWhsAAAAAAAAAuVepjiR4/fXXc11CpXHKKafEFVdcEatWrYqIiDFjxsRrr70Whx122FbnpNPpGD58eFbfT37yk6hSpdLlSgAAAAAAAADYjkoVGOjbt2+uS6g0mjdvHueff37cfPPNmb6zzjor3nzzzWjduvUW59x0000xZsyYTLthw4Zx8cUXl3mtAAAAAAAAAJS/ChUY+PWvf535fujQobHHHnvksJqyNW7cuFizZs1m/ZMmTcpqr127Nl555ZUtrtG6devo2rXrVq9xySWXxEMPPRTz58+PiIgZM2ZE796946677orjjjsuUqlURETMnTs3brjhhvjzn/+cNf/KK6+Mxo0bl+h9AQAAAAAAAFA5VKjAwJ133pm5iX3sscduNzCwbNmy+PDDDzPtPn36lGl9penHP/5xzJo1a7vjvvrqqxg0aNAWXzvjjDPib3/721bnNm7cOP71r3/FEUccEWvXro2IiFmzZsXgwYMjLy8vOnToEMuWLYvZs2fHxo0bs+YOHjw4LrroouK/IQAAAAAAAAAqlQoVGIiISKfTmdDA9rz33ntx+OGHR0REKpWKgoKCsiytUurTp0+MHDkyTjzxxFiyZEmmf9myZfHf//53i3N+9KMfxQMPPFDs3wMAAAAAAAAAlU+VXBdQVElvUqfT6cwXW3bYYYfFp59+Gueee27UqVNnq+P222+/eOKJJ+If//hH1KxZsxwrBAAAAAAAAKC8VbgdBpJi5syZ5Xq9Fi1axD333BO33357jB8/PiZPnhzLli2LGjVqRJs2beKggw7a7hEQAAAAAAAAAOw6BAYSpnbt2jFgwIAYMGBArksBAAAAAAAAIIcq3JEEAAAAAAAAAEDZExgAAAAAAAAAgAQSGAAAAAAAAACABBIYAAAAAAAAAIAEEhgAAAAAAAAAgAQSGAAAAAAAAACABBIYAAAAAAAAAIAEqpbrArZm0qRJUa3atsubNGlSVnvs2LGRTqd36Hp9+vTZoXkAAAAAAAAAUBlVyMBAOp2Oiy66qMRz+vXrt0PXS6VSUVBQsENzAQAAAAAAAKAyqpCBgVQqVeydAlKpVOb7Hd1dAAAAAAAAAACSpkIGBiKygwBlOUfIAAAAAAAAAIAkqlCBgd12222HbvoDAAAAAAAAACVToQIDM2fOzHUJAAAAAAAAAJAIVXJdAAAAAAAAAABQ/gQGAAAAAAAAACCBBAYAAAAAAAAAIIEEBgAAAAAAAAAggQQGAAAAAAAAACCBBAYAAAAAAAAAIIEEBgAAAAAAAAAggQQGAAAAAAAAACCBBAYAAAAAAAAAIIEEBgAAAAAAAAAggQQGAAAAAAAAACCBBAYAAAAAAAAAIIEEBgAAAAAAAAAggQQGAAAAAAAAACCBBAYAAAAAAAAAIIEEBgAAAAAAAAAggQQGAAAAAAAAACCBBAYAAAAAAAAAIIEEBgAAAAAAAAAggQQGAAAAAAAAACCBBAYAAAAAAAAAIIEEBgAAAAAAAAAggQQGAAAAAAAAACCBBAYAAAAAAAAAIIEEBgAAAAAAAAAggQQGAAAAAAAAACCBBAYAAAAAAAAAIIEEBgAAAAAAAAAggQQGAAAAAAAAACCBBAYAAAAAAAAAIIEEBgAAAAAAAAAggQQGAAAAAAAAACCBBAYAAAAAAAAAIIEEBgAAAAAAAAAggQQGAAAAAAAAACCBBAYAAAAAAAAAIIEEBgAAAAAAAAAggQQGAAAAAAAAACCBBAYAAAAAAAAAIIEEBgAAAAAAAAAggQQGAAAAAAAAACCBBAYAAAAAAAAAIIEEBgAAAAAAAAAggQQGAAAAAAAAACCBBAYAAAAAAAAAIIEEBgAAAAAAAAAggQQGAAAAAAAAACCBBAYAAAAAAAAAIIEEBgAAAAAAAAAggQQGAAAAAAAAACCBBAYAAAAAAAAAIIEEBgAAAAAAAAAggQQGAAAAAAAAACCBBAYAAAAAAAAAIIEEBgAAAAAAAAAggQQGAAAAAAAAACCBBAYAAAAAAAAAIIEEBgAAAAAAAAAggQQGAAAAAAAAACCBBAYAAAAAAAAAIIEEBgAAAAAAAAAggQQGAAAAAAAAACCBBAYAAAAAAAAAIIEEBgAAAAAAAAAggQQGAAAAAAAAACCBBAYAAAAAAAAAIIEEBgAAAAAAAAAggQQGAAAAAAAAACCBBAYAAAAAAAAAIIEEBgAAAAAAAAAggQQGAAAAAAAAACCBBAYAAAAAAAAAIIEEBgAAAAAAAAAggQQGAAAAAAAAACCBBAYAAAAAAAAAIIEEBgAAAAAAAAAggQQGAAAAAAAAACCBBAYAAAAAAAAAIIEEBgAAAAAAAAAggQQGAAAAAAAAACCBBAYAAAAAAAAAIIEEBgAAAAAAAAAggQQGAAAAAAAAACCBBAYAAAAAAAAAIIEEBgAAAAAAAAAggQQGAAAAAAAAACCBBAYAAAAAAAAAIIEEBgAAAAAAAAAggQQGAAAAAAAAACCBBAYAAAAAAAAAIIEEBgAAAAAAAAAggQQGAAAAAAAAACCBBAYAAAAAAAAAIIEEBgAAAAAAAAAggQQGAAAAAAAAACCBBAYAAAAAAAAAIIEEBgAAAAAAAAAggQQGAAAAAAAAACCBBAYAAAAAAAAAIIEEBgAAAAAAAAAggQQGAAAAAAAAACCBBAYAAAAAAAAAIIEEBgAAAAAAAAAggQQGAAAAAAAAACCBBAYAAAAAAAAAIIEEBgAAAAAAAAAggQQGAAAAAAAAACCBBAYAAAAAAAAAIIEEBgAAAAAAAAAggQQGAAAAAAAAACCBBAYAAAAAAAAAIIEEBgAAAAAAAAAggQQGAAAAAAAAACCBBAYAAAAAAAAAIIEEBgAAAAAAAAAggQQGAAAAAAAAACCBBAYAAAAAAAAAIIEEBgAAAAAAAAAggQQGAAAAAAAAACCBBAYAAAAAAAAAIIEEBgAAAAAAAAAggQQGAAAAAAAAACCBBAYAAAAAAAAAIIEEBgAAAAAAAAAggQQGAAAAAAAAACCBBAYAAAAAAAAAIIEEBgAAAAAAAAAggQQGAAAAAAAAACCBBAYAAAAAAAAAIIEEBgAAAAAAAAAggQQGAAAAAAAAACCBBAYAAAAAAAAAIIEEBgAAAAAAAAAggQQGAAAAAAAAACCBBAYAAAAAAAAAIIEEBgAAAAAAAAAggQQGAAAAAAAAACCBBAYAAAAAAAAAIIEEBgAAAAAAAAAggQQGAAAAAAAAACCBBAYAAAAAAAAAIIEEBgAAAAAAAAAggQQGAAAAAAAAACCBBAYAAAAAAAAAIIEEBgAAAAAAAAAggQQGAAAAAAAAACCBBAYAAAAAAAAAIIEEBnZh1157baRSqR3+GjJkSK7fAgAAAAAAAABlRGAAAAAAAAAAABJIYAAAAAAAAAAAEqhargug/Nx2222xzz77FHt869aty7AaAAAAAAAAAHJJYCBBevToEf369ct1GQAAAAAAAABUAI4kAAAAAAAAAIAEEhgAAAAAAAAAgAQSGAAAAAAAAACABBIYAAAAAAAAAIAEEhgAAAAAAAAAgASqlusCKF/r1q2L6dOnx+LFi6N69erRpEmTaN26ddSpUyfXpQEAAAAAAABQjgQGEuS8886L6dOnx9q1a7P6q1WrFj169Iijjjoqhg4dGs2aNSuzGhYsWBALFy4s0Zxp06aVUTUAAAAAAAAAySUwkCCffvrpFvsLCgpiwoQJMWHChLj55pvjoosuimHDhkXVqlVLvYZ77rknhg8fXurrAgAAAAAAAFAyVXJdABXLmjVr4vrrr4+BAwfGypUrc10OAAAAAAAAAGVEYGAXl0qlonfv3nHjjTfGqFGjYu7cubF69epYu3Zt5Ofnx7PPPhtnn3121KpVK2ve6NGj45RTTomNGzfmqHIAAAAAAAAAylIqnU6nc10EZWP8+PHRtGnT+Na3vrXdsXPnzo1TTjklxo0bl9V/1113xf/93/+VWk0LFiyIhQsXlmjOtGnT4oQTTsi0P/744+jWrVup1ZRUqfP/kesSAIiI9N0/znUJAAAAAADk0CeffBJ77bVXpl2e90OrlctVyInevXsXe2zbtm3jlVdeicMOOyzeeuutTP8NN9wQZ555ZtSpU6dUamrevHk0b968VNYCAAAAAAAAYMc5koCMWrVqxcMPPxzVqv3/HMmCBQvi5ZdfzmFVAAAAAAAAAJQFgQGy7LHHHnH88cdn9QkMAAAAAAAAAOx6BAbYzIABA7LaU6ZMyVElAAAAAAAAAJQVgQE2065du6z2woULc1QJAAAAAAAAAGVFYIDNVK9ePau9YcOGHFUCAAAAAAAAQFkRGGAz8+fPz2o3a9YsR5UAAAAAAAAAUFYEBtjMm2++mdUuekQBAAAAAAAAAJWfwABZli1bFk888URW34ABA3JUDQAAAAAAAABlRWCALBdddFEsW7Ys065Ro0YcddRRuSsIAAAAAAAAgDIhMLCL+u1vfxvvvfdesccXFBTEhRdeGPfff39W/znnnBOtWrUq7fIAAAAAAAAAyDGBgV3Uiy++GAcccEAccsgh8fvf/z4+/vjjKCgo2Gzc8uXL49FHH40DDzwwfve732W91qlTp7jmmmvKq2QAAAAAAAAAylG1XBdA2Ro/fnyMHz8+IiJq1qwZbdu2jYYNG0bVqlVj8eLFMXPmzCgsLNxsXsuWLeOFF16IJk2alHfJAAAAAAAAAJQDgYEEWbduXXzxxRfbHXf00UfHgw8+GM2bNy+HqgAAAAAAAADIBYGBXdSVV14ZXbp0ibFjx8Znn30WGzdu3Ob4evXqxVFHHRXnn39+9OnTp5yqBAAAAAAAACBXBAZ2UYMGDYpBgwZFRMTq1avj008/jZkzZ8a8efNi5cqVUVhYGHl5edGoUaPo2rVr7L333lG1atUcVw0AAAAAAABAeREYSIA6derEAQccEAcccECuSwEAAAAAAACggqiS6wIAAAAAAAAAgPInMAAAAAAAAAAACSQwAAAAAAAAAAAJJDAAAAAAAAAAAAkkMAAAAAAAAAAACSQwAAAAAAAAAAAJJDAAAAAAAAAAAAkkMAAAAAAAAAAACSQwAAAAAAAAAAAJJDAAAAAAAAAAAAkkMAAAAAAAAAAACSQwAAAAAAAAAAAJJDAAAAAAAAAAAAkkMAAAAAAAAAAACSQwAAAAAAAAAAAJJDAAAAAAAAAAAAkkMAAAAAAAAAAACSQwAAAAAAAAAAAJJDAAAAAAAAAAAAkkMAAAAAAAAAAACSQwAAAAAAAAAAAJJDAAAAAAAAAAAAkkMAAAAAAAAAAACSQwAAAAAAAAAAAJJDAAAAAAAAAAAAkkMAAAAAAAAAAACSQwAAAAAAAAAAAJJDAAAAAAAAAAAAkkMAAAAAAAAAAACSQwAAAAAAAAAAAJJDAAAAAAAAAAAAkkMAAAAAAAAAAACSQwAAAAAAAAAAAJJDAAAAAAAAAAAAkkMAAAAAAAAAAACSQwAAAAAAAAAAAJJDAAAAAAAAAAAAkkMAAAAAAAAAAACSQwAAAAAAAAAAAJJDAAAAAAAAAAAAkkMAAAAAAAAAAACSQwAAAAAAAAAAAJJDAAAAAAAAAAAAkkMAAAAAAAAAAACSQwAAAAAAAAAAAJJDAAAAAAAAAAAAkkMAAAAAAAAAAACSQwAAAAAAAAAAAJJDAAAAAAAAAAAAkkMAAAAAAAAAAACSQwAAAAAAAAAAAJJDAAAAAAAAAAAAkkMAAAAAAAAAAACSQwAAAAAAAAAAAJJDAAAAAAAAAAAAkkMAAAAAAAAAAACSQwAAAAAAAAAAAJJDAAAAAAAAAAAAkkMAAAAAAAAAAACSQwAAAAAAAAAAAJJDAAAAAAAAAAAAkkMAAAAAAAAAAACSQwAAAAAAAAAAAJJDAAAAAAAAAAAAkkMAAAAAAAAAAACSQwAAAAAAAAAAAJJDAAAAAAAAAAAAkkMAAAAAAAAAAACSQwAAAAAAAAAAAJJDAAAAAAAAAAAAkkMAAAAAAAAAAACSQwAAAAAAAAAAAJJDAAAAAAAAAAAAkkMAAAAAAAAAAACSQwAAAAAAAAAAAJJDAAAAAAAAAAAAkkMAAAAAAAAAAACSQwAAAAAAAAAAAJJDAAAAAAAAAAAAkkMAAAAAAAAAAACSQwAAAAAAAAAAAJJDAAAAAAAAAAAAkkMAAAAAAAAAAACSQwAAAAAAAAAAAJJDAAAAAAAAAAAAkkMAAAAAAAAAAACSQwAAAAAAAAAAAJJDAAAAAAAAAAAAkkMAAAAAAAAAAACSQwAAAAAAAAAAAJJDAAAAAAAAAAAAkkMAAAAAAAAAAACSQwAAAAAAAAAAAJJDAAAAAAAAAAAAkkMAAAAAAAAAAACVQt1wUAAAAAsPNS5/8j1yUAEBHpu3+c6xIAAIrNDgMAAAAAAAAAkEACAwAAAAAAAACQQAIDAAAAAAAAAJBAAgMAAAAAAAAAkEACAwAAAAAAAACQQAIDAAAAAAAAAJBAAgMAAAAAAAAAkEACAwAAAAAAAACQQAIDAAAAAAAAAJBAAgMAAAAAAAAAkEACAwAAAAAAAACQQAIDAAAAAAAAAJBAAgMAAAAAAAAAkEACAwAAAAAAAACQQAIDAAAAAAAAAJBAAgMAAAAAAAAAkEACAwAAAAAAAACQQAIDAAAAAAAAAJBAAgMAAAAAAAAAkEACAwAAAAAAAACQQAIDAAAAAAAAAJBAAgMAAAAAAAAAkEACAwAAAAAAAACQQAIDAAAAAAAAAJBAAgMAAAAAAAAAkEACAwAAAAAAAACQQAIDAAAAAAAAAJBAAgMAAAAAAAAAkEACAwAAAAAAAACQQAIDAAAAAAAAAJBAAgMAAAAAAAAAkEACAwAAAAAAAACQQAIDAAAAAAAAAJBAAgMAAAAAAAAAkEACAwAAAAAAAACQQAIDAAAAAAAAAJBAAgMAAAAAAAAAkEDVcl0AAAAAAABAcaXO/0euSwAgItJ3/zjXJVAK7DAAAAAAAAAAAAkkMAAAAAAAAAAACSQwAAAAAAAAAAAJJDAAAAAAAAAAAAkkMAAAAAAAAAAACSQwAAAAAAAAAAAJJDAAAAAAAAAAAAkkMAAAAAAAAAAACSQwAAAAAAAAAAAJJDAAAAAAAAAAAAkkMAAAAAAAAAAACSQwAAAAAAAAAAAJJDAAAAAAAAAAAAkkMAAAAAAAAAAACSQwAAAAAAAAAAAJJDAAAAAAAAAAAAkkMAAAAAAAAAAACSQwAAAAAAAAAAAJJDAAAAAAAAAAAAkkMAAAAAAAAAAACSQwAAAAAAAAAAAJJDAAAAAAAAAAAAlULdcFkBtffPFFTJw4MebOnRvr16+PRo0aRefOnaN3795Rq1atXJcHAAAAAAAAQBkTGEiYp59+Oq6//vp4//33t/h6vXr1YsiQITFs2LBo2rRpOVcHAAAAAAAAQHlxJEFCrFu3Lk499dT47ne/u9WwQETEypUr4+67746uXbvGmDFjyrFCAAAAAAAAAMqTwEACFBYWxsknnxz/+Mc/svqrVq0aHTp0iH333TcaNmyY9drChQvjqKOOirfeeqs8SwUAAAAAAACgnAgMJMCtt94azzzzTFbfOeecE7Nnz47p06fHf//731iyZEk8+eSTsdtuu2XGrF69Ok466aRYvnx5eZcMAAAAAAAAQBkTGNjFLV68OG688casvptuuinuvffeaN26daavSpUq8d3vfjfGjx8fu+++e6Z/7ty58bvf/a68ygUAAAAAAACgnAgM7OJuueWWWLFiRabdp0+fuPTSS7c6vk2bNnHfffdl9d1xxx2xePHiMqsRAAAAAAAAgPInMLALKywsjAcffDCr79prr41UKrXNeQMGDIhDDz00016xYkX8+9//LpMaAQAAAAAAAMgNgYFd2Pjx42PhwoWZdseOHaNfv37FmnvmmWdmtZ9++ulSrAwAAAAAAACAXBMY2IWNHDkyqz1o0KDt7i7wzbHfNHr06Fi1alWp1QYAAAAAAABAbgkM7MI++OCDrHbv3r2LPbd169ax++67Z9rr16+PTz/9tJQqAwAAAAAAACDXBAZ2YZMnT85qd+3atUTzi44vuh4AAAAAAAAAlZfAwC5qzZo1MXv27Ky+du3alWiNouOnTJmy03UBAAAAAAAAUDFUy3UBlI1FixZFOp3OtKtXrx7Nmzcv0Rpt2rTJai9YsGCn61qwYEEsXLiwRHOKHoUwbdq0na6DiFg8N9cVABARn3zySa5LAAB2Ff47D6BC8N955cDfPIAKwd+80lP0/ue6devK7doCA7uolStXZrXr1KkTqVSqRGvUrVt3m2vuiHvuuSeGDx++U2uccMIJO10HAFQUez12Wa5LAAAAoBT57zwAksLfvLIzZ86c2H///cvlWo4k2EUVvblfq1atEq9Ru3btba4JAAAAAAAAQOUlMLCLWrt2bVa7Ro0aJV6jZs2aWe01a9bsVE0AAAAAAAAAVByOJNhFFd1RYP369SVeo+jZGDuyS0FRQ4cOjRNPPLFEc77++ut49913o0GDBpGXlxft2rXbLMwAJMu0adOyjid5+umnY4899shdQQBQRvzNAyAp/M0DICn8zQO2ZN26dTFnzpxMu2/fvuV2bYGBXVS9evWy2kV3HCiOojsKFF1zRzRv3jyaN29e4nm9evXa6WsDu6499tgjunXrlusyAKDM+ZsHQFL4mwdAUvibB2yy//775+S6jiTYRRW9ub969epIp9MlWmPVqlXbXBMAAAAAAACAyktgYBfVtGnTSKVSmfaGDRtiwYIFJVojPz8/q70jOwMAAAAAAAAAUDEJDOyiateuHbvttltW3+zZs0u0RtHxnTt33um6AAAAAAAAAKgYBAZ2YUVv8H/66aclmj958uRtrgcAAAAAAABA5SUwsAvbd999s9rjx48v9tx58+bFzJkzM+3q1atH165dS6kyAAAAAAAAAHJNYGAXduyxx2a1X3nllUin08Wa+/LLL2e1+/fvH/Xq1Su12gAAAAAAAADILYGBXVjv3r2jadOmmfb06dNj9OjRxZp7//33Z7UHDx5cmqUBAAAAAAAAkGMCA7uwKlWqxJAhQ7L6hg8fvt1dBl599dUYO3Zspl2/fv046aSTyqJEAAAAAAAAAHJEYGAXd+mll2YdJfDGG2/EzTffvNXx+fn5cdZZZ2X1/fKXv8zaqQAAAAAAAACAyk9gYBfXtGnTuOKKK7L6Lr/88hg6dGh8+eWXmb7CwsJ4+umno3fv3jFz5sxMf+vWrePCCy8sr3IBAAAAAAAAKCcCAwlw6aWXxrHHHpvVd++998Zuu+0WnTp1iv333z+aNGkS3/3ud2P27NmZMbVr145///vfkZeXV84VAwAAAAAAAFDWquW6AMpelSpVYsSIEfGTn/wkHnvssUz/xo0bY/r06Vuc06RJk3j88cfjkEMOKa8yAYqtWbNmMWzYsKw2AOyK/M0DICn8zQMgKfzNAyqaVDqdTue6CMrPE088ETfccEN88MEHW3y9bt26ccYZZ8SwYcOiefPm5VscAAAAAAAAAOVGYCChpk2bFhMmTIj8/PxYv3595OXlRZcuXeKQQw6JWrVq5bo8AAAAAAAAAMqYwAAAAAAAAAAAJFCVXBcAAAAAAAAAAJQ/gQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIoGq5LgAASuqLL76IiRMnxty5c2P9+vXRqFGj6Ny5c/Tu3Ttq1aqV6/IAAADYjnQ6HTNnzoyPPvoo5s6dG8uWLYuaNWtGo0aNYs8994wDDzzQf98BsEtYv359fPbZZzFz5szIz8+PFStWxIYNG6JBgwbRpEmT6N69e3Tp0iWqVq2a61KBhBIYAKDSePrpp+P666+P999/f4uv16tXL4YMGRLDhg2Lpk2blnN1AFA68vPzY+LEiTFhwoSYOHFivPvuu7FixYrM6+3bt4+ZM2fmrkAA2EFLly6Np59+Ol588cV47bXXYtGiRVsdW7169TjmmGPiV7/6VfTt27ccqwSAnff444/HK6+8EuPGjYvPPvssCgoKtjm+YcOG8cMf/jB++ctfRufOncupSoD/SaXT6XSuiwCAbVm3bl2ceeaZ8Y9//KNY45s1axaPP/549OnTp4wrA4DSMW7cuLj99ttjwoQJ8eWXX25zrMAAAJXReeedF/fdd1+sX7++xHNPP/30+MMf/hANGjQog8oAoPS1bds28vPzSzyvevXqccUVV8SwYcMilUqVQWUAm7PDAAAVWmFhYZx88snxzDPPZPVXrVo1dtttt2jYsGHMmDEjli9fnnlt4cKFcdRRR8Urr7wSvXr1Ku+SAaDE3nnnnXjqqadyXQYAlJkJEyZsMSxQtWrVaNWqVbRo0SI2bNgQs2bNyvrvu4iIhx9+OD777LN49dVXo169euVVMgCUqlq1amX+PbOwsDAWLVoUs2fPjm8+17thw4YYPnx4zJkzJ+6///4cVgskSZVcFwAA23LrrbduFhY455xzYvbs2TF9+vT473//G0uWLIknn3wydtttt8yY1atXx0knnbTZPzQBQGXjxggAu5q8vLwYOnRojBw5MpYuXRpz5syJd999NyZNmhSLFy+O119/PQ499NCsORMnTowhQ4bkpmAA2AGtW7eOn/3sZ/HII4/EtGnTYtWqVTFlypTM0XMzZ86MxYsXx1/+8pdo27Zt1twHHnggHnzwwRxVDiSNIwkAqLAWL14cHTp0yDq3+aabborLLrtsi+Pz8/PjO9/5TtY2zddcc00MHz68rEsFgJ1y5513xgUXXBD169ePHj16xIEHHhg9e/aMAw88MGbMmBH9+/fPjHUkAQCV0QEHHBCLFy+Oq666Kn70ox9F7dq1tzl+48aNMXTo0PjLX/6S1f/aa69l/V0EgIroww8/jL333rvYxwosXbo0Bg4cGO+//36mr1WrVjF37tyoUsWzv0DZEhgAoMK69NJL45Zbbsm0+/TpE6NHj97m/6P96quvxsCBAzPt+vXrx4wZM6JJkyZlWisA7Iwvvvgi1q1bF507d97sH4NGjx4tMABApTdy5MgYNGhQ1KhRo9hzNm7cGAcffHC8++67mb4f/ehH8Y9//KMsSgSAnJo8eXJ069Yt64iCMWPGbLbrDkBpE0sCoEIqLCzcbNuta6+9drup3AEDBmT9P9ErVqyIf//732VSIwCUlk6dOkXXrl09OQLALuuYY44pUVggIqJq1apxySWXZPW99NJLpVkWAFQYXbp0iR49emT1TZ48OUfVAEniX6MAqJDGjx8fCxcuzLQ7duwY/fr1K9bcM888M6v99NNPl2JlAAAAlJeiT1UuXrw4Vq9enaNqAKBsderUKau9aNGiHFUCJInAAAAV0siRI7PagwYNKvaZX4MGDcpqjx49OlatWlVqtQEAAFA+GjVqtFnf8uXLc1AJAJS9tWvXZrXz8vJyUwiQKAIDAFRIH3zwQVa7d+/exZ7bunXr2H333TPt9evXx6efflpKlQEAAFBe8vPzN+tr0qRJDioBgLKVTqfjnXfeyeorekQBQFkQGACgQip6PlfXrl1LNL/oeOd9AQAAVD5jx47Nardv3z5q1KiRo2oAoOw88MAD8eWXX2banTt3jp49e+awIiApBAYAqHDWrFkTs2fPzupr165didYoOn7KlCk7XRcAAADl64EHHshqH3300TmqBADKzkMPPRRDhw7NtKtUqRJ33313sY9oBdgZ1XJdAAAUtWjRokin05l29erVo3nz5iVao02bNlntBQsWlEptAAAAlI/nn38+xowZk9U3ZMiQ3BQDADvh888/z3pAasOGDbF06dL4+OOP45lnnsk6TrVGjRrxl7/8JQYMGJCLUoEEEhgAoMJZuXJlVrtOnTolTtPWrVt3m2sCAABQcS1ZsiTOPvvsrL4TTjjB1swAVEr33HNP/P73v9/mmFQqFUceeWTcdNNNsc8++5RTZQACAwBUQEVv7teqVavEa9SuXXubawIAAFAxFRYWxqmnnhpz587N9DVs2DDuuuuuHFYFAGXrxBNPjF/84hfCAkC5q5LrAgCgqLVr12a1a9SoUeI1atasmdVes2bNTtUEAABA+bj44ovjhRdeyOr785//HO3atctRRQBQ9v7973/Hd77znejTp09MmzYt1+UACSIwAECFU3RHgfXr15d4jXXr1m1zTQAAACqeu+66K373u99l9V1yySVx8skn56giANh5d955Z6TT6czX6tWrY86cOfHcc8/FmWeembVb6tixY+PAAw+Md999N4cVA0kiMABAhVOvXr2sdtEdB4qj6I4CRdcEAACgYvnnP/8Zv/rVr7L6hgwZEr/97W9zUxAAlJHatWtH27Zt45hjjon77rsvPvzww9h3330zry9btixOOOGEWLZsWc5qBJJDYACACqfozf3Vq1dHOp0u0RqrVq3a5poAAABUHM8991ycccYZWf/t973vfS/uu+++SKVSOawMAMreHnvsEaNGjco6fic/Pz9uvfXWHFYFJIXAAAAVTtOmTbP+QWjDhg2xYMGCEq2Rn5+f1W7evHmp1AYAAEDpev311+PEE0+MgoKCTN+gQYPi0UcfjapVq+awMgAoP02bNo3hw4dn9f3tb3/LTTFAoggMAFDh1K5dO3bbbbesvtmzZ5dojaLjO3fuvNN1AQAAULomTJgQxx9/fNZRdL17946nnnoqatSokcPKAKD8ffe73816kOrLL7+MWbNm5bAiIAkEBgCokIre4P/0009LNH/y5MnbXA8AAIDc+vDDD+Ooo46KlStXZvr222+/eP7556Nu3bo5rAwAciMvLy8aN26c1Td//vwcVQMkhcAAABXSvvvum9UeP358sefOmzcvZs6cmWlXr149unbtWkqVAQAAsLOmTJkSgwYNiqVLl2b6unTpEi+99FI0bNgwh5UBQMVSvXr1XJcA7OIEBgCokI499tis9iuvvBLpdLpYc19++eWsdv/+/aNevXqlVhsAAAA7btasWTFw4MBYsGBBpq9Dhw4xatSoaNasWQ4rA4DcWrFiRSxZsiSrr0WLFjmqBkgKgQEAKqTevXtH06ZNM+3p06fH6NGjizX3/vvvz2oPHjy4NEsDAABgB82bNy8GDBgQc+fOzfS1adMmXn311WjTpk0OKwOA3Bs5cmTWQ1PNmjWLVq1a5bAiIAkEBgCokKpUqRJDhgzJ6hs+fPh2dxl49dVXY+zYsZl2/fr146STTiqLEgEAACiBJUuWxKBBg+KLL77I9DVr1ixGjRoVHTp0yGFlAJB7a9asiWHDhmX1HXvssVGlilt5QNnyf2UAqLAuvfTSrKME3njjjbj55pu3Oj4/Pz/OOuusrL5f/vKXWTsVAAAAUP5WrFgRRx55ZHzyySeZvry8vHj55ZejS5cuOawMAErXJZdcEu+8806J5ixZsiSOP/74+PzzzzN9VatWjQsuuKC0ywPYTCpd3AOhASAHbrrpprjiiiuy+s4999y46qqronXr1hERUVhYGP/5z3/il7/8ZcyePTszrnXr1vHJJ59EXl5eeZYMADtk3LhxsWbNms36J02aFBdddFGm3aJFi/j73/++xTVat24dXbt2LbMaAWBH9e/ff7Nj5q677rro1atXidfq0aNHNGrUqJQqA4DSte+++8akSZOiZ8+ecfLJJ8dhhx0W3bp1i+rVq2eNS6fTMWXKlBgxYkTcddddsWjRoqzXL7roorj11lvLs3QgoQQGAKjQCgsLY/DgwfHcc89l9VetWjXat28fDRs2jBkzZsSyZcuyXq9du3aMGjUqDjnkkHKsFgB23O677x6zZs3aqTXOOOOM+Nvf/lY6BQFAKUqlUqW21uuvvx79+vUrtfUAoDRtCgx8U40aNaJNmzaRl5cXNWrUiBUrVsScOXNixYoVW1zjjDPOiAceeMBxBEC5qJbrAgBgW6pUqRIjRoyIn/zkJ/HYY49l+jdu3BjTp0/f4pwmTZrE448/LiwAAAAAAOTc+vXrY8aMGdsd16BBg/jtb38b55xzTqmG7QC2RTQJgAqvVq1a8eijj8bjjz8e++6771bH1a1bN4YOHRqffvqpp00AAAAAgHL36KOPxs033xwDBw6MBg0abHd8KpWK7t27x6233hrTpk2Lc889V1gAKFeOJACg0pk2bVpMmDAh8vPzY/369ZGXlxddunSJQw45JGrVqpXr8gAAAAAAorCwMKZOnRrTpk2L2bNnx9dffx0bNmyI+vXrR8OGDWP33XeP/fffv1jBAoCyIjAAAAAAAAAAAAnkSAIAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAABIqHQ6Hc8++2z8+Mc/jj322CPq168fqVQq89WvX79clwgAAACUoWq5LgAAAAAof8uWLYsf/OAH8eqrr+a6FAAAACBH7DAAAABApbD77rtnPf2eSqWiU6dOsWHDhp1ea9myZaVfcAV38sknCwsAAABAwtlhAAAAgEpr+vTp8cADD8TZZ5+d61Iqleeffz5efvnlTLtevXpx3nnnxUEHHRT169fP9Ddq1CgX5QEAAADlRGAAAACASu3666+PM844I2rVqpXrUiqNhx9+OKv9n//8J/r375+jagAAAIBccSQBAAAAlVp+fn7ce++9uS6jUnnrrbcy3++5557CAgAAAJBQAgMAAABUejfddFOsXLky12VUCmvXro3Zs2dn2t26dcthNQAAAEAuCQwAAABQKfXu3Tvz/cKFC+POO+/MXTGVyPLly7PaDRo0yFElAAAAQK4JDAAAAFAp3XDDDZFKpTLt2267LZYuXZrDiiqHtWvXZrW/+TMEAAAAkqVargsAAACAHbHffvvF97///Xj88ccj4n9Pzt96663xm9/8plyuv3r16njzzTdjzpw5sXDhwqhVq1Y0b948unXrFvvss0+51LAj0ul0ma398ccfx+TJk2PevHmxcuXKaNGiRZx++ulRvXr1bc5bsGBBvP322zF//vxYvHhx1KtXL5o3bx49e/aMDh06lEpt6XQ6Pvzww5g8eXIsWLAgVq1aFU2bNo22bdvGoYceGvXq1SuV65TE/Pnz4/3334+ZM2fG119/HYWFhVGnTp1o3rx5dOzYMfbaa69SqSs/Pz/Gjx8fs2bNioKCgmjVqlXstdde0aNHj51at7CwMKZOnRqffPJJfPnll/H1119HzZo1o3HjxrHHHntEz549o2bNmjtd/yarVq2Kt956K/Lz82PhwoWxYcOGaNCgQXTo0CG6d+8ebdu23eG1y/IzuGTJknj//fdj2rRpsXz58igoKIg6depE06ZNo0OHDtGtW7do1KjRTl0DAABgR6XSZfkvBQAAAFBKdt9995g1a1amvXTp0pg3b17svffesXHjxoiIqFu3bnzxxRfRokWLEq+Vl5dXrDomTZoUw4YNi5deemmzp/U3adOmTfz0pz+NSy65JCc3oovq169fvPHGGyWa07dv3xg9enSmPXr06Ojfv3+mPWzYsLj22mujoKAg7r333vjzn/8cn3zyyWbrbO1nW1hYGH//+9/jD3/4Q7z33ntbDTJ06dIlLrnkkjj99NOjSpWSb5S4cOHCuOmmm+Kxxx6LefPmbXFMjRo14sgjj4zrr78+unfvXuJrlNSIESPijjvuiLfeemub46pWrRrdu3ePE044Ic4///xo3LjxFscV/f1u+llOmjQpLrnkkhg1atQWf76dOnWKq666KoYMGVLs2lesWBFPPfVUPP300zF69Oht7upRs2bNOO644+Lyyy+P/fffv9jXKOqFF16I2267Ld58881Yv379Vsd16dIlTj755Pj5z38erVq12u66Zf0ZfPXVV+Pmm2+OV199NQoLC7c6LpVKxbe//e0YPHhwnHfeedGuXbtiXwMAAGBnCQwAAABQKWztJv+QIUPioYceyvT/4he/iN///vc7tNa2pNPpuOyyy+K2227b5s2/b2rZsmWMGDEivvOd7xRrfFkpq8DAL3/5yzj++OPjzTff3Oo6W/rZTp06NU488cSYNGlSses5+OCD4z//+U80a9as2HPuv//+uOCCC2LFihXFGl+lSpUYNmxYXHPNNcW+RkmsW7cufvjDH8ZTTz1V4rmjRo2KgQMHbvG1LQUGHn300TjjjDNiw4YN2137uOOOixEjRhRrN4CmTZvG4sWLi194/O+G+A033BBXXHFFiebNmzcvTjnllBgzZkyJ5p1xxhnxt7/9bZtjyvIzmE6n4xe/+EXcfffdxV57k7/+9a9x1llnlXgeAADAjip5NB8AAAAqkGHDhmVtef/nP/855syZU6rXSKfTMWTIkLjllls2Cws0bdo09t9//+jSpUvUqlUr67X58+fH4YcfHi+99FKp1lMRFBQUbBYWaNSoUXTv3j26d+8eDRs23OK8CRMmRO/evTe7UVu1atXMNvZdu3bd7Gf59ttvR69evWLhwoXFqu/qq6+Os846a7OwQIMGDaJbt27Rs2fP2H333bNeKywszAQhysJZZ521xbBA8+bNY7/99ouDDz44unXrVqJQxJa8/vrrcfrpp2fCApt+tgcccEC0bt16s/HPPvtsfP/734+CgoLtrl10V41UKhXt2rWL7t27Z+qvU6dO1ph0Oh1XXnllXHfddcV+Dx999FH07Nlzi2GBRo0aRbdu3eLAAw+MPffcc7tHXhRV1p/Ba665ZothgcaNG8c+++wTBx98cOy9997F2gUBAACgrAkMAAAAUKl16NAhfvazn2Xa69atK9GNyeK4++674+GHH87qO/TQQ2PcuHGxYMGCeO+99+LTTz+NhQsXxl//+tesrePXrFkTP/rRj+LLL78s1ZpK4vbbb49Ro0bFqFGj4u9//3vWa4cffnjmtW9+3X777dtc87777suEBQYOHBjjxo2LRYsWxaRJk2LSpEmxdOnSGDVqVNSuXTszZ/78+XH88cfHokWLMn3du3ePRx99NJYtWxZTp06NCRMmxCeffBJLly6Nf/3rX9GpU6fM2C+++CKGDBmy1a3jN3nwwQfjhhtuyLRTqVScfvrp8c4778TSpUvj448/jgkTJsSMGTMiPz8/Lr/88qybznfddVf8+9//3uY1Suqdd97J+tlXq1YtLr/88pg5c2Z89dVX8f7778dbb70VH3/8cSxYsCDmz58fI0aMiNNPPz3rZ1gcP/nJT6KgoCBq1KgR1157bcybNy+mTp0a77zzTuTn58ekSZPi2GOPzZozcuTI7f7ON+ncuXNcffXVMX78+Fi5cmXMnj07Jk2alKl/xYoV8dZbb8Upp5ySNe+6666Ld955Z7vrL1u2LAYPHhxz587N9FWpUiV++tOfxrvvvhuLFy+Ojz/+OCZOnBiff/55fP311zF27Nj41a9+FU2bNt3m2mX9GczPz4+bb745q+/ss8+OTz/9NBYvXhwffPBBvPXWW/Hhhx/Gl19+GUuWLInnnnsuzjnnnK2GbAAAAMpUGgAAACqB9u3bpyMi87V06dLMa19++WW6du3amdeqVauW/vzzz3doraLmzJmTtXZEpM8444x0YWHhVufMmDEj3aZNm6w5gwcP3oF3XfpmzJix2Xspjtdffz1r3qavX/3qV8W+9pFHHpk19+c//3l6/fr125yzdOnSdO/evbPmPfnkk1sd/8UXX6Tr1KmTGVu7du30888/v93a3njjjazfc/PmzdNr1qwp9nvbnosvvjjrPTzwwAPFnrto0aL0ggULtvp63759N/u91KxZM/3qq69uc90LLrgga07t2rXTs2bN2uac119/vdh1p9Pp9EMPPZR1jZNOOmm7c0455ZSsOQ0aNEi/9tprxbreqlWr0m+99dZWXy/rz+Af//jHrHHXXHNNsepOp9PpFStWpGfPnl3s8QAAAKXBDgMAAABUeq1atYrzzjsv0y4oKIhhw4aVytr33HNPrFmzJtPeZ5994r777otUKrXVObvvvnuMGDEia8x//vOfmDp1aqnUVFH07t07fve73xVr7Ntvvx0vvvhipn3UUUfFn/70p+1uJ5+XlxdPPPFE1K9fP9O3rSfhb7nllli9enWm/cADD8RRRx213fr69OkTt912W6a9YMGCzXZj2Bmff/555vt69erF6aefXuy5TZo0KfExBTfeeGMcdthh2xxz++23R69evTLtNWvWxJ/+9KdtzunXr1+J6jj99NPj1FNPzbSffPLJWL58+VbHf/bZZ/Gvf/0r006lUvHvf/87+vfvX6zr1alTJw4++OAtvlYen8Fv/p4jIoYOHVqsuiP+97lo165dsccDAACUBoEBAAAAdgmXXXZZ1g29f/3rX/HRRx/t1JrpdDruv//+rL7bbrstqlWrtt25vXr1ipNPPjlrrfvuu2+n6qlorrvuum0GJ77pzjvvzGrfcccdxZ7bsmXLOOusszLtcePGxVdffbXZuCVLlmQdHdGrV6/NtsXflp/97GfRvHnzTPuJJ54o9tzt+WbopEqVKlGlStn9k0ybNm3iF7/4xXbHpVKpzbbPf/DBB7d75ENJfTMwUFBQsM1jCe66666s65966qlxxBFHlEod5fEZ/ObvOSK2G0YAAADINYEBAAAAdglNmjSJX//615l2YWFhXH311Tu15meffRYLFizItHfbbbcYMGBAsef/9Kc/zWqPGTNmp+qpSFq0aLHdJ9g3KSwszHqyu2fPnvHtb3+7RNc7/PDDs9pjx47dbMzo0aOzbtiedtppJbpG9erVs55kHz9+fBQWFpZoja1p3bp15vuvv/46nn322VJZd0tOOeWUYt+oPvTQQ6Njx46Z9vz582PKlCmlWk+HDh2y2v/973+3Ovbll1/Oahcn+FAc5fUZ/ObvOSJKdZcKAACAsiAwAAAAwC7j17/+dTRp0iTTfuaZZ2LixIk7vN6ECROy2v379y/2E8kR/9vm/pu7Efz3v/+N9evX73A9FckBBxxQ7J/FRx99lLUN/QEHHFDi6+22225Z7cmTJ282pugN3J29ztdffx35+fklXmNLBg0alNX+8Y9/HLfffnssW7asVNb/ppIeG9C3b9+sdnH+N1NYWBivvfZaXHjhhTFw4MBo37595OXlRdWqVSOVSmV9Fb0xv2jRoi2uOW/evPjiiy8y7ebNm+/Q73BLyuszWPT3fOGFF8ZVV10V8+fPL/H1AAAAyoPAAAAAALuMBg0axKWXXprVd+WVV+7werNmzcpqd+/evUTza9asGZ07d860161bt8VtzCujok+Nb0vRG6v33HPPZjeVt/fVrVu3rDWWLFmy3ev07NmzxNe59dZbt3udHXHiiSdG165dM+2VK1fGRRddFC1atIjDDz88fvvb38abb74Za9eu3elr7bXXXjs1fsaMGdsc/8wzz8Qee+wRAwYMiN/97nfx6quvxuzZs2P58uXF2pFhayGJb4YFIiJ69Oix3bWKq7w+g717984KDRQUFMSNN94Ybdq0iUMPPTSuvfbaePXVV2PFihWl9t4AAAB2hsAAAAAAu5Tzzz8/WrVqlWm/8sorMXr06B1aa+nSpVntpk2blniNonOKrllZNWjQoNhjFy9eXOrX/+bT4uV9nR1RvXr1ePbZZzd72n79+vUxatSouPzyy+PQQw+NvLy86N+/f9x55507HC755i4bOzJ+W7seXHHFFXHCCSdsN1SwLevWrdtif9Eb8M2bN9/haxRVnp+Nf/7zn3HwwQdn9RUWFsabb74Zw4cPj4EDB0bjxo2jV69eceONN8bMmTNLvTYAAIDiEhgAAABgl1K7du246qqrsvp2dJeBlStXZrXr1q1b4jWKztlVniyuXr16sceWxbb7W3qSvbyus6M6duwY77//fuaJ8y1Zt25djB49Oi644ILYbbfd4he/+EWJPzN16tQp0fiin9Gin/tNHnroobjpppuy+mrXrh2HH354XHXVVfGXv/wlnnzyyRg5cmSMGjUq8/X3v/+9WHUUfZ/16tUrwbvYtvL8bDRt2jTGjBkT99xzT+yxxx5bHFNQUBBvv/12XHXVVdGpU6c47bTTdpndRwAAgMql2vaHAAAAQOVy1llnxa233pp5cnf8+PExcuTIOOaYY0q0TtEblqtWrSpxLUXn1K9fv8RrVHZFb2D/8Ic/jJ/+9Kc7tWbr1q23e50HH3ww2rZtu1PX2WeffXZqflF16tSJK664Ii677LIYN25cvPbaazF69OiYMGFCrFmzJmvs+vXr4w9/+EO8/PLLMWbMmGI/cb969eoSfc6Kfka3dKN+/fr1mx338dOf/jRuueWW7e5oMGXKlGLVUbTmrQUXdkR5fQY3qV69epx77rlx7rnnxrvvvhuvvvpqjB49OsaPHx9ff/111tjCwsL4+9//ntkNpeguFAAAAGVJYAAAAIBdTo0aNeLaa6+NIUOGZPquuuqqOProoyOVShV7nUaNGmW1d2Rb80WLFm1zzSQoeixDXl5eDBw4sMyv07Vr1+jZs2epX6c0VKlSJQ499NA49NBDY9iwYbFhw4Z4991348UXX4x//vOfMW3atMzYKVOmxJAhQ+L5558v1tqLFi0qUWCg6Oc6Ly9vszGjR4/OegL+8MMPj/vvv79Y6xc9amBrGjdunNVesGBBseYVR3l9BrfkgAMOiAMOOCAuvfTSKCwsjEmTJsWLL74Y//rXv2LSpEmZcfPnz48f/OAHMWnSpKhSxaagAABA+fBfHwAAAOySTj311OjcuXOm/cEHH8Tjjz9eojXat2+f1f7mzb3iWLduXdbT1TVr1owWLVqUaI1dQYcOHbLa37wZXhmvUxaqV68evXr1iuHDh8fnn38ef/zjH7NuGr/wwgsxefLkYq318ccfl+jaH330UVa76M8xIuLtt9/Oag8dOrTY63/yySfFGld0+/733nuv2NfYnory2ahSpUrst99+cfnll8cHH3wQTzzxRNSuXTvz+scffxwvvfRSTmoDAACSSWAAAACAXVLVqlXjuuuuy+q75pprYuPGjcVe4+CDD85qjx49OtLpdLHnjx07NjZs2JBp77///lGjRo1iz99V9OzZM2tL+PHjx8fatWtL/Tr9+/fPar/22mulfo3ykEqlYujQofGjH/0oq//NN98s1vw33nijRNcbM2ZMVntLuzJ8c3eBiCjRtvnF/T20bNky9txzz0x7wYIF8e677xb7OttSXp/Bkvre974XF154YVZfcX/PAAAApUFgAAAAgF3WD37wg9hvv/0y7c8++yweeeSRYs//9re/nbUjwKxZs+L1118v9vwHHnggq923b99iz92V1KhRIw477LBMe9WqVfHggw+W+nUGDhwY1ar9/9MXH3vssR06RqKiOOSQQ7LaRY+32JrHHnssK6iyLWPHjo3p06dn2i1bttxiGKBoUGb9+vXFWv+rr76KJ598slhjIyKOPPLIrPZdd91V7LnbUl6fwR2xo79nAACA0iAwAAAAwC4rlUrFDTfckNU3fPjwYt9MTaVSceaZZ2b1XXzxxcXapWDixInx2GOPZa111llnFeu6u6KLL744qz1s2LCYPXt2qV6jRYsWcdppp2Xaq1ativPOO69Ur1Geit44btSoUbHm5efnF+tGezqdjksvvTSrb8iQIZFKpTYb27Jly6x2cZ+C/7//+79Yt25dscZuGv/Noxj+/ve/x8svv1zs+dtSHp/BHbGjv2cAAIDSIDAAAADALu3oo4/OeoJ35syZ8eWXXxZ7/rnnnpt1xvj7778f55xzzjaPJpg9e3b84Ac/yBozePDg6NSp01bn9OvXL1KpVObr2muvLXaNlUGfPn3iiCOOyLQXLlwYhx9+eHz22WfFXqOwsDCefvrpzW5yf9NVV12VtfX8v/71rzj77LOL/UR8RMSSJUvihhtuiGeffbbYc7bnxz/+cYmOCli6dGncd999WX09evQo9vwrr7xyu7thXHjhhfHWW29l2rVq1Ypzzjlni2N79+6d1f7tb3+73Sfhr7rqqhgxYkQxK/6fPffcM+sohnQ6HSeeeGKMHj26WPNXrVoVb7/99hZfK4/P4HnnnRfPPvtssY8uWbdu3WbhjpL8ngEAAHaWwAAAAAC7vBtvvHGH57Zt2zZuueWWrL777rsvDjvssM1uTK5atSruv//+6NGjR8yZMyfT37hx4/jjH/+4wzXsKh5++OFo165dpj1lypTo0aNH/OpXv4pJkyZt8Sbr0qVL45VXXokLLrggdt999/jud78bEyZM2Oo1OnbsGPfff39W31/+8pfYe++9469//Wt89dVXm81Jp9PxxRdfxCOPPBLf+973om3btnH11VeX6nEGI0eOjH79+kXXrl1j2LBh8dZbb8Xq1as3G7dmzZoYMWJEHHTQQTFr1qxM/z777BMHHnhgsa7Vvn37WLduXRx55JExfPjwWLhwYdbrH330URx//PFxxx13ZPVfc8010b59+y2u2bdv36zX5syZE4ccckiMGjUq6/eWTqdj/PjxMWjQoMz/7rp06VKsuje5++67o2PHjpn2119/HQMHDoyzzjor3n///c0+J2vXro0333wzLrjggmjfvn386U9/2uraZf0ZHDduXBx//PHRoUOHuOiii2L06NHx9ddfbzZuw4YN8eKLL8YhhxwS77zzTqa/ZcuWceyxx279hwMAAFDKUuniRp4BAAAgh3bfffesG6hLly6NvLy8Ys8//PDDY9SoUVt8bXtrpdPpOOOMM+KRRx7Z7LVmzZpFu3btYu3atTFjxoxYs2ZN1uu1a9eOp556KuvJ5i3p169f1hPow4YNK5NdBmbOnBkdOnTItM8444z429/+tt15o0ePjv79++90fR999FEcc8wxWYGKTRo2bBht2rSJ+vXrx8qVK2PJkiUxb968zcb17dt3u0+c/+53v4uLL744CgsLN3utXbt20bRp06hWrVosW7Ys5s+fHytWrNhs3IMPPhhDhgwp9nvblry8vFi+fHlWX9WqVaNt27bRuHHjqFGjRixbtiymT5++2ZEZderUibFjx8b++++/xbWLfnZee+21OPzww6OgoCAiIqpVqxYdOnSIhg0bxrx58yI/P3+zNY444oh49tlno3r16lt9DyNGjIiTTjpps/5GjRpFx44dY+PGjTF79uxYsmRJ5rUWLVrEiBEjok+fPpm+4nzmPvnkkzjyyCNj7ty5m73WuHHjaNOmTdSuXTuWLl0aM2fOzPqZbW/9svwM7rvvvjFp0qSsvlQqFW3atIkmTZpE7dq14+uvv47p06fH2rVrs8ZVrVo1nnnmmTjmmGO2WjsAAEBpq5brAgAAAKA83HjjjVsNDGxPKpWKhx56KFq2bBm333571k3ohQsXbvYE9yYtW7aMESNGxHe+850duu6uaO+994733nsvTjvttHjppZeyXlu+fPlmN9W3ZLfddtvumF//+tfRrVu3+MlPfrLZDd85c+Zs8WbxN9WsWTOaN2++3evsjI0bN8asWbOygjBFtWnTJkaMGLHVsMCW9O/fPx555JE444wzYv369VFQUBBTp07d6vijjz46Hn/88W2GBSIiTjzxxLjxxhvjqquuynoSf+nSpfHee+9tNr5du3bx/PPPR7169Ypd+ybdunWLCRMmxIknnhjjx4/Pem3JkiVZoYSSKq/P4CbpdDrmzp27xfDDJo0aNYoHH3xQWAAAACh3jiQAAAAgEQ488MA44YQTdnh+KpWKW265Jd5///04/vjjo2bNmlsd27p167j66qtj6tSpwgJb0KxZs3jxxRdjzJgxcdxxx0XdunW3OT6VSsV+++0Xl112WXz44Yfx8MMPF+s6RxxxREyfPj3uuuuu6N69e6RSqW2Or1evXhxzzDFx7733xrx58+Loo48u9nvanokTJ8Ytt9wSAwYM2O77jYjYY4894vrrr48pU6ZEr169Sny9U045JSZOnBiDBg3a6piOHTvGAw88ECNHjozatWsXa90rrrgiRo4cGfvss89WxzRo0CAuvPDC+Oijj2KvvfYqce2btG7dOsaNGxdPPvlkHHLIIVG1atWtjk2lUrHvvvvGzTffHLfddtt21y6rz+Czzz4bd999dxxzzDHF2gGldevWcfHFF8fnn38egwcP3u54AACA0uZIAgAAANgBq1evjjfffDNmz54dixYtyjyR3q1bt9h3331zXV6lsmHDhpg4cWLMmDEjFi1aFKtWrYq6detGo0aN4lvf+lZ07do1GjZsuNPXWbhwYUyYMCHmz58fixcvjsLCwmjQoEG0bNkyunTpEnvuued2n7IvDRs3bozJkyfH1KlTIz8/P3McQv369aNNmzax7777Zh0bsT1FjyQo+k89c+fOjXHjxsXs2bOjoKAgWrVqFXvttVcccMABO/U+Jk+eHBMmTIgFCxZEQUFBNGnSJLp06RIHH3xw1KhRY6fW3pKlS5fG+PHjY968ebFo0aJIpVLRsGHD6NSpU+yzzz47tSNEWXwG0+l0fP755zF16tSYPXt2fP3117Fx48aoX79+tGzZMrp37x7f+ta3okoVz/MAAAC5IzAAAAAAUIltLzAAAAAAWyPCDAAAAAAAAAAJJDAAAAAAAAAAAAkkMAAAAAAAAAAACSQwAAAAAAAAAAD/r507KAIABGAYdvgXPVzAo4mCCegtSDAAAAAAAAAAAEGCAQAAAAAAAAAIEgwAAAAAAAAAQNDZtt8jAAAAAAAAAIC3PAwAAAAAAAAAQJBgAAAAAAAAAACCBAMAAAAAAAAAECQYAAAAAAAAAIAgwQAAAAAAAAAABAkGAAAAAAAAACBIMAAAAAAAAAAAQYIBAAAAAAAAAAgSDAAAAAAAAABAkGAAAAAAAAAAAIIEAwAAAAAAAAAQJBgAAAAAAAAAgCDBAAAAAAAAAAAECQYAAAAAAAAAIEgwAAAAAAAAAABBggEAAAAAAAAACBIMAAAAAAAAAECQYAAAAAAAAAAAggQDAAAAAAAAABAkGAAAAAAAAACAIMEAAAAAAAAAAAQJBgAAAAAAAAAgSDAAAAAAAAAAAEGCAQAAAAAAAAAIEgwAAAAAAAAAQJBgAAAAAAAAAACCBAMAAAAAAAAAECQYAAAAAAAAAICgC3IO3WXIKEQrAAAAAElFTkSuQmCC", + "image/png": "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", "text/plain": [ "
" ] @@ -1099,7 +1099,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 27, @@ -1108,7 +1108,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1180,7 +1180,7 @@ }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAACAwAAASYCAYAAACeDs3kAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvc2/+5QAAAAlwSFlzAAAuIwAALiMBeKU/dgAAyLJJREFUeJzs3XmYVmX9P/DPA8O+L4MKArKpqKCkiEvIoqhFbiiZW66JaaVfF8pMy19larmUhqmomfuKae4KKJYiroAiiDIgCDLsDDvM+f3hxdTDDDAzDDyM5/W6rrma83nOfd+fZ+YwXXXez30ySZIkAQAAAAAAAACkSo1cNwAAAAAAAAAAbHsCAwAAAAAAAACQQgIDAAAAAAAAAJBCAgMAAAAAAAAAkEICAwAAAAAAAACQQgIDAAAAAAAAAJBCAgMAAAAAAAAAkEICAwAAAAAAAACQQgIDAAAAAAAAAJBCAgMAAAAAAAAAkEICAwAAAAAAAACQQgIDAAAAAAAAAJBCAgMAAAAAAAAAkEICAwAAAAAAAACQQgIDAAAAAAAAAJBCAgMAAAAAAAAAkEICAwAAAAAAAACQQgIDAAAAAAAAAJBCAgMAAAAAAAAAkEICAwAAAAAAAACQQgIDAAAAAAAAAJBCAgMAAAAAAAAAkEICAwAAAAAAAACQQgIDAAAAAAAAAJBCAgMAAAAAAAAAkEICAwAAAAAAAACQQgIDAAAAAAAAAJBCAgMAAAAAAAAAkEICAwAAAAAAAACQQgIDAAAAVEu77LJLZDKZkq8zzjgj1y1RAYsXL45bb701Bg8eHF26dInmzZtHzZo1s36n++yzT67bBAAAgG+0vFw3AAAAAKTL3/72txg6dGgsXbo0160AAABAqgkMAAAA5EhBQUF06NCh3OfXrVs3mjRpEk2aNIldd9019t133+jdu3f069cvatSwgRzVw29/+9u46qqrct0GAAAAEAIDAAAA1cbKlStj5cqV8dVXX8WUKVPiX//6V0R8vTX/T37yk7jwwgsjL8//zONrffv2jddee63kuE+fPjF69OjcNRQR7777bvzmN78pVc9kMtG2bdto2rRpZDKZkvpuu+22DbsDAACA9PH/JAEAAFRzBQUFcemll8ZDDz0UDz30UHTp0iXXLUGZbrzxxiguLs6qXX755XHppZdG8+bNc9QVAAAApJfAAAAAwHakQYMG0blz5zJfW758ecybNy8WLlxY5uvvvvtuHHbYYfHvf/87dt55563ZJlRYcXFxPPPMM1m1wYMHxzXXXJOjjgAAAACBAQAAgO3Ifvvtt9lt4z/77LN4+OGH4+abb4558+ZlvTZjxowYPHhwvPnmm1uxy+1DQUFBrlugAiZNmhRLly7Nqp144ok56gYAAACIiKiR6wYAAAComE6dOsUVV1wREyZMiP3337/U62+99VY89thjOegMNm7GjBmlarvttlsOOgEAAADWExgAAACopnbcccf417/+FTvuuGOp126//fYcdAQbt3jx4lK1Bg0a5KATAAAAYD2BAQAAgGosPz8/hg4dWqr+xhtvxPLly3PQEZRt5cqVpWqZTCYHnQAAAADr5eW6AQAAALbMoEGD4uKLL86qrVq1Kj766KPo2bNnpeZct25dfPDBB/Hxxx/HV199FStXrowGDRpE9+7d49BDDy3XHIsWLYq333475syZE4WFhbFu3bpo1apVtGrVKnr27Bn5+fmV6m1rWrduXbz33nsxffr0KCwsjIULF0bjxo0jPz8/unTpEj169NhqN7lXr14d77zzTsycOTPmz58fCxcujDp16kTjxo2jU6dOsccee5S5mwSlLVq0KMaNGxefffZZLFq0KIqLi6N58+bxne98J9q3b1+uOXJ5LSxfvjzGjh1b8m9n2bJl0aJFi8jPz4999tknOnTosFXWrYwkSeLzzz+P8ePHx5w5c2LJkiWxdu3aqFevXjRs2DB23nnn2GWXXWLXXXeNvLyq/7+hvvzyyxg3blxMmzYtli1bFs2bN4/WrVtHz549o3Xr1lW61ooVK2LKlCnxySefxLx582LJkiWRl5cXzZo1i5YtW8Y+++wTu+yyS5WuuaH1f5sLCgpi3rx5sWDBgsjLy4vGjRvHLrvsEl27do127dpV2XozZsyI8ePHR2FhYRQWFkbNmjWjZcuW0bp16zjwwAOjYcOGVbbWmjVrYtKkSTFx4sRYsGBBLFmyJDKZTNSrVy+aNm0a7dq1i44dO271nzEAAKROAgAAQE5MmzYtiYisrz59+lRqrgYNGpSa69lnny113qhRo0qdN2rUqJLXp0+fnlxwwQVJs2bNSp1Xnv7WrFmT3HHHHcm3v/3tpGbNmmXOERFJJpNJ9ttvv+SGG25IVq5cWan33L59+6w5Tz/99ErNkyRJ8vLLLycnnHBC0rRp0432HBFJixYtkh/+8IfJpEmTKr3W/1q7dm3yj3/8IzniiCOS+vXrb3LtiEh222235MILL0zee++9Mufb3PjyfE2bNq1K3tvpp5++RX2U9fvccM727dtnvf7cc88lhx122EavvXvuuWezfefqWlizZk1y5513Jv37909q1669ybU7deqUXH755cn8+fOrZO3KmDx5cvKzn/0s2WGHHcr1+6xfv37Su3fv5Pe//30yefLkzc6/ud/1iBEjkgMPPHCj69WoUSPp3bt38uSTT1b6PRYXFydvvPFGMnTo0GT//fdP8vLyNvs+d9555+TCCy9Mpk+fXul1y/LPf/4zOeaYY5ImTZpstod27dol55xzTvL6669Xaq2ZM2cml1xySbL77rtvcp1atWolvXv3Th5++OGkuLi40u9t5MiRyYknnpjUq1evXNdSy5Ytk+9973vJHXfckRQWFlZ6XQAA4GsCAwAAADlSlYGB1q1bl5rrgQceKHXepgIDw4cP3+xN603198orryS77bZbhW8Mt2vXrlI39aoiMDB+/Pikf//+Fe65Zs2ayZAhQyoddkiSJHn88ceTzp07V3jt9V833HBDqTkrO9f/flXHwMDSpUuT448/frNzbiowkMtrYcSIEZW6Fho3bpzceuutlV63MoqLi5Nf/epXmw01bOprhx122Ow6G/tdL1u2LBk0aFCF1jvmmGMqfGN59OjRSdu2bSv9HvPy8pJf/epXybp16yrzYy4xatSopEePHpXu46c//Wm511q+fHly6aWXJnXr1q3wOt27d08mTJhQofe2YMGC5LjjjtuivxMnnnhiRX+kAADABmoEAAAA1d7ixYtL1Zo2bVru8X/84x/jnHPOieXLl1dq/XvuuSeOPPLImDx5coXHzpgxI44//vj44x//WKm1K+uZZ56JAw88MEaOHFnhsevWrYvbb789+vbtG3Pnzq3Q2OLi4rjsssvihBNOiKlTp1Z47fWWLFlS6bHfJMuWLYtDDz00nnjiiUrPkatrIUmS+PWvfx3HHXdcpa6FJUuWxE9+8pMYMmRIrFu3rsLjK+P000+P3/3ud7F69eptst7/WrVqVRx55JHx5JNPVmjcP//5zzj00ENj/vz55R4zbdq0+OKLLyraYom1a9fG7373uzjmmGNi7dq1lZrj5ptvjsMOOyzef//9SvdR3r8Tc+bMib59+8af/vSnWLlyZYXXGT9+fBx00EHx3HPPlev8hQsXRt++fWPEiBEVXgsAAKhaVf/wOAAAALap6dOnx7Jly0rV8/PzyzX+pZdeimuvvbbkuE6dOtGvX7/o27dv7LjjjpGXlxczZ86MsWPHRlFRUanx9913X5x11lml6plMJg488MD4zne+E23bto28vLyYNWtWvPzyyzFq1KisG5xJksTQoUMjk8nEpZdeWq6+t8SDDz4Yp512WhQXF2fVa9euHf37949evXpF27Zto0mTJlFUVBQFBQXx6quvxhtvvJF1/ltvvRWDBg2KUaNGRa1atcq19mmnnRYPPvhgma/ttddeMWDAgOjUqVO0bNky1qxZEwsWLIiPP/44xo0bF++//34kSbLRuffee++S76dOnZp1XTRo0CA6d+682f5q165drvexOe3atcvqZ8GCBaVuwHbt2nWj65X3OeznnntuvP322yXHrVu3joEDB0a3bt2iVatWsWTJkpg+fXo8/fTTZY7P5bXw4x//OG6//fZS9ebNm8eAAQNi3333jVatWkX9+vVj0aJF8dFHH8ULL7xQKphzxx13RNOmTeO6664r17qVde+998Z9991Xqp6fnx9HHHFEdOvWLVq3bh316tWLFStWxNKlS2PatGnx0UcfxZtvvhkLFy7covUvueSSGDNmTMlxy5YtY9CgQdG9e/do2bJlzJs3LyZMmBBPPvlkFBYWZo0dP358HHHEEfHmm2+W+/fzv3bcccfYd999o2vXrrHLLrtE48aNo379+rFs2bKYO3duTJgwIV544YVSoZF//etf8ctf/jKuv/76Cq33y1/+Mv7whz+U+Vrnzp3j8MMPj9122y3y8/MjSZJYuHBhTJkyJd555514++23KxRS+Oqrr+KAAw6I6dOnl3ptr732ij59+sSee+5ZEkKbO3duvPnmm/Hcc8/F0qVLS85dunRpHH/88fGf//wnevTosck1L7744hg/fnyp+q677hqHHXZY7L777tGiRYuoU6dOFBUVxaJFi2LKlCkxceLEGDt2bKxatarc7w8AANiM3G5wAAAAkF5V9UiCG2+8sdQ8tWvXToqKikqdW9YjCf73ee/HH398MmPGjI2utWLFiqzjTz/9NGnYsGGpOffaa69k7NixG53n448/Tg444IBS42rVqpWMGzeuXO+7so8kmDhxYqlHL+Tl5SWXXXZZMnfu3E2Off/995N99923VN+XXnppudb+4x//WOa22n379k3efvvtzY6fOXNmctNNNyUdO3ZMfv3rX2/y3D59+mzxtVWV7rnnnlLvu6KPP9hwm/r/vXbr1auX3Hzzzcnq1as3On7D6zeX18Ldd99damzz5s2T22+/vVSf/6u4uDh58sknk1atWpUa/8wzz5Rr7cra8LEJNWvWTK6//vpyPY5h7dq1yRtvvJGce+65SadOnTZ7/oa/6zp16iSZTCaJiKRGjRrJz3/+843+nFasWJH84he/SGrUqFHqZ/Sb3/ymXO/1nnvuSTp27Jj87ne/Sz788MNyjVm7dm1y//33JzvuuGPWmplMplz/vtd77LHHyvw7sc8++yQvvvjiZsfPmzcvufPOO5Pu3btv9u/iunXrynwUx0EHHZS89dZbmxy7cOHC5OKLLy75vaz/6tChQ7JkyZKNjpsxY0apMfn5+cnTTz+92feWJElSVFSUjBgxIhk4cGBy8sknl2sMAACwcQIDAAAAOVIVgYHCwsJSN6ciIunfv3+Z55cVGFj/9bOf/azC72HAgAGl5tlvv/2SRYsWbXbsihUryrxR1a1bt3KtXZnAwLp165K99tora1yDBg2SkSNHlmvNJEmSVatWlXrftWvXTr744otNjpswYULWDe71XxdddFGFn3O+du3aTQY7kiQdgYH//R2+9tprFZorl9fCtGnTSgUVdt11182O+18zZsxIdt5556w59txzz6S4uLjcc1TExIkTK33zfUPLli3b7Dkb+11HRHLbbbeVa53bbrut1NhatWolU6dO3ezYJUuWVPpnOX369KRdu3ZZ65500knlGjt37tykUaNGpfr+/ve/X65gxoYKCgo2+fp1111Xaq0LLrigQu+9rPDLddddt9Hzb7311lLnjx49utzr/a/yXEsAAMCm1QgAAACqpa+++iqOPvromDNnTqnXfvSjH1Vorv333z9uvPHGCo2ZOHFivPzyy1m1xo0bx1NPPRVNmjTZ7Pi6devGk08+GTvuuGNWfcKECfHSSy9VqJfyeuKJJ2LixIlZtXvuuSf69etX7jlq164djz32WLRs2bKktnr16s3+/K655ppSz5k/+eST46abbooaNSr2P89r1qwZbdu2rdCYb7Jrr702DjnkkAqNyeW18Mc//jGWL19ectygQYN44YUXYueddy732m3bto2HH344q/bRRx/FM888U+45KuLzzz8vVavo35n16tevX+k+zjjjjDjvvPPKde55550XZ5xxRlZtzZo1cdttt212bKNGjSKTyVSmxWjXrl0MGzYsq/bYY4/F4sWLNzv2pptuytrmPyKid+/e8dBDD0WdOnUq3Ev79u03+try5cvjj3/8Y1Zt4MCBceutt1bovZ955plxzjnnZNVuuummWL16dZnnb3gtdenSJfr06VPu9f7XllxLAADA1wQGAAAAqpnPP/88rr322ujevXu8+eabpV7v2bNnnHjiiRWa849//GPUrFmzQmNuvfXWUrVf/epX0aZNm3LP0aRJk7j22mvLNXdV2PAZ73379o3BgwdXeJ4mTZrEhRdemFUbMWLERs8vKCiIRx99NKuWn59frhuXbFqnTp3iggsuqPC4XF0LhYWFcc8992TVLrvssujQoUOF1z744IPj0EMPLffaW2LDm9gRES1atNgqa21MvXr1Sv3eNue6666LevXqZdXuueeeWLVqVVW2Vsp3vvOdrCDJ2rVrY+zYsZscU1RUFH/961+zarVr14777ruvwqGi8rj77rtj3rx5Jcc1atSIW265pVJzXXXVVVkhgzlz5pT5308Rpa+lbX0dAQAA2QQGAAAAtiPvvPNO7LPPPmV+7bbbbtGiRYvo1KlTXH755TF37txS49u0aROPPfZYhT4d2qVLlwp/OjsiSu0uUKdOnTj77LMrPM8PfvCDaN68eVZt1KhRpT6Nv6UKCgri3Xffzapt+KnYihg4cGCp+adPn17muc8++2yp93PeeedF48aNK70+XzvzzDMr/EnwXF8LK1as2Gprjx49utJzbUpZN3XfeOONrbLWxhxzzDHRqlWrCo1p1apVHHvssVm1BQsWxNtvv12FnZVWo0aN6NSpU1btrbfe2uSY1157LZYsWZJVO/HEEze5S8CWePzxx7OO+/fvX6ngSsTXO15069Ytq7axa3HDa2nChAnl2n0BAADYOvJy3QAAAAD/tWzZsvjwww8rNXafffaJhx9+uMI3l/r27VvhtebMmVNqW+l+/fqVuvFfHnXq1Imjjz46/v73v5fUioqK4sMPP4xvfetbFZ5vY1577bVStYMPPrjS85V1Y+39998v8+df1o2z0047rdJr818VeYTAerm8FjZcu3379hXalWNzaxcUFMSiRYuiadOmlZ6zLD179owaNWpEcXFxSe1HP/pRPPPMM7HnnntW6Vobs+GN//IaNGhQPPTQQ1m1t956K3r37l2heSZOnBjjxo2L8ePHx/Tp02PJkiWxdOnSje5WMHXq1KzjGTNmbHL+bfl3YtWqVaV2PNiSfwMRX1+L48ePLzl+//33yzyvV69eWcfLli2LH/zgB/HAAw9U6r9DAACALSMwAAAAUM21a9cuLrjggvi///u/qFWrVoXHV+am/HvvvVeqtt9++1V4nvV69uyZFRhYv0ZVBgb+/e9/l6pV9gbkxvzv9t7/a8OtufPz86NLly5VunYaZTKZ2GeffSo8LpfXwoZrz5s3r1LvYb2ioqIy167qwEDz5s3j6KOPjqeeeqqkNm3atNh7773jmGOOiZNOOikOP/zwrbprxr777lupcWX9Hdlwh4mNWbVqVdxyyy1xzz33xMcff1yp9ddbtGjRJl/f8O9EjRo14oADDtiiNTfm3XffjZUrV2bV7r777qzfb0VtGIjY2L+BI444InbaaaeYPXt2Se2FF16Ijh07ximnnBInnHBCfPvb367Uf58BAAAVJzAAAABQTdSpUycaN24cTZs2jV133TX23XffOOSQQ6Jfv35b9Hzrim7xHVH2jaCuXbtWuoc99tijXGtsiZkzZ5aqVXY3h42ZP39+mfUNHx+x4dbdVE7Dhg2jfv36FR6Xy2thw7W3ZFeRTa3duXPnKp0zIuJPf/pTvP7667FgwYKS2rp16+LJJ5+MJ598MmrWrBk9evSIAw88MHr27BmHHHJIlW2nn5eXV2qL//Lq2LFj1K5dO1avXl1SK+uRLhv697//Haeffnp89tlnlVp3Q5vbdv+rr77KOt5ll12iUaNGVbL2hsr6N/DFF1/EF198UWVrbOzfQL169eLWW2+NE044IZIkKakvXrw4hg0bFsOGDYv69evHgQceGL169YpevXpF7969o1mzZlXWGwAA8F8CAwAAANuRPn36bLVnkG9MZT4RvHDhwlK1LflEc1k3gv73pmRV2NjNq6q04bPpIyKWLl0aa9asyaq58VU1Kvtp9lxdCytWrCizvi3WrgqdOnWKV155JY4//viYNm1aqdfXrVsX77zzTrzzzjsltV122SUGDRoUp5xyyhbtGNKoUaPIZDKVHt+4ceOsENLmPu0/atSo+N73vhfLly+v9Job2vDvwIY2/Ju3Nf9O5OrfwHqDBg2K+++/P84999xYtmxZqdeXL18er776arz66qsR8fVuCz169IjBgwfHySefHG3btt1qfQMAQNpU/iMoAAAAfCPk5VU8S7506dJStQYNGlS6h7LGlrXGligr5LAtLFmypFStYcOGOejkm6cy125E7q6FXK1blXr06BETJ06M6667rlw3bQsKCuLGG2+MfffdNw477LD44IMPKrXulvx9KWv8pv6+LFy4ME488cRSYYEaNWrE4YcfHn/4wx/ihRdeiI8++ijmzZsXRUVFsW7dukiSJOurT58+Fepxw78VW/PvxPZwLZ588skxefLkOP/88ze7k0JxcXG8++678Ytf/CI6deoU55xzThQWFm6jTgEA4JvNDgMAAABUWFk3d8r6lGh5lTW2qrfirlevXqnaihUrom7dulW6zobK+hR8Wc+dZ9vJ1bVQ1rq9evWKt956a6uuW9Xq168fQ4cOjcsuuyzGjBkTL7/8crz++usxbty4TX6q/NVXX41evXrFHXfcEaeffnqF1tySvy9ljd/U35drrrmm1M3o/fbbLx588MHo0qVLudes6E4PjRs3ztplYGv+nSjrWrztttvivPPO22prlqVNmzbx17/+Nf70pz/FCy+8ECNHjowxY8bExIkTY926dWWOWbNmTdx1113x7LPPxrPPPrtFO1cAAAACAwAAAFRCWVtlb26L700pa2zz5s0rPV9ZWrZsWaq2YMGCaN26dZWus6FGjRpFrVq1srYj3x4+3ZtmuboWmjZtGnl5ebF27dqsdaurTCYThxxySBxyyCEREbF27dr44IMPYsyYMfHKK6/EqFGjSt00X716dZx99tnRoUOHknHlsXTp0kiSpNKPJdjw0/ubeoTKww8/nHXctm3beOWVV6JJkyYVWrOiv9sWLVpkjdmafyc29m8gV+rVqxfHHXdcHHfccRHxdVjirbfeijfeeCNeeOGFGDduXBQXF2eNmTNnTgwcODAmTpwYLVq0yEXbAADwjeCRBAAAAFRYfn5+qdqkSZMqPd/HH39cqlbWDa0tscMOO5SqTZ8+vUrX2Jgdd9wx63jChAnbZF3KlqtrIZPJlPq3M2vWrKwAQXWWl5cX++23X/zf//1fPPvsszF37tz429/+ViqIsW7durjssssqNPfatWvj888/r1Rf06ZNi9WrV2fVWrVqVea5kyZNipkzZ2bVfvazn1U4LLBmzZpS82zOhn8nCgoKqvzRLOvl8u9heTRs2DAOO+yw+M1vfhNvvfVWTJ8+PS6//PJSu4DMmTMnrr/++hx1CQAA3wwCAwAAAFRYWVtAv/POO5Web9y4caVq++67b6XnK0uvXr1K1V5//fUqXWNjDjzwwKzjwsLCmDJlyjZZm9JyeS1suPby5cvj3Xff3SZrb2sNGzaMIUOGxHvvvRdt27bNeu3tt9+OL774okLzVfbnVNa4jf19Kaun3r17V3jN999/P1auXFmhMRv+nSguLo4333yzwmuXx3777Rc1amT/34Lb6t9AZey8885xzTXXxEsvvRQ1a9bMeu2JJ57IUVcAAPDNIDAAAABAhe2www7RsWPHrNqoUaMqtaX16tWr4+mnn86qNWzYMLp3775FPW5owIABpWpPPvlkla6xMX379i1Vu++++7bqmnl52U8h3NjzwNMol9dCLtfOlR122CEuueSSUvWK7rTx1FNPVWr9sn6+BxxwQJnnzps3r1StMo9HeeSRRyo8Zlv+nWjevHmp0MQnn3xS5m4v25PevXvHUUcdlVX77LPPYvny5TnqCAAAqj+BAQAAACrliCOOyDpetWpV3HPPPRWe55FHHon58+dn1fr371/qU6Rbao899oguXbpk1d5+++0YOXJkla5Tlu9973ulbuDffvvtpZ6rXpUaNWqUdVxUVLTV1qpucnktDBw4sNS1/be//S0WLVq01dfOpd13371UbfHixRWa46mnnorCwsIKjSksLIx//vOfWbXmzZvH/vvvX+b5DRo0KFUrK0SwKYsWLYq77767QmMiIvr06RPNmjXLqj366KNb7VEBxxxzTKnatddeu1XWqkpVcS0BAAD/JTAAAABApZx//vmlar/97W9j9uzZ5Z5jyZIl8fOf/7xU/ac//ekW9bYxV1xxRanaOeecU6mdESqibdu2cfLJJ2fVCgsL48c//vFWW3PDG4/Tpk2LJEm22nrVTa6uhfbt28dpp52WVVuyZEmceeaZ3+jfT1l/F/Lz8ys0x4oVK+IXv/hFhcb84he/KPXp8zPPPDPq1KlT5vk77bRTqdpLL71UoTV/8pOfVCoAUr9+/VJ/+1avXh2nnXZaFBcXV3i+zfnJT34STZs2zardf//9MWLEiCpfqypteC1lMplo2bJljroBAIDqT2AAAACAStlrr73i8MMPz6otXrw4jjvuuHJ9mn3VqlVxwgknlLr507179zjssMOqtNf1Tj311FKfTp02bVp897vfjS+//LJScy5ZsiSuv/76uP/++zd53uWXXx61atXKqj344INx8cUXV/hG8bp16zb7/Pdu3bplHS9evDj+85//VGidb7JcXgtXXXVVqRvWTz31VJx77rmxatWqSq1dUFAQP/3pT2PixImVGr85f//73+OJJ56o1KMt1qxZE8OGDcuq1ahRI/baa68Kz3X33XfH8OHDy3XunXfeWeqT/rVq1dpkUKdHjx7RsGHDrNqf//znmDlzZrnW/H//7//FAw88UK5zy3LhhReWuok/ZsyYOOmkkyp1bWxqd4ImTZrEZZddllVLkiR++MMfltqVoSKef/75Tf6Mf/Ob38TYsWMrNfcXX3xRKtDQtWvXUn9bAQCA8hMYAAAAoNKGDRtW6uba2LFjo3fv3vHee+9tdNwnn3wS/fv3j5dffjmrXqtWrbjrrru2Sq8RETVr1ozHHnus1Hb9Y8eOjR49esSwYcNi5cqVm51n7dq18corr8S5554b7dq1i5///OcxZ86cTY7Zfffd44YbbihVv+mmm+LQQw+Nd955Z7Przp49O/785z/Hrrvuutmf00EHHVSqdtZZZ8WoUaO2yqeVq5tcXgsdOnSI22+/vVR9+PDhccABB8S//vWvcoVIli5dGg8++GAce+yx0blz57j11lvL1XNlfPDBB3HCCSdE586d41e/+tUm/33/r+nTp8fRRx8d48aNy6ofdthhseOOO5Z7/Tp16kQmk4mIiCFDhsQVV1yx0Rvoq1atiiuuuCLOO++8Uq9dccUV0alTp42uU6tWrTj22GOzagsXLoxDDz00xo8fv9FxX375ZZx88snx61//uqTWuHHjTb2lMjVv3jzuvffekve63qOPPhoHHnhgvPLKK5udY+HChXHXXXfF3nvvndVPWYYOHVoqoFVUVBTHHXdcnHvuufH555+Xq+9PP/00rrnmmthrr73iu9/9bowZM2aj5z711FNxwAEHxAEHHBB//vOfY8aMGeVa4z//+U/079+/1KNcTj311HKNBwAAypa3+VMAAACgbJ06dYphw4bFD3/4w6z6Bx98ED179oyDDz44jjzyyGjbtm3UrFkzZs2aFa+88kqMHDky1q5dW2q+a665Jvbbb7+t2vNee+0VDzzwQAwaNCirh7lz58YFF1wQV1xxRfTp0yd69eoVrVq1iiZNmsSyZcti0aJFMWPGjHj33Xfj/fffL3XTqjx++tOfxttvv13qE+ijRo2Knj17Rvfu3WPAgAHRsWPHaNmyZaxZsyYWLlwYkyZNinfeeSfeeeedct/s79WrV+yxxx7x8ccfl9SmTJkS/fv3j3r16sXOO+8c9evXLzXuueeei9atW1f4vVVHubwWTj/99Jg0aVJcd911WfUPPvggjjrqqGjXrl3069cv9t5772jRokXUr18/Fi9eHIsWLYopU6bEu+++GxMmTIjVq1dv8c+hIgoKCuL3v/99/P73v4+ddtopvvWtb8U+++wTrVu3jqZNm0bt2rWjqKgoCgoK4j//+U+MHj061qxZkzVHnTp1ygzPbMqOO+4YAwcOjGHDhkVxcXFcc801ceedd8bxxx8f3bt3jxYtWsT8+fNj/Pjx8eSTT8bcuXNLzbHvvvvGL3/5y82udeWVV8YjjzyS1feUKVOiR48eceSRR0b//v1j5513jrVr18bs2bNj9OjR8corr2QFGM4666z47LPP4rXXXqvQ+4yIOProo+OKK66I3/3ud1n1999/PwYMGBBdunSJww8/PHbbbbfIz8+PJElKrov33nsv3nzzzZLee/Toscm18vLy4tFHH42DDjooPvnkk5J6kiQlOzTst99+ccghh0SHDh2iefPmUVxcHIsWLYrCwsIYP358vPvuu1FQUFDh9zl27NgYO3ZsXHTRRbHbbrvFPvvsE926dYv8/PySXRbWv69Ro0aVGVLp0qVLXHjhhRVeGwAA+C+BAQAAALbIaaedFmvWrIkhQ4Zk3XQtLi6OMWPGbPKTputlMpm49tpr49JLL92arZY46qij4tVXX40TTzyx1KfBFy1aFP/85z+3aEvuTbn33ntjhx12KPOG6fjx4zf5KeaKuuWWW+Lwww8vtY38ihUr4tNPPy1zzLa+AZ1rubwWrr322mjbtm1cfPHFpX7uM2bMiHvvvXerrFtVZs+eHc8++2w8++yz5R5Tp06duO+++yr1OIIbb7wxxo8fH2+88UZERBQWFsbf/va3co3t3r17vPjii+Xaun7XXXeNW265pdQOBcXFxfHcc8/Fc889t8nx/fv3j2HDhsURRxxRrt7K8tvf/jaaN28el156aamQ0KeffrrRf7+V0axZs/jPf/4Tp512Wqnf5bp160pu7G9NkydPjsmTJ8cjjzxS7jE777xzjBgxoszgEwAAUH4eSQAAAMAWO+uss+L555+PXXfdtcJj27ZtG48//ngMHTp0K3S2cYcccki89957ceqpp0bNmjUrPU8mk4l+/fpF7969y3V+jRo14k9/+lM8/PDDscsuu1R6zfz8/M2e179//xgxYkTssMMOlVonLXJ1LUREXHDBBTFmzJj49re/Xel1IyLq1asXP/jBD6Jdu3ZbNM/GtGrVqtQ2+RW11157xciRI2Pw4MGVGl+nTp144YUX4phjjqnQuKOPPjpeffXVaNGiRbnHDBkyJIYNGxa1a9eu0FpnnXVWPPfcc1GnTp0KjSvL//3f/8WLL74Y3bp1q/Qc5f2336xZs3jmmWfi5ptv3uK/F+3bt48zzzxzo69X5FEUG3PUUUfFW2+9FXvuuecWzwUAAGknMAAAAECVOOyww+Kjjz6K22+/PQ4++OBN3njNZDKx7777xg033BBTpkyJQYMGbcNO/2unnXaK++67Lz799NO46KKLomvXruUa16hRo/je974XN998c0ybNi1GjhwZvXr1qtDaJ554YkyZMiVuv/326NOnT7luTHbv3j0uv/zymDx5clxwwQXlWueoo46KgoKCePTRR+Pss8+O/fffP3bcccdo0KDBFt8A/ibJ5bWw//77l+zGccopp5T7kRCtW7eO0047Lf7xj3/E7Nmz46GHHopWrVpVaO3y+uUvfxmzZ8+Ou+66K0455ZTo0KFDucbVqlUrvvOd78QDDzwQH3zwQRx00EFb1EeDBg3iqaeeisceeyx69uy50fMymUx8+9vfjieeeCL++c9/RsuWLSu81o9//ON477334sQTT9zkzgS1a9eOo446Kl5//fW46667qiQssN5hhx0WH374YTz88MNx5JFHluvT9Lvuumv87Gc/i/fee6/UIy82JZPJxIUXXhgFBQUxbNiw6NevX9StW3ez42rUqBHf+ta3YujQoTF69OiYNm1aXHLJJRs9/4UXXoiPP/44/vSnP8X3vve9cv9umjRpEqeffnq89tpr8fTTT0ebNm3K/d4AAICNyyRJkuS6CQAAAL55Fi1aFG+99VZ89dVXUVhYGOvWrYv8/PzYYYcdomfPnlt8Y7Nt27Yxc+bMkuOzzz47hg8fvqVtx1dffRXvvfdezJs3L+bPnx9FRUXRoEGDaNy4cbRp0yZ23333aN++fZXfbF+2bFmMHTs2Zs+eHfPmzYulS5dGgwYNomnTptG5c+fYY489KvQJabZcrq6FiIgpU6bEpEmTYv78+TF//vxYs2ZNNGrUKBo3bhwdOnSI3XfffauFA8pr/vz58emnn8bnn38e8+bNi6Kiooj4OkTRvHnz6Nq1a+y5556VuoF+xhlnZD2SoX379lFQUFDqvJkzZ8a4ceOioKAgli1bFs2bN4+ddtop9t9//yq9obxs2bL4z3/+E59//nksWLAgMplMNG/ePLp06RI9e/aMhg0bVtlam7Jq1aoYN25czJw5MwoLC2Px4sVRr169aNKkSXTs2DH22GOPKvkE//+u984778SsWbNi/vz5sXDhwsjLy4tGjRpFy5YtY9ddd43ddtutXMGCTZkxY0Z89tlnUVBQEIsWLYply5ZFrVq1onHjxtGqVavo1q1bdO7cOWrU8NknAACoagIDAAAAVEstW7aM+fPnlxxfdNFFcdNNN+WwI6CqlDcwAAAAwJYRywUAAKDaWb16dSxcuDCr1qRJkxx1AwAAAFA9CQwAAABQ7UyaNCmKi4uzarvvvnuOugEAAACongQGAAAAqHYefvjhUrUePXrkoBMAAACA6isv1w0AAABAeS1fvjzuvPPOuOGGG7Lqe+21V+y222456goAAACgehIYAAAAYLv2t7/9Lf72t79FUVFRTJ8+PdauXVvqnJ/97Gc56AwAAACgehMYAAAAYLs2Z86c+PDDDzf6+mGHHRbnnHPONuwIAAAA4JuhRq4bAAAAgMo66aST4umnn45MJpPrVgAAAACqHTsMAAAAUC3UqlUrmjZtGu3atYvevXvHaaedFt/61rdy3RYAAABAtZVJkiTJdRMAAAAAAAAAwLblkQQAAAAAAAAAkEICAwAAAAAAAACQQgIDAAAAAAAAAJBCAgMAAAAAAAAAkEICAwAAAAAAAACQQnm5biDtkiSJgoKCmDBhQsycOTMWLVoUderUiWbNmkWXLl2iZ8+eUbdu3Vy3CQAAAAAAAMA3jMBADixcuDCeeuqpeOGFF2LkyJExb968jZ5bq1atGDhwYFx00UXRp0+fCq1TUFAQHTp02KJekyTZovEAAAAAAAAAbJ8yiTvC29QFF1wQw4cPj9WrV1d47A9/+MO45ZZbonHjxuU6X2AAAAAAAAAAgI2xw8A2Nnbs2DLDAjVr1oyddtopdthhh1izZk1Mnz49Fi9enHXOP/7xj/jkk0/i1VdfjYYNG26rlgEAAAAAAAD4BhIYyKGmTZvGySefHAMHDozevXtHo0aNSl5bt25djBkzJq666qoYM2ZMSf3tt9+OM844Ix5//PEKr3f44YfHZZddViW9AwAAAAAAAFC9eSTBNrbffvvF/Pnz41e/+lWcfPLJUa9evU2ev27dujj//PPjjjvuyKqPHDky+vXrt8mxGz6S4PTTT4+///3vle4dAAAAAAAAgG8OOwxsY1dffXUMGDAgateuXa7za9asGcOGDYv33nsv3nnnnZL68OHDNxsY+KZYtGhRvPbaayXHbdu2jTp16uSwIwAAAAAAAICqsWrVqvjiiy9Kjvv06RNNmzbdJmsLDGxjAwcOrPCYmjVrxtChQ+P73/9+Se3FF1+syra2a6+99loce+yxuW4DAAAAAAAAYKt76qmn4phjjtkma9XYJquwxXr37p11PH/+/Fi+fHmOugEAAAAAAACguhMYqCaaNWtWqrZ48eIcdAIAAAAAAADAN4FHElQTs2bNKlVr0aJFDjrZ9tq2bZt1/NRTT0Xnzp1z1A0AAAAAAABA1Zk6dWrWI9o3vD+6NQkMVBNjxozJOm7fvn3Url27UnN98cUXMWfOnFi5cmU0b948WrVqFfn5+VXR5lZRp06drOPOnTvHnnvumaNuAAAAAAAAALaeDe+Pbk0CA9XE3XffnXX83e9+t8JzvPTSS9G6deuYPXt2qdd22WWX6Nu3b5x77rlx4IEHVrpPAAAAAAAAAKoHgYFq4LnnnovXX389q3bGGWdUeJ6yggLrFRQUxN///vf4+9//Hv3794977rkn2rVrV+E1Nmfu3LlRWFhYoTFTp06t8j4AAAAAAAAA0k5gYDu3YMGCGDJkSFbt2GOPjf3333+rrTly5Mjo0aNHjBgxIg455JAqnXvYsGFx9dVXV+mcAAAAAAAAAFRcjVw3wMYVFxfHqaeeGjNnziypNWnSJP7yl79UaJ6dd945fvzjH8djjz0WkyZNikWLFsWaNWti3rx5MW7cuLj++uujY8eOWWMWLFgQxxxzTHzyySdV8l4AAAAAAAAA2L7YYWA7dtlll8Xzzz+fVbv99tujbdu25RrfpEmTePrpp2PgwIFRo0bpbEiLFi2iRYsWsd9++8XFF18cv/3tb+O3v/1tFBcXR0TEokWL4tRTT41x48ZFJpPZ8jcEAAAAAAAAwHYjkyRJkusmKO0vf/lLXHjhhVm1oUOHxnXXXbdV1/3zn/8cF110UVbt8ccfj+OPP75K5p87d24UFhZWaMzUqVPj2GOPLTmeOHFi7LnnnlXSDwAAAAAAAEAuffTRR7HXXnuVHG/L+6F2GNgOPfjgg6Vu2p9xxhlx7bXXbvW1L7zwwhgxYkS89tprJbX77ruvygIDrVq1ilatWlXJXAAAAAAAAABUXul96smpf/3rX3H66afH/278MGjQoBg+fPg2eyzAJZdcknU8cuTIWLt27TZZGwAAAAAAAIBtQ2BgOzJq1KgYPHhw1s35AQMGxEMPPRQ1a9bcZn30798/K5ywdOnSmD179jZbHwAAAAAAAICtT2BgOzF27Ng4+uijY+XKlSW1gw46KEaMGBG1a9fepr00aNAgmjVrllUrLCzcpj0AAAAAAAAAsHUJDGwHxo8fH9/5zneiqKiopNajR4947rnnokGDBjnpqVatWlnHa9asyUkfAAAAAAAAAGwdAgM5Nnny5BgwYEAsXLiwpNa1a9d48cUXo0mTJjnpae3atTF//vysWn5+fk56AQAAAAAAAGDrEBjIoenTp8dhhx0Wc+fOLal16NAhXn755ZzeoH/rrbdi7dq1Jcd5eXmx44475qwfAAAAAAAAAKqewECOzJ49Ow499NCYOXNmSa1Nmzbx6quvRps2bXLYWcRdd92VdXzggQdG/fr1c9QNAAAAAAAAAFuDwEAOLFiwIAYMGBCfffZZSS0/Pz9efvnl6NChQw47ixg9enTcd999WbVjjz02N80AAAAAAAAAsNUIDGxjS5cujSOPPDI++uijklrTpk3jpZdeiq5du1bZOi+//HLcc889WY8W2JyRI0fGoEGDYt26dSW1nXbaKc4777wq6wsAAAAAAACA7UNerhtIm6OPPjrGjRuXVbv44otj3rx58corr1Rorn333TeaNWtW5muzZs2Ks846K6688soYPHhwHH300fGtb30rmjRpknXeunXr4p133olhw4bF/fffH8XFxSWv1ahRI/761796HAEAAAAAAADAN5DAwDY2evToUrWrrrqqUnONGjUq+vbtu8lzZs2aFTfffHPcfPPNERHRpk2baN68eTRo0CCWLFkSM2bMiKKiolLjMplM3HzzzXHcccdVqjcAAAAAAAAAtm8CAykza9asmDVr1ibP2WmnneLee++NAQMGbKOuAAAAAAAAANjWauS6AbaO/v37x9VXXx19+/aNRo0abfb8GjVqxLe+9a3429/+FlOnThUWAAAAAAAAAPiGs8PANpYkyTZZp127dnHVVVfFVVddFUmSxGeffRZTp06NL774IhYtWhQrV66MBg0aRLNmzaJt27ax//77R+PGjbdJbwAAAAAAAADknsBACmQymejcuXN07tw5160AAAAAAAAAsJ3wSAIAAAAAAAAASCGBAQAAAAAAAABIIYEBAAAAAAAAAEghgQEAAAAAAAAASCGBAQAAAAAAAABIIYEBAAAAAAAAAEghgQEAAAAAAAAASCGBAQAAAAAAAABIIYEBAAAAAAAAAEghgQEAAAAAAAAASCGBAQAAAAAAAABIIYEBAAAAAAAAAEghgQEAAAAAAAAASCGBAQAAAAAAAABIIYEBAAAAAAAAAEghgQEAAAAAAAAASCGBAQAAAAAAAABIIYEBAAAAAAAAAEihvFw3AORG5icP5LoF2C4lt56S6xYAAAAAAAC2CTsMAAAAAAAAAEAKCQwAAAAAAAAAQAoJDAAAAAAAAABACgkMAAAAAAAAAEAKCQwAAAAAAAAAQAoJDAAAAAAAAABACgkMAAAAAAAAAEAKCQwAAAAAAAAAQAoJDAAAAAAAAABACgkMAAAAAAAAAEAKCQwAAAAAAAAAQAoJDAAAAAAAAABACgkMAAAAAAAAAEAKCQwAAAAAAAAAQAoJDAAAAAAAAABACgkMAAAAAAAAAEAKCQwAAAAAAAAAQAoJDAAAAAAAAABACgkMAAAAAAAAAEAKCQwAAAAAAAAAQAoJDAAAAAAAAABACgkMAAAAAAAAAEAKCQwAAAAAAAAAQAoJDAAAAAAAAABACgkMAAAAAAAAAEAKCQwAAAAAAAAAQAoJDAAAAAAAAABACgkMAAAAAAAAAEAKCQwAAAAAAAAAQAoJDAAAAAAAAABACgkMAAAAAAAAAEAKCQwAAAAAAAAAQAoJDAAAAAAAAABACgkMAAAAAAAAAEAKCQwAAAAAAAAAQAoJDAAAAAAAAABACuXlugEAoOplfvJArluA7VJy6ym5bgEAAAAAYLthhwEAAAAAAAAASCGBAQAAAAAAAABIIYEBAAAAAAAAAEghgQEAAAAAAAAASCGBAQAAAAAAAABIIYEBAAAAAAAAAEghgQEAAAAAAAAASCGBAQAAAAAAAABIIYEBAAAAAAAAAEghgQEAAAAAAAAASCGBAQAAAAAAAABIIYEBAAAAAAAAAEghgQEAAAAAAAAASCGBAQAAAAAAAABIIYEBAAAAAAAAAEghgQEAAAAAAAAASCGBAQAAAAAAAABIIYEBAAAAAAAAAEghgQEAAAAAAAAASCGBAQAAAAAAAABIIYEBAAAAAAAAAEghgQEAAAAAAAAASCGBAQAAAAAAAABIIYEBAAAAAAAAAEghgQEAAAAAAAAASCGBAQAAAAAAAABIIYEBAAAAAAAAAEghgQEAAAAAAAAASCGBAQAAAAAAAABIIYEBAAAAAAAAAEghgQEAAAAAAAAASCGBAQAAAAAAAABIIYEBAAAAAAAAAEghgQEAAAAAAAAASCGBAQAAAAAAAABIIYEBAAAAAAAAAEghgQEAAAAAAAAASCGBAQAAAAAAAABIIYEBAAAAAAAAAEghgQEAAAAAAAAASCGBAQAAAAAAAABIIYEBAAAAAAAAAEghgQEAAAAAAAAASCGBAQAAAAAAAABIIYEBAAAAAAAAAEghgQEAAAAAAAAASCGBAQAAAAAAAABIIYEBAAAAAAAAAEghgQEAAAAAAAAASCGBAQAAAAAAAABIIYEBAAAAAAAAAEghgQEAAAAAAAAASCGBAQAAAAAAAABIIYEBAAAAAAAAAEghgQEAAAAAAAAASCGBAQAAAAAAAABIIYEBAAAAAAAAAEghgQEAAAAAAAAASCGBAQAAAAAAAABIIYEBAAAAAAAAAEghgQEAAAAAAAAASCGBAQAAAAAAAABIIYEBAAAAAAAAAEghgQEAAAAAAAAASCGBAQAAAAAAAABIIYEBAAAAAAAAAEghgQEAAAAAAAAASCGBAQAAAAAAAABIIYEBAAAAAAAAAEghgQEAAAAAAAAASCGBAQAAAAAAAABIIYEBAAAAAAAAAEghgQEAAAAAAAAASCGBAQAAAAAAAABIIYEBAAAAAAAAAEghgQEAAAAAAAAASCGBAQAAAAAAAABIIYEBAAAAAAAAAEghgQEAAAAAAAAASCGBAQAAAAAAAABIIYEBAAAAAAAAAEghgQEAAAAAAAAASCGBAQAAAAAAAABIIYEBAAAAAAAAAEghgQEAAAAAAAAASCGBAQAAAAAAAABIIYEBAAAAAAAAAEghgQEAAAAAAAAASCGBAQAAAAAAAABIIYEBAAAAAAAAAEghgQEAAAAAAAAASCGBAQAAAAAAAABIIYEBAAAAAAAAAEghgQEAAAAAAAAASKG8XDeQdkmSREFBQUyYMCFmzpwZixYtijp16kSzZs2iS5cu0bNnz6hbt26Vrrl06dL497//HVOmTIklS5ZEvXr1on379nHQQQdF69atq3QtAAAAAAAAALZPAgM5sHDhwnjqqafihRdeiJEjR8a8efM2em6tWrVi4MCBcdFFF0WfPn22aN1p06bFVVddFY8++misXr261OuZTCb69OkTV199dRxyyCFbtBYAAAAAAAAA2zePJNjGLrjggthxxx3jrLPOikcffXSTYYGIiDVr1sRTTz0Vffv2jdNPPz2WLFlSqXUfffTR2GuvveL+++8vMywQ8fVuB6NHj46+ffvGL37xi0iSpFJrAQAAAAAAALD9s8PANjZ27Ngyb9jXrFkzdtppp9hhhx1izZo1MX369Fi8eHHWOf/4xz/ik08+iVdffTUaNmxY7jUfe+yxOOmkk6K4uDirnp+fH23bto25c+fGrFmzSgICSZLEddddF6tWrYqbbrqpEu8SAAAAAAAAgO2dHQZyqGnTpnH++efHs88+GwsXLowvvvgi3nnnnfjwww9j/vz5MWrUqOjdu3fWmLfffjvOOOOMcq/x2WefxZlnnpkVFth7771j5MiRMXfu3Hj33Xfjiy++iEmTJsWgQYOyxt58883x5JNPbtF7BAAAAAAAAGD7JDCQA7vssksMHz48vvzyy/jrX/8a3/3ud6NRo0ZZ59SsWTP69u0bo0aNinPPPTfrtSeeeCJGjRpVrrWuvPLKWLZsWclxz5494/XXX49+/fplnbfbbrvF448/XmqtoUOHxtq1ayvy9gAAAAAAAACoBgQGtrGrr746Jk+eHGeffXbUq1dvs+fXrFkzhg0bFvvtt19Wffjw4Zsd+9FHH8UjjzxScly7du249957o3HjxmWen8lk4s9//nN06dKlpPbZZ5/FPffcs9m1AAAAAAAAAKheBAa2sYEDB0bt2rUrNKZmzZoxdOjQrNqLL7642XF333131qMIfvCDH0TXrl03OaZu3brxi1/8IqtWnnACAAAAAAAAANWLwEA10bt376zj+fPnx/Llyzc55umnn846Pvvss8u11oknnhgNGjQoOR43blx8+eWX5ewUAAAAAAAAgOpAYKCaaNasWana4sWLN3r+5MmTY+rUqSXHDRo0iIMOOqhca214bpIk8eyzz1agWwAAAAAAAAC2dwID1cSsWbNK1Vq0aLHR8z/44IOs4/333z/y8vLKvd7BBx+8yfkAAAAAAAAAqN4EBqqJMWPGZB23b98+ateuvdHzJ02alHW8xx57VGi9Dc/fcD4AAAAAAAAAqjeBgWri7rvvzjr+7ne/u8nzJ0+enHXctm3bCq234fkbzgcAAAAAAABA9Vb+PerJmeeeey5ef/31rNoZZ5yxyTFz587NOt55550rtGabNm2yjgsLCys0fmPmzp1b4bmmTp1aJWsDAAAAAAAA8F8CA9u5BQsWxJAhQ7Jqxx57bOy///6bHFdUVJR13KBBgwqtu+H5a9asiVWrVkWdOnUqNM+Ghg0bFldfffUWzQEAAAAAAADAlvNIgu1YcXFxnHrqqTFz5sySWpMmTeIvf/nLZsduGBioW7duhdauV6/eZucEAAAAAAAAoPoSGNiOXXbZZfH8889n1W6//fZo27btZseuXLky67h27doVWrusnQRWrFhRoTkAAAAAAAAA2H55JMF26i9/+UvceOONWbWhQ4fGiSeeWK7xG+4osHr16gqtv2rVqs3OWRnnn39+DB48uEJjpk6dGscee+wWrw0AAAAAAADAfwkMbIcefPDBuOiii7JqZ5xxRlx77bXlnqNhw4ZZxxvuOLA5Ze0msOGcldGqVato1arVFs8DAAAAAAAAwJbxSILtzL/+9a84/fTTI0mSktqgQYNi+PDhkclkyj3Phjf3ly1bVqE+Njw/Ly+vSnYYAAAAAAAAAGD7IDCwHRk1alQMHjw41q5dW1IbMGBAPPTQQ1GzZs0KzbXhp/hnzpxZofGzZs3KOs7Pz6/QeAAAAAAAAAC2bwID24mxY8fG0UcfnfXogIMOOihGjBgRtWvXrvB8u+22W9bxjBkzKjR+w/N33333CvcAAAAAAAAAwPZLYGA7MH78+PjOd74TRUVFJbUePXrEc889Fw0aNKjUnBve4P/4448rNH7SpEmbnA8AAAAAAACA6k1gIMcmT54cAwYMiIULF5bUunbtGi+++GI0adKk0vPus88+Wcfjxo3LetTB5vz73//e5HwAAAAAAAAAVG8CAzk0ffr0OOyww2Lu3LkltQ4dOsTLL78c+fn5WzT37rvvHp06dSo5XrZsWfznP/8p19hly5bFm2++WXKcyWTie9/73hb1AwAAAAAAAMD2RWAgR2bPnh2HHnpozJw5s6TWpk2bePXVV6NNmzZVssbRRx+ddXzXXXeVa9wjjzyS9XiE/fbbL1q3bl0lPQEAAAAAAACwfRAYyIEFCxbEgAED4rPPPiup5efnx8svvxwdOnSosnXOOuusyGQyJccPP/xwTJo0aZNjVq5cGddee21W7eyzz66yngAAAAAAAADYPggMbGNLly6NI488Mj766KOSWtOmTeOll16Krl27Vulae+21V3z/+98vOV69enWcfvrpsWTJkjLPT5IkLrroovj0009Lah07doyzzjqrSvsCAAAAAAAAIPfyct1A2hx99NExbty4rNrFF18c8+bNi1deeaVCc+27777RrFmzTZ7zu9/9Lp555plYvnx5RESMGzcuDjnkkLj55pujb9++JedNmTIlLr/88njyySezxl977bVRq1atCvUFAAAAAAAAwPZPYGAbGz16dKnaVVddVam5Ro0alXXTvyydO3eOu+66K04++eRIkiQiIj788MPo169f5OfnR7t27WLu3Lkxc+bMktfX++lPfxqDBw+uVG8AAAAAAAAAbN8EBlLgBz/4QSRJEmeffXasWLGipF5YWBiFhYVljrn00kvj+uuv31YtAgAAAAAAALCN1ch1A2wbJ510UkycODFOPvnkTT5i4JBDDonRo0fHH//4x8hkMtuwQwAAAAAAAAC2JTsMbGMbbvu/LXXs2DEeeOCBuO222+KNN96ITz/9NJYuXRp169aNdu3axcEHHxxt2rTJWX8AAAAAAAAAbDsCAynUuHHj+O53v5vrNgAAAAAAAADIIY8kAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUyst1A2k3a9asePvtt2Ps2LHx9ttvxzvvvBNLly4teb19+/ZRUFBQqbkzmcwW9TZt2rTYZZddtmgOAAAAAAAAALZPAgM58O9//ztuuOGGGDt2bHz55Ze5bgcAAAAAAACAFKpWjyQ46aSTYvTo0bluY4uNGzcuRowYISwAAAAAAAAAQM5Uqx0GHnnkkXj00UejY8eO8aMf/SjOOOOMaNWqVa7bqlINGzaMoqKiKp+3e/fuccMNN1RozI477ljlfQAAAAAAAACwfahWgYH1Pvvss7j88svjyiuvjKOOOirOOeecOPLII3PdVoU1atQo9t133+jZs2fsv//+0bNnz5g2bVr069evytdq1qxZHHbYYVU+LwAAAAAAAADVU7UMDGQymUiSJNasWRMjRoyIESNGRNu2bePss8+OM888M3beeedct7hJRx11VBx++OGx++67R40a2U+FmDZtWo66AgAAAAAAACBNamz+lO3HU089FQMHDiy5yZ7JZCIiIkmSmDFjRvzmN7+JDh06xPe+9714+umno7i4OJftblSnTp1ijz32KBUWAAAAAAAAAIBtpVrdsT766KPj6aefjunTp8fVV18d7du3jyRJIuK/uw6sW7cunn/++TjuuOOibdu28atf/SoKCgpy2zgAAAAAAAAAbGeqVWBgvdatW8eVV14Zn3/+ebz44otx/PHHR61atSIie9eB2bNnxx/+8Ifo3LlzHH744fH444/H2rVrc9k6AAAAAAAAAGwXqmVg4H8NGDAgHnvssZg5c2Zcf/31seuuu2btOhARUVxcHK+++mqceOKJ0aZNmxg6dGhMnjw5l20DAAAAAAAAQE5V+8DAei1btoxLL700Jk2aFK+//nqceuqpUbdu3UiSJGvXgcLCwrjhhhtijz32iD59+sQDDzwQq1atynH3287s2bPj3Xffjddffz0mTJgQs2fPznVLAAAAAAAAAORAXq4b2Bq+/e1vx7e//e245ZZb4v7774/hw4fHhx9+GBFf7zqwfgeCN954I95444342c9+Fqeeemqcc8450a1bt1y2vtVMmDAhOnbsGNOmTSv12o477hh9+vSJM844I4488sit2sfcuXOjsLCwQmOmTp26lboBAAAAAAAASK9vZGBgvSZNmsQFF1wQF1xwQYwbNy6GDx8eDz/8cBQVFUVElAQHFi5cGLfeemvceuut0atXr/jJT34SgwcPjlq1auWy/Sq1YMGCWLBgQZmvzZkzJx555JF45JFHokePHnHvvfduteDEsGHD4uqrr94qcwMAAAAAAABQft+YRxJsTs+ePePiiy+Ok046qSQokMlkSr4ivg4QjB07Nk477bTo1KlT3HHHHblsOSfef//96NWrVzz22GO5bgUAAAAAAACAregbHxhYtWpV3H///dGnT5/YY4894s477ywJCER8HRJY//W/tZkzZ8aPf/zjOPjgg2P27Nm5aL1KtGzZMs4444y4//77Y/z48bFgwYJYs2ZNLFy4MD788MO49dZbY++9984as2LFijj11FPj9ddfz1HXAAAAAAAAAGxt39hHEkyYMCHuvPPOeOCBB2LRokUR8XUQIJPJlIQDGjZsGCeddFKcddZZ8fHHH8fw4cPjzTffjIgoOe/NN9+Mfv36xXvvvRf169fP1duplPvvvz8GDx4ctWvXLvVa06ZNo2nTptG9e/e44IIL4vbbb48LL7wwVq1aFRERq1evjpNPPjmmTp0adevWrbKezj///Bg8eHCFxkydOjWOPfbYKusBAAAAAAAAgG9YYGDZsmXx0EMPxfDhw2PcuHEREVmPH1h/vPfee8eQIUPi1FNPjYYNG0ZERK9eveLMM8+MCRMmxHXXXRcPPfRQSWjg008/jVtuuSV+/vOf5+aNVdIpp5xS7nOHDBkS+fn5MXjw4CguLo6IiFmzZsVf//rXuOSSS6qsp1atWkWrVq2qbD4AAAAAAAAAKucb8UiCcePGxbnnnhs77bRTDBkyJMaNG1cqKFC3bt04/fTT480334z3338/zjvvvJKwwP/q1q1b3H///fHKK69EnTp1SkIDTzzxxDZ9T7kwaNCgOO2007Jq9913X466AQAAAAAAAGBrqraBgcWLF8df//rX2GeffeKAAw6Iu+66K4qKikqCAhFf7yaw++67x8033xxffvll3HPPPdGrV69yzd+vX7/40Y9+VDLf5MmTt8r72N5suJvA+PHj46uvvspRNwAAAAAAAABsLdXukQRvvPFG3HnnnfH444/HypUrs3YSWL8bQO3ateP444+PIUOGRO/evSu91re//e245ZZbIiKiqKioSvrf3nXr1i1atWoVc+fOjYivQxdTpkyJHXbYIcedAQAAAAAAAFCVqlVgoGvXrjFlypSIiKygQJIkkSRJdOnSJc4999w444wzokWLFlu8XvPmzUvWSJOdd965JDAQEVFYWJjDbgAAAAAAAADYGqpVYGDy5MklN+/XBwXy8vLimGOOiSFDhsShhx66VdZNkiRVoYFatWplHa9ZsyZHnQAAAAAAAACwtVSrwMB6SZLELrvsEj/60Y/irLPO2mrb5e+7774xatSorTL39mzOnDlZx/n5+TnqBAAAAAAAAICtpVoFBmrWrBkDBw6M8847L4444oit/qn/pk2bRp8+fbbqGtubmTNnxvTp07Nqbdu2zVE3AAAAAAAAAGwt1SowUFBQEG3atMl1G99od911V9Zx27Zto0uXLjnqBgAAAAAAAICtpUauG6gIYYGta9KkSXHDDTdk1Y499tjcNAMAAAAAAADAVlWtAgOUzwcffBA33XRTLF++vEJjjjzyyFi6dGlJrV69evGLX/xia7QIAAAAAAAAQI5Vq0cSfJP8+9//jhUrVpSqf/jhh1nHK1eujFdeeaXMOVq3bh177LFHqfqiRYvi4osvjt///vcxaNCgOO6446Jnz57RsmXLrPOSJImJEyfGnXfeGXfccUesWrUq6/U//OEP0bp164q+NQAAAAAAAACqgWoVGBg/fnzWFvn33HNP9OnTp8LzjB49Os4666yIiMhkMvH888/HrrvuWlVtlsspp5wS06dP3+x5X331VQwYMKDM104//fT4+9//vtGx8+fPjzvvvDPuvPPOiIjYYYcdomXLltGoUaMoKiqKWbNmxcKFC8sce8kll8SFF164+TcCAAAAAAAAQLVUrQIDt912WxQUFERExB577FGpsEBERN++faNOnToxefLkyGQycfvtt8cNN9xQhZ1un7766qv46quvNnlO48aNY9iwYXHKKadso64AAAAAAAAAyIUauW6gIv75z39GxNe7Apx66qlbNNcPf/jDiPh6W/4RI0ZscW/bk27dusV1110XRx55ZDRv3rxcY3bfffe4/vrro6CgQFgAAAAAAAAAIAWqzQ4DkyZNijlz5pQcH3PMMVs03zHHHBNXXHFFRERMnz49pk2bFh06dNiiOSti/U4JW0OLFi1i6NChMXTo0Ij4+v19+umnMWPGjFi4cGGsWLEi6tatG82aNYuddtopevXqFS1atNhq/QAAAAAAAACw/ak2gYGPP/645PuGDRtG165dt2i+rl27RsOGDaOoqCgiIiZOnLhNAwPbUvv27aN9+/a5bgMAAAAAAACA7Ui1eSTBrFmzIuLrxxG0bdt2i+fLZDLRrl27kuMZM2Zs8ZwAAAAAAAAAUF1Um8DA+p0AIiIaN25cJXM2atSo5PulS5dWyZwAAAAAAAAAUB1Um8DA/97cX7hwYZXMuWjRopLva9euXSVzAgAAAAAAAEB1UG0CAy1btoyIiCRJ4osvvog1a9Zs0XyrV6+OL774ouQ4Pz9/i+YDAAAAAAAAgOqk2gQGOnXqVPL9ihUr4rXXXtui+V577bVYvnx5yXH79u23aD4AAAAAAAAAqE6qTWBgv/32iyZNmkQmk4mIiD/84Q9bNN+1115b8n2DBg3iwAMP3KL5AAAAAAAAAKA6qTaBgRo1asR3v/vdSJIkkiSJ0aNHx0033VSpuW688cYYNWpUZDKZyGQyccQRR0StWrWquGMAAAAAAAAA2H5Vm8BARMQVV1wRNWrUiEwmE0mSxGWXXRZXXXVVrFu3rlzj161bF1deeWUMHTq0ZI5MJhNXXnnlVu4cAAAAAAAAALYv1SowsMcee8S5555bcqO/uLg4fv/738fuu+8eN910U3zyySdljvvkk0/ixhtvjN133z2uueaaKC4ujoiITCYTZ599dnTv3n1bvg0AAAAAAAAAyLm8XDdQUX/5y1/io48+ijFjxpTsEvDZZ5/FpZdeGpdeemk0aNAgWrZsGQ0bNoyioqKYN29eLFu2LCIikiSJiCgZ17dv3/jrX/+ay7cDAAAAAAAAADlRrXYYiIjIy8uLZ555Jo499tiSnQbWBwCSJImioqIoKCiIiRMnRkFBQRQVFZW89r/nnnDCCfHPf/4z8vKqXWYCAAAAAAAAALZYtQsMREQ0btw4nnzyybjtttuibdu2WTsHbOwr4usdBtq3bx/Dhw+PRx99NBo1apTLtwEAAAAAAAAAOVOtP14/ZMiQOOecc+LJJ5+Ml156KcaMGROff/55rF27tuScvLy86Ny5c/Tu3TuOPPLIOOaYY6JGjWqZkwAAAAAAAACAKlOtAwMRETVr1ozBgwfH4MGDS2pLly6NpUuXRqNGjewiAAAAAAAAAABlqPaBgbIICgAAAAAAAADAptmbHwAAAAAAAABSSGAAAAAAAAAAAFJIYAAAAAAAAAAAUigv1w1UlTVr1sTixYtjxYoVkSRJhce3a9duK3QFAAAAAAAAANunahsYWLhwYdx///3x/PPPx3vvvReFhYWVniuTycTatWursDsAAAAAAAAA2L5Vy8DAzTffHFdeeWUsX748IqJSOwoAAAAAAAAAQJpVu8DAeeedF3feeWdJSCCTyUQmkxEaAAAAAAAAAIAKqFaBgXvvvTfuuOOOiIiSkECSJNGsWbPo1q1btGrVKho0aJDjLgEAAAAAAABg+1etAgNXXXVVRPw3LLD33nvHtddeGwMGDIgaNWrkuDsAAAAAAAAAqD6qTWDg/fffjy+++CIymUxERBx00EHx8ssvR7169XLcGQAAAAAAAABUP9XmY/kffPBBREQkSRIREbfeequwAAAAAAAAAABUUrUJDBQWFpZ837p169hnn31y1wwAAAAAAAAAVHPVJjCw/lEEmUwm2rRpk+NuAAAAAAAAAKB6qzaBgXbt2pV8X1RUlMNOAAAAAAAAAKD6qzaBgYMOOigiIpIkiYKCgli9enWOOwIAAAAAAACA6qvaBAbatm0b/fr1i4iIFStWxPPPP5/jjgAAAAAAAACg+qo2gYGIiGuvvTZq1qwZERFXXHFFrFy5MscdAQAAAAAAAED1VK0CAz179owbbrghkiSJSZMmxfHHHx9Lly7NdVsAAAAAAAAAUO1Uq8BARMTPfvazuO2226JWrVrxwgsvRPfu3eOOO+6IhQsX5ro1AAAAAAAAAKg28nLdQEX079+/5Pv8/PyYNWtWTJ8+PX784x/H+eefH7vssku0atUq6tatW6F5M5lMvPrqq1XdLgAAAAAAAABst6pVYGD06NGRyWRKjtd/nyRJJEkSn3/+eUybNq1CcyZJkjUnAAAAAAAAAKRBtQoMbIwb/gAAAAAAAABQMdUuMJAkSa5bAAAAAAAAAIBqr1oFBoqLi3PdAgAAAAAAAAB8I9TIdQMAAAAAAAAAwLYnMAAAAAAAAAAAKSQwAAAAAAAAAAApJDAAAAAAAAAAACkkMAAAAAAAAAAAKZSX6wa21NSpU2PEiBExZsyYmDRpUixYsCAWL14cEREvvfRS9O/fv9SY2bNnx5o1ayIiol69epGfn79NewYAAAAAAACAXKu2gYHPP/88LrnkknjmmWciSZKIiJL/jIjIZDIbHfub3/wmhg8fHhER+fn5MWvWrKhZs+bWbRgAAAAAAAAAtiPV8pEETzzxRHzrW9+Kp59+OoqLi7Ne21RQYL1LLrkkIr4OGBQWFsa//vWvrdInAAAAAAAAAGyvql1g4Lnnnosf/OAHsWTJkpJakiSxww47RM+ePbN2GdiYXXfdNQ4++OCS4yeffHKr9AoAAAAAAAAA26tqFRgoLCyMk046KdatWxeZTCaSJInBgwfHhx9+GF9++WWMHTs2Isq3y8Dxxx8fEV+HDV555ZWt2jcAAAAAAAAAbG+qVWDgt7/9bSxdurTk+Prrr49HHnkkunXrVuG5+vXrV/L9nDlzYsaMGVXSIwAAAAAAAABUB9UmMFBcXBz3339/ZDKZyGQyccIJJ8Sll15a6fn22GOPqF27dsnxpEmTqqJNAAAAAAAAAKgWqk1g4K233opFixZFkiQREfGrX/1qi+bLy8uLNm3alBzbYQAAAAAAAACANKk2gYFPP/205PtWrVpV6jEEG2ratGnJ94sXL97i+QAAAAAAAACguqg2gYHCwsKIiMhkMrHzzjtXyZx5eXkl369du7ZK5gQAAAAAAACA6qDaBAZq1Phvq8XFxVUy54IFC0q+b9asWZXMCQAAAAAAAADVQbUJDOTn50dERJIkMWfOnC2eb/ny5TF9+vTIZDJZ8wMAAAAAAABAGlSbwMAuu+xS8v2cOXNi+vTpWzTfqFGjYu3atZEkSURE7LPPPls0HwAAAAAAAABUJ9UmMHDAAQdEw4YNS3YE+Pvf/75F8910000l37dr1y46duy4RfMBAAAAAAAAQHVSbQIDtWrViiOPPDKSJIkkSeLGG2+MgoKCSs01fPjwGDlyZGQymchkMvH973+/apsFAAAAAAAAgO1ctQkMRET8+te/jho1akQmk4mlS5fGEUccUeHQwO233x4/+clPIpPJRJIkUa9evbj00ku3TsMAAAAAAAAAsJ2qVoGBPffcM3784x9HkiSRyWTi008/jW7dusWVV14ZU6ZMKXX++scXzJkzJx588ME46KCD4vzzz4/Vq1eXzPGb3/wm8vPzt/VbAQAAAAAAAICcyst1AxV18803x6effhovvfRSZDKZWLZsWVxzzTVxzTXXRIMGDSIiSsIA3//+92PFihWxYsWKkvHrX0uSJL7//e/bXQAAAAAAAACAVKpWOwxERNSsWTNGjBgRp512WsnN/4ivgwBFRUVZx/Pnz4/ly5dHkiSRJEnJHEmSxJAhQ+K+++7LyXsAAAAAAAAAgFyrdoGBiIh69erFvffeGw899FDstttuJWGA9WGBTCZT6ivi66BA586d46GHHorbbrst8vKq3QYLAAAAAAAAAFAlqvUd8xNPPDFOPPHEePHFF+O5556LMWPGxKRJk2LVqlUl5+Tl5UX79u2jX79+ceSRR8axxx4bNWpUy5wEAAAAAAAAAFSZah0YWO+II46II444ouR4+fLlsWjRoqhfv340bdo0d40BAAAAAAAAwHbqGxEY2FD9+vWjfv36uW4DAAAAAAAAALZb9uYHAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBTKy3UDFdGxY8etMm8mk4nPPvtsq8wNAMD/Z+++o6Ss7v+Bf2bpSBUEpYggRkrEgqLCVwEpNgRTbIlREkk0aDTGXiJiib3EJCaxt0QTrFFsoKIIClZQQRSkyArSkd52fn94nJ+ztF3Y3dnd5/U6Z8+Ze+fe+3x2dybBfd5zLwAAAAAA5VGFCgzMmDEjUqlUpNPpEl03lUqV6HoAAAAAAAAAUN5VqMDAd0riBn86nS6V8AEAAAAAAAAAVAQVKjCw6667FjsssHLlyli8eHGsX78+Iv5/2KBhw4ZRr169Eq8RAAAAAAAAACqCChUYmDFjxjbN27BhQ3z44Yfx2GOPxV133RXLli2LvLy8+Pvf/x5HHHFEyRYJAAAAAAAAABVAXq4LKAtVqlSJzp07x0033RQTJ06MfffdNxYuXBj9+/ePJ598MtflAQAAAAAAAECZS0Rg4PtatWoVL774YrRo0SLWr18fv/jFL+Kzzz7LdVkAAAAAAAAAUKYSFxiIiNhpp51i6NChERGxevXquPDCC3NcEQAAAAAAAACUrUQGBiIijjvuuKhWrVqk0+l47rnn4uuvv851SQAAAAAAAABQZhIbGKhTp060adMmIiLS6XSMHj06xxUBAAAAAAAAQNlJbGAgIqJ+/fqZxzNnzsxhJQAAAAAAAABQthIdGJg/f37m8fr163NYCQAAAAAAAACUrcQGBqZNmxbTp0+PVCoVERGNGzfOcUUAAAAAAAAAUHYSGRhIp9Nx7rnnZh5HRHTs2DGXJQEAAAAAAABAmUpcYODzzz+Pfv36xXPPPZe1u8CBBx6Y48oAAAAAAAAAoOxUzXUBxXHVVVdt07xVq1bF119/HR988EFMnDgx059OpyOVSsUll1ySCQ8AAAAAAAAAQBJUqMDAlVdeuV039r87fiCVSkUqlYp0Oh1HH310nH322SVVIgAAAAAAAABUCIk6kuD7QYFUKhVnnXVWDBs2LPLyEvVjAAAAAAAAAICKtcNAxP/fJWBbpFKp+MEPfhBHHXVUnHbaadGhQ4cSrAwAAAAAAAAAKo4KFRh47bXXij0nlUpFzZo1o169etGyZcvYYYcdSqEyAAAAAAAAAKhYKlRgoHv37rkuAQAAAAAAAAAqhbxcFwAAAAAAAAAAlD2BAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIoKq5LqA4rrrqqpxe/4orrsjp9QEAAAAAAACgpFSowMCVV14ZqVQqZ9cXGAAAAAAAAACgsqhQgYHvS6fTm+zfVKCgOGM3d61cBhUAAAAAAAAAoKRVuMDA92/+F76Jn06nixwO2NJYAAAAAAAAAKjsKlRg4LXXXouIiK+//jouvvjimDlzZuam/z777BM9evSIvfbaKxo1ahQ77LBDrFixIhYuXBgTJ06M119/PT788MOI+DY80Lp167j++uujSZMmufp2AAAAAAAAACBnKlRgoHv37vHxxx/HySefHF999VWk0+no06dP3HTTTdGpU6etzp8wYUJccMEFMXLkyJgxY0acf/758eKLL0b79u3LoHoAAAAAAAAAKD/ycl1AcSxcuDCOOOKIyM/Pj4iIyy+/PF566aUihQUiIvbee+94+eWX47LLLot0Oh1ffvllHH744bFo0aLSLBsAAAAAAAAAyp0KFRi49NJL46uvvopUKhU//vGP46qrrtqmda6++ur48Y9/HBER+fn5cdlll5VkmQAAAAAAAABQ7lWYwMDy5cvjoYceyrS3NSxQeH46nY4HH3wwVqxYsV3rAQAAAAAAAEBFUmECA6NHj441a9ZEKpWKZs2aRfv27bdrvQ4dOkSLFi0iImLNmjXxxhtvlESZAAAAAAAAAFAhVJjAwOeff5553KxZsxJZc5dddtnk+gAAAAAAAABQ2VWYwMD3jwxYsmRJiaz5/XUcSQAAAAAAAABAklSYwEDjxo0jIiKdTsf06dNjwYIF27XeggULYvr06ZFKpbLWBwAAAAAAAIAkqDCBgTZt2kRERCqVig0bNsQ//vGP7VrvzjvvjPXr10c6nc5aHwAAAAAAAACSoMIEBrp37x477rhjRHy7y8C1114br7/++jatNWrUqPjTn/6U2V2gYcOG0b179xKrFQAAAAAAAADKuwoTGKhatWr8+te/jnQ6HalUKtasWRNHHnlk3H777bFhw4YirbFhw4a47bbb4qijjop169Zl1vrNb34TVatWLeXvAAAAAAAAAADKjwoTGIiIGDJkSLRt2zYivj2aYPXq1XHeeedF69at48ILL4znn38+Zs2aFStWrIh0Oh0rVqyImTNnxvDhw+PCCy+M1q1bx/nnnx+rV6/OrLn77rvHFVdckatvCQAAAAAAAAByokJ9rL5mzZrx0ksvxWGHHRYzZ86MVCoV6XQ6Zs+eHbfcckvccsstW5yfTqcjIjLzWrVqFS+++GLUrFmzLMoHAAAAAAAAgHKjQu0wEBHRunXrGDt2bBx++OGZIwVSqVREfBsI2NxXRGSN6927d7z55pvRpk2bnH0vAAAAAAAAAJArFS4wEBGxyy67xAsvvBCPPfZYHHjggVmhgIjIhAi+CwhE/P8wwYEHHhiPPvpovPzyy9G8efNclA8AAAAAAAAAOVehjiQo7Pjjj4/jjz8+Pv300xg1alSMHz8+pk+fHkuWLInly5fHDjvsEA0aNIg2bdrEAQccED169Ij27dvnumwAAAAAAAAAyLkKHRj4Trt27aJdu3Zxxhln5LoUAAAAAAAAAKgQKuSRBAAAAAAAAADA9hEYAAAAAAAAAIAEEhgAAAAAAAAAgASqmusCSsL8+fNj9OjRMXny5Fi0aFEsXbo0CgoK4sILL4x27drlujwAAAAAAAAAKHcqdGDgmWeeiVtuuSXGjBmzyedPPvnkTQYGLr744hg/fnxERLRq1Sruv//+Uq0TAAAAAAAAAMqbChkYWLhwYQwcODCef/75iIhIp9MREZFKpbIeb85BBx0UN954Y2bc+eefHx07dizlqgEAAAAAAACg/MjLdQHFtWDBgjj44IPj+eefz4QDvpNOp7cYFPjOgAEDomXLlpn2v//97xKvEwAAAAAAAADKswoVGEin09G/f/+YOnVqpq9OnTpx7rnnxgsvvBAff/zxRiGCTUmlUvGTn/wk037ppZdKpV4AAAAAAAAAKK8q1JEEDz30ULz99tuZXQS6du0aTzzxRDRt2jRrXFF2GTj66KPj9ttvj3Q6HR9++GEsW7Ys6tatWyp1AwAAAAAAAEB5U6F2GLjxxhsj4tudBnbfffd4/vnnNwoLFFXnzp0zj9PpdEyaNKlEagQAAAAAAACAiqDCBAZmzJgRkydPjlQqFalUKv70pz9FvXr1tnm9Bg0axC677JJpf/bZZyVRJgAAAAAAAABUCBUmMDB+/PiI+HY3gJo1a0b//v23e80dd9wx83jx4sXbvR4AAAAAAAAAVBQVJjAwb968iIhIpVLRpk2bqF69+navWadOnczjFStWbPd6AAAAAAAAAFBRVJjAwPLlyzOPv3+jf3ssW7Ys83iHHXYokTUBAAAAAAAAoCKoMIGBRo0aZR4vWrSoRNbMz8/PPG7cuHGJrAkAAAAAAAAAFUGFCQzsvPPOERGRTqdj+vTpsXLlyu1ab+LEibF06dJMu3Xr1tu1HgAAAAAAAABUJBUmMHDQQQdFKpWKVCoVGzZsiOHDh2/Xevfff3/m8Q477BBdunTZ3hIBAAAAAAAAoMKoMIGBnXbaKTp37hzpdDoiIv70pz/Fhg0btmmtKVOmxN13350JIBx22GFRpUqVkiwXAAAAAAAAAMq1ChMYiIg466yzMo8nTpwYv/vd74q9xuzZs+PYY4+NlStXZsIHF1xwQYnVCAAAAAAAAAAVQYUKDPziF7+ITp06RUREOp2Of/7zn3HMMcfE559/vtW5a9eujX/+85+x//77x2effZbZXeDwww+Pbt26lXbpAAAAAAAAAFCuVM11AcWRSqVi2LBh0a1bt1i4cGFERDz//PPx/PPPR5cuXWL//fePiG/DBKlUKu6777548sknY+rUqTF27NhYsWJF5rl0Oh277rprPPzww7n8lgAAAAAAAAAgJypUYCAiYo899ohnn302BgwYEPPmzcvc/B8/fnyMHz8+My6dTsejjz6a1Y6IzPiWLVvGc889F40aNSrz7wEAAAAAAAAAcq1CHUnwnQMPPDAmTJgQhx9+eCYI8J3vjhpIpVIb9Ud8Gxw4/PDD4913340f/vCHZVYzAAAAAAAAAJQnFTIwEBHRtGnTeOGFF+Ktt96K448/PurVqxfpdHqzX7Vq1Yp+/frF66+/Hi+88ELstNNOuf4WAAAAAAAAACBnKtyRBIUdeOCB8dhjj0U6nY6PPvooJk+eHAsXLowlS5ZE7dq1o3HjxtG6devo0qVLVKtWLdflAgAAAAAAAEC5UGECAxs2bIgVK1Zk2rVq1coKAKRSqejUqVN06tQpF+UBAAAAAAAAQIVSYY4kePDBB6Nhw4aZr9GjR+e6JAAAAAAAAACosCpMYODrr7+OdDod6XQ66tevH4cddliuSwIAAAAAAACACqvCBAbq1KkTEd8ePdCqVascVwMAAAAAAAAAFVvVXBdQVLvsskuuS6gUVq9eHWPHjo1PP/00Fi9eHNWrV48WLVrEgQceGG3atMl1eQAAAAAAAACUkQoTGGjfvn1ERKTT6fjyyy9zXE3Jyc/Pj/Hjx8e4ceNi/Pjx8e6778ayZcsyz7dq1SpmzJix3deZP39+DB06NB544IFYsWLFJsd07tw5/vjHP8aAAQO2+3oAAAAAAAAAlG8VJjDQsWPH6NixY3zyySexePHiGDduXBx44IG5LmubjBkzJm655ZYYN25cfPXVV6V+vVGjRsVxxx0XCxYs2OK49957L4499tg45ZRT4u67747q1auXem0AAAAAAAAA5EZergsojt/85jeZx0OGDMlhJdvnnXfeiaeeeqpMwgJvvvlmHHXUURuFBRo0aBD77rtv7LbbblGlSpWs5x566KE46aSTIp1Ol3p9AAAAAAAAAORGhQoMDB48OLp16xbpdDpGjBgR559/fq5LKnF16tQpsbUWL14cJ5xwQqxatSrT16pVq3j66adj0aJF8f7778f06dNjxowZcfrpp2fNffLJJ+O2224rsVoAAAAAAAAAKF8qVGCgSpUq8eyzz8b//d//RTqdjttuuy0OPfTQGDVqVK5L2yZ169aNHj16xAUXXBDDhg2LGTNmxLPPPlti6990001Zuxi0bt06xo4dGwMGDIhUKpXpb9GiRfzjH/+Ia6+9Nmv+VVddFYsXLy6xegAAAAAAAAAoP6rmuoDiuOqqqyIionv37vH555/H119/HWPGjIlevXpF06ZNY//994/WrVtHvXr1olq1asVa+4orriiNkjfpmGOOib59+0a7du0iLy87szF9+vQSucb8+fPjL3/5S1bf3XffHc2aNdvsnEsuuSReeumleOONNyIiYunSpXHzzTdvFCQAAAAAAAAAoOKrUIGBK6+8MuuT8alUKtLpdEREzJ07N4YPH77Na5dlYGD33Xcv9Ws89thjsXz58kz70EMPjV69em1xTiqViiFDhmSNu+++++Kaa67J+rkDAAAAAAAAUPFVqCMJNiWVSmW+tsV3gYPK5plnnslqn3baaUWa17Nnz2jdunWmPXfu3Hj77bdLtDYAAAAAAAAAcq/CBQbS6XSJflVGy5cvzxwr8J2+ffsWaW4qlYrevXtn9T333HMlVhsAAAAAAAAA5UOFOpLgtddey3UJFcInn3wS69aty7Rbt24dO++8c5Hnd+vWLe6+++5M+8MPPyzJ8gAAAAAAAAAoBypUYKB79+65LqFCmDx5cla7Q4cOxZpfeHzh9QAAAAAAAACo+MpVYOAPf/hD5vHgwYOjbdu2Oaym4poyZUpWu2XLlsWaX3j8zJkzY/Xq1VGzZs3trg0AAAAAAACA8qFcBQZuv/32SKVSERHRr1+/rQYGlixZEhMnTsy0Dz300FKtr6KYN29eVrtFixbFmt+0adOoWrVqrF+/PiIiCgoKYuHChdG8efMSqW3+/PnFmjN16tTtvi4AAAAAAAAA2cpVYCAiIp1OZ0IDW/Pee+9F3759IyIilUplbnAn3fLly7PaO+ywQ7Hmp1KpqFWrVixbtmyza26rO++8M4YOHVoiawEAAAAAAACw7cpdYKCoYYHvpNPpUqqk4ip8c39bjhIorcAAAADbL3XWv3JdApRL6b/+PNclAAAAAFQoebkugJK3evXqrHb16tWLvUaNGjWy2qtWrdqumgAAAAAAAAAoX8rdDgNsv8I7Cqxdu7bYa6xZs2aLa26rwYMHx3HHHVesOVOnTo1jjz22RK4PAAAAAAAAwLcEBiqhOnXqZLUL7zhQFIV3FCi85rZq0qRJNGnSpETWAgAAAAAAAGDbOZKgEip8c3/FihXFmp9Op0stMAAAAAAAAABA+SAwUAkV/gT/7NmzizX/66+/jvXr12faeXl50bhx4xKpDQAAAAAAAIDyQWCgEtpzzz2z2rNmzSrW/MLjW7VqFTVr1tzuugAAAAAAAAAoPwQGKqF27dpltSdNmlSs+ZMnT97iegAAAAAAAABUfAIDlVDHjh2jWrVqmfaMGTNizpw5RZ4/ZsyYrPY+++xTUqUBAAAAAAAAUE4IDFRCdevWjUMPPTSrb8SIEUWam06nY+TIkVl9xxxzTInVBgAAAAAAAED5UDXXBWzOhAkTomrVLZc3YcKErPbo0aMjnU5v0/UK32Cv6Pr37x+vvPJKpn3vvffGKaecstV5r732WkyfPj3Tbtq0aRx44IGlUiMAAAAAAAAAuVMuAwPpdDrOP//8Ys/p0aPHNl0vlUrF+vXrt2lueXXiiSfGpZdeGitWrIiIiDfeeCNeffXVOOywwzY7J51Ox9ChQ7P6fvnLX0Zeno0oAAAAAAAAACqbcnknOJVKRTqdLtJXKpXKfBV1zqa+KpsmTZrEWWedldU3aNCg+OqrrzY757rrros33ngj065fv35ccMEFpVYjAAAAAAAAALlTLncYiPg2NFAWc3IVFhgzZkysWrVqo/7CxyysXr06Ro4cuck1mjVrFh06dNjsNS688MJ48MEHY+7cuRERMX369OjatWvccccdccwxx2R+XrNnz45rrrkm/vnPf2bNv+yyy2LHHXcs1vcFAAAAAAAAQMVQrgIDu+666zbd9K+Ifv7zn8fMmTO3Ou7rr7+OPn36bPK5U089NR544IHNzt1xxx3jP//5Txx++OGxevXqiIiYOXNmDBgwIBo0aBCtW7eOJUuWxKxZs2LDhg1ZcwcMGFDsYyEAAAAAAAAAqDjKVWBgxowZuS6h0jn00ENj+PDhcdxxx8WiRYsy/UuWLIkPPvhgk3N+9rOfxX333ZeY8AYAAAAAAABAEuXlugBK32GHHRaTJk2K3/72t1G7du3Njtt3333jiSeeiH/9619Ro0aNMqwQAAAAAAAAgLJWrnYYSJKy3k2hadOmceedd8Ytt9wSY8eOjcmTJ8eSJUuievXq0bx58zjwwAOjbdu2ZVoTAAAAAAAAALkjMJAwtWrVil69ekWvXr1yXQoAAAAAAAAAOeRIAgAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEigqrkuAAAAAACSIHXWv3JdApRL6b/+PNclAAAklh0GAAAAAAAAACCBBAYAAAAAAAAAIIEEBgAAAAAAAAAggQQGAAAAAAAAACCBBAYAAAAAAAAAIIEEBgAAAAAAAAAggQQGAAAAAAAAACCBBAYAAAAAAAAAIIEEBgAAAAAAAAAggQQGAAAAAAAAACCBBAYAAAAAAAAAIIEEBgAAAAAAAAAggQQGAAAAAAAAACCBBAYAAAAAAAAAIIEEBgAAAAAAAAAggQQGAAAAAAAAACCBBAYAAAAAAAAAIIEEBgAAAAAAAAAggQQGAAAAAAAAACCBBAYAAAAAAAAAIIEEBgAAAAAAAAAggQQGAAAAAAAAACCBBAYAAAAAAAAAIIEEBiqxK6+8MlKp1DZ/DRw4MNffAgAAAAAAAAClRGAAAAAAAAAAABJIYAAAAAAAAAAAEqhqrgug7Nx8882x9957F3l8s2bNSrEaAAAAAAAAAHJJYCBBOnfuHD169Mh1GQAAAAAAAACUA44kAAAAAAAAAIAEEhgAAAAAAAAAgAQSGAAAAAAAAACABBIYAAAAAAAAAIAEEhgAAAAAAAAAgASqmusCKFtr1qyJL774IhYuXBjVqlWLRo0aRbNmzaJ27dq5Lg0AAAAAAACAMiQwkCBnnnlmfPHFF7F69eqs/qpVq0bnzp3jyCOPjMGDB8dOO+1UajXMmzcv5s+fX6w5U6dOLaVqAAAAAAAAAJJLYCBBJk2atMn+9evXx7hx42LcuHFxww03xPnnnx9DhgyJKlWqlHgNd955ZwwdOrTE1wUAAAAAAACgePJyXQDly6pVq+Lqq6+O3r17x/Lly3NdDgAAAAAAAAClRGCgkkulUtG1a9e49tprY8SIETF79uxYuXJlrF69OvLz8+PZZ5+N008/PWrWrJk1b9SoUXHiiSfGhg0bclQ5AAAAAAAAAKXJkQSVWN++feNnP/tZ/OAHP9jk882aNYtmzZpFv3794vLLL48TTzwxxowZk3l++PDhceedd8bvfve7Eqtp8ODBcdxxxxVrztSpU+PYY48tsRoAAAAAAAAAEBio1Lp27VrksS1atIiRI0fGYYcdFm+99Vam/5prronTTjstateuXSI1NWnSJJo0aVIiawEAAAAAAACw7RxJQEbNmjXjoYceiqpV/3+OZN68efHyyy/nsCoAAAAAAAAASoPAAFnatm0b/fv3z+oTGAAAAAAAAACofAQG2EivXr2y2lOmTMlRJQAAAAAAAACUFoEBNtKyZcus9vz583NUCQAAAAAAAAClRWCAjVSrVi2rvW7duhxVAgAAAAAAAEBpERhgI3Pnzs1q77TTTjmqBAAAAAAAAIDSIjDARt58882sduEjCgAAAAAAAACo+AQGyLJkyZJ44oknsvp69eqVo2oAAAAAAAAAKC0CA2Q5//zzY8mSJZl29erV48gjj8xdQQAAAAAAAACUCoGBSur666+P9957r8jj169fH+edd17ce++9Wf1nnHFG7LLLLiVdHgAAAAAAAAA5JjBQSb344oux//77R7du3eLPf/5zfPzxx7F+/fqNxi1dujQeffTROOCAA+LWW2/Nem733XePK664oqxKBgAAAAAAAKAMVc11AZSusWPHxtixYyMiokaNGtGiRYuoX79+VKlSJRYuXBgzZsyIgoKCjebtvPPO8cILL0SjRo3KumQAAAAAAAAAyoDAQIKsWbMmpk2bttVxRx11VNx///3RpEmTMqgKAAAAAAAAgFwQGKikLrvssmjfvn2MHj06Pv3009iwYcMWx9epUyeOPPLIOOuss+LQQw8toyoBAAAAAAAAyBWBgUqqT58+0adPn4iIWLlyZUyaNClmzJgRc+bMieXLl0dBQUE0aNAgGjZsGB06dIi99torqlSpkuOqAQAAAAAAACgrAgMJULt27dh///1j//33z3UpAAAAAAAAAJQTebkuAAAAAAAAAAAoewIDAAAAAAAAAJBAAgMAAAAAAAAAkEACAwAAAAAAAACQQAIDAAAAAAAAAJBAAgMAAAAAAAAAkEACAwAAAAAAAACQQAIDAAAAAAAAAJBAAgMAAAAAAAAAkEACAwAAAAAAAACQQAIDAAAAAAAAAJBAAgMAAAAAAAAAkEACAwAAAAAAAACQQAIDAAAAAAAAAJBAAgMAAAAAAAAAkEACAwAAAAAAAACQQAIDAAAAAAAAAJBAAgMAAAAAAAAAkEACAwAAAAAAAACQQAIDAAAAAAAAAJBAAgMAAAAAAAAAkEACAwAAAAAAAACQQAIDAAAAAAAAAJBAAgMAAAAAAAAAkEACAwAAAAAAAACQQAIDAAAAAAAAAJBAAgMAAAAAAAAAkEACAwAAAAAAAACQQAIDAAAAAAAAAJBAAgMAAAAAAAAAkEACAwAAAAAAAACQQAIDAAAAAAAAAJBAAgMAAAAAAAAAkEACAwAAAAAAAACQQAIDAAAAAAAAAJBAAgMAAAAAAAAAkEACAwAAAAAAAACQQAIDAAAAAAAAAJBAAgMAAAAAAAAAkEACAwAAAAAAAACQQAIDAAAAAAAAAJBAAgMAAAAAAAAAkEACAwAAAAAAAACQQAIDAAAAAAAAAJBAAgMAAAAAAAAAkEACAwAAAAAAAACQQAIDAAAAAAAAAJBAAgMAAAAAAAAAkEACAwAAAAAAAACQQAIDAAAAAAAAAJBAAgMAAAAAAAAAkEACAwAAAAAAAACQQAIDAAAAAAAAAJBAVXNdAAAAAPCt1Fn/ynUJUC6l//rzXJcAAABQKdlhAAAAAAAAAAASSGAAAAAAAAAAABJIYAAAAAAAAAAAEkhgAAAAAAAAAAASSGAAAAAAAAAAABJIYAAAAAAAAAAAEkhgAAAAAAAAAAASSGAAAAAAAAAAABJIYAAAAAAAAAAAEkhgAAAAAAAAAAASSGAAAAAAAAAAABJIYAAAAAAAAAAAEkhgAAAAAAAAAAASSGAAAAAAAAAAABJIYAAAAAAAAAAAEkhgAAAAAAAAAAASSGAAAAAAAAAAABJIYAAAAAAAAAAAEkhgAAAAAAAAAAASSGAAAAAAAAAAABJIYAAAAAAAAAAAEkhgAAAAAAAAAAASSGAAAAAAAAAAABJIYAAAAAAAAAAAEkhgAAAAAAAAAAASSGAAAAAAAAAAABJIYAAAAAAAAAAAEkhgAAAAAAAAAAASSGAAAAAAAAAAABJIYAAAAAAAAAAAEkhgAAAAAAAAAAASSGAAAAAAAAAAABJIYAAAAAAAAAAAEkhgAAAAAAAAAAASSGAAAAAAAAAAABJIYAAAAAAAAAAAEqhqrgsAAAAAAICKLnXWv3JdApRL6b/+PNclALAFdhgAAAAAAAAAgAQSGAAAAAAAAACABBIYAAAAAAAAAIAEEhgAAAAAAAAAgAQSGAAAAAAAAACABBIYAAAAAAAAAIAEEhgAAAAAAAAAgAQSGAAAAAAAAACABBIYAAAAAAAAAIAEEhgAAAAAAAAAgAQSGAAAAAAAAACABBIYAAAAAAAAAIAEEhgAAAAAAAAAgAQSGAAAAAAAAACABBIYAAAAAAAAAIAEEhgAAAAAAAAAgAQSGAAAAAAAAACABBIYAAAAAAAAAIAEEhgAAAAAAAAAgAQSGAAAAAAAAACABBIYAAAAAAAAAIAEEhgAAAAAAAAAgAQSGAAAAAAAAACABBIYAAAAAAAAAIAEEhgAAAAAAAAAgAQSGAAAAAAAAACABBIYAAAAAAAAAIAEEhgAAAAAAAAAgAQSGAAAAAAAAACABBIYAAAAAAAAAIAEEhgAAAAAAAAAgAQSGAAAAAAAAACABBIYAAAAAAAAAIAEEhgAAAAAAAAAgAQSGAAAAAAAAACABBIYAAAAAAAAAIAEqprrAgAAAAAAAKC8Sp31r1yXAOVS+q8/z3UJlAA7DAAAAAAAAABAAgkMAAAAAAAAAEACCQwAAAAAAAAAQAIJDAAAAAAAAABAAgkMAAAAAAAAAEACCQwAAAAAAAAAQAIJDAAAAAAAAABAAgkMAAAAAAAAAEACCQwAAAAAAAAAQAIJDAAAAAAAAABAAgkMAAAAAAAAAEACCQwAAAAAAAAAQAIJDAAAAAAAAABAAgkMAAAAAAAAAEACCQwAAAAAAAAAQAIJDAAAAAAAAABAAgkMAAAAAAAAAEACCQwAAAAAAAAAQAIJDAAAAAAAAABAAgkMAAAAAAAAAEACVc11AeTGtGnTYvz48TF79uxYu3ZtNGzYMNq1axddu3aNmjVr5ro8AAAAAAAAAEqZwEDCPP3003H11VfH+++/v8nn69SpEwMHDowhQ4ZE48aNy7g6AAAAAAAAAMqKIwkSYs2aNXHyySfHj370o82GBSIili9fHn/961+jQ4cO8cYbb5RhhQAAAAAAAACUJYGBBCgoKIgTTjgh/vWvf2X1V6lSJVq3bh377LNP1K9fP+u5+fPnx5FHHhlvvfVWWZYKAAAAAAAAQBkRGEiAm266KZ555pmsvjPOOCNmzZoVX3zxRXzwwQexaNGiePLJJ2PXXXfNjFm5cmUcf/zxsXTp0rIuGQAAAAAAAIBSJjBQyS1cuDCuvfbarL7rrrsu/v73v0ezZs0yfXl5efGjH/0oxo4dG7vttlumf/bs2XHrrbeWVbkAAAAAAAAAlBGBgUruxhtvjGXLlmXahx56aFx00UWbHd+8efO45557svpuu+22WLhwYanVCAAAAAAAAEDZExioxAoKCuL+++/P6rvyyisjlUptcV6vXr3ikEMOybSXLVsW//3vf0ulRgAAAAAAAAByQ2CgEhs7dmzMnz8/027Tpk306NGjSHNPO+20rPbTTz9dgpUBAAAAAAAAkGsCA5XY8OHDs9p9+vTZ6u4C3x/7faNGjYoVK1aUWG0AAAAAAAAA5JbAQCX24YcfZrW7du1a5LnNmjWL3XbbLdNeu3ZtTJo0qYQqAwAAAAAAACDXBAYqscmTJ2e1O3ToUKz5hccXXg8AAAAAAACAiktgoJJatWpVzJo1K6uvZcuWxVqj8PgpU6Zsd10AAAAAAAAAlA9Vc10ApWPBggWRTqcz7WrVqkWTJk2KtUbz5s2z2vPmzdvuuubNmxfz588v1pzCRyFMnTp1u+sgIhbOznUFUC598sknuS6hZHiPwyZ5j0PlVine497fsEmV4v0d4T0Om+E9DpVbpXiPe3/DJlWK93c5Ufj+55o1a8rs2qn09+8qU2lMnjw560iB+vXrx5IlS4q1xq233hrnnXdepn3iiSfGo48+ul11XXnllTF06NDtWgMAAAAAAACgsnr66adjwIABZXItRxJUUsuXL89q16xZs9hr1KpVa4trAgAAAAAAAFBxCQxUUqtXr85qV69evdhr1KhRI6u9atWq7aoJAAAAAAAAgPKjaq4LoHQU3lFg7dq1xV6j8NkY27JLQWGDBw+O4447rlhzvvnmm3j33XejXr160aBBg2jZsuVGYQaoqKZOnRrHHntspv30009H27Ztc1cQUKK8x6Hy8v6Gys17HCov72+o3LzHoXLzHqcyW7NmTXz55ZeZdvfu3cvs2gIDlVSdOnWy2oV3HCiKwjsKFF5zWzRp0iSaNGlS7HkHH3zwdl8bKoK2bdtGx44dc10GUEq8x6Hy8v6Gys17HCov72+o3LzHoXLzHqey2W+//XJyXUcSVFKFb+6vXLky0ul0sdZYsWLFFtcEAAAAAAAAoOISGKikGjduHKlUKtNet25dzJs3r1hr5OfnZ7W3ZWcAAAAAAAAAAMongYFKqlatWrHrrrtm9c2aNatYaxQe365du+2uCwAAAAAAAIDyQWCgEit8g3/SpEnFmj958uQtrgcAAAAAAABAxSUwUInts88+We2xY8cWee6cOXNixowZmXa1atWiQ4cOJVQZAAAAAAAAALkmMFCJ9evXL6s9cuTISKfTRZr78ssvZ7V79uwZderUKbHaAAAAAAAAAMgtgYFKrGvXrtG4ceNM+4svvohRo0YVae69996b1R4wYEBJlgYAAAAAAABAjgkMVGJ5eXkxcODArL6hQ4dudZeBV155JUaPHp1p161bN44//vjSKBEAAAAAAACAHBEYqOQuuuiirKMEXn/99bjhhhs2Oz4/Pz8GDRqU1XfOOedk7VQAAAAAAAAAQMUnMFDJNW7cOC699NKsvksuuSQGDx4cX331VaavoKAgnn766ejatWvMmDEj09+sWbM477zzyqpcAAAAAAAAAMqIwEACXHTRRdGvX7+svr///e+x6667xu677x777bdfNGrUKH70ox/FrFmzMmNq1aoV//3vf6NBgwZlXDEAAAAAAAAApa1qrgug9OXl5cWwYcPil7/8ZTz22GOZ/g0bNsQXX3yxyTmNGjWKxx9/PLp161ZWZUIi7bTTTjFkyJCsNlB5eI9D5eX9DZWb9zhUXt7fULl5j0Pl5j0OpSOVTqfTuS6CsvPEE0/ENddcEx9++OEmn99hhx3i1FNPjSFDhkSTJk3KtjgAAAAAAAAAyozAQEJNnTo1xo0bF/n5+bF27dpo0KBBtG/fPrp16xY1a9bMdXkAAAAAAAAAlDKBAQAAAAAAAABIoLxcFwAAAAAAAAAAlD2BAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEigqrkuACCppk2bFuPHj4/Zs2fH2rVro2HDhtGuXbvo2rVr1KxZM9flAQDfk06nY8aMGfHRRx/F7NmzY8mSJVGjRo1o2LBh7LHHHnHAAQf4/2+owNauXRuffvppzJgxI/Lz82PZsmWxbt26qFevXjRq1Cg6deoU7du3jypVquS6VAAASLQpU6bEhAkTYvbs2bFy5cqoVatWNG3aNH7wgx/E3nvvHTVq1Mh1iVDhCAwAlLGnn346rr766nj//fc3+XydOnVi4MCBMWTIkGjcuHEZVwdsj/z8/Bg/fnyMGzcuxo8fH++++24sW7Ys83yrVq1ixowZuSsQKJbFixfH008/HS+++GK8+uqrsWDBgs2OrVatWhx99NHx+9//Prp3716GVQLb6vHHH4+RI0fGmDFj4tNPP43169dvcXz9+vXjpJNOinPOOSfatWtXRlUCpemkk06Kxx57LKvPv9kBoPxZtmxZ/OUvf4l77rknpk+fvtlx1atXjy5dusRPf/rTOOecc8qwQqjYUul0Op3rIgCSYM2aNXHaaafFv/71ryKN32mnneLxxx+PQw89tJQrA7bHmDFj4pZbbolx48bFV199tcWx/vgIFceZZ54Z99xzT6xdu7bYc0855ZT4y1/+EvXq1SuFyoCS0qJFi8jPzy/2vGrVqsWll14aQ4YMiVQqVQqVAWXh2Wefjf79+2/U79/sUP5deeWVMXTo0G2ef+qpp8YDDzxQcgUBpeq5556LQYMGxddff13kOU2bNo25c+eWYlVQudhhAKAMFBQUxAknnBDPPPNMVn+VKlVi1113jfr168f06dNj6dKlmefmz58fRx55ZIwcOTIOPvjgsi4ZKKJ33nknnnrqqVyXAZSwcePGbTIsUKVKldhll12iadOmsW7dupg5c2bW/39HRDz00EPx6aefxiuvvBJ16tQpq5KBElCzZs3Mv88LCgpiwYIFMWvWrPj+Zy3WrVsXQ4cOjS+//DLuvffeHFYLbKulS5fGb3/721yXAQBsxW233RbnnXdeFP7sc82aNaNZs2bRuHHjWLVqVcyZM2eLuwICW5aX6wIAkuCmm27aKCxwxhlnxKxZs+KLL76IDz74IBYtWhRPPvlk7LrrrpkxK1eujOOPP36jGxFAxeBGIVQODRo0iMGDB8fw4cNj8eLF8eWXX8a7774bEyZMiIULF8Zrr70WhxxySNac8ePHx8CBA3NTMFBkzZo1i1//+tfx8MMPx9SpU2PFihUxZcqUzNFCM2bMiIULF8Zdd90VLVq0yJp73333xf3335+jyoHtccEFF2R2GNlhhx1yXA0AsCn33ntv/OEPf8gKCxx55JHxwgsvxJIlS2LatGkxbty4mDhxYsyfPz/y8/Pj4Ycfjp/85CdRvXr1HFYOFY8jCQBK2cKFC6N169ZZ55hfd911cfHFF29yfH5+fvzf//1f1haIV1xxxXZttQaUnttvvz3OPffcqFu3bnTu3DkOOOCA6NKlSxxwwAExffr06NmzZ2as7U2h4th///1j4cKFcfnll8fPfvazqFWr1hbHb9iwIQYPHhx33XVXVv+rr76a9b8DQPkxceLE2GuvvYp8rMDixYujd+/e8f7772f6dtlll5g9e3bk5fk8BlQUo0aNisMOOyzS6XTk5eXF9ddfHxdeeGHmef9mh/Kv8JEEN998c+y9995Fnt+sWbPo0KFDaZQGlJCpU6fGXnvtFatXr46Ib48Fe/DBB+Okk04q0vzFixdHw4YNS7NEqFQcSQBQym688cassMChhx4aF1100WbHN2/ePO65557o3bt3pu+2226Ls88+Oxo1alSqtQLFd8wxx0Tfvn2jXbt2G90smD59eo6qArbX0KFDo0+fPkX+VEKVKlXizjvvjPfffz/efffdTP8999wjMADlVKdOnYo1vmHDhvHII49Ex44dM59ymjNnTowZM2ajXUaA8mnVqlUxaNCgzHv4d7/7XRxwwAE5rgrYXp07d44ePXrkugygBP3mN7/JhAUiIv71r3/FcccdV+T5wgJQPCLwAKWooKBgo21Kr7zyyq1+iqlXr15Zf3RctmxZ/Pe//y2VGoHts/vuu0eHDh18shAqmaOPPrrYWxhWqVIl6xOKEREvvfRSSZYF5Fj79u2jc+fOWX2TJ0/OUTVAcf3xj3+MadOmRUTErrvuGtdcc02OKwIACnvmmWfitddey7SPO+64YoUFgOLzl22AUjR27NiYP39+pt2mTZsiJ55PO+20rPbTTz9dgpUBAKWh8KeMFy5cGCtXrsxRNUBp2H333bPaCxYsyFElQHG88847cfvtt2faf/vb36JOnTq5KwgA2KTCR/0NGTIkR5VAcggMAJSi4cOHZ7X79OlT5DNS+/Tpk9UeNWpUrFixosRqAwBK3qa2PVy6dGkOKgFKy/e3Ro2IaNCgQW4KAYps3bp1cdppp8WGDRsi4ttPKvbr1y/HVQEAheXn52ft1LfPPvtEx44dc1gRJIPAAEAp+vDDD7PaXbt2LfLcZs2axW677ZZpr127NiZNmlRClQEApSE/P3+jvkaNGuWgEqA0pNPpeOedd7L6Ch9RAJQ/1113XXz00UcR8W3I54477shxRQDAprz44ouZgF9ERM+ePXNYDSSHwABAKSp8nmmHDh2KNb/weOejAkD5Nnr06Kx2q1atonr16jmqBihp9913X3z11VeZdrt27aJLly45rAjYmkmTJsW1116bad9www2x884757AiAGBzCodz995778zjDz74IM4+++zYe++9o2HDhlG7du3Ybbfdok+fPnHzzTdvMsAPFE3VXBcAUFmtWrUqZs2aldXXsmXLYq1RePyUKVO2uy4AoPTcd999We2jjjoqR5UAJe3BBx+MwYMHZ9p5eXnx17/+tchHjgFlr6CgIE477bRYu3ZtREQccsgh8etf/zrHVQGlYc2aNfHFF1/EwoULo1q1atGoUaNo1qxZ1K5dO9elAcVQODDQpk2bWL58eZxzzjkb/fd2RMTMmTNj5syZMXLkyLjiiivi97//fQwdOjSqVatWViVDpSAwAFBKFixYEOl0OtOuVq1aNGnSpFhrNG/ePKs9b968EqkNACh5zz//fLzxxhtZfQMHDsxNMUCxffbZZ1mB33Xr1sXixYvj448/jmeeeSbreLDq1avHXXfdFb169cpFqUAR3XHHHfH2229HxP9/3wr5QOVz5plnxhdffBGrV6/O6q9atWp07tw5jjzyyBg8eHDstNNOOaoQKKqpU6dmtfPy8uLQQw+NDz74YKtzV61aFdddd12888478eSTT0bdunVLq0yodAQGAErJ8uXLs9q1a9cu9h8mdthhhy2uCQCUD4sWLYrTTz89q+/YY4+1VTlUIHfeeWf8+c9/3uKYVCoVRxxxRFx33XVZ26MC5c/06dPj8ssvz7QvueSSaNeuXQ4rAkrL90N937d+/foYN25cjBs3Lm644YY4//zzY8iQIVGlSpUyrhAoioKCgli2bFlW39lnn50JC6RSqejXr18cddRR0aJFi1ixYkV88MEH8fDDD2cdGzZy5MgYOHBgPPHEE2VaP1RkebkuAKCyKnxzv2bNmsVeo1atWltcEwDIvYKCgjj55JNj9uzZmb769evHHXfckcOqgNJw3HHHxWWXXSYsABXAb37zm1ixYkVERLRr1y4uvfTSHFcE5NKqVavi6quvjt69e/v7GpRTS5cuzdqxNyLi/fffj4iIRo0axeuvvx7/+9//4owzzoh+/frFCSecENdff31MmTIlfvazn2XNe/LJJ+Ohhx4qs9qhohMYACglhbdBq169erHXqFGjRlZ71apV21UTAFDyLrjggnjhhRey+v75z39Gy5Ytc1QRUFr++9//xv/93//FoYceutF2qUD5ce+998bIkSMj4ttPI951113b9N/kQPmVSqWia9euce2118aIESNi9uzZsXLlyli9enXk5+fHs88+G6effvpGH+AZNWpUnHjiibFhw4YcVQ5szubCPFWqVInhw4fHIYccssnn69SpEw8//HD07ds3q/9Pf/rTRgEEYNMEBgBKSeH/IFm7dm2x11izZs0W1wQAcuuOO+6IW2+9NavvwgsvjBNOOCFHFQHb6vbbb490Op35WrlyZXz55Zfx3HPPxWmnnZa1+9fo0aPjgAMOiHfffTeHFQObMmfOnDj//PMz7UGDBm32BgNQMfXt2zc+/fTTGDNmTFx66aXRu3fvaN68edSqVStq1KgRzZo1i379+sU//vGP+Pzzz6Nbt25Z84cPHx533nlnjqoHNmdzf/seNGhQHHjggVucm5eXF3//+98jL+//3/acMmVKvP766yVaI1RWAgMApaROnTpZ7cI7DhRF4R0FCq8JAOTOv//97/j973+f1Tdw4MC4/vrrc1MQUKJq1aoVLVq0iKOPPjruueeemDhxYuyzzz6Z55csWRLHHntsLFmyJGc1Ahs788wzM+/LnXfeOW688cbcFgSUuK5du8YPfvCDIo1t0aJFjBw5Mg4++OCs/muuuSZWrlxZGuUB22hzf/v+9a9/XaT5bdq0id69e2f1CQxA0QgMAJSSwv/AWblyZbG3QPruvMXNrQkA5MZzzz0Xp556atb/t//4xz+Oe+65J1KpVA4rA0pL27ZtY8SIEVnHjeTn58dNN92Uw6qA7xs2bFg89dRTmfaf//znaNCgQe4KAsqFmjVrxkMPPRRVq1bN9M2bNy9efvnlHFYFFFarVq2oUqVKVl/dunVj3333LfIa3bt3z2rbEQyKRmAAoJQ0btw464bBunXrYt68ecVaIz8/P6vdpEmTEqkNANh2r732Whx33HGxfv36TF+fPn3i0Ucf3eiPG0Dl0rhx4xg6dGhW3wMPPJCbYoCNXHDBBZnHRx99dBx//PE5rAYoT9q2bRv9+/fP6hMYgPKn8N+/27Ztm3XMwNbsueeeWe3i/j0ekkpgAKCU1KpVK3bdddesvlmzZhVrjcLj27Vrt911AQDbbty4cdG/f/+so4a6du0aTz31VFSvXj2HlQFl5Uc/+lFWMPirr76KmTNn5rAi4DvfPyJk+PDhkUqltvrVs2fPrDVmzpy50ZgPP/ywbL8RoFT06tUrqz1lypQcVQJsTvv27bPa9erVK9b8wuMXL1683TVBEggMAJSiwjf4J02aVKz5kydP3uJ6AEDZmThxYhx55JGxfPnyTN++++4bzz//fOywww45rAwoSw0aNIgdd9wxq2/u3Lk5qgYAKKrvHysUETF//vwcVQJsTocOHbLaa9asKdb874f7IyJq16693TVBEggMAJSiffbZJ6s9duzYIs+dM2dOzJgxI9OuVq3aRv9gAgDKxpQpU6JPnz5Zn05o3759vPTSS1G/fv0cVgaUB9WqVct1CQDAVhT+/+t169blqBJgc/bbb7+s9tdff12s+YWPIGjUqNF21wRJUDXXBQBUZv369Ysbbrgh0x45cmSk0+msLUw3p/A5aj179ow6deqUeI0AwJbNnDkzevfunfWHh9atW8eIESNip512ymFlQC4sW7YsFi1alNXXtGnTHFUDfN8zzzxT7BuAEyZMiPPPPz/Tbtq0aTzyyCNZY9q2bVsi9QG5VXhHIP+Wh/Ln6KOPjry8vCgoKIiIiOnTp8eiRYs22uFrc957772s9p577lniNUJlJDAAUIq6du0ajRs3jgULFkRExBdffBGjRo3a6IzETbn33nuz2gMGDCiVGgGAzZszZ0706tUrZs+enelr3rx5vPLKK9G8efMcVgbkyvDhwyOdTmfaO+20U+yyyy45rAj4Tvfu3Ys9p2rV7D+P1qxZM3r37l1SJQHlyJtvvpnVLnxEAZB7TZo0iW7dusXo0aMzfU8++WQMGjRoq3PXr18fTz31VFZfjx49SrpEqJQcSQBQivLy8mLgwIFZfUOHDs36A+OmvPLKK1n/KKpbt24cf/zxpVEiALAZixYtij59+sS0adMyfTvttFOMGDEiWrduncPKgFxZtWpVDBkyJKuvX79+kZfnzysAUJ4tWbIknnjiiay+Xr165agaYEtOP/30rPZNN90Ua9as2eq8u+++O2snkXr16sXhhx9e4vVBZeS/aAFK2UUXXZR1lMDrr7+edUxBYfn5+RslJs8555xo3LhxqdUIAGRbtmxZHHHEEfHJJ59k+ho0aBAvv/xytG/fPoeVASXhwgsvjHfeeadYcxYtWhT9+/ePzz77LNNXpUqVOPfcc0u6PACghJ1//vmxZMmSTLt69epx5JFH5q4gYLNOOumk2GuvvTLtzz77LE4//fTMMQWbMm7cuLjwwguz+gYPHhz169cvtTqhMnEkAUApa9y4cVx66aVx6aWXZvouueSSmDVrVlx++eXRrFmziIgoKCiI//3vf3HOOefErFmzMmObNWsW5513XpnXDRTdmDFjYtWqVRv1T5gwIau9evXqGDly5CbXaNasWXTo0KFU6gOKr3///hvdTPzDH/4QCxYs2Oz7eHM6d+4cDRs2LMnygO308ssvx0033RRdunSJE044IQ477LDo2LFjVKtWLWtcOp2OKVOmxLBhw+KOO+7IHDX2nXPPPTfrj5kAQOm6/vrro0+fPtG5c+cijV+/fn1cdNFFGx39ecYZZzhSCMqpvLy8uO2226JPnz6ZnXoffPDByM/Pj+uvvz7r/b906dK49957Y8iQIbF8+fJM/w9+8IOsv8cDW5ZKb21fbAC2W0FBQQwYMCCee+65rP4qVapEq1aton79+jF9+vSspHNERK1atWLEiBHRrVu3MqwWKK7ddtstZs6cuV1rnHrqqfHAAw+UTEHAdkulUiW21muvvebcRChn9tlnn42CfdWrV4/mzZtHgwYNonr16rFs2bL48ssvY9myZZtc49RTT4377rvPcQRQwY0aNSp69uyZabdq1SpmzJiRu4KALerRo0e8/vrr0bVr1zj++OOjV69e0a5du6haNfuzkUuXLo3nn38+brzxxvjwww+zntt9991j3Lhx0ahRozKsHCiuG264IS6++OKN+nfeeedo0aJFrFixIqZNmxZr167Ner5Ro0bx2muvCfZCMdhhAKAM5OXlxbBhw+KXv/xlPPbYY5n+DRs2xBdffLHJOY0aNYrHH39cWAAAAMrA2rVrY/r06VsdV69evbj++uvjjDPOKNFwEQBQdGPHjo2xY8dGRESNGjWiRYsWUb9+/ahSpUosXLgwZsyYscnty3feeed44YUXhAWgArjooouidu3acd5558W6desy/XPnzo25c+ducs6ee+4Zzz77bOyxxx5lVSZUCmLwAGWkZs2a8eijj8bjjz8e++yzz2bH7bDDDjF48OCYNGmSTyMCAEApePTRR+OGG26I3r17R7169bY6PpVKRadOneKmm26KqVOnxm9/+1thAQAoJ9asWRPTpk2L999/P95555344osvNhkWOOqoo2LChAluJEIF8rvf/S4mTpwYJ5xwwkbHh31f69at489//nNMnDjRexy2gSMJAHJk6tSpMW7cuMjPz4+1a9dGgwYNon379tGtW7eoWbNmrssDAIBEKCgoiM8//zymTp0as2bNim+++SbWrVsXdevWjfr168duu+0W++23X5GCBQBA6RoxYkQ8+eSTMXr06Pj0009jw4YNWxxfp06dOPLII+Oss86KQw89tIyqBErDN998E2PHjo3PP/88li5dGnXq1ImmTZvGfvvtF3vuuWeuy4MKTWAAAAAAAACoUFauXBmTJk2KGTNmxJw5c2L58uVRUFAQDRo0iIYNG0aHDh1ir732iipVquS6VAAo1wQGAAAAAAAAACCB8nJdAAAAAAAAAABQ9gQGAAAAAAAAACCBBAYAAAAAAAAAIIEEBgAAAAAAAAAggQQGAAAAAAAAACCBBAYAAAAAAAAAIIEEBgAAAAAAAAAggQQGAAAAAAAAACCBBAYAAAAAAAAAIIEEBgAAAAAAAAAggQQGAAAAAAAAACCBBAYAAAAAAAAAIIEEBgAAAAAAAAAggQQGAAAAAAAAACCBBAYAAAAAAAAAIIEEBgAAAAAAAAAggQQGAAAAAAAAACCBBAYAAAAAAAAAIIEEBgAAAAAAAAAggQQGAAAAAAAAACCBBAYAAAAAAAAAIIEEBgAAAAAAAAAggQQGAAAAAAAAACCBBAYAAAAgodLpdDz77LPx85//PNq2bRt169aNVCqV+erRo0euSwQAAABKUdVcFwAAAACUvSVLlsRPf/rTeOWVV3JdCgAAAJAjdhgAAACgQthtt92yPv2eSqVi9913j3Xr1m33WkuWLCn5gsu5E044QVgAAAAAEs4OAwAAAFRYX3zxRdx3331x+umn57qUCuX555+Pl19+OdOuU6dOnHnmmXHggQdG3bp1M/0NGzbMRXkAAABAGREYAAAAoEK7+uqr49RTT42aNWvmupQK46GHHspq/+9//4uePXvmqBoAAAAgVxxJAAAAQIWWn58ff//733NdRoXy1ltvZR7vsccewgIAAACQUAIDAAAAVHjXXXddLF++PNdlVAirV6+OWbNmZdodO3bMYTUAAABALgkMAAAAUCF17do183j+/Plx++23566YCmTp0qVZ7Xr16uWoEgAAACDXBAYAAACokK655ppIpVKZ9s033xyLFy/OYUUVw+rVq7Pa3/8ZAgAAAMlSNdcFAAAAwLbYd9994yc/+Uk8/vjjEfHtJ+dvuumm+NOf/lQm11+5cmW8+eab8eWXX8b8+fOjZs2a0aRJk+jYsWPsvffeZVLDtkin06W29scffxyTJ0+OOXPmxPLly6Np06ZxyimnRLVq1bY4b968efH222/H3LlzY+HChVGnTp1o0qRJdOnSJVq3bl0itaXT6Zg4cWJMnjw55s2bFytWrIjGjRtHixYt4pBDDok6deqUyHWKY+7cufH+++/HjBkz4ptvvomCgoKoXbt2NGnSJNq0aRM//OEPS6Su/Pz8GDt2bMycOTPWr18fu+yyS/zwhz+Mzp07b9e6BQUF8fnnn8cnn3wSX331VXzzzTdRo0aN2HHHHaNt27bRpUuXqFGjxnbX/50VK1bEW2+9Ffn5+TF//vxYt25d1KtXL1q3bh2dOnWKFi1abPPapfkaXLRoUbz//vsxderUWLp0aaxfvz5q164djRs3jtatW0fHjh2jYcOG23UNAACAbZVKl+ZfCgAAAKCE7LbbbjFz5sxMe/HixTFnzpzYa6+9YsOGDRERscMOO8S0adOiadOmxV6rQYMGRapjwoQJMWTIkHjppZc2+rT+d5o3bx6/+tWv4sILL8zJjejCevToEa+//nqx5nTv3j1GjRqVaY8aNSp69uyZaQ8ZMiSuvPLKWL9+ffz973+Pf/7zn/HJJ59stM7mfrYFBQXxyCOPxF/+8pd47733NhtkaN++fVx44YVxyimnRF5e8TdKnD9/flx33XXx2GOPxZw5czY5pnr16nHEEUfE1VdfHZ06dSr2NYpr2LBhcdttt8Vbb721xXFVqlSJTp06xbHHHhtnnXVW7LjjjpscV/j3+93PcsKECXHhhRfGiBEjNvnz3X333ePyyy+PgQMHFrn2ZcuWxVNPPRVPP/10jBo1aou7etSoUSOOOeaYuOSSS2K//fYr8jUKe+GFF+Lmm2+ON998M9auXbvZce3bt48TTjghfvOb38Quu+yy1XVL+zX4yiuvxA033BCvvPJKFBQUbHZcKpWKPffcMwYMGBBnnnlmtGzZssjXAAAA2F4CAwAAAFQIm7vJP3DgwHjwwQcz/WeffXb8+c9/3qa1tiSdTsfFF18cN9988xZv/n3fzjvvHMOGDYv/+7//K9L40lJagYFzzjkn+vfvH2+++eZm19nUz/bzzz+P4447LiZMmFDkeg466KD43//+FzvttFOR59x7771x7rnnxrJly4o0Pi8vL4YMGRJXXHFFka9RHGvWrImTTjopnnrqqWLPHTFiRPTu3XuTz20qMPDoo4/GqaeeGuvWrdvq2sccc0wMGzasSLsBNG7cOBYuXFj0wuPbG+LXXHNNXHrppcWaN2fOnDjxxBPjjTfeKNa8U089NR544IEtjinN12A6nY6zzz47/vrXvxZ57e/cfffdMWjQoGLPAwAA2FbFj+YDAABAOTJkyJCsLe//+c9/xpdfflmi10in0zFw4MC48cYbNwoLNG7cOPbbb79o37591KxZM+u5uXPnRt++feOll14q0XrKg/Xr128UFmjYsGF06tQpOnXqFPXr19/kvHHjxkXXrl03ulFbpUqVzDb2HTp02Ohn+fbbb8fBBx8c8+fPL1J9f/zjH2PQoEEbhQXq1asXHTt2jC5dusRuu+2W9VxBQUEmCFEaBg0atMmwQJMmTWLfffeNgw46KDp27FisUMSmvPbaa3HKKadkwgLf/Wz333//aNas2Ubjn3322fjJT34S69ev3+rahXfVSKVS0bJly+jUqVOm/tq1a2eNSafTcdlll8VVV11V5O/ho48+ii5dumwyLNCwYcPo2LFjHHDAAbHHHnts9ciLwkr7NXjFFVdsMiyw4447xt577x0HHXRQ7LXXXkXaBQEAAKC0CQwAAABQobVu3Tp+/etfZ9pr1qwp1o3JovjrX/8aDz30UFbfIYccEmPGjIl58+bFe++9F5MmTYr58+fH3XffnbV1/KpVq+JnP/tZfPXVVyVaU3HccsstMWLEiBgxYkQ88sgjWc/17ds389z3v2655ZYtrnnPPfdkwgK9e/eOMWPGxIIFC2LChAkxYcKEWLx4cYwYMSJq1aqVmTN37tzo379/LFiwINPXqVOnePTRR2PJkiXx+eefx7hx4+KTTz6JxYsXx3/+85/YfffdM2OnTZsWAwcO3OzW8d+5//7745prrsm0U6lUnHLKKfHOO+/E4sWL4+OPP45x48bF9OnTIz8/Py655JKsm8533HFH/Pe//93iNYrrnXfeyfrZV61aNS655JKYMWNGfP311/H+++/HW2+9FR9//HHMmzcv5s6dG8OGDYtTTjkl62dYFL/85S9j/fr1Ub169bjyyitjzpw58fnnn8c777wT+fn5MWHChOjXr1/WnOHDh2/1d/6ddu3axR//+McYO3ZsLF++PGbNmhUTJkzI1L9s2bJ466234sQTT8yad9VVV8U777yz1fWXLFkSAwYMiNmzZ2f68vLy4le/+lW8++67sXDhwvj4449j/Pjx8dlnn8U333wTo0ePjt///vfRuHHjLa5d2q/B/Pz8uOGGG7L6Tj/99Jg0aVIsXLgwPvzww3jrrbdi4sSJ8dVXX8WiRYviueeeizPOOGOzIRsAAIBSlQYAAIAKoFWrVumIyHwtXrw489xXX32VrlWrVua5qlWrpj/77LNtWquwL7/8MmvtiEifeuqp6YKCgs3OmT59erp58+ZZcwYMGLAN33XJmz59+kbfS1G89tprWfO++/r9739f5GsfccQRWXN/85vfpNeuXbvFOYsXL0537do1a96TTz652fHTpk1L165dOzO2Vq1a6eeff36rtb3++utZv+cmTZqkV61aVeTvbWsuuOCCrO/hvvvuK/LcBQsWpOfNm7fZ57t3777R76VGjRrpV155ZYvrnnvuuVlzatWqlZ45c+YW57z22mtFrjudTqcffPDBrGscf/zxW51z4oknZs2pV69e+tVXXy3S9VasWJF+6623Nvt8ab8G//a3v2WNu+KKK4pUdzqdTi9btiw9a9asIo8HAAAoCXYYAAAAoMLbZZdd4swzz8y0169fH0OGDCmRte+8885YtWpVpr333nvHPffcE6lUarNzdttttxg2bFjWmP/973/x+eefl0hN5UXXrl3j1ltvLdLYt99+O1588cVM+8gjj4x//OMfW91OvkGDBvHEE09E3bp1M31b+iT8jTfeGCtXrsy077vvvjjyyCO3Wt+hhx4aN998c6Y9b968jXZj2B6fffZZ5nGdOnXilFNOKfLcRo0aFfuYgmuvvTYOO+ywLY655ZZb4uCDD860V61aFf/4xz+2OKdHjx7FquOUU06Jk08+OdN+8sknY+nSpZsd/+mnn8Z//vOfTDuVSsV///vf6NmzZ5GuV7t27TjooIM2+VxZvAa//3uOiBg8eHCR6o749nXRsmXLIo8HAAAoCQIDAAAAVAoXX3xx1g29//znP/HRRx9t15rpdDruvfferL6bb745qlatutW5Bx98cJxwwglZa91zzz3bVU95c9VVV20xOPF9t99+e1b7tttuK/LcnXfeOQYNGpRpjxkzJr7++uuNxi1atCjr6IiDDz54o23xt+TXv/51NGnSJNN+4oknijx3a74fOsnLy4u8vNL7k0zz5s3j7LPP3uq4VCq10fb5999//1aPfCiu7wcG1q9fv8VjCe64446s65988slx+OGHl0gdZfEa/P7vOSK2GkYAAADINYEBAAAAKoVGjRrFH/7wh0y7oKAg/vjHP27Xmp9++mnMmzcv0951112jV69eRZ7/q1/9Kqv9xhtvbFc95UnTpk23+gn27xQUFGR9srtLly6x5557Fut6ffv2zWqPHj16ozGjRo3KumH7i1/8oljXqFatWtYn2ceOHRsFBQXFWmNzmjVrlnn8zTffxLPPPlsi627KiSeeWOQb1Ycccki0adMm0547d25MmTKlROtp3bp1VvuDDz7Y7NiXX345q12U4ENRlNVr8Pu/54go0V0qAAAASoPAAAAAAJXGH/7wh2jUqFGm/cwzz8T48eO3eb1x48ZltXv27FnkTyRHfLvN/fd3I/jggw9i7dq121xPebL//vsX+Wfx0UcfZW1Dv//++xf7ervuumtWe/LkyRuNKXwDd3uv880330R+fn6x19iUPn36ZLV//vOfxy233BJLliwpkfW/r7jHBnTv3j2rXZT3TEFBQbz66qtx3nnnRe/evaNVq1bRoEGDqFKlSqRSqayvwjfmFyxYsMk158yZE9OmTcu0mzRpsk2/w00pq9dg4d/zeeedF5dffnnMnTu32NcDAAAoCwIDAAAAVBr16tWLiy66KKvvsssu2+b1Zs6cmdXu1KlTsebXqFEj2rVrl2mvWbNmk9uYV0SFPzW+JYVvrN55550b3VTe2lfHjh2z1li0aNFWr9OlS5diX+emm27a6nW2xXHHHRcdOnTItJcvXx7nn39+NG3aNPr27RvXX399vPnmm7F69ertvtYPf/jD7Ro/ffr0LY5/5plnom3bttGrV6+49dZb45VXXolZs2bF0qVLi7Qjw+ZCEt8PC0REdO7ceatrFVVZvQa7du2aFRpYv359XHvttdG8efM45JBD4sorr4xXXnklli1bVmLfGwAAwPYQGAAAAKBSOeuss2KXXXbJtEeOHBmjRo3aprUWL16c1W7cuHGx1yg8p/CaFVW9evWKPHbhwoUlfv3vf1q8rK+zLapVqxbPPvvsRp+2X7t2bYwYMSIuueSSOOSQQ6JBgwbRs2fPuP3227c5XPL9XTa2ZfyWdj249NJL49hjj91qqGBL1qxZs8n+wjfgmzRpss3XKKwsXxv//ve/46CDDsrqKygoiDfffDOGDh0avXv3jh133DEOPvjguPbaa2PGjBklXhsAAEBRCQwAAABQqdSqVSsuv/zyrL5t3WVg+fLlWe0ddtih2GsUnlNZPllcrVq1Io8tjW33N/VJ9rK6zrZq06ZNvP/++5lPnG/KmjVrYtSoUXHuuefGrrvuGmeffXaxXzO1a9cu1vjCr9HCr/vvPPjgg3Hddddl9dWqVSv69u0bl19+edx1113x5JNPxvDhw2PEiBGZr0ceeaRIdRT+PuvUqVOM72LLyvK10bhx43jjjTfizjvvjLZt225yzPr16+Ptt9+Oyy+/PHbffff4xS9+UWl2HwEAACqWqlsfAgAAABXLoEGD4qabbsp8cnfs2LExfPjwOProo4u1TuEblitWrCh2LYXn1K1bt9hrVHSFb2CfdNJJ8atf/Wq71mzWrNlWr3P//fdHixYttus6e++993bNL6x27dpx6aWXxsUXXxxjxoyJV199NUaNGhXjxo2LVatWZY1du3Zt/OUvf4mXX3453njjjSJ/4n7lypXFep0Vfo1u6kb92rVrNzru41e/+lXceOONW93RYMqUKUWqo3DNmwsubIuyeg1+p1q1avHb3/42fvvb38a7774br7zySowaNSrGjh0b33zzTdbYgoKCeOSRRzK7oRTehQIAAKA0CQwAAABQ6VSvXj2uvPLKGDhwYKbv8ssvj6OOOipSqVSR12nYsGFWe1u2NV+wYMEW10yCwscyNGjQIHr37l3q1+nQoUN06dKlxK9TEvLy8uKQQw6JQw45JIYMGRLr1q2Ld999N1588cX497//HVOnTs2MnTJlSgwcODCef/75Iq29YMGCYgUGCr+uGzRosNGYUaNGZX0Cvm/fvnHvvfcWaf3CRw1szo477pjVnjdvXpHmFUVZvQY3Zf/994/9998/LrrooigoKIgJEybEiy++GP/5z39iwoQJmXFz586Nn/70pzFhwoTIy7MpKAAAUDb81wcAAACV0sknnxzt2rXLtD/88MN4/PHHi7VGq1atstrfv7lXFGvWrMn6dHWNGjWiadOmxVqjMmjdunVW+/s3wyvidUpDtWrV4uCDD46hQ4fGZ599Fn/729+ybhq/8MILMXny5CKt9fHHHxfr2h999FFWu/DPMSLi7bffzmoPHjy4yOt/8sknRRpXePv+9957r8jX2Jry8trIy8uLfffdNy655JL48MMP44knnohatWplnv/444/jpZdeykltAABAMgkMAAAAUClVqVIlrrrqqqy+K664IjZs2FDkNQ466KCs9qhRoyKdThd5/ujRo2PdunWZ9n777RfVq1cv8vzKokuXLllbwo8dOzZWr15d4tfp2bNnVvvVV18t8WuUhVQqFYMHD46f/exnWf1vvvlmkea//vrrxbreG2+8kdXe1K4M399dICKKtW1+UX8PO++8c+yxxx6Z9rx58+Ldd98t8nW2pKxeg8X14x//OM4777ysvqL+ngEAAEqCwAAAAACV1k9/+tPYd999M+1PP/00Hn744SLP33PPPbN2BJg5c2a89tprRZ5/3333ZbW7d+9e5LmVSfXq1eOwww7LtFesWBH3339/iV+nd+/eUbXq/z998bHHHtumYyTKi27dumW1Cx9vsTmPPfZYVlBlS0aPHh1ffPFFpr3zzjtvMgxQOCizdu3aIq3/9ddfx5NPPlmksRERRxxxRFb7jjvuKPLcLSmr1+C22NbfMwAAQEkQGAAAAKDSSqVScc0112T1DR06tMg3U1OpVJx22mlZfRdccEGRdikYP358PPbYY1lrDRo0qEjXrYwuuOCCrPaQIUNi1qxZJXqNpk2bxi9+8YtMe8WKFXHmmWeW6DXKUuEbxw0bNizSvPz8/CLdaE+n03HRRRdl9Q0cODBSqdRGY3feeeesdlE/Bf+73/0u1qxZU6Sx343//lEMjzzySLz88stFnr8lZfEa3Bbb+nsGAAAoCQIDAAAAVGpHHXVU1id4Z8yYEV999VWR5//2t7/NOmP8/fffjzPOOGOLRxPMmjUrfvrTn2aNGTBgQOy+++6bndOjR49IpVKZryuvvLLINVYEhx56aBx++OGZ9vz586Nv377x6aefFnmNgoKCePrppze6yf19l19+edbW8//5z3/i9NNPL/In4iMiFi1aFNdcc008++yzRZ6zNT//+c+LdVTA4sWL45577snq69y5c5HnX3bZZVvdDeO8886Lt956K9OuWbNmnHHGGZsc27Vr16z29ddfv9VPwl9++eUxbNiwIlb8rT322CPrKIZ0Oh3HHXdcjBo1qkjzV6xYEW+//fYmnyuL1+CZZ54Zzz77bJGPLlmzZs1G4Y7i/J4BAAC2l8AAAAAAld611167zXNbtGgRN954Y1bfPffcE4cddthGNyZXrFgR9957b3Tu3Dm+/PLLTP+OO+4Yf/vb37a5hsrioYceipYtW2baU6ZMic6dO8fvf//7mDBhwiZvsi5evDhGjhwZ5557buy2227xox/9KMaNG7fZa7Rp0ybuvfferL677ror9tprr7j77rvj66+/3mhOOp2OadOmxcMPPxw//vGPo0WLFvHHP/6xRI8zGD58ePTo0SM6dOgQQ4YMibfeeitWrly50bhVq1bFsGHD4sADD4yZM2dm+vfee+844IADinStVq1axZo1a+KII46IoUOHxvz587Oe/+ijj6J///5x2223ZfVfccUV0apVq02u2b1796znvvzyy+jWrVuMGDEi6/eWTqdj7Nix0adPn8z7rn379kWq+zt//etfo02bNpn2N998E717945BgwbF+++/v9HrZPXq1fHmm2/GueeeG61atYp//OMfm127tF+DY8aMif79+0fr1q3j/PPPj1GjRsU333yz0bh169bFiy++GN26dYt33nkn07/zzjtHv379Nv/DAQAAKGGpdFEjzwAAAJBDu+22W9YN1MWLF0eDBg2KPL9v374xYsSITT63tbXS6XSceuqp8fDDD2/03E477RQtW7aM1atXx/Tp02PVqlVZz9eqVSueeuqprE82b0qPHj2yPoE+ZMiQUtllYMaMGdG6detM+9RTT40HHnhgq/NGjRoVPXv23O76Pvroozj66KOzAhXfqV+/fjRv3jzq1q0by5cvj0WLFsWcOXM2Gte9e/etfuL81ltvjQsuuCAKCgo2eq5ly5bRuHHjqFq1aixZsiTmzp0by5Yt22jc/fffHwMHDizy97YlDRo0iKVLl2b1ValSJVq0aBE77rhjVK9ePf5fe3f32uP/B3D89fm6WWM3jTBblLkpxjaiiJTEtOXmhJxI/gVSEkfagcWJlDPC4aS0iBMH2GqrKaRlq2G2JmZjReLzse8R/WabzX3f3/V4HF7Xe+/rfX26jnY9r+t6/fp1dHR0DPtkxpQpU+L27duxYsWKEef++tq5efNmbN68OdLpdERETJw4MebNmxf5+fnR09MT3d3dw+aorKyM+vr6mDRp0qjnUFdXF7t27Rq2vaCgIEpKSiKTyURnZ2f09fV92Tdr1qyoq6uL9evXf9k2nmvu4cOHsWXLlujq6hq2b9q0aVFcXBzZ2dnR398fT548GfKbjTX/77wGKyoq4t69e0O2pVKpKC4ujunTp0d2dnYMDAxER0dHvH//fsi4CRMmxJUrV6K6unrUtQMAAPxqE//2AgAAAOBPqKmpGTUYGEsqlYrz589HYWFhnDx5cshN6JcvXw57gvuzwsLCqKuri3Xr1v3Qcf8fLVu2LFpaWmLPnj1x48aNIfvevHkz7Kb6SObOnTvmmP3790dpaWns27dv2A3fZ8+ejXiz+H9lZWXFzJkzxzzOz8hkMvH06dMhIczXiouLo66ubtRYYCQbNmyIixcvxt69e+PDhw+RTqejvb191PFVVVVx6dKlb8YCERE7d+6MmpqaOHLkyJAn8fv7+6OlpWXY+Dlz5sS1a9ciJydn3Gv/rLS0NJqammLnzp3R2Ng4ZF9fX9+QKOF7/alr8LPBwcHo6uoaMX74rKCgIM6dOycWAAAA/jifJAAAACARVq1aFTt27Pjhv0+lUlFbWxt3796Nbdu2RVZW1qhji4qK4ujRo9He3i4WGMGMGTPi+vXrcevWrdi6dWtMnTr1m+NTqVQsX748Dh06FPfv348LFy6M6ziVlZXR0dERp06dirKyskilUt8cn5OTE9XV1XHmzJno6emJqqqqcZ/TWJqbm6O2tjY2btw45vlGRCxYsCCOHTsWjx49ijVr1nz38Xbv3h3Nzc2xadOmUceUlJTE2bNn4+rVq5GdnT2ueQ8fPhxXr16N8vLyUcfk5eXFgQMH4sGDB7F06dLvXvtnRUVF0dDQEJcvX461a9fGhAkTRh2bSqWioqIijh8/HidOnBhz7t91DdbX18fp06ejurp6XG9AKSoqioMHD0ZbW1ts3759zPEAAAC/mk8SAAAAwA949+5d3LlzJzo7O6O3t/fLE+mlpaVRUVHxt5f3n/Lx48dobm6Ox48fR29vb7x9+zamTp0aBQUFsWjRoliyZEnk5+f/9HFevnwZTU1N8fz583j16lV8+vQp8vLyorCwMBYvXhwLFy4c8yn7XyGTyURra2u0t7dHd3f3l88h5ObmRnFxcVRUVAz5bMRYvv4kwdf/6unq6oqGhobo7OyMdDods2fPjqVLl8bKlSt/6jxaW1ujqakpXrx4Eel0OqZPnx6LFy+O1atXx+TJk39q7pH09/dHY2Nj9PT0RG9vb6RSqcjPz4/58+dHeXn5T70R4ndcg4ODg9HW1hbt7e3R2dkZAwMDkclkIjc3NwoLC6OsrCwWLVoU//zjeR4AAODvEQwAAAAA/IeNFQwAAADAaCTMAAAAAAAAAJBAggEAAAAAAAAASCDBAAAAAAAAAAAkkGAAAAAAAAAAABJIMAAAAAAAAAAACSQYAAAAAAAAAIAEEgwAAAAAAAAAQAKlBgcHB//2IgAAAAAAAACAP8sbBgAAAAAAAAAggQQDAAAAAAAAAJBAggEAAAAAAAAASCDBAAAAAAAAAAAkkGAAAAAAAAAAABJIMAAAAAAAAAAACSQYAAAAAAAAAIAEEgwAAAAAAAAAQAIJBgAAAAAAAAAggQQDAAAAAAAAAJBAggEAAAAAAAAASCDBAAAAAAAAAAAkkGAAAAAAAAAAABJIMAAAAAAAAAAACSQYAAAAAAAAAIAEEgwAAAAAAAAAQAIJBgAAAAAAAAAggQQDAAAAAAAAAJBAggEAAAAAAAAASCDBAAAAAAAAAAAkkGAAAAAAAAAAABJIMAAAAAAAAAAACSQYAAAAAAAAAIAEEgwAAAAAAAAAQAIJBgAAAAAAAAAggQQDAAAAAAAAAJBAggEAAAAAAAAASCDBAAAAAAAAAAAk0L9XpOkNxoWZHgAAAABJRU5ErkJggg==", "text/plain": [ "
" ] @@ -1213,7 +1213,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 30, @@ -1222,7 +1222,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1546,7 +1546,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1592,7 +1592,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 36, @@ -1601,7 +1601,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1861,7 +1861,7 @@ "metadata": { "celltoolbar": "Tags", "kernelspec": { - "display_name": "matching", + "display_name": ".venv", "language": "python", "name": "python3" }, @@ -1875,7 +1875,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.10" + "version": "3.13.1" } }, "nbformat": 4, diff --git a/pyproject.toml b/pyproject.toml index 4030698..3c31cb9 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -46,6 +46,7 @@ docs = [ "ipython>=7.34.0", "matplotlib>=3.10.1", "nbsphinx>=0.9.7", + "pandas>=2.2.3", "pyyaml>=6.0.1", "quartodoc>=0.9.1", ] diff --git a/uv.lock b/uv.lock index 63d2496..b057407 100644 --- a/uv.lock +++ b/uv.lock @@ -1,7 +1,9 @@ version = 1 +revision = 1 requires-python = ">=3.10" resolution-markers = [ - "python_full_version >= '3.11'", + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", "python_full_version < '3.11'", ] @@ -679,7 +681,8 @@ name = "ipython" version = "9.0.2" source = { registry = "https://pypi.org/simple" } resolution-markers = [ - "python_full_version >= '3.11'", + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", ] dependencies = [ { name = "colorama", marker = "python_full_version >= '3.11' and sys_platform == 'win32'" }, @@ -974,6 +977,7 @@ dev = [ { name = "matplotlib" }, { name = "nbsphinx" }, { name = "nbval" }, + { name = "pandas" }, { name = "pytest" }, { name = "pytest-cov" }, { name = "pytest-randomly" }, @@ -987,6 +991,7 @@ docs = [ { name = "ipython", version = "9.0.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, { name = "matplotlib" }, { name = "nbsphinx" }, + { name = "pandas" }, { name = "pyyaml" }, { name = "quartodoc" }, ] @@ -1007,6 +1012,7 @@ requires-dist = [ { name = "nbsphinx", marker = "extra == 'docs'", specifier = ">=0.9.7" }, { name = "nbval", marker = "extra == 'test'", specifier = ">=0.11.0" }, { name = "numpy", specifier = ">=2.2.4" }, + { name = "pandas", marker = "extra == 'docs'", specifier = ">=2.2.3" }, { name = "pytest", marker = "extra == 'test'", specifier = ">=7.4.4" }, { name = "pytest-cov", marker = "extra == 'test'", specifier = ">=6.0.0" }, { name = "pytest-randomly", marker = "extra == 'test'", specifier = ">=3.16.0" }, @@ -1016,6 +1022,7 @@ requires-dist = [ { name = "ruff", marker = "extra == 'dev'", specifier = ">=0.11.1" }, { name = "scipy", specifier = ">=1.11.3" }, ] +provides-extras = ["test", "docs", "dev"] [[package]] name = "matplotlib" @@ -1279,6 +1286,54 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/88/ef/eb23f262cca3c0c4eb7ab1933c3b1f03d021f2c48f54763065b6f0e321be/packaging-24.2-py3-none-any.whl", hash = "sha256:09abb1bccd265c01f4a3aa3f7a7db064b36514d2cba19a2f694fe6150451a759", size = 65451 }, ] +[[package]] +name = "pandas" +version = "2.2.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy" }, + { name = "python-dateutil" }, + { name = "pytz" }, + { name = "tzdata" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/9c/d6/9f8431bacc2e19dca897724cd097b1bb224a6ad5433784a44b587c7c13af/pandas-2.2.3.tar.gz", hash = "sha256:4f18ba62b61d7e192368b84517265a99b4d7ee8912f8708660fb4a366cc82667", size = 4399213 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/aa/70/c853aec59839bceed032d52010ff5f1b8d87dc3114b762e4ba2727661a3b/pandas-2.2.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:1948ddde24197a0f7add2bdc4ca83bf2b1ef84a1bc8ccffd95eda17fd836ecb5", size = 12580827 }, + { url = "https://files.pythonhosted.org/packages/99/f2/c4527768739ffa4469b2b4fff05aa3768a478aed89a2f271a79a40eee984/pandas-2.2.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:381175499d3802cde0eabbaf6324cce0c4f5d52ca6f8c377c29ad442f50f6348", size = 11303897 }, + { url = "https://files.pythonhosted.org/packages/ed/12/86c1747ea27989d7a4064f806ce2bae2c6d575b950be087837bdfcabacc9/pandas-2.2.3-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d9c45366def9a3dd85a6454c0e7908f2b3b8e9c138f5dc38fed7ce720d8453ed", size = 66480908 }, + { url = "https://files.pythonhosted.org/packages/44/50/7db2cd5e6373ae796f0ddad3675268c8d59fb6076e66f0c339d61cea886b/pandas-2.2.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:86976a1c5b25ae3f8ccae3a5306e443569ee3c3faf444dfd0f41cda24667ad57", size = 13064210 }, + { url = "https://files.pythonhosted.org/packages/61/61/a89015a6d5536cb0d6c3ba02cebed51a95538cf83472975275e28ebf7d0c/pandas-2.2.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:b8661b0238a69d7aafe156b7fa86c44b881387509653fdf857bebc5e4008ad42", size = 16754292 }, + { url = "https://files.pythonhosted.org/packages/ce/0d/4cc7b69ce37fac07645a94e1d4b0880b15999494372c1523508511b09e40/pandas-2.2.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:37e0aced3e8f539eccf2e099f65cdb9c8aa85109b0be6e93e2baff94264bdc6f", size = 14416379 }, + { url = "https://files.pythonhosted.org/packages/31/9e/6ebb433de864a6cd45716af52a4d7a8c3c9aaf3a98368e61db9e69e69a9c/pandas-2.2.3-cp310-cp310-win_amd64.whl", hash = "sha256:56534ce0746a58afaf7942ba4863e0ef81c9c50d3f0ae93e9497d6a41a057645", size = 11598471 }, + { url = "https://files.pythonhosted.org/packages/a8/44/d9502bf0ed197ba9bf1103c9867d5904ddcaf869e52329787fc54ed70cc8/pandas-2.2.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:66108071e1b935240e74525006034333f98bcdb87ea116de573a6a0dccb6c039", size = 12602222 }, + { url = "https://files.pythonhosted.org/packages/52/11/9eac327a38834f162b8250aab32a6781339c69afe7574368fffe46387edf/pandas-2.2.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:7c2875855b0ff77b2a64a0365e24455d9990730d6431b9e0ee18ad8acee13dbd", size = 11321274 }, + { url = "https://files.pythonhosted.org/packages/45/fb/c4beeb084718598ba19aa9f5abbc8aed8b42f90930da861fcb1acdb54c3a/pandas-2.2.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:cd8d0c3be0515c12fed0bdbae072551c8b54b7192c7b1fda0ba56059a0179698", size = 15579836 }, + { url = "https://files.pythonhosted.org/packages/cd/5f/4dba1d39bb9c38d574a9a22548c540177f78ea47b32f99c0ff2ec499fac5/pandas-2.2.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c124333816c3a9b03fbeef3a9f230ba9a737e9e5bb4060aa2107a86cc0a497fc", size = 13058505 }, + { url = "https://files.pythonhosted.org/packages/b9/57/708135b90391995361636634df1f1130d03ba456e95bcf576fada459115a/pandas-2.2.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:63cc132e40a2e084cf01adf0775b15ac515ba905d7dcca47e9a251819c575ef3", size = 16744420 }, + { url = "https://files.pythonhosted.org/packages/86/4a/03ed6b7ee323cf30404265c284cee9c65c56a212e0a08d9ee06984ba2240/pandas-2.2.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:29401dbfa9ad77319367d36940cd8a0b3a11aba16063e39632d98b0e931ddf32", size = 14440457 }, + { url = "https://files.pythonhosted.org/packages/ed/8c/87ddf1fcb55d11f9f847e3c69bb1c6f8e46e2f40ab1a2d2abadb2401b007/pandas-2.2.3-cp311-cp311-win_amd64.whl", hash = "sha256:3fc6873a41186404dad67245896a6e440baacc92f5b716ccd1bc9ed2995ab2c5", size = 11617166 }, + { url = "https://files.pythonhosted.org/packages/17/a3/fb2734118db0af37ea7433f57f722c0a56687e14b14690edff0cdb4b7e58/pandas-2.2.3-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:b1d432e8d08679a40e2a6d8b2f9770a5c21793a6f9f47fdd52c5ce1948a5a8a9", size = 12529893 }, + { url = "https://files.pythonhosted.org/packages/e1/0c/ad295fd74bfac85358fd579e271cded3ac969de81f62dd0142c426b9da91/pandas-2.2.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:a5a1595fe639f5988ba6a8e5bc9649af3baf26df3998a0abe56c02609392e0a4", size = 11363475 }, + { url = "https://files.pythonhosted.org/packages/c6/2a/4bba3f03f7d07207481fed47f5b35f556c7441acddc368ec43d6643c5777/pandas-2.2.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:5de54125a92bb4d1c051c0659e6fcb75256bf799a732a87184e5ea503965bce3", size = 15188645 }, + { url = "https://files.pythonhosted.org/packages/38/f8/d8fddee9ed0d0c0f4a2132c1dfcf0e3e53265055da8df952a53e7eaf178c/pandas-2.2.3-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fffb8ae78d8af97f849404f21411c95062db1496aeb3e56f146f0355c9989319", size = 12739445 }, + { url = "https://files.pythonhosted.org/packages/20/e8/45a05d9c39d2cea61ab175dbe6a2de1d05b679e8de2011da4ee190d7e748/pandas-2.2.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:6dfcb5ee8d4d50c06a51c2fffa6cff6272098ad6540aed1a76d15fb9318194d8", size = 16359235 }, + { url = "https://files.pythonhosted.org/packages/1d/99/617d07a6a5e429ff90c90da64d428516605a1ec7d7bea494235e1c3882de/pandas-2.2.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:062309c1b9ea12a50e8ce661145c6aab431b1e99530d3cd60640e255778bd43a", size = 14056756 }, + { url = "https://files.pythonhosted.org/packages/29/d4/1244ab8edf173a10fd601f7e13b9566c1b525c4f365d6bee918e68381889/pandas-2.2.3-cp312-cp312-win_amd64.whl", hash = "sha256:59ef3764d0fe818125a5097d2ae867ca3fa64df032331b7e0917cf5d7bf66b13", size = 11504248 }, + { url = "https://files.pythonhosted.org/packages/64/22/3b8f4e0ed70644e85cfdcd57454686b9057c6c38d2f74fe4b8bc2527214a/pandas-2.2.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f00d1345d84d8c86a63e476bb4955e46458b304b9575dcf71102b5c705320015", size = 12477643 }, + { url = "https://files.pythonhosted.org/packages/e4/93/b3f5d1838500e22c8d793625da672f3eec046b1a99257666c94446969282/pandas-2.2.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:3508d914817e153ad359d7e069d752cdd736a247c322d932eb89e6bc84217f28", size = 11281573 }, + { url = "https://files.pythonhosted.org/packages/f5/94/6c79b07f0e5aab1dcfa35a75f4817f5c4f677931d4234afcd75f0e6a66ca/pandas-2.2.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:22a9d949bfc9a502d320aa04e5d02feab689d61da4e7764b62c30b991c42c5f0", size = 15196085 }, + { url = "https://files.pythonhosted.org/packages/e8/31/aa8da88ca0eadbabd0a639788a6da13bb2ff6edbbb9f29aa786450a30a91/pandas-2.2.3-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f3a255b2c19987fbbe62a9dfd6cff7ff2aa9ccab3fc75218fd4b7530f01efa24", size = 12711809 }, + { url = "https://files.pythonhosted.org/packages/ee/7c/c6dbdb0cb2a4344cacfb8de1c5808ca885b2e4dcfde8008266608f9372af/pandas-2.2.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:800250ecdadb6d9c78eae4990da62743b857b470883fa27f652db8bdde7f6659", size = 16356316 }, + { url = "https://files.pythonhosted.org/packages/57/b7/8b757e7d92023b832869fa8881a992696a0bfe2e26f72c9ae9f255988d42/pandas-2.2.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6374c452ff3ec675a8f46fd9ab25c4ad0ba590b71cf0656f8b6daa5202bca3fb", size = 14022055 }, + { url = "https://files.pythonhosted.org/packages/3b/bc/4b18e2b8c002572c5a441a64826252ce5da2aa738855747247a971988043/pandas-2.2.3-cp313-cp313-win_amd64.whl", hash = "sha256:61c5ad4043f791b61dd4752191d9f07f0ae412515d59ba8f005832a532f8736d", size = 11481175 }, + { url = "https://files.pythonhosted.org/packages/76/a3/a5d88146815e972d40d19247b2c162e88213ef51c7c25993942c39dbf41d/pandas-2.2.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:3b71f27954685ee685317063bf13c7709a7ba74fc996b84fc6821c59b0f06468", size = 12615650 }, + { url = "https://files.pythonhosted.org/packages/9c/8c/f0fd18f6140ddafc0c24122c8a964e48294acc579d47def376fef12bcb4a/pandas-2.2.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:38cf8125c40dae9d5acc10fa66af8ea6fdf760b2714ee482ca691fc66e6fcb18", size = 11290177 }, + { url = "https://files.pythonhosted.org/packages/ed/f9/e995754eab9c0f14c6777401f7eece0943840b7a9fc932221c19d1abee9f/pandas-2.2.3-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:ba96630bc17c875161df3818780af30e43be9b166ce51c9a18c1feae342906c2", size = 14651526 }, + { url = "https://files.pythonhosted.org/packages/25/b0/98d6ae2e1abac4f35230aa756005e8654649d305df9a28b16b9ae4353bff/pandas-2.2.3-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1db71525a1538b30142094edb9adc10be3f3e176748cd7acc2240c2f2e5aa3a4", size = 11871013 }, + { url = "https://files.pythonhosted.org/packages/cc/57/0f72a10f9db6a4628744c8e8f0df4e6e21de01212c7c981d31e50ffc8328/pandas-2.2.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:15c0e1e02e93116177d29ff83e8b1619c93ddc9c49083f237d4312337a61165d", size = 15711620 }, + { url = "https://files.pythonhosted.org/packages/ab/5f/b38085618b950b79d2d9164a711c52b10aefc0ae6833b96f626b7021b2ed/pandas-2.2.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:ad5b65698ab28ed8d7f18790a0dc58005c7629f227be9ecc1072aa74c0c1d43a", size = 13098436 }, +] + [[package]] name = "pandocfilters" version = "1.5.1" @@ -1646,6 +1701,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/ec/57/56b9bcc3c9c6a792fcbaf139543cee77261f3651ca9da0c93f5c1221264b/python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427", size = 229892 }, ] +[[package]] +name = "pytz" +version = "2025.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f8/bf/abbd3cdfb8fbc7fb3d4d38d320f2441b1e7cbe29be4f23797b4a2b5d8aac/pytz-2025.2.tar.gz", hash = "sha256:360b9e3dbb49a209c21ad61809c7fb453643e048b38924c765813546746e81c3", size = 320884 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/81/c4/34e93fe5f5429d7570ec1fa436f1986fb1f00c3e0f43a589fe2bbcd22c3f/pytz-2025.2-py2.py3-none-any.whl", hash = "sha256:5ddf76296dd8c44c26eb8f4b6f35488f3ccbf6fbbd7adee0b7262d43f0ec2f00", size = 509225 }, +] + [[package]] name = "pywin32" version = "310" @@ -2266,6 +2330,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/26/9f/ad63fc0248c5379346306f8668cda6e2e2e9c95e01216d2b8ffd9ff037d0/typing_extensions-4.12.2-py3-none-any.whl", hash = "sha256:04e5ca0351e0f3f85c6853954072df659d0d13fac324d0072316b67d7794700d", size = 37438 }, ] +[[package]] +name = "tzdata" +version = "2025.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/95/32/1a225d6164441be760d75c2c42e2780dc0873fe382da3e98a2e1e48361e5/tzdata-2025.2.tar.gz", hash = "sha256:b60a638fcc0daffadf82fe0f57e53d06bdec2f36c4df66280ae79bce6bd6f2b9", size = 196380 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5c/23/c7abc0ca0a1526a0774eca151daeb8de62ec457e77262b66b359c3c7679e/tzdata-2025.2-py2.py3-none-any.whl", hash = "sha256:1a403fada01ff9221ca8044d701868fa132215d84beb92242d9acd2147f667a8", size = 347839 }, +] + [[package]] name = "urllib3" version = "2.3.0" From 648cefdc63113d0890ecc9640da91d9532792bf1 Mon Sep 17 00:00:00 2001 From: Henry Wilde Date: Thu, 15 May 2025 12:38:42 +0100 Subject: [PATCH 22/26] Update how-tos and CI workflow --- .github/workflows/ci.yml | 16 +++++++++------- docs/how-to/check_matching_status.ipynb | 6 +++--- docs/how-to/choose_optimality.ipynb | 8 ++++---- 3 files changed, 16 insertions(+), 14 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 18f17b2..955fc7d 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -30,13 +30,6 @@ jobs: - name: Install the project run: uv sync --all-extras - - name: Run tests - run: | - uv run python -m doctest README.md - uv run pytest docs --nbval --nbval-current-env -p no:randomly - uv run pytest tests \ - --cov=matching --cov-fail-under=100 --hypothesis-profile=ci - - name: Run linters (3.13-ubuntu only) if: | matrix.python-version == '3.13' && @@ -44,3 +37,12 @@ jobs: run: | uv run ruff format --check . uv run ruff check . + + - name: Run documentation tests + run: | + uv run python -m doctest README.md + uv run pytest docs --nbval --nbval-current-env -p no:randomly + + - name: Run unit tests + run: | + uv run pytest tests --cov --cov-fail-under=100 --hypothesis-profile=ci diff --git a/docs/how-to/check_matching_status.ipynb b/docs/how-to/check_matching_status.ipynb index bf7f74a..779a7b8 100644 --- a/docs/how-to/check_matching_status.ipynb +++ b/docs/how-to/check_matching_status.ipynb @@ -83,9 +83,9 @@ ], "metadata": { "kernelspec": { - "display_name": "matching-docs", + "display_name": ".venv", "language": "python", - "name": "matching-docs" + "name": "python3" }, "language_info": { "codemirror_mode": { @@ -97,7 +97,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.16" + "version": "3.13.1" } }, "nbformat": 4, diff --git a/docs/how-to/choose_optimality.ipynb b/docs/how-to/choose_optimality.ipynb index d6c2544..5747d0b 100644 --- a/docs/how-to/choose_optimality.ipynb +++ b/docs/how-to/choose_optimality.ipynb @@ -47,7 +47,7 @@ { "data": { "text/plain": [ - "SingleMatching({'Y': 'C', 'Z': 'B', 'X': 'A'}, keys=\"reviewers\", values=\"suitors\")" + "SMMatching({'Y': 'C', 'Z': 'B', 'X': 'A'}, keys=\"reviewers\", values=\"suitors\")" ] }, "execution_count": 2, @@ -69,7 +69,7 @@ { "data": { "text/plain": [ - "SingleMatching({'Y': 'A', 'Z': 'B', 'X': 'C'}, keys=\"reviewers\", values=\"suitors\")" + "SMMatching({'Y': 'A', 'Z': 'B', 'X': 'C'}, keys=\"reviewers\", values=\"suitors\")" ] }, "execution_count": 3, @@ -86,7 +86,7 @@ ], "metadata": { "kernelspec": { - "display_name": "matching", + "display_name": ".venv", "language": "python", "name": "python3" }, @@ -100,7 +100,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.10" + "version": "3.13.1" } }, "nbformat": 4, From 8de017dd479f0ca0ffd27477e1aff1487dbc91b7 Mon Sep 17 00:00:00 2001 From: Henry Wilde Date: Thu, 15 May 2025 13:21:22 +0100 Subject: [PATCH 23/26] Reach 100% coverage on HR components --- tests/hospital_resident/strategies.py | 2 +- tests/hospital_resident/test_algorithm.py | 41 ++++++++++------------- 2 files changed, 19 insertions(+), 24 deletions(-) diff --git a/tests/hospital_resident/strategies.py b/tests/hospital_resident/strategies.py index 688a979..63c0b11 100644 --- a/tests/hospital_resident/strategies.py +++ b/tests/hospital_resident/strategies.py @@ -33,7 +33,7 @@ def st_capacities(draw, hmin=1, hmax=3): """Create a capacity vector.""" size = draw(st.integers(hmin, hmax)) - capacities = draw(st.lists(st.integers(1, 3), min_size=size, max_size=size)) + capacities = draw(st.lists(st.integers(1, 2), min_size=size, max_size=size)) return np.array(capacities) diff --git a/tests/hospital_resident/test_algorithm.py b/tests/hospital_resident/test_algorithm.py index 424b373..4a07c6b 100644 --- a/tests/hospital_resident/test_algorithm.py +++ b/tests/hospital_resident/test_algorithm.py @@ -29,9 +29,9 @@ def test_resident_optimal_resident_optimal(ranks_capacities): """ Check the resident-optimal algorithm is optimal for residents. - We affirm this by going through the matching and checking that - for each resident, if they prefer a hospital to their current match, - then the hospital prefers their matches to the resident. + We affirm this by going through the residents and checking that + either they are unmatched or they prefer their match to any other + hospital. """ resident_ranks, hospital_ranks, capacities = ranks_capacities game = mocked_game(HospitalResident, *ranks_capacities) @@ -40,15 +40,13 @@ def test_resident_optimal_resident_optimal(ranks_capacities): _assert_matching_is_valid_shape(matching, hospital_ranks, resident_ranks, capacities) - for hospital, residents in matching.items(): - for resident in residents: - resident_rank = game.resident_ranks[resident] - preferred_hospitals, *_ = np.where(resident_rank < resident_rank[hospital]) - for preferred in preferred_hospitals: - preferred_rank = game.hospital_ranks[preferred] - partners = matching[preferred] - for partner in partners: - assert preferred_rank[resident] > preferred_rank[partner] + for resident, resident_rank in enumerate(game.resident_ranks): + hospital = next((h for h, rs in matching.items() if resident in rs), None) + if hospital is None: + continue + + preferred_hospitals, *_ = np.where(resident_rank < resident_rank[hospital]) + assert not preferred_hospitals.any() @given(st_ranks_capacities()) @@ -56,10 +54,10 @@ def test_resident_optimal_hospital_pessimal(ranks_capacities): """ Check the resident-optimal algorithm is pessimal for hospitals. - We affirm this by going through the matching and checking that for - each hospital, if they prefer a resident to their worst current - match, then the resident matched to them already or prefers their - match to the hospital. + We affirm this by going through the hospitals and checking that if + they prefer a resident to their worst current match, then the + resident matched to them already or prefers their match to the + hospital. """ resident_ranks, hospital_ranks, capacities = ranks_capacities game = mocked_game(HospitalResident, *ranks_capacities) @@ -81,9 +79,8 @@ def test_resident_optimal_hospital_pessimal(ranks_capacities): preferred_rank = game.resident_ranks[preferred] partner = next((h for h, rs in matching.items() if preferred in rs), None) - if partner is None: - continue + assert partner is not None assert preferred_rank[partner] < preferred_rank[hospital] @@ -113,9 +110,8 @@ def test_hospital_optimal_hospital_optimal(ranks_capacities): for preferred in preferred_residents: preferred_rank = game.resident_ranks[preferred] partner = next((h for h, rs in matching.items() if preferred in rs), None) - if partner is None: - assert False + assert partner is not None assert preferred_rank[partner] < preferred_rank[hospital] @@ -142,9 +138,8 @@ def test_hospital_optimal_resident_pessimal(ranks_capacities): preferred_hospitals, *_ = np.where(resident_rank < resident_rank[hospital]) for preferred in preferred_hospitals: - preferred_matches = matching[preferred] - if not preferred_matches: - assert False + preferred_matches = matching.get(preferred) + assert preferred_matches is not None preferred_rank = game.hospital_ranks[preferred] worst_match = preferred_rank[preferred_matches].max() From 04879b6056bb9b9ca1afadc232dead510d16f86f Mon Sep 17 00:00:00 2001 From: Henry Wilde Date: Thu, 15 May 2025 13:53:38 +0100 Subject: [PATCH 24/26] Write tests for the matching classes --- tests/common.py | 6 + tests/hospital_resident/strategies.py | 30 ++--- tests/matchings/__init__.py | 1 + tests/matchings/test_hospital_resident.py | 109 ++++++++++++++++++ .../test_stable_marriage.py} | 21 ++-- 5 files changed, 140 insertions(+), 27 deletions(-) create mode 100644 tests/matchings/__init__.py create mode 100644 tests/matchings/test_hospital_resident.py rename tests/{test_matchings.py => matchings/test_stable_marriage.py} (84%) diff --git a/tests/common.py b/tests/common.py index 888c2ad..b0c83c3 100644 --- a/tests/common.py +++ b/tests/common.py @@ -50,3 +50,9 @@ def st_single_utilities(draw, nrows: int, ncols: int | None = None): ) return utility + + +@st.composite +def st_sizes(draw, nmin=1, nmax=5): + """Create a size for a side in a game.""" + return draw(st.integers(nmin, nmax)) diff --git a/tests/hospital_resident/strategies.py b/tests/hospital_resident/strategies.py index 63c0b11..9a99d99 100644 --- a/tests/hospital_resident/strategies.py +++ b/tests/hospital_resident/strategies.py @@ -3,24 +3,15 @@ import numpy as np from hypothesis import strategies as st -from ..common import st_single_ranks, st_single_utilities - - -@st.composite -def st_sizes(draw, hmin, hmax, rmin, rmax): - """Create sizes for the resident and hospital sets.""" - - hsize = draw(st.integers(hmin, hmax)) - rsize = draw(st.integers(rmin, rmax)) - - return hsize, rsize +from ..common import st_single_ranks, st_single_utilities, st_sizes @st.composite def st_ranks(draw, hmin=1, hmax=3, rmin=1, rmax=5): """Create a set of rankings for a test.""" - hsize, rsize = draw(st_sizes(hmin, hmax, rmin, rmax)) + hsize = draw(st_sizes(hmin, hmax)) + rsize = draw(st_sizes(rmin, rmax)) resident_ranks = draw(st_single_ranks(rsize, hsize)) hospital_ranks = draw(st_single_ranks(hsize, rsize)) @@ -32,7 +23,7 @@ def st_ranks(draw, hmin=1, hmax=3, rmin=1, rmax=5): def st_capacities(draw, hmin=1, hmax=3): """Create a capacity vector.""" - size = draw(st.integers(hmin, hmax)) + size = draw(st_sizes(hmin, hmax)) capacities = draw(st.lists(st.integers(1, 2), min_size=size, max_size=size)) return np.array(capacities) @@ -42,7 +33,8 @@ def st_capacities(draw, hmin=1, hmax=3): def st_ranks_capacities(draw, hmin=1, hmax=3, rmin=1, rmax=5): """Create a set of rankings and capacities for a test.""" - hsize, rsize = draw(st_sizes(hmin, hmax, rmin, rmax)) + hsize = draw(st_sizes(hmin, hmax)) + rsize = draw(st_sizes(rmin, rmax)) resident_ranks, hospital_ranks = draw(st_ranks(hsize, hsize, rsize, rsize)) capacities = draw(st_capacities(hsize, hsize)) @@ -54,11 +46,12 @@ def st_ranks_capacities(draw, hmin=1, hmax=3, rmin=1, rmax=5): def st_utilities_capacities(draw, hmin=1, hmax=3, rmin=1, rmax=5): """Create a set of utilities and capacities for a test.""" - hsize, rsize = draw(st_sizes(hmin, hmax, rmin, rmax)) + hsize = draw(st_sizes(hmin, hmax)) + rsize = draw(st_sizes(rmin, rmax)) resident_utility = draw(st_single_utilities(rsize, hsize)) hospital_utility = draw(st_single_utilities(hsize, rsize)) - capacities = draw(st_capacities(hsize)) + capacities = draw(st_capacities(hsize, hsize)) return resident_utility, hospital_utility, capacities @@ -67,14 +60,15 @@ def st_utilities_capacities(draw, hmin=1, hmax=3, rmin=1, rmax=5): def st_preferences_capacities(draw, hmin=1, hmax=3, rmin=1, rmax=5): """Create a set of preferences and capacities for a test.""" - hsize, rsize = draw(st_sizes(hmin, hmax, rmin, rmax)) + hsize = draw(st_sizes(hmin, hmax)) + rsize = draw(st_sizes(rmin, rmax)) residents = draw(st.lists(st.integers(), min_size=rsize, max_size=rsize, unique=True)) hospitals = draw(st.lists(st.text(), min_size=hsize, max_size=hsize, unique=True)) resident_preferences = {r: draw(st.permutations(hospitals)) for r in residents} hospital_preferences = {h: draw(st.permutations(residents)) for h in hospitals} - capacities = dict(zip(hospital_preferences, draw(st_capacities(hsize)))) + capacities = dict(zip(hospital_preferences, draw(st_capacities(hsize, hsize)))) return resident_preferences, hospital_preferences, capacities diff --git a/tests/matchings/__init__.py b/tests/matchings/__init__.py new file mode 100644 index 0000000..ad36acb --- /dev/null +++ b/tests/matchings/__init__.py @@ -0,0 +1 @@ +"""Tests for the `matching.matchings` module.""" diff --git a/tests/matchings/test_hospital_resident.py b/tests/matchings/test_hospital_resident.py new file mode 100644 index 0000000..7792f90 --- /dev/null +++ b/tests/matchings/test_hospital_resident.py @@ -0,0 +1,109 @@ +"""Tests for the `HRMatching` class.""" + +from hypothesis import given +from hypothesis import strategies as st + +from matching import matchings + +from ..common import st_sizes + + +@st.composite +def st_params(draw, hmin=1, hmax=3, rmin=1, rmax=5): + """Create a parameter set for a HRMatching instance.""" + + hsize = draw(st_sizes(hmin, hmax)) + rsize = draw(st_sizes(rmin, rmax)) + capacities = draw(st.lists(st.integers(1, 2), min_size=hsize, max_size=hsize)) + + matched_residents = draw(st.lists(st.integers(0, rsize - 1), unique=True)) + if not matched_residents: + matching = None + else: + resident_matching = {} + for resident in matched_residents: + hospital = draw(st.integers(0, hsize - 1)) + if capacities[hospital]: + resident_matching[resident] = hospital + capacities[hospital] -= 1 + + matching = { + hospital: [r for r in resident_matching if resident_matching[r] == hospital] + for hospital in range(hsize) + if hospital in resident_matching.values() + } + + params = dict( + dictionary=matching, keys=draw(st.text(min_size=1)), values=draw(st.text(min_size=1)) + ) + + return params + + +@st.composite +def st_matchings(draw, hmin=1, hmax=3, rmin=1, rmax=5): + """Create a HRMatching instance.""" + + params = draw(st_params(hmin, hmax, rmin, rmax)) + + return matchings.HRMatching(**params) + + +@given(st_params()) +def test_init(params): + """Check that a HRMatching can be created correctly.""" + + matching = matchings.HRMatching(**params) + + assert isinstance(matching, matchings.HRMatching) + assert isinstance(matching, dict) + + dictionary = params["dictionary"] or {} + assert matching.items() == dictionary.items() + assert vars(matching) == {"keys_": params["keys"], "values_": params["values"]} + + +@given(st_matchings()) +def test_repr(matching): + """Check that the string representation of a matching is correct.""" + + repr_ = repr(matching) + + assert isinstance(repr_, str) + assert repr_.startswith("HRMatching") + assert str(dict(matching)) in repr_ + assert matching.keys_ in repr_ + assert matching.values_ in repr_ + + +@given(st_params()) +def test_eq(params): + """Check that two HRMatchings are equal.""" + + matching1 = matchings.HRMatching(**params) + matching2 = matchings.HRMatching(**params) + + assert matching1 == matching2 + assert matching1 is not matching2 + + if params["dictionary"] is not None: + key = next(iter(params["dictionary"].keys())) + matching2[key] = None + + assert matching1 != matching2 + assert vars(matching1) == vars(matching2) + + +@given(st_matchings()) +def test_invert(matching): + """Check that the invert method works correctly.""" + + inverted = matching.invert() + + assert isinstance(inverted, matchings.HRMatching) + assert inverted.keys_ == matching.values_ + assert inverted.values_ == matching.keys_ + + for key, values in matching.items(): + for value in values: + assert inverted[value] == [key] diff --git a/tests/test_matchings.py b/tests/matchings/test_stable_marriage.py similarity index 84% rename from tests/test_matchings.py rename to tests/matchings/test_stable_marriage.py index fe2bc96..da02ef0 100644 --- a/tests/test_matchings.py +++ b/tests/matchings/test_stable_marriage.py @@ -1,16 +1,18 @@ -"""Tests for the `matchings` module.""" +"""Tests for the `SMMatching` class.""" from hypothesis import given from hypothesis import strategies as st from matching import matchings +from ..common import st_sizes + @st.composite -def st_sm_params(draw, min_size=2, max_size=5): +def st_params(draw, min_size=2, max_size=5): """Create a parameter set for a SMMatching instance.""" - size = draw(st.integers(min_size, max_size)) + size = draw(st_sizes(min_size, max_size)) midpoint = size // 2 players = list(range(size)) keys, values = players[:midpoint], players[midpoint:] @@ -25,15 +27,15 @@ def st_sm_params(draw, min_size=2, max_size=5): @st.composite -def st_sms(draw, min_size=2, max_size=5): +def st_matchings(draw, min_size=2, max_size=5): """Create a SMMatching instance.""" - params = draw(st_sm_params(min_size, max_size)) + params = draw(st_params(min_size, max_size)) return matchings.SMMatching(**params) -@given(st_sm_params()) +@given(st_params()) def test_init(params): """Check that a SMMatching can be created correctly.""" @@ -47,7 +49,7 @@ def test_init(params): assert vars(matching) == {"keys_": params["keys"], "values_": params["values"]} -@given(st_sms()) +@given(st_matchings()) def test_repr(matching): """Check that the string representation of a matching is correct.""" @@ -60,7 +62,7 @@ def test_repr(matching): assert matching.values_ in repr_ -@given(st_sm_params()) +@given(st_params()) def test_eq(params): """Check the equivalence dunder works as expected.""" @@ -68,6 +70,7 @@ def test_eq(params): matching2 = matchings.SMMatching(**params) assert matching1 == matching2 + assert matching1 is not matching2 if params["dictionary"] is not None: key = next(iter(params["dictionary"].keys())) @@ -77,7 +80,7 @@ def test_eq(params): assert vars(matching1) == vars(matching2) -@given(st_sms()) +@given(st_matchings()) def test_invert(matching): """Check the matching inverter works as it should.""" From 8a312753c7adafe1c538d4525742bbf11fc5f1ff Mon Sep 17 00:00:00 2001 From: Henry Wilde Date: Thu, 15 May 2025 13:53:48 +0100 Subject: [PATCH 25/26] Get to 100% coverage on SM tests --- tests/stable_marriage/test_algorithm.py | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/tests/stable_marriage/test_algorithm.py b/tests/stable_marriage/test_algorithm.py index 25220bd..6581f03 100644 --- a/tests/stable_marriage/test_algorithm.py +++ b/tests/stable_marriage/test_algorithm.py @@ -32,10 +32,7 @@ def test_stable_marriage_suitor_optimal(ranks): for reviewer, suitor in matching.items(): suitor_rank = game.suitor_ranks[suitor] preferred_reviewers, *_ = np.where(suitor_rank < suitor_rank[reviewer]) - for preferred in preferred_reviewers: - preferred_rank = game.reviewer_ranks[preferred] - partner = matching[preferred] - assert preferred_rank[suitor] > preferred_rank[partner] + assert not preferred_reviewers.any() @given(st_ranks()) From ff6061e283ca41ebab2bb9f7b6aa2118db8e912f Mon Sep 17 00:00:00 2001 From: Henry Wilde Date: Thu, 15 May 2025 14:07:20 +0100 Subject: [PATCH 26/26] Enable branch coverage --- pyproject.toml | 3 +++ 1 file changed, 3 insertions(+) diff --git a/pyproject.toml b/pyproject.toml index 3c31cb9..46bfcd0 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -83,3 +83,6 @@ known-first-party = ["matching"] [tool.ruff.lint.pydocstyle] convention = "numpy" + +[tool.coverage.run] +branch = true