From 6c32b647aa25ce33f3054a4804925b1c032f631c Mon Sep 17 00:00:00 2001 From: Kyle Oliver Date: Sun, 7 May 2023 23:13:53 -0400 Subject: [PATCH 01/17] Initial bit of the plugin --- .flake8 | 2 +- poetry.lock | 42 ++++- pyproject.toml | 14 ++ src/pytest_static/parametric.py | 178 ++++++++++++++++++ src/pytest_static/plugin.py | 21 +++ src/pytest_static/type_sets.py | 227 +++++++++++++++++++++++ tests/conftest.py | 1 + tests/unit_tests/__init__.py | 0 tests/unit_tests/conftest.py | 0 tests/{ => unit_tests}/test_main.py | 0 tests/unit_tests/test_parametric.py | 268 ++++++++++++++++++++++++++++ tests/unit_tests/test_plugin.py | 148 +++++++++++++++ tests/unit_tests/test_type_sets.py | 7 + 13 files changed, 903 insertions(+), 5 deletions(-) create mode 100644 src/pytest_static/parametric.py create mode 100644 src/pytest_static/plugin.py create mode 100644 src/pytest_static/type_sets.py create mode 100644 tests/conftest.py create mode 100644 tests/unit_tests/__init__.py create mode 100644 tests/unit_tests/conftest.py rename tests/{ => unit_tests}/test_main.py (100%) create mode 100644 tests/unit_tests/test_parametric.py create mode 100644 tests/unit_tests/test_plugin.py create mode 100644 tests/unit_tests/test_type_sets.py diff --git a/.flake8 b/.flake8 index 0f46431..e45d7f9 100644 --- a/.flake8 +++ b/.flake8 @@ -4,6 +4,6 @@ ignore = E203,E501,RST201,RST203,RST301,W503 max-line-length = 80 max-complexity = 10 docstring-convention = google -per-file-ignores = tests/*:S101 +per-file-ignores = tests/*:S101,D100,D101,D102,D103,D104 rst-roles = class,const,func,meth,mod,ref rst-directives = deprecated diff --git a/poetry.lock b/poetry.lock index c9a37e4..289a882 100644 --- a/poetry.lock +++ b/poetry.lock @@ -95,7 +95,7 @@ uvloop = ["uvloop (>=0.15.2)"] [[package]] name = "certifi" -version = "2022.12.7" +version = "2023.5.7" description = "Python package for providing Mozilla's CA Bundle." category = "dev" optional = false @@ -411,6 +411,21 @@ python-versions = "*" six = "*" tornado = {version = "*", markers = "python_version > \"2.7\""} +[[package]] +name = "loguru" +version = "0.7.0" +description = "Python logging made (stupidly) simple" +category = "main" +optional = false +python-versions = ">=3.5" + +[package.dependencies] +colorama = {version = ">=0.3.4", markers = "sys_platform == \"win32\""} +win32-setctime = {version = ">=1.0.0", markers = "sys_platform == \"win32\""} + +[package.extras] +dev = ["Sphinx (==5.3.0)", "colorama (==0.4.5)", "colorama (==0.4.6)", "freezegun (==1.1.0)", "freezegun (==1.2.2)", "mypy (==v0.910)", "mypy (==v0.971)", "mypy (==v0.990)", "pre-commit (==3.2.1)", "pytest (==6.1.2)", "pytest (==7.2.1)", "pytest-cov (==2.12.1)", "pytest-cov (==4.0.0)", "pytest-mypy-plugins (==1.10.1)", "pytest-mypy-plugins (==1.9.3)", "sphinx-autobuild (==2021.3.14)", "sphinx-rtd-theme (==1.2.0)", "tox (==3.27.1)", "tox (==4.4.6)"] + [[package]] name = "markdown-it-py" version = "2.2.0" @@ -1096,6 +1111,17 @@ platformdirs = ">=2,<3" docs = ["proselint (>=0.10.2)", "sphinx (>=3)", "sphinx-argparse (>=0.2.5)", "sphinx-rtd-theme (>=0.4.3)", "towncrier (>=21.3)"] testing = ["coverage (>=4)", "coverage-enable-subprocess (>=1)", "flaky (>=3)", "packaging (>=20.0)", "pytest (>=4)", "pytest-env (>=0.6.2)", "pytest-freezegun (>=0.4.1)", "pytest-mock (>=2)", "pytest-randomly (>=1)", "pytest-timeout (>=1)"] +[[package]] +name = "win32-setctime" +version = "1.1.0" +description = "A small Python utility to set file creation time on Windows" +category = "main" +optional = false +python-versions = ">=3.5" + +[package.extras] +dev = ["black (>=19.3b0)", "pytest (>=4.6.2)"] + [[package]] name = "xdoctest" version = "1.1.1" @@ -1137,7 +1163,7 @@ testing = ["big-o", "flake8 (<5)", "jaraco.functools", "jaraco.itertools", "more [metadata] lock-version = "1.1" python-versions = "^3.7" -content-hash = "1900b973776618b00b3a495afaf7e3577de250e6c7d5068674585f37f4ab5896" +content-hash = "d4deb64ce8bb7377e45d8a748d7391fd973b58fb8a8b46782970f1580fce9e96" [metadata.files] alabaster = [ @@ -1175,8 +1201,8 @@ black = [ {file = "black-22.12.0.tar.gz", hash = "sha256:229351e5a18ca30f447bf724d007f890f97e13af070bb6ad4c0a441cd7596a2f"}, ] certifi = [ - {file = "certifi-2022.12.7-py3-none-any.whl", hash = "sha256:4ad3232f5e926d6718ec31cfc1fcadfde020920e278684144551c91769c7bc18"}, - {file = "certifi-2022.12.7.tar.gz", hash = "sha256:35824b4c3a97115964b408844d64aa14db1cc518f6562e8d7261699d1350a9e3"}, + {file = "certifi-2023.5.7-py3-none-any.whl", hash = "sha256:c6c2e98f5c7869efca1f8916fed228dd91539f9f1b444c314c06eef02980c716"}, + {file = "certifi-2023.5.7.tar.gz", hash = "sha256:0f0d56dc5a6ad56fd4ba36484d6cc34451e1c6548c61daad8c320169f91eddc7"}, ] cfgv = [ {file = "cfgv-3.3.1-py2.py3-none-any.whl", hash = "sha256:c6a0883f3917a037485059700b9e75da2464e6c27051014ad85ba6aaa5884426"}, @@ -1407,6 +1433,10 @@ jinja2 = [ livereload = [ {file = "livereload-2.6.3.tar.gz", hash = "sha256:776f2f865e59fde56490a56bcc6773b6917366bce0c267c60ee8aaf1a0959869"}, ] +loguru = [ + {file = "loguru-0.7.0-py3-none-any.whl", hash = "sha256:b93aa30099fa6860d4727f1b81f8718e965bb96253fa190fab2077aaad6d15d3"}, + {file = "loguru-0.7.0.tar.gz", hash = "sha256:1612053ced6ae84d7959dd7d5e431a0532642237ec21f7fd83ac73fe539e03e1"}, +] markdown-it-py = [ {file = "markdown-it-py-2.2.0.tar.gz", hash = "sha256:7c9a5e412688bc771c67432cbfebcdd686c93ce6484913dccf06cb5a0bea35a1"}, {file = "markdown_it_py-2.2.0-py3-none-any.whl", hash = "sha256:5a35f8d1870171d9acc47b99612dc146129b631baf04970128b568f190d0cc30"}, @@ -1795,6 +1825,10 @@ virtualenv = [ {file = "virtualenv-20.16.2-py2.py3-none-any.whl", hash = "sha256:635b272a8e2f77cb051946f46c60a54ace3cb5e25568228bd6b57fc70eca9ff3"}, {file = "virtualenv-20.16.2.tar.gz", hash = "sha256:0ef5be6d07181946891f5abc8047fda8bc2f0b4b9bf222c64e6e8963baee76db"}, ] +win32-setctime = [ + {file = "win32_setctime-1.1.0-py3-none-any.whl", hash = "sha256:231db239e959c2fe7eb1d7dc129f11172354f98361c4fa2d6d2d7e278baa8aad"}, + {file = "win32_setctime-1.1.0.tar.gz", hash = "sha256:15cf5750465118d6929ae4de4eb46e8edae9a5634350c01ba582df868e932cb2"}, +] xdoctest = [ {file = "xdoctest-1.1.1-py3-none-any.whl", hash = "sha256:d59d4ed91cb92e4430ef0ad1b134a2bef02adff7d2fb9c9f057547bee44081a2"}, {file = "xdoctest-1.1.1.tar.gz", hash = "sha256:2eac8131bdcdf2781b4e5a62d6de87f044b730cc8db8af142a51bb29c245e779"}, diff --git a/pyproject.toml b/pyproject.toml index 8dbe0db..871a4ae 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -10,6 +10,16 @@ repository = "https://github.com/56kyle/pytest-static" documentation = "https://pytest-static.readthedocs.io" classifiers = [ "Development Status :: 1 - Planning", + "Programming Language :: Python :: 3", + "Programming Language :: Python :: 3.7", + "Programming Language :: Python :: 3.8", + "Programming Language :: Python :: 3.9", + "Programming Language :: Python :: 3.10", + "License :: OSI Approved :: MIT License", + "Operating System :: OS Independent", + "Topic :: Software Development :: Testing", + "Framework :: Pytest", + "Framework :: Pytest :: Plugin", ] [tool.poetry.urls] @@ -18,6 +28,7 @@ Changelog = "https://github.com/56kyle/pytest-static/releases" [tool.poetry.dependencies] python = "^3.7" click = ">=8.0.1" +loguru = "^0.7.0" [tool.poetry.dev-dependencies] Pygments = ">=2.10.0" @@ -48,6 +59,9 @@ myst-parser = {version = ">=0.16.1"} [tool.poetry.scripts] pytest-static = "pytest_static.__main__:main" +[tool.poetry.plugins."pytest"] +pytest-static= "pytest_static.plugin" + [tool.coverage.paths] source = ["src", "*/site-packages"] tests = ["tests", "*/tests"] diff --git a/src/pytest_static/parametric.py b/src/pytest_static/parametric.py new file mode 100644 index 0000000..10211d7 --- /dev/null +++ b/src/pytest_static/parametric.py @@ -0,0 +1,178 @@ +"""A Python module used for parameterizing Literal's and common types.""" +import itertools +from dataclasses import dataclass +from dataclasses import field +from enum import Enum +from typing import Any +from typing import Callable +from typing import Dict +from typing import FrozenSet +from typing import Generic +from typing import Iterable +from typing import List +from typing import Literal +from typing import Optional +from typing import Sequence +from typing import Set +from typing import Tuple +from typing import Type +from typing import TypeVar +from typing import Union +from typing import get_args +from typing import get_origin + +from _pytest.python import Metafunc + +from pytest_static.type_sets import PREDEFINED_TYPE_SETS + + +T = TypeVar("T") + + +DEFAULT_SUM_TYPES: Set[Any] = {Union, Optional, Enum} +DEFAULT_PRODUCT_TYPES: Set[Any] = { + List, + list, + Set, + set, + FrozenSet, + frozenset, + Dict, + dict, + Tuple, + tuple, +} + + +@dataclass(frozen=True) +class ExpandedType(Generic[T]): + """A dataclass used to represent a type with expanded type arguments.""" + + primary_type: Type[T] + type_args: Tuple[Union[Any, "ExpandedType[Any]"], ...] + + def get_instances(self) -> Tuple[T, ...]: + """Returns a tuple of all possible instances of the primary_type.""" + type_sets: List[Tuple[T, ...]] = [] + for arg in self.type_args: + if isinstance(arg, ExpandedType): + type_sets.append(arg.get_instances()) + else: + type_sets.append(PREDEFINED_TYPE_SETS.get(arg, arg)) + instances: List[T] = list( + self.primary_type(*args) for args in itertools.product(*type_sets) + ) + return tuple(instances) + + +@dataclass(frozen=True) +class Config: + """A dataclass used to configure the expansion of types.""" + + max_elements: int = 5 + max_depth: int = 5 + custom_handlers: Dict[ + Any, Callable[[Type[T], "Config"], Set[Union[Any, ExpandedType[T]]]] + ] = field(default_factory=dict) + + +DEFAULT_CONFIG: Config = Config() + + +def parametrize_types( + metafunc: Metafunc, + argnames: Union[str, Sequence[str]], + argtypes: List[Type[T]], + ids: Optional[Union[Sequence[str], Callable]] = None, + *args, + **kwargs +) -> None: + """Parametrizes the provided argnames with the provided argtypes.""" + argnames = _ensure_sequence(argnames) + if len(argnames) != len(argtypes): + raise ValueError("The number of argnames and argtypes must be the same.") + + expanded_types = [expand_type(t) for t in argtypes] + type_sets = [list(et) for et in expanded_types] + + # Get instances for each type set + instance_sets = [] + for ts in type_sets: + instances = [] + for t in ts: + if isinstance(t, ExpandedType): + instances.extend(t.get_instances()) + else: + instances.extend(PREDEFINED_TYPE_SETS.get(t, [])) + instance_sets.append(instances) + + instance_combinations = list(itertools.product(*instance_sets)) + + if ids is None: + ids = [", ".join(map(repr, ic)) for ic in instance_combinations] + + metafunc.parametrize(argnames, instance_combinations, ids=ids, *args, **kwargs) + + +def _ensure_sequence(value: Union[str, Sequence[str]]) -> Sequence[str]: + if isinstance(value, str): + return value.split(", ") + return value + + +def return_self(arg: T, *_: Any) -> Set[T]: + """Returns the provided argument.""" + return {arg} + + +def expand_type( + type_arg: Union[Any, Type[T]], config: Config = DEFAULT_CONFIG +) -> Set[Union[Any, ExpandedType[T]]]: + """Expands the provided type into the set of all possible subtype combinations.""" + origin: Any = get_origin(type_arg) or type_arg + + if origin in PREDEFINED_TYPE_SETS: + return {origin} + + type_handlers: Dict[ + Any, Callable[[Type[T], Config], Set[Union[Any, ExpandedType[T]]]] + ] = { + Literal: return_self, + Ellipsis: return_self, + **{sum_type: expand_sum_type for sum_type in DEFAULT_SUM_TYPES}, + **{product_type: expand_product_type for product_type in DEFAULT_PRODUCT_TYPES}, + } + + # Add custom handlers from configuration + type_handlers.update(config.custom_handlers) + + if origin in type_handlers: + return type_handlers[origin](type_arg, config) + + return {type_arg} + + +def expand_sum_type( + type_arg: Type[T], config: Config +) -> Set[Union[Any, ExpandedType[T]]]: + """Expands a sum type into the set of all possible subtype combinations.""" + return { + *itertools.chain.from_iterable( + expand_type(arg, config) for arg in get_args(type_arg) + ) + } + + +def expand_product_type( + type_arg: Type[T], config: Config +) -> Set[Union[Any, ExpandedType[T]]]: + """Expands a product type into the set of all possible subtype combinations.""" + origin: Any = get_origin(type_arg) or type_arg + args: Tuple[Any, ...] = get_args(type_arg) + sets: List[Set[Union[Any, ExpandedType[T]]]] = [ + expand_type(arg, config) for arg in args + ] + product_sets: Tuple[Iterable[Union[Any, ExpandedType[T]]], ...] = tuple( + itertools.product(*sets) + ) + return {ExpandedType(origin, tuple(product_set)) for product_set in product_sets} diff --git a/src/pytest_static/plugin.py b/src/pytest_static/plugin.py new file mode 100644 index 0000000..5907033 --- /dev/null +++ b/src/pytest_static/plugin.py @@ -0,0 +1,21 @@ +"""The pytest-static pytest plugin.""" + +import pytest +from _pytest.python import Metafunc + +from pytest_static.parametric import parametrize_types + + +def pytest_generate_tests(metafunc: Metafunc) -> None: + """Generate parametrized tests for the given argnames and types.""" + for marker in metafunc.definition.iter_markers(name="parametrize_types"): + parametrize_types(metafunc, *marker.args, **marker.kwargs) + + +def pytest_configure(config: pytest.Config) -> None: + """Adds pytest-static plugin markers to the pytest CLI.""" + config.addinivalue_line( + "markers", + "parametrize_types(argnames, types, ids, *args, **kwargs):" + " Generate parametrized tests for the given argnames and types in argvalues.", + ) diff --git a/src/pytest_static/type_sets.py b/src/pytest_static/type_sets.py new file mode 100644 index 0000000..598c2ea --- /dev/null +++ b/src/pytest_static/type_sets.py @@ -0,0 +1,227 @@ +"""Default type sets for pytest_static to use in parametrization.""" +from typing import Any +from typing import Dict +from typing import Set +from typing import Type +from typing import TypeVar + + +T = TypeVar("T", bound=Any) + + +BoolParams: Set[bool] = {True, False} + +IntParams: Set[int] = { + 0, + 1, + -1, + 2, + -2, + 2147483647, + -2147483648, + 9223372036854775807, + -9223372036854775808, +} + +Whitespace: Set[str] = {" ", "\t", "\n", "\r", "\v", "\f"} +SpecialChars: Set[str] = { + "!", + "@", + "#", + "$", + "%", + "^", + "&", + "*", + "(", + ")", + "-", + "+", + "=", + "{", + "}", + "[", + "]", + "|", + "\\", + ";", + ":", + "'", + '"', + ",", + "<", + ".", + ">", + "/", + "?", + "`", + "~", +} +Digits: Set[str] = {"0", "1", "2", "3", "4", "5", "6", "7", "8", "9"} +LowercaseLetters: Set[str] = { + "a", + "b", + "c", + "d", + "e", + "f", + "g", + "h", + "i", + "j", + "k", + "l", + "m", + "n", + "o", + "p", + "q", + "r", + "s", + "t", + "u", + "v", + "w", + "x", + "y", + "z", +} +UppercaseLetters: Set[str] = { + "A", + "B", + "C", + "D", + "E", + "F", + "G", + "H", + "I", + "J", + "K", + "L", + "M", + "N", + "O", + "P", + "Q", + "R", + "S", + "T", + "U", + "V", + "W", + "X", + "Y", + "Z", +} +UnicodeChars: Set[str] = { + "\u00E9", + "\u00F1", + "\u2603", + "\u00A9", + "\u00AE", + "\U0001F600", +} +ForeignChars: Set[str] = {"Д", "д", "ב", "ע", "α", "Ω", "い", "ろ", "は", "我", "们"} +EscapeSequences: Set[str] = { + "\\\\", + "\\'", + '\\"', + "\\n", + "\\r", + "\\t", + "\\x00", + "\\x7F", +} +TripleQuotes: Set[str] = {'"""', "'''"} + +StrParams: Set[str] = { + "", + *Whitespace, + *SpecialChars, + *Digits, + *LowercaseLetters, + *UppercaseLetters, + *UnicodeChars, + *ForeignChars, + *EscapeSequences, + *TripleQuotes, +} + +# Float +FloatParams: Set[float] = { + 0.0, + -0.0, + 1.0, + -1.0, + 1e-10, + -1e-10, + 1e10, + -1e10, + float("inf"), + -float("inf"), + float("nan"), +} + +# Complex +ComplexParams: Set[complex] = { + 0j, + 1j, + -1j, + 1 + 1j, + -1 - 1j, + 1e-10j, + -1e-10j, + 1e10j, + -1e10j, + (1e-10 + 1e-10j), + (-1e-10 - 1e-10j), + (1e10 + 1e10j), + (-1e10 - 1e10j), +} + +# bytes +BytesParams: Set[bytes] = { + b"", + b"\x00", + b"\xFF", + b"\x00\xFF", + b"\xFF\x00", + b" ", + b"\t", + b"\n", + b"\r", + b"\v", + b"\f", + b"0", + b"1", + b"2", + b"3", + b"4", + b"5", + b"6", + b"7", + b"8", + b"9", + b"a", + b"A", + b"z", + b"Z", + b"\x80", + b"\xFE", +} + + +PREDEFINED_TYPE_SETS: Dict[Type[Any], Set[Any]] = { + bool: BoolParams, + int: IntParams, + float: FloatParams, + complex: ComplexParams, + str: StrParams, + bytes: BytesParams, + type(None): {None}, + type(...): {Ellipsis}, + type(NotImplemented): {NotImplemented}, + type(Any): {Any}, + type: {type}, +} diff --git a/tests/conftest.py b/tests/conftest.py new file mode 100644 index 0000000..391394c --- /dev/null +++ b/tests/conftest.py @@ -0,0 +1 @@ +pytest_plugins = ["pytester", "pytest_static.plugin", "pytest_static.p3.plugin"] diff --git a/tests/unit_tests/__init__.py b/tests/unit_tests/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/unit_tests/conftest.py b/tests/unit_tests/conftest.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/test_main.py b/tests/unit_tests/test_main.py similarity index 100% rename from tests/test_main.py rename to tests/unit_tests/test_main.py diff --git a/tests/unit_tests/test_parametric.py b/tests/unit_tests/test_parametric.py new file mode 100644 index 0000000..db2b27e --- /dev/null +++ b/tests/unit_tests/test_parametric.py @@ -0,0 +1,268 @@ +from types import NoneType +from typing import Any +from typing import Dict +from typing import FrozenSet +from typing import List +from typing import Literal +from typing import Optional +from typing import Sequence +from typing import Set +from typing import Tuple +from typing import Type +from typing import TypeVar +from typing import Union + +import pytest +from _pytest.monkeypatch import MonkeyPatch + +from pytest_static.parametric import Config +from pytest_static.parametric import ExpandedType +from pytest_static.parametric import expand_type +from pytest_static.type_sets import PREDEFINED_TYPE_SETS + + +T = TypeVar("T") + + +class DummyClass: + pass + + +class TestExpandedType: + def test_get_instances_with_basic(self): + expanded_type = ExpandedType(list, (int,)) + assert expanded_type.get_instances() == tuple( + [value] for value in PREDEFINED_TYPE_SETS[int] + ) + + def test_get_instances_with_nested(self): + expanded_type = ExpandedType(list, (ExpandedType(list, (int,)),)) + assert expanded_type.get_instances() == tuple( + [[value]] for value in PREDEFINED_TYPE_SETS[int] + ) + + def test_get_instances_with_multiple(self, monkeypatch: MonkeyPatch): + monkeypatch.setitem(PREDEFINED_TYPE_SETS, int, {1, 2}) + monkeypatch.setitem(PREDEFINED_TYPE_SETS, str, {"a", "b"}) + expected_instances: Tuple[List[int, str], ...] = ( + [1, "a"], + [1, "b"], + [2, "a"], + [2, "b"], + ) + expanded_type = ExpandedType(list, (int, str)) + expanded_instances: Tuple[Tuple[Any, ...], ...] = expanded_type.get_instances() + for instance in expected_instances: + assert instance in expanded_instances + + def test_get_instances_with_multiple_nested(self, monkeypatch: MonkeyPatch): + monkeypatch.setitem(PREDEFINED_TYPE_SETS, int, {1, 2}) + monkeypatch.setitem(PREDEFINED_TYPE_SETS, str, {"a", "b"}) + expected_instances: Tuple[List[List[int], str], ...] = ( + [[1], "a"], + [[1], "b"], + [[2], "a"], + [[2], "b"], + ) + expanded_type = ExpandedType(list, (ExpandedType(list, (int,)), str)) + expanded_instances: Tuple[Tuple[Any, ...], ...] = expanded_type.get_instances() + for instance in expected_instances: + assert instance in expanded_instances + + +@pytest.mark.parametrize( + argnames=["type_arg", "expected"], + argvalues=[ + ((DummyClass), {DummyClass}), + ], +) +def test_expand_type_with_non_supported_type( + type_arg: Type[T], expected: Set[Type[T]] +) -> None: + + assert expand_type(type_arg) == expected + + +@pytest.mark.parametrize( + argnames=["type_arg", "expected"], + argvalues=[ + (int, {int}), + (float, {float}), + (complex, {complex}), + (str, {str}), + (bytes, {bytes}), + (bool, {bool}), + (type(None), {NoneType}), + ], +) +def test_base_types(type_arg: Type[T], expected: Set[Type[T]]) -> None: + + assert expand_type(type_arg) == expected + + +@pytest.mark.parametrize( + argnames=["type_arg", "expected"], + argvalues=[ + (List[int], [ExpandedType(list, (int,))]), + (List[List[int]], [ExpandedType(list, (ExpandedType(list, (int,)),))]), + (Dict[str, int], [ExpandedType(dict, (str, int))]), + (Dict[str, List[int]], [ExpandedType(dict, (str, ExpandedType(list, (int,))))]), + (Tuple[int], [ExpandedType(tuple, (int,))]), + (Tuple[int, str], [ExpandedType(tuple, (int, str))]), + (Tuple[int, ...], [ExpandedType(tuple, (int, ...))]), + ( + Tuple[int, Dict[str, int]], + [ExpandedType(tuple, (int, ExpandedType(dict, (str, int))))], + ), + ( + Tuple[int, Union[float, str]], + [ExpandedType(tuple, (int, float)), ExpandedType(tuple, (int, str))], + ), + (Set[str], [ExpandedType(set, (str,))]), + (FrozenSet[str], [ExpandedType(frozenset, (str,))]), + ], + ids=lambda x: str(x), +) +def test_expand_type_with_product_types( + type_arg: Type[T], expected: Sequence[Any] +) -> None: + + assert expand_type(type_arg) == {*expected} + + +@pytest.mark.parametrize( + argnames=["type_arg", "expected"], + argvalues=[ + (Union[int, str], [int, str]), + (Union[int, str, float], [int, str, float]), + (Literal["a", "b", "c"], [Literal["a", "b", "c"]]), + (Optional[int], [int, NoneType]), + (Optional[Optional[int]], [int, NoneType]), + (Optional[Union[int, str]], [int, str, NoneType]), + ], + ids=lambda x: str(x), +) +def test_expand_type_with_sum_types(type_arg: Type[T], expected: Sequence[Any]) -> None: + + assert expand_type(type_arg) == {*expected} + + +@pytest.mark.parametrize( + argnames=["type_arg", "expected"], + argvalues=[ + (List[int], [ExpandedType(list, (int,))]), + (List[List[int]], [ExpandedType(list, (ExpandedType(list, (int,)),))]), + (Dict[str, int], [ExpandedType(dict, (str, int))]), + (Dict[str, List[int]], [ExpandedType(dict, (str, ExpandedType(list, (int,))))]), + (Tuple[int], [ExpandedType(tuple, (int,))]), + (Tuple[int, str], [ExpandedType(tuple, (int, str))]), + (Tuple[int, ...], [ExpandedType(tuple, (int, ...))]), + ( + Tuple[int, Dict[str, int]], + [ExpandedType(tuple, (int, ExpandedType(dict, (str, int))))], + ), + ], + ids=lambda x: str(x), +) +def test_expand_type_with_recursive_types( + type_arg: Type[T], expected: Sequence[Any] +) -> None: + + assert expand_type(type_arg) == {*expected} + + +@pytest.mark.parametrize( + argnames=["type_arg", "expected"], + argvalues=[ + ( + List[Union[str, int]], + [ExpandedType(list, (str,)), ExpandedType(list, (int,))], + ), + ( + List[Union[str, int, float]], + [ + ExpandedType(list, (str,)), + ExpandedType(list, (int,)), + ExpandedType(list, (float,)), + ], + ), + ( + Union[List[str], List[int]], + [ExpandedType(list, (str,)), ExpandedType(list, (int,))], + ), + ( + Union[List[str], List[int], List[float]], + [ + ExpandedType(list, (str,)), + ExpandedType(list, (int,)), + ExpandedType(list, (float,)), + ], + ), + ( + List[Union[Dict[str, int], Optional[int]]], + [ + ExpandedType(list, (ExpandedType(dict, (str, int)),)), + ExpandedType(list, (NoneType,)), + ExpandedType(list, (int,)), + ], + ), + ( + Union[Dict[str, int], Optional[int]], + [ExpandedType(dict, (str, int)), NoneType, int], + ), + ( + List[Union[Dict[str, Optional[int]], Optional[int]]], + [ + ExpandedType(list, (ExpandedType(dict, (str, int)),)), + ExpandedType(list, (ExpandedType(dict, (str, NoneType)),)), + ExpandedType(list, (NoneType,)), + ExpandedType(list, (int,)), + ], + ), + ( + List[Union[Dict[Union[str, int], Optional[int]], Optional[int]]], + [ + ExpandedType(list, (ExpandedType(dict, (str, int)),)), + ExpandedType(list, (ExpandedType(dict, (int, int)),)), + ExpandedType(list, (ExpandedType(dict, (str, NoneType)),)), + ExpandedType(list, (ExpandedType(dict, (int, NoneType)),)), + ExpandedType(list, (NoneType,)), + ExpandedType(list, (int,)), + ], + ), + ], + ids=lambda x: str(x), +) +def test_expand_type_with_combinations( + type_arg: Type[T], expected: Sequence[Any] +) -> None: + assert expand_type(type_arg) == {*expected} + + +def test_optional_expansion() -> None: + result: Set[Union[Any, ExpandedType[Any]]] = expand_type(Optional[int]) + assert NoneType in result + assert int in result + + +def test_union_expansion() -> None: + result: Set[Union[Any, ExpandedType[Any]]] = expand_type(Union[int, str]) + assert NoneType not in result + assert int in result + assert str in result + + +def test_expanded_type() -> None: + result: Set[Union[Any, ExpandedType[Any]]] = expand_type(Dict[str, Optional[int]]) + assert ExpandedType(dict, (str, int)) in result + assert ExpandedType(dict, (str, NoneType)) in result + + +def test_custom_handler() -> None: + def custom_handler( + type_arg: Type[T], config: Config + ) -> Set[Union[Any, ExpandedType[T]]]: + return {int} + + config: Config = Config(max_elements=5, custom_handlers={list: custom_handler}) + assert expand_type(List[str], config) == {int} diff --git a/tests/unit_tests/test_plugin.py b/tests/unit_tests/test_plugin.py new file mode 100644 index 0000000..5d61a3f --- /dev/null +++ b/tests/unit_tests/test_plugin.py @@ -0,0 +1,148 @@ +from pathlib import Path +from typing import Any +from typing import Iterable +from typing import List +from typing import Sequence +from typing import Union + +import pytest + +from pytest_static.plugin import pytest_configure +from pytest_static.type_sets import PREDEFINED_TYPE_SETS +from pytest_static.type_sets import BoolParams +from pytest_static.type_sets import BytesParams +from pytest_static.type_sets import ComplexParams +from pytest_static.type_sets import FloatParams +from pytest_static.type_sets import IntParams +from pytest_static.type_sets import StrParams + + +@pytest.mark.parametrize_types("foo", [Union[int, str]]) +def test_parametrize(foo: Any): + assert foo in PREDEFINED_TYPE_SETS[type(foo)] + + +@pytest.fixture +def conftest(pytester: pytest.Pytester) -> Path: + return pytester.makeconftest( + """ + import pytest + pytest_plugins = ["pytest_static.plugin"] + """ + ) + + +@pytest.fixture +def argtypes(request: pytest.FixtureRequest) -> Sequence[Any]: + return getattr(request, "param", ()) + + +@pytest.fixture +def parametrize_types_test( + pytester: pytest.Pytester, conftest: Path, argtypes: Sequence[str] +) -> Path: + argnames: List[str] = [f"arg{i}" for i in range(len(argtypes))] + argtypes_formatted: str = ", ".join([f"{argtype}" for argtype in argtypes]) + signature: str = ", ".join( + [f"{argname}" for argname, argtype in zip(argnames, argtypes, strict=True)] + ) + + return pytester.makepyfile( + f""" + import pytest + import typing + from typing import * + + @pytest.mark.parametrize_types( + argnames={argnames}, + argtypes=[{argtypes_formatted}], + ids=lambda x: str(x) + ) + def test_func({signature}) -> None: + pass + """ + ) + + +@pytest.mark.parametrize( + argnames=["argtypes", "expected"], + argvalues=[ + (("bool",), len(BoolParams)), + (("int",), len(IntParams)), + (("float",), len(FloatParams)), + (("complex",), len(ComplexParams)), + (("str",), len(StrParams)), + (("bytes",), len(BytesParams)), + ], + ids=lambda x: str(x) if isinstance(x, Iterable) else "", + indirect=["argtypes"], +) +def test_parametrize_types_with_single_basic( + pytester: pytest.Pytester, parametrize_types_test: Path, expected: int +) -> None: + result: pytest.Result = pytester.runpytest(parametrize_types_test) + result.assert_outcomes(passed=expected) + + +@pytest.mark.parametrize( + argnames=["argtypes", "expected"], + argvalues=[ + (("bool", "int"), len(BoolParams) * len(IntParams)), + ], + ids=lambda x: str(x) if isinstance(x, Iterable) else "", + indirect=["argtypes"], +) +def test_parametrize_types_with_multiple_basic( + pytester: pytest.Pytester, parametrize_types_test: Path, expected: int +) -> None: + result: pytest.Result = pytester.runpytest(parametrize_types_test) + result.assert_outcomes(passed=expected) + + +@pytest.mark.parametrize( + argnames=["argtypes", "expected"], + argvalues=[ + (("List[int]",), len(IntParams)), + (("List[str]",), len(StrParams)), + (("Dict[str, int]",), len(StrParams) * len(IntParams)), + (("Dict[str, str]",), len(StrParams) * len(StrParams)), + (("Tuple[int, str]",), len(IntParams) * len(StrParams)), + ], + ids=lambda x: str(x) if isinstance(x, Iterable) else "", + indirect=["argtypes"], +) +def test_parametrize_types_with_single_expanded( + pytester: pytest.Pytester, parametrize_types_test: Path, expected: int +) -> None: + result: pytest.Result = pytester.runpytest(parametrize_types_test) + result.assert_outcomes(passed=expected) + + +@pytest.mark.parametrize( + argnames=["argtypes", "expected"], + argvalues=[ + (("List[int]", "List[str]"), len(IntParams) * len(StrParams)), + ( + ("List[int]", "Dict[str, int]"), + len(IntParams) * len(StrParams) * len(IntParams), + ), + ( + ("List[int]", "Dict[str, str]"), + len(IntParams) * len(StrParams) * len(StrParams), + ), + ], + ids=lambda x: str(x) if isinstance(x, Iterable) else "", + indirect=["argtypes"], +) +def test_parametrize_types_with_multiple_expanded( + pytester: pytest.Pytester, parametrize_types_test: Path, expected: int +) -> None: + result: pytest.Result = pytester.runpytest(parametrize_types_test) + result.assert_outcomes(passed=expected) + + +def test_pytest_configure(pytester: pytest.Pytester) -> None: + config: pytest.Config = pytester.parseconfig() + assert len(config.getini("markers")) == 0 + pytest_configure(config) + assert "parametrize_types" in config.getini("markers")[0] diff --git a/tests/unit_tests/test_type_sets.py b/tests/unit_tests/test_type_sets.py new file mode 100644 index 0000000..ed63abd --- /dev/null +++ b/tests/unit_tests/test_type_sets.py @@ -0,0 +1,7 @@ +from pytest_static.type_sets import PREDEFINED_TYPE_SETS + + +def test_type_sets() -> None: + assert PREDEFINED_TYPE_SETS + for type_set in PREDEFINED_TYPE_SETS.values(): + assert type_set From 59485f431bde3767d9e5ced8853e5e2473263a7f Mon Sep 17 00:00:00 2001 From: Kyle Oliver Date: Thu, 11 May 2023 21:59:04 -0400 Subject: [PATCH 02/17] Finds a bit of a middle ground for the chaos surrounding dicts --- src/pytest_static/parametric.py | 112 +++++++++++++++++++++++++------- tests/conftest.py | 2 +- tests/unit_tests/test_plugin.py | 12 ++-- 3 files changed, 97 insertions(+), 29 deletions(-) diff --git a/src/pytest_static/parametric.py b/src/pytest_static/parametric.py index 10211d7..3341ea6 100644 --- a/src/pytest_static/parametric.py +++ b/src/pytest_static/parametric.py @@ -1,4 +1,5 @@ """A Python module used for parameterizing Literal's and common types.""" +import inspect import itertools from dataclasses import dataclass from dataclasses import field @@ -53,16 +54,80 @@ class ExpandedType(Generic[T]): def get_instances(self) -> Tuple[T, ...]: """Returns a tuple of all possible instances of the primary_type.""" - type_sets: List[Tuple[T, ...]] = [] + parameter_instance_sets: List[ + Tuple[T, ...] + ] = self._get_parameter_instance_sets() + parameter_combinations: List[ + Tuple[Any, ...] + ] = self._get_parameter_combinations(parameter_instance_sets) + instances = self._instantiate_each_parameter_combination(parameter_combinations) + return instances + + def _get_parameter_instance_sets(self) -> List[Tuple[T, ...]]: + parameter_instances: List[Tuple[T, ...]] = [] for arg in self.type_args: if isinstance(arg, ExpandedType): - type_sets.append(arg.get_instances()) + parameter_instances.append(arg.get_instances()) else: - type_sets.append(PREDEFINED_TYPE_SETS.get(arg, arg)) - instances: List[T] = list( - self.primary_type(*args) for args in itertools.product(*type_sets) - ) - return tuple(instances) + parameter_instances.append(tuple(PREDEFINED_TYPE_SETS.get(arg, arg))) + return parameter_instances + + def _get_parameter_combinations( + self, parameter_instance_sets: List[Tuple[T, ...]] + ) -> List[Tuple[Any, ...]]: + """Returns a list of parameter combinations.""" + if len(parameter_instance_sets) >= 2: + return list(itertools.product(*parameter_instance_sets)) + return list(zip(*parameter_instance_sets, strict=True)) + + def _instantiate_each_parameter_combination( + self, parameter_combinations: List[Tuple[Any, ...]] + ) -> Tuple[T, ...]: + """Returns a tuple of all possible instances of the primary_type.""" + try: + return self._instantiate_from_signature(parameter_combinations) + except ValueError as e: + if "no signature found for builtin type" not in str(e): + raise e + return self._instantiate_from_trial_and_error(parameter_combinations) + + def _instantiate_from_signature( + self, parameter_combinations: List[Tuple[Any, ...]] + ) -> Tuple[T, ...]: + """Returns a tuple of all possible instances of the primary_type.""" + signature: inspect.Signature = inspect.signature(self.primary_type) + if len(signature.parameters) > 1: + return tuple( + self._instantiate_expanded(pc) for pc in parameter_combinations + ) + else: + return tuple( + self._instantiate_not_expanded(pc) for pc in parameter_combinations + ) + + def _instantiate_from_trial_and_error( + self, parameter_combinations: List[Tuple[Any, ...]] + ) -> Tuple[T, ...]: + """Returns a tuple of all possible instances of the primary_type.""" + try: + return tuple( + self._instantiate_expanded(pc) for pc in parameter_combinations + ) + except TypeError: + return tuple( + self._instantiate_not_expanded(pc) for pc in parameter_combinations + ) + + def _instantiate_expanded(self, combination: Tuple[Any, ...]) -> T: + """Returns an instance of the primary_type using the combination provided.""" + if self.primary_type is dict: + return {combination[0]: combination[1]} + else: + return self.primary_type(*combination) + + def _instantiate_not_expanded(self, combination: Tuple[Any, ...]) -> T: + """Returns an instance of the primary_type using the combination provided.""" + return self.primary_type(combination) @dataclass(frozen=True) @@ -92,21 +157,10 @@ def parametrize_types( if len(argnames) != len(argtypes): raise ValueError("The number of argnames and argtypes must be the same.") - expanded_types = [expand_type(t) for t in argtypes] - type_sets = [list(et) for et in expanded_types] - - # Get instances for each type set - instance_sets = [] - for ts in type_sets: - instances = [] - for t in ts: - if isinstance(t, ExpandedType): - instances.extend(t.get_instances()) - else: - instances.extend(PREDEFINED_TYPE_SETS.get(t, [])) - instance_sets.append(instances) - - instance_combinations = list(itertools.product(*instance_sets)) + instance_sets: List[List[T]] = [ + list(get_all_possible_type_instances(t)) for t in argtypes + ] + instance_combinations: List[List[T]] = list(itertools.product(*instance_sets)) if ids is None: ids = [", ".join(map(repr, ic)) for ic in instance_combinations] @@ -114,6 +168,20 @@ def parametrize_types( metafunc.parametrize(argnames, instance_combinations, ids=ids, *args, **kwargs) +def get_all_possible_type_instances( + type_arg: Type[T], config: Config = DEFAULT_CONFIG +) -> Tuple[T, ...]: + """Returns a tuple of all possible instances of the provided type.""" + expanded_types: Set[Union[Any, ExpandedType[T]]] = expand_type(type_arg, config) + instances: List[T] = [] + for expanded_type in expanded_types: + if isinstance(expanded_type, ExpandedType): + instances.extend(expanded_type.get_instances()) + else: + instances.extend(PREDEFINED_TYPE_SETS.get(expanded_type, [])) + return tuple(instances) + + def _ensure_sequence(value: Union[str, Sequence[str]]) -> Sequence[str]: if isinstance(value, str): return value.split(", ") diff --git a/tests/conftest.py b/tests/conftest.py index 391394c..fde58c7 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -1 +1 @@ -pytest_plugins = ["pytester", "pytest_static.plugin", "pytest_static.p3.plugin"] +pytest_plugins = ["pytester", "pytest_static.plugin"] diff --git a/tests/unit_tests/test_plugin.py b/tests/unit_tests/test_plugin.py index 5d61a3f..26ab13c 100644 --- a/tests/unit_tests/test_plugin.py +++ b/tests/unit_tests/test_plugin.py @@ -104,8 +104,8 @@ def test_parametrize_types_with_multiple_basic( argvalues=[ (("List[int]",), len(IntParams)), (("List[str]",), len(StrParams)), - (("Dict[str, int]",), len(StrParams) * len(IntParams)), - (("Dict[str, str]",), len(StrParams) * len(StrParams)), + (("Dict[bool, int]",), len(BoolParams) * len(IntParams)), + (("Dict[str, bool]",), len(StrParams) * len(BoolParams)), (("Tuple[int, str]",), len(IntParams) * len(StrParams)), ], ids=lambda x: str(x) if isinstance(x, Iterable) else "", @@ -123,12 +123,12 @@ def test_parametrize_types_with_single_expanded( argvalues=[ (("List[int]", "List[str]"), len(IntParams) * len(StrParams)), ( - ("List[int]", "Dict[str, int]"), - len(IntParams) * len(StrParams) * len(IntParams), + ("List[int]", "Dict[bool, int]"), + len(IntParams) * len(BoolParams) * len(IntParams), ), ( - ("List[int]", "Dict[str, str]"), - len(IntParams) * len(StrParams) * len(StrParams), + ("List[int]", "Dict[str, bool]"), + len(IntParams) * len(StrParams) * len(BoolParams), ), ], ids=lambda x: str(x) if isinstance(x, Iterable) else "", From 8d9282ecd7d5da1c0cd946686f0b62007ebc72b0 Mon Sep 17 00:00:00 2001 From: Kyle Oliver Date: Sat, 19 Aug 2023 05:10:14 -0400 Subject: [PATCH 03/17] Fixes imports --- src/pytest_static/parametric.py | 2 +- src/pytest_static/plugin.py | 2 +- src/pytest_static/type_sets.py | 3 --- 3 files changed, 2 insertions(+), 5 deletions(-) diff --git a/src/pytest_static/parametric.py b/src/pytest_static/parametric.py index 3341ea6..1b1455b 100644 --- a/src/pytest_static/parametric.py +++ b/src/pytest_static/parametric.py @@ -24,7 +24,7 @@ from _pytest.python import Metafunc -from pytest_static.type_sets import PREDEFINED_TYPE_SETS +from src.pytest_static.type_sets import PREDEFINED_TYPE_SETS T = TypeVar("T") diff --git a/src/pytest_static/plugin.py b/src/pytest_static/plugin.py index 5907033..c032c1e 100644 --- a/src/pytest_static/plugin.py +++ b/src/pytest_static/plugin.py @@ -3,7 +3,7 @@ import pytest from _pytest.python import Metafunc -from pytest_static.parametric import parametrize_types +from src.pytest_static.parametric import parametrize_types def pytest_generate_tests(metafunc: Metafunc) -> None: diff --git a/src/pytest_static/type_sets.py b/src/pytest_static/type_sets.py index 598c2ea..9cc9c00 100644 --- a/src/pytest_static/type_sets.py +++ b/src/pytest_static/type_sets.py @@ -148,7 +148,6 @@ *TripleQuotes, } -# Float FloatParams: Set[float] = { 0.0, -0.0, @@ -163,7 +162,6 @@ float("nan"), } -# Complex ComplexParams: Set[complex] = { 0j, 1j, @@ -180,7 +178,6 @@ (-1e10 - 1e10j), } -# bytes BytesParams: Set[bytes] = { b"", b"\x00", From ad8a0820e9e063e068b59434ba42eca253723567 Mon Sep 17 00:00:00 2001 From: Kyle Oliver Date: Sat, 19 Aug 2023 11:12:24 -0400 Subject: [PATCH 04/17] Refactors a bit and fixes more imports broken by the project move. --- src/pytest_static/parametric.py | 15 +++++++++------ tests/unit_tests/test_main.py | 2 +- tests/unit_tests/test_parametric.py | 9 ++++----- tests/unit_tests/test_plugin.py | 16 ++++++++-------- tests/unit_tests/test_type_sets.py | 2 +- 5 files changed, 23 insertions(+), 21 deletions(-) diff --git a/src/pytest_static/parametric.py b/src/pytest_static/parametric.py index 1b1455b..69aa647 100644 --- a/src/pytest_static/parametric.py +++ b/src/pytest_static/parametric.py @@ -60,10 +60,13 @@ def get_instances(self) -> Tuple[T, ...]: parameter_combinations: List[ Tuple[Any, ...] ] = self._get_parameter_combinations(parameter_instance_sets) - instances = self._instantiate_each_parameter_combination(parameter_combinations) + instances: Tuple[T, ...] = self._instantiate_each_parameter_combination( + parameter_combinations + ) return instances def _get_parameter_instance_sets(self) -> List[Tuple[T, ...]]: + """Returns a list of parameter instance sets.""" parameter_instances: List[Tuple[T, ...]] = [] for arg in self.type_args: if isinstance(arg, ExpandedType): @@ -76,7 +79,7 @@ def _get_parameter_combinations( self, parameter_instance_sets: List[Tuple[T, ...]] ) -> List[Tuple[Any, ...]]: """Returns a list of parameter combinations.""" - if len(parameter_instance_sets) >= 2: + if len(parameter_instance_sets) > 1: return list(itertools.product(*parameter_instance_sets)) return list(zip(*parameter_instance_sets, strict=True)) @@ -100,10 +103,9 @@ def _instantiate_from_signature( return tuple( self._instantiate_expanded(pc) for pc in parameter_combinations ) - else: - return tuple( - self._instantiate_not_expanded(pc) for pc in parameter_combinations - ) + return tuple( + self._instantiate_not_expanded(pc) for pc in parameter_combinations + ) def _instantiate_from_trial_and_error( self, parameter_combinations: List[Tuple[Any, ...]] @@ -183,6 +185,7 @@ def get_all_possible_type_instances( def _ensure_sequence(value: Union[str, Sequence[str]]) -> Sequence[str]: + """Returns the provided value as a sequence.""" if isinstance(value, str): return value.split(", ") return value diff --git a/tests/unit_tests/test_main.py b/tests/unit_tests/test_main.py index 2d8fc50..3e1a29f 100644 --- a/tests/unit_tests/test_main.py +++ b/tests/unit_tests/test_main.py @@ -2,7 +2,7 @@ import pytest from click.testing import CliRunner -from pytest_static import __main__ +from src.pytest_static import __main__ @pytest.fixture diff --git a/tests/unit_tests/test_parametric.py b/tests/unit_tests/test_parametric.py index db2b27e..2a25b96 100644 --- a/tests/unit_tests/test_parametric.py +++ b/tests/unit_tests/test_parametric.py @@ -15,10 +15,10 @@ import pytest from _pytest.monkeypatch import MonkeyPatch -from pytest_static.parametric import Config -from pytest_static.parametric import ExpandedType -from pytest_static.parametric import expand_type -from pytest_static.type_sets import PREDEFINED_TYPE_SETS +from src.pytest_static.parametric import Config +from src.pytest_static.parametric import ExpandedType +from src.pytest_static.parametric import expand_type +from src.pytest_static.type_sets import PREDEFINED_TYPE_SETS T = TypeVar("T") @@ -167,7 +167,6 @@ def test_expand_type_with_sum_types(type_arg: Type[T], expected: Sequence[Any]) def test_expand_type_with_recursive_types( type_arg: Type[T], expected: Sequence[Any] ) -> None: - assert expand_type(type_arg) == {*expected} diff --git a/tests/unit_tests/test_plugin.py b/tests/unit_tests/test_plugin.py index 26ab13c..6411c27 100644 --- a/tests/unit_tests/test_plugin.py +++ b/tests/unit_tests/test_plugin.py @@ -7,14 +7,14 @@ import pytest -from pytest_static.plugin import pytest_configure -from pytest_static.type_sets import PREDEFINED_TYPE_SETS -from pytest_static.type_sets import BoolParams -from pytest_static.type_sets import BytesParams -from pytest_static.type_sets import ComplexParams -from pytest_static.type_sets import FloatParams -from pytest_static.type_sets import IntParams -from pytest_static.type_sets import StrParams +from src.pytest_static.plugin import pytest_configure +from src.pytest_static.type_sets import PREDEFINED_TYPE_SETS +from src.pytest_static.type_sets import BoolParams +from src.pytest_static.type_sets import BytesParams +from src.pytest_static.type_sets import ComplexParams +from src.pytest_static.type_sets import FloatParams +from src.pytest_static.type_sets import IntParams +from src.pytest_static.type_sets import StrParams @pytest.mark.parametrize_types("foo", [Union[int, str]]) diff --git a/tests/unit_tests/test_type_sets.py b/tests/unit_tests/test_type_sets.py index ed63abd..676cc18 100644 --- a/tests/unit_tests/test_type_sets.py +++ b/tests/unit_tests/test_type_sets.py @@ -1,4 +1,4 @@ -from pytest_static.type_sets import PREDEFINED_TYPE_SETS +from src.pytest_static.type_sets import PREDEFINED_TYPE_SETS def test_type_sets() -> None: From cc4d0b9b434e7153b7c1efcdaafc539b4caba50b Mon Sep 17 00:00:00 2001 From: Kyle Oliver Date: Sat, 19 Aug 2023 11:37:38 -0400 Subject: [PATCH 05/17] Converts imports back to not include src directory and instead adds a sources root in pycharm --- src/pytest_static/parametric.py | 2 +- src/pytest_static/plugin.py | 2 +- tests/unit_tests/test_main.py | 2 +- tests/unit_tests/test_parametric.py | 8 +-- tests/unit_tests/test_plugin.py | 29 +++++------ tests/unit_tests/test_type_sets.py | 77 ++++++++++++++++++++++++++++- 6 files changed, 94 insertions(+), 26 deletions(-) diff --git a/src/pytest_static/parametric.py b/src/pytest_static/parametric.py index 69aa647..3d77f88 100644 --- a/src/pytest_static/parametric.py +++ b/src/pytest_static/parametric.py @@ -24,7 +24,7 @@ from _pytest.python import Metafunc -from src.pytest_static.type_sets import PREDEFINED_TYPE_SETS +from pytest_static.type_sets import PREDEFINED_TYPE_SETS T = TypeVar("T") diff --git a/src/pytest_static/plugin.py b/src/pytest_static/plugin.py index c032c1e..5907033 100644 --- a/src/pytest_static/plugin.py +++ b/src/pytest_static/plugin.py @@ -3,7 +3,7 @@ import pytest from _pytest.python import Metafunc -from src.pytest_static.parametric import parametrize_types +from pytest_static.parametric import parametrize_types def pytest_generate_tests(metafunc: Metafunc) -> None: diff --git a/tests/unit_tests/test_main.py b/tests/unit_tests/test_main.py index 3e1a29f..2d8fc50 100644 --- a/tests/unit_tests/test_main.py +++ b/tests/unit_tests/test_main.py @@ -2,7 +2,7 @@ import pytest from click.testing import CliRunner -from src.pytest_static import __main__ +from pytest_static import __main__ @pytest.fixture diff --git a/tests/unit_tests/test_parametric.py b/tests/unit_tests/test_parametric.py index 2a25b96..ddbcf98 100644 --- a/tests/unit_tests/test_parametric.py +++ b/tests/unit_tests/test_parametric.py @@ -15,10 +15,10 @@ import pytest from _pytest.monkeypatch import MonkeyPatch -from src.pytest_static.parametric import Config -from src.pytest_static.parametric import ExpandedType -from src.pytest_static.parametric import expand_type -from src.pytest_static.type_sets import PREDEFINED_TYPE_SETS +from pytest_static.parametric import Config +from pytest_static.parametric import ExpandedType +from pytest_static.parametric import expand_type +from pytest_static.type_sets import PREDEFINED_TYPE_SETS T = TypeVar("T") diff --git a/tests/unit_tests/test_plugin.py b/tests/unit_tests/test_plugin.py index 6411c27..df590f2 100644 --- a/tests/unit_tests/test_plugin.py +++ b/tests/unit_tests/test_plugin.py @@ -3,23 +3,16 @@ from typing import Iterable from typing import List from typing import Sequence -from typing import Union import pytest -from src.pytest_static.plugin import pytest_configure -from src.pytest_static.type_sets import PREDEFINED_TYPE_SETS -from src.pytest_static.type_sets import BoolParams -from src.pytest_static.type_sets import BytesParams -from src.pytest_static.type_sets import ComplexParams -from src.pytest_static.type_sets import FloatParams -from src.pytest_static.type_sets import IntParams -from src.pytest_static.type_sets import StrParams - - -@pytest.mark.parametrize_types("foo", [Union[int, str]]) -def test_parametrize(foo: Any): - assert foo in PREDEFINED_TYPE_SETS[type(foo)] +from pytest_static.plugin import pytest_configure +from pytest_static.type_sets import BoolParams +from pytest_static.type_sets import BytesParams +from pytest_static.type_sets import ComplexParams +from pytest_static.type_sets import FloatParams +from pytest_static.type_sets import IntParams +from pytest_static.type_sets import StrParams @pytest.fixture @@ -80,7 +73,7 @@ def test_func({signature}) -> None: def test_parametrize_types_with_single_basic( pytester: pytest.Pytester, parametrize_types_test: Path, expected: int ) -> None: - result: pytest.Result = pytester.runpytest(parametrize_types_test) + result: pytest.RunResult = pytester.runpytest(parametrize_types_test) result.assert_outcomes(passed=expected) @@ -95,7 +88,7 @@ def test_parametrize_types_with_single_basic( def test_parametrize_types_with_multiple_basic( pytester: pytest.Pytester, parametrize_types_test: Path, expected: int ) -> None: - result: pytest.Result = pytester.runpytest(parametrize_types_test) + result: pytest.RunResult = pytester.runpytest(parametrize_types_test) result.assert_outcomes(passed=expected) @@ -114,7 +107,7 @@ def test_parametrize_types_with_multiple_basic( def test_parametrize_types_with_single_expanded( pytester: pytest.Pytester, parametrize_types_test: Path, expected: int ) -> None: - result: pytest.Result = pytester.runpytest(parametrize_types_test) + result: pytest.RunResult = pytester.runpytest(parametrize_types_test) result.assert_outcomes(passed=expected) @@ -137,7 +130,7 @@ def test_parametrize_types_with_single_expanded( def test_parametrize_types_with_multiple_expanded( pytester: pytest.Pytester, parametrize_types_test: Path, expected: int ) -> None: - result: pytest.Result = pytester.runpytest(parametrize_types_test) + result: pytest.RunResult = pytester.runpytest(parametrize_types_test) result.assert_outcomes(passed=expected) diff --git a/tests/unit_tests/test_type_sets.py b/tests/unit_tests/test_type_sets.py index 676cc18..5508886 100644 --- a/tests/unit_tests/test_type_sets.py +++ b/tests/unit_tests/test_type_sets.py @@ -1,7 +1,82 @@ -from src.pytest_static.type_sets import PREDEFINED_TYPE_SETS +from pytest_static.type_sets import PREDEFINED_TYPE_SETS +from pytest_static.type_sets import BoolParams +from pytest_static.type_sets import BytesParams +from pytest_static.type_sets import ComplexParams +from pytest_static.type_sets import Digits +from pytest_static.type_sets import EscapeSequences +from pytest_static.type_sets import FloatParams +from pytest_static.type_sets import ForeignChars +from pytest_static.type_sets import IntParams +from pytest_static.type_sets import LowercaseLetters +from pytest_static.type_sets import SpecialChars +from pytest_static.type_sets import StrParams +from pytest_static.type_sets import TripleQuotes +from pytest_static.type_sets import UnicodeChars +from pytest_static.type_sets import UppercaseLetters +from pytest_static.type_sets import Whitespace def test_type_sets() -> None: assert PREDEFINED_TYPE_SETS for type_set in PREDEFINED_TYPE_SETS.values(): assert type_set + + +def test_bool_params() -> None: + assert BoolParams + + +def test_int_params() -> None: + assert IntParams + + +def test_whitespace() -> None: + assert Whitespace + + +def test_special_chars() -> None: + assert SpecialChars + + +def test_digits() -> None: + assert Digits + + +def test_lowercase_letters() -> None: + assert LowercaseLetters + + +def test_uppercase_letters() -> None: + assert UppercaseLetters + + +def test_unicode_chars() -> None: + assert UnicodeChars + + +def test_foreign_chars() -> None: + assert ForeignChars + + +def test_escape_sequences() -> None: + assert EscapeSequences + + +def test_triple_quotes() -> None: + assert TripleQuotes + + +def test_str_params() -> None: + assert StrParams + + +def test_float_params() -> None: + assert FloatParams + + +def test_complex_params() -> None: + assert ComplexParams + + +def test_bytes_params() -> None: + assert BytesParams From 0cef4c78ee39cba2fd59c307a1f5e3d5d411bc8b Mon Sep 17 00:00:00 2001 From: Kyle Oliver Date: Sat, 19 Aug 2023 11:48:49 -0400 Subject: [PATCH 06/17] Adds more types for mypy --- tests/unit_tests/test_parametric.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/tests/unit_tests/test_parametric.py b/tests/unit_tests/test_parametric.py index ddbcf98..80327fd 100644 --- a/tests/unit_tests/test_parametric.py +++ b/tests/unit_tests/test_parametric.py @@ -29,19 +29,19 @@ class DummyClass: class TestExpandedType: - def test_get_instances_with_basic(self): + def test_get_instances_with_basic(self) -> None: expanded_type = ExpandedType(list, (int,)) assert expanded_type.get_instances() == tuple( [value] for value in PREDEFINED_TYPE_SETS[int] ) - def test_get_instances_with_nested(self): + def test_get_instances_with_nested(self) -> None: expanded_type = ExpandedType(list, (ExpandedType(list, (int,)),)) assert expanded_type.get_instances() == tuple( [[value]] for value in PREDEFINED_TYPE_SETS[int] ) - def test_get_instances_with_multiple(self, monkeypatch: MonkeyPatch): + def test_get_instances_with_multiple(self, monkeypatch: MonkeyPatch) -> None: monkeypatch.setitem(PREDEFINED_TYPE_SETS, int, {1, 2}) monkeypatch.setitem(PREDEFINED_TYPE_SETS, str, {"a", "b"}) expected_instances: Tuple[List[int, str], ...] = ( @@ -55,7 +55,7 @@ def test_get_instances_with_multiple(self, monkeypatch: MonkeyPatch): for instance in expected_instances: assert instance in expanded_instances - def test_get_instances_with_multiple_nested(self, monkeypatch: MonkeyPatch): + def test_get_instances_with_multiple_nested(self, monkeypatch: MonkeyPatch) -> None: monkeypatch.setitem(PREDEFINED_TYPE_SETS, int, {1, 2}) monkeypatch.setitem(PREDEFINED_TYPE_SETS, str, {"a", "b"}) expected_instances: Tuple[List[List[int], str], ...] = ( From d4344893d68c056218c196399cd21abfc9c5e2b2 Mon Sep 17 00:00:00 2001 From: Kyle Oliver Date: Sun, 20 Aug 2023 10:12:10 -0400 Subject: [PATCH 07/17] More work trying to appease the mypy overlord --- src/pytest_static/parametric.py | 60 +++++++++++++++++++++-------- tests/acceptance_tests/__init__.py | 0 tests/unit_tests/test_parametric.py | 10 ++--- 3 files changed, 50 insertions(+), 20 deletions(-) create mode 100644 tests/acceptance_tests/__init__.py diff --git a/src/pytest_static/parametric.py b/src/pytest_static/parametric.py index 3d77f88..565924f 100644 --- a/src/pytest_static/parametric.py +++ b/src/pytest_static/parametric.py @@ -4,6 +4,7 @@ from dataclasses import dataclass from dataclasses import field from enum import Enum +from typing import TYPE_CHECKING from typing import Any from typing import Callable from typing import Dict @@ -22,11 +23,16 @@ from typing import get_args from typing import get_origin +from _pytest.mark import Mark from _pytest.python import Metafunc from pytest_static.type_sets import PREDEFINED_TYPE_SETS +if TYPE_CHECKING: + from _pytest.scope import _ScopeName + + T = TypeVar("T") @@ -100,11 +106,11 @@ def _instantiate_from_signature( """Returns a tuple of all possible instances of the primary_type.""" signature: inspect.Signature = inspect.signature(self.primary_type) if len(signature.parameters) > 1: - return tuple( - self._instantiate_expanded(pc) for pc in parameter_combinations + return self._instantiate_combinations_using_expanded( + parameter_combinations=parameter_combinations ) - return tuple( - self._instantiate_not_expanded(pc) for pc in parameter_combinations + return self._instantiate_combinations_using_not_expanded( + parameter_combinations=parameter_combinations ) def _instantiate_from_trial_and_error( @@ -112,20 +118,33 @@ def _instantiate_from_trial_and_error( ) -> Tuple[T, ...]: """Returns a tuple of all possible instances of the primary_type.""" try: - return tuple( - self._instantiate_expanded(pc) for pc in parameter_combinations + return self._instantiate_combinations_using_expanded( + parameter_combinations=parameter_combinations ) except TypeError: - return tuple( - self._instantiate_not_expanded(pc) for pc in parameter_combinations + return self._instantiate_combinations_using_not_expanded( + parameter_combinations=parameter_combinations ) + def _instantiate_combinations_using_expanded( + self, parameter_combinations: List[Tuple[Any, ...]] + ) -> Tuple[T, ...]: + """Returns a tuple of all possible instances of the primary_type.""" + return tuple(self._instantiate_expanded(pc) for pc in parameter_combinations) + + def _instantiate_combinations_using_not_expanded( + self, parameter_combinations: List[Tuple[Any, ...]] + ) -> Tuple[T, ...]: + """Returns a tuple of all possible instances of the primary_type.""" + return tuple( + self._instantiate_not_expanded(pc) for pc in parameter_combinations + ) + def _instantiate_expanded(self, combination: Tuple[Any, ...]) -> T: """Returns an instance of the primary_type using the combination provided.""" if self.primary_type is dict: - return {combination[0]: combination[1]} - else: - return self.primary_type(*combination) + return self.primary_type([combination]) + return self.primary_type(*combination) def _instantiate_not_expanded(self, combination: Tuple[Any, ...]) -> T: """Returns an instance of the primary_type using the combination provided.""" @@ -150,9 +169,13 @@ def parametrize_types( metafunc: Metafunc, argnames: Union[str, Sequence[str]], argtypes: List[Type[T]], - ids: Optional[Union[Sequence[str], Callable]] = None, - *args, - **kwargs + indirect: Union[bool, Sequence[str]] = False, + ids: Optional[ + Union[Iterable[Optional[object]], Callable[[Any], Optional[object]]] + ] = None, + scope: "Optional[_ScopeName]" = None, + *, + _param_mark: Optional[Mark] = None, ) -> None: """Parametrizes the provided argnames with the provided argtypes.""" argnames = _ensure_sequence(argnames) @@ -167,7 +190,14 @@ def parametrize_types( if ids is None: ids = [", ".join(map(repr, ic)) for ic in instance_combinations] - metafunc.parametrize(argnames, instance_combinations, ids=ids, *args, **kwargs) + metafunc.parametrize( + argnames=argnames, + argvalues=instance_combinations, + indirect=indirect, + ids=ids, + scope=scope, + _param_mark=_param_mark, + ) def get_all_possible_type_instances( diff --git a/tests/acceptance_tests/__init__.py b/tests/acceptance_tests/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/unit_tests/test_parametric.py b/tests/unit_tests/test_parametric.py index 80327fd..934584c 100644 --- a/tests/unit_tests/test_parametric.py +++ b/tests/unit_tests/test_parametric.py @@ -44,28 +44,28 @@ def test_get_instances_with_nested(self) -> None: def test_get_instances_with_multiple(self, monkeypatch: MonkeyPatch) -> None: monkeypatch.setitem(PREDEFINED_TYPE_SETS, int, {1, 2}) monkeypatch.setitem(PREDEFINED_TYPE_SETS, str, {"a", "b"}) - expected_instances: Tuple[List[int, str], ...] = ( + expected_instances: Tuple[List[Union[int, str]], ...] = ( [1, "a"], [1, "b"], [2, "a"], [2, "b"], ) - expanded_type = ExpandedType(list, (int, str)) - expanded_instances: Tuple[Tuple[Any, ...], ...] = expanded_type.get_instances() + expanded_type: ExpandedType[List[Any]] = ExpandedType(list, (int, str)) + expanded_instances: Tuple[List[Any], ...] = expanded_type.get_instances() for instance in expected_instances: assert instance in expanded_instances def test_get_instances_with_multiple_nested(self, monkeypatch: MonkeyPatch) -> None: monkeypatch.setitem(PREDEFINED_TYPE_SETS, int, {1, 2}) monkeypatch.setitem(PREDEFINED_TYPE_SETS, str, {"a", "b"}) - expected_instances: Tuple[List[List[int], str], ...] = ( + expected_instances: Tuple[List[Union[List[int], str]], ...] = ( [[1], "a"], [[1], "b"], [[2], "a"], [[2], "b"], ) expanded_type = ExpandedType(list, (ExpandedType(list, (int,)), str)) - expanded_instances: Tuple[Tuple[Any, ...], ...] = expanded_type.get_instances() + expanded_instances: Tuple[List[Any], ...] = expanded_type.get_instances() for instance in expected_instances: assert instance in expanded_instances From 72c863560a29da04666e1bcae2d7e9880d047e2d Mon Sep 17 00:00:00 2001 From: Kyle Oliver Date: Sun, 20 Aug 2023 13:20:49 -0400 Subject: [PATCH 08/17] Works a bit more on tests and adds some fixtures --- src/pytest_static/parametric.py | 19 +++++--- tests/unit_tests/conftest.py | 37 ++++++++++++++ tests/unit_tests/test_parametric.py | 75 +++++++++++++++++++++++++++++ 3 files changed, 123 insertions(+), 8 deletions(-) diff --git a/src/pytest_static/parametric.py b/src/pytest_static/parametric.py index 565924f..154d4a7 100644 --- a/src/pytest_static/parametric.py +++ b/src/pytest_static/parametric.py @@ -58,14 +58,25 @@ class ExpandedType(Generic[T]): primary_type: Type[T] type_args: Tuple[Union[Any, "ExpandedType[Any]"], ...] + @staticmethod + def _get_parameter_combinations( + parameter_instance_sets: List[Tuple[T, ...]] + ) -> List[Tuple[Any, ...]]: + """Returns a list of parameter combinations.""" + if len(parameter_instance_sets) > 1: + return list(itertools.product(*parameter_instance_sets)) + return list(zip(*parameter_instance_sets, strict=True)) + def get_instances(self) -> Tuple[T, ...]: """Returns a tuple of all possible instances of the primary_type.""" parameter_instance_sets: List[ Tuple[T, ...] ] = self._get_parameter_instance_sets() + parameter_combinations: List[ Tuple[Any, ...] ] = self._get_parameter_combinations(parameter_instance_sets) + instances: Tuple[T, ...] = self._instantiate_each_parameter_combination( parameter_combinations ) @@ -81,14 +92,6 @@ def _get_parameter_instance_sets(self) -> List[Tuple[T, ...]]: parameter_instances.append(tuple(PREDEFINED_TYPE_SETS.get(arg, arg))) return parameter_instances - def _get_parameter_combinations( - self, parameter_instance_sets: List[Tuple[T, ...]] - ) -> List[Tuple[Any, ...]]: - """Returns a list of parameter combinations.""" - if len(parameter_instance_sets) > 1: - return list(itertools.product(*parameter_instance_sets)) - return list(zip(*parameter_instance_sets, strict=True)) - def _instantiate_each_parameter_combination( self, parameter_combinations: List[Tuple[Any, ...]] ) -> Tuple[T, ...]: diff --git a/tests/unit_tests/conftest.py b/tests/unit_tests/conftest.py index e69de29..9d14f2e 100644 --- a/tests/unit_tests/conftest.py +++ b/tests/unit_tests/conftest.py @@ -0,0 +1,37 @@ +from typing import Any +from typing import List +from typing import Tuple +from typing import Type +from typing import Union + +import pytest +from _pytest.fixtures import FixtureRequest + +from pytest_static.parametric import ExpandedType +from pytest_static.parametric import T + + +@pytest.fixture(scope="function") +def expanded_type( + request: FixtureRequest, + primary_type: Type[T], + type_args: Tuple[Union[Any, ExpandedType[Any]], ...], +) -> ExpandedType[T]: + return getattr( + request, + "param", + ExpandedType( + primary_type=primary_type, + type_args=type_args, + ), + ) + + +@pytest.fixture(scope="function") +def primary_type(request: FixtureRequest) -> Type[T]: + return getattr(request, "param", List) + + +@pytest.fixture(scope="function") +def type_args(request: FixtureRequest) -> Tuple[Union[Any, ExpandedType[Any]], ...]: + return getattr(request, "param", (int,)) diff --git a/tests/unit_tests/test_parametric.py b/tests/unit_tests/test_parametric.py index 934584c..c3970c8 100644 --- a/tests/unit_tests/test_parametric.py +++ b/tests/unit_tests/test_parametric.py @@ -69,6 +69,81 @@ def test_get_instances_with_multiple_nested(self, monkeypatch: MonkeyPatch) -> N for instance in expected_instances: assert instance in expanded_instances + @pytest.mark.parametrize( + argnames=["primary_type", "type_args", "expected_sets"], + argvalues=[ + ( + List, + (int,), + [ + PREDEFINED_TYPE_SETS[int], + ], + ), + (Union, (int, str), [PREDEFINED_TYPE_SETS[int], PREDEFINED_TYPE_SETS[str]]), + (Tuple, (int, str), [PREDEFINED_TYPE_SETS[int], PREDEFINED_TYPE_SETS[str]]), + ], + ids=["nested_param", "sum_param", "product_param"], + ) + def test__get_parameter_instance_sets( + self, + primary_type: Type[T], + type_args: Type[T], + expected_sets: Tuple[Set[Any], ...], + ) -> None: + expected_sets = [tuple(expected_set) for expected_set in expected_sets] + assert ( + ExpandedType( + primary_type=primary_type, + type_args=type_args, + )._get_parameter_instance_sets() + == expected_sets + ) + + @pytest.mark.parametrize( + argnames=["instance_sets", "expected_combinations"], + argvalues=[ + ([(1, 2)], [(1,), (2,)]), + ([(1, 2), (3, 4)], [(1, 3), (1, 4), (2, 3), (2, 4)]), + ], + ids=[ + "single_set", + "multiple_sets", + ], + ) + def test__get_parameter_combinations( + self, + instance_sets: List[Tuple[T, ...]], + expected_combinations: List[Tuple[Any, ...]], + ) -> None: + assert ( + ExpandedType._get_parameter_combinations(instance_sets) + == expected_combinations + ) + + def test__instantiate_each_parameter_combination(self) -> None: + pass + + def test__instantiate_from_signature(self) -> None: + pass + + def test__instantiate_from_trial_and_error(self) -> None: + pass + + def test__instantiate_combinations_using_expanded(self) -> None: + pass + + def test__instantiate_combinations_using_not_expanded(self) -> None: + pass + + def test__instantiate_expanded(self) -> None: + pass + + def test__instantiate_not_expanded( + self, + expanded_type: ExpandedType, + ) -> None: + pass + @pytest.mark.parametrize( argnames=["type_arg", "expected"], From 04efd3d2cff70745ed2e8be3719ef01296d7c40e Mon Sep 17 00:00:00 2001 From: Kyle Oliver Date: Mon, 28 Aug 2023 22:54:00 -0400 Subject: [PATCH 09/17] Fixes a test --- tests/unit_tests/test_parametric.py | 17 ++++++++++++++++- 1 file changed, 16 insertions(+), 1 deletion(-) diff --git a/tests/unit_tests/test_parametric.py b/tests/unit_tests/test_parametric.py index c3970c8..fb2c7c3 100644 --- a/tests/unit_tests/test_parametric.py +++ b/tests/unit_tests/test_parametric.py @@ -138,11 +138,26 @@ def test__instantiate_combinations_using_not_expanded(self) -> None: def test__instantiate_expanded(self) -> None: pass + @pytest.mark.parametrize( + argnames=["primary_type", "type_args", "combination"], + argvalues=[ + (list, (int,), (1,)), + (list, (int,), (1, 2)), + ], + ids=[ + "single_type_arg", + "multiple_type_args", + ], + indirect=["primary_type", "type_args"], + ) def test__instantiate_not_expanded( self, expanded_type: ExpandedType, + combination: Tuple[Any, ...], ) -> None: - pass + assert expanded_type._instantiate_not_expanded( + combination + ) == expanded_type.primary_type(combination) @pytest.mark.parametrize( From a2e757b7d31ee33c27492abb4bfb74a90a23df55 Mon Sep 17 00:00:00 2001 From: Kyle Oliver Date: Tue, 29 Aug 2023 00:29:56 -0400 Subject: [PATCH 10/17] Improving test coverage by adding _ScopeName to the package --- src/pytest_static/parametric.py | 8 +++----- tests/unit_tests/test_parametric.py | 11 +++++++++-- 2 files changed, 12 insertions(+), 7 deletions(-) diff --git a/src/pytest_static/parametric.py b/src/pytest_static/parametric.py index 154d4a7..b0c2dab 100644 --- a/src/pytest_static/parametric.py +++ b/src/pytest_static/parametric.py @@ -4,7 +4,6 @@ from dataclasses import dataclass from dataclasses import field from enum import Enum -from typing import TYPE_CHECKING from typing import Any from typing import Callable from typing import Dict @@ -29,9 +28,8 @@ from pytest_static.type_sets import PREDEFINED_TYPE_SETS -if TYPE_CHECKING: - from _pytest.scope import _ScopeName - +# Redefines pytest's typing so that we can get 100% test coverage +_ScopeName = Literal["session", "package", "module", "class", "function"] T = TypeVar("T") @@ -176,7 +174,7 @@ def parametrize_types( ids: Optional[ Union[Iterable[Optional[object]], Callable[[Any], Optional[object]]] ] = None, - scope: "Optional[_ScopeName]" = None, + scope: Optional[_ScopeName] = None, *, _param_mark: Optional[Mark] = None, ) -> None: diff --git a/tests/unit_tests/test_parametric.py b/tests/unit_tests/test_parametric.py index fb2c7c3..9c43653 100644 --- a/tests/unit_tests/test_parametric.py +++ b/tests/unit_tests/test_parametric.py @@ -120,8 +120,15 @@ def test__get_parameter_combinations( == expected_combinations ) - def test__instantiate_each_parameter_combination(self) -> None: - pass + @pytest.mark.parametrize( + argnames=["primary_type"], argvalues=[(dict,)], indirect=True + ) + def test__instantiate_each_parameter_combination_with_builtin( + self, expanded_type: ExpandedType + ) -> None: + expanded_type._instantiate_each_parameter_combination( + parameter_combinations=[("foo", {"a": "b"})] + ) def test__instantiate_from_signature(self) -> None: pass From b44dde93894c7c94f256b60f349560ed269e9b8e Mon Sep 17 00:00:00 2001 From: Kyle Oliver Date: Wed, 30 Aug 2023 22:44:27 -0400 Subject: [PATCH 11/17] Returns test coverage to 100% --- tests/unit_tests/test_parametric.py | 71 +++++++++++++++++++++++++---- tests/unit_tests/test_plugin.py | 66 +++++++++++++++++++++++++++ 2 files changed, 129 insertions(+), 8 deletions(-) diff --git a/tests/unit_tests/test_parametric.py b/tests/unit_tests/test_parametric.py index 9c43653..7b3abc2 100644 --- a/tests/unit_tests/test_parametric.py +++ b/tests/unit_tests/test_parametric.py @@ -121,20 +121,75 @@ def test__get_parameter_combinations( ) @pytest.mark.parametrize( - argnames=["primary_type"], argvalues=[(dict,)], indirect=True + argnames=["primary_type"], + argvalues=[ + (type,), + ], + indirect=True, ) def test__instantiate_each_parameter_combination_with_builtin( self, expanded_type: ExpandedType ) -> None: - expanded_type._instantiate_each_parameter_combination( - parameter_combinations=[("foo", {"a": "b"})] - ) + with pytest.raises(ValueError): + expanded_type._instantiate_each_parameter_combination( + parameter_combinations=[("foo", "bar")] + ) - def test__instantiate_from_signature(self) -> None: - pass + @pytest.mark.parametrize( + argnames=["primary_type", "type_args", "combinations", "expected"], + argvalues=[ + (lambda: None, tuple(), tuple(), tuple()), + (list, (int,), ((1, 2),), ([1, 2],)), + ( + lambda a, b, c: [a, b, c], + (bool, bool, bool), + ((True, False, True),), + ([True, False, True],), + ), + ], + ids=["no_parameters_sig", "one_parameter_sig", "many_parameters_sig"], + indirect=["primary_type", "type_args"], + ) + def test__instantiate_from_signature( + self, + expanded_type: ExpandedType[T], + combinations: List[Tuple[Any, ...]], + expected: Tuple[T, ...], + ) -> None: + assert ( + expanded_type._instantiate_from_signature( + parameter_combinations=combinations + ) + == expected + ) - def test__instantiate_from_trial_and_error(self) -> None: - pass + @pytest.mark.parametrize( + argnames=["primary_type", "type_args", "combinations", "expected"], + argvalues=[ + (lambda: None, tuple(), tuple(), tuple()), + (list, (int,), ((1, 2),), ([1, 2],)), + ( + lambda a, b, c: [a, b, c], + (bool, bool, bool), + ((True, False, True),), + ([True, False, True],), + ), + ], + ids=["no_parameters_sig", "one_parameter_sig", "many_parameters_sig"], + indirect=["primary_type", "type_args"], + ) + def test__instantiate_from_trial_and_error( + self, + expanded_type: ExpandedType[T], + combinations: List[Tuple[Any, ...]], + expected: Tuple[T, ...], + ) -> None: + assert ( + expanded_type._instantiate_from_trial_and_error( + parameter_combinations=combinations + ) + == expected + ) def test__instantiate_combinations_using_expanded(self) -> None: pass diff --git a/tests/unit_tests/test_plugin.py b/tests/unit_tests/test_plugin.py index df590f2..5d16c61 100644 --- a/tests/unit_tests/test_plugin.py +++ b/tests/unit_tests/test_plugin.py @@ -57,6 +57,72 @@ def test_func({signature}) -> None: ) +def test_parametrize_types_with_unequal_names_and_types( + pytester: pytest.Pytester, conftest: Path +) -> None: + test_path: Path = pytester.makepyfile( + """ + import pytest + import typing + from typing import * + + @pytest.mark.parametrize_types( + argnames=["a", "b"], + argtypes=[int, float, str], + ) + def test_func(a, b) -> None: + assert a + assert b + """ + ) + result: pytest.RunResult = pytester.runpytest(test_path) + result.assert_outcomes(errors=1) + + +def test_parametrize_types_with_no_ids_provided( + pytester: pytest.Pytester, conftest: Path +) -> None: + test_path: Path = pytester.makepyfile( + """ + import pytest + import typing + from typing import * + + @pytest.mark.parametrize_types( + argnames=["a", "b"], + argtypes=[bool, bool], + ) + def test_func(a, b) -> None: + assert a is not None + assert b is not None + """ + ) + result: pytest.RunResult = pytester.runpytest(test_path) + result.assert_outcomes(passed=4) + + +def test_parametrize_types_with_argnames_as_string( + pytester: pytest.Pytester, conftest: Path +) -> None: + test_path: Path = pytester.makepyfile( + """ + import pytest + import typing + from typing import * + + @pytest.mark.parametrize_types( + argnames="a, b", + argtypes=[bool, bool], + ) + def test_func(a, b) -> None: + assert a is not None + assert b is not None + """ + ) + result: pytest.RunResult = pytester.runpytest(test_path) + result.assert_outcomes(passed=4) + + @pytest.mark.parametrize( argnames=["argtypes", "expected"], argvalues=[ From 757bebf4cbe623d26c192ba1e2601957adc1fb47 Mon Sep 17 00:00:00 2001 From: Kyle Oliver Date: Wed, 30 Aug 2023 23:26:15 -0400 Subject: [PATCH 12/17] Appeases the majority of mypy. Prepping to use ParamSpec in ExpandedType --- src/pytest_static/parametric.py | 4 +++- tests/unit_tests/conftest.py | 2 +- tests/unit_tests/test_parametric.py | 18 ++++++++++-------- 3 files changed, 14 insertions(+), 10 deletions(-) diff --git a/src/pytest_static/parametric.py b/src/pytest_static/parametric.py index b0c2dab..87afa1c 100644 --- a/src/pytest_static/parametric.py +++ b/src/pytest_static/parametric.py @@ -186,7 +186,9 @@ def parametrize_types( instance_sets: List[List[T]] = [ list(get_all_possible_type_instances(t)) for t in argtypes ] - instance_combinations: List[List[T]] = list(itertools.product(*instance_sets)) + instance_combinations: List[Iterable[itertools.product[Tuple[Any, ...]]]] = list( + itertools.product(*instance_sets) + ) if ids is None: ids = [", ".join(map(repr, ic)) for ic in instance_combinations] diff --git a/tests/unit_tests/conftest.py b/tests/unit_tests/conftest.py index 9d14f2e..a52b8af 100644 --- a/tests/unit_tests/conftest.py +++ b/tests/unit_tests/conftest.py @@ -28,7 +28,7 @@ def expanded_type( @pytest.fixture(scope="function") -def primary_type(request: FixtureRequest) -> Type[T]: +def primary_type(request: FixtureRequest) -> Type[Any]: return getattr(request, "param", List) diff --git a/tests/unit_tests/test_parametric.py b/tests/unit_tests/test_parametric.py index 7b3abc2..f0a44b6 100644 --- a/tests/unit_tests/test_parametric.py +++ b/tests/unit_tests/test_parametric.py @@ -87,16 +87,18 @@ def test_get_instances_with_multiple_nested(self, monkeypatch: MonkeyPatch) -> N def test__get_parameter_instance_sets( self, primary_type: Type[T], - type_args: Type[T], + type_args: Tuple[Union[Any, ExpandedType[Any]], ...], expected_sets: Tuple[Set[Any], ...], ) -> None: - expected_sets = [tuple(expected_set) for expected_set in expected_sets] + expected: List[Tuple[Any, ...]] = [ + tuple(iter(expected_set)) for expected_set in expected_sets + ] assert ( ExpandedType( primary_type=primary_type, type_args=type_args, )._get_parameter_instance_sets() - == expected_sets + == expected ) @pytest.mark.parametrize( @@ -128,7 +130,7 @@ def test__get_parameter_combinations( indirect=True, ) def test__instantiate_each_parameter_combination_with_builtin( - self, expanded_type: ExpandedType + self, expanded_type: ExpandedType[Any] ) -> None: with pytest.raises(ValueError): expanded_type._instantiate_each_parameter_combination( @@ -203,8 +205,8 @@ def test__instantiate_expanded(self) -> None: @pytest.mark.parametrize( argnames=["primary_type", "type_args", "combination"], argvalues=[ - (list, (int,), (1,)), - (list, (int,), (1, 2)), + (list, (int,), (1, 2, 3)), + (list, (int, str), (1, "2", 3)), ], ids=[ "single_type_arg", @@ -214,11 +216,11 @@ def test__instantiate_expanded(self) -> None: ) def test__instantiate_not_expanded( self, - expanded_type: ExpandedType, + expanded_type: ExpandedType[List[Any]], combination: Tuple[Any, ...], ) -> None: assert expanded_type._instantiate_not_expanded( - combination + combination=combination ) == expanded_type.primary_type(combination) From f55b650bb8099e1b4af015e2b9e7820b40b294be Mon Sep 17 00:00:00 2001 From: Kyle Oliver Date: Thu, 31 Aug 2023 18:23:09 -0400 Subject: [PATCH 13/17] cleans up typing and sacrifices a goat for our mypy overlords --- src/pytest_static/parametric.py | 6 ++++-- tests/unit_tests/test_parametric.py | 21 ++++++++++++++++----- 2 files changed, 20 insertions(+), 7 deletions(-) diff --git a/src/pytest_static/parametric.py b/src/pytest_static/parametric.py index 87afa1c..1ccdcf6 100644 --- a/src/pytest_static/parametric.py +++ b/src/pytest_static/parametric.py @@ -144,12 +144,14 @@ def _instantiate_combinations_using_not_expanded( def _instantiate_expanded(self, combination: Tuple[Any, ...]) -> T: """Returns an instance of the primary_type using the combination provided.""" if self.primary_type is dict: - return self.primary_type([combination]) + instantiation_method: Callable[..., T] = self.primary_type + return instantiation_method([combination]) return self.primary_type(*combination) def _instantiate_not_expanded(self, combination: Tuple[Any, ...]) -> T: """Returns an instance of the primary_type using the combination provided.""" - return self.primary_type(combination) + instantiation_method: Callable[..., T] = self.primary_type + return instantiation_method(combination) @dataclass(frozen=True) diff --git a/tests/unit_tests/test_parametric.py b/tests/unit_tests/test_parametric.py index f0a44b6..2501b24 100644 --- a/tests/unit_tests/test_parametric.py +++ b/tests/unit_tests/test_parametric.py @@ -15,13 +15,14 @@ import pytest from _pytest.monkeypatch import MonkeyPatch +from pytest_static import type_sets from pytest_static.parametric import Config from pytest_static.parametric import ExpandedType from pytest_static.parametric import expand_type from pytest_static.type_sets import PREDEFINED_TYPE_SETS -T = TypeVar("T") +T = TypeVar("T", bound=Any) class DummyClass: @@ -42,8 +43,13 @@ def test_get_instances_with_nested(self) -> None: ) def test_get_instances_with_multiple(self, monkeypatch: MonkeyPatch) -> None: - monkeypatch.setitem(PREDEFINED_TYPE_SETS, int, {1, 2}) - monkeypatch.setitem(PREDEFINED_TYPE_SETS, str, {"a", "b"}) + new_predefined_type_sets: Dict[Type[Any], Set[Any]] = { + **PREDEFINED_TYPE_SETS, + int: {1, 2}, + str: {"a", "b"}, + } + monkeypatch.setattr(type_sets, "PREDEFINED_TYPE_SETS", new_predefined_type_sets) + expected_instances: Tuple[List[Union[int, str]], ...] = ( [1, "a"], [1, "b"], @@ -56,8 +62,13 @@ def test_get_instances_with_multiple(self, monkeypatch: MonkeyPatch) -> None: assert instance in expanded_instances def test_get_instances_with_multiple_nested(self, monkeypatch: MonkeyPatch) -> None: - monkeypatch.setitem(PREDEFINED_TYPE_SETS, int, {1, 2}) - monkeypatch.setitem(PREDEFINED_TYPE_SETS, str, {"a", "b"}) + new_predefined_type_sets: Dict[Type[Any], Set[Any]] = { + **PREDEFINED_TYPE_SETS, + int: {1, 2}, + str: {"a", "b"}, + } + monkeypatch.setattr(type_sets, "PREDEFINED_TYPE_SETS", new_predefined_type_sets) + expected_instances: Tuple[List[Union[List[int], str]], ...] = ( [[1], "a"], [[1], "b"], From 2815ee6dd7c9c50971edb1423e6d3e65293bcd20 Mon Sep 17 00:00:00 2001 From: Kyle Oliver Date: Thu, 31 Aug 2023 21:01:40 -0400 Subject: [PATCH 14/17] Appeases mypy further and adds B905 to Flake8 ignore due to backward compatibility not allowing zip to use strict --- .flake8 | 2 +- noxfile.py | 2 +- src/pytest_static/parametric.py | 2 +- tests/unit_tests/test_parametric.py | 4 +++- tests/unit_tests/test_plugin.py | 2 +- 5 files changed, 7 insertions(+), 5 deletions(-) diff --git a/.flake8 b/.flake8 index e45d7f9..256fca2 100644 --- a/.flake8 +++ b/.flake8 @@ -1,6 +1,6 @@ [flake8] select = B,B9,C,D,DAR,E,F,N,RST,S,W -ignore = E203,E501,RST201,RST203,RST301,W503 +ignore = E203,E501,RST201,RST203,RST301,W503,B905 max-line-length = 80 max-complexity = 10 docstring-convention = google diff --git a/noxfile.py b/noxfile.py index 9002d17..71c768a 100644 --- a/noxfile.py +++ b/noxfile.py @@ -23,7 +23,7 @@ package = "pytest_static" -python_versions = ["3.10", "3.9", "3.8", "3.7"] +python_versions = ["3.10", "3.9", "3.8"] nox.needs_version = ">= 2021.6.6" nox.options.sessions = ( "pre-commit", diff --git a/src/pytest_static/parametric.py b/src/pytest_static/parametric.py index 1ccdcf6..cef7a47 100644 --- a/src/pytest_static/parametric.py +++ b/src/pytest_static/parametric.py @@ -63,7 +63,7 @@ def _get_parameter_combinations( """Returns a list of parameter combinations.""" if len(parameter_instance_sets) > 1: return list(itertools.product(*parameter_instance_sets)) - return list(zip(*parameter_instance_sets, strict=True)) + return list(zip(*parameter_instance_sets)) def get_instances(self) -> Tuple[T, ...]: """Returns a tuple of all possible instances of the primary_type.""" diff --git a/tests/unit_tests/test_parametric.py b/tests/unit_tests/test_parametric.py index 2501b24..3413711 100644 --- a/tests/unit_tests/test_parametric.py +++ b/tests/unit_tests/test_parametric.py @@ -1,4 +1,3 @@ -from types import NoneType from typing import Any from typing import Dict from typing import FrozenSet @@ -22,6 +21,9 @@ from pytest_static.type_sets import PREDEFINED_TYPE_SETS +NoneType: Type[None] = type(None) + + T = TypeVar("T", bound=Any) diff --git a/tests/unit_tests/test_plugin.py b/tests/unit_tests/test_plugin.py index 5d16c61..c323a53 100644 --- a/tests/unit_tests/test_plugin.py +++ b/tests/unit_tests/test_plugin.py @@ -37,7 +37,7 @@ def parametrize_types_test( argnames: List[str] = [f"arg{i}" for i in range(len(argtypes))] argtypes_formatted: str = ", ".join([f"{argtype}" for argtype in argtypes]) signature: str = ", ".join( - [f"{argname}" for argname, argtype in zip(argnames, argtypes, strict=True)] + [f"{argname}" for argname, argtype in zip(argnames, argtypes)] ) return pytester.makepyfile( From 49c04c925add8d43be7567218f8fbffe2dacbf50 Mon Sep 17 00:00:00 2001 From: Kyle Oliver Date: Thu, 31 Aug 2023 21:30:47 -0400 Subject: [PATCH 15/17] Updates packages --- poetry.lock | 998 ++++++++++++++++++++++++------------------------- pyproject.toml | 4 +- 2 files changed, 482 insertions(+), 520 deletions(-) diff --git a/poetry.lock b/poetry.lock index 289a882..cc40caa 100644 --- a/poetry.lock +++ b/poetry.lock @@ -14,9 +14,6 @@ category = "dev" optional = false python-versions = ">=3.7" -[package.dependencies] -importlib-metadata = {version = "*", markers = "python_version < \"3.8\""} - [package.extras] cov = ["attrs", "coverage[toml] (>=5.3)"] dev = ["attrs", "pre-commit"] @@ -84,7 +81,6 @@ mypy-extensions = ">=0.4.3" pathspec = ">=0.9.0" platformdirs = ">=2" tomli = {version = ">=1.1.0", markers = "python_full_version < \"3.11.0a7\""} -typed-ast = {version = ">=1.4.2", markers = "python_version < \"3.8\" and implementation_name == \"cpython\""} typing-extensions = {version = ">=3.10.0.0", markers = "python_version < \"3.10\""} [package.extras] @@ -95,7 +91,7 @@ uvloop = ["uvloop (>=0.15.2)"] [[package]] name = "certifi" -version = "2023.5.7" +version = "2023.7.22" description = "Python package for providing Mozilla's CA Bundle." category = "dev" optional = false @@ -103,15 +99,15 @@ python-versions = ">=3.6" [[package]] name = "cfgv" -version = "3.3.1" +version = "3.4.0" description = "Validate configuration and produce human readable error messages." category = "dev" optional = false -python-versions = ">=3.6.1" +python-versions = ">=3.8" [[package]] name = "charset-normalizer" -version = "3.1.0" +version = "3.2.0" description = "The Real First Universal Charset Detector. Open, modern and actively maintained alternative to Chardet." category = "dev" optional = false @@ -119,7 +115,7 @@ python-versions = ">=3.7.0" [[package]] name = "click" -version = "8.1.3" +version = "8.1.7" description = "Composable command line interface toolkit" category = "main" optional = false @@ -127,7 +123,6 @@ python-versions = ">=3.7" [package.dependencies] colorama = {version = "*", markers = "platform_system == \"Windows\""} -importlib-metadata = {version = "*", markers = "python_version < \"3.8\""} [[package]] name = "colorama" @@ -139,11 +134,11 @@ python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,!=3.6.*,>=2.7 [[package]] name = "coverage" -version = "7.2.5" +version = "7.3.0" description = "Code coverage measurement for Python" category = "dev" optional = false -python-versions = ">=3.7" +python-versions = ">=3.8" [package.dependencies] tomli = {version = "*", optional = true, markers = "python_full_version <= \"3.11.0a6\" and extra == \"toml\""} @@ -161,7 +156,7 @@ python-versions = ">=3.6,<4.0" [[package]] name = "distlib" -version = "0.3.6" +version = "0.3.7" description = "Distribution utilities" category = "dev" optional = false @@ -169,31 +164,31 @@ python-versions = "*" [[package]] name = "docutils" -version = "0.17.1" +version = "0.20.1" description = "Docutils -- Python Documentation Utilities" category = "dev" optional = false -python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*" +python-versions = ">=3.7" [[package]] name = "dparse" -version = "0.6.2" +version = "0.6.3" description = "A parser for Python dependency files" category = "dev" optional = false -python-versions = ">=3.5" +python-versions = ">=3.6" [package.dependencies] packaging = "*" -toml = "*" +tomli = {version = "*", markers = "python_version < \"3.11\""} [package.extras] conda = ["pyyaml"] -pipenv = ["pipenv"] +pipenv = ["pipenv (<=2022.12.19)"] [[package]] name = "exceptiongroup" -version = "1.1.1" +version = "1.1.3" description = "Backport of PEP 654 (exception groups)" category = "dev" optional = false @@ -204,15 +199,18 @@ test = ["pytest (>=6)"] [[package]] name = "filelock" -version = "3.12.0" +version = "3.12.3" description = "A platform independent file lock." category = "dev" optional = false -python-versions = ">=3.7" +python-versions = ">=3.8" + +[package.dependencies] +typing-extensions = {version = ">=4.7.1", markers = "python_version < \"3.11\""} [package.extras] -docs = ["furo (>=2023.3.27)", "sphinx (>=6.1.3)", "sphinx-autodoc-typehints (>=1.23,!=1.23.4)"] -testing = ["covdefaults (>=2.3)", "coverage (>=7.2.3)", "diff-cover (>=7.5)", "pytest (>=7.3.1)", "pytest-cov (>=4)", "pytest-mock (>=3.10)", "pytest-timeout (>=2.1)"] +docs = ["furo (>=2023.7.26)", "sphinx (>=7.1.2)", "sphinx-autodoc-typehints (>=1.24)"] +testing = ["covdefaults (>=2.3)", "coverage (>=7.3)", "diff-cover (>=7.7)", "pytest (>=7.4)", "pytest-cov (>=4.1)", "pytest-mock (>=3.11.1)", "pytest-timeout (>=2.1)"] [[package]] name = "flake8" @@ -223,7 +221,6 @@ optional = false python-versions = ">=3.6.1" [package.dependencies] -importlib-metadata = {version = ">=1.1.0,<4.3", markers = "python_version < \"3.8\""} mccabe = ">=0.7.0,<0.8.0" pycodestyle = ">=2.9.0,<2.10.0" pyflakes = ">=2.5.0,<2.6.0" @@ -285,16 +282,16 @@ develop = ["build", "twine"] [[package]] name = "furo" -version = "2022.9.29" +version = "2023.8.19" description = "A clean customisable Sphinx documentation theme." category = "dev" optional = false -python-versions = ">=3.7" +python-versions = ">=3.8" [package.dependencies] beautifulsoup4 = "*" pygments = ">=2.7" -sphinx = ">=4.0,<6.0" +sphinx = ">=6.0,<8.0" sphinx-basic-ng = "*" [[package]] @@ -310,7 +307,7 @@ smmap = ">=3.0.1,<6" [[package]] name = "gitpython" -version = "3.1.31" +version = "3.1.32" description = "GitPython is a Python library used to interact with Git repositories" category = "dev" optional = false @@ -318,15 +315,14 @@ python-versions = ">=3.7" [package.dependencies] gitdb = ">=4.0.1,<5" -typing-extensions = {version = ">=3.7.4.3", markers = "python_version < \"3.8\""} [[package]] name = "identify" -version = "2.5.24" +version = "2.5.27" description = "File identification library for Python" category = "dev" optional = false -python-versions = ">=3.7" +python-versions = ">=3.8" [package.extras] license = ["ukkonen"] @@ -349,19 +345,19 @@ python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" [[package]] name = "importlib-metadata" -version = "4.2.0" +version = "6.8.0" description = "Read metadata from Python packages" -category = "main" +category = "dev" optional = false -python-versions = ">=3.6" +python-versions = ">=3.8" [package.dependencies] -typing-extensions = {version = ">=3.6.4", markers = "python_version < \"3.8\""} zipp = ">=0.5" [package.extras] -docs = ["jaraco.packaging (>=8.2)", "rst.linker (>=1.9)", "sphinx"] -testing = ["flufl.flake8", "importlib-resources (>=1.3)", "packaging", "pep517", "pyfakefs", "pytest (>=4.6)", "pytest-black (>=0.3.7)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=1.0.1)", "pytest-flake8", "pytest-mypy"] +docs = ["furo", "jaraco.packaging (>=9)", "jaraco.tidelift (>=1.4)", "rst.linker (>=1.9)", "sphinx (>=3.5)", "sphinx-lint"] +perf = ["ipython"] +testing = ["flufl.flake8", "importlib-resources (>=1.3)", "packaging", "pyfakefs", "pytest (>=6)", "pytest-black (>=0.3.7)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=2.2)", "pytest-mypy (>=0.9.1)", "pytest-perf (>=0.9.2)", "pytest-ruff"] [[package]] name = "iniconfig" @@ -373,14 +369,14 @@ python-versions = ">=3.7" [[package]] name = "isort" -version = "5.11.5" +version = "5.12.0" description = "A Python utility / library to sort Python imports." category = "dev" optional = false -python-versions = ">=3.7.0" +python-versions = ">=3.8.0" [package.extras] -colors = ["colorama (>=0.4.3,<0.5.0)"] +colors = ["colorama (>=0.4.3)"] pipfile-deprecated-finder = ["pip-shims (>=0.5.2)", "pipreqs", "requirementslib"] plugins = ["setuptools"] requirements-deprecated-finder = ["pip-api", "pipreqs"] @@ -428,15 +424,14 @@ dev = ["Sphinx (==5.3.0)", "colorama (==0.4.5)", "colorama (==0.4.6)", "freezegu [[package]] name = "markdown-it-py" -version = "2.2.0" +version = "3.0.0" description = "Python port of markdown-it. Markdown parsing, done right!" category = "dev" optional = false -python-versions = ">=3.7" +python-versions = ">=3.8" [package.dependencies] mdurl = ">=0.1,<1.0" -typing_extensions = {version = ">=3.7.4", markers = "python_version < \"3.8\""} [package.extras] benchmarking = ["psutil", "pytest", "pytest-benchmark"] @@ -445,12 +440,12 @@ compare = ["commonmark (>=0.9,<1.0)", "markdown (>=3.4,<4.0)", "mistletoe (>=1.0 linkify = ["linkify-it-py (>=1,<3)"] plugins = ["mdit-py-plugins"] profiling = ["gprof2dot"] -rtd = ["attrs", "myst-parser", "pyyaml", "sphinx", "sphinx-book-theme", "sphinx-copybutton", "sphinx-design"] +rtd = ["jupyter-sphinx", "mdit-py-plugins", "myst-parser", "pyyaml", "sphinx", "sphinx-book-theme", "sphinx-copybutton", "sphinx-design"] testing = ["coverage", "pytest", "pytest-cov", "pytest-regressions"] [[package]] name = "markupsafe" -version = "2.1.2" +version = "2.1.3" description = "Safely add untrusted strings to HTML/XML markup." category = "dev" optional = false @@ -466,18 +461,18 @@ python-versions = ">=3.6" [[package]] name = "mdit-py-plugins" -version = "0.3.5" +version = "0.4.0" description = "Collection of plugins for markdown-it-py" category = "dev" optional = false -python-versions = ">=3.7" +python-versions = ">=3.8" [package.dependencies] -markdown-it-py = ">=1.0.0,<3.0.0" +markdown-it-py = ">=1.0.0,<4.0.0" [package.extras] code_style = ["pre-commit"] -rtd = ["attrs", "myst-parser (>=0.16.1,<0.17.0)", "sphinx-book-theme (>=0.1.0,<0.2.0)"] +rtd = ["myst-parser", "sphinx-book-theme"] testing = ["coverage", "pytest", "pytest-cov", "pytest-regressions"] [[package]] @@ -490,22 +485,20 @@ python-versions = ">=3.7" [[package]] name = "mypy" -version = "1.2.0" +version = "1.5.1" description = "Optional static typing for Python" category = "dev" optional = false -python-versions = ">=3.7" +python-versions = ">=3.8" [package.dependencies] mypy-extensions = ">=1.0.0" tomli = {version = ">=1.1.0", markers = "python_version < \"3.11\""} -typed-ast = {version = ">=1.4.0,<2", markers = "python_version < \"3.8\""} -typing-extensions = ">=3.10" +typing-extensions = ">=4.1.0" [package.extras] dmypy = ["psutil (>=4.0)"] install-types = ["pip"] -python2 = ["typed-ast (>=1.4.0,<2)"] reports = ["lxml"] [[package]] @@ -518,30 +511,30 @@ python-versions = ">=3.5" [[package]] name = "myst-parser" -version = "0.18.1" -description = "An extended commonmark compliant parser, with bridges to docutils & sphinx." +version = "2.0.0" +description = "An extended [CommonMark](https://spec.commonmark.org/) compliant parser," category = "dev" optional = false -python-versions = ">=3.7" +python-versions = ">=3.8" [package.dependencies] -docutils = ">=0.15,<0.20" +docutils = ">=0.16,<0.21" jinja2 = "*" -markdown-it-py = ">=1.0.0,<3.0.0" -mdit-py-plugins = ">=0.3.1,<0.4.0" +markdown-it-py = ">=3.0,<4.0" +mdit-py-plugins = ">=0.4,<1.0" pyyaml = "*" -sphinx = ">=4,<6" -typing-extensions = "*" +sphinx = ">=6,<8" [package.extras] -code_style = ["pre-commit (>=2.12,<3.0)"] -linkify = ["linkify-it-py (>=1.0,<2.0)"] -rtd = ["ipython", "sphinx-book-theme", "sphinx-design", "sphinxcontrib.mermaid (>=0.7.1,<0.8.0)", "sphinxext-opengraph (>=0.6.3,<0.7.0)", "sphinxext-rediraffe (>=0.2.7,<0.3.0)"] -testing = ["beautifulsoup4", "coverage", "pytest (>=6,<7)", "pytest-cov", "pytest-param-files (>=0.3.4,<0.4.0)", "pytest-regressions", "sphinx (<5.2)", "sphinx-pytest"] +code_style = ["pre-commit (>=3.0,<4.0)"] +linkify = ["linkify-it-py (>=2.0,<3.0)"] +rtd = ["ipython", "pydata-sphinx-theme (==v0.13.0rc4)", "sphinx-autodoc2 (>=0.4.2,<0.5.0)", "sphinx-book-theme (==1.0.0rc2)", "sphinx-copybutton", "sphinx-design2", "sphinx-pyscript", "sphinx-tippy (>=0.3.1)", "sphinx-togglebutton", "sphinxext-opengraph (>=0.8.2,<0.9.0)", "sphinxext-rediraffe (>=0.2.7,<0.3.0)"] +testing = ["beautifulsoup4", "coverage", "pytest (>=7,<8)", "pytest-cov", "pytest-param-files (>=0.3.4,<0.4.0)", "pytest-regressions", "sphinx-pytest"] +testing-docutils = ["pygments", "pytest (>=7,<8)", "pytest-param-files (>=0.3.4,<0.4.0)"] [[package]] name = "nodeenv" -version = "1.7.0" +version = "1.8.0" description = "Node.js virtual environment builder" category = "dev" optional = false @@ -560,7 +553,7 @@ pyparsing = ">=2.0.2,<3.0.5 || >3.0.5" [[package]] name = "pathspec" -version = "0.11.1" +version = "0.11.2" description = "Utility library for gitignore style pattern matching of file paths." category = "dev" optional = false @@ -587,29 +580,23 @@ flake8 = ">=5.0.0" [[package]] name = "platformdirs" -version = "2.6.2" +version = "3.10.0" description = "A small Python package for determining appropriate platform-specific dirs, e.g. a \"user data dir\"." category = "dev" optional = false python-versions = ">=3.7" -[package.dependencies] -typing-extensions = {version = ">=4.4", markers = "python_version < \"3.8\""} - [package.extras] -docs = ["furo (>=2022.12.7)", "proselint (>=0.13)", "sphinx (>=5.3)", "sphinx-autodoc-typehints (>=1.19.5)"] -test = ["appdirs (==1.4.4)", "covdefaults (>=2.2.2)", "pytest (>=7.2)", "pytest-cov (>=4)", "pytest-mock (>=3.10)"] +docs = ["furo (>=2023.7.26)", "proselint (>=0.13)", "sphinx (>=7.1.1)", "sphinx-autodoc-typehints (>=1.24)"] +test = ["appdirs (==1.4.4)", "covdefaults (>=2.3)", "pytest (>=7.4)", "pytest-cov (>=4.1)", "pytest-mock (>=3.11.1)"] [[package]] name = "pluggy" -version = "1.0.0" +version = "1.3.0" description = "plugin and hook calling mechanisms for python" category = "dev" optional = false -python-versions = ">=3.6" - -[package.dependencies] -importlib-metadata = {version = ">=0.12", markers = "python_version < \"3.8\""} +python-versions = ">=3.8" [package.extras] dev = ["pre-commit", "tox"] @@ -617,16 +604,15 @@ testing = ["pytest", "pytest-benchmark"] [[package]] name = "pre-commit" -version = "2.21.0" +version = "3.3.3" description = "A framework for managing and maintaining multi-language pre-commit hooks." category = "dev" optional = false -python-versions = ">=3.7" +python-versions = ">=3.8" [package.dependencies] cfgv = ">=2.0.0" identify = ">=1.0.0" -importlib-metadata = {version = "*", markers = "python_version < \"3.8\""} nodeenv = ">=0.11.1" pyyaml = ">=5.1" virtualenv = ">=20.10.0" @@ -660,7 +646,6 @@ optional = false python-versions = ">=3.6" [package.dependencies] -importlib-metadata = {version = ">=2.0.0,<5.0.0", markers = "python_version < \"3.8\""} snowballstemmer = ">=2.2.0" [package.extras] @@ -676,7 +661,7 @@ python-versions = ">=3.6" [[package]] name = "pygments" -version = "2.15.1" +version = "2.16.1" description = "Pygments is a syntax highlighting package written in Python." category = "dev" optional = false @@ -687,7 +672,7 @@ plugins = ["importlib-metadata"] [[package]] name = "pyparsing" -version = "3.0.9" +version = "3.1.1" description = "pyparsing module - Classes and methods to define and execute parsing grammars" category = "dev" optional = false @@ -698,7 +683,7 @@ diagrams = ["jinja2", "railroad-diagrams"] [[package]] name = "pytest" -version = "7.3.1" +version = "7.4.0" description = "pytest: simple powerful testing with Python" category = "dev" optional = false @@ -707,14 +692,13 @@ python-versions = ">=3.7" [package.dependencies] colorama = {version = "*", markers = "sys_platform == \"win32\""} exceptiongroup = {version = ">=1.0.0rc8", markers = "python_version < \"3.11\""} -importlib-metadata = {version = ">=0.12", markers = "python_version < \"3.8\""} iniconfig = "*" packaging = "*" pluggy = ">=0.12,<2.0" tomli = {version = ">=1.0.0", markers = "python_version < \"3.11\""} [package.extras] -testing = ["argcomplete", "attrs (>=19.2.0)", "hypothesis (>=3.56)", "mock", "nose", "pygments (>=2.7.2)", "requests", "xmlschema"] +testing = ["argcomplete", "attrs (>=19.2.0)", "hypothesis (>=3.56)", "mock", "nose", "pygments (>=2.7.2)", "requests", "setuptools", "xmlschema"] [[package]] name = "pytz" @@ -726,18 +710,18 @@ python-versions = "*" [[package]] name = "pyupgrade" -version = "3.3.2" +version = "3.8.0" description = "A tool to automatically upgrade syntax for newer versions." category = "dev" optional = false -python-versions = ">=3.7" +python-versions = ">=3.8" [package.dependencies] tokenize-rt = ">=3.2.0" [[package]] name = "pyyaml" -version = "6.0" +version = "6.0.1" description = "YAML parser and emitter for Python" category = "dev" optional = false @@ -745,7 +729,7 @@ python-versions = ">=3.6" [[package]] name = "requests" -version = "2.30.0" +version = "2.31.0" description = "Python HTTP for Humans." category = "dev" optional = false @@ -774,14 +758,14 @@ docutils = ">=0.11,<1.0" [[package]] name = "rich" -version = "13.3.5" +version = "13.5.2" description = "Render rich text, tables, progress bars, syntax highlighting, markdown and more to the terminal" category = "dev" optional = false python-versions = ">=3.7.0" [package.dependencies] -markdown-it-py = ">=2.2.0,<3.0.0" +markdown-it-py = ">=2.2.0" pygments = ">=2.13.0,<3.0.0" typing-extensions = {version = ">=4.0.0,<5.0", markers = "python_version < \"3.9\""} @@ -790,7 +774,7 @@ jupyter = ["ipywidgets (>=7.5.1,<9)"] [[package]] name = "ruamel.yaml" -version = "0.17.24" +version = "0.17.32" description = "ruamel.yaml is a YAML parser/emitter that supports roundtrip preservation of comments, seq/map flow style, and map key order" category = "dev" optional = false @@ -864,23 +848,24 @@ python-versions = ">=3.7" [[package]] name = "sphinx" -version = "4.3.2" +version = "7.1.2" description = "Python documentation generator" category = "dev" optional = false -python-versions = ">=3.6" +python-versions = ">=3.8" [package.dependencies] alabaster = ">=0.7,<0.8" -babel = ">=1.3" -colorama = {version = ">=0.3.5", markers = "sys_platform == \"win32\""} -docutils = ">=0.14,<0.18" -imagesize = "*" -Jinja2 = ">=2.3" -packaging = "*" -Pygments = ">=2.0" -requests = ">=2.5.0" -snowballstemmer = ">=1.1" +babel = ">=2.9" +colorama = {version = ">=0.4.5", markers = "sys_platform == \"win32\""} +docutils = ">=0.18.1,<0.21" +imagesize = ">=1.3" +importlib-metadata = {version = ">=4.8", markers = "python_version < \"3.10\""} +Jinja2 = ">=3.0" +packaging = ">=21.0" +Pygments = ">=2.13" +requests = ">=2.25.0" +snowballstemmer = ">=2.0" sphinxcontrib-applehelp = "*" sphinxcontrib-devhelp = "*" sphinxcontrib-htmlhelp = ">=2.0.0" @@ -890,8 +875,8 @@ sphinxcontrib-serializinghtml = ">=1.1.5" [package.extras] docs = ["sphinxcontrib-websupport"] -lint = ["docutils-stubs", "flake8 (>=3.5.0)", "isort", "mypy (>=0.920)", "types-pkg-resources", "types-requests", "types-typed-ast"] -test = ["cython", "html5lib", "pytest", "pytest-cov", "typed-ast"] +lint = ["docutils-stubs", "flake8 (>=3.5.0)", "flake8-simplify", "isort", "mypy (>=0.990)", "ruff", "sphinx-lint", "types-requests"] +test = ["cython", "filelock", "html5lib", "pytest (>=4.6)"] [[package]] name = "sphinx-autobuild" @@ -911,7 +896,7 @@ test = ["pytest", "pytest-cov"] [[package]] name = "sphinx-basic-ng" -version = "1.0.0b1" +version = "1.0.0b2" description = "A modern skeleton for Sphinx themes." category = "dev" optional = false @@ -925,11 +910,11 @@ docs = ["furo", "ipython", "myst-parser", "sphinx-copybutton", "sphinx-inline-ta [[package]] name = "sphinx-click" -version = "4.4.0" +version = "5.0.1" description = "Sphinx extension that automatically documents click applications" category = "dev" optional = false -python-versions = ">=3.7" +python-versions = ">=3.8" [package.dependencies] click = ">=7.0" @@ -938,11 +923,11 @@ sphinx = ">=2.0" [[package]] name = "sphinxcontrib-applehelp" -version = "1.0.2" -description = "sphinxcontrib-applehelp is a sphinx extension which outputs Apple help books" +version = "1.0.4" +description = "sphinxcontrib-applehelp is a Sphinx extension which outputs Apple help books" category = "dev" optional = false -python-versions = ">=3.5" +python-versions = ">=3.8" [package.extras] lint = ["docutils-stubs", "flake8", "mypy"] @@ -962,11 +947,11 @@ test = ["pytest"] [[package]] name = "sphinxcontrib-htmlhelp" -version = "2.0.0" +version = "2.0.1" description = "sphinxcontrib-htmlhelp is a sphinx extension which renders HTML help files" category = "dev" optional = false -python-versions = ">=3.6" +python-versions = ">=3.8" [package.extras] lint = ["docutils-stubs", "flake8", "mypy"] @@ -1009,31 +994,22 @@ test = ["pytest"] [[package]] name = "stevedore" -version = "3.5.2" +version = "5.1.0" description = "Manage dynamic plugins for Python applications" category = "dev" optional = false -python-versions = ">=3.6" +python-versions = ">=3.8" [package.dependencies] -importlib-metadata = {version = ">=1.7.0", markers = "python_version < \"3.8\""} pbr = ">=2.0.0,<2.1.0 || >2.1.0" [[package]] name = "tokenize-rt" -version = "5.0.0" +version = "5.2.0" description = "A wrapper around the stdlib `tokenize` which roundtrips." category = "dev" optional = false -python-versions = ">=3.7" - -[[package]] -name = "toml" -version = "0.10.2" -description = "Python Library for Tom's Obvious, Minimal Language" -category = "dev" -optional = false -python-versions = ">=2.6, !=3.0.*, !=3.1.*, !=3.2.*" +python-versions = ">=3.8" [[package]] name = "tomli" @@ -1045,43 +1021,39 @@ python-versions = ">=3.7" [[package]] name = "tornado" -version = "6.2" +version = "6.3.3" description = "Tornado is a Python web framework and asynchronous networking library, originally developed at FriendFeed." -category = "dev" +category = "main" optional = false -python-versions = ">= 3.7" - -[[package]] -name = "typed-ast" -version = "1.5.4" -description = "a fork of Python 2 and 3 ast modules with type comment support" -category = "dev" -optional = false -python-versions = ">=3.6" +python-versions = ">= 3.8" [[package]] name = "typeguard" -version = "2.13.3" +version = "4.1.3" description = "Run-time type checker for Python" category = "dev" optional = false -python-versions = ">=3.5.3" +python-versions = ">=3.8" + +[package.dependencies] +importlib-metadata = {version = ">=3.6", markers = "python_version < \"3.10\""} +typing-extensions = {version = ">=4.7.0", markers = "python_version < \"3.12\""} [package.extras] -doc = ["sphinx-autodoc-typehints (>=1.2.0)", "sphinx-rtd-theme"] -test = ["mypy", "pytest", "typing-extensions"] +doc = ["Sphinx (>=7)", "packaging", "sphinx-autodoc-typehints (>=1.2.0)"] +test = ["coverage[toml] (>=7)", "mypy (>=1.2.0)", "pytest (>=7)"] [[package]] name = "typing-extensions" -version = "4.5.0" +version = "4.7.1" description = "Backported and Experimental Type Hints for Python 3.7+" -category = "main" +category = "dev" optional = false python-versions = ">=3.7" [[package]] name = "urllib3" -version = "2.0.2" +version = "2.0.4" description = "HTTP library with thread-safe connection pooling, file post, and more." category = "dev" optional = false @@ -1095,21 +1067,20 @@ zstd = ["zstandard (>=0.18.0)"] [[package]] name = "virtualenv" -version = "20.16.2" +version = "20.24.4" description = "Virtual Python Environment builder" category = "dev" optional = false -python-versions = ">=3.6" +python-versions = ">=3.7" [package.dependencies] -distlib = ">=0.3.1,<1" -filelock = ">=3.2,<4" -importlib-metadata = {version = ">=0.12", markers = "python_version < \"3.8\""} -platformdirs = ">=2,<3" +distlib = ">=0.3.7,<1" +filelock = ">=3.12.2,<4" +platformdirs = ">=3.9.1,<4" [package.extras] -docs = ["proselint (>=0.10.2)", "sphinx (>=3)", "sphinx-argparse (>=0.2.5)", "sphinx-rtd-theme (>=0.4.3)", "towncrier (>=21.3)"] -testing = ["coverage (>=4)", "coverage-enable-subprocess (>=1)", "flaky (>=3)", "packaging (>=20.0)", "pytest (>=4)", "pytest-env (>=0.6.2)", "pytest-freezegun (>=0.4.1)", "pytest-mock (>=2)", "pytest-randomly (>=1)", "pytest-timeout (>=1)"] +docs = ["furo (>=2023.7.26)", "proselint (>=0.13)", "sphinx (>=7.1.2)", "sphinx-argparse (>=0.4)", "sphinxcontrib-towncrier (>=0.2.1a0)", "towncrier (>=23.6)"] +test = ["covdefaults (>=2.3)", "coverage (>=7.2.7)", "coverage-enable-subprocess (>=1)", "flaky (>=3.7)", "packaging (>=23.1)", "pytest (>=7.4)", "pytest-env (>=0.8.2)", "pytest-freezer (>=0.4.8)", "pytest-mock (>=3.11.1)", "pytest-randomly (>=3.12)", "pytest-timeout (>=2.1)", "setuptools (>=68)", "time-machine (>=2.10)"] [[package]] name = "win32-setctime" @@ -1150,20 +1121,20 @@ tests-strict = ["codecov (==2.0.15)", "pytest (==4.6.0)", "pytest (==4.6.0)", "p [[package]] name = "zipp" -version = "3.15.0" +version = "3.16.2" description = "Backport of pathlib-compatible object wrapper for zip files" -category = "main" +category = "dev" optional = false -python-versions = ">=3.7" +python-versions = ">=3.8" [package.extras] -docs = ["furo", "jaraco.packaging (>=9)", "jaraco.tidelift (>=1.4)", "rst.linker (>=1.9)", "sphinx (>=3.5)", "sphinx-lint"] -testing = ["big-o", "flake8 (<5)", "jaraco.functools", "jaraco.itertools", "more-itertools", "pytest (>=6)", "pytest-black (>=0.3.7)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=1.3)", "pytest-flake8", "pytest-mypy (>=0.9.1)"] +docs = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "rst.linker (>=1.9)", "sphinx (>=3.5)", "sphinx-lint"] +testing = ["big-o", "jaraco.functools", "jaraco.itertools", "more-itertools", "pytest (>=6)", "pytest-black (>=0.3.7)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=2.2)", "pytest-ignore-flaky", "pytest-mypy (>=0.9.1)", "pytest-ruff"] [metadata] lock-version = "1.1" -python-versions = "^3.7" -content-hash = "d4deb64ce8bb7377e45d8a748d7391fd973b58fb8a8b46782970f1580fce9e96" +python-versions = ">=3.8,<4.0" +content-hash = "f8b18e5f2d723b3fa275aa4ab3c48d887c064d22c56f59e2c255166c05de60f7" [metadata.files] alabaster = [ @@ -1201,174 +1172,175 @@ black = [ {file = "black-22.12.0.tar.gz", hash = "sha256:229351e5a18ca30f447bf724d007f890f97e13af070bb6ad4c0a441cd7596a2f"}, ] certifi = [ - {file = "certifi-2023.5.7-py3-none-any.whl", hash = "sha256:c6c2e98f5c7869efca1f8916fed228dd91539f9f1b444c314c06eef02980c716"}, - {file = "certifi-2023.5.7.tar.gz", hash = "sha256:0f0d56dc5a6ad56fd4ba36484d6cc34451e1c6548c61daad8c320169f91eddc7"}, + {file = "certifi-2023.7.22-py3-none-any.whl", hash = "sha256:92d6037539857d8206b8f6ae472e8b77db8058fec5937a1ef3f54304089edbb9"}, + {file = "certifi-2023.7.22.tar.gz", hash = "sha256:539cc1d13202e33ca466e88b2807e29f4c13049d6d87031a3c110744495cb082"}, ] cfgv = [ - {file = "cfgv-3.3.1-py2.py3-none-any.whl", hash = "sha256:c6a0883f3917a037485059700b9e75da2464e6c27051014ad85ba6aaa5884426"}, - {file = "cfgv-3.3.1.tar.gz", hash = "sha256:f5a830efb9ce7a445376bb66ec94c638a9787422f96264c98edc6bdeed8ab736"}, + {file = "cfgv-3.4.0-py2.py3-none-any.whl", hash = "sha256:b7265b1f29fd3316bfcd2b330d63d024f2bfd8bcb8b0272f8e19a504856c48f9"}, + {file = "cfgv-3.4.0.tar.gz", hash = "sha256:e52591d4c5f5dead8e0f673fb16db7949d2cfb3f7da4582893288f0ded8fe560"}, ] charset-normalizer = [ - {file = "charset-normalizer-3.1.0.tar.gz", hash = "sha256:34e0a2f9c370eb95597aae63bf85eb5e96826d81e3dcf88b8886012906f509b5"}, - {file = "charset_normalizer-3.1.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:e0ac8959c929593fee38da1c2b64ee9778733cdf03c482c9ff1d508b6b593b2b"}, - {file = "charset_normalizer-3.1.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:d7fc3fca01da18fbabe4625d64bb612b533533ed10045a2ac3dd194bfa656b60"}, - {file = "charset_normalizer-3.1.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:04eefcee095f58eaabe6dc3cc2262f3bcd776d2c67005880894f447b3f2cb9c1"}, - {file = "charset_normalizer-3.1.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:20064ead0717cf9a73a6d1e779b23d149b53daf971169289ed2ed43a71e8d3b0"}, - {file = "charset_normalizer-3.1.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1435ae15108b1cb6fffbcea2af3d468683b7afed0169ad718451f8db5d1aff6f"}, - {file = "charset_normalizer-3.1.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c84132a54c750fda57729d1e2599bb598f5fa0344085dbde5003ba429a4798c0"}, - {file = "charset_normalizer-3.1.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:75f2568b4189dda1c567339b48cba4ac7384accb9c2a7ed655cd86b04055c795"}, - {file = "charset_normalizer-3.1.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:11d3bcb7be35e7b1bba2c23beedac81ee893ac9871d0ba79effc7fc01167db6c"}, - {file = "charset_normalizer-3.1.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:891cf9b48776b5c61c700b55a598621fdb7b1e301a550365571e9624f270c203"}, - {file = "charset_normalizer-3.1.0-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:5f008525e02908b20e04707a4f704cd286d94718f48bb33edddc7d7b584dddc1"}, - {file = "charset_normalizer-3.1.0-cp310-cp310-musllinux_1_1_ppc64le.whl", hash = "sha256:b06f0d3bf045158d2fb8837c5785fe9ff9b8c93358be64461a1089f5da983137"}, - {file = "charset_normalizer-3.1.0-cp310-cp310-musllinux_1_1_s390x.whl", hash = "sha256:49919f8400b5e49e961f320c735388ee686a62327e773fa5b3ce6721f7e785ce"}, - {file = "charset_normalizer-3.1.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:22908891a380d50738e1f978667536f6c6b526a2064156203d418f4856d6e86a"}, - {file = "charset_normalizer-3.1.0-cp310-cp310-win32.whl", hash = "sha256:12d1a39aa6b8c6f6248bb54550efcc1c38ce0d8096a146638fd4738e42284448"}, - {file = "charset_normalizer-3.1.0-cp310-cp310-win_amd64.whl", hash = "sha256:65ed923f84a6844de5fd29726b888e58c62820e0769b76565480e1fdc3d062f8"}, - {file = "charset_normalizer-3.1.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:9a3267620866c9d17b959a84dd0bd2d45719b817245e49371ead79ed4f710d19"}, - {file = "charset_normalizer-3.1.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:6734e606355834f13445b6adc38b53c0fd45f1a56a9ba06c2058f86893ae8017"}, - {file = "charset_normalizer-3.1.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:f8303414c7b03f794347ad062c0516cee0e15f7a612abd0ce1e25caf6ceb47df"}, - {file = "charset_normalizer-3.1.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:aaf53a6cebad0eae578f062c7d462155eada9c172bd8c4d250b8c1d8eb7f916a"}, - {file = "charset_normalizer-3.1.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3dc5b6a8ecfdc5748a7e429782598e4f17ef378e3e272eeb1340ea57c9109f41"}, - {file = "charset_normalizer-3.1.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e1b25e3ad6c909f398df8921780d6a3d120d8c09466720226fc621605b6f92b1"}, - {file = "charset_normalizer-3.1.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0ca564606d2caafb0abe6d1b5311c2649e8071eb241b2d64e75a0d0065107e62"}, - {file = "charset_normalizer-3.1.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b82fab78e0b1329e183a65260581de4375f619167478dddab510c6c6fb04d9b6"}, - {file = "charset_normalizer-3.1.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:bd7163182133c0c7701b25e604cf1611c0d87712e56e88e7ee5d72deab3e76b5"}, - {file = "charset_normalizer-3.1.0-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:11d117e6c63e8f495412d37e7dc2e2fff09c34b2d09dbe2bee3c6229577818be"}, - {file = "charset_normalizer-3.1.0-cp311-cp311-musllinux_1_1_ppc64le.whl", hash = "sha256:cf6511efa4801b9b38dc5546d7547d5b5c6ef4b081c60b23e4d941d0eba9cbeb"}, - {file = "charset_normalizer-3.1.0-cp311-cp311-musllinux_1_1_s390x.whl", hash = "sha256:abc1185d79f47c0a7aaf7e2412a0eb2c03b724581139193d2d82b3ad8cbb00ac"}, - {file = "charset_normalizer-3.1.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:cb7b2ab0188829593b9de646545175547a70d9a6e2b63bf2cd87a0a391599324"}, - {file = "charset_normalizer-3.1.0-cp311-cp311-win32.whl", hash = "sha256:c36bcbc0d5174a80d6cccf43a0ecaca44e81d25be4b7f90f0ed7bcfbb5a00909"}, - {file = "charset_normalizer-3.1.0-cp311-cp311-win_amd64.whl", hash = "sha256:cca4def576f47a09a943666b8f829606bcb17e2bc2d5911a46c8f8da45f56755"}, - {file = "charset_normalizer-3.1.0-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:0c95f12b74681e9ae127728f7e5409cbbef9cd914d5896ef238cc779b8152373"}, - {file = "charset_normalizer-3.1.0-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fca62a8301b605b954ad2e9c3666f9d97f63872aa4efcae5492baca2056b74ab"}, - {file = "charset_normalizer-3.1.0-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ac0aa6cd53ab9a31d397f8303f92c42f534693528fafbdb997c82bae6e477ad9"}, - {file = "charset_normalizer-3.1.0-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c3af8e0f07399d3176b179f2e2634c3ce9c1301379a6b8c9c9aeecd481da494f"}, - {file = "charset_normalizer-3.1.0-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3a5fc78f9e3f501a1614a98f7c54d3969f3ad9bba8ba3d9b438c3bc5d047dd28"}, - {file = "charset_normalizer-3.1.0-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:628c985afb2c7d27a4800bfb609e03985aaecb42f955049957814e0491d4006d"}, - {file = "charset_normalizer-3.1.0-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:74db0052d985cf37fa111828d0dd230776ac99c740e1a758ad99094be4f1803d"}, - {file = "charset_normalizer-3.1.0-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:1e8fcdd8f672a1c4fc8d0bd3a2b576b152d2a349782d1eb0f6b8e52e9954731d"}, - {file = "charset_normalizer-3.1.0-cp37-cp37m-musllinux_1_1_ppc64le.whl", hash = "sha256:04afa6387e2b282cf78ff3dbce20f0cc071c12dc8f685bd40960cc68644cfea6"}, - {file = "charset_normalizer-3.1.0-cp37-cp37m-musllinux_1_1_s390x.whl", hash = "sha256:dd5653e67b149503c68c4018bf07e42eeed6b4e956b24c00ccdf93ac79cdff84"}, - {file = "charset_normalizer-3.1.0-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:d2686f91611f9e17f4548dbf050e75b079bbc2a82be565832bc8ea9047b61c8c"}, - {file = "charset_normalizer-3.1.0-cp37-cp37m-win32.whl", hash = "sha256:4155b51ae05ed47199dc5b2a4e62abccb274cee6b01da5b895099b61b1982974"}, - {file = "charset_normalizer-3.1.0-cp37-cp37m-win_amd64.whl", hash = "sha256:322102cdf1ab682ecc7d9b1c5eed4ec59657a65e1c146a0da342b78f4112db23"}, - {file = "charset_normalizer-3.1.0-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:e633940f28c1e913615fd624fcdd72fdba807bf53ea6925d6a588e84e1151531"}, - {file = "charset_normalizer-3.1.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:3a06f32c9634a8705f4ca9946d667609f52cf130d5548881401f1eb2c39b1e2c"}, - {file = "charset_normalizer-3.1.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:7381c66e0561c5757ffe616af869b916c8b4e42b367ab29fedc98481d1e74e14"}, - {file = "charset_normalizer-3.1.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3573d376454d956553c356df45bb824262c397c6e26ce43e8203c4c540ee0acb"}, - {file = "charset_normalizer-3.1.0-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e89df2958e5159b811af9ff0f92614dabf4ff617c03a4c1c6ff53bf1c399e0e1"}, - {file = "charset_normalizer-3.1.0-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:78cacd03e79d009d95635e7d6ff12c21eb89b894c354bd2b2ed0b4763373693b"}, - {file = "charset_normalizer-3.1.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:de5695a6f1d8340b12a5d6d4484290ee74d61e467c39ff03b39e30df62cf83a0"}, - {file = "charset_normalizer-3.1.0-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1c60b9c202d00052183c9be85e5eaf18a4ada0a47d188a83c8f5c5b23252f649"}, - {file = "charset_normalizer-3.1.0-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:f645caaf0008bacf349875a974220f1f1da349c5dbe7c4ec93048cdc785a3326"}, - {file = "charset_normalizer-3.1.0-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:ea9f9c6034ea2d93d9147818f17c2a0860d41b71c38b9ce4d55f21b6f9165a11"}, - {file = "charset_normalizer-3.1.0-cp38-cp38-musllinux_1_1_ppc64le.whl", hash = "sha256:80d1543d58bd3d6c271b66abf454d437a438dff01c3e62fdbcd68f2a11310d4b"}, - {file = "charset_normalizer-3.1.0-cp38-cp38-musllinux_1_1_s390x.whl", hash = "sha256:73dc03a6a7e30b7edc5b01b601e53e7fc924b04e1835e8e407c12c037e81adbd"}, - {file = "charset_normalizer-3.1.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:6f5c2e7bc8a4bf7c426599765b1bd33217ec84023033672c1e9a8b35eaeaaaf8"}, - {file = "charset_normalizer-3.1.0-cp38-cp38-win32.whl", hash = "sha256:12a2b561af122e3d94cdb97fe6fb2bb2b82cef0cdca131646fdb940a1eda04f0"}, - {file = "charset_normalizer-3.1.0-cp38-cp38-win_amd64.whl", hash = "sha256:3160a0fd9754aab7d47f95a6b63ab355388d890163eb03b2d2b87ab0a30cfa59"}, - {file = "charset_normalizer-3.1.0-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:38e812a197bf8e71a59fe55b757a84c1f946d0ac114acafaafaf21667a7e169e"}, - {file = "charset_normalizer-3.1.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:6baf0baf0d5d265fa7944feb9f7451cc316bfe30e8df1a61b1bb08577c554f31"}, - {file = "charset_normalizer-3.1.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:8f25e17ab3039b05f762b0a55ae0b3632b2e073d9c8fc88e89aca31a6198e88f"}, - {file = "charset_normalizer-3.1.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3747443b6a904001473370d7810aa19c3a180ccd52a7157aacc264a5ac79265e"}, - {file = "charset_normalizer-3.1.0-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b116502087ce8a6b7a5f1814568ccbd0e9f6cfd99948aa59b0e241dc57cf739f"}, - {file = "charset_normalizer-3.1.0-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d16fd5252f883eb074ca55cb622bc0bee49b979ae4e8639fff6ca3ff44f9f854"}, - {file = "charset_normalizer-3.1.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:21fa558996782fc226b529fdd2ed7866c2c6ec91cee82735c98a197fae39f706"}, - {file = "charset_normalizer-3.1.0-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6f6c7a8a57e9405cad7485f4c9d3172ae486cfef1344b5ddd8e5239582d7355e"}, - {file = "charset_normalizer-3.1.0-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:ac3775e3311661d4adace3697a52ac0bab17edd166087d493b52d4f4f553f9f0"}, - {file = "charset_normalizer-3.1.0-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:10c93628d7497c81686e8e5e557aafa78f230cd9e77dd0c40032ef90c18f2230"}, - {file = "charset_normalizer-3.1.0-cp39-cp39-musllinux_1_1_ppc64le.whl", hash = "sha256:6f4f4668e1831850ebcc2fd0b1cd11721947b6dc7c00bf1c6bd3c929ae14f2c7"}, - {file = "charset_normalizer-3.1.0-cp39-cp39-musllinux_1_1_s390x.whl", hash = "sha256:0be65ccf618c1e7ac9b849c315cc2e8a8751d9cfdaa43027d4f6624bd587ab7e"}, - {file = "charset_normalizer-3.1.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:53d0a3fa5f8af98a1e261de6a3943ca631c526635eb5817a87a59d9a57ebf48f"}, - {file = "charset_normalizer-3.1.0-cp39-cp39-win32.whl", hash = "sha256:a04f86f41a8916fe45ac5024ec477f41f886b3c435da2d4e3d2709b22ab02af1"}, - {file = "charset_normalizer-3.1.0-cp39-cp39-win_amd64.whl", hash = "sha256:830d2948a5ec37c386d3170c483063798d7879037492540f10a475e3fd6f244b"}, - {file = "charset_normalizer-3.1.0-py3-none-any.whl", hash = "sha256:3d9098b479e78c85080c98e1e35ff40b4a31d8953102bb0fd7d1b6f8a2111a3d"}, + {file = "charset-normalizer-3.2.0.tar.gz", hash = "sha256:3bb3d25a8e6c0aedd251753a79ae98a093c7e7b471faa3aa9a93a81431987ace"}, + {file = "charset_normalizer-3.2.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:0b87549028f680ca955556e3bd57013ab47474c3124dc069faa0b6545b6c9710"}, + {file = "charset_normalizer-3.2.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:7c70087bfee18a42b4040bb9ec1ca15a08242cf5867c58726530bdf3945672ed"}, + {file = "charset_normalizer-3.2.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:a103b3a7069b62f5d4890ae1b8f0597618f628b286b03d4bc9195230b154bfa9"}, + {file = "charset_normalizer-3.2.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:94aea8eff76ee6d1cdacb07dd2123a68283cb5569e0250feab1240058f53b623"}, + {file = "charset_normalizer-3.2.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:db901e2ac34c931d73054d9797383d0f8009991e723dab15109740a63e7f902a"}, + {file = "charset_normalizer-3.2.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b0dac0ff919ba34d4df1b6131f59ce95b08b9065233446be7e459f95554c0dc8"}, + {file = "charset_normalizer-3.2.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:193cbc708ea3aca45e7221ae58f0fd63f933753a9bfb498a3b474878f12caaad"}, + {file = "charset_normalizer-3.2.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:09393e1b2a9461950b1c9a45d5fd251dc7c6f228acab64da1c9c0165d9c7765c"}, + {file = "charset_normalizer-3.2.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:baacc6aee0b2ef6f3d308e197b5d7a81c0e70b06beae1f1fcacffdbd124fe0e3"}, + {file = "charset_normalizer-3.2.0-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:bf420121d4c8dce6b889f0e8e4ec0ca34b7f40186203f06a946fa0276ba54029"}, + {file = "charset_normalizer-3.2.0-cp310-cp310-musllinux_1_1_ppc64le.whl", hash = "sha256:c04a46716adde8d927adb9457bbe39cf473e1e2c2f5d0a16ceb837e5d841ad4f"}, + {file = "charset_normalizer-3.2.0-cp310-cp310-musllinux_1_1_s390x.whl", hash = "sha256:aaf63899c94de41fe3cf934601b0f7ccb6b428c6e4eeb80da72c58eab077b19a"}, + {file = "charset_normalizer-3.2.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:d62e51710986674142526ab9f78663ca2b0726066ae26b78b22e0f5e571238dd"}, + {file = "charset_normalizer-3.2.0-cp310-cp310-win32.whl", hash = "sha256:04e57ab9fbf9607b77f7d057974694b4f6b142da9ed4a199859d9d4d5c63fe96"}, + {file = "charset_normalizer-3.2.0-cp310-cp310-win_amd64.whl", hash = "sha256:48021783bdf96e3d6de03a6e39a1171ed5bd7e8bb93fc84cc649d11490f87cea"}, + {file = "charset_normalizer-3.2.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:4957669ef390f0e6719db3613ab3a7631e68424604a7b448f079bee145da6e09"}, + {file = "charset_normalizer-3.2.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:46fb8c61d794b78ec7134a715a3e564aafc8f6b5e338417cb19fe9f57a5a9bf2"}, + {file = "charset_normalizer-3.2.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:f779d3ad205f108d14e99bb3859aa7dd8e9c68874617c72354d7ecaec2a054ac"}, + {file = "charset_normalizer-3.2.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f25c229a6ba38a35ae6e25ca1264621cc25d4d38dca2942a7fce0b67a4efe918"}, + {file = "charset_normalizer-3.2.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:2efb1bd13885392adfda4614c33d3b68dee4921fd0ac1d3988f8cbb7d589e72a"}, + {file = "charset_normalizer-3.2.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:1f30b48dd7fa1474554b0b0f3fdfdd4c13b5c737a3c6284d3cdc424ec0ffff3a"}, + {file = "charset_normalizer-3.2.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:246de67b99b6851627d945db38147d1b209a899311b1305dd84916f2b88526c6"}, + {file = "charset_normalizer-3.2.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:9bd9b3b31adcb054116447ea22caa61a285d92e94d710aa5ec97992ff5eb7cf3"}, + {file = "charset_normalizer-3.2.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:8c2f5e83493748286002f9369f3e6607c565a6a90425a3a1fef5ae32a36d749d"}, + {file = "charset_normalizer-3.2.0-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:3170c9399da12c9dc66366e9d14da8bf7147e1e9d9ea566067bbce7bb74bd9c2"}, + {file = "charset_normalizer-3.2.0-cp311-cp311-musllinux_1_1_ppc64le.whl", hash = "sha256:7a4826ad2bd6b07ca615c74ab91f32f6c96d08f6fcc3902ceeedaec8cdc3bcd6"}, + {file = "charset_normalizer-3.2.0-cp311-cp311-musllinux_1_1_s390x.whl", hash = "sha256:3b1613dd5aee995ec6d4c69f00378bbd07614702a315a2cf6c1d21461fe17c23"}, + {file = "charset_normalizer-3.2.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:9e608aafdb55eb9f255034709e20d5a83b6d60c054df0802fa9c9883d0a937aa"}, + {file = "charset_normalizer-3.2.0-cp311-cp311-win32.whl", hash = "sha256:f2a1d0fd4242bd8643ce6f98927cf9c04540af6efa92323e9d3124f57727bfc1"}, + {file = "charset_normalizer-3.2.0-cp311-cp311-win_amd64.whl", hash = "sha256:681eb3d7e02e3c3655d1b16059fbfb605ac464c834a0c629048a30fad2b27489"}, + {file = "charset_normalizer-3.2.0-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:c57921cda3a80d0f2b8aec7e25c8aa14479ea92b5b51b6876d975d925a2ea346"}, + {file = "charset_normalizer-3.2.0-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:41b25eaa7d15909cf3ac4c96088c1f266a9a93ec44f87f1d13d4a0e86c81b982"}, + {file = "charset_normalizer-3.2.0-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f058f6963fd82eb143c692cecdc89e075fa0828db2e5b291070485390b2f1c9c"}, + {file = "charset_normalizer-3.2.0-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a7647ebdfb9682b7bb97e2a5e7cb6ae735b1c25008a70b906aecca294ee96cf4"}, + {file = "charset_normalizer-3.2.0-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eef9df1eefada2c09a5e7a40991b9fc6ac6ef20b1372abd48d2794a316dc0449"}, + {file = "charset_normalizer-3.2.0-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e03b8895a6990c9ab2cdcd0f2fe44088ca1c65ae592b8f795c3294af00a461c3"}, + {file = "charset_normalizer-3.2.0-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:ee4006268ed33370957f55bf2e6f4d263eaf4dc3cfc473d1d90baff6ed36ce4a"}, + {file = "charset_normalizer-3.2.0-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:c4983bf937209c57240cff65906b18bb35e64ae872da6a0db937d7b4af845dd7"}, + {file = "charset_normalizer-3.2.0-cp37-cp37m-musllinux_1_1_ppc64le.whl", hash = "sha256:3bb7fda7260735efe66d5107fb7e6af6a7c04c7fce9b2514e04b7a74b06bf5dd"}, + {file = "charset_normalizer-3.2.0-cp37-cp37m-musllinux_1_1_s390x.whl", hash = "sha256:72814c01533f51d68702802d74f77ea026b5ec52793c791e2da806a3844a46c3"}, + {file = "charset_normalizer-3.2.0-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:70c610f6cbe4b9fce272c407dd9d07e33e6bf7b4aa1b7ffb6f6ded8e634e3592"}, + {file = "charset_normalizer-3.2.0-cp37-cp37m-win32.whl", hash = "sha256:a401b4598e5d3f4a9a811f3daf42ee2291790c7f9d74b18d75d6e21dda98a1a1"}, + {file = "charset_normalizer-3.2.0-cp37-cp37m-win_amd64.whl", hash = "sha256:c0b21078a4b56965e2b12f247467b234734491897e99c1d51cee628da9786959"}, + {file = "charset_normalizer-3.2.0-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:95eb302ff792e12aba9a8b8f8474ab229a83c103d74a750ec0bd1c1eea32e669"}, + {file = "charset_normalizer-3.2.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:1a100c6d595a7f316f1b6f01d20815d916e75ff98c27a01ae817439ea7726329"}, + {file = "charset_normalizer-3.2.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:6339d047dab2780cc6220f46306628e04d9750f02f983ddb37439ca47ced7149"}, + {file = "charset_normalizer-3.2.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e4b749b9cc6ee664a3300bb3a273c1ca8068c46be705b6c31cf5d276f8628a94"}, + {file = "charset_normalizer-3.2.0-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a38856a971c602f98472050165cea2cdc97709240373041b69030be15047691f"}, + {file = "charset_normalizer-3.2.0-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f87f746ee241d30d6ed93969de31e5ffd09a2961a051e60ae6bddde9ec3583aa"}, + {file = "charset_normalizer-3.2.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:89f1b185a01fe560bc8ae5f619e924407efca2191b56ce749ec84982fc59a32a"}, + {file = "charset_normalizer-3.2.0-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e1c8a2f4c69e08e89632defbfabec2feb8a8d99edc9f89ce33c4b9e36ab63037"}, + {file = "charset_normalizer-3.2.0-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:2f4ac36d8e2b4cc1aa71df3dd84ff8efbe3bfb97ac41242fbcfc053c67434f46"}, + {file = "charset_normalizer-3.2.0-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:a386ebe437176aab38c041de1260cd3ea459c6ce5263594399880bbc398225b2"}, + {file = "charset_normalizer-3.2.0-cp38-cp38-musllinux_1_1_ppc64le.whl", hash = "sha256:ccd16eb18a849fd8dcb23e23380e2f0a354e8daa0c984b8a732d9cfaba3a776d"}, + {file = "charset_normalizer-3.2.0-cp38-cp38-musllinux_1_1_s390x.whl", hash = "sha256:e6a5bf2cba5ae1bb80b154ed68a3cfa2fa00fde979a7f50d6598d3e17d9ac20c"}, + {file = "charset_normalizer-3.2.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:45de3f87179c1823e6d9e32156fb14c1927fcc9aba21433f088fdfb555b77c10"}, + {file = "charset_normalizer-3.2.0-cp38-cp38-win32.whl", hash = "sha256:1000fba1057b92a65daec275aec30586c3de2401ccdcd41f8a5c1e2c87078706"}, + {file = "charset_normalizer-3.2.0-cp38-cp38-win_amd64.whl", hash = "sha256:8b2c760cfc7042b27ebdb4a43a4453bd829a5742503599144d54a032c5dc7e9e"}, + {file = "charset_normalizer-3.2.0-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:855eafa5d5a2034b4621c74925d89c5efef61418570e5ef9b37717d9c796419c"}, + {file = "charset_normalizer-3.2.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:203f0c8871d5a7987be20c72442488a0b8cfd0f43b7973771640fc593f56321f"}, + {file = "charset_normalizer-3.2.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:e857a2232ba53ae940d3456f7533ce6ca98b81917d47adc3c7fd55dad8fab858"}, + {file = "charset_normalizer-3.2.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5e86d77b090dbddbe78867a0275cb4df08ea195e660f1f7f13435a4649e954e5"}, + {file = "charset_normalizer-3.2.0-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c4fb39a81950ec280984b3a44f5bd12819953dc5fa3a7e6fa7a80db5ee853952"}, + {file = "charset_normalizer-3.2.0-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2dee8e57f052ef5353cf608e0b4c871aee320dd1b87d351c28764fc0ca55f9f4"}, + {file = "charset_normalizer-3.2.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8700f06d0ce6f128de3ccdbc1acaea1ee264d2caa9ca05daaf492fde7c2a7200"}, + {file = "charset_normalizer-3.2.0-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1920d4ff15ce893210c1f0c0e9d19bfbecb7983c76b33f046c13a8ffbd570252"}, + {file = "charset_normalizer-3.2.0-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:c1c76a1743432b4b60ab3358c937a3fe1341c828ae6194108a94c69028247f22"}, + {file = "charset_normalizer-3.2.0-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:f7560358a6811e52e9c4d142d497f1a6e10103d3a6881f18d04dbce3729c0e2c"}, + {file = "charset_normalizer-3.2.0-cp39-cp39-musllinux_1_1_ppc64le.whl", hash = "sha256:c8063cf17b19661471ecbdb3df1c84f24ad2e389e326ccaf89e3fb2484d8dd7e"}, + {file = "charset_normalizer-3.2.0-cp39-cp39-musllinux_1_1_s390x.whl", hash = "sha256:cd6dbe0238f7743d0efe563ab46294f54f9bc8f4b9bcf57c3c666cc5bc9d1299"}, + {file = "charset_normalizer-3.2.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:1249cbbf3d3b04902ff081ffbb33ce3377fa6e4c7356f759f3cd076cc138d020"}, + {file = "charset_normalizer-3.2.0-cp39-cp39-win32.whl", hash = "sha256:6c409c0deba34f147f77efaa67b8e4bb83d2f11c8806405f76397ae5b8c0d1c9"}, + {file = "charset_normalizer-3.2.0-cp39-cp39-win_amd64.whl", hash = "sha256:7095f6fbfaa55defb6b733cfeb14efaae7a29f0b59d8cf213be4e7ca0b857b80"}, + {file = "charset_normalizer-3.2.0-py3-none-any.whl", hash = "sha256:8e098148dd37b4ce3baca71fb394c81dc5d9c7728c95df695d2dca218edf40e6"}, ] click = [ - {file = "click-8.1.3-py3-none-any.whl", hash = "sha256:bb4d8133cb15a609f44e8213d9b391b0809795062913b383c62be0ee95b1db48"}, - {file = "click-8.1.3.tar.gz", hash = "sha256:7682dc8afb30297001674575ea00d1814d808d6a36af415a82bd481d37ba7b8e"}, + {file = "click-8.1.7-py3-none-any.whl", hash = "sha256:ae74fb96c20a0277a1d615f1e4d73c8414f5a98db8b799a7931d1582f3390c28"}, + {file = "click-8.1.7.tar.gz", hash = "sha256:ca9853ad459e787e2192211578cc907e7594e294c7ccc834310722b41b9ca6de"}, ] colorama = [ {file = "colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6"}, {file = "colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44"}, ] coverage = [ - {file = "coverage-7.2.5-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:883123d0bbe1c136f76b56276074b0c79b5817dd4238097ffa64ac67257f4b6c"}, - {file = "coverage-7.2.5-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:d2fbc2a127e857d2f8898aaabcc34c37771bf78a4d5e17d3e1f5c30cd0cbc62a"}, - {file = "coverage-7.2.5-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5f3671662dc4b422b15776cdca89c041a6349b4864a43aa2350b6b0b03bbcc7f"}, - {file = "coverage-7.2.5-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:780551e47d62095e088f251f5db428473c26db7829884323e56d9c0c3118791a"}, - {file = "coverage-7.2.5-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:066b44897c493e0dcbc9e6a6d9f8bbb6607ef82367cf6810d387c09f0cd4fe9a"}, - {file = "coverage-7.2.5-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:b9a4ee55174b04f6af539218f9f8083140f61a46eabcaa4234f3c2a452c4ed11"}, - {file = "coverage-7.2.5-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:706ec567267c96717ab9363904d846ec009a48d5f832140b6ad08aad3791b1f5"}, - {file = "coverage-7.2.5-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:ae453f655640157d76209f42c62c64c4d4f2c7f97256d3567e3b439bd5c9b06c"}, - {file = "coverage-7.2.5-cp310-cp310-win32.whl", hash = "sha256:f81c9b4bd8aa747d417407a7f6f0b1469a43b36a85748145e144ac4e8d303cb5"}, - {file = "coverage-7.2.5-cp310-cp310-win_amd64.whl", hash = "sha256:dc945064a8783b86fcce9a0a705abd7db2117d95e340df8a4333f00be5efb64c"}, - {file = "coverage-7.2.5-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:40cc0f91c6cde033da493227797be2826cbf8f388eaa36a0271a97a332bfd7ce"}, - {file = "coverage-7.2.5-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:a66e055254a26c82aead7ff420d9fa8dc2da10c82679ea850d8feebf11074d88"}, - {file = "coverage-7.2.5-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c10fbc8a64aa0f3ed136b0b086b6b577bc64d67d5581acd7cc129af52654384e"}, - {file = "coverage-7.2.5-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:9a22cbb5ede6fade0482111fa7f01115ff04039795d7092ed0db43522431b4f2"}, - {file = "coverage-7.2.5-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:292300f76440651529b8ceec283a9370532f4ecba9ad67d120617021bb5ef139"}, - {file = "coverage-7.2.5-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:7ff8f3fb38233035028dbc93715551d81eadc110199e14bbbfa01c5c4a43f8d8"}, - {file = "coverage-7.2.5-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:a08c7401d0b24e8c2982f4e307124b671c6736d40d1c39e09d7a8687bddf83ed"}, - {file = "coverage-7.2.5-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:ef9659d1cda9ce9ac9585c045aaa1e59223b143f2407db0eaee0b61a4f266fb6"}, - {file = "coverage-7.2.5-cp311-cp311-win32.whl", hash = "sha256:30dcaf05adfa69c2a7b9f7dfd9f60bc8e36b282d7ed25c308ef9e114de7fc23b"}, - {file = "coverage-7.2.5-cp311-cp311-win_amd64.whl", hash = "sha256:97072cc90f1009386c8a5b7de9d4fc1a9f91ba5ef2146c55c1f005e7b5c5e068"}, - {file = "coverage-7.2.5-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:bebea5f5ed41f618797ce3ffb4606c64a5de92e9c3f26d26c2e0aae292f015c1"}, - {file = "coverage-7.2.5-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:828189fcdda99aae0d6bf718ea766b2e715eabc1868670a0a07bf8404bf58c33"}, - {file = "coverage-7.2.5-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6e8a95f243d01ba572341c52f89f3acb98a3b6d1d5d830efba86033dd3687ade"}, - {file = "coverage-7.2.5-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e8834e5f17d89e05697c3c043d3e58a8b19682bf365048837383abfe39adaed5"}, - {file = "coverage-7.2.5-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:d1f25ee9de21a39b3a8516f2c5feb8de248f17da7eead089c2e04aa097936b47"}, - {file = "coverage-7.2.5-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:1637253b11a18f453e34013c665d8bf15904c9e3c44fbda34c643fbdc9d452cd"}, - {file = "coverage-7.2.5-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:8e575a59315a91ccd00c7757127f6b2488c2f914096077c745c2f1ba5b8c0969"}, - {file = "coverage-7.2.5-cp37-cp37m-win32.whl", hash = "sha256:509ecd8334c380000d259dc66feb191dd0a93b21f2453faa75f7f9cdcefc0718"}, - {file = "coverage-7.2.5-cp37-cp37m-win_amd64.whl", hash = "sha256:12580845917b1e59f8a1c2ffa6af6d0908cb39220f3019e36c110c943dc875b0"}, - {file = "coverage-7.2.5-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:b5016e331b75310610c2cf955d9f58a9749943ed5f7b8cfc0bb89c6134ab0a84"}, - {file = "coverage-7.2.5-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:373ea34dca98f2fdb3e5cb33d83b6d801007a8074f992b80311fc589d3e6b790"}, - {file = "coverage-7.2.5-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a063aad9f7b4c9f9da7b2550eae0a582ffc7623dca1c925e50c3fbde7a579771"}, - {file = "coverage-7.2.5-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:38c0a497a000d50491055805313ed83ddba069353d102ece8aef5d11b5faf045"}, - {file = "coverage-7.2.5-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a2b3b05e22a77bb0ae1a3125126a4e08535961c946b62f30985535ed40e26614"}, - {file = "coverage-7.2.5-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:0342a28617e63ad15d96dca0f7ae9479a37b7d8a295f749c14f3436ea59fdcb3"}, - {file = "coverage-7.2.5-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:cf97ed82ca986e5c637ea286ba2793c85325b30f869bf64d3009ccc1a31ae3fd"}, - {file = "coverage-7.2.5-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:c2c41c1b1866b670573657d584de413df701f482574bad7e28214a2362cb1fd1"}, - {file = "coverage-7.2.5-cp38-cp38-win32.whl", hash = "sha256:10b15394c13544fce02382360cab54e51a9e0fd1bd61ae9ce012c0d1e103c813"}, - {file = "coverage-7.2.5-cp38-cp38-win_amd64.whl", hash = "sha256:a0b273fe6dc655b110e8dc89b8ec7f1a778d78c9fd9b4bda7c384c8906072212"}, - {file = "coverage-7.2.5-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:5c587f52c81211d4530fa6857884d37f514bcf9453bdeee0ff93eaaf906a5c1b"}, - {file = "coverage-7.2.5-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:4436cc9ba5414c2c998eaedee5343f49c02ca93b21769c5fdfa4f9d799e84200"}, - {file = "coverage-7.2.5-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6599bf92f33ab041e36e06d25890afbdf12078aacfe1f1d08c713906e49a3fe5"}, - {file = "coverage-7.2.5-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:857abe2fa6a4973f8663e039ead8d22215d31db613ace76e4a98f52ec919068e"}, - {file = "coverage-7.2.5-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f6f5cab2d7f0c12f8187a376cc6582c477d2df91d63f75341307fcdcb5d60303"}, - {file = "coverage-7.2.5-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:aa387bd7489f3e1787ff82068b295bcaafbf6f79c3dad3cbc82ef88ce3f48ad3"}, - {file = "coverage-7.2.5-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:156192e5fd3dbbcb11cd777cc469cf010a294f4c736a2b2c891c77618cb1379a"}, - {file = "coverage-7.2.5-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:bd3b4b8175c1db502adf209d06136c000df4d245105c8839e9d0be71c94aefe1"}, - {file = "coverage-7.2.5-cp39-cp39-win32.whl", hash = "sha256:ddc5a54edb653e9e215f75de377354e2455376f416c4378e1d43b08ec50acc31"}, - {file = "coverage-7.2.5-cp39-cp39-win_amd64.whl", hash = "sha256:338aa9d9883aaaad53695cb14ccdeb36d4060485bb9388446330bef9c361c252"}, - {file = "coverage-7.2.5-pp37.pp38.pp39-none-any.whl", hash = "sha256:8877d9b437b35a85c18e3c6499b23674684bf690f5d96c1006a1ef61f9fdf0f3"}, - {file = "coverage-7.2.5.tar.gz", hash = "sha256:f99ef080288f09ffc687423b8d60978cf3a465d3f404a18d1a05474bd8575a47"}, + {file = "coverage-7.3.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:db76a1bcb51f02b2007adacbed4c88b6dee75342c37b05d1822815eed19edee5"}, + {file = "coverage-7.3.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:c02cfa6c36144ab334d556989406837336c1d05215a9bdf44c0bc1d1ac1cb637"}, + {file = "coverage-7.3.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:477c9430ad5d1b80b07f3c12f7120eef40bfbf849e9e7859e53b9c93b922d2af"}, + {file = "coverage-7.3.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ce2ee86ca75f9f96072295c5ebb4ef2a43cecf2870b0ca5e7a1cbdd929cf67e1"}, + {file = "coverage-7.3.0-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:68d8a0426b49c053013e631c0cdc09b952d857efa8f68121746b339912d27a12"}, + {file = "coverage-7.3.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:b3eb0c93e2ea6445b2173da48cb548364f8f65bf68f3d090404080d338e3a689"}, + {file = "coverage-7.3.0-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:90b6e2f0f66750c5a1178ffa9370dec6c508a8ca5265c42fbad3ccac210a7977"}, + {file = "coverage-7.3.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:96d7d761aea65b291a98c84e1250cd57b5b51726821a6f2f8df65db89363be51"}, + {file = "coverage-7.3.0-cp310-cp310-win32.whl", hash = "sha256:63c5b8ecbc3b3d5eb3a9d873dec60afc0cd5ff9d9f1c75981d8c31cfe4df8527"}, + {file = "coverage-7.3.0-cp310-cp310-win_amd64.whl", hash = "sha256:97c44f4ee13bce914272589b6b41165bbb650e48fdb7bd5493a38bde8de730a1"}, + {file = "coverage-7.3.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:74c160285f2dfe0acf0f72d425f3e970b21b6de04157fc65adc9fd07ee44177f"}, + {file = "coverage-7.3.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:b543302a3707245d454fc49b8ecd2c2d5982b50eb63f3535244fd79a4be0c99d"}, + {file = "coverage-7.3.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ad0f87826c4ebd3ef484502e79b39614e9c03a5d1510cfb623f4a4a051edc6fd"}, + {file = "coverage-7.3.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:13c6cbbd5f31211d8fdb477f0f7b03438591bdd077054076eec362cf2207b4a7"}, + {file = "coverage-7.3.0-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fac440c43e9b479d1241fe9d768645e7ccec3fb65dc3a5f6e90675e75c3f3e3a"}, + {file = "coverage-7.3.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:3c9834d5e3df9d2aba0275c9f67989c590e05732439b3318fa37a725dff51e74"}, + {file = "coverage-7.3.0-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:4c8e31cf29b60859876474034a83f59a14381af50cbe8a9dbaadbf70adc4b214"}, + {file = "coverage-7.3.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:7a9baf8e230f9621f8e1d00c580394a0aa328fdac0df2b3f8384387c44083c0f"}, + {file = "coverage-7.3.0-cp311-cp311-win32.whl", hash = "sha256:ccc51713b5581e12f93ccb9c5e39e8b5d4b16776d584c0f5e9e4e63381356482"}, + {file = "coverage-7.3.0-cp311-cp311-win_amd64.whl", hash = "sha256:887665f00ea4e488501ba755a0e3c2cfd6278e846ada3185f42d391ef95e7e70"}, + {file = "coverage-7.3.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:d000a739f9feed900381605a12a61f7aaced6beae832719ae0d15058a1e81c1b"}, + {file = "coverage-7.3.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:59777652e245bb1e300e620ce2bef0d341945842e4eb888c23a7f1d9e143c446"}, + {file = "coverage-7.3.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c9737bc49a9255d78da085fa04f628a310c2332b187cd49b958b0e494c125071"}, + {file = "coverage-7.3.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:5247bab12f84a1d608213b96b8af0cbb30d090d705b6663ad794c2f2a5e5b9fe"}, + {file = "coverage-7.3.0-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e2ac9a1de294773b9fa77447ab7e529cf4fe3910f6a0832816e5f3d538cfea9a"}, + {file = "coverage-7.3.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:85b7335c22455ec12444cec0d600533a238d6439d8d709d545158c1208483873"}, + {file = "coverage-7.3.0-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:36ce5d43a072a036f287029a55b5c6a0e9bd73db58961a273b6dc11a2c6eb9c2"}, + {file = "coverage-7.3.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:211a4576e984f96d9fce61766ffaed0115d5dab1419e4f63d6992b480c2bd60b"}, + {file = "coverage-7.3.0-cp312-cp312-win32.whl", hash = "sha256:56afbf41fa4a7b27f6635bc4289050ac3ab7951b8a821bca46f5b024500e6321"}, + {file = "coverage-7.3.0-cp312-cp312-win_amd64.whl", hash = "sha256:7f297e0c1ae55300ff688568b04ff26b01c13dfbf4c9d2b7d0cb688ac60df479"}, + {file = "coverage-7.3.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:ac0dec90e7de0087d3d95fa0533e1d2d722dcc008bc7b60e1143402a04c117c1"}, + {file = "coverage-7.3.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:438856d3f8f1e27f8e79b5410ae56650732a0dcfa94e756df88c7e2d24851fcd"}, + {file = "coverage-7.3.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1084393c6bda8875c05e04fce5cfe1301a425f758eb012f010eab586f1f3905e"}, + {file = "coverage-7.3.0-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:49ab200acf891e3dde19e5aa4b0f35d12d8b4bd805dc0be8792270c71bd56c54"}, + {file = "coverage-7.3.0-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a67e6bbe756ed458646e1ef2b0778591ed4d1fcd4b146fc3ba2feb1a7afd4254"}, + {file = "coverage-7.3.0-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:8f39c49faf5344af36042b293ce05c0d9004270d811c7080610b3e713251c9b0"}, + {file = "coverage-7.3.0-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:7df91fb24c2edaabec4e0eee512ff3bc6ec20eb8dccac2e77001c1fe516c0c84"}, + {file = "coverage-7.3.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:34f9f0763d5fa3035a315b69b428fe9c34d4fc2f615262d6be3d3bf3882fb985"}, + {file = "coverage-7.3.0-cp38-cp38-win32.whl", hash = "sha256:bac329371d4c0d456e8d5f38a9b0816b446581b5f278474e416ea0c68c47dcd9"}, + {file = "coverage-7.3.0-cp38-cp38-win_amd64.whl", hash = "sha256:b859128a093f135b556b4765658d5d2e758e1fae3e7cc2f8c10f26fe7005e543"}, + {file = "coverage-7.3.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:fc0ed8d310afe013db1eedd37176d0839dc66c96bcfcce8f6607a73ffea2d6ba"}, + {file = "coverage-7.3.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:e61260ec93f99f2c2d93d264b564ba912bec502f679793c56f678ba5251f0393"}, + {file = "coverage-7.3.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:97af9554a799bd7c58c0179cc8dbf14aa7ab50e1fd5fa73f90b9b7215874ba28"}, + {file = "coverage-7.3.0-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3558e5b574d62f9c46b76120a5c7c16c4612dc2644c3d48a9f4064a705eaee95"}, + {file = "coverage-7.3.0-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:37d5576d35fcb765fca05654f66aa71e2808d4237d026e64ac8b397ffa66a56a"}, + {file = "coverage-7.3.0-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:07ea61bcb179f8f05ffd804d2732b09d23a1238642bf7e51dad62082b5019b34"}, + {file = "coverage-7.3.0-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:80501d1b2270d7e8daf1b64b895745c3e234289e00d5f0e30923e706f110334e"}, + {file = "coverage-7.3.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:4eddd3153d02204f22aef0825409091a91bf2a20bce06fe0f638f5c19a85de54"}, + {file = "coverage-7.3.0-cp39-cp39-win32.whl", hash = "sha256:2d22172f938455c156e9af2612650f26cceea47dc86ca048fa4e0b2d21646ad3"}, + {file = "coverage-7.3.0-cp39-cp39-win_amd64.whl", hash = "sha256:60f64e2007c9144375dd0f480a54d6070f00bb1a28f65c408370544091c9bc9e"}, + {file = "coverage-7.3.0-pp38.pp39.pp310-none-any.whl", hash = "sha256:5492a6ce3bdb15c6ad66cb68a0244854d9917478877a25671d70378bdc8562d0"}, + {file = "coverage-7.3.0.tar.gz", hash = "sha256:49dbb19cdcafc130f597d9e04a29d0a032ceedf729e41b181f51cd170e6ee865"}, ] darglint = [ {file = "darglint-1.8.1-py3-none-any.whl", hash = "sha256:5ae11c259c17b0701618a20c3da343a3eb98b3bc4b5a83d31cdd94f5ebdced8d"}, {file = "darglint-1.8.1.tar.gz", hash = "sha256:080d5106df149b199822e7ee7deb9c012b49891538f14a11be681044f0bb20da"}, ] distlib = [ - {file = "distlib-0.3.6-py2.py3-none-any.whl", hash = "sha256:f35c4b692542ca110de7ef0bea44d73981caeb34ca0b9b6b2e6d7790dda8f80e"}, - {file = "distlib-0.3.6.tar.gz", hash = "sha256:14bad2d9b04d3a36127ac97f30b12a19268f211063d8f8ee4f47108896e11b46"}, + {file = "distlib-0.3.7-py2.py3-none-any.whl", hash = "sha256:2e24928bc811348f0feb63014e97aaae3037f2cf48712d51ae61df7fd6075057"}, + {file = "distlib-0.3.7.tar.gz", hash = "sha256:9dafe54b34a028eafd95039d5e5d4851a13734540f1331060d31c9916e7147a8"}, ] docutils = [ - {file = "docutils-0.17.1-py2.py3-none-any.whl", hash = "sha256:cf316c8370a737a022b72b56874f6602acf974a37a9fba42ec2876387549fc61"}, - {file = "docutils-0.17.1.tar.gz", hash = "sha256:686577d2e4c32380bb50cbb22f575ed742d58168cee37e99117a854bcd88f125"}, + {file = "docutils-0.20.1-py3-none-any.whl", hash = "sha256:96f387a2c5562db4476f09f13bbab2192e764cac08ebbf3a34a95d9b1e4a59d6"}, + {file = "docutils-0.20.1.tar.gz", hash = "sha256:f08a4e276c3a1583a86dce3e34aba3fe04d02bba2dd51ed16106244e8a923e3b"}, ] dparse = [ - {file = "dparse-0.6.2-py3-none-any.whl", hash = "sha256:8097076f1dd26c377f30d4745e6ec18fef42f3bf493933b842ac5bafad8c345f"}, - {file = "dparse-0.6.2.tar.gz", hash = "sha256:d45255bda21f998bc7ddf2afd5e62505ba6134756ba2d42a84c56b0826614dfe"}, + {file = "dparse-0.6.3-py3-none-any.whl", hash = "sha256:0d8fe18714056ca632d98b24fbfc4e9791d4e47065285ab486182288813a5318"}, + {file = "dparse-0.6.3.tar.gz", hash = "sha256:27bb8b4bcaefec3997697ba3f6e06b2447200ba273c0b085c3d012a04571b528"}, ] exceptiongroup = [ - {file = "exceptiongroup-1.1.1-py3-none-any.whl", hash = "sha256:232c37c63e4f682982c8b6459f33a8981039e5fb8756b2074364e5055c498c9e"}, - {file = "exceptiongroup-1.1.1.tar.gz", hash = "sha256:d484c3090ba2889ae2928419117447a14daf3c1231d5e30d0aae34f354f01785"}, + {file = "exceptiongroup-1.1.3-py3-none-any.whl", hash = "sha256:343280667a4585d195ca1cf9cef84a4e178c4b6cf2274caef9859782b567d5e3"}, + {file = "exceptiongroup-1.1.3.tar.gz", hash = "sha256:097acd85d473d75af5bb98e41b61ff7fe35efe6675e4f9370ec6ec5126d160e9"}, ] filelock = [ - {file = "filelock-3.12.0-py3-none-any.whl", hash = "sha256:ad98852315c2ab702aeb628412cbf7e95b7ce8c3bf9565670b4eaecf1db370a9"}, - {file = "filelock-3.12.0.tar.gz", hash = "sha256:fc03ae43288c013d2ea83c8597001b1129db351aad9c57fe2409327916b8e718"}, + {file = "filelock-3.12.3-py3-none-any.whl", hash = "sha256:f067e40ccc40f2b48395a80fcbd4728262fab54e232e090a4063ab804179efeb"}, + {file = "filelock-3.12.3.tar.gz", hash = "sha256:0ecc1dd2ec4672a10c8550a8182f1bd0c0a5088470ecd5a125e45f49472fac3d"}, ] flake8 = [ {file = "flake8-5.0.4-py2.py3-none-any.whl", hash = "sha256:7a1cf6b73744f5806ab95e526f6f0d8c01c66d7bbe349562d22dfca20610b248"}, @@ -1391,20 +1363,20 @@ flake8-rst-docstrings = [ {file = "flake8_rst_docstrings-0.3.0-py3-none-any.whl", hash = "sha256:f8c3c6892ff402292651c31983a38da082480ad3ba253743de52989bdc84ca1c"}, ] furo = [ - {file = "furo-2022.9.29-py3-none-any.whl", hash = "sha256:559ee17999c0f52728481dcf6b1b0cf8c9743e68c5e3a18cb45a7992747869a9"}, - {file = "furo-2022.9.29.tar.gz", hash = "sha256:d4238145629c623609c2deb5384f8d036e2a1ee2a101d64b67b4348112470dbd"}, + {file = "furo-2023.8.19-py3-none-any.whl", hash = "sha256:12f99f87a1873b6746228cfde18f77244e6c1ffb85d7fed95e638aae70d80590"}, + {file = "furo-2023.8.19.tar.gz", hash = "sha256:e671ee638ab3f1b472f4033b0167f502ab407830e0db0f843b1c1028119c9cd1"}, ] gitdb = [ {file = "gitdb-4.0.10-py3-none-any.whl", hash = "sha256:c286cf298426064079ed96a9e4a9d39e7f3e9bf15ba60701e95f5492f28415c7"}, {file = "gitdb-4.0.10.tar.gz", hash = "sha256:6eb990b69df4e15bad899ea868dc46572c3f75339735663b81de79b06f17eb9a"}, ] gitpython = [ - {file = "GitPython-3.1.31-py3-none-any.whl", hash = "sha256:f04893614f6aa713a60cbbe1e6a97403ef633103cdd0ef5eb6efe0deb98dbe8d"}, - {file = "GitPython-3.1.31.tar.gz", hash = "sha256:8ce3bcf69adfdf7c7d503e78fd3b1c492af782d58893b650adb2ac8912ddd573"}, + {file = "GitPython-3.1.32-py3-none-any.whl", hash = "sha256:e3d59b1c2c6ebb9dfa7a184daf3b6dd4914237e7488a1730a6d8f6f5d0b4187f"}, + {file = "GitPython-3.1.32.tar.gz", hash = "sha256:8d9b8cb1e80b9735e8717c9362079d3ce4c6e5ddeebedd0361b228c3a67a62f6"}, ] identify = [ - {file = "identify-2.5.24-py2.py3-none-any.whl", hash = "sha256:986dbfb38b1140e763e413e6feb44cd731faf72d1909543178aa79b0e258265d"}, - {file = "identify-2.5.24.tar.gz", hash = "sha256:0aac67d5b4812498056d28a9a512a483f5085cc28640b02b258a59dac34301d4"}, + {file = "identify-2.5.27-py2.py3-none-any.whl", hash = "sha256:fdb527b2dfe24602809b2201e033c2a113d7bdf716db3ca8e3243f735dcecaba"}, + {file = "identify-2.5.27.tar.gz", hash = "sha256:287b75b04a0e22d727bc9a41f0d4f3c1bcada97490fa6eabb5b28f0e9097e733"}, ] idna = [ {file = "idna-3.4-py3-none-any.whl", hash = "sha256:90b77e79eaa3eba6de819a0c442c0b4ceefc341a7a2ab77d7562bf49f425c5c2"}, @@ -1415,16 +1387,16 @@ imagesize = [ {file = "imagesize-1.4.1.tar.gz", hash = "sha256:69150444affb9cb0d5cc5a92b3676f0b2fb7cd9ae39e947a5e11a36b4497cd4a"}, ] importlib-metadata = [ - {file = "importlib_metadata-4.2.0-py3-none-any.whl", hash = "sha256:057e92c15bc8d9e8109738a48db0ccb31b4d9d5cfbee5a8670879a30be66304b"}, - {file = "importlib_metadata-4.2.0.tar.gz", hash = "sha256:b7e52a1f8dec14a75ea73e0891f3060099ca1d8e6a462a4dff11c3e119ea1b31"}, + {file = "importlib_metadata-6.8.0-py3-none-any.whl", hash = "sha256:3ebb78df84a805d7698245025b975d9d67053cd94c79245ba4b3eb694abe68bb"}, + {file = "importlib_metadata-6.8.0.tar.gz", hash = "sha256:dbace7892d8c0c4ac1ad096662232f831d4e64f4c4545bd53016a3e9d4654743"}, ] iniconfig = [ {file = "iniconfig-2.0.0-py3-none-any.whl", hash = "sha256:b6a85871a79d2e3b22d2d1b94ac2824226a63c6b741c88f7ae975f18b6778374"}, {file = "iniconfig-2.0.0.tar.gz", hash = "sha256:2d91e135bf72d31a410b17c16da610a82cb55f6b0477d1a902134b24a455b8b3"}, ] isort = [ - {file = "isort-5.11.5-py3-none-any.whl", hash = "sha256:ba1d72fb2595a01c7895a5128f9585a5cc4b6d395f1c8d514989b9a7eb2a8746"}, - {file = "isort-5.11.5.tar.gz", hash = "sha256:6be1f76a507cb2ecf16c7cf14a37e41609ca082330be4e3436a18ef74add55db"}, + {file = "isort-5.12.0-py3-none-any.whl", hash = "sha256:f84c2818376e66cf843d497486ea8fed8700b340f308f076c6fb1229dff318b6"}, + {file = "isort-5.12.0.tar.gz", hash = "sha256:8bef7dde241278824a6d83f44a544709b065191b95b6e50894bdc722fcba0504"}, ] jinja2 = [ {file = "Jinja2-3.1.2-py3-none-any.whl", hash = "sha256:6088930bfe239f0e6710546ab9c19c9ef35e29792895fed6e6e31a023a182a61"}, @@ -1438,120 +1410,121 @@ loguru = [ {file = "loguru-0.7.0.tar.gz", hash = "sha256:1612053ced6ae84d7959dd7d5e431a0532642237ec21f7fd83ac73fe539e03e1"}, ] markdown-it-py = [ - {file = "markdown-it-py-2.2.0.tar.gz", hash = "sha256:7c9a5e412688bc771c67432cbfebcdd686c93ce6484913dccf06cb5a0bea35a1"}, - {file = "markdown_it_py-2.2.0-py3-none-any.whl", hash = "sha256:5a35f8d1870171d9acc47b99612dc146129b631baf04970128b568f190d0cc30"}, + {file = "markdown-it-py-3.0.0.tar.gz", hash = "sha256:e3f60a94fa066dc52ec76661e37c851cb232d92f9886b15cb560aaada2df8feb"}, + {file = "markdown_it_py-3.0.0-py3-none-any.whl", hash = "sha256:355216845c60bd96232cd8d8c40e8f9765cc86f46880e43a8fd22dc1a1a8cab1"}, ] markupsafe = [ - {file = "MarkupSafe-2.1.2-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:665a36ae6f8f20a4676b53224e33d456a6f5a72657d9c83c2aa00765072f31f7"}, - {file = "MarkupSafe-2.1.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:340bea174e9761308703ae988e982005aedf427de816d1afe98147668cc03036"}, - {file = "MarkupSafe-2.1.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:22152d00bf4a9c7c83960521fc558f55a1adbc0631fbb00a9471e097b19d72e1"}, - {file = "MarkupSafe-2.1.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:28057e985dace2f478e042eaa15606c7efccb700797660629da387eb289b9323"}, - {file = "MarkupSafe-2.1.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ca244fa73f50a800cf8c3ebf7fd93149ec37f5cb9596aa8873ae2c1d23498601"}, - {file = "MarkupSafe-2.1.2-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:d9d971ec1e79906046aa3ca266de79eac42f1dbf3612a05dc9368125952bd1a1"}, - {file = "MarkupSafe-2.1.2-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:7e007132af78ea9df29495dbf7b5824cb71648d7133cf7848a2a5dd00d36f9ff"}, - {file = "MarkupSafe-2.1.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:7313ce6a199651c4ed9d7e4cfb4aa56fe923b1adf9af3b420ee14e6d9a73df65"}, - {file = "MarkupSafe-2.1.2-cp310-cp310-win32.whl", hash = "sha256:c4a549890a45f57f1ebf99c067a4ad0cb423a05544accaf2b065246827ed9603"}, - {file = "MarkupSafe-2.1.2-cp310-cp310-win_amd64.whl", hash = "sha256:835fb5e38fd89328e9c81067fd642b3593c33e1e17e2fdbf77f5676abb14a156"}, - {file = "MarkupSafe-2.1.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:2ec4f2d48ae59bbb9d1f9d7efb9236ab81429a764dedca114f5fdabbc3788013"}, - {file = "MarkupSafe-2.1.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:608e7073dfa9e38a85d38474c082d4281f4ce276ac0010224eaba11e929dd53a"}, - {file = "MarkupSafe-2.1.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:65608c35bfb8a76763f37036547f7adfd09270fbdbf96608be2bead319728fcd"}, - {file = "MarkupSafe-2.1.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f2bfb563d0211ce16b63c7cb9395d2c682a23187f54c3d79bfec33e6705473c6"}, - {file = "MarkupSafe-2.1.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:da25303d91526aac3672ee6d49a2f3db2d9502a4a60b55519feb1a4c7714e07d"}, - {file = "MarkupSafe-2.1.2-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:9cad97ab29dfc3f0249b483412c85c8ef4766d96cdf9dcf5a1e3caa3f3661cf1"}, - {file = "MarkupSafe-2.1.2-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:085fd3201e7b12809f9e6e9bc1e5c96a368c8523fad5afb02afe3c051ae4afcc"}, - {file = "MarkupSafe-2.1.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:1bea30e9bf331f3fef67e0a3877b2288593c98a21ccb2cf29b74c581a4eb3af0"}, - {file = "MarkupSafe-2.1.2-cp311-cp311-win32.whl", hash = "sha256:7df70907e00c970c60b9ef2938d894a9381f38e6b9db73c5be35e59d92e06625"}, - {file = "MarkupSafe-2.1.2-cp311-cp311-win_amd64.whl", hash = "sha256:e55e40ff0cc8cc5c07996915ad367fa47da6b3fc091fdadca7f5403239c5fec3"}, - {file = "MarkupSafe-2.1.2-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:a6e40afa7f45939ca356f348c8e23048e02cb109ced1eb8420961b2f40fb373a"}, - {file = "MarkupSafe-2.1.2-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cf877ab4ed6e302ec1d04952ca358b381a882fbd9d1b07cccbfd61783561f98a"}, - {file = "MarkupSafe-2.1.2-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:63ba06c9941e46fa389d389644e2d8225e0e3e5ebcc4ff1ea8506dce646f8c8a"}, - {file = "MarkupSafe-2.1.2-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f1cd098434e83e656abf198f103a8207a8187c0fc110306691a2e94a78d0abb2"}, - {file = "MarkupSafe-2.1.2-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:55f44b440d491028addb3b88f72207d71eeebfb7b5dbf0643f7c023ae1fba619"}, - {file = "MarkupSafe-2.1.2-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:a6f2fcca746e8d5910e18782f976489939d54a91f9411c32051b4aab2bd7c513"}, - {file = "MarkupSafe-2.1.2-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:0b462104ba25f1ac006fdab8b6a01ebbfbce9ed37fd37fd4acd70c67c973e460"}, - {file = "MarkupSafe-2.1.2-cp37-cp37m-win32.whl", hash = "sha256:7668b52e102d0ed87cb082380a7e2e1e78737ddecdde129acadb0eccc5423859"}, - {file = "MarkupSafe-2.1.2-cp37-cp37m-win_amd64.whl", hash = "sha256:6d6607f98fcf17e534162f0709aaad3ab7a96032723d8ac8750ffe17ae5a0666"}, - {file = "MarkupSafe-2.1.2-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:a806db027852538d2ad7555b203300173dd1b77ba116de92da9afbc3a3be3eed"}, - {file = "MarkupSafe-2.1.2-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:a4abaec6ca3ad8660690236d11bfe28dfd707778e2442b45addd2f086d6ef094"}, - {file = "MarkupSafe-2.1.2-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f03a532d7dee1bed20bc4884194a16160a2de9ffc6354b3878ec9682bb623c54"}, - {file = "MarkupSafe-2.1.2-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4cf06cdc1dda95223e9d2d3c58d3b178aa5dacb35ee7e3bbac10e4e1faacb419"}, - {file = "MarkupSafe-2.1.2-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:22731d79ed2eb25059ae3df1dfc9cb1546691cc41f4e3130fe6bfbc3ecbbecfa"}, - {file = "MarkupSafe-2.1.2-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:f8ffb705ffcf5ddd0e80b65ddf7bed7ee4f5a441ea7d3419e861a12eaf41af58"}, - {file = "MarkupSafe-2.1.2-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:8db032bf0ce9022a8e41a22598eefc802314e81b879ae093f36ce9ddf39ab1ba"}, - {file = "MarkupSafe-2.1.2-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:2298c859cfc5463f1b64bd55cb3e602528db6fa0f3cfd568d3605c50678f8f03"}, - {file = "MarkupSafe-2.1.2-cp38-cp38-win32.whl", hash = "sha256:50c42830a633fa0cf9e7d27664637532791bfc31c731a87b202d2d8ac40c3ea2"}, - {file = "MarkupSafe-2.1.2-cp38-cp38-win_amd64.whl", hash = "sha256:bb06feb762bade6bf3c8b844462274db0c76acc95c52abe8dbed28ae3d44a147"}, - {file = "MarkupSafe-2.1.2-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:99625a92da8229df6d44335e6fcc558a5037dd0a760e11d84be2260e6f37002f"}, - {file = "MarkupSafe-2.1.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:8bca7e26c1dd751236cfb0c6c72d4ad61d986e9a41bbf76cb445f69488b2a2bd"}, - {file = "MarkupSafe-2.1.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:40627dcf047dadb22cd25ea7ecfe9cbf3bbbad0482ee5920b582f3809c97654f"}, - {file = "MarkupSafe-2.1.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:40dfd3fefbef579ee058f139733ac336312663c6706d1163b82b3003fb1925c4"}, - {file = "MarkupSafe-2.1.2-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:090376d812fb6ac5f171e5938e82e7f2d7adc2b629101cec0db8b267815c85e2"}, - {file = "MarkupSafe-2.1.2-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:2e7821bffe00aa6bd07a23913b7f4e01328c3d5cc0b40b36c0bd81d362faeb65"}, - {file = "MarkupSafe-2.1.2-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:c0a33bc9f02c2b17c3ea382f91b4db0e6cde90b63b296422a939886a7a80de1c"}, - {file = "MarkupSafe-2.1.2-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:b8526c6d437855442cdd3d87eede9c425c4445ea011ca38d937db299382e6fa3"}, - {file = "MarkupSafe-2.1.2-cp39-cp39-win32.whl", hash = "sha256:137678c63c977754abe9086a3ec011e8fd985ab90631145dfb9294ad09c102a7"}, - {file = "MarkupSafe-2.1.2-cp39-cp39-win_amd64.whl", hash = "sha256:0576fe974b40a400449768941d5d0858cc624e3249dfd1e0c33674e5c7ca7aed"}, - {file = "MarkupSafe-2.1.2.tar.gz", hash = "sha256:abcabc8c2b26036d62d4c746381a6f7cf60aafcc653198ad678306986b09450d"}, + {file = "MarkupSafe-2.1.3-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:cd0f502fe016460680cd20aaa5a76d241d6f35a1c3350c474bac1273803893fa"}, + {file = "MarkupSafe-2.1.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:e09031c87a1e51556fdcb46e5bd4f59dfb743061cf93c4d6831bf894f125eb57"}, + {file = "MarkupSafe-2.1.3-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:68e78619a61ecf91e76aa3e6e8e33fc4894a2bebe93410754bd28fce0a8a4f9f"}, + {file = "MarkupSafe-2.1.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:65c1a9bcdadc6c28eecee2c119465aebff8f7a584dd719facdd9e825ec61ab52"}, + {file = "MarkupSafe-2.1.3-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:525808b8019e36eb524b8c68acdd63a37e75714eac50e988180b169d64480a00"}, + {file = "MarkupSafe-2.1.3-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:962f82a3086483f5e5f64dbad880d31038b698494799b097bc59c2edf392fce6"}, + {file = "MarkupSafe-2.1.3-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:aa7bd130efab1c280bed0f45501b7c8795f9fdbeb02e965371bbef3523627779"}, + {file = "MarkupSafe-2.1.3-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:c9c804664ebe8f83a211cace637506669e7890fec1b4195b505c214e50dd4eb7"}, + {file = "MarkupSafe-2.1.3-cp310-cp310-win32.whl", hash = "sha256:10bbfe99883db80bdbaff2dcf681dfc6533a614f700da1287707e8a5d78a8431"}, + {file = "MarkupSafe-2.1.3-cp310-cp310-win_amd64.whl", hash = "sha256:1577735524cdad32f9f694208aa75e422adba74f1baee7551620e43a3141f559"}, + {file = "MarkupSafe-2.1.3-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:ad9e82fb8f09ade1c3e1b996a6337afac2b8b9e365f926f5a61aacc71adc5b3c"}, + {file = "MarkupSafe-2.1.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:3c0fae6c3be832a0a0473ac912810b2877c8cb9d76ca48de1ed31e1c68386575"}, + {file = "MarkupSafe-2.1.3-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b076b6226fb84157e3f7c971a47ff3a679d837cf338547532ab866c57930dbee"}, + {file = "MarkupSafe-2.1.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bfce63a9e7834b12b87c64d6b155fdd9b3b96191b6bd334bf37db7ff1fe457f2"}, + {file = "MarkupSafe-2.1.3-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:338ae27d6b8745585f87218a3f23f1512dbf52c26c28e322dbe54bcede54ccb9"}, + {file = "MarkupSafe-2.1.3-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:e4dd52d80b8c83fdce44e12478ad2e85c64ea965e75d66dbeafb0a3e77308fcc"}, + {file = "MarkupSafe-2.1.3-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:df0be2b576a7abbf737b1575f048c23fb1d769f267ec4358296f31c2479db8f9"}, + {file = "MarkupSafe-2.1.3-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:5bbe06f8eeafd38e5d0a4894ffec89378b6c6a625ff57e3028921f8ff59318ac"}, + {file = "MarkupSafe-2.1.3-cp311-cp311-win32.whl", hash = "sha256:dd15ff04ffd7e05ffcb7fe79f1b98041b8ea30ae9234aed2a9168b5797c3effb"}, + {file = "MarkupSafe-2.1.3-cp311-cp311-win_amd64.whl", hash = "sha256:134da1eca9ec0ae528110ccc9e48041e0828d79f24121a1a146161103c76e686"}, + {file = "MarkupSafe-2.1.3-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:8e254ae696c88d98da6555f5ace2279cf7cd5b3f52be2b5cf97feafe883b58d2"}, + {file = "MarkupSafe-2.1.3-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cb0932dc158471523c9637e807d9bfb93e06a95cbf010f1a38b98623b929ef2b"}, + {file = "MarkupSafe-2.1.3-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9402b03f1a1b4dc4c19845e5c749e3ab82d5078d16a2a4c2cd2df62d57bb0707"}, + {file = "MarkupSafe-2.1.3-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ca379055a47383d02a5400cb0d110cef0a776fc644cda797db0c5696cfd7e18e"}, + {file = "MarkupSafe-2.1.3-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:b7ff0f54cb4ff66dd38bebd335a38e2c22c41a8ee45aa608efc890ac3e3931bc"}, + {file = "MarkupSafe-2.1.3-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:c011a4149cfbcf9f03994ec2edffcb8b1dc2d2aede7ca243746df97a5d41ce48"}, + {file = "MarkupSafe-2.1.3-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:56d9f2ecac662ca1611d183feb03a3fa4406469dafe241673d521dd5ae92a155"}, + {file = "MarkupSafe-2.1.3-cp37-cp37m-win32.whl", hash = "sha256:8758846a7e80910096950b67071243da3e5a20ed2546e6392603c096778d48e0"}, + {file = "MarkupSafe-2.1.3-cp37-cp37m-win_amd64.whl", hash = "sha256:787003c0ddb00500e49a10f2844fac87aa6ce977b90b0feaaf9de23c22508b24"}, + {file = "MarkupSafe-2.1.3-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:2ef12179d3a291be237280175b542c07a36e7f60718296278d8593d21ca937d4"}, + {file = "MarkupSafe-2.1.3-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:2c1b19b3aaacc6e57b7e25710ff571c24d6c3613a45e905b1fde04d691b98ee0"}, + {file = "MarkupSafe-2.1.3-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8afafd99945ead6e075b973fefa56379c5b5c53fd8937dad92c662da5d8fd5ee"}, + {file = "MarkupSafe-2.1.3-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8c41976a29d078bb235fea9b2ecd3da465df42a562910f9022f1a03107bd02be"}, + {file = "MarkupSafe-2.1.3-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d080e0a5eb2529460b30190fcfcc4199bd7f827663f858a226a81bc27beaa97e"}, + {file = "MarkupSafe-2.1.3-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:69c0f17e9f5a7afdf2cc9fb2d1ce6aabdb3bafb7f38017c0b77862bcec2bbad8"}, + {file = "MarkupSafe-2.1.3-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:504b320cd4b7eff6f968eddf81127112db685e81f7e36e75f9f84f0df46041c3"}, + {file = "MarkupSafe-2.1.3-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:42de32b22b6b804f42c5d98be4f7e5e977ecdd9ee9b660fda1a3edf03b11792d"}, + {file = "MarkupSafe-2.1.3-cp38-cp38-win32.whl", hash = "sha256:ceb01949af7121f9fc39f7d27f91be8546f3fb112c608bc4029aef0bab86a2a5"}, + {file = "MarkupSafe-2.1.3-cp38-cp38-win_amd64.whl", hash = "sha256:1b40069d487e7edb2676d3fbdb2b0829ffa2cd63a2ec26c4938b2d34391b4ecc"}, + {file = "MarkupSafe-2.1.3-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:8023faf4e01efadfa183e863fefde0046de576c6f14659e8782065bcece22198"}, + {file = "MarkupSafe-2.1.3-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:6b2b56950d93e41f33b4223ead100ea0fe11f8e6ee5f641eb753ce4b77a7042b"}, + {file = "MarkupSafe-2.1.3-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9dcdfd0eaf283af041973bff14a2e143b8bd64e069f4c383416ecd79a81aab58"}, + {file = "MarkupSafe-2.1.3-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:05fb21170423db021895e1ea1e1f3ab3adb85d1c2333cbc2310f2a26bc77272e"}, + {file = "MarkupSafe-2.1.3-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:282c2cb35b5b673bbcadb33a585408104df04f14b2d9b01d4c345a3b92861c2c"}, + {file = "MarkupSafe-2.1.3-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:ab4a0df41e7c16a1392727727e7998a467472d0ad65f3ad5e6e765015df08636"}, + {file = "MarkupSafe-2.1.3-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:7ef3cb2ebbf91e330e3bb937efada0edd9003683db6b57bb108c4001f37a02ea"}, + {file = "MarkupSafe-2.1.3-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:0a4e4a1aff6c7ac4cd55792abf96c915634c2b97e3cc1c7129578aa68ebd754e"}, + {file = "MarkupSafe-2.1.3-cp39-cp39-win32.whl", hash = "sha256:fec21693218efe39aa7f8599346e90c705afa52c5b31ae019b2e57e8f6542bb2"}, + {file = "MarkupSafe-2.1.3-cp39-cp39-win_amd64.whl", hash = "sha256:3fd4abcb888d15a94f32b75d8fd18ee162ca0c064f35b11134be77050296d6ba"}, + {file = "MarkupSafe-2.1.3.tar.gz", hash = "sha256:af598ed32d6ae86f1b747b82783958b1a4ab8f617b06fe68795c7f026abbdcad"}, ] mccabe = [ {file = "mccabe-0.7.0-py2.py3-none-any.whl", hash = "sha256:6c2d30ab6be0e4a46919781807b4f0d834ebdd6c6e3dca0bda5a15f863427b6e"}, {file = "mccabe-0.7.0.tar.gz", hash = "sha256:348e0240c33b60bbdf4e523192ef919f28cb2c3d7d5c7794f74009290f236325"}, ] mdit-py-plugins = [ - {file = "mdit-py-plugins-0.3.5.tar.gz", hash = "sha256:eee0adc7195e5827e17e02d2a258a2ba159944a0748f59c5099a4a27f78fcf6a"}, - {file = "mdit_py_plugins-0.3.5-py3-none-any.whl", hash = "sha256:ca9a0714ea59a24b2b044a1831f48d817dd0c817e84339f20e7889f392d77c4e"}, + {file = "mdit_py_plugins-0.4.0-py3-none-any.whl", hash = "sha256:b51b3bb70691f57f974e257e367107857a93b36f322a9e6d44ca5bf28ec2def9"}, + {file = "mdit_py_plugins-0.4.0.tar.gz", hash = "sha256:d8ab27e9aed6c38aa716819fedfde15ca275715955f8a185a8e1cf90fb1d2c1b"}, ] mdurl = [ {file = "mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8"}, {file = "mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba"}, ] mypy = [ - {file = "mypy-1.2.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:701189408b460a2ff42b984e6bd45c3f41f0ac9f5f58b8873bbedc511900086d"}, - {file = "mypy-1.2.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:fe91be1c51c90e2afe6827601ca14353bbf3953f343c2129fa1e247d55fd95ba"}, - {file = "mypy-1.2.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8d26b513225ffd3eacece727f4387bdce6469192ef029ca9dd469940158bc89e"}, - {file = "mypy-1.2.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:3a2d219775a120581a0ae8ca392b31f238d452729adbcb6892fa89688cb8306a"}, - {file = "mypy-1.2.0-cp310-cp310-win_amd64.whl", hash = "sha256:2e93a8a553e0394b26c4ca683923b85a69f7ccdc0139e6acd1354cc884fe0128"}, - {file = "mypy-1.2.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:3efde4af6f2d3ccf58ae825495dbb8d74abd6d176ee686ce2ab19bd025273f41"}, - {file = "mypy-1.2.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:695c45cea7e8abb6f088a34a6034b1d273122e5530aeebb9c09626cea6dca4cb"}, - {file = "mypy-1.2.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d0e9464a0af6715852267bf29c9553e4555b61f5904a4fc538547a4d67617937"}, - {file = "mypy-1.2.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:8293a216e902ac12779eb7a08f2bc39ec6c878d7c6025aa59464e0c4c16f7eb9"}, - {file = "mypy-1.2.0-cp311-cp311-win_amd64.whl", hash = "sha256:f46af8d162f3d470d8ffc997aaf7a269996d205f9d746124a179d3abe05ac602"}, - {file = "mypy-1.2.0-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:031fc69c9a7e12bcc5660b74122ed84b3f1c505e762cc4296884096c6d8ee140"}, - {file = "mypy-1.2.0-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:390bc685ec209ada4e9d35068ac6988c60160b2b703072d2850457b62499e336"}, - {file = "mypy-1.2.0-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:4b41412df69ec06ab141808d12e0bf2823717b1c363bd77b4c0820feaa37249e"}, - {file = "mypy-1.2.0-cp37-cp37m-win_amd64.whl", hash = "sha256:4e4a682b3f2489d218751981639cffc4e281d548f9d517addfd5a2917ac78119"}, - {file = "mypy-1.2.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:a197ad3a774f8e74f21e428f0de7f60ad26a8d23437b69638aac2764d1e06a6a"}, - {file = "mypy-1.2.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:c9a084bce1061e55cdc0493a2ad890375af359c766b8ac311ac8120d3a472950"}, - {file = "mypy-1.2.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eaeaa0888b7f3ccb7bcd40b50497ca30923dba14f385bde4af78fac713d6d6f6"}, - {file = "mypy-1.2.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:bea55fc25b96c53affab852ad94bf111a3083bc1d8b0c76a61dd101d8a388cf5"}, - {file = "mypy-1.2.0-cp38-cp38-win_amd64.whl", hash = "sha256:4c8d8c6b80aa4a1689f2a179d31d86ae1367ea4a12855cc13aa3ba24bb36b2d8"}, - {file = "mypy-1.2.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:70894c5345bea98321a2fe84df35f43ee7bb0feec117a71420c60459fc3e1eed"}, - {file = "mypy-1.2.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:4a99fe1768925e4a139aace8f3fb66db3576ee1c30b9c0f70f744ead7e329c9f"}, - {file = "mypy-1.2.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:023fe9e618182ca6317ae89833ba422c411469156b690fde6a315ad10695a521"}, - {file = "mypy-1.2.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:4d19f1a239d59f10fdc31263d48b7937c585810288376671eaf75380b074f238"}, - {file = "mypy-1.2.0-cp39-cp39-win_amd64.whl", hash = "sha256:2de7babe398cb7a85ac7f1fd5c42f396c215ab3eff731b4d761d68d0f6a80f48"}, - {file = "mypy-1.2.0-py3-none-any.whl", hash = "sha256:d8e9187bfcd5ffedbe87403195e1fc340189a68463903c39e2b63307c9fa0394"}, - {file = "mypy-1.2.0.tar.gz", hash = "sha256:f70a40410d774ae23fcb4afbbeca652905a04de7948eaf0b1789c8d1426b72d1"}, + {file = "mypy-1.5.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:f33592ddf9655a4894aef22d134de7393e95fcbdc2d15c1ab65828eee5c66c70"}, + {file = "mypy-1.5.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:258b22210a4a258ccd077426c7a181d789d1121aca6db73a83f79372f5569ae0"}, + {file = "mypy-1.5.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a9ec1f695f0c25986e6f7f8778e5ce61659063268836a38c951200c57479cc12"}, + {file = "mypy-1.5.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:abed92d9c8f08643c7d831300b739562b0a6c9fcb028d211134fc9ab20ccad5d"}, + {file = "mypy-1.5.1-cp310-cp310-win_amd64.whl", hash = "sha256:a156e6390944c265eb56afa67c74c0636f10283429171018446b732f1a05af25"}, + {file = "mypy-1.5.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:6ac9c21bfe7bc9f7f1b6fae441746e6a106e48fc9de530dea29e8cd37a2c0cc4"}, + {file = "mypy-1.5.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:51cb1323064b1099e177098cb939eab2da42fea5d818d40113957ec954fc85f4"}, + {file = "mypy-1.5.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:596fae69f2bfcb7305808c75c00f81fe2829b6236eadda536f00610ac5ec2243"}, + {file = "mypy-1.5.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:32cb59609b0534f0bd67faebb6e022fe534bdb0e2ecab4290d683d248be1b275"}, + {file = "mypy-1.5.1-cp311-cp311-win_amd64.whl", hash = "sha256:159aa9acb16086b79bbb0016145034a1a05360626046a929f84579ce1666b315"}, + {file = "mypy-1.5.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:f6b0e77db9ff4fda74de7df13f30016a0a663928d669c9f2c057048ba44f09bb"}, + {file = "mypy-1.5.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:26f71b535dfc158a71264e6dc805a9f8d2e60b67215ca0bfa26e2e1aa4d4d373"}, + {file = "mypy-1.5.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2fc3a600f749b1008cc75e02b6fb3d4db8dbcca2d733030fe7a3b3502902f161"}, + {file = "mypy-1.5.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:26fb32e4d4afa205b24bf645eddfbb36a1e17e995c5c99d6d00edb24b693406a"}, + {file = "mypy-1.5.1-cp312-cp312-win_amd64.whl", hash = "sha256:82cb6193de9bbb3844bab4c7cf80e6227d5225cc7625b068a06d005d861ad5f1"}, + {file = "mypy-1.5.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:4a465ea2ca12804d5b34bb056be3a29dc47aea5973b892d0417c6a10a40b2d65"}, + {file = "mypy-1.5.1-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:9fece120dbb041771a63eb95e4896791386fe287fefb2837258925b8326d6160"}, + {file = "mypy-1.5.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d28ddc3e3dfeab553e743e532fb95b4e6afad51d4706dd22f28e1e5e664828d2"}, + {file = "mypy-1.5.1-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:57b10c56016adce71fba6bc6e9fd45d8083f74361f629390c556738565af8eeb"}, + {file = "mypy-1.5.1-cp38-cp38-win_amd64.whl", hash = "sha256:ff0cedc84184115202475bbb46dd99f8dcb87fe24d5d0ddfc0fe6b8575c88d2f"}, + {file = "mypy-1.5.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:8f772942d372c8cbac575be99f9cc9d9fb3bd95c8bc2de6c01411e2c84ebca8a"}, + {file = "mypy-1.5.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:5d627124700b92b6bbaa99f27cbe615c8ea7b3402960f6372ea7d65faf376c14"}, + {file = "mypy-1.5.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:361da43c4f5a96173220eb53340ace68cda81845cd88218f8862dfb0adc8cddb"}, + {file = "mypy-1.5.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:330857f9507c24de5c5724235e66858f8364a0693894342485e543f5b07c8693"}, + {file = "mypy-1.5.1-cp39-cp39-win_amd64.whl", hash = "sha256:c543214ffdd422623e9fedd0869166c2f16affe4ba37463975043ef7d2ea8770"}, + {file = "mypy-1.5.1-py3-none-any.whl", hash = "sha256:f757063a83970d67c444f6e01d9550a7402322af3557ce7630d3c957386fa8f5"}, + {file = "mypy-1.5.1.tar.gz", hash = "sha256:b031b9601f1060bf1281feab89697324726ba0c0bae9d7cd7ab4b690940f0b92"}, ] mypy-extensions = [ {file = "mypy_extensions-1.0.0-py3-none-any.whl", hash = "sha256:4392f6c0eb8a5668a69e23d168ffa70f0be9ccfd32b5cc2d26a34ae5b844552d"}, {file = "mypy_extensions-1.0.0.tar.gz", hash = "sha256:75dbf8955dc00442a438fc4d0666508a9a97b6bd41aa2f0ffe9d2f2725af0782"}, ] myst-parser = [ - {file = "myst-parser-0.18.1.tar.gz", hash = "sha256:79317f4bb2c13053dd6e64f9da1ba1da6cd9c40c8a430c447a7b146a594c246d"}, - {file = "myst_parser-0.18.1-py3-none-any.whl", hash = "sha256:61b275b85d9f58aa327f370913ae1bec26ebad372cc99f3ab85c8ec3ee8d9fb8"}, + {file = "myst_parser-2.0.0-py3-none-any.whl", hash = "sha256:7c36344ae39c8e740dad7fdabf5aa6fc4897a813083c6cc9990044eb93656b14"}, + {file = "myst_parser-2.0.0.tar.gz", hash = "sha256:ea929a67a6a0b1683cdbe19b8d2e724cd7643f8aa3e7bb18dd65beac3483bead"}, ] nodeenv = [ - {file = "nodeenv-1.7.0-py2.py3-none-any.whl", hash = "sha256:27083a7b96a25f2f5e1d8cb4b6317ee8aeda3bdd121394e5ac54e498028a042e"}, - {file = "nodeenv-1.7.0.tar.gz", hash = "sha256:e0e7f7dfb85fc5394c6fe1e8fa98131a2473e04311a45afb6508f7cf1836fa2b"}, + {file = "nodeenv-1.8.0-py2.py3-none-any.whl", hash = "sha256:df865724bb3c3adc86b3876fa209771517b0cfe596beff01a92700e0e8be4cec"}, + {file = "nodeenv-1.8.0.tar.gz", hash = "sha256:d51e0c37e64fbf47d017feac3145cdbb58836d7eee8c6f6d3b6880c5456227d2"}, ] packaging = [ {file = "packaging-21.3-py3-none-any.whl", hash = "sha256:ef103e05f519cdc783ae24ea4e2e0f508a9c99b2d4969652eed6a2e1ea5bd522"}, {file = "packaging-21.3.tar.gz", hash = "sha256:dd47c42927d89ab911e606518907cc2d3a1f38bbd026385970643f9c5b8ecfeb"}, ] pathspec = [ - {file = "pathspec-0.11.1-py3-none-any.whl", hash = "sha256:d8af70af76652554bd134c22b3e8a1cc46ed7d91edcdd721ef1a0c51a84a5293"}, - {file = "pathspec-0.11.1.tar.gz", hash = "sha256:2798de800fa92780e33acca925945e9a19a133b715067cf165b8866c15a31687"}, + {file = "pathspec-0.11.2-py3-none-any.whl", hash = "sha256:1d6ed233af05e679efb96b1851550ea95bbb64b7c490b0f5aa52996c11e92a20"}, + {file = "pathspec-0.11.2.tar.gz", hash = "sha256:e0d8d0ac2f12da61956eb2306b69f9469b42f4deb0f3cb6ed47b9cce9996ced3"}, ] pbr = [ {file = "pbr-5.11.1-py2.py3-none-any.whl", hash = "sha256:567f09558bae2b3ab53cb3c1e2e33e726ff3338e7bae3db5dc954b3a44eef12b"}, @@ -1562,16 +1535,16 @@ pep8-naming = [ {file = "pep8_naming-0.13.3-py3-none-any.whl", hash = "sha256:1a86b8c71a03337c97181917e2b472f0f5e4ccb06844a0d6f0a33522549e7a80"}, ] platformdirs = [ - {file = "platformdirs-2.6.2-py3-none-any.whl", hash = "sha256:83c8f6d04389165de7c9b6f0c682439697887bca0aa2f1c87ef1826be3584490"}, - {file = "platformdirs-2.6.2.tar.gz", hash = "sha256:e1fea1fe471b9ff8332e229df3cb7de4f53eeea4998d3b6bfff542115e998bd2"}, + {file = "platformdirs-3.10.0-py3-none-any.whl", hash = "sha256:d7c24979f292f916dc9cbf8648319032f551ea8c49a4c9bf2fb556a02070ec1d"}, + {file = "platformdirs-3.10.0.tar.gz", hash = "sha256:b45696dab2d7cc691a3226759c0d3b00c47c8b6e293d96f6436f733303f77f6d"}, ] pluggy = [ - {file = "pluggy-1.0.0-py2.py3-none-any.whl", hash = "sha256:74134bbf457f031a36d68416e1509f34bd5ccc019f0bcc952c7b909d06b37bd3"}, - {file = "pluggy-1.0.0.tar.gz", hash = "sha256:4224373bacce55f955a878bf9cfa763c1e360858e330072059e10bad68531159"}, + {file = "pluggy-1.3.0-py3-none-any.whl", hash = "sha256:d89c696a773f8bd377d18e5ecda92b7a3793cbe66c87060a6fb58c7b6e1061f7"}, + {file = "pluggy-1.3.0.tar.gz", hash = "sha256:cf61ae8f126ac6f7c451172cf30e3e43d3ca77615509771b3a984a0730651e12"}, ] pre-commit = [ - {file = "pre_commit-2.21.0-py2.py3-none-any.whl", hash = "sha256:e2f91727039fc39a92f58a588a25b87f936de6567eed4f0e673e0507edc75bad"}, - {file = "pre_commit-2.21.0.tar.gz", hash = "sha256:31ef31af7e474a8d8995027fefdfcf509b5c913ff31f2015b4ec4beb26a6f658"}, + {file = "pre_commit-3.3.3-py2.py3-none-any.whl", hash = "sha256:10badb65d6a38caff29703362271d7dca483d01da88f9d7e05d0b97171c136cb"}, + {file = "pre_commit-3.3.3.tar.gz", hash = "sha256:a2256f489cd913d575c145132ae196fe335da32d91a8294b7afe6622335dd023"}, ] pre-commit-hooks = [ {file = "pre_commit_hooks-4.4.0-py2.py3-none-any.whl", hash = "sha256:fc8837335476221ccccda3d176ed6ae29fe58753ce7e8b7863f5d0f987328fc6"}, @@ -1590,74 +1563,91 @@ pyflakes = [ {file = "pyflakes-2.5.0.tar.gz", hash = "sha256:491feb020dca48ccc562a8c0cbe8df07ee13078df59813b83959cbdada312ea3"}, ] pygments = [ - {file = "Pygments-2.15.1-py3-none-any.whl", hash = "sha256:db2db3deb4b4179f399a09054b023b6a586b76499d36965813c71aa8ed7b5fd1"}, - {file = "Pygments-2.15.1.tar.gz", hash = "sha256:8ace4d3c1dd481894b2005f560ead0f9f19ee64fe983366be1a21e171d12775c"}, + {file = "Pygments-2.16.1-py3-none-any.whl", hash = "sha256:13fc09fa63bc8d8671a6d247e1eb303c4b343eaee81d861f3404db2935653692"}, + {file = "Pygments-2.16.1.tar.gz", hash = "sha256:1daff0494820c69bc8941e407aa20f577374ee88364ee10a98fdbe0aece96e29"}, ] pyparsing = [ - {file = "pyparsing-3.0.9-py3-none-any.whl", hash = "sha256:5026bae9a10eeaefb61dab2f09052b9f4307d44aee4eda64b309723d8d206bbc"}, - {file = "pyparsing-3.0.9.tar.gz", hash = "sha256:2b020ecf7d21b687f219b71ecad3631f644a47f01403fa1d1036b0c6416d70fb"}, + {file = "pyparsing-3.1.1-py3-none-any.whl", hash = "sha256:32c7c0b711493c72ff18a981d24f28aaf9c1fb7ed5e9667c9e84e3db623bdbfb"}, + {file = "pyparsing-3.1.1.tar.gz", hash = "sha256:ede28a1a32462f5a9705e07aea48001a08f7cf81a021585011deba701581a0db"}, ] pytest = [ - {file = "pytest-7.3.1-py3-none-any.whl", hash = "sha256:3799fa815351fea3a5e96ac7e503a96fa51cc9942c3753cda7651b93c1cfa362"}, - {file = "pytest-7.3.1.tar.gz", hash = "sha256:434afafd78b1d78ed0addf160ad2b77a30d35d4bdf8af234fe621919d9ed15e3"}, + {file = "pytest-7.4.0-py3-none-any.whl", hash = "sha256:78bf16451a2eb8c7a2ea98e32dc119fd2aa758f1d5d66dbf0a59d69a3969df32"}, + {file = "pytest-7.4.0.tar.gz", hash = "sha256:b4bf8c45bd59934ed84001ad51e11b4ee40d40a1229d2c79f9c592b0a3f6bd8a"}, ] pytz = [ {file = "pytz-2023.3-py2.py3-none-any.whl", hash = "sha256:a151b3abb88eda1d4e34a9814df37de2a80e301e68ba0fd856fb9b46bfbbbffb"}, {file = "pytz-2023.3.tar.gz", hash = "sha256:1d8ce29db189191fb55338ee6d0387d82ab59f3d00eac103412d64e0ebd0c588"}, ] pyupgrade = [ - {file = "pyupgrade-3.3.2-py2.py3-none-any.whl", hash = "sha256:c05b82c911934b3a638b29f48f48dc6e0ef6c57c55ec36f2b41ae9dbf6711b4b"}, - {file = "pyupgrade-3.3.2.tar.gz", hash = "sha256:bcfed63d38811809f179fd269dec246680b0aaa5bbe662b535826e5fa2275219"}, + {file = "pyupgrade-3.8.0-py2.py3-none-any.whl", hash = "sha256:08d0e6129f5e9da7e7a581bdbea689e0d49c3c93eeaf156a07ae2fd794f52660"}, + {file = "pyupgrade-3.8.0.tar.gz", hash = "sha256:1facb0b8407cca468dfcc1d13717e3a85aa37b9e6e7338664ad5bfe5ef50c867"}, ] pyyaml = [ - {file = "PyYAML-6.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:d4db7c7aef085872ef65a8fd7d6d09a14ae91f691dec3e87ee5ee0539d516f53"}, - {file = "PyYAML-6.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:9df7ed3b3d2e0ecfe09e14741b857df43adb5a3ddadc919a2d94fbdf78fea53c"}, - {file = "PyYAML-6.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:77f396e6ef4c73fdc33a9157446466f1cff553d979bd00ecb64385760c6babdc"}, - {file = "PyYAML-6.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a80a78046a72361de73f8f395f1f1e49f956c6be882eed58505a15f3e430962b"}, - {file = "PyYAML-6.0-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:f84fbc98b019fef2ee9a1cb3ce93e3187a6df0b2538a651bfb890254ba9f90b5"}, - {file = "PyYAML-6.0-cp310-cp310-win32.whl", hash = "sha256:2cd5df3de48857ed0544b34e2d40e9fac445930039f3cfe4bcc592a1f836d513"}, - {file = "PyYAML-6.0-cp310-cp310-win_amd64.whl", hash = "sha256:daf496c58a8c52083df09b80c860005194014c3698698d1a57cbcfa182142a3a"}, - {file = "PyYAML-6.0-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:897b80890765f037df3403d22bab41627ca8811ae55e9a722fd0392850ec4d86"}, - {file = "PyYAML-6.0-cp36-cp36m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:50602afada6d6cbfad699b0c7bb50d5ccffa7e46a3d738092afddc1f9758427f"}, - {file = "PyYAML-6.0-cp36-cp36m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:48c346915c114f5fdb3ead70312bd042a953a8ce5c7106d5bfb1a5254e47da92"}, - {file = "PyYAML-6.0-cp36-cp36m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:98c4d36e99714e55cfbaaee6dd5badbc9a1ec339ebfc3b1f52e293aee6bb71a4"}, - {file = "PyYAML-6.0-cp36-cp36m-win32.whl", hash = "sha256:0283c35a6a9fbf047493e3a0ce8d79ef5030852c51e9d911a27badfde0605293"}, - {file = "PyYAML-6.0-cp36-cp36m-win_amd64.whl", hash = "sha256:07751360502caac1c067a8132d150cf3d61339af5691fe9e87803040dbc5db57"}, - {file = "PyYAML-6.0-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:819b3830a1543db06c4d4b865e70ded25be52a2e0631ccd2f6a47a2822f2fd7c"}, - {file = "PyYAML-6.0-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:473f9edb243cb1935ab5a084eb238d842fb8f404ed2193a915d1784b5a6b5fc0"}, - {file = "PyYAML-6.0-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:0ce82d761c532fe4ec3f87fc45688bdd3a4c1dc5e0b4a19814b9009a29baefd4"}, - {file = "PyYAML-6.0-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:231710d57adfd809ef5d34183b8ed1eeae3f76459c18fb4a0b373ad56bedcdd9"}, - {file = "PyYAML-6.0-cp37-cp37m-win32.whl", hash = "sha256:c5687b8d43cf58545ade1fe3e055f70eac7a5a1a0bf42824308d868289a95737"}, - {file = "PyYAML-6.0-cp37-cp37m-win_amd64.whl", hash = "sha256:d15a181d1ecd0d4270dc32edb46f7cb7733c7c508857278d3d378d14d606db2d"}, - {file = "PyYAML-6.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:0b4624f379dab24d3725ffde76559cff63d9ec94e1736b556dacdfebe5ab6d4b"}, - {file = "PyYAML-6.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:213c60cd50106436cc818accf5baa1aba61c0189ff610f64f4a3e8c6726218ba"}, - {file = "PyYAML-6.0-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9fa600030013c4de8165339db93d182b9431076eb98eb40ee068700c9c813e34"}, - {file = "PyYAML-6.0-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:277a0ef2981ca40581a47093e9e2d13b3f1fbbeffae064c1d21bfceba2030287"}, - {file = "PyYAML-6.0-cp38-cp38-win32.whl", hash = "sha256:d4eccecf9adf6fbcc6861a38015c2a64f38b9d94838ac1810a9023a0609e1b78"}, - {file = "PyYAML-6.0-cp38-cp38-win_amd64.whl", hash = "sha256:1e4747bc279b4f613a09eb64bba2ba602d8a6664c6ce6396a4d0cd413a50ce07"}, - {file = "PyYAML-6.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:055d937d65826939cb044fc8c9b08889e8c743fdc6a32b33e2390f66013e449b"}, - {file = "PyYAML-6.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:e61ceaab6f49fb8bdfaa0f92c4b57bcfbea54c09277b1b4f7ac376bfb7a7c174"}, - {file = "PyYAML-6.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d67d839ede4ed1b28a4e8909735fc992a923cdb84e618544973d7dfc71540803"}, - {file = "PyYAML-6.0-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:cba8c411ef271aa037d7357a2bc8f9ee8b58b9965831d9e51baf703280dc73d3"}, - {file = "PyYAML-6.0-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:40527857252b61eacd1d9af500c3337ba8deb8fc298940291486c465c8b46ec0"}, - {file = "PyYAML-6.0-cp39-cp39-win32.whl", hash = "sha256:b5b9eccad747aabaaffbc6064800670f0c297e52c12754eb1d976c57e4f74dcb"}, - {file = "PyYAML-6.0-cp39-cp39-win_amd64.whl", hash = "sha256:b3d267842bf12586ba6c734f89d1f5b871df0273157918b0ccefa29deb05c21c"}, - {file = "PyYAML-6.0.tar.gz", hash = "sha256:68fb519c14306fec9720a2a5b45bc9f0c8d1b9c72adf45c37baedfcd949c35a2"}, + {file = "PyYAML-6.0.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:d858aa552c999bc8a8d57426ed01e40bef403cd8ccdd0fc5f6f04a00414cac2a"}, + {file = "PyYAML-6.0.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:fd66fc5d0da6d9815ba2cebeb4205f95818ff4b79c3ebe268e75d961704af52f"}, + {file = "PyYAML-6.0.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:69b023b2b4daa7548bcfbd4aa3da05b3a74b772db9e23b982788168117739938"}, + {file = "PyYAML-6.0.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:81e0b275a9ecc9c0c0c07b4b90ba548307583c125f54d5b6946cfee6360c733d"}, + {file = "PyYAML-6.0.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ba336e390cd8e4d1739f42dfe9bb83a3cc2e80f567d8805e11b46f4a943f5515"}, + {file = "PyYAML-6.0.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:326c013efe8048858a6d312ddd31d56e468118ad4cdeda36c719bf5bb6192290"}, + {file = "PyYAML-6.0.1-cp310-cp310-win32.whl", hash = "sha256:bd4af7373a854424dabd882decdc5579653d7868b8fb26dc7d0e99f823aa5924"}, + {file = "PyYAML-6.0.1-cp310-cp310-win_amd64.whl", hash = "sha256:fd1592b3fdf65fff2ad0004b5e363300ef59ced41c2e6b3a99d4089fa8c5435d"}, + {file = "PyYAML-6.0.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:6965a7bc3cf88e5a1c3bd2e0b5c22f8d677dc88a455344035f03399034eb3007"}, + {file = "PyYAML-6.0.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:f003ed9ad21d6a4713f0a9b5a7a0a79e08dd0f221aff4525a2be4c346ee60aab"}, + {file = "PyYAML-6.0.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:42f8152b8dbc4fe7d96729ec2b99c7097d656dc1213a3229ca5383f973a5ed6d"}, + {file = "PyYAML-6.0.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:062582fca9fabdd2c8b54a3ef1c978d786e0f6b3a1510e0ac93ef59e0ddae2bc"}, + {file = "PyYAML-6.0.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d2b04aac4d386b172d5b9692e2d2da8de7bfb6c387fa4f801fbf6fb2e6ba4673"}, + {file = "PyYAML-6.0.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:e7d73685e87afe9f3b36c799222440d6cf362062f78be1013661b00c5c6f678b"}, + {file = "PyYAML-6.0.1-cp311-cp311-win32.whl", hash = "sha256:1635fd110e8d85d55237ab316b5b011de701ea0f29d07611174a1b42f1444741"}, + {file = "PyYAML-6.0.1-cp311-cp311-win_amd64.whl", hash = "sha256:bf07ee2fef7014951eeb99f56f39c9bb4af143d8aa3c21b1677805985307da34"}, + {file = "PyYAML-6.0.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:855fb52b0dc35af121542a76b9a84f8d1cd886ea97c84703eaa6d88e37a2ad28"}, + {file = "PyYAML-6.0.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:40df9b996c2b73138957fe23a16a4f0ba614f4c0efce1e9406a184b6d07fa3a9"}, + {file = "PyYAML-6.0.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6c22bec3fbe2524cde73d7ada88f6566758a8f7227bfbf93a408a9d86bcc12a0"}, + {file = "PyYAML-6.0.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:8d4e9c88387b0f5c7d5f281e55304de64cf7f9c0021a3525bd3b1c542da3b0e4"}, + {file = "PyYAML-6.0.1-cp312-cp312-win32.whl", hash = "sha256:d483d2cdf104e7c9fa60c544d92981f12ad66a457afae824d146093b8c294c54"}, + {file = "PyYAML-6.0.1-cp312-cp312-win_amd64.whl", hash = "sha256:0d3304d8c0adc42be59c5f8a4d9e3d7379e6955ad754aa9d6ab7a398b59dd1df"}, + {file = "PyYAML-6.0.1-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:50550eb667afee136e9a77d6dc71ae76a44df8b3e51e41b77f6de2932bfe0f47"}, + {file = "PyYAML-6.0.1-cp36-cp36m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1fe35611261b29bd1de0070f0b2f47cb6ff71fa6595c077e42bd0c419fa27b98"}, + {file = "PyYAML-6.0.1-cp36-cp36m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:704219a11b772aea0d8ecd7058d0082713c3562b4e271b849ad7dc4a5c90c13c"}, + {file = "PyYAML-6.0.1-cp36-cp36m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:afd7e57eddb1a54f0f1a974bc4391af8bcce0b444685d936840f125cf046d5bd"}, + {file = "PyYAML-6.0.1-cp36-cp36m-win32.whl", hash = "sha256:fca0e3a251908a499833aa292323f32437106001d436eca0e6e7833256674585"}, + {file = "PyYAML-6.0.1-cp36-cp36m-win_amd64.whl", hash = "sha256:f22ac1c3cac4dbc50079e965eba2c1058622631e526bd9afd45fedd49ba781fa"}, + {file = "PyYAML-6.0.1-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:b1275ad35a5d18c62a7220633c913e1b42d44b46ee12554e5fd39c70a243d6a3"}, + {file = "PyYAML-6.0.1-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:18aeb1bf9a78867dc38b259769503436b7c72f7a1f1f4c93ff9a17de54319b27"}, + {file = "PyYAML-6.0.1-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:596106435fa6ad000c2991a98fa58eeb8656ef2325d7e158344fb33864ed87e3"}, + {file = "PyYAML-6.0.1-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:baa90d3f661d43131ca170712d903e6295d1f7a0f595074f151c0aed377c9b9c"}, + {file = "PyYAML-6.0.1-cp37-cp37m-win32.whl", hash = "sha256:9046c58c4395dff28dd494285c82ba00b546adfc7ef001486fbf0324bc174fba"}, + {file = "PyYAML-6.0.1-cp37-cp37m-win_amd64.whl", hash = "sha256:4fb147e7a67ef577a588a0e2c17b6db51dda102c71de36f8549b6816a96e1867"}, + {file = "PyYAML-6.0.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:1d4c7e777c441b20e32f52bd377e0c409713e8bb1386e1099c2415f26e479595"}, + {file = "PyYAML-6.0.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a0cd17c15d3bb3fa06978b4e8958dcdc6e0174ccea823003a106c7d4d7899ac5"}, + {file = "PyYAML-6.0.1-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:28c119d996beec18c05208a8bd78cbe4007878c6dd15091efb73a30e90539696"}, + {file = "PyYAML-6.0.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7e07cbde391ba96ab58e532ff4803f79c4129397514e1413a7dc761ccd755735"}, + {file = "PyYAML-6.0.1-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:49a183be227561de579b4a36efbb21b3eab9651dd81b1858589f796549873dd6"}, + {file = "PyYAML-6.0.1-cp38-cp38-win32.whl", hash = "sha256:184c5108a2aca3c5b3d3bf9395d50893a7ab82a38004c8f61c258d4428e80206"}, + {file = "PyYAML-6.0.1-cp38-cp38-win_amd64.whl", hash = "sha256:1e2722cc9fbb45d9b87631ac70924c11d3a401b2d7f410cc0e3bbf249f2dca62"}, + {file = "PyYAML-6.0.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:9eb6caa9a297fc2c2fb8862bc5370d0303ddba53ba97e71f08023b6cd73d16a8"}, + {file = "PyYAML-6.0.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:c8098ddcc2a85b61647b2590f825f3db38891662cfc2fc776415143f599bb859"}, + {file = "PyYAML-6.0.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5773183b6446b2c99bb77e77595dd486303b4faab2b086e7b17bc6bef28865f6"}, + {file = "PyYAML-6.0.1-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b786eecbdf8499b9ca1d697215862083bd6d2a99965554781d0d8d1ad31e13a0"}, + {file = "PyYAML-6.0.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bc1bf2925a1ecd43da378f4db9e4f799775d6367bdb94671027b73b393a7c42c"}, + {file = "PyYAML-6.0.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:04ac92ad1925b2cff1db0cfebffb6ffc43457495c9b3c39d3fcae417d7125dc5"}, + {file = "PyYAML-6.0.1-cp39-cp39-win32.whl", hash = "sha256:faca3bdcf85b2fc05d06ff3fbc1f83e1391b3e724afa3feba7d13eeab355484c"}, + {file = "PyYAML-6.0.1-cp39-cp39-win_amd64.whl", hash = "sha256:510c9deebc5c0225e8c96813043e62b680ba2f9c50a08d3724c7f28a747d1486"}, + {file = "PyYAML-6.0.1.tar.gz", hash = "sha256:bfdf460b1736c775f2ba9f6a92bca30bc2095067b8a9d77876d1fad6cc3b4a43"}, ] requests = [ - {file = "requests-2.30.0-py3-none-any.whl", hash = "sha256:10e94cc4f3121ee6da529d358cdaeaff2f1c409cd377dbc72b825852f2f7e294"}, - {file = "requests-2.30.0.tar.gz", hash = "sha256:239d7d4458afcb28a692cdd298d87542235f4ca8d36d03a15bfc128a6559a2f4"}, + {file = "requests-2.31.0-py3-none-any.whl", hash = "sha256:58cd2187c01e70e6e26505bca751777aa9f2ee0b7f4300988b709f44e013003f"}, + {file = "requests-2.31.0.tar.gz", hash = "sha256:942c5a758f98d790eaed1a29cb6eefc7ffb0d1cf7af05c3d2791656dbd6ad1e1"}, ] restructuredtext-lint = [ {file = "restructuredtext_lint-1.4.0.tar.gz", hash = "sha256:1b235c0c922341ab6c530390892eb9e92f90b9b75046063e047cacfb0f050c45"}, ] rich = [ - {file = "rich-13.3.5-py3-none-any.whl", hash = "sha256:69cdf53799e63f38b95b9bf9c875f8c90e78dd62b2f00c13a911c7a3b9fa4704"}, - {file = "rich-13.3.5.tar.gz", hash = "sha256:2d11b9b8dd03868f09b4fffadc84a6a8cda574e40dc90821bd845720ebb8e89c"}, + {file = "rich-13.5.2-py3-none-any.whl", hash = "sha256:146a90b3b6b47cac4a73c12866a499e9817426423f57c5a66949c086191a8808"}, + {file = "rich-13.5.2.tar.gz", hash = "sha256:fb9d6c0a0f643c99eed3875b5377a184132ba9be4d61516a55273d3554d75a39"}, ] "ruamel.yaml" = [ - {file = "ruamel.yaml-0.17.24-py3-none-any.whl", hash = "sha256:f251bd9096207af604af69d6495c3c650a3338d0493d27b04bc55477d7a884ed"}, - {file = "ruamel.yaml-0.17.24.tar.gz", hash = "sha256:90e398ee24524ebe20fc48cd1861cedd25520457b9a36cfb548613e57fde30a0"}, + {file = "ruamel.yaml-0.17.32-py3-none-any.whl", hash = "sha256:23cd2ed620231677564646b0c6a89d138b6822a0d78656df7abda5879ec4f447"}, + {file = "ruamel.yaml-0.17.32.tar.gz", hash = "sha256:ec939063761914e14542972a5cba6d33c23b0859ab6342f61cf070cfc600efc2"}, ] "ruamel.yaml.clib" = [ {file = "ruamel.yaml.clib-0.2.7-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:d5859983f26d8cd7bb5c287ef452e8aacc86501487634573d260968f753e1d71"}, @@ -1715,32 +1705,32 @@ soupsieve = [ {file = "soupsieve-2.4.1.tar.gz", hash = "sha256:89d12b2d5dfcd2c9e8c22326da9d9aa9cb3dfab0a83a024f05704076ee8d35ea"}, ] sphinx = [ - {file = "Sphinx-4.3.2-py3-none-any.whl", hash = "sha256:6a11ea5dd0bdb197f9c2abc2e0ce73e01340464feaece525e64036546d24c851"}, - {file = "Sphinx-4.3.2.tar.gz", hash = "sha256:0a8836751a68306b3fe97ecbe44db786f8479c3bf4b80e3a7f5c838657b4698c"}, + {file = "sphinx-7.1.2-py3-none-any.whl", hash = "sha256:d170a81825b2fcacb6dfd5a0d7f578a053e45d3f2b153fecc948c37344eb4cbe"}, + {file = "sphinx-7.1.2.tar.gz", hash = "sha256:780f4d32f1d7d1126576e0e5ecc19dc32ab76cd24e950228dcf7b1f6d3d9e22f"}, ] sphinx-autobuild = [ {file = "sphinx-autobuild-2021.3.14.tar.gz", hash = "sha256:de1ca3b66e271d2b5b5140c35034c89e47f263f2cd5db302c9217065f7443f05"}, {file = "sphinx_autobuild-2021.3.14-py3-none-any.whl", hash = "sha256:8fe8cbfdb75db04475232f05187c776f46f6e9e04cacf1e49ce81bdac649ccac"}, ] sphinx-basic-ng = [ - {file = "sphinx_basic_ng-1.0.0b1-py3-none-any.whl", hash = "sha256:ade597a3029c7865b24ad0eda88318766bcc2f9f4cef60df7e28126fde94db2a"}, - {file = "sphinx_basic_ng-1.0.0b1.tar.gz", hash = "sha256:89374bd3ccd9452a301786781e28c8718e99960f2d4f411845ea75fc7bb5a9b0"}, + {file = "sphinx_basic_ng-1.0.0b2-py3-none-any.whl", hash = "sha256:eb09aedbabfb650607e9b4b68c9d240b90b1e1be221d6ad71d61c52e29f7932b"}, + {file = "sphinx_basic_ng-1.0.0b2.tar.gz", hash = "sha256:9ec55a47c90c8c002b5960c57492ec3021f5193cb26cebc2dc4ea226848651c9"}, ] sphinx-click = [ - {file = "sphinx-click-4.4.0.tar.gz", hash = "sha256:cc67692bd28f482c7f01531c61b64e9d2f069bfcf3d24cbbb51d4a84a749fa48"}, - {file = "sphinx_click-4.4.0-py3-none-any.whl", hash = "sha256:2821c10a68fc9ee6ce7c92fad26540d8d8c8f45e6d7258f0e4fb7529ae8fab49"}, + {file = "sphinx-click-5.0.1.tar.gz", hash = "sha256:fcc7df15e56e3ff17ebf446cdd316c2eb79580b37c49579fba11e5468802ef25"}, + {file = "sphinx_click-5.0.1-py3-none-any.whl", hash = "sha256:31836ca22f746d3c26cbfdfe0c58edf0bca5783731a0b2e25bb6d59800bb75a1"}, ] sphinxcontrib-applehelp = [ - {file = "sphinxcontrib-applehelp-1.0.2.tar.gz", hash = "sha256:a072735ec80e7675e3f432fcae8610ecf509c5f1869d17e2eecff44389cdbc58"}, - {file = "sphinxcontrib_applehelp-1.0.2-py2.py3-none-any.whl", hash = "sha256:806111e5e962be97c29ec4c1e7fe277bfd19e9652fb1a4392105b43e01af885a"}, + {file = "sphinxcontrib-applehelp-1.0.4.tar.gz", hash = "sha256:828f867945bbe39817c210a1abfd1bc4895c8b73fcaade56d45357a348a07d7e"}, + {file = "sphinxcontrib_applehelp-1.0.4-py3-none-any.whl", hash = "sha256:29d341f67fb0f6f586b23ad80e072c8e6ad0b48417db2bde114a4c9746feb228"}, ] sphinxcontrib-devhelp = [ {file = "sphinxcontrib-devhelp-1.0.2.tar.gz", hash = "sha256:ff7f1afa7b9642e7060379360a67e9c41e8f3121f2ce9164266f61b9f4b338e4"}, {file = "sphinxcontrib_devhelp-1.0.2-py2.py3-none-any.whl", hash = "sha256:8165223f9a335cc1af7ffe1ed31d2871f325254c0423bc0c4c7cd1c1e4734a2e"}, ] sphinxcontrib-htmlhelp = [ - {file = "sphinxcontrib-htmlhelp-2.0.0.tar.gz", hash = "sha256:f5f8bb2d0d629f398bf47d0d69c07bc13b65f75a81ad9e2f71a63d4b7a2f6db2"}, - {file = "sphinxcontrib_htmlhelp-2.0.0-py2.py3-none-any.whl", hash = "sha256:d412243dfb797ae3ec2b59eca0e52dac12e75a241bf0e4eb861e450d06c6ed07"}, + {file = "sphinxcontrib-htmlhelp-2.0.1.tar.gz", hash = "sha256:0cbdd302815330058422b98a113195c9249825d681e18f11e8b1f78a2f11efff"}, + {file = "sphinxcontrib_htmlhelp-2.0.1-py3-none-any.whl", hash = "sha256:c38cb46dccf316c79de6e5515e1770414b797162b23cd3d06e67020e1d2a6903"}, ] sphinxcontrib-jsmath = [ {file = "sphinxcontrib-jsmath-1.0.1.tar.gz", hash = "sha256:a9925e4a4587247ed2191a22df5f6970656cb8ca2bd6284309578f2153e0c4b8"}, @@ -1755,75 +1745,45 @@ sphinxcontrib-serializinghtml = [ {file = "sphinxcontrib_serializinghtml-1.1.5-py2.py3-none-any.whl", hash = "sha256:352a9a00ae864471d3a7ead8d7d79f5fc0b57e8b3f95e9867eb9eb28999b92fd"}, ] stevedore = [ - {file = "stevedore-3.5.2-py3-none-any.whl", hash = "sha256:fa2630e3d0ad3e22d4914aff2501445815b9a4467a6edc49387c667a38faf5bf"}, - {file = "stevedore-3.5.2.tar.gz", hash = "sha256:cf99f41fc0d5a4f185ca4d3d42b03be9011b0a1ec1a4ea1a282be1b4b306dcc2"}, + {file = "stevedore-5.1.0-py3-none-any.whl", hash = "sha256:8cc040628f3cea5d7128f2e76cf486b2251a4e543c7b938f58d9a377f6694a2d"}, + {file = "stevedore-5.1.0.tar.gz", hash = "sha256:a54534acf9b89bc7ed264807013b505bf07f74dbe4bcfa37d32bd063870b087c"}, ] tokenize-rt = [ - {file = "tokenize_rt-5.0.0-py2.py3-none-any.whl", hash = "sha256:c67772c662c6b3dc65edf66808577968fb10badfc2042e3027196bed4daf9e5a"}, - {file = "tokenize_rt-5.0.0.tar.gz", hash = "sha256:3160bc0c3e8491312d0485171dea861fc160a240f5f5766b72a1165408d10740"}, -] -toml = [ - {file = "toml-0.10.2-py2.py3-none-any.whl", hash = "sha256:806143ae5bfb6a3c6e736a764057db0e6a0e05e338b5630894a5f779cabb4f9b"}, - {file = "toml-0.10.2.tar.gz", hash = "sha256:b3bda1d108d5dd99f4a20d24d9c348e91c4db7ab1b749200bded2f839ccbe68f"}, + {file = "tokenize_rt-5.2.0-py2.py3-none-any.whl", hash = "sha256:b79d41a65cfec71285433511b50271b05da3584a1da144a0752e9c621a285289"}, + {file = "tokenize_rt-5.2.0.tar.gz", hash = "sha256:9fe80f8a5c1edad2d3ede0f37481cc0cc1538a2f442c9c2f9e4feacd2792d054"}, ] tomli = [ {file = "tomli-2.0.1-py3-none-any.whl", hash = "sha256:939de3e7a6161af0c887ef91b7d41a53e7c5a1ca976325f429cb46ea9bc30ecc"}, {file = "tomli-2.0.1.tar.gz", hash = "sha256:de526c12914f0c550d15924c62d72abc48d6fe7364aa87328337a31007fe8a4f"}, ] tornado = [ - {file = "tornado-6.2-cp37-abi3-macosx_10_9_universal2.whl", hash = "sha256:20f638fd8cc85f3cbae3c732326e96addff0a15e22d80f049e00121651e82e72"}, - {file = "tornado-6.2-cp37-abi3-macosx_10_9_x86_64.whl", hash = "sha256:87dcafae3e884462f90c90ecc200defe5e580a7fbbb4365eda7c7c1eb809ebc9"}, - {file = "tornado-6.2-cp37-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ba09ef14ca9893954244fd872798b4ccb2367c165946ce2dd7376aebdde8e3ac"}, - {file = "tornado-6.2-cp37-abi3-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b8150f721c101abdef99073bf66d3903e292d851bee51910839831caba341a75"}, - {file = "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"}, - {file = "tornado-6.2-cp37-abi3-musllinux_1_1_aarch64.whl", hash = "sha256:5f8c52d219d4995388119af7ccaa0bcec289535747620116a58d830e7c25d8a8"}, - {file = "tornado-6.2-cp37-abi3-musllinux_1_1_i686.whl", hash = "sha256:6fdfabffd8dfcb6cf887428849d30cf19a3ea34c2c248461e1f7d718ad30b66b"}, - {file = "tornado-6.2-cp37-abi3-musllinux_1_1_x86_64.whl", hash = "sha256:1d54d13ab8414ed44de07efecb97d4ef7c39f7438cf5e976ccd356bebb1b5fca"}, - {file = "tornado-6.2-cp37-abi3-win32.whl", hash = "sha256:5c87076709343557ef8032934ce5f637dbb552efa7b21d08e89ae7619ed0eb23"}, - {file = "tornado-6.2-cp37-abi3-win_amd64.whl", hash = "sha256:e5f923aa6a47e133d1cf87d60700889d7eae68988704e20c75fb2d65677a8e4b"}, - {file = "tornado-6.2.tar.gz", hash = "sha256:9b630419bde84ec666bfd7ea0a4cb2a8a651c2d5cccdbdd1972a0c859dfc3c13"}, -] -typed-ast = [ - {file = "typed_ast-1.5.4-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:669dd0c4167f6f2cd9f57041e03c3c2ebf9063d0757dc89f79ba1daa2bfca9d4"}, - {file = "typed_ast-1.5.4-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:211260621ab1cd7324e0798d6be953d00b74e0428382991adfddb352252f1d62"}, - {file = "typed_ast-1.5.4-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:267e3f78697a6c00c689c03db4876dd1efdfea2f251a5ad6555e82a26847b4ac"}, - {file = "typed_ast-1.5.4-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:c542eeda69212fa10a7ada75e668876fdec5f856cd3d06829e6aa64ad17c8dfe"}, - {file = "typed_ast-1.5.4-cp310-cp310-win_amd64.whl", hash = "sha256:a9916d2bb8865f973824fb47436fa45e1ebf2efd920f2b9f99342cb7fab93f72"}, - {file = "typed_ast-1.5.4-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:79b1e0869db7c830ba6a981d58711c88b6677506e648496b1f64ac7d15633aec"}, - {file = "typed_ast-1.5.4-cp36-cp36m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a94d55d142c9265f4ea46fab70977a1944ecae359ae867397757d836ea5a3f47"}, - {file = "typed_ast-1.5.4-cp36-cp36m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:183afdf0ec5b1b211724dfef3d2cad2d767cbefac291f24d69b00546c1837fb6"}, - {file = "typed_ast-1.5.4-cp36-cp36m-win_amd64.whl", hash = "sha256:639c5f0b21776605dd6c9dbe592d5228f021404dafd377e2b7ac046b0349b1a1"}, - {file = "typed_ast-1.5.4-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:cf4afcfac006ece570e32d6fa90ab74a17245b83dfd6655a6f68568098345ff6"}, - {file = "typed_ast-1.5.4-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ed855bbe3eb3715fca349c80174cfcfd699c2f9de574d40527b8429acae23a66"}, - {file = "typed_ast-1.5.4-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:6778e1b2f81dfc7bc58e4b259363b83d2e509a65198e85d5700dfae4c6c8ff1c"}, - {file = "typed_ast-1.5.4-cp37-cp37m-win_amd64.whl", hash = "sha256:0261195c2062caf107831e92a76764c81227dae162c4f75192c0d489faf751a2"}, - {file = "typed_ast-1.5.4-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:2efae9db7a8c05ad5547d522e7dbe62c83d838d3906a3716d1478b6c1d61388d"}, - {file = "typed_ast-1.5.4-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:7d5d014b7daa8b0bf2eaef684295acae12b036d79f54178b92a2b6a56f92278f"}, - {file = "typed_ast-1.5.4-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:370788a63915e82fd6f212865a596a0fefcbb7d408bbbb13dea723d971ed8bdc"}, - {file = "typed_ast-1.5.4-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:4e964b4ff86550a7a7d56345c7864b18f403f5bd7380edf44a3c1fb4ee7ac6c6"}, - {file = "typed_ast-1.5.4-cp38-cp38-win_amd64.whl", hash = "sha256:683407d92dc953c8a7347119596f0b0e6c55eb98ebebd9b23437501b28dcbb8e"}, - {file = "typed_ast-1.5.4-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:4879da6c9b73443f97e731b617184a596ac1235fe91f98d279a7af36c796da35"}, - {file = "typed_ast-1.5.4-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:3e123d878ba170397916557d31c8f589951e353cc95fb7f24f6bb69adc1a8a97"}, - {file = "typed_ast-1.5.4-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ebd9d7f80ccf7a82ac5f88c521115cc55d84e35bf8b446fcd7836eb6b98929a3"}, - {file = "typed_ast-1.5.4-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:98f80dee3c03455e92796b58b98ff6ca0b2a6f652120c263efdba4d6c5e58f72"}, - {file = "typed_ast-1.5.4-cp39-cp39-win_amd64.whl", hash = "sha256:0fdbcf2fef0ca421a3f5912555804296f0b0960f0418c440f5d6d3abb549f3e1"}, - {file = "typed_ast-1.5.4.tar.gz", hash = "sha256:39e21ceb7388e4bb37f4c679d72707ed46c2fbf2a5609b8b8ebc4b067d977df2"}, + {file = "tornado-6.3.3-cp38-abi3-macosx_10_9_universal2.whl", hash = "sha256:502fba735c84450974fec147340016ad928d29f1e91f49be168c0a4c18181e1d"}, + {file = "tornado-6.3.3-cp38-abi3-macosx_10_9_x86_64.whl", hash = "sha256:805d507b1f588320c26f7f097108eb4023bbaa984d63176d1652e184ba24270a"}, + {file = "tornado-6.3.3-cp38-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1bd19ca6c16882e4d37368e0152f99c099bad93e0950ce55e71daed74045908f"}, + {file = "tornado-6.3.3-cp38-abi3-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7ac51f42808cca9b3613f51ffe2a965c8525cb1b00b7b2d56828b8045354f76a"}, + {file = "tornado-6.3.3-cp38-abi3-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:71a8db65160a3c55d61839b7302a9a400074c9c753040455494e2af74e2501f2"}, + {file = "tornado-6.3.3-cp38-abi3-musllinux_1_1_aarch64.whl", hash = "sha256:ceb917a50cd35882b57600709dd5421a418c29ddc852da8bcdab1f0db33406b0"}, + {file = "tornado-6.3.3-cp38-abi3-musllinux_1_1_i686.whl", hash = "sha256:7d01abc57ea0dbb51ddfed477dfe22719d376119844e33c661d873bf9c0e4a16"}, + {file = "tornado-6.3.3-cp38-abi3-musllinux_1_1_x86_64.whl", hash = "sha256:9dc4444c0defcd3929d5c1eb5706cbe1b116e762ff3e0deca8b715d14bf6ec17"}, + {file = "tornado-6.3.3-cp38-abi3-win32.whl", hash = "sha256:65ceca9500383fbdf33a98c0087cb975b2ef3bfb874cb35b8de8740cf7f41bd3"}, + {file = "tornado-6.3.3-cp38-abi3-win_amd64.whl", hash = "sha256:22d3c2fa10b5793da13c807e6fc38ff49a4f6e1e3868b0a6f4164768bb8e20f5"}, + {file = "tornado-6.3.3.tar.gz", hash = "sha256:e7d8db41c0181c80d76c982aacc442c0783a2c54d6400fe028954201a2e032fe"}, ] typeguard = [ - {file = "typeguard-2.13.3-py3-none-any.whl", hash = "sha256:5e3e3be01e887e7eafae5af63d1f36c849aaa94e3a0112097312aabfa16284f1"}, - {file = "typeguard-2.13.3.tar.gz", hash = "sha256:00edaa8da3a133674796cf5ea87d9f4b4c367d77476e185e80251cc13dfbb8c4"}, + {file = "typeguard-4.1.3-py3-none-any.whl", hash = "sha256:5b7453b1e3b35fcfe2d62fa4ec500d05e6f2f2eb46f4126ae964677fcc384fff"}, + {file = "typeguard-4.1.3.tar.gz", hash = "sha256:7d4264cd631ac1157c5bb5ec992281b4f1e2ba7a35db91bc15f442235e244803"}, ] typing-extensions = [ - {file = "typing_extensions-4.5.0-py3-none-any.whl", hash = "sha256:fb33085c39dd998ac16d1431ebc293a8b3eedd00fd4a32de0ff79002c19511b4"}, - {file = "typing_extensions-4.5.0.tar.gz", hash = "sha256:5cb5f4a79139d699607b3ef622a1dedafa84e115ab0024e0d9c044a9479ca7cb"}, + {file = "typing_extensions-4.7.1-py3-none-any.whl", hash = "sha256:440d5dd3af93b060174bf433bccd69b0babc3b15b1a8dca43789fd7f61514b36"}, + {file = "typing_extensions-4.7.1.tar.gz", hash = "sha256:b75ddc264f0ba5615db7ba217daeb99701ad295353c45f9e95963337ceeeffb2"}, ] urllib3 = [ - {file = "urllib3-2.0.2-py3-none-any.whl", hash = "sha256:d055c2f9d38dc53c808f6fdc8eab7360b6fdbbde02340ed25cfbcd817c62469e"}, - {file = "urllib3-2.0.2.tar.gz", hash = "sha256:61717a1095d7e155cdb737ac7bb2f4324a858a1e2e6466f6d03ff630ca68d3cc"}, + {file = "urllib3-2.0.4-py3-none-any.whl", hash = "sha256:de7df1803967d2c2a98e4b11bb7d6bd9210474c46e8a0401514e3a42a75ebde4"}, + {file = "urllib3-2.0.4.tar.gz", hash = "sha256:8d22f86aae8ef5e410d4f539fde9ce6b2113a001bb4d189e0aed70642d602b11"}, ] virtualenv = [ - {file = "virtualenv-20.16.2-py2.py3-none-any.whl", hash = "sha256:635b272a8e2f77cb051946f46c60a54ace3cb5e25568228bd6b57fc70eca9ff3"}, - {file = "virtualenv-20.16.2.tar.gz", hash = "sha256:0ef5be6d07181946891f5abc8047fda8bc2f0b4b9bf222c64e6e8963baee76db"}, + {file = "virtualenv-20.24.4-py3-none-any.whl", hash = "sha256:29c70bb9b88510f6414ac3e55c8b413a1f96239b6b789ca123437d5e892190cb"}, + {file = "virtualenv-20.24.4.tar.gz", hash = "sha256:772b05bfda7ed3b8ecd16021ca9716273ad9f4467c801f27e83ac73430246dca"}, ] win32-setctime = [ {file = "win32_setctime-1.1.0-py3-none-any.whl", hash = "sha256:231db239e959c2fe7eb1d7dc129f11172354f98361c4fa2d6d2d7e278baa8aad"}, @@ -1834,6 +1794,6 @@ xdoctest = [ {file = "xdoctest-1.1.1.tar.gz", hash = "sha256:2eac8131bdcdf2781b4e5a62d6de87f044b730cc8db8af142a51bb29c245e779"}, ] zipp = [ - {file = "zipp-3.15.0-py3-none-any.whl", hash = "sha256:48904fc76a60e542af151aded95726c1a5c34ed43ab4134b597665c86d7ad556"}, - {file = "zipp-3.15.0.tar.gz", hash = "sha256:112929ad649da941c23de50f356a2b5570c954b65150642bccdd66bf194d224b"}, + {file = "zipp-3.16.2-py3-none-any.whl", hash = "sha256:679e51dd4403591b2d6838a48de3d283f3d188412a9782faadf845f298736ba0"}, + {file = "zipp-3.16.2.tar.gz", hash = "sha256:ebc15946aa78bd63458992fc81ec3b6f7b1e92d51c35e6de1c3804e73b799147"}, ] diff --git a/pyproject.toml b/pyproject.toml index 871a4ae..67ac6d1 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -26,9 +26,11 @@ classifiers = [ Changelog = "https://github.com/56kyle/pytest-static/releases" [tool.poetry.dependencies] -python = "^3.7" +python = ">=3.8,<4.0" click = ">=8.0.1" loguru = "^0.7.0" +tornado = ">=6.3.2" + [tool.poetry.dev-dependencies] Pygments = ">=2.10.0" From d162a4bfa05c233d1669d6229ffee8b7d49a6416 Mon Sep 17 00:00:00 2001 From: Kyle Oliver Date: Thu, 31 Aug 2023 21:35:27 -0400 Subject: [PATCH 16/17] Changes github actions to stop checking 3.7 since it reached EOL --- .github/workflows/tests.yml | 2 -- 1 file changed, 2 deletions(-) diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml index be15e5e..3a4e878 100644 --- a/.github/workflows/tests.yml +++ b/.github/workflows/tests.yml @@ -17,11 +17,9 @@ jobs: - { python: "3.10", os: "ubuntu-latest", session: "mypy" } - { python: "3.9", os: "ubuntu-latest", session: "mypy" } - { python: "3.8", os: "ubuntu-latest", session: "mypy" } - - { python: "3.7", os: "ubuntu-latest", session: "mypy" } - { python: "3.10", os: "ubuntu-latest", session: "tests" } - { python: "3.9", os: "ubuntu-latest", session: "tests" } - { python: "3.8", os: "ubuntu-latest", session: "tests" } - - { python: "3.7", os: "ubuntu-latest", session: "tests" } - { python: "3.10", os: "windows-latest", session: "tests" } - { python: "3.10", os: "macos-latest", session: "tests" } - { python: "3.10", os: "ubuntu-latest", session: "typeguard" } From a87d3d32f7029b4271a28bfd63f9a4e404b1006c Mon Sep 17 00:00:00 2001 From: Kyle Oliver Date: Fri, 1 Sep 2023 00:05:47 -0400 Subject: [PATCH 17/17] Changes pyproject.toml to match our actual allowed versions --- pyproject.toml | 1 - 1 file changed, 1 deletion(-) diff --git a/pyproject.toml b/pyproject.toml index 67ac6d1..2d781fa 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -11,7 +11,6 @@ documentation = "https://pytest-static.readthedocs.io" classifiers = [ "Development Status :: 1 - Planning", "Programming Language :: Python :: 3", - "Programming Language :: Python :: 3.7", "Programming Language :: Python :: 3.8", "Programming Language :: Python :: 3.9", "Programming Language :: Python :: 3.10",